Files
Live_RC/src/app.js
T

7549 lines
472 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { getSyncStatus } from "./sync_status.js";
import { installListSorting } from "./list_sorting.js";
import { escapeHtml } from "./html_escape.js";
import { getOverlayModeLabel, buildOverlayPanels, renderOverlaySidePanel, renderOverlayLeaderboard, renderTeamOverlay, renderObsOverlay } from "./overlays.js";
import { renderSettings, openSettingsTab } from "./settings.js";
import { buildRaceDayQueue, buildRaceDayPreflight, getRaceDriverIds } from "./race_day_logic.js";
import { recordTransponderSighting, buildWarmupCheck, createPrologue, getPrologueRemainingMs, holdPrologue, resumePrologue, setPrologueRemaining, takeDuePrologueCall, formatPrologueTime, getPrologueHandoverMs, normalizePrologueSec } from "./prologue_logic.js";
import { findTransponderConflict, getDriverProfileId } from "./driver_profile_logic.js";
import { renderRaceDayView, refreshRaceDayWarmup, refreshRaceDayPrologueClock, updateRaceDayStartDisplay, refreshRaceDayLive } from "./race_day_view.js";
import { normalizeRaceDays, getRaceDay, upsertRaceDay, orderDaySessions, buildDaySchedule, getAutopilotAction, moveInDayOrder, pickBoardDate, getDueCall } from "./day_schedule_logic.js";
import { renderDaySchedulePanel, bindDaySchedulePanel, buildDaySchedulePrintHtml, renderDriverBoard, formatClockTime, renderDayCallBanner, bindDayCallBanner } from "./day_schedule_view.js";
import { beginSession as beginSessionControl, finishSession as finishSessionControl, pauseSession as pauseSessionControl, resumeSession as resumeSessionControl } from "./session_control.js";
import { normalizeSeries, buildSeriesStandings, getSeriesRoundStatus, getSeriesRoundNextStep, getSeriesDayResult } from "./series_logic.js";
import { renderSeriesView } from "./series_view.js";
import { RACE_AUDIO_EVENT_DEFINITIONS, createRaceAudioEngine, normalizeRaceAudioSettings, isSilencedDuringRace } from "./race_audio.js";
import { renderRaceFormatField, renderRaceFormatContextCard, getRaceSummaryItems, getRaceSummaryWarnings, renderManageStatusBadge, renderRaceWizardSteps, renderRaceWizardContent, renderRaceStandingsTable } from "./race_setup_ui.js";
import { normalizeRaceTeam as normalizeRaceTeamLogic, normalizeStoredRacePreset as normalizeStoredRacePresetLogic, getRaceFormatPresets as getRaceFormatPresetsLogic, applyRaceFormatPreset as applyRaceFormatPresetLogic, buildRaceFormatConfigFromForm as buildRaceFormatConfigFromFormLogic, normalizeEvent as normalizeEventLogic, normalizeBrandingConfig as normalizeBrandingConfigLogic, resolveEventBranding as resolveEventBrandingLogic, getRaceManageStatuses as getRaceManageStatusesLogic, buildDefaultRaceWizardDraft as buildDefaultRaceWizardDraftLogic, getRaceWizardPreset as getRaceWizardPresetLogic, applyRaceWizardPresetDefaults as applyRaceWizardPresetDefaultsLogic, ensureRaceParticipantsConfigured as ensureRaceParticipantsConfiguredLogic, buildRaceSession as buildRaceSessionLogic, buildOpenPracticeBundle as buildOpenPracticeBundleLogic, buildTrackSession as buildTrackSessionLogic, createSponsorRounds as createSponsorRoundsLogic, buildRaceSessionsFromWizard as buildRaceSessionsFromWizardLogic, getRaceWizardSessionPlan as getRaceWizardSessionPlanLogic, getEventDrivers as getEventDriversLogic, getEventTeams as getEventTeamsLogic, getTeamDriverPool as getTeamDriverPoolLogic, reassignTeamMembers as reassignTeamMembersLogic, findEventTeamForPassing as findEventTeamForPassingLogic, generateQualifyingForRace as generateQualifyingForRaceLogic, reseedUpcomingQualifying as reseedUpcomingQualifyingLogic, moveDriversIntoQualifyingHeat as moveDriversIntoQualifyingHeatLogic, parseQualifyingHeatName as parseQualifyingHeatNameLogic, generateFinalsForRace as generateFinalsForRaceLogic, applyBumpsForRace as applyBumpsForRaceLogic, buildEventSchedule as buildEventScheduleLogic, normalizeHeatOrder, planSeedingGroups } from "./event_race_logic.js";
import { getSessionTypeLabel as getSessionTypeLabelLogic, getStatusLabel as getStatusLabelLogic, isUntimedSession as isUntimedSessionLogic, getActiveSession as getActiveSessionLogic, getLiveSession as getLiveSessionLogic, getSessionTargetMs as getSessionTargetMsLogic, getSessionLapWindow as getSessionLapWindowLogic, isCountedPassing as isCountedPassingLogic, getVisiblePassings as getVisiblePassingsLogic, getPassingValidationLabel as getPassingValidationLabelLogic, getSessionTiming as getSessionTimingLogic, ensureSessionResult as ensureSessionResultLogic, buildLeaderboard as buildLeaderboardLogic, formatLapDelta as formatLapDeltaLogic, formatLeaderboardGap as formatLeaderboardGapLogic, getCompetitorElapsedMs as getCompetitorElapsedMsLogic, getCompetitorPassings as getCompetitorPassingsLogic, getCompetitorSeedMetric as getCompetitorSeedMetricLogic, getSessionEntrants as getSessionEntrantsLogic, buildPracticeStandings as buildPracticeStandingsLogic, getQualifyingPointsValue as getQualifyingPointsValueLogic, isHighPointsTable as isHighPointsTableLogic, compareNumberSet as compareNumberSetLogic, buildQualifyingTieBreakNote as buildQualifyingTieBreakNoteLogic, hasQualifyingPrimaryTie as hasQualifyingPrimaryTieLogic, buildQualifyingStandings as buildQualifyingStandingsLogic, formatTeamActiveMemberLabel as formatTeamActiveMemberLabelLogic, buildTeamRaceStandings as buildTeamRaceStandingsLogic, buildSessionChannelStats as buildSessionChannelStatsLogic, buildTeamStintLog as buildTeamStintLogLogic, getSessionGridEntries as getSessionGridEntriesLogic, getSessionGridOrder as getSessionGridOrderLogic, ensureSessionDriverOrder as ensureSessionDriverOrderLogic, buildFinalStandings as buildFinalStandingsLogic, getTrackRecordMs as getTrackRecordMsLogic } from "./timing_logic.js";
import { normalizeTrackLayouts, getTrackLayoutIdAt, getTrackLayoutLabel, nextTrackLayoutLabel, findRaceSessionBlockingLayoutChange, isPracticeSessionType, isTrackLayoutInUse } from "./track_layouts_logic.js";
import { renderDashboardView, renderClassesView, renderDriversView, renderCarsView } from "./core_views.js";
import { renderGuideView, renderOverlayPageView } from "./misc_views.js";
import { installAuthFetchGuard, showPinDialog, mountAuthSettings } from "./auth_view.js";
import { getSessionsForEventHelper, getModeLabelHelper, normalizeStartModeHelper, getStartModeLabelHelper, getClassNameHelper, getEventNameHelper, renderAssignmentListView, renderSessionsTableView } from "./event_common.js";
import { renderEventWorkspaceView } from "./event_workspace_controller.js";
import { renderEventManagerMarkup } from "./event_manager_view.js";
import { renderEventManagerView } from "./event_manager_controller.js";
import { createDefaultAmmcConfigHelper, getManagedWsUrlHelper, loadAmmcConfigFromBackendHelper, saveAmmcConfigToBackendHelper, refreshAmmcStatusHelper, startManagedAmmcHelper, stopManagedAmmcHelper, applyPersistedStateHelper, hydrateFromBackendHelper, scheduleBackendSyncHelper, syncStateToBackendHelper, pingBackendHelper, checkAppVersionHelper, startAppVersionPollingHelper, startOverlaySyncHelper, startBackgroundHydrationHelper, startOverlayRotationHelper, startOverlayLiveRefreshHelper, ensureAudioContextHelper, playPassingBeepHelper, playFinishSirenHelper, playLeaderCueHelper, playStartCueHelper, playBestLapCueHelper, pushOverlayEventHelper, getSpeechVoicesHelper, speakTextHelper, announceRaceStartedHelper, announceRaceFinishedHelper, handleSessionTimerTickHelper, tickClockHelper } from "./runtime_services.js";
import { connectDecoderHelper, disconnectDecoderHelper, processDecoderMessageHelper } from "./decoder_runtime.js";
import { listPendingSuspectLaps, releaseSettledSuspectLaps } from "./suspect_laps_logic.js";
import { writeLocalCache } from "./local_cache.js";
import { normalizeTrainingState as normalizeTrainingStateLogic, syncTrainingLedger as syncTrainingLedgerLogic, buildDriverTrainingStats as buildDriverTrainingStatsLogic, buildDriverTimingChannelStats as buildDriverTimingChannelStatsLogic, buildDriverActivePracticeStats as buildDriverActivePracticeStatsLogic, buildEvenLapsProgress as buildEvenLapsProgressLogic, buildStepTrainingProgress as buildStepTrainingProgressLogic, buildTrainingRecommendation as buildTrainingRecommendationLogic, getTrainingGoalProgress as getTrainingGoalProgressLogic, getNextTrainingMilestone as getNextTrainingMilestoneLogic, buildTrainingMissions as buildTrainingMissionsLogic, buildTrainingHighlights as buildTrainingHighlightsLogic, getClubTrainingGoalProgress as getClubTrainingGoalProgressLogic, countDriverExerciseSessions as countDriverExerciseSessionsLogic, countExerciseSessions as countExerciseSessionsLogic, buildTrainingPaceBuckets as buildTrainingPaceBucketsLogic, buildTrainingWeekdayStats as buildTrainingWeekdayStatsLogic, buildTrainingStintAnalysis as buildTrainingStintAnalysisLogic, buildTrainingMarkerComparisons as buildTrainingMarkerComparisonsLogic } from "./training_logic.js";
import { renderTrainingView } from "./training_views.js";
import { renderResultsArchiveView } from "./results_archive_view.js";
import { importDriversCsv, importCarsCsv } from "./csv_import.js";
import { renderTimingView, renderJudgingView, renderSuspectLapsPanel as renderSuspectLapsPanelView } from "./timing_views.js";
import { createSessionReplayRuntime } from "./session_replay.js";
import { renderTeamStintLog as renderTeamStintLogHelper, renderSessionChannelAnalysis as renderSessionChannelAnalysisHelper, renderTeamRaceStandings as renderTeamRaceStandingsHelper, getSessionSortWeight as getSessionSortWeightHelper, getDriverDisplayById as getDriverDisplayByIdHelper, renderPositionGrid as renderPositionGridHelper, renderGridEditor as renderGridEditorHelper, getFinalMainLayouts as getFinalMainLayoutsHelper, renderFinalMatrix as renderFinalMatrixHelper, buildPrintBrandBlock as buildPrintBrandBlockHelper, buildRaceStartListsHtml as buildRaceStartListsHtmlHelper, buildRaceResultsHtml as buildRaceResultsHtmlHelper, buildTeamRaceResultsHtml as buildTeamRaceResultsHtmlHelper } from "./race_render_helpers.js";
import { setCompetitorLapStatus as setCompetitorLapStatusLogic, getManualCorrectionSummary as getManualCorrectionSummaryLogic, applyCompetitorCorrection as applyCompetitorCorrectionLogic, recalculateCompetitorFromPassings as recalculateCompetitorFromPassingsLogic, invalidateCompetitorLastLap as invalidateCompetitorLastLapLogic, restoreCompetitorLastInvalidLap as restoreCompetitorLastInvalidLapLogic, findPassingByUndoMarker as findPassingByUndoMarkerLogic, undoJudgingAdjustment as undoJudgingAdjustmentLogic, getJudgeFilteredRows as getJudgeFilteredRowsLogic, getJudgeFilteredLog as getJudgeFilteredLogLogic } from "./judging_logic.js";
const PRODUCT_NAME = "RC RaceCore";
const renderRaceFormatFieldView = (labelKey, hintKey, controlHtml, options = {}) => renderRaceFormatField(labelKey, hintKey, controlHtml, options, { t });
const renderRaceFormatContextCardView = (titleKey, hintKey) => renderRaceFormatContextCard(titleKey, hintKey, { t });
const renderManageStatusBadgeView = (status) => renderManageStatusBadge(status, { t });
const renderRaceWizardStepsView = () => renderRaceWizardSteps({ t, raceWizardStep, escapeHtml });
const renderRaceWizardContentView = (draft, classOptions, wizardDrivers, preset) =>
renderRaceWizardContent(draft, classOptions, wizardDrivers, preset, { t, escapeHtml, raceWizardStep, getRaceFormatPresets, getClassName, getRaceWizardSessionPlan });
const renderRaceStandingsTableView = (rows, emptyLabel) => renderRaceStandingsTable(rows, emptyLabel, { t, renderTable, escapeHtml });
const normalizeRaceTeam = (team) => normalizeRaceTeamLogic(team, { uid });
const normalizeStoredRacePreset = (preset) => normalizeStoredRacePresetLogic(preset, { uid });
const getRaceFormatPresets = () => getRaceFormatPresetsLogic({ state, t, uid, normalizeStoredRacePreset });
const applyRaceFormatPreset = (event, presetId) => applyRaceFormatPresetLogic(event, presetId, { getRaceFormatPresets });
const buildRaceFormatConfigFromForm = (form, event) => buildRaceFormatConfigFromFormLogic(form, event, { normalizeStartMode, getEventTeams });
const normalizeBrandingConfig = (branding) => normalizeBrandingConfigLogic(branding);
const normalizeEvent = (event) => normalizeEventLogic(event, { normalizeBrandingConfig, normalizeStartMode, normalizeRaceTeam });
const resolveEventBranding = (event) => resolveEventBrandingLogic(event, { normalizeBrandingConfig, state });
const getRaceManageStatuses = (event, sessions, raceDrivers, raceTeams, selectedPreset) =>
getRaceManageStatusesLogic(event, sessions, raceDrivers, raceTeams, selectedPreset, { t, buildPracticeStandings, buildQualifyingStandings, buildFinalStandings });
const buildDefaultRaceWizardDraft = () => buildDefaultRaceWizardDraftLogic({ state, getDriversForClass });
const getRaceWizardPreset = (presetId) => getRaceWizardPresetLogic(presetId, { getRaceFormatPresets });
const applyRaceWizardPresetDefaults = (draft, presetId) => applyRaceWizardPresetDefaultsLogic(draft, presetId, { getRaceWizardPreset });
const ensureRaceParticipantsConfigured = (event) => ensureRaceParticipantsConfiguredLogic(event, { state });
const buildRaceSession = (eventId, name, type, durationMin, overrides = {}) => buildRaceSessionLogic(eventId, name, type, durationMin, overrides, { normalizeSession, uid });
const buildOpenPracticeBundle = (input) => buildOpenPracticeBundleLogic(input, { normalizeEvent, buildRaceSession, uid });
const buildTrackSession = (eventId, name, type, durationMin) => buildTrackSessionLogic(eventId, name, type, durationMin, { normalizeSession, uid });
const createSponsorRounds = (eventId, config) => createSponsorRoundsLogic(eventId, config, { state, t, buildTrackSession });
const buildRaceSessionsFromWizard = (event, draft) => buildRaceSessionsFromWizardLogic(event, draft, { t, buildRaceSession });
const getRaceWizardSessionPlan = (draft) => getRaceWizardSessionPlanLogic(draft, { t });
const getEventDrivers = (event) => getEventDriversLogic(event, { state });
const getEventTeams = (event) => getEventTeamsLogic(event, { normalizeRaceTeam });
const getTeamDriverPool = (event) => getTeamDriverPoolLogic(event, { getEventDrivers, state });
const reassignTeamMembers = (teams, options) => reassignTeamMembersLogic(teams, options);
const moveDriversIntoQualifyingHeat = (targetSessionId, driverIds) => moveDriversIntoQualifyingHeatLogic(state.sessions, targetSessionId, driverIds);
const parseQualifyingHeatName = (name) => parseQualifyingHeatNameLogic(name);
const findEventTeamForPassing = (event, driverId, carId) => findEventTeamForPassingLogic(event, driverId, carId, { getEventTeams });
const generateQualifyingForRace = (event) => generateQualifyingForRaceLogic(event, { buildPracticeStandings, getEventDrivers, state, normalizeStartMode, normalizeSession, uid, chunkArray, clearGeneratedQualifying });
const reseedUpcomingQualifying = (event) => reseedUpcomingQualifyingLogic(event, { buildQualifyingStandings, buildPracticeStandings, getEventDrivers, getSessionsForEvent, chunkArray });
const generateFinalsForRace = (event) => generateFinalsForRaceLogic(event, { buildPracticeStandings, buildQualifyingStandings, clearGeneratedFinals, state, normalizeStartMode, normalizeSession, uid, chunkArray, t });
const applyBumpsForRace = (event) => applyBumpsForRaceLogic(event, { buildFinalStandings, getSessionsForEvent });
const getSessionTypeLabel = (type) => getSessionTypeLabelLogic(type, { t });
const getStatusLabel = (status) => getStatusLabelLogic(status, { t });
const isUntimedSession = (session) => isUntimedSessionLogic(session);
const getActiveSession = () => getActiveSessionLogic({ state });
const getLiveSession = () => getLiveSessionLogic({ state });
const normalizeSeriesList = (list) => (Array.isArray(list) ? list : []).map((series) => normalizeSeries(series, { uid })).filter((series) => series.id);
const getSessionTargetMs = (session) => getSessionTargetMsLogic(session, { isUntimedSession });
const getSessionLapWindow = (session) => getSessionLapWindowLogic(session, { state });
const isCountedPassing = (passing) => isCountedPassingLogic(passing);
const getVisiblePassings = (result) => getVisiblePassingsLogic(result, { isCountedPassing });
const getPassingValidationLabel = (passing) => getPassingValidationLabelLogic(passing, { t });
const getSessionTiming = (session, nowTs = Date.now()) => getSessionTimingLogic(session, nowTs, { getSessionTargetMs });
const ensureSessionResult = (sessionId) => ensureSessionResultLogic(sessionId, { state });
const buildSessionChannelStats = (session) => buildSessionChannelStatsLogic(session, { ensureSessionResult });
const renderSessionChannelAnalysis = (session) => renderSessionChannelAnalysisHelper(session, { t, escapeHtml, renderTable, formatLap, formatRaceClock, buildSessionChannelStats });
const formatLapDelta = (deltaMs) => formatLapDeltaLogic(deltaMs, { formatLap });
const formatLeaderboardGap = (row, referenceRow, options = {}) => formatLeaderboardGapLogic(row, referenceRow, options, { t });
const getCompetitorElapsedMs = (session, row) => getCompetitorElapsedMsLogic(session, row);
const getCompetitorPassings = (session, row, options = {}) => getCompetitorPassingsLogic(session, row, options, { ensureSessionResult, isCountedPassing });
const getCompetitorSeedMetric = (session, row) => getCompetitorSeedMetricLogic(session, row, { getCompetitorPassings });
const getSessionEntrants = (session) => getSessionEntrantsLogic(session, { state, getEventDrivers });
const buildLeaderboard = (session) => buildLeaderboardLogic(session, { ensureSessionResult, getSessionTargetMs, getCompetitorPassings, isCountedPassing, getCompetitorElapsedMs, getCompetitorSeedMetric, getSessionLapWindow, getPassingValidationLabel, formatSeedMetric, formatRaceClock, formatLeaderboardGap, formatLapDelta, formatLap, t });
const buildPracticeStandings = (event) => buildPracticeStandingsLogic(event, { getSessionsForEvent, buildLeaderboard, getCompetitorSeedMetric, formatSeedMetric, formatRaceClock });
const getQualifyingPointsValue = (place, fieldSize, tableType) => getQualifyingPointsValueLogic(place, fieldSize, tableType);
const isHighPointsTable = (tableType) => isHighPointsTableLogic(tableType);
const compareNumberSet = (left, right, highWins = false) => compareNumberSetLogic(left, right, highWins);
const buildQualifyingTieBreakNote = (row, tieBreak) => buildQualifyingTieBreakNoteLogic(row, tieBreak, { t, formatLap });
const hasQualifyingPrimaryTie = (left, right, scoringMode) => hasQualifyingPrimaryTieLogic(left, right, scoringMode);
const buildQualifyingStandings = (event) => buildQualifyingStandingsLogic(event, { getSessionsForEvent, buildLeaderboard, getSessionEntrants, isHighPointsTable, getQualifyingPointsValue, compareNumberSet, buildQualifyingTieBreakNote, formatLap, formatRaceClock, t, hasQualifyingPrimaryTie });
const formatTeamActiveMemberLabel = (rowOrPassing) => formatTeamActiveMemberLabelLogic(rowOrPassing);
const buildTeamRaceStandings = (event) => buildTeamRaceStandingsLogic(event, { getSessionsForEvent, buildLeaderboard, getSessionSortWeight });
const buildTeamStintLog = (session, row) => buildTeamStintLogLogic(session, row, { getCompetitorPassings, getSessionLapWindow, formatTeamActiveMemberLabel });
const getSessionGridEntries = (session) => getSessionGridEntriesLogic(session, { state, t, getEventTeams, getDriverDisplayById, getSessionGridOrder });
const getSessionGridOrder = (session) => getSessionGridOrderLogic(session);
const ensureSessionDriverOrder = (session) => ensureSessionDriverOrderLogic(session, { getSessionEntrants });
const buildFinalStandings = (event) => buildFinalStandingsLogic(event, { getSessionsForEvent, buildLeaderboard, getSessionEntrants, t });
const getManualCorrectionSummary = (row) => getManualCorrectionSummaryLogic(row, { formatLap });
const renderTeamStintLog = (session, rows) => renderTeamStintLogHelper(session, rows, { t, escapeHtml, buildTeamStintLog, formatTeamActiveMemberLabel, renderTable, formatRaceClock });
const renderTeamRaceStandings = (event) => renderTeamRaceStandingsHelper(event, { t, escapeHtml, buildTeamRaceStandings, getSessionTypeLabel, renderTable, formatTeamActiveMemberLabel, formatLap, formatRaceClock, renderTeamStintLog, buildSessionChannelStats });
const getSessionSortWeight = (session) => getSessionSortWeightHelper(session);
const buildEventSchedule = (event) => buildEventScheduleLogic(event, getSessionsForEvent(event.id));
const getDriverDisplayById = (driverId) => getDriverDisplayByIdHelper(driverId, { state, t });
const renderPositionGrid = (session) => renderPositionGridHelper(session, { t, escapeHtml, getSessionGridEntries });
const renderGridEditor = (session) => renderGridEditorHelper(session, { t, escapeHtml, ensureSessionDriverOrder, state });
const getFinalMainLayouts = (event) => getFinalMainLayoutsHelper(event, { getSessionsForEvent, getSessionGridOrder, getDriverDisplayById, t });
const renderFinalMatrix = (event) => renderFinalMatrixHelper(event, { t, escapeHtml, getFinalMainLayouts, getStatusLabel });
const buildPrintBrandBlock = (branding) => buildPrintBrandBlockHelper(branding, { escapeHtml });
const buildRaceStartListsHtml = (event) => buildRaceStartListsHtmlHelper(event, { t, state, escapeHtml, resolveEventBranding, getSessionsForEvent, getSessionSortWeight, getClassName, buildPrintBrandBlock, getSessionGridEntries, getSessionTypeLabel, getStartModeLabel, renderTable, buildEventSchedule });
const buildRaceResultsHtml = (event) => buildRaceResultsHtmlHelper(event, { t, escapeHtml, resolveEventBranding, getClassName, buildPrintBrandBlock, renderRaceStandingsTableView, buildPracticeStandings, buildQualifyingStandings, buildFinalStandings, renderTeamRaceStandings, getSessionsForEvent, renderSessionChannelAnalysis });
const getSessionsForEvent = (eventId) => getSessionsForEventHelper(state, eventId);
const getModeLabel = (mode) => getModeLabelHelper(mode, { t });
const normalizeStartMode = (mode) => normalizeStartModeHelper(mode);
const getStartModeLabel = (mode) => getStartModeLabelHelper(mode, { t, normalizeStartMode });
const getClassName = (classId) => getClassNameHelper(state, classId, { t });
const getEventName = (eventId) => getEventNameHelper(state, eventId, { t });
const renderAssignmentList = (eventId) => renderAssignmentListView(eventId, { state, t, escapeHtml, getSessionsForEvent, getSessionTypeLabel, saveState, renderAssignmentList });
const renderSessionsTable = (sessions) => renderSessionsTableView(sessions, { t, renderTable, escapeHtml, getEventName, getSessionTypeLabel, getStatusLabel, getModeLabel });
const createDefaultAmmcConfig = () => createDefaultAmmcConfigHelper();
const getManagedWsUrl = (role = "main") => getManagedWsUrlHelper({ ammc, getBackendUrl }, role);
const loadAmmcConfigFromBackend = () => loadAmmcConfigFromBackendHelper({ ammc, t, getBackendUrl, createDefaultAmmcConfig });
const saveAmmcConfigToBackend = (config) => saveAmmcConfigToBackendHelper(config, { ammc, t, getBackendUrl, createDefaultAmmcConfig });
const refreshAmmcStatus = () => refreshAmmcStatusHelper({ ammc, t, getBackendUrl });
const startManagedAmmc = () => startManagedAmmcHelper({ ammc, t, getBackendUrl });
const stopManagedAmmc = () => stopManagedAmmcHelper({ ammc, t, getBackendUrl });
const applyPersistedState = (persisted) => applyPersistedStateHelper(persisted, { state, backend, t, getDefaultBackendUrl, DEFAULT_LANGUAGE, DEFAULT_THEME, AVAILABLE_THEMES, normalizeDriver, normalizeCar, normalizeEvent, normalizeSession, normalizeStoredRacePreset, normalizeObsOverlaySettings, normalizeTrainingState, normalizeRaceAudioSettings, normalizeTrackLayouts: (value) => normalizeTrackLayouts(value, { uid }), applyTheme });
const hydrateFromBackend = ({ initial = false } = {}) => hydrateFromBackendHelper({
backend, t, getBackendUrl, applyPersistedState, saveState,
// The first load at page start always takes the server's state.
...(initial ? {} : { getLocalStateVersion: () => localStateVersion, getLocalStateDirty: () => localStateDirty, keepLocal: isRunningRaceHere }),
});
// This browser is starting or timing a heat: its own state is the newest. A stand-alone
// overlay window only shows the race, so it always follows the server.
const isRunningRaceHere = () => !overlayMode && Boolean(getPrologueSession() || pendingStartSessionId || startsInProgress > 0
|| (state.decoder?.connected && state.sessions.some((session) => ["running", "paused"].includes(session.status))));
const scheduleBackendSync = () => scheduleBackendSyncHelper({ getBackendSyncTimer: () => backendSyncTimer, setBackendSyncTimer: (value) => { backendSyncTimer = value; }, syncStateToBackend });
const syncStateToBackend = () => syncStateToBackendHelper({ backend, t, getBackendUrl, buildPersistableState, getLocalStateVersion: () => localStateVersion, getSyncedStateVersion: () => syncedStateVersion, setSyncedStateVersion: (value) => { syncedStateVersion = value; }, getLocalStateDirty: () => localStateDirty, setLocalStateDirty: (value) => { localStateDirty = value; } });
const pingBackend = () => pingBackendHelper({ backend, t, getBackendUrl });
const checkAppVersion = () => checkAppVersionHelper({ onContact: (online) => {
backend.available = online;
backend.connectionChecked = true;
if (online) backend.lastContactAt = Date.now();
updateSyncStatus();
}, onVersion: (version) => {
const label = document.getElementById("appVersionLabel");
if (label) { label.textContent = `RC RaceCore v${version}`; label.hidden = false; }
}, getBackendUrl, getBaselineAppVersion: () => baselineAppVersion, setBaselineAppVersion: (value) => { baselineAppVersion = value; }, getPendingAppVersion: () => pendingAppVersion, setPendingAppVersion: (value) => { pendingAppVersion = value; }, getLocalStateDirty: () => localStateDirty });
const startAppVersionPolling = () => startAppVersionPollingHelper({ checkAppVersion, getAppVersionPollTimer: () => appVersionPollTimer, setAppVersionPollTimer: (value) => { appVersionPollTimer = value; } });
const startOverlaySync = () => startOverlaySyncHelper({ getOverlaySyncTimer: () => overlaySyncTimer, setOverlaySyncTimer: (value) => { overlaySyncTimer = value; }, getLocalStateDirty: () => localStateDirty, hydrateFromBackend, getCurrentView: () => currentView, renderView });
const startBackgroundHydration = () => startBackgroundHydrationHelper({ getBackgroundHydrationTimer: () => backgroundHydrationTimer, setBackgroundHydrationTimer: (value) => { backgroundHydrationTimer = value; }, getLocalStateDirty: () => localStateDirty, hydrateFromBackend, getCurrentView: () => currentView });
const startOverlayRotation = () => startOverlayRotationHelper({ getOverlayRotationTimer: () => overlayRotationTimer, setOverlayRotationTimer: (value) => { overlayRotationTimer = value; }, getOverlayRotationIndex: () => overlayRotationIndex, setOverlayRotationIndex: (value) => { overlayRotationIndex = value; }, getCurrentView: () => currentView, getOverlayViewMode: () => overlayViewMode, renderView });
const startOverlayLiveRefresh = () => startOverlayLiveRefreshHelper({ getOverlayLiveRefreshTimer: () => overlayLiveRefreshTimer, setOverlayLiveRefreshTimer: (value) => { overlayLiveRefreshTimer = value; }, getCurrentView: () => currentView, getOverlayViewMode: () => overlayViewMode, refreshOverlayDynamics });
const ensureAudioContext = () => ensureAudioContextHelper({ state, getAudioCtx: () => audioCtx, setAudioCtx: (value) => { audioCtx = value; } });
const playPassingBeep = () => playPassingBeepHelper({ ensureAudioContext });
const playFinishSiren = () => playFinishSirenHelper({ ensureAudioContext });
const playLeaderCue = () => playLeaderCueHelper({ ensureAudioContext });
const playStartCue = () => playStartCueHelper({ ensureAudioContext });
const playBestLapCue = () => playBestLapCueHelper({ ensureAudioContext });
const pushOverlayEvent = (type, label, options = {}) => pushOverlayEventHelper(type, label, { uid, state, t, getOverlayEvents: () => overlayEvents, setOverlayEvents: (value) => { overlayEvents = value; }, getOverlayMode: () => overlayMode, getCurrentView: () => currentView, getOverlayViewMode: () => overlayViewMode, playLeaderCue, playPassingBeep, playFinishSiren, playStartCue, playBestLapCue }, options);
const getSpeechVoices = () => getSpeechVoicesHelper();
const speakText = (text, options = {}) => speakTextHelper(text, { state, currentLanguage }, options);
const triggerRaceAudio = (eventKey, options = {}) => {
// The Settings test buttons use force: they must sound even with no session running.
if (!options.force && isSilencedDuringRace(eventKey, state.settings.raceAudio, getLiveSession())) return { skipped: true, voiceDone: Promise.resolve(false) };
return raceAudioEngine.trigger(eventKey, options);
};
const getPassingSoundProfile = (entry) => {
const car = state.cars.find((item) => item.id === entry?.carId);
const driver = state.drivers.find((item) => item.id === entry?.driverId);
return String(car?.passSound || driver?.passSound || "").trim();
};
const announcePassing = (entry) => {
if (state.settings.raceAudio?.enabled) {
triggerRaceAudio("transponder_pass", { variant: entry?.carId || entry?.driverId || entry?.transponder, effectPath: getPassingSoundProfile(entry), scope: entry?.key });
}
};
const announceRaceStarted = (session) => announceRaceStartedHelper(session, { t, pushOverlayEvent });
// `finished` is the session that just ended (the timer may finish a running heat while the
// next one is already selected); manual finish selects the session first, so the default holds.
const announceRaceFinished = (finished = null) => {
const session = finished || getActiveSession();
announceRaceFinishedHelper({ t, getActiveSession: () => session, pushOverlayEvent });
if (!session || !state.settings.raceAudio?.enabled) return;
triggerRaceAudio(session.type === "qualification" ? "qualifying_finished" : "race_finished", { interrupt: true, logData: { raceId: session.eventId, sessionId: session.id } });
const podium = buildLeaderboard(session).slice(0, 3);
if (podium[0]) triggerRaceAudio(session.type === "qualification" ? "pole_position" : session.type === "heat" ? "heat_winner" : "race_winner", { variables: { driverName: podium[0].displayName || podium[0].driverName }, logData: { raceId: session.eventId, driverId: podium[0].driverId } });
if (podium.length > 1) triggerRaceAudio("podium", { variables: { podium: podium.map((row) => row.displayName || row.driverName).join(", ") } });
};
const announceRaceClockEvent = (eventKey, session) => triggerRaceAudio(eventKey, { logData: { raceId: session.eventId, sessionId: session.id } });
const handleSessionTimerTick = () => handleSessionTimerTickHelper({ getActiveSession: getLiveSession, isUntimedSession, getSessionTiming, saveState, getLastFinishAnnouncementSessionId: () => lastFinishAnnouncementSessionId, setLastFinishAnnouncementSessionId: (value) => { lastFinishAnnouncementSessionId = value; }, announceRaceFinished, announceRaceClockEvent });
const cancelRaceStart = () => raceAudioEngine.cancelStartSequence();
const startSessionWithAudio = (session, callbacks) => {
// Only the casual, come-and-go practice modes (open_practice - the standalone "Quick
// Open Practice" shortcut - and free_practice, both rolling/best-lap ranked with no
// fixed roster) skip the race-start ceremony. "practice" is a proper scheduled slot in
// a structured event's session plan (built by the Race Setup wizard alongside
// qualifying/finals, and already ranked like a real timed session, not rolling) and
// gets the same countdown/lights/start-tone ceremony as qualifying/heat/final.
const skipCeremony = ["open_practice", "free_practice"].includes(String(session?.type || ""));
const staggerOrder = getSessionGridOrder(session)
.map((driverId) => state.drivers.find((driver) => driver.id === driverId)?.transponder)
.filter(Boolean);
return raceAudioEngine.runStartSequence(session, { ...callbacks, skipAudio: skipCeremony, staggerOrder });
};
const tickClock = () => {
tickClockHelper({ dom, currentLanguage, handleSessionTimerTick, getActiveSession, getCurrentView: () => currentView, getOverlayMode: () => overlayMode, renderView, refreshTimingDynamics, updateHeaderState });
tickAutopilot();
tickDayCalls();
// The drivers' board counts down to each heat.
if (overlayMode && overlayViewMode === "schedule") renderView();
};
const buildTeamRaceResultsHtml = (event) => buildTeamRaceResultsHtmlHelper(event, { t, escapeHtml, resolveEventBranding, getClassName, buildPrintBrandBlock, buildTeamRaceStandings, renderTable, formatLap, renderTeamStintLog, renderSessionChannelAnalysis });
const connectDecoder = () => connectDecoderHelper({
state,
t,
saveState,
getWsClient: (role) => wsClients[role] || null,
setWsClient: (role, value) => { wsClients[role] = value; },
getReconnectTimer: (role) => reconnectTimers[role] || null,
setReconnectTimer: (role, value) => { reconnectTimers[role] = value; },
getCurrentView: () => currentView,
renderView,
updateConnectionBadge,
getActiveSession,
processDecoderMessage,
disconnectDecoder,
});
const disconnectDecoder = (options = {}) => disconnectDecoderHelper(options, {
state,
saveState,
getWsClient: (role) => wsClients[role] || null,
setWsClient: (role, value) => { wsClients[role] = value; },
getReconnectTimer: (role) => reconnectTimers[role] || null,
setReconnectTimer: (role, value) => { reconnectTimers[role] = value; },
updateConnectionBadge,
});
const getTrackRecordMs = (session) => getTrackRecordMsLogic(session, { state });
// Prologue = the count-down before a heat (see prologue_logic.js). It lives in this tab only
// (plus sessionStorage, so a reload keeps it - but on hold): a second browser showing the same
// event must never run its own count-down and double the announcements. Sightings are in
// memory only; they answer "has this transponder crossed the line since the prologue began".
const transponderSightings = new Map();
const PROLOGUE_STORAGE_KEY = "rc_race_prologue";
let racePrologue = restoreRacePrologue();
let prologueTimer = null;
const onTransponderSeen = (transponder) => {
recordTransponderSighting(transponderSightings, transponder, Date.now());
if (racePrologue && currentView === "race_day") refreshRaceDayWarmup();
};
function restoreRacePrologue() {
try {
const saved = JSON.parse(sessionStorage.getItem(PROLOGUE_STORAGE_KEY) || "null");
// Never let a reload fire a start on its own: a restored count-down comes back on hold.
return saved?.sessionId ? holdPrologue(saved) : null;
} catch { return null; }
}
function storeRacePrologue() {
try {
if (racePrologue) sessionStorage.setItem(PROLOGUE_STORAGE_KEY, JSON.stringify(racePrologue));
else sessionStorage.removeItem(PROLOGUE_STORAGE_KEY);
} catch { /* per-tab convenience only */ }
}
function getPrologueSession() {
const session = racePrologue ? state.sessions.find((item) => item.id === racePrologue.sessionId) : null;
return session?.status === "ready" ? session : null;
}
function getDefaultPrologueSec(session) {
const config = state.events.find((item) => item.id === session?.eventId)?.raceConfig || {};
return normalizePrologueSec(session?.type === "qualification" ? config.qualPrologueSec : config.finalPrologueSec);
}
// Count-down calls replace each other (group) and are dropped when late: a second-by-second
// call more than 1.2 s late, any other call after 4 s.
function speakPrologue(eventKey, session, variables = {}) {
triggerRaceAudio(eventKey, { interrupt: true, force: true, variables, group: "prologue", maxDelayMs: eventKey === "prologue_count" ? 1200 : 4000, logData: { raceId: session.eventId, sessionId: session.id } });
}
function setRacePrologue(next) {
racePrologue = next;
storeRacePrologue();
clearInterval(prologueTimer);
prologueTimer = racePrologue ? setInterval(tickRacePrologue, 200) : null;
}
function startRacePrologue(session, seconds) {
if (!session) return;
if (!seconds) { setRacePrologue(null); launchFromPrologue(session, { countedDown: false }); return; }
setRacePrologue(createPrologue(session.id, seconds * 1000));
speakPrologue("prologue_start", session, { heat: session.name, time: formatPrologueTime(seconds * 1000, currentLanguage()) });
renderView();
}
function tickRacePrologue() {
const session = getPrologueSession();
if (!session) { setRacePrologue(null); if (currentView === "race_day") renderView(); return; }
const startMode = normalizeStartMode(session.startMode);
const { prologue, call } = takeDuePrologueCall(racePrologue, startMode);
if (call) { racePrologue = prologue; storeRacePrologue(); speakPrologue(call.event, session, call.variables); }
if (racePrologue.heldRemainingMs === null && getPrologueRemainingMs(racePrologue) <= getPrologueHandoverMs(startMode)) {
setRacePrologue(null);
launchFromPrologue(session, { countedDown: true });
return;
}
refreshRaceDayPrologueClock(getPrologueRemainingMs(racePrologue));
}
// Hands over to the start procedure. "Go" (no count-down, or Go now) still gets the intro
// calls ("drivers, stand by"); a count-down that ran out has already called 10..3.
let pendingStartSessionId = null;
async function launchFromPrologue(session, { countedDown }) {
raceAudioEngine.dropVoiceGroup("prologue");
pendingStartSessionId = session.id;
renderView();
const result = await startOperationalSession(session, {
requirePreflight: true, skipCountdown: true, skipIntro: countedDown,
onCountdown: (seconds) => updateRaceDayStartDisplay(String(seconds), 0),
onLight: (light) => updateRaceDayStartDisplay(`LIGHT_${light}`, light),
onArmed: () => updateRaceDayStartDisplay("WAIT_RANDOM", 5),
});
pendingStartSessionId = null;
if (!result.ok && result.message) alert(result.message);
if (!result.ok) renderView();
}
function holdRacePrologue() {
const session = getPrologueSession();
if (!session || racePrologue.heldRemainingMs !== null) return;
setRacePrologue(holdPrologue(racePrologue));
speakPrologue("prologue_hold", session);
renderView();
}
function resumeRacePrologue() {
const session = getPrologueSession();
if (!session || racePrologue.heldRemainingMs === null) return;
setRacePrologue(resumePrologue(racePrologue));
speakPrologue("prologue_resumed", session, { time: formatPrologueTime(getPrologueRemainingMs(racePrologue), currentLanguage()) });
renderView();
}
function setRacePrologueRemaining(remainingMs) {
if (!getPrologueSession()) return;
setRacePrologue(setPrologueRemaining(racePrologue, remainingMs));
renderView();
}
// --- The race day schedule and its autopilot ------------------------------------------
// The plan (start time, gap, order, paused) is shared in state.raceDays; the autopilot runs
// only in the tab where it was switched on (sessionStorage), like the count-down, so two
// browsers never start the same heat.
const AUTOPILOT_STORAGE_KEY = "rc_day_autopilot";
let autopilotDate = (() => { try { return sessionStorage.getItem(AUTOPILOT_STORAGE_KEY) || ""; } catch { return ""; } })();
let autopilotStatus = "";
let autopilotLaunchingId = null;
let dayShowDone = false;
const todayKey = () => { const d = new Date(); return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`; };
const getDayPlan = (date) => getRaceDay(state.raceDays, date);
const saveDayPlan = (day) => { state.raceDays = upsertRaceDay(state.raceDays, day); saveState(); };
const getDayClassLabel = (session) => { const event = state.events.find((item) => item.id === session.eventId); return event?.classId ? getClassName(event.classId) : event?.name || ""; };
function buildDayRows(date, now = Date.now()) {
const day = getDayPlan(date);
const ordered = orderDaySessions({ events: state.events, sessions: state.sessions, date, manualOrder: day.sessionOrder });
return buildDaySchedule(ordered, day, now).map((row) => ({ ...row, driverCount: getSessionGridEntries(row.session).length }));
}
// Race Day works on the date of the session in focus, else today.
const getRaceDayDate = () => {
const session = buildRaceDayQueue(state).current;
const event = session ? state.events.find((item) => item.id === session.eventId) : null;
return event?.mode === "race" && event.date ? event.date : todayKey();
};
const usesCountDown = (session) => Boolean(session && session.mode !== "track" && session.type !== "team_race" && !isPracticeSessionType(session.type));
function setAutopilot(date, on) {
autopilotDate = on ? date : "";
try { if (on) sessionStorage.setItem(AUTOPILOT_STORAGE_KEY, date); else sessionStorage.removeItem(AUTOPILOT_STORAGE_KEY); } catch { /* per tab only */ }
autopilotStatus = "";
saveDayPlan({ ...getDayPlan(date), autopilot: on });
tickAutopilot();
renderView();
}
function describeAutopilot(action) {
const name = action.row ? `${getDayClassLabel(action.row.session)} ${action.row.session.name}`.trim() : "";
if (action.reason === "until") return t("day.auto_until", { name, time: formatDayClock(action.row.start), min: Math.max(0, Math.ceil((action.launchAt - Date.now()) / 60000)) });
return t(`day.auto_${action.reason}`, { name });
}
function tickAutopilot() {
if (!autopilotDate || overlayMode) return;
const day = getDayPlan(autopilotDate);
const rows = buildDayRows(autopilotDate);
const busy = Boolean(getPrologueSession() || pendingStartSessionId || startsInProgress > 0 || autopilotLaunchingId
|| state.sessions.some((session) => ["running", "paused"].includes(session.status)));
let action = getAutopilotAction(rows, { day, busy, prologueMs: (session) => (usesCountDown(session) ? getDefaultPrologueSec(session) * 1000 : 0) });
if (action.type === "start") {
const session = action.row.session;
if (!state.decoder?.connected) action = { type: "wait", reason: "decoder", row: action.row };
else if (!buildRaceDayPreflight(state, session, { backendAvailable: backend.available }).ready) action = { type: "wait", reason: "preflight", row: action.row };
}
autopilotStatus = describeAutopilot(action);
document.querySelectorAll("[data-autopilot-status]").forEach((node) => { node.textContent = autopilotStatus; });
if (action.type !== "start") return;
const session = action.row.session;
autopilotLaunchingId = session.id;
selectOperationalSession(session.id, { render: false });
if (usesCountDown(session)) {
startRacePrologue(session, getDefaultPrologueSec(session));
autopilotLaunchingId = null;
return;
}
void startOperationalSession(session, { requirePreflight: true }).finally(() => { autopilotLaunchingId = null; renderView(); });
}
// Calling a heat: the speaker says who drives it and the drivers' board highlights it. With the
// autopilot on it happens on its own; otherwise Race Day asks the race controller.
const callSnoozes = new Map();
let shownCallId = null;
function callHeat(sessionId) {
const session = state.sessions.find((item) => item.id === sessionId);
if (!session || session.calledAt) return;
const event = state.events.find((item) => item.id === session.eventId);
const row = event ? buildDayRows(event.date).find((item) => item.session.id === sessionId) : null;
session.calledAt = Date.now();
saveState();
triggerRaceAudio("heat_call", {
force: true,
variables: {
heat: `${getDayClassLabel(session)} ${session.name}`.trim(),
minutes: Math.max(1, Math.round(((row?.start || Date.now()) - Date.now()) / 60000)),
drivers: getSessionGridEntries(session).map((entry) => entry.name).join(", "),
},
logData: { raceId: session.eventId, sessionId: session.id },
});
renderView();
}
function getDueCallFor(date) {
return getDueCall(buildDayRows(date), { day: getDayPlan(date), snoozedUntil: (id) => callSnoozes.get(id) || 0 });
}
function tickDayCalls() {
if (overlayMode) return;
if (autopilotDate) {
const due = getDueCallFor(autopilotDate);
if (due) callHeat(due.session.id);
return;
}
if (currentView !== "race_day") return;
const due = getDueCallFor(getRaceDayDate());
if ((due?.session.id || null) !== shownCallId) renderView();
}
const renderDayCall = () => {
const date = getRaceDayDate();
const row = autopilotDate ? null : getDueCallFor(date);
shownCallId = row?.session.id || null;
return renderDayCallBanner({ t, escapeHtml, row, getClassLabel: getDayClassLabel, driverNames: row ? getSessionGridEntries(row.session).map((entry) => entry.name) : [] });
};
const bindDayCall = (root) => bindDayCallBanner(root, {
onCall: (sessionId) => callHeat(sessionId),
onLater: (sessionId) => { callSnoozes.set(sessionId, Date.now() + 2 * 60000); renderView(); },
});
// Pausing the day stops the autopilot and pauses whatever is on track (or holds the count-down).
function pauseRaceDay(date) {
saveDayPlan({ ...getDayPlan(date), pausedAt: Date.now() });
const live = state.sessions.find((session) => session.status === "running");
if (live) pauseOperationalSession(live);
if (getPrologueSession() && racePrologue.heldRemainingMs === null) holdRacePrologue();
renderView();
}
function resumeRaceDay(date) {
saveDayPlan({ ...getDayPlan(date), pausedAt: null });
const paused = state.sessions.find((session) => session.status === "paused" && session.mode === "race" && !isPracticeSessionType(session.type));
if (paused) resumeOperationalSession(paused);
if (getPrologueSession() && racePrologue.heldRemainingMs !== null) resumeRacePrologue();
renderView();
}
function moveDaySession(date, sessionId, step) {
const day = getDayPlan(date);
const ordered = orderDaySessions({ events: state.events, sessions: state.sessions, date, manualOrder: day.sessionOrder });
saveDayPlan({ ...day, sessionOrder: moveInDayOrder(ordered, sessionId, step) });
renderView();
}
const formatDayClock = (ts) => formatClockTime(ts);
const renderDaySchedule = () => {
const date = getRaceDayDate();
return renderDaySchedulePanel({ t, escapeHtml, date, day: getDayPlan(date), rows: buildDayRows(date), autopilotHere: autopilotDate === date, autopilotStatus: autopilotDate === date ? autopilotStatus : "", getClassLabel: getDayClassLabel, showDone: dayShowDone });
};
const bindDaySchedule = (root) => {
const date = getRaceDayDate();
bindDaySchedulePanel(root, {
date,
onSavePlan: ({ startAt, gapMin, callMin }) => { saveDayPlan({ ...getDayPlan(date), startAt, gapMin, callMin }); renderView(); },
onMove: (sessionId, step) => moveDaySession(date, sessionId, step),
onPrint: () => openPrintWindow(t("day.print_title", { date }), buildDaySchedulePrintHtml({ t, escapeHtml, date, rows: buildDayRows(date), getClassLabel: getDayClassLabel, getSessionGridEntries })),
onBoard: () => window.open(buildOverlayUrl("schedule", { public: true }), "_blank"),
onAutopilot: (on) => {
if (on && !window.confirm(t("day.autopilot_confirm"))) return;
setAutopilot(date, on);
},
onPause: () => pauseRaceDay(date),
onToggleDone: () => { dayShowDone = !dayShowDone; renderView(); },
onResume: () => resumeRaceDay(date),
});
};
const renderBoard = () => {
const date = pickBoardDate({ events: state.events, sessions: state.sessions, today: todayKey() });
dom.view.innerHTML = renderDriverBoard({
t, escapeHtml, date, rows: buildDayRows(date), getClassLabel: getDayClassLabel, getSessionGridEntries,
getRemainingLabel: (session) => { const timing = getSessionTiming(session); return timing.untimed ? formatElapsedClock(timing.elapsedMs) : formatCountdown(timing.remainingMs); },
});
};
// --- Race Day as the place where things are run --------------------------------------
// "New practice day": clears the session's laps on Timing for a new day; every lap so far
// is first put in the training stats, where resultsResetAt keeps it (see syncTrainingLedger).
function resetSessionData(session) {
if (!session) return false;
syncTrainingLedger();
session.resultsResetAt = Date.now();
delete state.resultsBySession[session.id];
session.followUpStartedAt = null;
session.calledAt = null;
// A heat (anything but an Open/Free Practice that runs all evening) goes back to "ready":
// the clock is back at zero and it can be started again.
const rerunHeat = !isPracticeSessionType(session.type) && session.status !== "running";
if (rerunHeat) {
// An empty result, also written straight to the server: a plain delete was put back by
// the server's live-results protection when the reset came right after the last lap.
ensureSessionResult(session.id);
Object.assign(session, { status: "ready", startedAt: null, endedAt: null, finishedByTimer: false, pausedAt: null, totalPausedMs: 0, followUpPausedMs: 0, audioAnnouncements: [] });
}
lastFinishAnnouncementSessionId = null;
delete lastOverlayLeaderKeyBySession[session.id];
delete lastOverlayTop3BySession[session.id];
overlayEvents = [];
saveState();
if (rerunHeat) void persistSessionResultToBackend(session.id);
renderView();
return true;
}
// The Open Practice "Start practice" works on: one already running, else a paused one,
// else the latest not-finished one (a club often runs one all season); null = make a new one.
function findOpenPracticeToContinue() {
const practices = state.sessions.filter((session) => session.type === "open_practice");
const latest = (list) => list.sort((a, b) => Number(b.startedAt || 0) - Number(a.startedAt || 0))[0] || null;
return latest(practices.filter((session) => session.status === "running"))
|| latest(practices.filter((session) => session.status === "paused"))
|| practices.filter((session) => session.status === "ready").at(-1)
|| null;
}
// One click from Race Day: continue the Open Practice, or create and start one for today.
async function startPracticeNow() {
let session = findOpenPracticeToContinue();
if (!session) {
const bundle = buildOpenPracticeBundle({ name: t("events.quick_open_practice_default"), date: new Date().toISOString().slice(0, 10) });
state.events.push(bundle.event);
state.sessions.push(bundle.session);
session = bundle.session;
}
selectOperationalSession(session.id, { render: false });
if (session.status === "paused") return resumeOperationalSession(session);
if (session.status === "running") { renderView(); return true; }
const result = await startOperationalSession(session);
if (!result.ok && result.message) alert(result.message);
renderView();
return result.ok;
}
function goRacePrologue() {
const session = getPrologueSession();
setRacePrologue(null);
if (session) launchFromPrologue(session, { countedDown: false });
}
function cancelRacePrologue() {
const session = getPrologueSession();
setRacePrologue(null);
if (session) speakPrologue("prologue_cancelled", session);
renderView();
}
function getRaceDayWarmupCheck(session) {
if (!session) return null;
const byId = new Map(state.drivers.map((driver) => [driver.id, driver]));
const entrantIds = getRaceDriverIds(state, session);
const gridOrder = getSessionGridOrder(session).filter((id) => entrantIds.includes(id));
const ordered = [...gridOrder, ...entrantIds.filter((id) => !gridOrder.includes(id))];
const prologue = racePrologue?.sessionId === session.id ? racePrologue : null;
return {
prologue,
remainingMs: prologue ? getPrologueRemainingMs(prologue) : 0,
...buildWarmupCheck({ entrants: ordered.map((id) => byId.get(id)).filter(Boolean), drivers: state.drivers, sightings: transponderSightings, since: prologue ? prologue.startedAt : Number.POSITIVE_INFINITY }),
};
}
// Quick fix from the warm-up panel: warns (like the Drivers page) if another person
// already uses that transponder, then saves it on the driver straight away.
function setDriverTransponder(driverId, transponder) {
const value = String(transponder || "").trim();
const driver = state.drivers.find((item) => item.id === driverId);
if (!driver || !value) return false;
const conflict = findTransponderConflict(state.drivers, { transponder: value, profileId: getDriverProfileId(driver), excludeDriverId: driver.id });
if (conflict && !window.confirm(t("warmup.transponder_conflict", { transponder: value, name: conflict.name }))) return false;
driver.transponder = value;
saveState();
return true;
}
const processDecoderMessage = (msg, decoderRole = "main") => processDecoderMessageHelper(msg, {
state,
t,
// Passings go to the session actually running (see getLiveSession), not only the selected one.
getActiveSession: getLiveSession,
ensureSessionResult,
normalizeStartMode,
getSessionLapWindow,
findEventTeamForPassing,
persistPassingToBackend,
pushOverlayEvent,
buildLeaderboard,
formatLap,
announcePassing,
saveState,
lastOverlayLeaderKeyBySession,
lastOverlayTop3BySession,
lastOverlayBestLapByKey,
triggerRaceAudio,
getTrackRecordMs,
onTransponderSeen,
// Race Day's preflight shows the decoder clock warning from warm-up passings, before a start.
onDecoderClockChange: () => { if (currentView === "race_day") renderView(); },
}, decoderRole);
const renderDashboard = () => renderDashboardView({ addTrackLayout, startPracticeNow, state, dom, t, backend, getActiveSession, getStatusLabel, getSessionTypeLabel, getEventName, getModeLabel, getBackendUrl, formatLap, renderSessionsTable, setCurrentView: (view) => { currentView = view; }, updateViewUrl, renderNav, renderView, connectDecoder, disconnectDecoder, openOverlayWindow, ensureAudioContext, playPassingBeep, playFinishSiren, escapeHtml });
const renderClasses = () => renderClassesView({ state, dom, t, selectedClassEditId: () => selectedClassEditId, setSelectedClassEditId: (value) => { selectedClassEditId = value; }, uid, saveState, renderView, renderTable, escapeHtml, setFormError, bindModalShell });
// Driver page "Test pronunciation": the passing sound, then two real announcements with the
// spoken name, through race audio (so the chosen voice / Piper is what you hear).
const testDriverVoice = ({ spokenName, passSound }) => {
if (!spokenName) return;
ensureAudioContext();
triggerRaceAudio("transponder_pass", { force: true, effectPath: passSound || "" });
const variables = { driverName: spokenName, lapTime: formatLap(16420), podium: spokenName };
triggerRaceAudio("personal_best", { force: true, interrupt: true, variables });
triggerRaceAudio("race_winner", { force: true, variables });
};
const renderDrivers = () => renderDriversView({ state, dom, t, driverBrandFilter: () => driverBrandFilter, setDriverBrandFilter: (value) => { driverBrandFilter = value; }, selectedDriverEditId: () => selectedDriverEditId, setSelectedDriverEditId: (value) => { selectedDriverEditId = value; }, uid, saveState, renderView, renderTable, escapeHtml, setFormError, bindModalShell, normalizeDriver, getClassName , testDriverVoice });
const renderCars = () => renderCarsView({ state, dom, t, carBrandFilter: () => carBrandFilter, setCarBrandFilter: (value) => { carBrandFilter = value; }, selectedCarEditId: () => selectedCarEditId, setSelectedCarEditId: (value) => { selectedCarEditId = value; }, uid, saveState, renderView, renderTable, escapeHtml, setFormError, bindModalShell, normalizeCar });
const renderGuide = () => renderGuideView({ dom, t });
const renderRaceDay = () => renderRaceDayView({
getRaceDayWarmupCheck, setDriverTransponder, getDefaultPrologueSec,
startRacePrologue, holdRacePrologue, resumeRacePrologue, setRacePrologueRemaining, cancelRacePrologue, goRacePrologue,
isStartPending: (session) => Boolean(session && pendingStartSessionId === session.id),
resetSessionData, startPracticeNow, findOpenPracticeToContinue,
getLiveSession,
renderSuspectLapsPanel: (session) => renderSuspectLapsPanelWithRelease(session),
buildLeaderboard, getSessionTargetMs, formatRaceClock,
renderDaySchedule, bindDaySchedule, renderDayCall, bindDayCall,
setCompetitorLapStatus,
addTrackLayout, renderView, state, dom, t, escapeHtml, formatLap, formatCountdown, formatElapsedClock,
getEventName, getSessionTypeLabel, getStatusLabel, getStartModeLabel,
getSessionTiming, getSessionGridEntries, buildRaceDayQueue, buildRaceDayPreflight,
backendAvailable: backend.available,
selectSession: selectOperationalSession,
startSession: (session, callbacks) => startOperationalSession(session, { ...callbacks, requirePreflight: true }),
finishSession: finishOperationalSession,
pauseSession: pauseOperationalSession,
resumeSession: resumeOperationalSession,
saveLapWindow: saveOperationalLapWindow,
navigateTo: navigateToView,
getStartLightState: () => raceAudioEngine.getStartLightState(),
});
const renderOverlay = () => renderOverlayPageView({ state, dom, t, escapeHtml, formatLap, formatCountdown, formatElapsedClock, formatPredictedLapDelta, getActiveSession, buildLeaderboard, ensureSessionResult, getSessionTiming, getVisiblePassings, resolveEventBranding, buildPracticeStandings, buildQualifyingStandings, buildFinalStandings, getOverlayModeLabel, getStatusLabel, getObsOverlayConfig, buildOverlayPanels, normalizeStartMode, renderPositionGrid, getEventName, getSessionTypeLabel, getStartModeLabel, renderRaceStandingsTableView, renderTeamOverlay, renderObsOverlay, renderOverlayLeaderboard: (rows, deps, options = {}) => renderOverlayLeaderboard(rows, deps, { ...options, driverLinks: !publicOverlayMode }), renderOverlaySidePanel, formatTeamActiveMemberLabel, getSessionGridEntries, getSessionGridOrder, overlayViewMode, overlayMode, publicOverlayMode, overlayEvents, overlayRotationIndex, openOverlayWindow, buildOverlayUrl });
const refreshOverlayDynamics = () => {
const active = getActiveSession();
if (!active) return;
const timing = getSessionTiming(active);
const clock = timing.followUpActive
? formatCountdown(timing.followUpRemainingMs)
: timing.untimed
? formatElapsedClock(timing.elapsedMs)
: formatCountdown(timing.remainingMs);
document.querySelectorAll("[data-overlay-clock]").forEach((node) => {
node.textContent = clock;
});
const rowsByKey = new Map(buildLeaderboard(active).map((row) => [String(row.key), row]));
document.querySelectorAll("[data-overlay-competitor]").forEach((node) => {
const row = rowsByKey.get(String(node.dataset.overlayCompetitor || ""));
if (!row) return;
const prediction = node.querySelector("[data-overlay-prediction]");
const fill = node.querySelector("[data-overlay-prediction-fill]");
if (prediction) prediction.textContent = formatPredictedLapDelta(row.predictedRemainingMs);
if (fill instanceof HTMLElement) {
fill.style.width = `${Math.max(0, Math.min(100, Math.round(Math.min(1, row.predictedProgress || 0) * 100)))}%`;
fill.classList.remove("overlay-prediction-good", "overlay-prediction-warn", "overlay-prediction-overdue");
fill.classList.add(`overlay-prediction-${row.predictionTone || "good"}`);
}
});
};
const refreshTimingDynamics = () => {
const active = getActiveSession();
if (!active) return;
const timing = getSessionTiming(active);
const clock = timing.followUpActive
? formatCountdown(timing.followUpRemainingMs)
: timing.untimed
? formatElapsedClock(timing.elapsedMs)
: formatCountdown(timing.remainingMs);
document.querySelectorAll("[data-timing-clock], [data-race-day-clock]").forEach((node) => {
node.textContent = clock;
});
if (currentView === "race_day") refreshRaceDayLive();
};
const renderTiming = () => renderTimingView({ renderSuspectLapsPanel: (session) => renderSuspectLapsPanelWithRelease(session), state, dom, t, escapeHtml, formatLap, formatCountdown, formatElapsedClock, formatRaceClock, renderTable, uid, getActiveSession, ensureSessionResult, buildLeaderboard, getSessionTiming, getVisiblePassings, getEventName, getSessionTypeLabel, getStatusLabel, normalizeStartMode, getStartModeLabel, renderPositionGrid, renderSessionChannelAnalysis, connectDecoder, disconnectDecoder, applyCompetitorCorrection, invalidateCompetitorLastLap, restoreCompetitorLastInvalidLap, startOperationalSession, finishOperationalSession, cancelRaceStart, triggerRaceAudio, getStartLightState: () => raceAudioEngine.getStartLightState(), saveState, updateHeaderState, renderView, normalizeDriver, normalizeCar, processDecoderMessage, getSelectedLeaderboardKey: () => selectedLeaderboardKey, setSelectedLeaderboardKey: (value) => { selectedLeaderboardKey = value; }, getQuickAddDraft: () => quickAddDraft, setQuickAddDraft: (value) => { quickAddDraft = value; }, getPassingValidationLabel, isCountedPassing, getCompetitorPassings, getManualCorrectionSummary, formatTeamActiveMemberLabel, lastFinishAnnouncementSessionId: () => lastFinishAnnouncementSessionId, setLastFinishAnnouncementSessionId: (value) => { lastFinishAnnouncementSessionId = value; }, lastOverlayLeaderKeyBySession, lastOverlayTop3BySession, overlayEvents: () => overlayEvents, setOverlayEvents: (value) => { overlayEvents = value; }, sessionReplay, syncTrainingLedger, setCompetitorLapStatus, getLiveSession, selectLiveSession: (id) => selectOperationalSession(id), openRaceDay: () => navigateToView("race_day"), openJudging: (rowKey) => { selectedJudgeKey = rowKey; selectedLeaderboardKey = null; navigateToView("judging"); } });
const renderJudging = () => renderJudgingView({ state, dom, t, escapeHtml, formatLap, renderTable, getActiveSession, ensureSessionResult, buildLeaderboard, getSessionTypeLabel, getJudgeFilteredRows, getJudgeFilteredLog, getCompetitorPassings, isCountedPassing, getPassingValidationLabel, undoJudgingAdjustment, applyCompetitorCorrection, invalidateCompetitorLastLap, restoreCompetitorLastInvalidLap, renderView, getSelectedJudgeKey: () => selectedJudgeKey, setSelectedJudgeKey: (value) => { selectedJudgeKey = value; }, getJudgingCompetitorFilter: () => judgingCompetitorFilter, setJudgingCompetitorFilter: (value) => { judgingCompetitorFilter = value; }, getJudgingLogFilter: () => judgingLogFilter, setJudgingLogFilter: (value) => { judgingLogFilter = value; } , setCompetitorLapStatus });
const normalizeTrainingState = (training) => normalizeTrainingStateLogic(training, { uid });
const syncTrainingLedger = () => {
state.training = syncTrainingLedgerLogic(state.training, state, { uid });
return state.training;
};
const buildDriverTrainingStats = (trainingState, driverId, classId = "", options = {}) => buildDriverTrainingStatsLogic(trainingState, driverId, classId, options);
const buildDriverActivePracticeStats = (trainingState, driverId, nowTs = Date.now(), classId = "") => buildDriverActivePracticeStatsLogic(trainingState, driverId, nowTs, classId);
const buildEvenLapsProgress = (trainingState, driverId, classId, config, nowTs = Date.now()) => buildEvenLapsProgressLogic(trainingState, driverId, classId, config, nowTs);
const buildStepTrainingProgress = (trainingState, driverId, classId, config, nowTs = Date.now()) => buildStepTrainingProgressLogic(trainingState, driverId, classId, config, nowTs);
const buildTrainingRecommendation = (stats) => buildTrainingRecommendationLogic(stats);
const getTrainingGoalProgress = (goal, stats, exerciseSessionCount) => getTrainingGoalProgressLogic(goal, stats, exerciseSessionCount);
const getNextTrainingMilestone = (stats) => getNextTrainingMilestoneLogic(stats);
// --- Series / cup ---------------------------------------------------------------------
// The day result a series scores: the final standings (A before B ...), then drivers who
// raced no final in qualifying order; or the qualifying order alone if no finals ran. Only
// once at least one qualifying/heat/final of the event is finished. `hasLap`: at least one
// counted lap in any of them (no lap = 0 series points).
const getEventDayResult = (event) => {
const sessions = getSessionsForEvent(event.id).filter((session) => ["qualification", "heat", "final"].includes(session.type));
if (!sessions.some((session) => session.status === "finished")) return [];
const lapped = new Set();
sessions.forEach((session) => (state.resultsBySession[session.id]?.passings || []).forEach((passing) => {
if (passing.validLap !== false && passing.driverId) lapped.add(String(passing.driverId));
}));
const order = [];
const add = (row) => { if (row?.driverId && !order.some((item) => item.driverId === row.driverId)) order.push({ driverId: row.driverId, driverName: row.driverName, hasLap: lapped.has(String(row.driverId)) }); };
buildFinalStandings(event).forEach(add);
buildQualifyingStandings(event).forEach(add);
return order;
};
const getDriverNameById = (driverId) => state.drivers.find((driver) => driver.id === driverId)?.name || "";
const getSeriesStandings = (series) => buildSeriesStandings(series, {
events: state.events,
dayResults: new Map(state.events.filter((event) => series.eventIds.includes(event.id)).map((event) => [event.id, getSeriesDayResult(series, event.id, getEventDayResult(event), getDriverNameById)])),
getDriverClub: (driverId) => state.drivers.find((driver) => driver.id === driverId)?.club || "",
getDriverName: (driverId) => state.drivers.find((driver) => driver.id === driverId)?.name || "",
classNames: new Map(state.classes.map((item) => [item.id, item.name])),
});
// One race per date and class, named "<series> #<round> <class>", with the chosen race format.
const createSeriesEvents = (series, dates, presetId, format = {}, { heatOrder = "", seedPractice = false, seedPracticeMin = 5, seedLaps = 3, seedMethod = "best_sum", seedGroupSize = 0 } = {}) => {
const existingDates = new Set(state.events.filter((event) => series.eventIds.includes(event.id)).map((event) => event.date));
const allDates = [...new Set([...existingDates, ...dates])].sort();
let created = 0;
[...new Set(dates)].sort().forEach((date) => {
const round = allDates.indexOf(date) + 1;
series.classIds.forEach((classId) => {
if (state.events.some((event) => series.eventIds.includes(event.id) && event.date === date && event.classId === classId)) return;
const event = normalizeEvent({ id: uid("event"), name: `${series.name} #${round} ${getClassName(classId)}`, date, classId, mode: "race" });
applyRaceFormatPreset(event, presetId);
state.events.push(event);
if (Object.keys(format).length) setSeriesRoundFormat(event.id, format);
if (heatOrder) event.raceConfig.heatOrder = normalizeHeatOrder(heatOrder);
// A practice before qualifying seeds the heats (no driver list: it follows the round's
// participants, set later).
if (seedPractice) {
event.raceConfig.seedGroupSize = Math.max(0, Math.round(Number(seedGroupSize) || 0));
state.sessions.push(buildRaceSession(event.id, t("series.seed_practice_name"), "practice", Math.max(1, Math.round(seedPracticeMin)), {
startMode: "mass", seedBestLapCount: seedLaps, seedMethod,
}));
}
series.eventIds.push(event.id);
created += 1;
});
});
saveState();
return created;
};
// --- Series hub: each round (one race) handled right from the series page ----------------
const byDriverName = (a, b) => String(a.name || "").localeCompare(String(b.name || ""), undefined, { sensitivity: "base" });
const getSeriesRounds = (series) => state.events
.filter((event) => series.eventIds.includes(event.id))
.sort((a, b) => String(a.date || "").localeCompare(String(b.date || "")) || getClassName(a.classId).localeCompare(getClassName(b.classId), undefined, { numeric: true }))
.map((event) => {
const sessions = getSessionsForEvent(event.id);
const qualSessions = sessions.filter((session) => session.type === "qualification");
return {
event,
className: getClassName(event.classId),
classDrivers: state.drivers.filter((driver) => driver.classId === event.classId).sort(byDriverName),
participantIds: getEventDrivers(event).map((driver) => driver.id),
status: getSeriesRoundStatus(sessions),
nextStep: getSeriesRoundNextStep(sessions, event.sessionOrder),
qualHeatCount: new Set(qualSessions.map((session) => String(session.name || "").split(" ").pop())).size,
finalCount: sessions.filter((session) => session.type === "final").length,
calculatedResult: getEventDayResult(event),
manualResult: series.manualResults?.[event.id] || null,
};
});
// Deleting a series can take its rounds along (races in another series are kept).
const deleteSeriesRaces = (series) => {
const inOtherSeries = new Set((state.series || []).filter((item) => item.id !== series.id).flatMap((item) => item.eventIds));
const eventIds = new Set(series.eventIds.filter((id) => !inOtherSeries.has(id)));
const sessionIds = state.sessions.filter((session) => eventIds.has(session.eventId)).map((session) => session.id);
state.events = state.events.filter((event) => !eventIds.has(event.id));
state.sessions = state.sessions.filter((session) => !eventIds.has(session.eventId));
sessionIds.forEach((id) => delete state.resultsBySession[id]);
if (sessionIds.includes(state.activeSessionId)) state.activeSessionId = null;
void purgeSessionPassings(sessionIds);
};
const findSeriesEvent = (eventId) => state.events.find((event) => event.id === eventId) || null;
// Format per round (can differ between rounds and classes); locked once qualifying exists.
const setSeriesRoundFormat = (eventId, values) => {
const event = findSeriesEvent(eventId);
if (!event) return;
const config = event.raceConfig;
config.qualifyingRounds = Math.max(1, Math.round(Number(values.qualifyingRounds ?? config.qualifyingRounds) || 1));
config.finalLegs = Math.max(1, Math.round(Number(values.finalLegs ?? config.finalLegs) || 1));
config.carsPerHeat = Math.max(2, Math.round(Number(values.carsPerHeat ?? config.carsPerHeat) || 2));
config.carsPerFinal = Math.max(2, Math.round(Number(values.carsPerHeat ?? config.carsPerFinal) || config.carsPerFinal || 2));
config.seedGroupSize = Math.max(0, Math.round(Number(values.seedGroupSize ?? config.seedGroupSize) || 0));
// Two of three finals count (or all, with fewer than three).
config.countedFinalLegs = config.finalLegs >= 3 ? config.finalLegs - 1 : config.finalLegs;
config.presetId = "custom";
saveState();
};
const setSeriesRoundParticipants = (eventId, driverIds) => {
const event = findSeriesEvent(eventId);
if (!event) return;
event.raceConfig.driverIds = [...new Set(driverIds)];
event.raceConfig.participantsConfigured = true;
saveState();
};
// Same starting field as the previous round of the same class in this series.
const copySeriesRoundParticipants = (series, eventId) => {
const rounds = getSeriesRounds(series);
const index = rounds.findIndex((round) => round.event.id === eventId);
const previous = rounds.slice(0, Math.max(0, index)).reverse().find((round) => round.event.classId === rounds[index]?.event.classId);
if (!previous) return false;
setSeriesRoundParticipants(eventId, previous.participantIds.filter((id) => rounds[index].classDrivers.some((driver) => driver.id === id)));
return true;
};
// A driver turning up on the day: registered in the round's class (and the series' club for a
// members-only series) and ticked for this round.
const addDriverToSeriesRound = (series, eventId, { name, transponder }) => {
const event = findSeriesEvent(eventId);
const cleanName = String(name || "").trim();
if (!event || !cleanName) return false;
const driver = normalizeDriver({ id: uid("driver"), name: cleanName, classId: event.classId, transponder: String(transponder || "").trim(), club: series.scoring === "club" ? series.club : "" });
state.drivers.push(driver);
setSeriesRoundParticipants(eventId, [...getEventDrivers(event).map((item) => item.id), driver.id]);
return true;
};
const generateSeriesRoundQualifying = (eventId) => {
const event = findSeriesEvent(eventId);
if (!event) return 0;
const created = generateQualifyingForRace(event);
saveState();
return created;
};
const generateSeriesRoundFinals = (eventId) => {
const event = findSeriesEvent(eventId);
if (!event) return 0;
const created = generateFinalsForRace(event);
saveState();
return created;
};
// Today's drivers in series-standings order (class table), the rest after them in entry
// order - the first round, and guests in a members-only series.
const rankForSeeding = (event) => {
const series = (state.series || []).find((item) => item.eventIds.includes(event.id));
const table = series ? getSeriesStandings(series).find((item) => item.classId === event.classId) : null;
const rank = new Map((table?.rows || []).map((row) => [row.driverId, row.rank]));
return getEventDrivers(event).map((driver, index) => ({ id: driver.id, index }))
.sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity) || a.index - b.index)
.map((item) => item.id);
};
// The round's seeding practice is (re)split into groups from today's drivers each time it is
// opened, until one group has started - so late entries and unticked drivers are taken in.
const prepareSeedingGroups = (eventId) => {
const event = findSeriesEvent(eventId);
const seeding = event ? getSessionsForEvent(eventId).filter((session) => session.type === "practice") : [];
if (!seeding.length || seeding.some((session) => session.status !== "ready")) return;
const groups = planSeedingGroups(rankForSeeding(event), event.raceConfig.seedGroupSize, event.raceConfig.heatOrder);
if (!groups.length) return;
const template = seeding[0];
const oldIds = new Set(seeding.map((session) => session.id));
if (oldIds.has(state.activeSessionId)) state.activeSessionId = null;
state.sessions = state.sessions.filter((session) => !oldIds.has(session.id));
const baseName = t("series.seed_practice_name");
groups.forEach((driverIds, index) => state.sessions.push(buildRaceSession(event.id, groups.length > 1 ? `${baseName} ${index + 1}` : baseName, "practice", template.durationMin, {
driverIds, startMode: template.startMode, seedBestLapCount: template.seedBestLapCount, seedMethod: template.seedMethod,
})));
};
const runSeriesSeeding = (eventId) => {
prepareSeedingGroups(eventId);
const step = getSeriesRoundNextStep(getSessionsForEvent(eventId));
if (step.session) runSeriesSession(step.session.id);
};
// The row's run button: make the session the active one and go to Race Day, where only
// Start is left to press.
const runSeriesSession = (sessionId) => {
if (!selectOperationalSession(sessionId, { render: false })) return;
navigateToView("race_day");
};
const openSeriesRound = (eventId) => {
selectedEventEditId = eventId;
navigateToView("race_setup");
};
const seriesCell = (table, row, event) => {
const result = row.results.find((item) => item.eventId === event.id);
if (!event.completed || !result) return "";
const text = result.absent ? "-" : String(result.points);
return result.counted ? text : `(${text})`;
};
const seriesSubtitle = (series) => [series.scoring === "club" && series.club ? t("series.subtitle_members", { club: series.club }) : "", t("series.count_rule", { rule: series.countMode === "drop" ? t("series.count_drop_value", { count: series.countValue }) : t("series.count_best_value", { count: series.countValue }) })].filter(Boolean).join(" • ");
const printSeries = (series, tables) => openPrintWindow(series.name, `
<div class="print-header"><div><p class="print-kicker">${escapeHtml(t("series.standings"))}</p><h1>${escapeHtml(series.name)}</h1><p>${escapeHtml(seriesSubtitle(series))}</p></div>
<div class="print-meta"><p>${escapeHtml(new Date().toLocaleDateString())}</p></div></div>
${tables.map((table) => `<div class="print-block"><h2>${escapeHtml(table.className)} - ${escapeHtml(t("series.counted_of", { counted: table.countedCount, completed: table.completedCount, total: table.events.length }))}</h2>
<table><thead><tr><th>${escapeHtml(t("table.pos"))}</th><th>${escapeHtml(t("table.driver"))}</th>${table.events.map((event, index) => `<th>${index + 1}</th>`).join("")}<th>${escapeHtml(t("series.starts"))}</th><th>${escapeHtml(t("series.total"))}</th></tr></thead>
<tbody>${table.rows.map((row) => `<tr><td>${row.rank}</td><td>${escapeHtml(row.driverName)}</td>${table.events.map((event) => `<td>${escapeHtml(seriesCell(table, row, event))}</td>`).join("")}<td>${row.starts}</td><td><strong>${row.total}</strong></td></tr>`).join("")}</tbody></table>
<p>${table.events.map((event, index) => `${index + 1}: ${escapeHtml(event.date || "")} ${escapeHtml(event.name)}`).join(" · ")}</p></div>`).join("")}
<p>${escapeHtml(t("series.legend"))}</p>`);
const exportSeriesPdf = async (series, tables) => {
const branding = resolveEventBranding(state.events.find((event) => series.eventIds.includes(event.id)) || {});
await requestPdfExport({
filename: `${(series.name || "series").replaceAll(/\s+/g, "_")}_standings.pdf`,
title: series.name,
subtitle: seriesSubtitle(series),
brandName: branding.brandName,
brandTagline: branding.brandTagline,
footer: branding.pdfFooter,
theme: branding.pdfTheme,
logoDataUrl: await ensurePdfLogoDataUrl(branding.logoDataUrl),
sections: tables.map((table) => buildPdfSection(
`${table.className} - ${t("series.counted_of", { counted: table.countedCount, completed: table.completedCount, total: table.events.length })}`,
[t("table.pos"), t("table.driver"), ...table.events.map((event, index) => String(index + 1)), t("series.starts"), t("series.total")],
table.rows.map((row) => [String(row.rank), row.driverName, ...table.events.map((event) => seriesCell(table, row, event)), String(row.starts), String(row.total)]),
)),
});
};
const renderSeries = () => renderSeriesView({ state, dom, t, escapeHtml, saveState, renderView, uid, getClassName, getSeriesStandings, createSeriesEvents, getRaceFormatPresets, exportSeriesPdf, printSeries, getSeriesRounds, deleteSeriesRaces, runSeriesSession, runSeriesSeeding, setSeriesRoundFormat, setSeriesRoundParticipants, copySeriesRoundParticipants, addDriverToSeriesRound, generateSeriesRoundQualifying, generateSeriesRoundFinals, openSeriesRound });
const renderArchive = () => renderResultsArchiveView({
state, dom, t, escapeHtml, formatLap, formatRaceClock, renderTable,
getClassName, getEventName, buildLeaderboard, getCompetitorPassings,
exportRaceResultsPdf, buildRacePackagePayload, downloadJsonFile, sanitizeFilenameSegment,
getArchiveFilters: () => archiveFilters, setArchiveFilters: (value) => { archiveFilters = value; },
getSelectedSessionId: () => archiveSelectedSessionId, setSelectedSessionId: (value) => { archiveSelectedSessionId = value; },
getTrackLayoutLabel,
});
const renderTraining = () => renderTrainingView({ addTrackLayout, state, dom, t, escapeHtml, formatLap, formatRaceClock, uid, saveState, syncStateToBackend, renderView, normalizeTrainingState, syncTrainingLedger, buildDriverTrainingStats, buildDriverTimingChannelStats: buildDriverTimingChannelStatsLogic, buildDriverActivePracticeStats, buildEvenLapsProgress, buildStepTrainingProgress, buildTrainingRecommendation, getTrainingGoalProgress, getNextTrainingMilestone, buildTrainingMissions: buildTrainingMissionsLogic, buildTrainingHighlights: buildTrainingHighlightsLogic, getClubTrainingGoalProgress: getClubTrainingGoalProgressLogic, countDriverExerciseSessions: countDriverExerciseSessionsLogic, countExerciseSessions: countExerciseSessionsLogic, buildTrainingPaceBuckets: buildTrainingPaceBucketsLogic, buildTrainingWeekdayStats: buildTrainingWeekdayStatsLogic, buildTrainingStintAnalysis: buildTrainingStintAnalysisLogic, buildTrainingMarkerComparisons: buildTrainingMarkerComparisonsLogic, isInitialLoadDone: () => initialLoadDone, openPublicAddressSettings: () => { openSettingsTab("system", "settingsPublicAddress"); navigateToView("settings"); }, getSelectedDriverId: () => selectedTrainingDriverId, setSelectedDriverId: (value) => { selectedTrainingDriverId = value; updateViewUrl("training", value, selectedTrainingClassId); }, getSelectedClassId: () => selectedTrainingClassId, setSelectedClassId: (value) => { selectedTrainingClassId = value; updateViewUrl("training", selectedTrainingDriverId, value); } });
// Judge corrections are saved as usual and also pushed as this session's result, so the
// server's "hot results" protection (live passings in the last 15 s) can't hold them back.
const saveCorrectionFor = (session) => () => {
saveState();
persistSessionResultToBackend(session?.id);
};
const applyCompetitorCorrection = (session, row, options = {}) => {
const result = applyCompetitorCorrectionLogic(session, row, options, { ensureSessionResult, uid, t, formatLap, saveState: saveCorrectionFor(session) });
if (!options.reset && ((Number(options.timeMsDelta || 0) > 0) || (Number(options.lapDelta || 0) < 0))) {
triggerRaceAudio("penalty", { variables: { driverName: row?.displayName || row?.driverName || "" }, driverId: row?.driverId, logData: { raceId: session?.eventId, driverId: row?.driverId } });
}
return result;
};
// Before the suspect list is shown: flagged laps that no longer stand out against the
// driver's pace now (they got faster, not a shortcut) lose the flag - this also clears laps
// flagged under the old rule, where flagged laps never entered the reference.
const renderSuspectLapsPanelWithRelease = (session) => {
const result = ensureSessionResult(session.id);
const keys = new Set(listPendingSuspectLaps(result).map((passing) => passing.competitorKey));
let released = 0;
keys.forEach((key) => {
const count = releaseSettledSuspectLaps(result.passings, key, String(session.trackLayoutId || "")).length;
if (count) recalculateCompetitorFromPassings(session, key);
released += count;
});
if (released) saveCorrectionFor(session)();
return renderSuspectLapsPanelView(session, { t, escapeHtml, formatLap, ensureSessionResult });
};
const recalculateCompetitorFromPassings = (session, rowKey) => recalculateCompetitorFromPassingsLogic(session, rowKey, { ensureSessionResult, getCompetitorPassings, isCountedPassing });
const invalidateCompetitorLastLap = (session, row) => invalidateCompetitorLastLapLogic(session, row, { ensureSessionResult, getCompetitorPassings, isCountedPassing, recalculateCompetitorFromPassings, uid, t, formatLap, saveState: saveCorrectionFor(session) });
const setCompetitorLapStatus = (session, rowKey, passingTimestamp, action) => setCompetitorLapStatusLogic(session, rowKey, passingTimestamp, action, { ensureSessionResult, recalculateCompetitorFromPassings, uid, t, formatLap, saveState: saveCorrectionFor(session) });
const restoreCompetitorLastInvalidLap = (session, row) => restoreCompetitorLastInvalidLapLogic(session, row, { ensureSessionResult, getCompetitorPassings, recalculateCompetitorFromPassings, uid, t, formatLap, saveState: saveCorrectionFor(session) });
const findPassingByUndoMarker = (session, rowKey, passingTimestamp) => findPassingByUndoMarkerLogic(session, rowKey, passingTimestamp, { ensureSessionResult });
const undoJudgingAdjustment = (session, adjustmentId) => undoJudgingAdjustmentLogic(session, adjustmentId, { ensureSessionResult, findPassingByUndoMarker, recalculateCompetitorFromPassings, uid, t, saveState: saveCorrectionFor(session) });
const getJudgeFilteredRows = (rows, filterValue) => getJudgeFilteredRowsLogic(rows, filterValue);
const getJudgeFilteredLog = (adjustments, filterValue) => getJudgeFilteredLogLogic(adjustments, filterValue);
const NAV_ITEMS = [
{ id: "dashboard", titleKey: "nav.dashboard", subtitleKey: "nav.dashboard_sub", groupKey: "nav.group_start" },
{ id: "race_day", titleKey: "nav.race_day", subtitleKey: "nav.race_day_sub", groupKey: "nav.group_start" },
{ id: "race_setup", titleKey: "nav.race_setup", subtitleKey: "nav.race_setup_sub", groupKey: "nav.group_create" },
{ id: "events", titleKey: "nav.events", subtitleKey: "nav.events_sub", groupKey: "nav.group_create" },
{ id: "series", titleKey: "nav.series", subtitleKey: "nav.series_sub", groupKey: "nav.group_create" },
{ id: "timing", titleKey: "nav.timing", subtitleKey: "nav.timing_sub", groupKey: "nav.group_run" },
{ id: "judging", titleKey: "nav.judging", subtitleKey: "nav.judging_sub", groupKey: "nav.group_run" },
{ id: "overlay", titleKey: "nav.overlay", subtitleKey: "nav.overlay_sub", groupKey: "nav.group_run" },
{ id: "training", titleKey: "nav.training", subtitleKey: "nav.training_sub", groupKey: "nav.group_run" },
{ id: "archive", titleKey: "nav.archive", subtitleKey: "nav.archive_sub", groupKey: "nav.group_run" },
{ id: "classes", titleKey: "nav.classes", subtitleKey: "nav.classes_sub", groupKey: "nav.group_register" },
{ id: "drivers", titleKey: "nav.drivers", subtitleKey: "nav.drivers_sub", groupKey: "nav.group_register" },
{ id: "cars", titleKey: "nav.cars", subtitleKey: "nav.cars_sub", groupKey: "nav.group_register" },
{ id: "settings", titleKey: "nav.settings", subtitleKey: "nav.settings_sub", groupKey: "nav.group_system" },
{ id: "guide", titleKey: "nav.guide", subtitleKey: "nav.guide_sub", groupKey: "nav.group_system" },
];
const SESSION_TYPES = ["open_practice", "free_practice", "practice", "qualification", "heat", "final", "team_race"];
function getSessionTypeChoices(mode) {
return mode === "track" ? SESSION_TYPES.filter((type) => type !== "team_race") : SESSION_TYPES;
}
const STORAGE_KEY = "rc_timing_control_v1";
let localCacheFull = false;
const DEFAULT_LANGUAGE = "sv";
const DEFAULT_THEME = "dark";
const AVAILABLE_THEMES = ["dark", "nord", "light"];
const EXPORT_SCHEMA_VERSION = 2;
const TRANSLATIONS = {
sv: {
"nav.dashboard": "Översikt",
"nav.dashboard_sub": "Status och liveinformation",
"nav.race_day": "Race Day",
"nav.race_day_sub": "Förkontroll, heat-kö och racedrift",
"race_day.current": "Pågår / vald",
"race_day.next": "Nästa",
"race_day.after_next": "Därefter",
"race_day.none": "Ingen",
"race_day.no_session": "Ingen session vald",
"race_day.no_session_hint": "Skapa sessioner i Race Setup och välj sedan heat här.",
"race_day.control": "Race Control",
"race_day.control_hint": "Starta endast när förkontrollen är grön. Avancerade inställningar ligger kvar i Race Setup.",
"race_day.ready": "Klar för start",
"race_day.not_ready": "Start blockerad",
"race_day.activate": "Välj session",
"race_day.finish": "Avsluta heat",
"race_day.start_list": "Startlista",
"race_day.live_title": "Live: {name}",
"race_day.live_title_done": "Resultat: {name}",
"race_day.live_hint": "Uppdateras varje sekund. Lila = heatets snabbaste varv, grönt = personbästa på senaste varvet, stapeln = hur långt in på varvet bilen är (röd = sen).",
"race_day.live_pos": "Pos",
"race_day.live_driver": "Förare",
"race_day.live_laps": "Varv",
"race_day.live_last": "Senaste",
"race_day.live_best": "Bästa",
"race_day.live_gap": "Till bilen före",
"race_day.live_leader": "Till ledaren",
"race_day.live_estimate": "Beräknat slut",
"race_day.live_result": "Resultat",
"race_day.live_seed": "Seedning",
"race_day.live_empty": "Inga varv ännu.",
"race_day.no_start_list": "Ingen startlista finns för sessionen.",
"sync.connecting": "Ansluter till servern",
"sync.connected": "Server ansluten",
"sync.saved": "Ändringar sparade",
"sync.pending": "Ändringar väntar på sparning",
"sync.saving": "Sparar till servern…",
"sync.error": "Sparning misslyckades",
"sync.offline": "Serveranslutning saknas",
"sync.stale": "Serverstatus är inaktuell",
"sync.retry": "Försök igen",
"sync.loaded": "Data hämtad {time}",
"sync.saved_at": "Sparat {time}",
"sync.stale_hint": "Visad data kan vara inaktuell.",
"race_day.preflight": "Förkontroll",
"race_day.check_summary": "{blockers} blockerar start · {warnings} varningar",
"race_day.heat_queue": "Heat-kö",
"race_day.select": "Välj",
"race_day.open_practice_any": "Alla inkommande transpondrar tillåts",
"race_day.count": "{count} registrerade",
"race_day.missing_count": "{count} saknar transponder",
"race_day.not_required": "Krävs inte",
"race_day.check_ok": "OK",
"race_day.check_warning": "Kontrollera före start",
"race_day.check_error": "Måste åtgärdas",
"race_day.check_session": "Session vald",
"race_day.check_backend": "Backend och automatisk backup",
"race_day.check_decoder_clock": "Decoderns klocka",
"race_day.decoder_clock_ahead": "{amount} före datorn – ställ in rätt tid i decodern (sommar-/vintertid?). Första varvet i ett heat och passen i mobilprofilen blir fel.",
"race_day.decoder_clock_behind": "{amount} efter datorn – ställ in rätt tid i decodern (sommar-/vintertid?). Första varvet i ett heat och passen i mobilprofilen blir fel.",
"race_day.check_decoder": "Main decoder",
"race_day.check_split_decoder": "Mellantidsdecoder",
"race_day.check_pit_decoders": "Depådecoders",
"race_day.check_lap_window": "Min/max varvtid",
"race_day.check_participants": "Deltagare",
"race_day.check_transponders": "Transpondrar",
"race_day.check_duplicate_transponders": "Dubbla transpondrar",
"race_day.check_duplicate_team_members": "Förare/bil i flera lag",
"race_day.check_grid": "Startgrid",
"race_day.check_audio": "Raceljud",
"race_day.lap_window_edit": "Justera varvgränser",
"race_day.lap_window_hint": "Min underkänner shortcuts. Max avslutar statistikstinten men varvet räknas fortfarande i racet. Gäller nya passeringar.",
"race_day.min_lap_sec": "Min sek",
"race_day.max_lap_sec": "Max sek",
"race_day.lap_window_invalid": "Max måste vara större än min och båda måste vara positiva.",
"race_day.backup_failed_confirm": "Automatisk backup misslyckades: {msg}\n\nStarta ändå?",
"race_day.start_failed": "Sessionen kunde inte startas.",
"nav.group_start": "Start",
"nav.group_create": "Skapa",
"nav.group_run": "Kör och följ",
"nav.group_register": "Register",
"nav.group_system": "System och hjälp",
"nav.events": "Sponsor Event",
"nav.events_sub": "Sponsor-event och delade bilar",
"nav.series": "Serier / cup",
"nav.series_sub": "Poäng över flera race",
"series.title": "Serier och cuper",
"series.hint": "Samla flera race i en serie med poäng per placering. Välj klasser, poängtabell och hur många resultat som räknas. Ställningen räknas per klass.",
"series.new": "Ny serie",
"series.new_name": "Serie {year}",
"series.none": "Inga serier ännu.",
"series.unnamed": "Namnlös serie",
"series.settings": "Inställningar",
"series.step1": "1 · Namn och klasser",
"series.step1_hint": "Bocka i klasserna som ingår. Varje klass får en egen ställning.",
"series.step2": "2 · Poäng",
"series.step2_hint": "Vem som får poäng, poängtabell och hur många resultat som räknas.",
"series.step3": "3 · Deltävlingar ({count})",
"series.step4": "4 · Ställning",
"series.classes_all": "Alla",
"dashboard.quick_title": "Vanliga uppgifter",
"dashboard.quick_practice": "Starta träning",
"dashboard.quick_practice_hint": "Fortsätter pågående Open Practice eller startar en ny - direkt till Race Day.",
"dashboard.quick_race": "Skapa race",
"dashboard.quick_race_hint": "Kval och finaler för en tävling.",
"dashboard.quick_series": "Skapa serie",
"dashboard.quick_series_hint": "Flera deltävlingar med poäng och ställning.",
"timing.run_on_race_day": "Starta, pausa, avsluta och ny träningsdag görs på Race Day.",
"timing.open_race_day": "Gå till Race Day",
"race_day.quick_title": "Snabbval",
"race_day.start_practice": "Starta träning",
"race_day.pause_practice": "Pausa",
"race_day.resume_practice": "Fortsätt",
"race_day.finish_practice": "Avsluta träning",
"race_day.quick_practice_new": "Starta träning",
"race_day.quick_practice_continue": "Fortsätt träning: {name}",
"race_day.quick_practice_show": "Pågående träning: {name}",
"race_day.quick_layout": "Ny banlayout",
"race_day.quick_race": "Skapa race",
"race_day.pick_session": "Session",
"race_day.show_all_sessions": "Visa alla sessioner",
"race_day.go_next": "Nästa: {name}",
"race_day.hidden_sessions": "({count} från andra dagar dolda)",
"race_day.restart_session": "Kör om",
"race_day.reset_session_hint": "Avbrutet eller klart heat, kval eller final: varv, resultat och klocka nollställs och den kan startas igen.",
"race_day.reset_session_confirm": "Kör om \"{name}\"?\n\nAlla varv och resultat nollställs och klockan står på noll - sedan trycker du Starta. Det går inte att ångra.",
"race_day.new_practice_day": "Nollställ – ny träningsdag",
"race_day.new_practice_day_hint": "Nollställer dagens varv i tidtagningen. Alla varv finns kvar i träningsstatistiken.",
"race_day.new_practice_day_confirm": "Starta en ny träningsdag i \"{name}\"?\n\nDagens varv nollställs i tidtagningen (topplistan börjar om). Alla varv finns kvar i träningsstatistiken.",
"timing.live_elsewhere": "Varv registreras just nu på \"{name}\", som pågår - inte på den valda sessionen.",
"timing.show_live": "Visa den",
"overlay.obs_show_position_change": "Placering sedan start (▲/▼) i race",
"overlay.position_change_title": "Placeringar vunna (▲) eller förlorade (▼) sedan starten",
"settings.public_address_title": "Publik adress (domän / DynDNS)",
"settings.public_address_hint": "Gäller alla förares mobilprofiler: länkar och QR-koder byggs med den här adressen, t.ex. https://klubben.dyndns.org eller https://klubben.se:8443. Lämna tomt för att använda datorns adress i det lokala nätverket (fungerar bara på samma wifi).",
"settings.public_address_in_use": "Används nu: {url}",
"settings.public_address_local": "Ingen publik adress - länkar och QR-koder använder datorns lokala nätverksadress.",
"training.public_address_local": "lokala nätverket (ingen publik adress satt)",
"training.public_address_change": "Ändra under Inställningar",
"series.round_participants": "Deltagare: {count} av {total} i klassen",
"series.copy_previous": "Kopiera från förra",
"series.no_previous_round": "Ingen tidigare deltävling i samma klass.",
"series.no_class_drivers": "Inga förare i klassen ännu - lägg till nedan.",
"series.new_driver_name": "Ny förare - namn",
"series.add_driver": "Lägg till",
"series.no_rounds": "Inga deltävlingar ännu - skapa dem ovan.",
"series.col_date": "Datum",
"series.col_race": "Race",
"series.col_drivers": "Förare",
"series.col_qual": "Kvalomgångar",
"series.col_qual_short": "Kval",
"series.col_qual_hint": "Antal kvalomgångar. Antalet heat per omgång räknas ut av antalet förare.",
"series.col_finals": "Finaler",
"series.col_per_heat": "Max bilar/heat",
"series.col_status": "Status",
"series.base_format": "Format",
"series.seed_practice": "Seedningsträning före kval",
"series.seed_practice_min": "Träning, minuter",
"series.seed_method": "Seedas på",
"series.seed_laps": "Antal varv (N)",
"series.seed_best_lap": "Bästa enskilda varv",
"series.seed_practice_name": "Seedningsträning",
"series.seed_hint": "Varje deltävling får en träning först. \"Generera kval\" delar sedan in heaten efter träningstiderna, så att lika snabba förare kör tillsammans. \"Reseeda kommande kval\" i tävlingen delar om efter kvalrankingen.",
"series.make_qualifying": "Skapa kval",
"series.make_finals": "Skapa finaler",
"series.open_race": "Öppna",
"series.result_button": "Resultat",
"series.result_title": "Rätta deltävlingens resultat",
"series.result_hint": "Sätt rätt slutordning för dagen, vinnaren först. Den ersätter appens uträkning i ställningen, t.ex. när kvalet blev fel. Förare som inte står med får inga poäng för deltävlingen.",
"series.result_up": "Flytta upp",
"series.result_down": "Flytta ned",
"series.result_remove": "Ta bort",
"series.result_add": "Lägg till förare",
"series.result_save": "Spara resultat",
"series.result_clear": "Använd appens resultat",
"series.result_clear_confirm": "Ta bort det rättade resultatet och räkna deltävlingen från heaten igen?",
"series.result_manual": "Rättat resultat",
"series.remove_round": "Ta bort ur serien (racet finns kvar)",
"series.remove_round_confirm": "Ta bort deltävlingen ur serien? Racet och dess resultat finns kvar.",
"series.no_participants": "Välj minst en förare först (klicka på antalet förare).",
"series.heats_made": "{heats} heat per omgång",
"series.status_not_started": "Ej startad",
"series.status_qual_ready": "Kval skapat",
"series.status_qual_running": "Kval pågår",
"series.status_qual_done": "Kval klart",
"series.status_finals": "Finaler",
"series.status_done": "Klar",
"series.add_existing": "Lägg till ett befintligt race",
"series.add_existing_pick": "Välj race ...",
"series.no_date": "utan datum",
"series.delete": "Ta bort serien",
"series.classes_none": "Inga",
"series.classes_hint": "{count} valda.",
"series.autosave": "Ändringar sparas direkt.",
"series.name": "Namn",
"series.name_placeholder": "t.ex. Winter Championship 2026/2027",
"series.scoring": "Vem får seriepoäng",
"series.scoring_all": "Alla förare (öppen serie)",
"series.scoring_club": "Endast klubbmedlemmar",
"series.club": "Klubb",
"series.club_placeholder": "t.ex. Östersunds RC",
"series.club_hint": "Förare från andra klubbar kör och syns i dagens resultat men får inga seriepoäng; medlemmarna rangordnas om utan dem. Klubben hämtas från förarregistret.",
"series.subtitle_members": "endast medlemmar i {club}",
"series.classes": "Klasser (en tabell per klass)",
"series.no_classes": "Skapa klasser först under Klasser.",
"series.points_preset": "Poängtabell",
"series.preset_orc": "100, 90, 82, 75, 69 ... (-4, lägst 10)",
"series.preset_hundred": "100, 80, 70, 60, 50 ... (-5, lägst 5)",
"series.preset_f1": "F1: 25, 18, 15, 12, 10 ...",
"series.preset_custom": "Egen",
"series.points_table": "Poäng plats 1, 2, 3 ...",
"series.points_table_hint": "Kommaseparerat, t.ex. 100, 80, 70, 60.",
"series.points_after": "Efter tabellen: minus per plats / lägst",
"series.points_after_hint": "0 / 0 = inga poäng efter tabellen.",
"series.count_mode": "Räknade resultat",
"series.count_best": "Bästa N räknas",
"series.count_drop": "Alla genomförda utom X sämsta",
"series.count_value": "N eller X",
"series.count_hint": "T.ex. bästa 9 av 12, eller stryk 3 (räknar automatiskt om ett race ställs in). Frånvaro = 0 och kan strykas.",
"series.count_rule": "räknas: {rule}",
"series.count_best_value": "bästa {count}",
"series.count_drop_value": "alla utom {count} sämsta",
"series.events": "Deltävlingar ({count})",
"series.events_hint": "Skapa alla deltävlingar på en gång (ett race per datum och klass). Sedan sköts varje deltävling härifrån: välj förare, ändra antal kval och finaler, skapa kval - heaten delas in efter hur många som är med - och sedan finaler.",
"series.no_events": "Inga race i de valda klasserna ännu - skapa dem nedan.",
"series.create_dates": "Skapa deltävlingar för datum",
"series.create_dates_hint": "Ett datum per rad (ÅÅÅÅ-MM-DD). Ett race skapas per datum och vald klass.",
"series.create_dates_invalid": "Ange minst ett datum som ÅÅÅÅ-MM-DD.",
"series.create_events": "Skapa deltävlingar",
"series.pick_classes_first": "Välj minst en klass i steg 1 först.",
"series.standings": "Ställning",
"series.print": "Skriv ut",
"series.starts": "Starter",
"series.total": "Summa",
"series.counted_of": "{counted} räknas av {completed} körda ({total} planerade)",
"series.no_results": "Inga körda deltävlingar ännu.",
"series.legend": "Siffra = seriepoäng. (Inom parentes) = struket resultat. – = deltog inte. Lika poäng: flest segrar, sedan andraplatser osv., sedan senaste gemensamma deltävling.",
"series.delete_confirm": "Ta bort serien \"{name}\"?",
"series.delete_races_confirm": "Ta också bort seriens {count} race från Race Setup, med heat och resultat?\n\nOK = ta bort racen\nAvbryt = behåll racen (t.ex. för resultatarkivet)",
"series.created_rounds": "{count} race skapade. De finns i listan nedan och under Race Setup.",
"series.created_none": "Inga nya race skapades: seriens klasser har redan race på de datumen.",
"series.run_seeding": "Seedningsträning",
"series.run_seeding_groups": "Seedningsträning ({count} grupper)",
"series.seed_group_size": "Max förare per seedningsgrupp",
"series.col_seed_group": "Max förare/seedgrupp",
"series.col_seed_group_hint": "Max antal förare i varje seedningsgrupp, inte antal grupper: 10 förare med 5 ger 2 grupper (0 = alla i samma). Grupperna delas efter serieställningen när du trycker ▶ Seedningsträning.",
"series.run_session": "Kör {name}",
"series.show_live": "Pågår: {name}",
"series.skip_seeding": "Hoppa över – generera kval",
"series.run_hint": "Väljer sessionen och öppnar Race Day – där trycker du Starta.",
"nav.race_setup": "Race Setup",
"nav.race_setup_sub": "Open Practice, klubbrace och endurance",
"nav.overlay": "Overlay",
"nav.overlay_sub": "Extern leaderboard-skärm",
"nav.classes": "Klasser",
"nav.classes_sub": "Hantera tävlingsklasser",
"nav.drivers": "Förare",
"nav.drivers_sub": "Förare och personliga transpondrar",
"nav.cars": "Bilar",
"nav.cars_sub": "Bilar med fasta transpondrar",
"nav.training": "Träningsstatistik",
"nav.training_sub": "Utveckling, delmål och belöningar per förare",
"nav.archive": "Resultatarkiv",
"nav.archive_sub": "Sök avslutade race utan att gå via Race Setup",
"archive.title": "Resultatarkiv",
"archive.hint": "Sök bland alla avslutade sessioner efter datum, klass eller förare.",
"archive.search": "Sök",
"archive.search_placeholder": "Event- eller sessionsnamn",
"archive.class": "Klass",
"archive.all_classes": "Alla klasser",
"archive.driver": "Förare",
"archive.all_drivers": "Alla förare",
"archive.date_from": "Från datum",
"archive.date_to": "Till datum",
"archive.date": "Datum",
"archive.event": "Event",
"archive.session": "Session",
"archive.layout": "Layout",
"archive.drivers": "Förare",
"archive.winner": "Vinnare",
"archive.penalties_short": "Straff",
"archive.view": "Visa",
"archive.no_results": "Inga avslutade sessioner matchar filtren.",
"archive.standings": "Resultat",
"archive.no_standings": "Inga resultat registrerade.",
"archive.penalties": "Straff och korrigeringar",
"archive.action": "Åtgärd",
"archive.detail": "Detalj",
"archive.no_penalties": "Inga straff eller korrigeringar registrerade för den här sessionen.",
"archive.adjustment_correction": "Korrigering",
"archive.adjustment_invalid": "Ogiltigförklaring",
"archive.adjustment_undo": "Ångrad",
"archive.lap_history": "Varvhistorik per förare",
"archive.close": "Stäng",
"archive.export_pdf": "Exportera PDF",
"archive.export_json": "Exportera racepaket (JSON)",
"nav.timing": "Tidtagning",
"nav.timing_sub": "Live timing-board",
"nav.judging": "Domare",
"nav.judging_sub": "Korrigeringar och penalties",
"nav.settings": "Inställningar",
"nav.settings_sub": "Decoder, backend och lagring",
"nav.guide": "Guide",
"nav.guide_sub": "Dokumentation och uppstart",
"ui.language": "Språk",
"ui.theme": "Tema",
"ui.theme_dark": "RaceCore",
"ui.theme_nord": "Nord",
"ui.theme_light": "Ljus",
"brand.title": "RC RaceCore",
"brand.subtitle": "Live Timing & Race Control",
"ui.no_active_session": "Ingen aktiv session",
"ui.event": "Event",
"ui.decoder_online": "Decoder online",
"ui.decoder_offline": "Decoder offline",
"training.eyebrow": "Förarutveckling",
"training.intro": "Följ träning över flera sessioner och gör utvecklingen synlig mellan tävlingarna.",
"training.overview_title": "Träningsöversikt",
"training.overview_intro": "Se klubbens registrerade träning per förare och klass. Välj en förare för personliga mål, rekommendationer och detaljerad statistik.",
"training.select_driver": "Välj förare...",
"training.back_overview": "Till översikten",
"training.registered_drivers": "Registrerade förare",
"training.active_drivers": "Förare med träning",
"training.profile_count_note": "Unika förarprofiler",
"training.with_training_data": "Med giltiga träningsvarv",
"training.overview_class_hint": "Varje klass visas separat så att exempelvis 2WD och 4WD aldrig blandas i varvtider eller statistik.",
"training.driver": "Förare",
"training.class": "Klass",
"training.no_drivers_title": "Ingen förare registrerad",
"training.no_drivers_body": "Skapa en förare först. Träningsstatistik kräver en registrerad förare på passeringarna.",
"training.total_laps": "Totala varv",
"training.valid_laps": "Giltiga registrerade varv",
"training.sessions": "Sessioner",
"training.recorded_sessions": "Med registrerade förarvarv",
"training.best_lap": "Bästa varv",
"training.personal_best": "Personbästa i sparad data",
"training.consistency": "Spridning",
"training.last_30_laps": "P10-P90, senaste 30 varven",
"training.recommendation": "Rekommenderat träningspass",
"training.plan_baseline_title": "Bygg en baslinje",
"training.plan_baseline_body": "Kör lugnt och jämnt tills minst 10 rena varv är registrerade. Fokusera på samma linje och bromspunkt varje varv.",
"training.plan_consistency_title": "Höj din lägstanivå",
"training.plan_consistency_body": "Spridningen är hög. Kör första blocket nära max, sedan ett kontrollerat block på 80-90 procent där rena, repeterbara varv är viktigare än ett enstaka snabbt varv.",
"training.plan_progression_title": "Balansera fart och kontroll",
"training.plan_progression_body": "Du har en stabil grund. Kör ett block med maxfokus och avsluta med ett kontrollerat block där målet är en obruten serie jämna varv.",
"training.plan_target": "Kontrollmål omkring {lap}",
"training.plan_no_target": "Registrera fler varv för tidsmål",
"training.block_push": "Maxfokus: hitta gränsen",
"training.block_control": "80-90%: höj lägstanivån",
"training.flexible_duration": "Valbar tid",
"training.block_one": "Block 1",
"training.block_two": "Block 2",
"training.new_goal": "Nytt delmål",
"training.manage_goals_sharing": "Mål och mobilprofil",
"training.manage_goals_sharing_hint": "Skapa belöningsmål eller hantera förarens delningslänk.",
"training.target_laps": "Antal varv",
"training.quick_targets": "Snabbval för antal varv",
"training.goal_type": "Måltyp",
"training.goal_type_laps": "Antal varv",
"training.goal_type_evenLaps": "Genomförda Jämna varv-pass",
"training.goal_type_stepTraining": "Genomförda Stegträning-pass",
"training.goal_type_timer": "Genomförda träningspass (timer)",
"training.target_sessions": "Antal pass",
"training.exercise_kind_timer": "Träningspass",
"training.exercise_kind_evenLaps": "Jämna varv",
"training.exercise_kind_stepTraining": "Stegträning",
"training.exercise_history_title": "Genomförda träningspass",
"training.exercise_history_hint": "Jämna varv, Stegträning och vanliga träningspass som föraren genomfört - se utvecklingen över tid.",
"training.exercise_history_empty": "Inga genomförda träningspass ännu för den här föraren och klassen.",
"training.exercise_history_evenLaps": "Serie på {streak} varv i mål {lap}",
"training.exercise_history_stepTraining": "{steps} steg, {laps} varv",
"training.exercise_history_timer": "{laps} varv, snitt {lap}",
"training.goal_name": "Namn på delmålet",
"training.goal_name_placeholder": "Till exempel Bronsnivå",
"training.reward": "Belöning",
"training.reward_placeholder": "Till exempel ny kaross eller klubbmärke",
"training.add_goal": "Lägg till delmål",
"training.goals": "Delmål och rewards",
"training.no_goals": "Inga delmål finns för den här föraren ännu.",
"training.default_goal_title": "Nå {laps} varv",
"training.default_goal_title_sessions": "Genomför {count} {kind}-pass",
"training.goal_progress": "Framsteg mot delmål",
"training.goal_remaining": "{laps} varv kvar",
"training.goal_remaining_sessions": "{count} pass kvar",
"training.goal_reached": "Målet är nått",
"training.goal_claimed": "Belöning utdelad",
"training.claim_reward": "Markera belöning utdelad",
"training.training_days": "Träningsdagar",
"training.sessions_count": "{sessions} sparade sessioner",
"training.next_level": "Nästa automatiska nivå",
"training.next_level_target": "Nå {laps} varv",
"training.average_lap": "Snittvarv",
"training.recent_average": "Snitt senaste 30",
"training.controlled_streak": "Flytserie",
"training.control_zone": "Kontrollzon",
"training.outlier_laps": "Avvikande varv",
"training.strong_finishes": "Starka avslutningar",
"training.lap_count": "{laps} varv",
"training.last_activity": "Senaste aktivitet",
"training.no_activity": "Ingen aktivitet ännu",
"training.history": "Träningshistorik per dag",
"training.detailed_stats": "Mer statistik",
"training.detailed_stats_hint": "Tempo per 30 minuter, setupändringar, stintanalys, mellantider, depåstopp och historik.",
"training.pace_30_title": "Tempo per aktivt 30-minutersblock",
"training.pace_30_hint": "Visar bara block med körning. Tempot är ett trimmat snitt så enstaka krascher inte styr hela blocket.",
"training.no_pace_data": "Det finns inte tillräckligt med varv för en tempokarta ännu.",
"training.weekday_pace": "Tempo per veckodag",
"training.weekday_hint": "Visas först efter minst tre träningsdagar och använder bara dagar med körning.",
"training.weekday_needs_days": "Minst tre träningsdagar behövs för en meningsfull jämförelse.",
"training.add_marker": "Markera en biländring",
"training.add_marker_hint": "Markeringen sparas nu för vald förare och klass. Systemet jämför 30 minuter före och efter.",
"training.marker_type": "Typ av ändring",
"training.marker_setup": "Ny setup",
"training.marker_tires": "Bytte däck",
"training.marker_suspension": "Ändrade dämpare",
"training.marker_car": "Bytte bil",
"training.marker_note": "Egen notering",
"training.marker_description": "Beskrivning",
"training.marker_placeholder": "Till exempel mjukare framfjädrar",
"training.mark_now": "Markera ändring nu",
"training.no_markers": "Inga setupmarkörer finns i den här klassen.",
"training.marker_collecting": "Samlar underlag ({before} före / {after} efter)",
"training.marker_improved": "{lap} snabbare efter ändringen",
"training.marker_slower": "{lap} långsammare efter ändringen",
"training.stint": "Stint",
"training.start": "Start",
"training.trimmed_pace": "Normaltempo",
"training.race_pace_10": "Race pace 10",
"training.mistakes": "Avvikande varv",
"training.start_end": "Tempohållning",
"training.strong_finish": "Stark avslutning",
"training.insufficient_data": "För lite data",
"training.no_stints": "Inga stintar finns ännu.",
"training.stint_faster": "{lap} snabbare",
"training.stint_slower": "{lap} långsammare",
"training.stint_same": "Oförändrat",
"training.stint_analysis": "Stintanalys",
"training.stint_analysis_hint": "En passering över inställd max varvtid, eller en paus över två minuter utan maxgräns, startar en ny stint. Övergångsvarvet räknas i race men inte i pace. 5-min resultat visar 300 sekunder plus sista påbörjade varvet.",
"training.best_stint": "Bästa stint {stint}: {laps} varv, {pace}",
"training.stint_five_minute": "5-min resultat",
"training.stint_duration": "Stintlängd",
"training.average_short": "snitt",
"training.show_all_stints": "Visa alla {count} stintar",
"training.stats_method": "Normaltempo använder trimmat snitt. Avvikande varv är varv mer än 15% långsammare än stintens median. Stark avslutning betyder att sluttempot är minst 99% av starttempot. Minst 3 varv krävs för jämnhet och 10 för Race pace 10.",
"training.split_passings": "Mellantidspasseringar",
"training.best_split": "Bästa mellantid",
"training.latest_sector_gain": "Senaste sektorförbättring",
"training.average_split": "Snitt mellantid",
"training.pit_stops": "Depåstopp",
"training.total_pit_time": "Total depåtid",
"training.average_pit_stop": "Snitt depåstopp",
"training.best_pit_stop": "Bästa depåstopp",
"training.recent_pit_stops": "Senaste depåstopp",
"training.no_history": "Ingen träningshistorik finns ännu.",
"training.date": "Datum",
"training.laps": "Varv",
"training.pb_improvement": "Senaste 30: {lap} snabbare",
"training.public_profile": "Mobilprofil för förare",
"training.public_profile_active": "Aktiv",
"training.public_profile_off": "Avstängd",
"training.public_profile_help": "Skapa en personlig mobilvy med träningsstatistik, mål, belöningar, träningstimer och en begränsad biländringsmarkör.",
"training.public_profile_private": "Länken innehåller en unik hemlig nyckel. Den visar inte transponder-ID, övriga förare eller adminfunktioner.",
"training.public_sections": "Synligt i mobilprofilen",
"training.public_sections_hint": "Valen sparas direkt. Avstängda sektioner skickas inte till den publika profilen.",
"training.public_section_progress": "Utveckling och graf",
"training.public_section_achievements": "Utmärkelser",
"training.public_section_performance": "Stints och prestation",
"training.public_section_goals": "Mål och belöningar",
"training.public_section_history": "Träningshistorik",
"training.public_profile_link": "Personlig delningslänk",
"training.public_base_url": "Publik adress eller FQDN",
"training.public_base_url_hint": "Exempel: https://jmkrb.myddns.rocks. Lämna tomt för adressen där RaceCore öppnades.",
"training.save_public_url": "Spara adress",
"training.detect_public_ip": "Hämta publik IP",
"training.detecting_public_ip": "Kontrollerar publik IP...",
"training.detected_public_ip": "Publik IP hittades: {address}. Använd FQDN om certifikatet har ett domännamn och spara.",
"training.detect_public_ip_failed": "Kunde inte hämta publik IP. Fyll i FQDN manuellt.",
"training.public_url_invalid": "Ange en komplett http- eller https-adress.",
"training.local_profile_qr": "Lokal QR-kod",
"training.local_profile_qr_hint": "RaceCore-serverns LAN-adress",
"training.public_profile_qr": "Publik QR-kod",
"training.public_profile_qr_hint": "Lokal QR fungerar på samma nätverk. Publik QR använder sparad FQDN eller publik IP.",
"training.copy_link": "Kopiera länk",
"training.open_profile": "Öppna profil",
"training.replace_link": "Skapa ny länk",
"training.disable_profile": "Stäng av profil",
"training.enable_profile": "Aktivera mobilprofil",
"training.replace_link_confirm": "Den gamla länken slutar fungera direkt. Vill du skapa en ny?",
"training.club_progress": "Klubbens träningsöversikt",
"training.club_progress_hint": "Följ aktivitet, totalvarv och nästa personliga mål utan inbördes ranking.",
"training.next_target": "Nästa mål",
"training.start_personal": "Öppna personlig träning",
"training.copy_mobile_link": "Kopiera mobillänk",
"training.create_personal_link": "Skapa personlig träningslänk",
"training.live_now": "Live just nu",
"training.active_practice": "Aktiv träning",
"training.shared_practice": "Gemensam practice",
"training.session_laps": "Varv i passet",
"training.latest_lap": "Senaste varv",
"training.live_practice_hint": "Alla kan fortsätta köra i samma Open/Free Practice. Kortet visar bara den valda förarens giltiga varv sedan den aktuella sessionen startades.",
"training.evenlaps_eyebrow": "Övning",
"training.evenlaps_title": "Jämna varv",
"training.evenlaps_hint": "Ställ in en måltid och tolerans nedan för att börja. Varje varv inom toleransen bygger på serien.",
"training.evenlaps_streak": "{current}/{target} jämna varv",
"training.evenlaps_new_streak": "Ny serie – försök slå din bästa",
"training.evenlaps_start_hint": "Kör ditt första varv för att starta en serie.",
"training.evenlaps_best_today": "Bästa serie idag: {best}",
"training.evenlaps_target": "Måltid",
"training.evenlaps_last_lap": "Senaste varv",
"training.evenlaps_target_label": "Måltid (sekunder)",
"training.evenlaps_tolerance_label": "Tolerans ± (sekunder)",
"training.evenlaps_lapcount_label": "Antal varv i serien",
"training.evenlaps_save": "Spara",
"training.evenlaps_suggestion_hint": "Förslag baserat på ditt bästa varv: {lap}",
"training.steptraining_eyebrow": "Övning",
"training.steptraining_title": "Stegträning",
"training.steptraining_hint": "Bygg din stegserie nedan för att börja. Standard är den klassiska pyramiden: lugnt, kontrollerat, snabbt, kontrollerat, lugnt.",
"training.steptraining_complete": "Serien klar – bra jobbat!",
"training.steptraining_current": "Steg {step}/{total}: {effort}",
"training.steptraining_remaining": "{laps} varv kvar",
"training.steptraining_controlled_compare": "Kontrollerat steg 1: {first} · Kontrollerat steg 2: {last} ({diff})",
"training.steptraining_config_hint": "Ange 0 varv för att hoppa över ett steg. Lugnt/kontrollerat/snabbt är en känsla, inte en exakt tid – systemet kan inte mäta hur hårt du kör.",
"training.steptraining_save": "Spara",
"training.steptraining_effort_calm": "Lugnt",
"training.steptraining_effort_controlled": "Kontrollerat",
"training.steptraining_effort_fast": "Snabbt",
"training.stints": "Stints",
"training.best_three": "Bästa 3 sammanhängande",
"training.best_five": "Bästa 5 min",
"training.five_avg_pace": "Avg pace, bästa 5 min",
"training.your_progress": "Din egen kurva",
"training.recent_trend": "Utveckling senaste varven",
"training.pace_trend": "Snittempo",
"training.consistency_trend": "Jämnhet",
"training.trend_collecting": "Samlar jämförbart underlag",
"training.trend_collecting_short": "Minst 20 varv behövs",
"training.trend_faster": "{lap} snabbare per varv",
"training.trend_slower": "{lap} långsammare just nu",
"training.trend_stable": "Stabil nivå",
"training.consistency_better": "{value} procentenheter jämnare",
"training.consistency_building": "Fortsätt bygga jämnhet",
"training.trend_hint": "Jämför de senaste 30 giltiga varven med de föregående 30 i samma klass. Det här är personlig utveckling, inte en jämförelse mot andra förare.",
"training.personal_credit": "Framsteg som räknas",
"training.achievements": "Achievements",
"training.achievement_unlocked": "Upplåst",
"training.achievement_next": "Nästa delmål",
"training.achievement_empty": "Kör första passet för att börja samla achievements.",
"training.achievement_first_session": "Första träningspasset",
"training.achievement_laps_100": "100 träningsvarv",
"training.achievement_laps_250": "250 träningsvarv",
"training.achievement_laps_500": "500 träningsvarv",
"training.achievement_laps_1000": "1 000 träningsvarv",
"training.achievement_laps_1500": "1 500 träningsvarv",
"training.achievement_days_3": "3 träningsdagar",
"training.achievement_days_10": "10 träningsdagar",
"training.achievement_sessions_5": "5 fullföljda träningspass",
"training.achievement_controlled_5": "5 kontrollerade varv i rad",
"training.achievement_controlled_10": "10 kontrollerade varv i rad",
"training.achievement_five_minute": "Fullföljd femminutersstint",
"training.achievement_five_minutes_3": "3 fullföljda femminutersstintar",
"training.achievement_consistency_5": "Jämnhet under 5 procent",
"training.achievement_strong_finish": "Stark avslutning",
"training.achievement_clean_five_minute": "Fem minuter utan avvikande varv",
"training.achievement_pace_gain": "Förbättrat snittempo",
"training.credit_eyebrow": "Din träning räknas",
"training.credit_today_title": "Bra jobbat, {driver}!",
"training.credit_today_body": "Varje genomfört varv bygger erfarenhet. Här är det du ska ta med dig från dagens körning.",
"training.credit_ready_title": "Redo när du är, {driver}",
"training.credit_ready_body": "Du behöver inte slå någon annan. Börja med ett lugnt varv och bygg vidare därifrån.",
"training.highlight_today_laps": "{laps} giltiga varv idag",
"training.highlight_personal_best": "Personbästat förbättrat med {lap}",
"training.highlight_pace_gain": "Snittempot förbättrat med {lap} per varv",
"training.highlight_consistency_gain": "{value} procentenheter jämnare körning",
"training.highlight_controlled_streak": "{laps} kontrollerade varv i rad idag",
"training.highlight_five_minute": "{count} fullföljd femminutersstint idag",
"training.highlight_sector_gain": "Sektortiden förbättrad med {lap}",
"training.highlight_strong_finish": "{count} stark avslutning idag",
"training.highlight_clean_five_minute": "{count} femminuterspass utan avvikande varv",
"training.highlight_keep_building": "{laps} varv har redan byggt din erfarenhet",
"training.highlight_ready": "Första giltiga varvet startar din utvecklingsresa",
"training.optional_challenges": "Valfritt, ingen press",
"training.daily_missions": "Dagens utmaningar",
"training.daily_missions_hint": "Tre små mål som nollställs varje dag. De ger kredit för mängd, kontroll och uthållighet i vald klass.",
"training.mission_laps_today": "Samla 20 varv",
"training.mission_controlled_today": "Kör 5 kontrollerade varv i rad",
"training.mission_five_minute_today": "Fullfölj en femminutersstint",
"training.mission_progress": "{current} / {target}",
"training.together": "Alla bidrar",
"training.club_goal": "Klubbens gemensamma mål",
"training.club_goal_active": "Gemensam utmaning",
"training.club_goal_reached": "Målet är nått",
"training.club_goal_celebrated": "Målet är firat",
"training.club_goal_default": "Tillsammans till {laps} varv",
"training.club_goal_default_sessions": "Tillsammans till {count} {kind}-pass",
"training.club_goal_remaining": "{laps} klubbvarv kvar",
"training.club_goal_remaining_sessions": "{count} klubbpass kvar",
"training.club_goal_empty": "Starta ett gemensamt mål där varje giltigt träningsvarv från alla förare räknas.",
"training.club_goal_create": "Skapa klubbmål",
"training.club_goal_new": "Starta ett nytt klubbmål",
"training.club_goal_name_placeholder": "Till exempel Klubben mot 10 000",
"training.club_goal_reward_placeholder": "Till exempel gemensam pizzakväll",
"training.club_goal_start": "Starta klubbmålet",
"training.club_goal_baseline_hint": "Målet börjar på noll när det sparas. Tidigare träningsvarv ligger kvar i statistiken men räknas inte i det nya klubbmålet.",
"training.club_goal_mark_celebrated": "Markera som firat",
"training.club_goal_delete": "Ta bort klubbmålet",
"training.progress_feed": "Klubbens senaste framsteg",
"training.progress_not_positions": "Utveckling, inte placering",
"training.feed_personal_best": "nytt PB, {lap} förbättring",
"training.feed_average_gain": "snittet förbättrat med {lap}",
"training.feed_five_minute": "fullföljde 5 minuter med {laps} varv",
"training.feed_controlled_streak": "{laps} kontrollerade varv i rad",
"training.feed_practice_laps": "{laps} giltiga träningsvarv",
"training.feed_empty": "När förare börjar träna visas deras personliga framsteg här.",
"mode.track": "Sponsor Event",
"mode.race": "Race",
"dashboard.events": "Event",
"dashboard.drivers": "Förare",
"dashboard.cars": "Bilar",
"dashboard.passings": "Passeringar",
"dashboard.created": "Skapade",
"dashboard.registered": "Registrerade",
"dashboard.track_fleet": "Banans bilar",
"dashboard.captured": "Mottagna",
"dashboard.live_session": "Live-session",
"dashboard.idle": "inaktiv",
"dashboard.duration": "Tid",
"dashboard.no_session": "Ingen session är aktiv. Gå till Event eller Tidtagning för att starta.",
"dashboard.quick_actions": "Snabbval",
"dashboard.create_event": "Skapa Event",
"dashboard.open_race_day": "Öppna Race Day",
"dashboard.open_timing": "Öppna Tidtagning",
"dashboard.connect_decoder": "Anslut Decoder",
"dashboard.recent_sessions": "Senaste sessioner",
"dashboard.free_practice": "Fri träning",
"dashboard.open_practice": "Open Practice",
"dashboard.live_board": "Live Board",
"dashboard.decoder_feed": "Decoder-feed",
"dashboard.backend_link": "Backend-länk",
"dashboard.audio_profile": "Ljudprofil",
"dashboard.schedule_drift": "Schemaavvikelse",
"dashboard.schedule_plan": "Planerad tid",
"dashboard.schedule_actual": "Faktisk tid",
"dashboard.on_time": "I fas",
"dashboard.ahead": "Före schema",
"dashboard.behind": "Efter schema",
"dashboard.live_note": "Snabb driftpanel för anslutning, overlay och ljud. Djupare konfig ligger kvar under Inställningar.",
"dashboard.get_started": "Kom igång",
"dashboard.get_started_hint": "Följ arbetsordningen första gången. För en vanlig träningskväll räcker knappen Starta träning ovan.",
"dashboard.step_system": "1. Anslut systemet",
"dashboard.step_system_hint": "Konfigurera backend, decoder och AMMC i Inställningar.",
"dashboard.step_register": "2. Lägg in register",
"dashboard.step_register_hint": "Skapa klasser, förare och bilar när du behöver namngivna resultat.",
"dashboard.step_create": "3. Skapa körning",
"dashboard.step_create_hint": "Starta enkel Open Practice eller bygg klubbrace, endurance och sponsor-event.",
"dashboard.step_run": "4. Kör och visa",
"dashboard.step_run_hint": "Starta, pausa och avsluta på Race Day. Följ tiderna i Tidtagning och öppna Overlay på en extern skärm.",
"dashboard.open_settings": "Öppna Inställningar",
"dashboard.open_register": "Öppna Förare",
"dashboard.open_race_setup": "Open Practice / Race Setup",
"dashboard.open_overlay": "Öppna Overlay",
"dashboard.untimed": "Ingen tidsgräns",
"session.none_yet": "Inga sessioner ännu.",
"classes.create": "Skapa klass",
"classes.placeholder": "Klassnamn (t.ex. 2WD Buggy)",
"classes.add": "Lägg till klass",
"classes.title": "Klasser",
"drivers.create": "Skapa förare",
"drivers.name_placeholder": "Förarnamn",
"drivers.brand_placeholder": "Team / märke (valfritt)",
"drivers.brand_filter_placeholder": "Sök namn / transponder / märke / klubb / land",
"drivers.transponder_placeholder": "Personlig transponder (valfritt)",
"drivers.transponder_conflict_confirm": "Transpondern {tp} används redan av {name} ({class}). Spara ändå?",
"drivers.speech_name": "Uttalsnamn",
"drivers.voice_test": "🔊 Testa uttal",
"drivers.speech_name_placeholder": "Uttal för uppläsning (valfritt)",
"drivers.speech_name_hint": "Skriv namnet som rösten ska uttala det, eller ett smeknamn. Lämna tomt för vanligt förarnamn. Testa med 🔊.",
"drivers.training_profile": "Träningsprofil",
"drivers.training_profile_hint": "Länka flera klass- och transponderposter för samma person till en gemensam träningsprofil.",
"drivers.training_profile_auto": "Automatiskt: samma namn eller ny profil",
"drivers.training_profile_new": "Ny separat profil",
"drivers.training_profile_separate": "Koppla loss till ny separat profil",
"drivers.club": "Klubb",
"drivers.club_placeholder": "Klubb (valfritt)",
"drivers.country": "Land",
"drivers.country_placeholder": "Land (valfritt)",
"drivers.add": "Lägg till förare",
"drivers.title": "Förare",
"cars.create": "Skapa bil",
"cars.name_placeholder": "Bilnamn eller nummer",
"cars.brand_placeholder": "Märke / modell (valfritt)",
"cars.brand_filter_placeholder": "Sök namn / transponder / brand",
"cars.transponder_placeholder": "Bilens transponder",
"cars.add": "Lägg till bil",
"cars.title": "Bilar",
"events.create": "Skapa event",
"events.create_race": "Skapa race",
"events.create_competition_race": "Skapa tävlingsrace",
"events.quick_open_practice_title": "Snabbstart Open Practice",
"events.quick_open_practice_intro": "För löpande tidtagning utan raceformat. Skapa sessionen och kör tills du själv stoppar den.",
"events.quick_open_practice_default": "Open Practice",
"events.quick_open_practice_create": "Skapa och öppna Tidtagning",
"events.open_practice_untimed": "Otidsstyrd",
"events.open_practice_all_transponders": "Alla transpondrar",
"events.open_practice_no_registration": "Fungerar utan registrerade förare",
"events.open_practice_until_stopped": "Pågår tills du stoppar den",
"events.name_placeholder": "Eventnamn",
"events.field_name": "Eventnamn",
"events.field_name_hint": "Namnet som visas i listor, overlay och resultat.",
"events.field_date": "Datum",
"events.field_date_hint": "Tävlings- eller eventdatum för planering och sortering.",
"events.field_class": "Klass",
"events.field_class_hint": "Den klass som eventet eller sponsorupplägget tillhör.",
"events.add": "Lägg till event",
"events.add_race": "Lägg till race",
"events.mode_race_option": "Race (förare med egen transponder)",
"events.mode_track_option": "Sponsor Event (delade bilar)",
"events.title": "Event",
"events.race_title": "Race",
"events.list_search": "Sök race…",
"events.list_empty": "Inga race skapade än.",
"events.list_no_date": "Utan datum",
"events.progress_empty": "Inga heat än",
"events.progress_done": "Klar",
"events.progress_next": "Nästa: {name}",
"events.progress_count": "{done}/{total} körda",
"events.group_today": "Idag",
"events.group_upcoming": "Kommande",
"events.group_nothing_planned": "Inget planerat idag eller framåt.",
"events.group_done": "Körda ({count})",
"events.track_only_intro": "Här skapar du sponsor-event med delade bilar/transpondrar.",
"events.race_only_intro": "Här skapar du riktiga race med personlig transponder per förare.",
"events.manage": "Hantera",
"events.open_timing": "Öppna Tidtagning",
"events.edit": "Redigera",
"events.sessions": "Sessioner",
"events.participants": "Deltagare",
"events.select_participants": "Välj racedeltagare",
"events.select_all_participants": "Markera alla",
"events.clear_participants": "Rensa deltagare",
"events.reseed_qualifying": "Reseeda kommande kval",
"events.reseed_done": "Kommande kval heat reseedade från aktuell ranking.",
"events.no_reseed_done": "Inga kommande kval kunde reseedas.",
"events.reseed_locked": "{count} heat hoppades över eftersom manuell grid är låst.",
"events.reseed_mismatched": "Antal deltagare matchar inte längre antal genererade heat i {count} omgång(ar) - generera om kvalet istället för att lita på en delvis reseed.",
"events.dns": "Ej start (DNS)",
"events.reserve_bump_slots": "Reservera bump-platser i finaler",
"events.bump_reserved_note": "Om bump används kan finalgeneratorn reservera platser i högre finaler redan från start.",
"events.actions": "Åtgärder",
"events.manage_title": "Hantera",
"events.wizard_hint": "Bygg upp racet i fyra steg: grunddata, deltagare, sessionsplan och bekräftelse. Finjustering sker sedan i Hantera.",
"events.wizard_step_1": "Grunddata",
"events.wizard_step_2": "Deltagare",
"events.wizard_step_3": "Sessionsplan",
"events.wizard_step_4": "Bekräfta",
"events.wizard_no_class_drivers": "Inga förare finns i vald klass ännu. Lägg upp förare först eller byt klass.",
"events.wizard_create": "Skapa race",
"events.wizard_use_practice": "Skapa practice-sessioner",
"events.wizard_practice_sessions": "Antal practice-sessioner",
"events.wizard_use_qualifying": "Skapa kvalomgångar",
"events.wizard_qualifying_rounds": "Antal kvalomgångar",
"events.wizard_use_team_race": "Skapa endurance / Team Race-session",
"events.wizard_team_duration": "Team Race-längd (min)",
"events.wizard_finals_note": "Finaler skapas senare från kvalrankingen via Race actions, inte direkt i wizard-steget.",
"events.wizard_summary_title": "Nytt race",
"events.wizard_summary_sessions": "Sessioner som skapas",
"events.manage_step_setup": "1. Setup",
"events.manage_step_setup_hint": "Deltagare och lag för just detta race.",
"events.manage_step_format": "2. Format",
"events.manage_step_format_hint": "Practice, kval, finaler och validering.",
"events.manage_step_generate": "3. Generering",
"events.manage_step_generate_hint": "Skapa kval/finaler, reseeda och bump-up.",
"events.manage_step_live": "4. Live / resultat",
"events.manage_step_live_hint": "Grid och standings.",
"events.manage_tab_setup": "Deltagare & lag",
"events.manage_tab_format": "Format",
"events.manage_tab_live": "Live & resultat",
"events.manage_tab_schedule": "Schema & utskrift",
"events.branding": "Branding för detta event",
"events.branding_note": "Lämna fält tomma för att ärva global branding från Inställningar. Logo används i overlay och bäddas in i PDF-export när den kan konverteras.",
"events.brand_name": "Brandnamn",
"events.brand_tagline": "Brandtext",
"events.brand_footer": "PDF-footer",
"events.brand_theme": "PDF-tema",
"events.brand_logo": "Eventlogo",
"events.branding_use_global": "Använd globalt standardtema",
"events.branding_save": "Spara branding",
"events.session_name": "Sessionsnamn",
"events.duration_placeholder": "Längd (min)",
"events.max_cars_placeholder": "Max bilar (valfritt)",
"events.start_mode": "Starttyp",
"events.seed_best_laps": "Seedning bästa varv",
"events.seed_method": "Seedmetod",
"events.seed_method_hint": "Hur bästa varv ska räknas när seedBestLapCount är större än 0.",
"events.seed_method_best_sum": "Bästa N varv, summa",
"events.seed_method_average": "Bästa N varv, snitt",
"events.seed_method_consecutive": "Bästa N konsekutiva varv",
"events.stagger_gap_sec": "Stagger-gap (sek)",
"events.session_settings": "Sessioninställningar",
"events.edit_session": "Inställningar",
"events.move_session_up": "Kör tidigare (flytta upp i körordningen)",
"events.move_session_down": "Kör senare (flytta ned i körordningen)",
"events.start_mode_mass": "Mass-start",
"events.start_mode_position": "Positionsstart",
"events.start_mode_staggered": "Staggered / individuell start",
"events.start_mode_flying": "Flygande start",
"events.seed_best_laps_hint": "0 = av, 2 eller 3 för practice/kval-seedning",
"events.race_format": "Raceformat",
"events.race_format_intro": "Ställ in hur kval och finaler ska skapas och rankas för just detta race.",
"events.setup_mode_basic": "Grundläge",
"events.setup_mode_advanced": "Avancerat",
"events.practice_block": "Practice / kval",
"events.practice_block_hint": "Bygg seedning, kvalomgångar och poäng/tie-break här.",
"events.finals_block": "Finaler",
"events.finals_block_hint": "Styr A/B/C-finaler, starttyp, leg och bump-up.",
"events.rules_block": "Validering och avslut",
"events.rules_block_hint": "Min/max-varv och follow-up påverkar både livekörning och statistik.",
"events.race_summary": "Sammanfattning",
"events.race_summary_hint": "Snabb kontroll av vad som faktiskt kommer att skapas och köras.",
"events.race_summary_preset": "Preset",
"events.race_summary_participants": "Deltagare",
"events.race_summary_created_sessions": "Skapade sessioner",
"events.race_summary_qualifying": "Kvalupplägg",
"events.race_summary_finals": "Finalupplägg",
"events.race_summary_validation": "Varvfönster",
"events.race_summary_follow_up": "Follow-up",
"events.race_summary_focus": "Fokus",
"events.race_summary_generation": "Generering",
"events.race_actions_title": "Race actions",
"events.race_actions_hint": "Generering och reseeding ligger separat från formatinställningarna så setupen blir lättare att läsa.",
"events.export_race_package": "Exportera racepaket",
"events.import_race_package": "Importera racepaket",
"events.race_package_hint": "Exportera eller importera ett enskilt race med dess sessioner, resultat och refererade registerdata.",
"events.context_standard_title": "Klubbrace-läge",
"events.context_standard_hint": "Börja med preset och Grundläge. När deltagare och tider ser rätt ut använder du Race actions för kval, reseeding och finaler.",
"events.context_endurance_title": "Endurance-läge",
"events.context_endurance_hint": "I Grundläge döljs kval- och finalfälten här eftersom endurance normalt byggs runt Team Race. Öppna Avancerat om eventet även ska ha stödheat eller finaler.",
"events.context_rules_title": "Valideringsexempel",
"events.context_rules_hint": "Exempel på kort teknisk bana: 11s min / 60s max. Justera efter verklig varvtid så statistik och stintar blir rimliga.",
"events.status_complete": "Klar",
"events.status_pending": "Väntar",
"events.status_attention": "Åtgärda",
"events.summary_warnings_title": "Kontrollpunkter",
"events.summary_warning_no_participants": "Inga racedeltagare är valda ännu.",
"events.summary_warning_no_sessions": "Inga sessioner finns ännu. Skapa dem i wizarden eller via Race actions.",
"events.summary_warning_no_qualifying": "Inga kvalsessioner finns ännu.",
"events.summary_warning_no_finals": "Inga finalsessioner finns ännu.",
"events.summary_warning_no_teams": "Endurance/Team Race saknar lag. Lägg upp lag i Setup innan körning.",
"events.summary_warning_invalid_lap_window": "Min/max varvtid ser fel ut. Max måste vara större än min.",
"events.detail_drivers": "förare",
"events.detail_teams": "lag",
"events.detail_sessions": "sessioner",
"events.detail_results": "resultat",
"events.detail_active": "aktiva",
"guide.manage_steps_6": "6. Statusbrickorna visar om varje steg är klart, väntar eller behöver åtgärdas. Sammanfattningen till höger visar också varningar om deltagare, lag eller sessioner saknas.",
"guide.manage_steps_7": "7. Klicka på en varning i sammanfattningen för att hoppa direkt till rätt sektion i Hantera i stället för att leta manuellt.",
"guide.manage_steps_8": "8. Stegkorten högst upp fungerar också som snabbhopp. Klicka på Setup, Format, Generering eller Live / resultat för att gå direkt till rätt block - de byter flik automatiskt om blocket ligger bakom en annan flik.",
"guide.manage_steps_9": "9. Hantera-sidan för race är uppdelad i fliken Deltagare & lag, Format, Live & resultat samt Schema & utskrift, i stället för en lång scroll. Track-/sponsorevent har kvar den enkla, oflikade layouten.",
"guide.schedule_title": "Tidsschema för racedagen",
"guide.card_schedule_blurb": "Sätt en starttid och en paus mellan sessioner, så räknas varje sessions klockslag ut automatiskt.",
"guide.videos_title": "Videoguider",
"guide.card_videos_blurb": "Korta berättade skärminspelningar som visar hur man gör de vanligaste sakerna.",
"guide.video_connect_decoder": "Koppla en dekoder",
"guide.video_add_drivers_cars": "Lägga till förare och bilar",
"guide.video_create_race": "Skapa ett race",
"guide.video_run_session": "Köra en session på Race Day",
"guide.video_settings_tabs": "Settings-flikarna",
"guide.video_event_manager_tabs": "Event Manager-flikarna",
"guide.video_event_schedule": "Race day-schemat",
"guide.tab_start": "Kom igång",
"guide.tab_create": "Skapa ett race",
"guide.tab_run": "Köra ett race",
"guide.tab_training": "Träning & resultat",
"guide.tab_series": "Serie / cup",
"guide.series_title": "Serie / cup",
"guide.card_series_blurb": "Samla flera race i en serie med poäng per placering, strukna resultat och ställning per klass.",
"guide.series_create_title": "Skapa en serie",
"guide.series_create_1": "1. Lägg först in klasser och förare (med rätt klass). Ska bara klubbmedlemmar få poäng behöver förarens klubb vara ifylld under Förare.",
"guide.series_create_2": "2. Menyn Serier / cup -> Ny serie. Steg 1: namn och vilka klasser som ingår. Varje klass får en egen ställning, poängen blandas aldrig mellan klasser.",
"guide.series_create_3": "3. Steg 2: vem som får poäng (alla förare, eller endast klubbmedlemmar), poängtabell (t.ex. 100, 90, 82 ... eller egen lista) och hur många resultat som räknas (bästa N, eller alla utom X sämsta).",
"guide.series_create_4": "4. Steg 3: klistra in datumen (ett per rad) och välj format, t.ex. ÖRC Winter (3 kval à 5 min med staggered start där flest varv på tiden vinner, 6 per heat, 3 finaler). Kryssa i Seedningsträning före kval (5 min, bästa 3 varv) och välj heatordning (snabbaste heatet sist). Tryck Skapa deltävlingar: ett race skapas per datum och klass, och knappen säger hur många.",
"guide.series_create_5": "5. Allt sparas direkt när du ändrar något. En befintlig tävling kan också läggas till i serien från listan under tabellen. Tar du bort en serie får du frågan om dess race också ska tas bort från Race Setup.",
"guide.series_day_title": "Varje tävlingsdag",
"guide.series_day_1": "1. Allt görs i tabellen i steg 3, en rad per race (datum och klass).",
"guide.series_day_2": "2. Klicka på antalet förare och bocka ur dem som inte kör. Kopiera från förra tar samma startfält som förra deltävlingen i klassen; Ny förare lägger in en efteranmäld förare och bockar i hen.",
"guide.series_day_3": "3. Ändra vid behov antal kval, finaler och max bilar per heat för just den deltävlingen - det kan skilja mellan deltävlingar och klasser.",
"guide.series_day_4": "4. Knappen på raden visar nästa steg. Börja med ▶ Seedningsträning: den delar dagens förare i seedningsgrupper (max enligt kolumnen Max förare/seedgrupp, efter serieställningen - första deltävlingen i anmälningsordning), väljer första gruppen och öppnar Race Day - tryck Starta. Sedan ▶ Seedningsträning 2 osv. Grupperna delas om tills första gruppen startat, så efteranmälda kommer med.",
"guide.series_day_5": "5. Skapa kval: heaten delas efter träningstiderna (lika snabba tillsammans, snabbaste heatet sist) och jämnt efter fältet (9 förare, max 6 -> 5 + 4). Sedan visar raden ▶ Kör Q1 H1, Q1 H2 ... och på Race Day väljer ▶ Nästa nästa heat. Reseeda kommande kval (i racet under Race Setup) delar om efter kvalrankingen.",
"guide.series_day_6": "6. När kvalet är klart: Skapa finaler, sedan ▶ Kör C Final 1, B Final 1, A Final 1, C Final 2 ... Status visar var deltävlingen är. Öppna tar dig till racet i Race Setup. Ställningen i steg 4 uppdateras av sig själv. Blev något fel (t.ex. kvalet)? ✎ Resultat på raden sätter dagens slutordning för hand, och ställningen följer den.",
"guide.series_points_title": "Poäng och ställning",
"guide.series_points_1": "Dagens placering i en deltävling: slutresultatet (A-final före B-final), sedan förare utan final i kvalordning. Utan finaler används kvalordningen.",
"guide.series_points_2": "Endast klubbmedlemmar: förare från andra klubbar kör och syns i dagens resultat men får inga poäng, och medlemmarna rangordnas om utan dem.",
"guide.series_points_3": "Den som inte kört något registrerat varv får 0 poäng. Frånvaro räknas som 0 och kan strykas.",
"guide.series_points_4": "Bästa N räknas, eller alla körda utom X sämsta - då minskar antalet automatiskt om en deltävling ställs in. Strukna resultat visas inom parentes.",
"guide.series_points_5": "Lika poäng: flest segrar bland räknade resultat, sedan andraplatser osv., sedan senaste gemensamma deltävling. Annars delad placering.",
"guide.series_points_6": "Ställningen kan skrivas ut eller exporteras som PDF (breda tabeller blir liggande A4). Inga kontaktuppgifter visas.",
"guide.series_example_title": "Exempel: klubbens vinterserie",
"guide.series_example_1": "12 söndagar, klasserna 2WD, 4WD och Rookie, poäng 100, 90, 82, 75, 69, 64, 60, 56, 52, 48 och sedan -4 per plats ner till 10, bästa 9 av 12, endast klubbmedlemmar.",
"guide.series_example_2": "Steg 1: bocka i 2WD, 4WD och Rookie. Steg 2: Endast klubbmedlemmar + klubben, poängtabellen 100, 90, 82 ... (-4, lägst 10), Bästa N räknas = 9.",
"guide.series_example_3": "Steg 3: klistra in de 12 datumen, format ÖRC Winter, Seedningsträning på, snabbaste heatet sist -> 36 race (12 datum × 3 klasser).",
"guide.series_example_4": "Varje söndag: välj förare per klass, och följ knappen på raden: Seedningsträning, Skapa kval, kör heaten, Skapa finaler, kör finalerna. Ställningen per klass är klar direkt efter sista finalen.",
"guide.tab_videos": "Videoguider",
"warmup.title": "Transponderkontroll",
"warmup.hint": "Under nedräkningen är banan öppen. Grön bock = transpondern har passerat linjen sedan nedräkningen började. Saknas någon kan du byta transponder direkt här, eller koppla en okänd transponder som just passerat.",
"prologue.length": "Nedräkning",
"prologue.option_go": "Go - direkt start",
"prologue.start": "Starta",
"prologue.to_start": "till start",
"prologue.running": "Nedräkning pågår",
"prologue.held": "Pausad",
"prologue.hold": "Pausa",
"prologue.resume": "Fortsätt",
"prologue.plus_minute": "+1 min",
"prologue.to_30": "Till 30 s",
"prologue.to_10": "Till 10 s",
"prologue.go": "Go nu",
"prologue.cancel": "Avbryt",
"events.qual_prologue": "Nedräkning före kval",
"events.final_prologue": "Nedräkning före final",
"events.prologue_hint": "Tid från Start på Race Day till start. Banan är öppen, speakern ropar ut tiden (EFRA: 2 min, 1 min, 30 s, 10 s) och transponderkontrollen visar vilka som passerat. Kan pausas medan bilarna ställs upp.",
"warmup.seen_count": "{seen} av {total} sedda",
"warmup.no_transponder": "Ingen transponder",
"warmup.assign_unknown": "Koppla okänd transponder...",
"warmup.new_transponder": "Ny transponder",
"warmup.save": "Spara",
"warmup.unknown_seen": "Okända transpondrar som passerat",
"warmup.start_missing": "Har inte passerat under nedräkningen: {names}. Starta ändå?",
"warmup.transponder_conflict": "Transponder {transponder} används redan av {name}. Spara ändå?",
"race_day.check_transponder_check": "Transponderkontroll",
"layouts.bar_current": "Banlayout: {label} - sedan {date}",
"layouts.bar_none": "Ingen banlayout satt ännu",
"layouts.new": "Ny layout",
"layouts.min_lap": "Minsta varvtid (s)",
"training.source": "Underlag",
"training.race_sessions": "Racepass 🏁",
"training.race_sessions_hint": "Ett race körs på fast tid och delas inte upp i stints. Här visas varje kval, heat och final för sig.",
"training.race_session": "Race · pass · serie",
"training.no_race_sessions": "Inga racepass ännu.",
"training.source_practice": "Träning",
"training.source_race": "Race (kval, heat, final) 🏁",
"training.source_all": "Alla",
"layouts.new_min_lap_prompt": "Minsta varvtid i sekunder för den nya layouten (tomt = som tävlingen, kan ändras under Inställningar):",
"layouts.max_lap": "Längsta varvtid (s)",
"layouts.lap_from_event": "som tävlingen",
"layouts.lap_window_hint": "Valfritt per layout: gäller träning (Open/Free practice) på den layouten. Tomt = tävlingens min/max. Kval, heat och final använder alltid tävlingens värden.",
"layouts.new_prompt": "Namn på den nya banlayouten (gäller från nu). Varv som körs efter bytet räknas till den nya layouten - även i ett Open Practice som redan pågår.",
"layouts.stats_for": "Statistik för",
"layouts.option_current": "Aktiv layout",
"layouts.option_none": "Utan layout (före första layouten)",
"layouts.option_all": "Alla layouter",
"tts.title": "Röstmotor",
"tts.hint": "Lokal röst (Piper) låter mer naturligt än webbläsarens röst och fungerar helt utan internet. Installera en gång (kräver internet just då), sedan körs allt lokalt. Om Piper saknas eller dröjer används webbläsarens röst automatiskt.",
"tts.engine": "Röstmotor",
"tts.engine_browser": "Webbläsarens röst",
"tts.engine_piper": "Lokal röst (Piper, offline)",
"tts.status_ready": "Piper är installerat.",
"tts.status_missing": "Piper eller röster saknas - klicka Installera.",
"tts.cached": "{count} repliker sparade",
"tts.install": "Installera Piper + svenska/engelska röster",
"tts.reinstall": "Kontrollera installation",
"tts.pregenerate": "Förgenerera fraser och förarnamn",
"tts.pregenerate_progress": "Förgenererat {done} av {total} ({failed} misslyckades)",
"tts.test": "Testa rösten",
"tts.voice_sv": "Svensk röst",
"tts.voice_en": "Engelsk röst",
"tts.voice_auto": "Automatisk",
"tts.gender_male": "man",
"tts.gender_female": "kvinna",
"tts.accent_us": "amerikansk",
"tts.accent_gb": "brittisk",
"tts.accent_gb_north": "nordengelsk",
"tts.accent_scottish": "skotsk",
"tts.more_voices": "Fler röster",
"tts.more_voices_hint": "Hämtas en i taget (ca 63 MB var, internet behövs bara under nedladdningen). Välj sedan rösten ovan och testa.",
"tts.download": "Hämta",
"tts.downloading": "Hämtar...",
"tts.test_failed": "Kunde inte spela upp den lokala rösten - kontrollera installationen.",
"auth.title": "Admin-PIN",
"auth.hint": "Skyddar alla ändringar (race, resultat, inställningar, uppdatering) med en PIN. Läsning och publika overlay-/träningslänkar påverkas inte. Inloggningen sparas i webbläsaren i 30 dagar.",
"auth.state_off": "Av - vem som helst på nätverket kan ändra.",
"auth.state_on_logged_in": "På - du är inloggad i den här webbläsaren.",
"auth.state_on_logged_out": "På - du är inte inloggad i den här webbläsaren.",
"auth.new_pin": "Ny PIN (minst 4 tecken)",
"auth.new_pin_change": "Byt till ny PIN",
"auth.confirm_pin": "Upprepa PIN",
"auth.enable": "Slå på PIN-skydd",
"auth.change_pin": "Byt PIN",
"auth.logout": "Logga ut",
"auth.disable": "Stäng av PIN-skydd",
"auth.disable_confirm": "Stänga av PIN-skyddet? Då kan alla på nätverket ändra igen.",
"auth.pin_mismatch": "PIN-koderna matchar inte.",
"auth.login_required": "Logga in med nuvarande PIN först.",
"auth.status_error": "Kunde inte läsa PIN-status från servern.",
"auth.login_title": "Logga in",
"auth.login_hint": "Ändringar är PIN-skyddade. Ange admin-PIN för att fortsätta.",
"auth.login": "Logga in",
"auth.cancel": "Avbryt",
"auth.wrong_pin": "Fel PIN.",
"auth.too_many": "För många felaktiga försök. Vänta några minuter.",
"guide.schedule_1": "1. Öppna Hantera -> fliken Schema & utskrift för ett race-event. Sätt starttid och paus mellan sessioner (standard 3 minuter) och klicka Spara schema.",
"guide.schedule_2": "2. Varje sessions planerade klockslag räknas ut i körordning (practice, sedan kval, sedan finaler) utifrån starttiden, sessionens längd/efterlöp och pausen mellan sessioner.",
"guide.schedule_3": "3. Så fort en session faktiskt startar eller avslutas flyttas resten av schemat automatiskt fram till den verkliga tiden - en sen start eller en session som drar över (inklusive paus) skjuter resten av dagen framåt utan att du behöver räkna om manuellt. En session som startade mer än en minut sent märks \"Försenad\".",
"guide.schedule_4": "4. Det planerade klockslaget skrivs också ut på startlistorna (Skriv ut/PDF startlistor) så förare kan se när deras session ungefär börjar.",
"guide.race_wizard_title": "Create Race Wizard",
"guide.race_wizard_1": "1. Börja i Race Setup och använd wizarden när du skapar ett nytt race, i stället för att bygga allt direkt i Hantera.",
"guide.race_wizard_2": "2. Steg 1 sätter namn, datum, klass och preset. Presetet fyller rimliga standardvärden innan du finjusterar något.",
"guide.race_wizard_3": "3. Steg 2 väljer exakt vilka förare som ska vara giltiga i racet. De blir då race-specifika deltagare och filter för timing/seedning.",
"guide.race_wizard_4": "4. Steg 3 väljer vilka sessioner som ska skapas direkt: practice, kval och/eller team race beroende på preset.",
"guide.race_wizard_5": "5. Wizarden skapar de första sessionerna automatiskt. Finaler skapas senare från Race actions när kval eller practice är klara.",
"guide.race_wizard_6": "6. Efter skapandet går du vidare till Hantera för raceformat, generering, grid, standings och utskrift.",
"guide.race_wizard_7": "7. I Hantera -> Race actions kan du exportera eller importera ett enskilt racepaket om du vill flytta just det racet till en annan installation.",
"guide.manage_steps_title": "Hantera race i fyra steg",
"guide.manage_steps_1": "1. Setup: välj racedeltagare och bygg eventuella lag för team race eller endurance.",
"guide.manage_steps_2": "2. Format: justera Race Format i Grundläge eller Avancerat. Practice/kval, finaler och validering ligger i egna block.",
"guide.manage_steps_3": "3. Generering: skapa kval, reseeda kommande heat, skapa finaler och applicera bump-ups från en separat Race actions-panel.",
"guide.manage_steps_4": "4. Live / resultat: använd grid editor, standings, finalmatris, print och PDF när tävlingen väl är byggd.",
"guide.manage_steps_5": "5. Sammanfattningskortet till höger fungerar som snabb kontroll av upplägget innan du börjar generera eller köra race.",
"events.qualifying_scoring_hint": "Välj om kval ska rankas på poäng per omgång eller bästa enskilda resultat.",
"events.qualifying_scoring": "Kval-scoring",
"events.qualifying_scoring_points": "Poäng per runda",
"events.qualifying_scoring_best": "Bästa runda / rank",
"events.qualifying_rounds": "Antal kvalrundor",
"events.qualifying_rounds_hint": "Hur många kvalomgångar som ska skapas totalt.",
"events.cars_per_heat": "Förare per kvalheat",
"events.cars_per_heat_hint": "Hur många förare som placeras i varje kvalheat.",
"events.qual_duration": "Kvaltid (min)",
"events.qual_duration_hint": "Längd per kvalheat i minuter.",
"events.qual_start_mode": "Kval-start",
"events.qual_start_mode_hint": "Flygande start (EFRA) - alla kör, var och ens tid startar vid första passeringen efter startsignalen. Staggered - bilarna släpps en och en. Eller mass/position.",
"events.qual_seed_laps": "Kval bästa varv",
"events.qual_seed_laps_hint": "0 = flest varv på tiden vinner (vanligast). Över 0 = heatet rankas på så många bästa varv i stället.",
"events.qual_seed_method": "Kval seedmetod",
"events.qual_seed_method_hint": "Hur kvalheat räknar varv när bästa-varvsläget används.",
"events.counted_qual_rounds": "Räknade kvalrundor",
"events.counted_qual_rounds_hint": "Hur många av kvalrundorna som räknas i slutrankingen.",
"events.qual_points_table": "Poängtabell",
"events.qual_points_table_hint": "Välj hur poäng per kvalomgång delas ut när Kval-scoring använder poäng.",
"events.qual_points_rank": "Placeringstal (1,2,3...)",
"events.qual_points_desc": "Fallande efter fältstorlek",
"events.qual_points_ifmar": "10-9-8-7-6-5-4-3-2-1",
"events.qual_tie_break": "Tie-break",
"events.qual_tie_break_hint": "Välj vilken regel som avgör lika resultat i kvalrankingen.",
"events.qual_tie_break_rounds": "Jämför räknade rundor",
"events.qual_tie_break_best_lap": "Bästa enskilda varv",
"events.qual_tie_break_best_round": "Bästa runda / heatresultat",
"events.race_preset": "Preset",
"events.race_preset_hint": "Snabbstart för bana/klass. Applicera preset och finjustera sedan manuellt.",
"events.apply_preset": "Applicera preset",
"events.save_preset": "Spara klubb-preset",
"events.delete_preset": "Ta bort klubb-preset",
"events.preset_name": "Presetnamn",
"events.preset_custom": "Custom / nuvarande värden",
"events.preset_short_technical": "Kort teknisk bana 16s",
"events.preset_club_qualifying": "Klubbrace kval + final",
"events.preset_orc_winter": "ÖRC Winter (3 kval, 6/heat, 3 finaler)",
"events.heat_order": "Heatordning",
"events.heat_order_hint": "Kvalheaten seedas efter practice (sedan kvalrankingen vid reseed). Välj om det snabbaste heatet körs först eller sist.",
"events.heat_order_fastest_last": "Snabbaste heatet sist",
"events.heat_order_fastest_first": "Snabbaste heatet först",
"events.preset_ifmar": "IFMAR-stil kval/final",
"events.preset_endurance": "Endurance / lagrace",
"events.tie_break_note": "Tie-break",
"events.counted_rounds_label": "Räknade rundor",
"events.tie_break_won": "Vann mot",
"events.tie_break_lost": "Förlorade mot",
"events.invalid_recent": "Senaste träff ogiltig",
"timing.invalid_manual": "Manuellt ogiltigförklarat",
"timing.invalidate_last_lap": "Ogiltigförklara senaste varv",
"events.cars_per_final": "Förare per final",
"events.cars_per_final_hint": "Max antal förare i varje A/B/C-final.",
"events.final_legs": "Final-heat per final",
"events.final_legs_hint": "Hur många finalheat som ska skapas per main.",
"events.counted_final_legs": "Räknade finalheat",
"events.counted_final_legs_hint": "Hur många finalheat som ska räknas i sammanlagd finalranking.",
"events.final_duration": "Finaltid (min)",
"events.final_duration_hint": "Längd per finalheat i minuter.",
"events.final_start_mode": "Final-start",
"events.final_start_mode_hint": "Starttyp för finaler, ofta positionsstart.",
"events.bump_count": "Bump-up per final",
"events.bump_count_hint": "Antal förare som kan flyttas upp från lägre final till nästa main.",
"events.save_race_format": "Spara raceformat",
"events.open_grid": "Grid",
"events.grid_editor": "Grid-editor",
"events.grid_editor_hint": "Dra förare upp eller ner för att ändra startordningen manuellt för positionsstart.",
"events.grid_reset": "Återställ från deltagarlista",
"events.grid_lock": "Lås grid",
"events.grid_unlock": "Lås upp grid",
"events.grid_locked": "Manuell grid är låst mot auto-reseed.",
"events.grid_unlocked": "Grid följer auto-seed/reseed tills du låser den.",
"events.grid_empty": "Ingen grid att redigera ännu.",
"events.print_heat_sheet": "Skriv ut heatsheet",
"events.export_heat_sheet": "Exportera heatsheet",
"events.pdf_heat_sheet": "PDF heatsheet",
"events.free_practice_note": "Free Practice visar löpande varvtider och används inte för seedning.",
"events.open_practice_note": "Open Practice visar alla inkommande transpondrar löpande. Om ingen förare matchar visas bara transpondern.",
"events.generate_qualifying": "Skapa kval från practice",
"events.clear_generated_qualifying": "Rensa genererade kval",
"events.generate_finals": "Skapa finaler från kval",
"events.clear_generated_finals": "Rensa genererade finaler",
"events.apply_bumps": "Applicera bump-ups",
"events.practice_standings": "Practice-ranking",
"events.qualifying_standings": "Kval-ranking",
"events.final_standings": "Final-ranking",
"events.generated_qualifying": "Kvalheat skapade från ranking.",
"events.finals_generated": "Finaler skapade från ranking.",
"events.bumps_applied": "Bump-ups applicerade till nästa final.",
"events.no_bumps_applied": "Inga bump-ups kunde appliceras ännu.",
"events.no_practice_results": "Inga practice-resultat ännu.",
"events.no_qualifying_results": "Inga kval-resultat ännu.",
"events.no_final_results": "Inga final-resultat ännu.",
"events.schedule_title": "Tidsschema",
"events.schedule_hint": "Sätt en starttid för dagen så räknas varje sessions planerade klockslag ut automatiskt utifrån längd, efterlöp och paus mellan sessioner. Skjuter en session upp sig (körs över tiden eller pausas) flyttas resten av schemat fram automatiskt.",
"events.schedule_start_time": "Starttid",
"events.schedule_gap": "Paus mellan sessioner (min)",
"events.schedule_save": "Spara schema",
"events.schedule_clear": "Rensa schema",
"events.schedule_not_set": "Inget schema satt ännu. Sätt en starttid ovan.",
"events.schedule_planned": "Planerad tid",
"events.schedule_actual": "Faktisk tid",
"events.schedule_delayed": "Försenad",
"events.final_matrix": "Finalmatris",
"events.print_startlists": "Skriv ut startlistor",
"events.print_results": "Skriv ut resultat",
"events.pdf_startlists": "PDF startlistor",
"events.pdf_results": "PDF resultat",
"events.reserved_slot": "Reserverad bump-plats",
"events.position_grid": "Grid / startordning",
"events.start_lists": "Startlistor",
"events.no_final_matrix": "Inga finaler skapade ännu.",
"events.results_overview": "Resultatöversikt",
"events.main": "Main",
"events.slot": "Ruta",
"events.leg_status": "Heatstatus",
"events.source_for_finals": "Källa för finaler",
"events.finals_from_qualifying": "Kval-ranking",
"events.finals_from_practice": "Practice-ranking",
"events.finals_source_hint": "Välj om finalerna ska seedas från practice eller kval.",
"events.follow_up_sec": "Follow-up tid (sek)",
"events.follow_up_sec_hint": "Extra tid efter ordinarie racetid så sista bilarna kan avsluta innan sessionen stängs.",
"events.min_lap_time": "Min varvtid (sek)",
"events.min_lap_time_hint": "Varv snabbare än detta ignoreras som shortcut eller felträff.",
"events.max_lap_time": "Max varvtid (sek)",
"events.max_lap_time_hint": "En passering över max startar en ny statistikstint och tas inte med i pace-snittet. Varvet räknas fortfarande i race och resultat.",
"events.race_driver_scope": "Race i denna klass använder alla förare i vald klass om sessionen inte har egen deltagarlista.",
"events.reserve_bump_slots_hint": "Reserverar tomma platser i högre finaler så bumpade förare kan flyttas in utan att skriva över seedade platser.",
"events.team_race": "Lagrace",
"events.team_race_intro": "Skapa lag för långlopp. Alla passeringar från lagets förare eller bilar summeras till lagets totalvarv i Team Race-sessioner.",
"events.team_name": "Lagnamn",
"events.add_team": "Lägg till lag",
"events.teams": "Lag",
"events.team_drivers": "Lagförare",
"events.team_cars": "Lagbilar",
"events.team_hint": "Välj minst en förare eller bil per lag. Team Race-sessioner summerar lagets totala varv under hela körtiden, t.ex. 4 timmar.",
"events.team_steps": "1. Skriv lagnamn. 2. Kryssa förare och/eller bilar här under. 3. Klicka Lägg till lag. 4. Använd Redigera lag för ändringar efteråt.",
"events.team_form_drivers": "Markera lagförare innan du sparar laget.",
"events.team_form_cars": "Markera lagbilar innan du sparar laget.",
"events.team_driver_fallback": "Inga förare matchade race-klassen eller deltagarlistan. Visar alla förare som fallback.",
"events.team_member_elsewhere": "Redan i {team} - kryssar du i flyttas den hit",
"events.heat_drivers": "Förare i heatet",
"events.heat_drivers_hint": "Kryssa i/ur för att ändra vilka förare som kör det här heatet. En förare som redan är i ett annat heat i samma omgång flyttas hit automatiskt när du sparar.",
"events.heat_member_elsewhere": "Redan i {heat} - kryssar du i flyttas den hit",
"events.no_teams": "Inga lag skapade ännu.",
"events.team_standings": "Lagställning",
"events.no_team_results": "Inga teamresultat ännu.",
"events.edit_team": "Redigera lag",
"events.team_stint_log": "Stint- och förarbyteslogg",
"events.team_report": "Lagrapport",
"events.print_team_results": "Skriv ut lagrapport",
"events.pdf_team_results": "PDF lagrapport",
"events.add_session": "Lägg till session",
"events.session_type_label": "Sessionstyp",
"events.session_type_hint_track": "Välj vilken del av sponsor-eventet du skapar: träning, kval, heat eller final. Eventet i sig är redan ett sponsor-event.",
"events.session_type_hint_race": "Välj vilken session i racet du skapar: träning, kval, heat, final eller lagrace.",
"events.session_duration_label": "Längd (min)",
"events.session_duration_hint": "Ordinarie körtid för sessionen i minuter.",
"events.session_followup_label": "Follow-up (sek)",
"events.session_followup_hint": "Extra tid efter ordinarie sluttid så sista bilarna kan fullfölja.",
"events.session_start_mode_label": "Starttyp",
"events.session_start_mode_hint": "Mass-start, positionsstart, staggered start eller flygande start.",
"events.session_seed_laps_label": "Seedning bästa varv",
"events.session_seed_laps_hint": "0 = av. Använd 2 eller 3 för practice/kval-seedning.",
"events.session_seed_method_label": "Seedmetod",
"events.session_seed_method_hint": "Hur de bästa varven ska räknas: summa, snitt eller följdvarv.",
"events.session_stagger_gap_label": "Stagger-gap (sek)",
"events.session_stagger_gap_hint": "Används bara för staggered start. 0 = ingen extra lucka.",
"events.session_max_cars_label": "Max bilar (valfritt)",
"events.session_max_cars_hint": "Sätt gräns om just den sessionen bara ska ha ett visst antal bilar.",
"events.edit_session_help": "Ändra sessionens namn, typ, tid och seed-/startinställningar här.",
"events.set_active": "Sätt aktiv",
"events.delete_race_confirm": "Ta bort racet \"{name}\"?\n\nDet tar bort {sessions} sessioner, varav {run} med körda varv. Det går inte att ångra.",
"events.delete_session_confirm": "Ta bort \"{name}\"? Heatets varv och resultat försvinner också. Det går inte att ångra.",
"events.more_actions": "Fler val: utskrift, export, grid, ta bort",
"events.step_practice": "Träning / seedning",
"events.step_qual_round": "Kval omgång {round}",
"events.step_qual": "Kval",
"events.step_finals": "Finaler",
"events.step_count": "{done}/{total} körda",
"events.assignments": "Tilldelningar",
"events.na": "ej relevant",
"events.sponsor_tools": "Sponsorverktyg",
"events.qual_rounds": "Kvalrundor",
"events.heat_rounds": "Heat-rundor",
"events.final_rounds": "Finalrundor",
"events.round_duration": "Rundtid (min)",
"events.create_rounds": "Skapa rundor",
"events.tp_rule": "Samma transponder kan återanvändas mellan sessioner (Heat 1 -> Heat 2 -> Final 1). I en pågående session måste alla aktiva bilar ha unikt transponder-ID.",
"events.assign_title": "Tilldelningar (Förare -> Bil)",
"events.assign": "Tilldela",
"events.auto_assign": "Auto-tilldela vald session",
"events.clear_assign": "Rensa vald session",
"events.no_assignments": "Inga tilldelningar",
"events.duplicate_car": "Den bilen är redan tilldelad i denna session.",
"events.duplicate_driver": "Den föraren är redan tilldelad i denna session.",
"events.duplicate_tp": "Dubblett-transponder i samma session är inte tillåtet. Återanvänd i nästa heat/final.",
"timing.decoder_connection": "Decoder-anslutning",
"timing.connect": "Anslut decoder",
"timing.disconnect": "Koppla ner",
"timing.simulate": "Simulera passering",
"timing.session_replay": "Session replay",
"timing.session_replay_hint": "Spela upp sparade passeringar utan decoder. Originalsession, resultat och träningsstatistik ändras aldrig.",
"timing.replay_isolated": "Isolerat testläge",
"timing.replay_select": "Välj sparad session",
"timing.replay_load": "Ladda replay",
"timing.replay_play": "Spela",
"timing.replay_pause": "Pausa",
"timing.replay_reset": "Till start",
"timing.replay_speed": "Hastighet",
"timing.replay_latest": "Senaste passering",
"timing.replay_load_hint": "Välj en session och ladda dess passeringar.",
"timing.replay_empty": "Inga sparade sessioner med passeringar finns.",
"timing.replay_no_visible_passings": "Replay har inte nått någon passering ännu.",
"timing.replay_status_idle": "Ej laddad",
"timing.replay_status_empty": "Tom",
"timing.replay_status_paused": "Pausad",
"timing.replay_status_running": "Spelar",
"timing.replay_status_finished": "Klar",
"timing.status": "Status",
"timing.connected": "Ansluten",
"timing.disconnected": "Frånkopplad",
"timing.last_message": "Senaste meddelande",
"timing.main_decoder": "Main start/mål",
"timing.split_decoder": "Mellantid",
"timing.pit_decoders": "Depå in/ut",
"timing.pit_entry_decoder": "Depå in",
"timing.pit_exit_decoder": "Depå ut",
"timing.pit_active": "I DEPÅ",
"timing.personal_time_up": "Klar",
"timing.channel_analysis": "Mellantider och depåstopp",
"timing.channel_analysis_hint": "Mellantider räknar inte varv. Depåtiden mäts från Depå in till Depå ut och kopplas till föraren och bilen vid infarten.",
"timing.channel_analysis_race_hint": "Sammanställning och full depålogg per heat. Använd detta exempelvis för att granska alla stopp i ett 45-minutersrace.",
"timing.split_count": "Antal split",
"timing.best_split": "Bästa split",
"timing.average_split": "Snitt split",
"timing.pit_stops": "Depåstopp",
"timing.total_pit": "Total depåtid",
"timing.average_pit": "Snitt depåstopp",
"timing.best_pit": "Bästa depåstopp",
"timing.pit_stop_log": "Depåstoppslogg",
"timing.pit_in": "Depå in",
"timing.pit_out": "Depå ut",
"timing.control": "Sessionkontroll",
"timing.speaker_panel": "Speaker-panel",
"timing.speaker_panel_hint": "Dessa växlar slår av/på cues direkt för pågående session och overlay utan att lämna Tidtagning.",
"timing.select_session": "Välj session",
"timing.other_sessions": "Övrigt",
"timing.set_active": "Sätt aktiv",
"timing.start": "Starta",
"timing.stop": "Stoppa",
"timing.reset": "Nollställ data",
"timing.lap_remove": "Ta bort",
"timing.corrections_in_judging": "Straff och varvändringar görs av domaren i Domarvyn (loggas och kan ångras).",
"timing.open_in_judging": "Öppna i Domarvyn",
"timing.lap_restore": "Återställ",
"timing.lap_removed": "borttaget",
"suspect.title": "Misstänkt korta varv ({count})",
"suspect.hint": "Mycket snabbare än förarens egen nivå - kanske en genväg. Varvet räknas som vanligt (även bästa varv och statistik) tills du tar bort det. Godkänn tar bara bort markeringen.",
"suspect.approve": "Godkänn",
"suspect.flag_title": "Misstänkt kort varv väntar på granskning",
"timing.total_passings": "Totala passeringar",
"timing.started": "Startad",
"timing.remaining": "Nedräkning",
"timing.elapsed": "Körtid",
"timing.race_finished": "Racet är avslutat",
"timing.race_started_voice": "Racet har startat",
"timing.race_finished_voice": "Racet är avslutat",
"timing.practice_started_voice": "Träningen har startat",
"timing.practice_finished_voice": "Träningen är avslutad",
"timing.follow_up": "Follow-up",
"timing.follow_up_active": "Follow-up aktiv",
"timing.no_active": "Ingen aktiv session vald.",
"timing.leaderboard": "Live leaderboard",
"timing.recent_passings": "Senaste passeringar",
"timing.no_laps": "Inga varv ännu.",
"timing.no_session_selected": "Ingen session vald.",
"timing.no_passings": "Inga passeringar registrerade.",
"timing.details": "Detaljer",
"timing.add_driver": "Lägg till förare",
"timing.add_car": "Lägg till bil",
"timing.quick_add_hint": "Snabbregistrera transponder",
"timing.quick_add_title": "Snabbregistrering",
"timing.quick_add_driver_title": "Lägg till förare från transponder",
"timing.quick_add_car_title": "Lägg till bil från transponder",
"timing.open_overlay": "Öppna overlay",
"timing.open_speaker_overlay": "Speaker overlay",
"timing.open_results_overlay": "Result overlay",
"timing.open_tv_overlay": "TV overlay",
"timing.open_team_overlay": "Team overlay",
"timing.open_obs_overlay": "OBS overlay",
"timing.close_details": "Stang",
"timing.detail_title": "Leaderboard-detaljer",
"timing.lap_history": "Varvhistorik",
"timing.no_lap_history": "Inga varv att visa.",
"timing.manual_corrections": "Manuella korrigeringar",
"timing.lap_adjustment": "Varvjustering",
"timing.time_penalty": "Tidspåslag",
"timing.penalty_add_lap": "+1 varv",
"timing.penalty_remove_lap": "-1 varv",
"timing.penalty_add_sec": "+1 sek",
"timing.penalty_add_5sec": "+5 sek",
"timing.penalty_remove_sec": "-1 sek",
"timing.penalty_reset": "Nollställ korrigering",
"timing.restore_last_invalid": "Återställ senaste manuellt ogiltiga varv",
"timing.no_manual_invalid": "Inget manuellt ogiltigt varv hittades.",
"timing.valid_passing": "Giltigt varv",
"timing.invalid_short": "För kort varv",
"timing.invalid_long": "Över maxvarv",
"timing.long_lap_stint": "Långt varv · räknat · ny stint",
"judging.title": "Domarvy",
"judging.active_session": "Aktiv session",
"judging.no_active_session": "Ingen aktiv session vald.",
"judging.select_competitor": "Välj förare eller lag",
"judging.manual_actions": "Manuella åtgärder",
"judging.action_log": "Domarlogg",
"judging.no_action_log": "Inga manuella åtgärder registrerade ännu.",
"judging.selected_none": "Ingen rad vald.",
"judging.restore_done": "Senaste manuellt ogiltiga varv återställdes.",
"judging.filter_competitors": "Filter rader",
"judging.filter_log": "Filter logg",
"judging.filter_all": "Alla",
"judging.filter_invalid": "Ogiltiga",
"judging.filter_corrected": "Korrigerade",
"judging.filter_team": "Team race",
"judging.filter_log_corrections": "Korrigeringar",
"judging.filter_log_invalidations": "Invalidate/restore",
"judging.filter_log_undo": "Undo",
"judging.export_log": "Exportera domarlogg",
"judging.undo_last": "Ångra senaste",
"judging.undo_action": "Ångra",
"judging.undo_done": "Senaste manuella åtgärden ångrades.",
"judging.no_undo": "Ingen åtgärd att ångra.",
"timing.total_time": "Total tid",
"timing.clear_confirm": "Rensa all tiddata för denna session? Varven finns kvar i träningsstatistiken.",
"timing.prompt_transponder": "Transponder",
"timing.first_crossing_start": "Första crossing satte personlig start",
"timing.seeding_mode": "Seedning",
"timing.position_grid_hint": "Griden visar startordningen för positionsstart i aktiv session.",
"settings.tab_connection": "Anslutning",
"settings.tab_audio": "Ljud",
"settings.tab_appearance": "Utseende & overlay",
"settings.tab_system": "System & backup",
"settings.decoder": "Decoder",
"settings.main_ws_url": "Main WebSocket-url",
"settings.enable_split_decoder": "Aktivera mellantidsdecoder",
"settings.split_ws_url": "Mellantid WebSocket-url",
"settings.enable_pit_decoders": "Aktivera depådecoders",
"settings.decoder_roles_hint": "Klientens WebSocket-url ska använda backend-datorns IP, inte den fysiska decoderns IP. Main räknar varv; mellantid och depå gör det aldrig.",
"settings.decoder_setup_title": "Välj decoderinstallation",
"settings.decoder_setup_hint": "Välj ett snabbval så bockas rätt extrakanaler i. Main används alltid. Kontrollera URL:erna och klicka sedan Spara.",
"settings.decoder_layout_main": "1 decoder: Main",
"settings.decoder_layout_split": "2 decoders: Main + mellantid",
"settings.decoder_layout_pit": "3 decoders: Main + depå",
"settings.decoder_layout_full": "4 decoders: Komplett",
"settings.role_required": "Obligatorisk",
"settings.role_enabled": "Aktiverad",
"settings.role_disabled": "Avstängd",
"settings.main_role_hint": "Start/mål. Den enda kanalen som räknar varv.",
"settings.split_role_hint": "En extra fysisk decoder för mellantid. Räknar aldrig varv.",
"settings.pit_role_hint": "Kräver två extra fysiska decoders: en vid depå in och en vid depå ut.",
"settings.connection_title": "Backend och anslutning",
"settings.backend_url_hint": "Webb/API på datorn som kör npm start, normalt port 8081.",
"settings.backend_url_mismatch": "Sidan är öppnad via {origin}, men Backend URL nedan är en annan adress. Webbläsaren blockerar då synk och backup (CORS) - de måste vara identiska.",
"settings.backend_url_use_current": "Använd {origin}",
"settings.managed_channels_hint": "Fälten Decoder IP / host nedan är de fysiska decodrarnas adresser. Backend startar en AMMC-process per roll på unika portar: main 9000, mellantid 9001, depå in 9002 och depå ut 9003.",
"settings.pit_entry_ws_url": "Depå in WebSocket-url",
"settings.pit_exit_ws_url": "Depå ut WebSocket-url",
"settings.split_decoder_host": "Mellantid decoder IP / host",
"settings.split_ws_port": "Mellantid WebSocket-port",
"settings.pit_entry_decoder_host": "Depå in decoder IP / host",
"settings.pit_entry_ws_port": "Depå in WebSocket-port",
"settings.pit_exit_decoder_host": "Depå ut decoder IP / host",
"settings.pit_exit_ws_port": "Depå ut WebSocket-port",
"settings.auto_reconnect": "Auto-återanslut",
"settings.save": "Spara",
"settings.connect_now": "Anslut nu",
"settings.expected_json": "Förväntat AMMC JSON-format",
"settings.managed_ammc": "Hanterad AMMC",
"settings.managed_ammc_sub": "Starta lokal AMMC från backend på denna maskin.",
"settings.enable_managed": "Aktivera hanterad AMMC",
"settings.auto_start_ammc": "Auto-starta AMMC när backend startar",
"settings.decoder_host": "Decoder IP / host",
"settings.ws_port": "AMMC WebSocket-port",
"settings.executable_path": "AMMC binär",
"settings.working_dir": "Arbetskatalog (valfritt)",
"settings.extra_args": "Extra argument (valfritt)",
"settings.save_ammc": "Spara AMMC",
"settings.start_ammc": "Starta AMMC",
"settings.stop_ammc": "Stoppa AMMC",
"settings.refresh_ammc": "Uppdatera status",
"settings.ammc_status": "AMMC-status",
"settings.running": "Kör",
"settings.stopped": "Stoppad",
"settings.server_platform": "Server-OS",
"settings.pid": "PID",
"settings.started_at": "Startad",
"settings.stopped_at": "Stoppad",
"settings.last_error": "Senaste fel",
"settings.output": "Senaste AMMC-logg",
"settings.executable_found": "Binär hittad",
"settings.executable_missing": "Binär saknas",
"settings.bundled_hint": "Bundlad standardbana i appen används automatiskt om den finns.",
"settings.use_server_ws": "Använd serverns WS-url",
"settings.audio": "Ljud",
"common.off": "Av",
"audio.race_sounds": "Raceljud och utrop",
"audio.enabled": "Aktivera nya raceljud",
"audio.mute": "Tysta allt",
"audio.language": "Utropsspråk",
"audio.voice_select": "Race-röst",
"audio.voice_auto": "Automatisk röst för valt språk",
"audio.voice_rate": "Race-röstens hastighet",
"audio.voice_pitch": "Race-röstens tonhöjd",
"audio.start_countdown": "Nedräkning före start",
"audio.master_volume": "Mastervolym",
"audio.effects_volume": "Effektvolym",
"audio.voice_volume": "Röstvolym",
"audio.passing_volume": "Passing-volym",
"audio.start_lights": "Startljus",
"audio.random_delay": "Slumpad startfördröjning",
"audio.min_delay": "Minsta fördröjning (sek)",
"audio.max_delay": "Största fördröjning (sek)",
"audio.per_competitor": "Olika passing-ton per förare/bil",
"audio.race_callouts": "Utrop under race",
"audio.practice_pb_warmup": "Träning: tyst personbästa första varven",
"audio.practice_pb_cooldown": "Träning: sekunder mellan PB-utrop per förare",
"audio.practice_pb_min_gain": "Träning: minsta förbättring för utrop (s)",
"audio.practice_pb_hint": "Gäller open practice. På nyladdade ackar slår alla sin bästa tid nästan varje varv i början av dagen. Bästa varvet visas ändå på skärm och overlay. 0 stänger av regeln.",
"audio.race_callouts_passing": "Bara passeringsljud (som tidtagningssystem)",
"audio.race_callouts_full": "Speaker - namn, bästa varv, ny ledare",
"audio.test": "Testa",
"audio.note": "Fasta effekter spelas från ljudpaketets WAV-filer. Röstutrop använder vald röstmotor ovan - lokal Piper-röst eller webbläsarens systemröster. Val sparas automatiskt; kritiska utrop avbryter lägre prioriterat tal.",
"audio.effect": "Effekt",
"audio.voice": "Röst",
"audio.track_call": "STOPP PÅ BANAN",
"audio.track_clear": "Banan fri",
"audio.red_flag": "Röd flagg",
"audio.race_pause": "Pausa race",
"audio.race_resume": "Fortsätt race",
"audio.false_start": "Felaktig start",
"audio.marshal_warning": "Banvaktsvarning",
"audio.passing_sound": "Eget passing-ljud",
"audio.pass_default": "Standard/fallback",
"settings.audio_enabled": "Aktivera ljud i browsern",
"settings.speaker_passing_cue": "Speaker-cue vid passing",
"settings.speaker_leader_cue": "Speaker-cue vid ny ledare",
"settings.speaker_finish_cue": "Speaker-cue vid finish",
"settings.speaker_bestlap_cue": "Speaker-cue vid nytt bästa varv",
"settings.speaker_top3_cue": "Speaker-cue vid topp 3-ändring",
"settings.speaker_start_cue": "Speaker-cue vid sessionstart",
"settings.passing_sound": "Passing-ljud",
"settings.passing_sound_off": "Av",
"settings.passing_sound_beep": "Blipp",
"settings.passing_sound_name": "Säg förarnamn",
"settings.finish_voice": "Läs upp start och avslut",
"settings.start_sound": "Startsignal",
"settings.finish_sound": "Målsignal",
"settings.speech_voice": "Talröst",
"settings.system_default_voice": "Automatisk röst för valt språk",
"settings.speech_rate": "Talhastighet",
"settings.speech_pitch": "Tonhöjd",
"settings.test_start": "Testa start",
"settings.test_finish": "Testa mål",
"settings.test_driver_voice": "Testa förarnamn",
"settings.driver_voice_sample": "Testförare",
"settings.test_audio": "Testa ljud",
"settings.audio_note": "Browsern kräver oftast ett klick först innan ljud/tal tillåts.",
"settings.voice_note": "Rösterna kommer från operativsystemet. På Windows ger Microsofts svenska röst oftast bäst uttal. Ange vid behov ett särskilt uttalsnamn under Förare.",
"settings.branding": "Klubbbranding / UI / PDF",
"settings.branding_note": "Klubbnamn, klubbtext och logotyp används i huvudmenyn, overlay, publik träningsprofil och PDF-export.",
"settings.save_branding": "Spara branding",
"settings.club_name": "Klubbnamn",
"settings.club_tagline": "Klubbtext",
"settings.pdf_footer": "PDF-footer",
"settings.pdf_theme": "PDF-tema",
"settings.pdf_theme_classic": "Classic",
"settings.pdf_theme_minimal": "Minimal",
"settings.pdf_theme_motorsport": "Motorsport",
"settings.logo": "Klubblogotyp",
"settings.logo_upload": "Ladda logo",
"settings.logo_clear": "Rensa logo",
"settings.logo_note": "Logotypen visas i huvudmenyn, overlay och publik träningsprofil. PDF-export försöker bädda in den via backend.",
"settings.track_layouts": "Banlayouter",
"settings.track_layouts_hint": "Lägg till en ny banlayout varje gång banan byggs om (t.ex. vid inomhuskörning i samma lokal), så jämförs personbästa, banrekord och \"jämn fart\"-ljudet bara mot pass körda på samma layout. Varje träningsvarv räknas till den layout som gällde när varvet kördes - byt layout mitt i ett pågående Open Practice så hamnar varven före och efter bytet på rätt layout. Layouter byts bara kring träning: inte medan ett racepass (kval, heat, final) pågår. Snabbast byter du med Ny layout på Träningsstatistik, Race Day eller Översikt. Om ingen layout läggs till fungerar allt som idag.",
"settings.track_layout_label": "Namn (valfritt)",
"settings.track_layout_started_at": "Gäller från",
"settings.track_layout_add": "Lägg till layout",
"settings.track_layout_none": "Inga banlayouter tillagda än.",
"settings.track_layout_unnamed": "Namnlös layout",
"settings.track_layout_invalid_date": "Ogiltigt datum.",
"settings.track_layout_date_error": "Ny layout måste börja gälla efter den senaste layoutens startdatum ({date}).",
"settings.track_layout_delete_confirm": "Ta bort banlayouten \"{label}\"?",
"settings.track_layout_delete_blocked": "Kan inte tas bort - sessioner eller träningsvarv är redan kopplade till den här layouten.",
"settings.track_layout_race_running": "Kan inte byta banlayout medan {name} pågår - layouter byts bara mellan eller under träningspass. Avsluta racepasset först.",
"settings.update_title": "Uppdateringar",
"settings.update_current_version": "Installerad version",
"settings.update_checking": "Kontrollerar om det finns en ny version...",
"settings.update_up_to_date": "Du har den senaste versionen.",
"settings.update_available": "Version {version} finns tillgänglig.",
"settings.update_available_sidebar": "Ny version v{version} - uppdatera",
"settings.update_error": "Kunde inte kontrollera version: {msg}",
"settings.update_check_now": "Kontrollera nu",
"settings.update_run_now": "Uppdatera nu",
"settings.update_confirm": "Uppdatera RC RaceCore till version {version}?\n\nServern stoppas, ny kod hämtas och startas om automatiskt. Det tar vanligtvis under en minut och sidan laddas om av sig själv när servern är tillbaka.",
"settings.update_confirm_active_session": "OBS: Ett aktivt race/session pågår just nu. En uppdatering stoppar servern under uppdateringen och avbryter tidtagningen. Uppdatera bara mellan heat.",
"settings.update_started": "Uppdatering startad. Servern startar om - sidan laddas om automatiskt när den är tillbaka.",
"settings.update_failed": "Uppdatering misslyckades: {msg}",
"settings.storage": "Lagring",
"settings.server_backups": "SQLite-backuper på servern",
"settings.server_backups_hint": "En backup skapas automatiskt före varje sessionstart. De 30 senaste sparas i data/backups.",
"settings.create_backup": "Skapa backup nu",
"settings.refresh_backups": "Uppdatera lista",
"settings.loading_backups": "Läser backuphistorik...",
"settings.no_backups": "Inga serverbackuper har skapats ännu.",
"settings.backup_reason_pre_start": "Före start",
"settings.backup_reason_pre_change": "Före större ändring",
"settings.backup_reason_pre_restore": "Före återställning",
"settings.backup_reason_manual": "Manuell",
"settings.backup_reason_unknown": "Okänd",
"settings.backup_created": "SQLite-backup skapades.",
"settings.backup_failed": "Backup misslyckades: {msg}",
"settings.safety_backup_failed_confirm": "Säkerhetsbackup misslyckades: {msg}\n\nFortsätt ändå?",
"settings.restore_backup_hint": "Återställning görs lokalt på servern medan RC RaceCore är stoppad. Webbåterställning aktiveras först när administrationsbehörigheter finns.",
"settings.race_presets": "Klubb-presetar",
"settings.race_presets_note": "Exportera eller importera lokala klubb-presetar mellan installationer.",
"settings.export_presets": "Exportera presets",
"settings.import_presets": "Importera presets",
"settings.backend_url": "Backend URL",
"settings.backend_status": "Backend-status",
"settings.online": "Online",
"settings.offline": "Offline",
"settings.last_sync": "Senaste synk",
"settings.test_backend": "Testa backend",
"settings.sync_now": "Synka nu",
"settings.export_json": "Exportera JSON",
"settings.export_all_data": "Exportera all race-data",
"settings.import_all_data": "Importera all race-data",
"settings.export_directory": "Exportera förare/klasser/bilar",
"settings.import_directory": "Importera förare/klasser/bilar",
"settings.export_drivers_csv": "Exportera förare CSV",
"settings.export_cars_csv": "Exportera bilar CSV",
"settings.import_drivers_csv": "Importera förare CSV",
"settings.import_cars_csv": "Importera bilar CSV",
"settings.download_drivers_csv_template": "Ladda ner förarmall",
"settings.driver_csv_guide_title": "Format för förarimport",
"settings.driver_csv_required": "Krav: name eller namn. Rader utan förarnamn hoppas över.",
"settings.driver_csv_columns": "Rekommenderat minimum är namn, transponder och klass. Valfria kolumner är id, brand/märke, spoken_name, club/klubb, country/land och profile_id.",
"settings.driver_csv_behavior": "Valfria kolumner och värden får saknas. De lämnas då tomma och skriver inte över befintliga uppgifter. Okända extra kolumner ignoreras.",
"settings.driver_csv_example": "Exempel med semikolon",
"settings.import_csv_success": "{type}: {added} tillagda, {updated} uppdaterade och {skipped} hoppade rader.",
"settings.csv_type_drivers": "Förare importerade",
"settings.csv_type_cars": "Bilar importerade",
"settings.storage_note_full": "Fullt datapaket innehåller klasser, förare, bilar, race/event, sessioner och resultat.",
"settings.storage_note_directory": "Registerpaket innehåller bara klasser, förare och bilar och mergeas in i befintlig data.",
"settings.storage_note_csv": "CSV kan exporteras eller importeras från Excel och LibreOffice. Komma, semikolon och tabb stöds. Importen slår ihop på ID, transponder eller namn i stället för att radera registret.",
"settings.clear_data_title": "Rensa data",
"settings.clear_data_note": "En SQLite-backup skapas automatiskt före rensning. Rensningen kan inte ångras, men system-, decoder-, tema- och brandinginställningar behålls. Råa passeringar i SQLite behålls som revisionslogg.",
"settings.clear_drivers": "Rensa förare",
"settings.clear_cars": "Rensa bilar",
"settings.clear_classes": "Rensa klasser",
"settings.clear_races": "Rensa race och sessioner",
"settings.clear_training": "Rensa träningsstatistik",
"settings.clear_all": "Rensa all tävlingsdata",
"settings.clear_drivers_confirm": "Rensa alla förare, deras träningsdata och förarreferenser i race? Detta kan inte ångras.",
"settings.clear_cars_confirm": "Rensa alla bilar och bilreferenser i race? Detta kan inte ångras.",
"settings.clear_classes_confirm": "Rensa alla klasser och koppla loss dem från förare och race? Detta kan inte ångras.",
"settings.clear_races_confirm": "Rensa alla event, race, sessioner och resultat? Befintliga träningsvarv arkiveras först. Detta kan inte ångras.",
"settings.clear_training_confirm": "Rensa all träningsstatistik, mål, belöningar och publika profillänkar? Detta kan inte ångras.",
"settings.clear_all_confirm": "Rensa alla klasser, förare, bilar, race, sessioner, resultat och all träningsstatistik? Systeminställningar behålls. Detta kan inte ångras.",
"settings.clear_success": "Valda data har rensats.",
"settings.import_full_confirm": "Importera \"{name}\"?\n\nAll nuvarande race-data (klasser, förare, bilar, race, sessioner och resultat) ersätts med filens innehåll. En backup tas först och finns under SQLite-backuper på servern.",
"settings.import_full_success": "Race-data importerad och ersatte nuvarande tävlingsdata.",
"settings.import_directory_success": "Klasser, förare och bilar importerades in i befintlig data.",
"settings.import_failed": "Import misslyckades: {msg}",
"table.name": "Namn",
"table.brand": "Märke",
"table.class": "Klass",
"table.transponder": "Transponder",
"table.delete": "Ta bort",
"table.car": "Bil",
"table.date": "Datum",
"table.mode": "Läge",
"table.start_mode": "Start",
"table.seeding": "Seedning",
"table.score": "Poäng",
"table.session": "Session",
"table.type": "Typ",
"table.duration": "Tid",
"table.status": "Status",
"table.time": "Tid",
"table.driver": "Förare",
"table.loop": "Loop",
"table.strength": "Signal",
"table.pos": "Pos",
"table.laps": "Varv",
"table.last_lap": "Senaste varv",
"table.best_lap": "Bästa varv",
"table.split": "Mellantid",
"table.pit": "Depå",
"table.gap": "Gap",
"table.event": "Event",
"table.result": "Resultat",
"table.lap": "Varv",
"table.leader_gap": "Gap ledare",
"table.ahead_gap": "Gap fram",
"table.own_delta": "Eget delta",
"common.delete": "Ta bort",
"common.cancel": "Avbryt",
"common.save": "Spara",
"common.edit": "Redigera",
"common.unknown_driver": "Okänd förare",
"common.unknown_car": "Okänd bil",
"common.unknown": "Okänd",
"common.unassigned_driver": "Otilldelad förare",
"common.driver_car": "Förarbil",
"common.unknown_event": "Okänt event",
"common.no_rows": "Inga rader",
"common.no_entries": "Inga poster.",
"common.previous": "Tillbaka",
"common.next": "Nästa",
"common.reset": "Återställ",
"status.ready": "redo",
"status.running": "pågår",
"status.paused": "pausad",
"status.finished": "klar",
"status.leader": "LEDARE",
"status.seeded": "SEED",
"status.free_practice": "FREE",
"status.open_practice": "OPEN",
"session.open_practice": "open practice",
"session.free_practice": "fri träning",
"session.practice": "träning",
"session.qualification": "kval",
"session.heat": "heat",
"session.final": "final",
"session.team_race": "lagrace",
"validation.no_assignments": "Ingen förar-/biltilldelning i denna session.",
"validation.missing_tp": "En eller flera tilldelade bilar saknar transponder-ID.",
"validation.duplicate_tp": "Dubblett-transponder i session: {ids}.",
"validation.invalid_date": "Datum måste vara i format YYYY-MM-DD.",
"validation.invalid_selection": "Välj ett giltigt alternativ.",
"validation.required_name": "Namn måste fyllas i.",
"validation.required_transponder": "Transponder måste fyllas i.",
"validation.required_date": "Datum måste fyllas i.",
"validation.required_duration": "Duration måste vara minst 1 minut.",
"edit.class_name": "Redigera klassnamn",
"edit.driver_name": "Redigera förarnamn",
"edit.driver_class": "Redigera förarklass",
"edit.new_driver_name": "Namn på ny förare",
"edit.driver_transponder": "Redigera personlig transponder (kan vara tom)",
"edit.car_name": "Redigera bilnamn",
"edit.new_car_name": "Namn på ny bil",
"edit.car_transponder": "Redigera bilens transponder",
"edit.event_name": "Redigera eventnamn",
"edit.event_date": "Redigera eventdatum (YYYY-MM-DD)",
"guide.title": "Guide och dokumentation",
"guide.intro": "Här finns steg-för-steg för sponsor-event, vanligt race, träningsstatistik och Create Race Wizard i Race Setup. Guiden beskriver också hur Hantera-flödet är uppdelat samt var AMMC faktiskt körs i Managed AMMC-läget.",
"guide.card_sponsor_blurb": "Delade bilar, roterande förare och heat/finaler för sponsor- och prova-på-event.",
"guide.card_race_blurb": "Personliga transpondrar, kval/finaler, raceformat och seedning för riktiga tävlingsrace.",
"guide.card_team_blurb": "Lagrace och endurance med team, stintlogg och summerade varv över lång tid.",
"guide.card_training_blurb": "Förarutveckling, beständig varvhistorik, träningsmål och belöningar i mobilvänlig vy.",
"guide.card_decoder_blurb": "AMMC, backend, WebSocket, Windows/Linux och lokal SQLite-lagring.",
"guide.audio_title": "Raceljud, startljus och race control",
"guide.audio_1": "1. Öppna Inställningar -> Raceljud och utrop. Välj svenska eller engelska och ställ master-, effekt-, röst- och passing-volym.",
"guide.audio_2": "2. Aktivera effekt och röst separat för varje event. Testknappen på raden provar exakt det eventet; saknade WAV-filer hoppas över eller använder passing-fallback.",
"guide.audio_3": "3. Välj 0, 10, 30 eller 60 sekunders förstart. För race följer sedan Förare gör er redo, startfras, fem startljus, slumpad väntan och startton.",
"guide.audio_4": "4. Den officiella raceklockan startar i samma callback som starttonen. Bara Quick Open Practice och fri träning startar direkt utan race-sekvens - en schemalagd \"Practice\"-session i ett race/sponsor-event får samma nedräkning, ljus och startton som kval/heat/final.",
"guide.audio_5": "5. Under Tidtagning finns manuella knappar för Stopp på banan, Banan fri, Röd flagg, felaktig start och banvaktsvarning. Kritiska utrop avbryter lägre prioriterat tal.",
"guide.audio_6": "6. Under Förare och Bilar kan du välja pass_01.wav till pass_08.wav. Om filen saknas används standardljudet; lägg egna korta filer i rc-race-sound-pack/sounds/effects/.",
"guide.audio_7": "7. Personbästa, snabbaste varv, banrekord, ledarbyte, tidsvarningar, depå in/ut, finish och podium hämtas från befintliga timinghändelser.",
"guide.audio_8": "8. Ljudet spelas i operatörens webbläsare. Klicka Testa före racet, kontrollera ljudutgången och håll Tidtagning-fliken öppen.",
"guide.audio_9": "9. Staggered start i ett kvalheat läser upp varje bils transpondernummer i startordning, cirka 3 sekunder mellan varje bil, direkt efter den vanliga starten - mass/position-start läser aldrig upp enskilda bilar.",
"guide.audio_10": "10. Bättre röst utan internet: under Inställningar -> Ljud -> Röstmotor, klicka Installera en gång (hämtar Piper och svenska + engelska röster, kräver internet just då) och välj Lokal röst. Välj manlig eller kvinnlig röst per språk under Svensk röst / Engelsk röst och lyssna med Testa rösten. Klicka sedan Förgenerera fraser och förarnamn före racedagen. Allt körs sedan lokalt; saknas Piper eller dröjer den används webbläsarens röst automatiskt.",
"guide.sponsor_title": "Skapa Sponsor Event: 10 personer, 4 bilar",
"guide.sponsor_1": "1. Lägg upp 4 bilar i sidan Bilar med unikt transponder-ID. Lägg gärna också in märke/modell i brandfältet.",
"guide.sponsor_2": "2. Lägg upp 10 förare i sidan Förare. Du kan också spara team/märke i brandfältet och filtrera listan på det senare.",
"guide.sponsor_3": "3. Skapa event med läge Sponsor Event.",
"guide.sponsor_4": "4. Klicka Hantera på eventet och skapa rundor (kval/heat/final).",
"guide.sponsor_5": "5. Tilldela 4 förare till 4 bilar i Heat 1, byt förare till Heat 2/3 osv.",
"guide.sponsor_6": "6. På Race Day: välj session och tryck Start, Pausa och Avsluta. Tidtagning visar tiderna.",
"guide.race_title": "Skapa vanligt race (förare har egna transpondrar)",
"guide.race_1": "1. Lägg in förare med personlig transponder. Brandfältet kan användas för team, sponsor eller bilmärke.",
"guide.race_2": "2. Skapa event med läge Race.",
"guide.race_3": "3. Klicka Hantera på racet och markera exakt vilka förare som ska få vara med i just detta race.",
"guide.race_4": "4. Gå igenom Raceformat och välj antal kvalrundor, förare per heat, tider, starttyp och hur finaler ska seedas.",
"guide.race_4a": "4a. Börja i Grundläge med en preset. Öppna Avancerat först när du behöver tie-break, poängtabell, reservplatser eller finjusterad seedning.",
"guide.race_5": "5. Kör practice om du vill använda practice som första seedning.",
"guide.race_6": "6. Klicka Skapa kval från practice för att bygga kvalheat från practice-ranking eller klasslista.",
"guide.race_7": "7. Kör kvalomgångarna. Om du vill omfördela kommande heat efter aktuell ranking klickar du Reseeda kommande kval.",
"guide.race_8": "8. Klicka Skapa finaler från kval när kvalen är färdiga.",
"guide.race_9": "9. Kör finalerna. Om bump används klickar du Applicera bump-ups mellan mains när en lägre final är färdig.",
"guide.race_10": "10. Använd Finalmatris och Skriv ut startlistor/resultat för att kontrollera och dela upplägget.",
"guide.race_format_title": "Förklaring av Raceformat",
"guide.race_format_0": "Raceformat är uppdelat i block för Practice/Kval, Finaler och Validering. Till höger visas en sammanfattning av upplägget innan du genererar heat och finaler.",
"guide.race_format_1": "Kval-scoring styr om ranking byggs på poäng per kvalomgång eller bästa enskilda kvalresultat.",
"guide.race_format_2": "Antal kvalrundor och Förare per kvalheat styr hur många kvalheat som skapas och hur de fylls.",
"guide.race_format_3": "Kvaltid, Kval-start och Räknade kvalrundor styr hur kvalen körs och vilka rundor som räknas.",
"guide.race_format_4": "Förare per final, Final-heat per final och Räknade finalheat styr hur A/B/C-finalerna byggs och räknas.",
"guide.race_format_5": "Finaltid och Final-start styr varje finalleg, ofta med positionsstart.",
"guide.race_format_6": "Bump-up per final och Reservera bump-platser används om förare ska kunna flyttas från lägre final till nästa main.",
"guide.race_format_7": "Källa för finaler avgör om finalerna seedas från practice eller kvalrankingen.",
"guide.race_format_8": "Follow-up tid ger en extra uppsamlingsperiod efter ordinarie racetid innan heatet verkligen stängs.",
"guide.race_format_9": "Min varvtid filtrerar bort shortcuts och felträffar. Exempel: på en 16-sekundersbana kan du sätta 11 sekunder som min-gräns.",
"guide.race_format_10": "Max varvtid är en statistikgräns. En längre passering avslutar stinten och utesluts ur pace-snittet, men varvet räknas fortfarande i race. Exempel: 120 sekunder ger en ny stint efter två minuters uppehåll.",
"guide.race_format_11": "Preset låter dig snabbt fylla raceformat med vettiga grundvärden för kort teknisk bana, klubbrace, IFMAR-liknande upplägg eller endurance.",
"guide.race_format_11a": "I Grundläge döljer endurance-presetet de flesta kval- och finalfälten för att hålla fokus på Team Race. Öppna Avancerat om eventet även ska ha stödheat eller vanliga finaler.",
"guide.race_format_12": "Du kan applicera preset och sedan justera enskilda fält manuellt innan du sparar raceformatet.",
"guide.race_format_13": "Spara klubb-preset lagrar dina egna lokala raceformat så du kan återanvända dem på samma installation utan att bygga om allt varje gång.",
"guide.race_format_14": "Klubb-presetar kan också exporteras och importeras från Inställningar om du vill flytta dem mellan olika servrar eller laptops.",
"guide.free_practice_title": "Free Practice",
"guide.free_practice_1": "Använd sessionstypen fri träning när du bara vill visa löpande varvtider.",
"guide.free_practice_2": "Free Practice påverkar inte seedning till kval eller finaler.",
"guide.free_practice_3": "Leaderboarden visar varv, senaste varv, bästa varv, gap till framförvarande och eget delta mot föregående varv.",
"guide.open_practice_title": "Open Practice",
"guide.open_practice_1": "Använd Open Practice när du vill att systemet bara ska lista alla transpondrar som kommer in.",
"guide.open_practice_2": "Om transpondern inte matchar en registrerad förare visas transpondernumret som namn.",
"guide.open_practice_3": "Open Practice påverkar inte seedning, kval eller finaler.",
"guide.open_practice_4": "Gå till Race Setup och använd Snabbstart Open Practice. Du behöver bara ange ett namn; klass, deltagare, preset och racetid behövs inte.",
"guide.open_practice_5": "Enklast: tryck Starta träning på Översikten eller Race Day - då fortsätter en pågående Open Practice eller så skapas och startas en ny. Nollställ – ny träningsdag på Race Day nollställer dagens varv utan att statistiken försvinner, och Ny banlayout finns bland snabbvalen.",
"guide.team_title": "Lagrace / Endurance",
"guide.team_1": "Gå till Race Setup och skapa ett race i rätt klass.",
"guide.team_2": "Öppna Hantera och gå till sektionen Lag.",
"guide.team_3": "Skriv lagnamn och kryssa förare och/eller bilar i samma teamblock innan du klickar Lägg till lag.",
"guide.team_4": "Efter att laget skapats kan du klicka Redigera lag för att ändra förare eller bilar.",
"guide.team_5": "Skapa en session med typ Team Race och sätt tiden, t.ex. 240 minuter för 4 timmar.",
"guide.team_6": "Starta sessionen i Tidtagning. Alla passeringar från lagets medlemmar summeras till lagets totalvarv.",
"guide.validation_title": "Ogiltiga varv, follow-up och manuella korrigeringar",
"guide.validation_1": "Senaste passeringar visar ogiltiga shortcuts som För kort varv. Passeringar över max markeras Långt varv · räknat · ny stint och ligger kvar i raceresultatet.",
"guide.validation_2": "Ogiltiga kortvarv under min-gränsen räknas inte alls i leaderboard eller statistik.",
"guide.validation_3": "Ogiltiga långvarv över max-gränsen räknas inte som varv, men de kan bryta lap-basen så nästa giltiga varv börjar om korrekt.",
"guide.validation_4": "När ordinarie tid är slut kan sessionen gå in i Follow-up aktiv om du har satt Follow-up tid i raceformat eller sessionen.",
"guide.validation_5": "Straff (+1/-1 varv, +1/+5/-1 sekunder) finns bara i race (kval, heat, final) och görs av domaren i Domarvyn. Det slår igenom direkt i leaderboarden. Tidtagning -> Detaljer visar korrigeringarna och har knappen Öppna i Domarvyn.",
"guide.validation_6": "Under träning tar du bort, återställer eller godkänner valfritt varv direkt i Tidtagning -> Detaljer. Misstänkt korta varv (genvägar) flaggas med ⚠ och listas med Godkänn / Ta bort på Tidtagning och Race Day.",
"guide.validation_7": "Domarvyn har leaderboard, varvhistorik med Ta bort / Återställ per varv, straff (endast race) och domarlogg med ångra för pågående session.",
"guide.validation_8": "Domarvyn kan filtrera på ogiltiga rader, korrigerade rader eller teamrace, exportera domarloggen och ångra flera senaste manuella åtgärder via undo-knappar.",
"guide.qualifying_title": "Seedning, poängtabeller och tie-break",
"guide.qualifying_1": "Practice och kval kan nu använda tre seedmetoder: bästa N varv som summa, bästa N varv som snitt eller bästa N konsekutiva varv.",
"guide.qualifying_2": "Raceformat styr både Kval seedvarv och Kval seedmetod när nya kvalheat skapas från practice eller deltagarlistan.",
"guide.qualifying_3": "Kval-scoring kan kombinera poängläge med poängtabell: placeringstal, fallande efter fältstorlek eller IFMAR 10-9-8-7-6-5-4-3-2-1.",
"guide.qualifying_4": "Tie-break i kvalrankingen kan avgöras på räknade rundor, bästa enskilda varv eller bästa runda/heatresultat.",
"guide.qualifying_5": "Leaderboarden visar seedningsresultat i rätt format, till exempel 3/00:48.321, 3 avg 16.107 eller 3 con 00:49.005.",
"guide.qualifying_6": "Vid flygande start (EFRA, standard för kval) och staggered start har varje förare sitt eget tidsfönster som börjar vid deras egen första passering efter startsignalen. Den som inte passerat i tid får klockan startad ändå: flygande start senast 150 % av första varvet någon kört, staggered när första bilen gått ett helt varv eller senast 1 minut efter start (EFRA 9.3, IFMAR 4.2.3) - och en grön \"Klar\"-flagga visas bredvid förarens namn i Tidtagning och overlays så fort deras fönster gått ut, även om heatet fortfarande pågår för andra.",
"guide.qualifying_7": "Heatets gemensamma klocka förlängs automatiskt för staggered start så att den täcker hela utropsschemat (antal förare minus ett, gånger sekunderna mellan varje bil) utöver den vanliga längden - annars skulle sista utropade föraren riskera att bli avbruten innan de hunnit köra sin fulla tid.",
"guide.race_day_title": "Race Day och säker start",
"guide.card_race_day_blurb": "Förkontroll, startlista, heat-kö, automatisk backup och fokuserad racedrift.",
"guide.race_day_1": "1. Skapa race och sessioner i Race Setup. Öppna sedan Race Day från gruppen Start.",
"guide.race_day_2": "2. Välj aktuellt heat. Listan visar dagens race (Visa alla sessioner visar resten). Pågår, Nästa och Därefter följer körordningen: träning, kval omgång för omgång, finaler från lägsta. ▶ Nästa väljer nästa heat när ett är klart. Ett heat som tagits bort och skapats om hamnar på rätt plats, och ▲▼ på sessionerna i Race Setup ändrar ordningen för hand.",
"guide.race_day_3": "3. Förkontrollen visar blockerare först, sedan varningar och godkända kontroller. Knapparna vid problemen öppnar relevant meny; min/max kan rättas direkt i Race Day. Förkontrollen blockerar start när Main decoder är offline, deltagare eller transpondrar saknas, transpondrar är dubbla, varvfönstret är ogiltigt eller en positionsgrid är ofullständig.",
"guide.race_day_4": "4. Gula kontroller är varningar. Valfria split-/depådecoders, backend och ljud visas tydligt men ändrar inte vanlig varvräkning.",
"guide.race_day_5": "5. Vid start synkas state till backend och en konsistent SQLite-backup skapas i data/backups innan den befintliga audio- och starttonssekvensen körs. De 30 senaste sparas.",
"guide.race_day_6": "6. Använd Race Day för start, paus, fortsätt och avslut. Menyn visar server- och sparstatus separat från decodern. Vid sparfel: behåll fliken öppen och klicka Försök igen; väntande ändringar är inte bekräftat sparade på servern. Tidtagning, Domare och Overlay finns som direkta genvägar. Lokal restore kräver stoppad server och npm run backup:restore -- <fil.sqlite> --confirm. Ett avbrutet eller klart heat, kval eller final körs om med ↻ Kör om: varv, resultat och klocka nollställs, sedan trycker du Starta. Medan heatet pågår visar Race Day racet live under klockan: ordning, varv, senaste och bästa varv, avstånd och beräknat slut - race controllern behöver ingen annan vy.",
"guide.race_day_7": "7. Session replay i Tidtagning spelar upp sparade passeringar i ett isolerat testläge. Välj session, ladda och kör i 1x, 2x, 5x eller 10x utan att ändra originalresultat eller träningsstatistik.",
"guide.race_day_8": "8. Redan när du registrerar eller ändrar en förare under Förare varnar systemet om transpondern redan används av en annan förare (t.ex. i fel klass) och namnger vem - ett komplement till förkontrollens kontroll av dubbla transpondrar inom samma heat. Samma person som kör flera klasser med sin egen transponder flaggas aldrig.",
"guide.race_day_9": "9. Kör ni på ett nät där fler har åtkomst (t.ex. arenans WiFi)? Slå på Admin-PIN under Inställningar -> System & backup. Då kräver alla ändringar PIN - resultat, inställningar och uppdatering - medan visning och publika overlay-/träningslänkar fungerar som vanligt. Varje webbläsare loggar in en gång och kommer ihåg det i 30 dagar.",
"guide.race_day_10": "10. Start med nedräkning (som EFRA/IFMAR): välj längd (Go, 30 s, 1, 1:30, 2, 3 eller 5 min - standard per tävling under Race Setup) och tryck Starta. Banan är öppen, speakern ropar ut tiden (varje minut, 30 s, 10 s; vid gridstart även \"bilarna till startplatsen\" vid 30 s och 9..3). Pausa medan bilarna ställs upp, +1 min, Till 30 s (omstart av gridet), Till 10 s, Go nu eller Avbryt. När tiden går ut startar heatet av sig själv: gridstart får startljus och slumpad signal, flygande start ger signalen och \"Klockan går\". Transponderkontrollen visar grön bock för alla som passerat sedan nedräkningen började - saknas någon, byt transponder direkt i panelen eller välj en okänd transponder som passerat. Go nu varnar om någon inte setts.",
"guide.race_day_11": "11. Dagens schema (längst ned på Race Day) visar alla klasser den dagen i en körordning med tider. Ange första start och paus mellan heaten; ▲▼ ändrar ordningen. Ett heat som startar sent eller pausas flyttar resten av dagen. 🖨 Skriv ut körordning ger en lista med tider och förare att sätta upp på tavlan, och 📺 Förarvy (/public-overlay/schedule) visar förarna nästa heat och vilka som kör. Upprop: när ett heat har 10 minuter kvar (ändras under Upprop) frågar Race Day om du vill ropa upp det – 📢 Ropa ut läser upp heatet och förarna i högtalarna och markerar det Uppropad i förarvyn; Senare frågar igen om 2 minuter. ▶ Kör dagen automatiskt startar varje heats nedräkning själv när det är dags och ropar då upp heaten själv (den här webbläsaren måste vara öppen); ■ Stoppa automatiken låter dig köra för hand och sedan slå på den igen; ⏸ Pausa dagen pausar heatet på banan och automatiken tills du fortsätter.",
"guide.dashboard_title": "Schemaavvikelse på Översikt",
"guide.dashboard_1": "Översikt visar nu skillnaden mellan planerad tid och faktisk körtid för alla startade sessioner.",
"guide.dashboard_2": "Planerad tid räknar sessionstid plus follow-up. Faktisk tid räknar verklig tid från start till stopp eller nuvarande tid om heatet fortfarande kör.",
"guide.dashboard_3": "Det gör det lättare att se om tävlingsdagen ligger före eller efter schema direkt från dashboarden.",
"guide.dashboard_4": "Kom igång-korten och den grupperade sidomenyn följer samma ordning: anslut systemet, registrera vid behov, skapa körning och öppna sedan Tidtagning/Overlay.",
"guide.training_title": "Träning, utveckling och belöningar",
"guide.training_1": "1. Registrera föraren och transpondern under Förare. Klubb och land är valfria profilfält. Har personen flera klasser väljer du samma Träningsprofil på varje förarpost.",
"guide.training_2": "2. Kör Free Practice eller Open Practice. Giltiga varv kopieras automatiskt till en beständig träningslogg; korta/långa ogiltiga varv räknas inte. Varv från kval, heat och final sparas också men räknas bara när du väljer Underlag: Race eller Alla - de märks 🏁 med tävling, pass och serie, och visas per racepass i stället för stints.",
"guide.training_3": "3. Öppna Träning och välj förare. Grundvyn visar bara totalvarv, träningsdagar, personbästa, jämnhet, nästa mål och dagens pass. Öppna Mer statistik eller Klubbens träningsöversikt bara när det behövs.",
"guide.training_4": "4. Nästa automatiska nivå räknas utan konfiguration. Skapa egna delmål om klubben eller en förälder vill koppla en fysisk belöning till exempelvis 500, 1000 eller 1500 varv.",
"guide.training_5": "5. När målet nåtts kan belöningen markeras som utdelad. Direktlänken `/?view=training&driver=<id>` kan bokmärkas på förarens mobil.",
"guide.training_6": "6. Träningsloggen uppdateras av domarkorrigeringar medan sessionen finns, men behålls när sessionen senare raderas. Full dataexport i Inställningar inkluderar både logg och mål.",
"guide.training_7": "7. Öppna Mål och mobilprofil och klicka Aktivera mobilprofil. Kopiera den personliga länken och öppna den på förarens eller förälderns mobil.",
"guide.training_8": "8. Mobilprofilen visar bara vald förares statistik. Föraren väljer minuter för Maxfokus och Kontrollerad körning och kan markera en biländring för vald klass. Inga race- eller registerinställningar kan ändras.",
"guide.training_9": "9. Mobilprofilens statusrad visar senaste hämtning och varnar vid gammal data eller hämtningsfel. Skriv klart i aktiva fält och använd Försök igen vid behov; statistiken ligger kvar. Klicka Skapa ny länk eller Stäng av profil om länken spridits fel. Publicera bara `/public-training/*`, `/src/public_training.js` och `/src/public_training.css` externt, aldrig hela admin-sidan eller `/api/state`.",
"guide.training_10": "10. När Open Practice, Free Practice eller Practice pågår visar Träning ett livekort för vald förare med varv, bästa varv, snitt och senaste varv. Alla förare kör fortfarande i samma gemensamma session.",
"guide.training_11": "11. Knappen högst upp skapar eller öppnar den valda förarens personliga mobillänk. Föraren ställer in och startar sin egen timer i mobilen utan att starta om eller påverka den gemensamma practice-sessionen. Tiden sparas separat per förare och klass.",
"guide.training_12": "12. Ett glapp över 2 minuter mellan passeringar startar automatiskt en ny stint. Ett långt pausvarv används som gräns men räknas inte som prestationsvarv i stintstatistiken.",
"guide.training_13": "13. Bästa 5 min använder 300 sekunder. Ett slutvarv räknas om det startade före 5:00 även om målgången sker efter tiden. Stinttabellen visar 5-min resultat separat från hela stintlängden, och olika transponderkällor blandas aldrig i samma resultat.",
"guide.training_14": "14. En personlig profil och mobillänk kan innehålla flera klasser, men 2WD/4WD-statistik, stints, varvtider och rekommendationer visas alltid separat per vald klass.",
"guide.training_15": "15. Utvecklingskortet jämför de senaste 30 giltiga varven med de föregående 30 inom samma klass. Positivt värde betyder snabbare snittempo eller mindre spridning; för litet underlag visas som insamling i stället för en osäker trend.",
"guide.training_16": "16. Achievements och klubbens framstegsfeed lyfter träningspass, varvmål, jämn körning och fullföljda femminutersstints. Feedens ordning följer senaste aktivitet och är inte en ranking mellan förare.",
"guide.training_17": "17. Öppna Mer statistik för tempo per aktivt 30-minutersblock, setupändringar, stintanalys, mellantider, depåstopp och historik. Tomma tider döljs och tempot använder trimmat snitt.",
"guide.training_18": "18. Före en biländring väljer du Ny setup, däck, dämpare, bil eller egen notering och klickar Markera ändring nu. Markören sparas endast för vald personlig profil och klass.",
"guide.training_19": "19. När det finns minst tre giltiga varv inom 30 minuter både före och efter markören visas förbättringen automatiskt. Jämför bara pass med liknande bana och förhållanden.",
"guide.training_20": "20. Stintanalysen använder glapp över två minuter som gräns. Normaltempo är trimmat snitt, avvikande varv är varv över 15 procent långsammare än stintens median och Race pace 10 kräver tio sammanhängande varv.",
"guide.training_21": "21. Dagens utmaningar är frivilliga och nollställs per kalenderdag och vald klass: 20 giltiga varv, 5 kontrollerade varv i rad och en fullföljd femminutersstint. De påverkar aldrig raceresultat eller timing.",
"guide.training_22": "22. Träningskortet ger positiv kredit för dagens varv, PB, förbättrat snittempo, jämnhet och uthållighet. Kortet jämför bara föraren med den egna historiken inom vald klass.",
"guide.training_23": "23. Skapa ett klubbmål från Träningsöversikten. Målet börjar på noll när det sparas och summerar därefter alla giltiga registrerade träningsvarv. När målet nås kan det markeras som firat och ersättas med ett nytt.",
"guide.training_24": "24. Ljudhändelsen training stable pace ger valbar personlig röstfeedback efter fem kontrollerade varv i samma practice-stint. Den använder förarens uppläsningsnamn, har två minuters cooldown och aktiveras separat under Raceljud och utrop.",
"guide.training_25": "25. Kontrollzonen går från personbästa till 8 procent långsammare. Flytserier bryts vid avvikande varv, ny stint eller ny session. Stark avslutning, rena femminuterspass och förbättrade mellantider ger positiv feedback men påverkar aldrig race-resultat.",
"guide.training_26": "26. Under Mål och mobilprofil väljer du vilka publika sektioner som visas. Stints/prestation innehåller även biländring och tempo per aktivt 30-minutersblock. Öppna sektioner ligger kvar vid live-uppdatering.",
"guide.training_27": "27. Under Träning kan du för vald förare/klass ställa in de två guidade övningarna \"Jämna varv\" (måltid, tolerans och antal varv i följd) och \"Stegträning\" (lugn/kontrollerad/snabb-sekvens). Båda körs inuti den redan aktiva Open Practice-sessionen utan att störa andra förare eller starta om timingen.",
"guide.training_28": "28. Samma två övningar går även att ställa in, starta och stoppa direkt från förarens egna mobillänk, oberoende av om adminsidan har Träning öppen. Livestatus (aktuell serie eller steg) visas där föraren själv kör.",
"guide.training_29": "29. När förarens 5-minuterstimer i mobillänken tar slut visas automatiskt en sammanfattning: tempo och jämnhet jämfört med tidigare pass, uppnådda mål eller varvmilstolpar med belöningstext, och ett förslag på nästa mål. Sammanfattningen döljs med Stäng och dyker upp igen efter nästa avslutade pass.",
"guide.training_30": "30. Genomförda pass (timer, Jämna varv och Stegträning) sparas permanent under Genomförda träningspass, både på förarens mobilprofil och här i admin - så gammal utveckling går att titta tillbaka på. En genomförd session verifieras alltid mot förarens riktiga varvdata innan den sparas, den kan aldrig bara påstås av mobilsidan.",
"guide.training_31": "31. Delmål och klubbmål kan väljas som antingen antal varv eller antal genomförda pass av en viss övningstyp (t.ex. 10 genomförda Stegträning-pass mot en belöning) - samma belöningsflöde funkar för båda typerna.",
"guide.archive_title": "Resultatarkiv",
"guide.card_archive_blurb": "Sök och öppna avslutade race på datum, klass eller förare utan att gå via Race Setup.",
"guide.archive_1": "1. Öppna Resultatarkiv i menyn för att se alla avslutade sessioner samlade, oavsett vilket event de tillhör.",
"guide.archive_2": "2. Sök på event- eller sessionsnamn, eller filtrera på klass, förare och datumintervall.",
"guide.archive_3": "3. Klicka Visa på en rad för att se resultat, straff/korrigeringar och varvhistorik per förare för den sessionen.",
"guide.archive_4": "4. Exportera samma PDF- och racepaket (JSON)-filer som redan finns i Manage Event, direkt från arkivet.",
"guide.archive_5": "5. Att radera ett event eller en session tar bort racets data överallt, inklusive de råa varvraderna i databasen - men påverkar aldrig förarens beständiga träningsstatistik, som redan sparas separat.",
"guide.archive_6": "6. Kör klubben på flera banlayouter (t.ex. inomhus i samma lokal) - tryck Ny layout (på Träningsstatistik, Race Day eller Översikt) när banan byggts om; det går även mitt i ett pågående Open Practice. Arkivet visar vilken layout varje session kördes på, och personbästa/banrekord jämförs bara mot samma layout. Under Träningsstatistik och i förarens mobilprofil väljer du Statistik för: aktiv layout, en äldre layout eller Alla layouter.",
"overlay.title": "Overlay",
"overlay.subtitle": "Extern leaderboard-skärm",
"overlay.no_active": "Ingen aktiv session vald.",
"overlay.last_passings": "Senaste passeringar",
"overlay.window_title": "RC RaceCore Overlay",
"overlay.mode_leaderboard": "Leaderboard",
"overlay.mode_speaker": "Speaker",
"overlay.mode_results": "Resultat",
"overlay.mode_tv": "TV",
"overlay.mode_team": "Team",
"overlay.mode_schedule": "Förarvy: dagens schema",
"day.title": "Dagens schema · {date}",
"day.hint": "Alla klasser i körordning med planerade tider. Ett heat som startar sent eller pausas flyttar resten av dagen. ▲▼ ändrar ordningen.",
"day.print": "Skriv ut körordning",
"day.board": "Förarvy",
"day.start_time": "Första start",
"day.gap": "Paus mellan heat (min)",
"day.show_done": "✓ {count} heat körda – visa",
"day.hide_done": "Dölj körda heat ({count})",
"day.next": "Nästa",
"day.call_min": "Upprop (min innan)",
"day.call_title": "{name} startar {time} (om {min} min) – dags att ropa upp",
"day.call_now": "Ropa ut",
"day.call_later": "Senare",
"day.called_at": "Uppropad {time}",
"day.autopilot_on": "Kör dagen automatiskt",
"day.autopilot_off": "Stoppa automatiken",
"day.autopilot_confirm": "Kör dagen automatiskt? Varje heat startar sin nedräkning själv när det är dags enligt schemat. Du kan pausa dagen eller ta över när som helst. Låt den här webbläsaren vara öppen.",
"day.autopilot_elsewhere": "Automatiken körs på en annan dator.",
"day.pause": "Pausa dagen",
"day.resume": "Fortsätt dagen",
"day.col_time": "Tid",
"day.col_session": "Klass · heat",
"day.col_drivers": "Förare",
"day.state_done": "Klar",
"day.state_live": "Pågår",
"day.state_paused": "Pausad",
"day.in_min": "om {min} min",
"day.auto_until": "Nästa: {name} kl {time} – nedräkningen börjar om {min} min",
"day.auto_running": "Väntar tills heatet på banan är klart",
"day.auto_paused": "Dagen är pausad",
"day.auto_done": "Alla heat i schemat är körda",
"day.auto_decoder": "Väntar: decodern är inte ansluten ({name} står på tur)",
"day.auto_preflight": "Väntar: {name} är inte redo – se kontrollerna",
"day.print_title": "Körordning {date}",
"day.print_hint": "Tiderna är planerade och kan flyttas om något drar ut på tiden. Följ förarvyn för aktuella tider.",
"day.board_title": "Dagens schema {date}",
"day.board_now": "startar nu",
"day.board_heads_up": "Uppropad – gör dig redo!",
"day.board_on_track": "På banan",
"day.board_all_done": "Alla heat är körda för idag.",
"day.board_none": "Inget schema för idag.",
"overlay.mode_obs": "OBS",
"overlay.fastest_lap": "Snabbaste varv",
"overlay.fullscreen": "Fullscreen",
"overlay.leaderboard_live": "Live leaderboard",
"overlay.rotating_panel": "Displaypanel",
"overlay.next_predicted_lap": "Nästa varv",
"overlay.event_markers": "Eventmarkörer",
"overlay.obs_config": "OBS-konfiguration",
"overlay.obs_public_hint": "Bygg en minimal publik overlay-länk för OBS eller extern webb.",
"overlay.obs_rows": "Antal rader",
"overlay.obs_show_clock": "Visa raceklocka",
"overlay.obs_show_fastest": "Visa snabbaste varv",
"overlay.obs_show_grid": "Visa startgrid när racet är klart att starta",
"overlay.obs_show_laps": "Visa varv",
"overlay.obs_show_result": "Visa resultat/tid",
"overlay.obs_show_best": "Visa bästa varv",
"overlay.obs_show_gap": "Visa gap",
"overlay.obs_copy_url": "Kopiera OBS-url",
"overlay.obs_layout": "OBS-layout",
"overlay.obs_theme": "OBS-tema",
"overlay.obs_public_token": "Publik token",
"overlay.obs_public_token_hint": "Valfri klienttoken som läggs i public-overlay-länken.",
"overlay.obs_layout_leaderboard": "Leaderboard",
"overlay.obs_layout_grid": "Startgrid",
"overlay.obs_layout_lowerthird": "Lower third",
"overlay.obs_theme_panel": "Panel",
"overlay.obs_theme_transparent": "Transparent",
"overlay.obs_theme_chroma": "Chroma",
"overlay.team_battle": "Lagkamp",
"overlay.active_member": "Aktiv förare/bil",
"overlay.open_training_stats": "Klicka för att se förarens träningsstatistik",
"overlay.top_three": "Topp 3",
"guide.host_title": "Hur Managed AMMC körs",
"guide.decoder_roles_title": "Decoderroller, IP och portar",
"guide.decoder_roles_1": "1. Main start/mål är obligatorisk och är den enda kanalen som får räkna varv. Exempel: decoder `192.168.1.10` -> AMMC-port `9000` -> `ws://server-ip:9000`.",
"guide.decoder_roles_2": "2. Mellantid är valfri och registrerar tiden från senaste main-passering utan att öka varvantalet. Exempel: `192.168.1.11` -> `9001`.",
"guide.decoder_roles_3": "3. Depåtid kräver två loopar: Depå in öppnar stoppet och Depå ut stänger det. Exempel: `192.168.1.12` -> `9002`, samt `192.168.1.13` -> `9003`.",
"guide.decoder_roles_4": "4. Decoder-IP är den fysiska decoderns adress. WebSocket-porten tillhör AMMC-processen på backend-hosten. Blanda inte ihop dessa två adresser.",
"guide.decoder_roles_5": "5. Varje fysisk decoder ska ha unik IP och varje aktiverad AMMC-process ska ha unik port. Main/split/depå får aldrig dela samma WebSocket-port.",
"guide.decoder_roles_6": "6. I Inställningar aktiverar du endast de extrakanaler som finns fysiskt, sparar Managed AMMC och klickar Starta AMMC. Använd sedan serverns WS-url och Anslut decoder. Öppna Decoder / socket-diagnostik för mottagna meddelanden, fel och kanalens senaste 50 händelser. Pausa/rensa gäller endast diagnostiken, aldrig tidtagningen.",
"guide.decoder_roles_7": "7. Öppna TCP 9000 och de valfria portarna 9001-9003 i backend-hostens brandvägg om webbläsaren kör på en annan maskin. Port 8081 används för webb/API.",
"guide.decoder_roles_8": "8. Kontrollera i Tidtagning att varje aktiverad roll står som Ansluten. Om main är offline räknas inga varv; om en extrakanal är offline fortsätter vanlig varvräkning.",
"guide.decoder_roles_9": "9. Tidtagning visar live-sammanställning och depåstoppslogg. Race Setup visar samma data per heat, och resultat-PDF inkluderar stoppantal, total depåtid samt varje depå in/ut.",
"guide.decoder_roles_10": "10. Träningsstatistik och den personliga mobilprofilen visar sanerade mellantids- och depåaggregat per vald klass. Mobilprofilen visar inte transpondrar eller rå depålogg. Vid förarbyte tillhör stoppet föraren och bilen vid Depå in.",
"guide.decoder_roles_11": "11. Välj installation: 1 decoder = Main; 2 = Main + Mellantid; 3 = Main + Depå in/ut; 4 = alla roller. Depå kräver alltid både in och ut.",
"guide.decoder_roles_12": "12. Exempel: backend 192.168.1.100, main-decoder .10, split .11, depå in .12 och depå ut .13. Decoder-IP-fälten får .10-.13; klientens WS-url använder alltid backend .100 med port 9000-9003.",
"guide.decoder_roles_13": "13. Startordning: pinga decoders från backend, starta backend, starta Managed AMMC, kontrollera AMMC-loggen, använd serverns WS-url och anslut sedan i Tidtagning.",
"guide.decoder_roles_14": "14. Funktionstest: Main ska öka varv, Split ska inte öka varv, Depå in ska visa I DEPÅ och Depå ut ska skapa ett tidtaget stopp. Komplett guide finns i docs/decoder-setup.sv.md.",
"guide.decoder_roles_15": "15. Inställningar är uppdelat i flikarna Anslutning (decoder + Managed AMMC), Ljud, Utseende & overlay och System & backup, i stället för en lång scroll - decoder-inställningarna ovan hittar du under Anslutning.",
"guide.host_1": "1. AMMC körs alltid på samma maskin som backend körs på (`npm.cmd start` i Windows eller `npm start` i Linux).",
"guide.host_2": "2. Om du bara surfar in från en laptop/webbläsare startas ingen process där. Webbläsaren styr bara backend via HTTP.",
"guide.host_3": "3. Kör backend på Linux-servern -> Linux-binären används: `AMMC/linux_x86-64/ammc-amb`.",
"guide.host_4": "4. Kör backend på Windows-burken -> Windows-binären används: `AMMC/windows64/ammc-amb.exe`.",
"guide.host_5": "5. Fältet `AMMC binär` i Settings är sökvägen på hosten där backend kör, inte på klient-laptopen.",
"guide.host_6": "6. Publicera helst bara `/public-overlay/*` och valda `/public-training/*`-routes externt via reverse proxy, inte hela admin-UI:t eller `/api/state`.",
"guide.host_7": "7. OBS overlay finns nu som publik URL: `/public-overlay/obs` och kan konfigureras från Overlay-menyn.",
"guide.host_8": "8. Sätt `PUBLIC_OVERLAY_TOKEN` på servern om du vill kräva `?token=...` för publika overlay-länkar.",
"guide.windows_title": "Windows + AMMC + npm",
"guide.windows_1": "1. Använd 64-bitars Windows 11. Dubbelklicka på `windows/install.bat`; skriptet installerar vid behov Node.js LTS med winget, kör `npm.cmd ci` och startar om backend.",
"guide.windows_2": "2. Installationen kräver Node 22 eller 24 LTS och verifierar automatiskt Express, SQLite samt `AMMC/windows64`.",
"guide.windows_3": "3. `windows/install.bat` kör `npm.cmd restart` automatiskt. Starta annars med `npm.cmd start` eller `windows/start_backend.bat`, kontrollera med `npm.cmd run status` och starta om med `npm.cmd restart`.",
"guide.windows_4": "4. I Inställningar: `Decoder IP / host` = decoderns IP, t.ex. `192.168.1.10`. Managed AMMC körs på Windows-hosten.",
"guide.windows_5": "5. Från andra enheter används `http://<windows-host>:8081` och `ws://<windows-host>:9000`. Se `windows/README.md` för brandvägg och felsökning.",
"guide.linux_title": "Linux + npm",
"guide.linux_1": "1. Installera Node 22 LTS, build-essential och python3 på Linux-hosten.",
"guide.linux_2": "2. Alla program i `AMMC/linux_x86-64` kräver GLIBC 2.39 eller senare. Kontrollera med `ldd --version` eller `npm run verify`; kontrollen verifierar även körflaggorna.",
"guide.linux_3": "3. Kör `npm install`, `npm start`. Servern lyssnar på 0.0.0.0:8081. `ammc-sim` kan användas som fake decoder för test med egna transponder-ID:n; se decoder-guiden.",
"guide.sqlite_title": "SQLite-lagring",
"guide.sqlite_1": "Databasfil: data/rc_timing.sqlite",
"guide.sqlite_2": "API: /api/state, /api/passings och /api/passings/purge",
"guide.sqlite_3": "I Inställningar -> Lagring kan du exportera hela racepaket för backup eller flytt till annan server/laptop.",
"guide.sqlite_4": "Du kan också exportera eller importera bara klasser, förare och bilar om du vill börja om med race men behålla registret.",
"guide.sqlite_5": "CSV-filer för förare och bilar kan både exporteras och importeras. För förare räcker name/namn, transponder och class/klass; endast namnet är obligatoriskt. Egna exporter bevarar ID:n och externa listor slås ihop på transponder eller namn och klass.",
"guide.sqlite_6": "Rensa data kan tömma förare, bilar, klasser, race eller träningsstatistik separat. Rensa all tävlingsdata behåller decoder-, tema-, branding- och serverinställningar. Att radera ett race, en session eller rensa förare/bilar/all tävlingsdata tar även bort de råa SQLite-passeringarna för berörda sessioner - förarens beständiga träningsstatistik påverkas aldrig. Exportera backup först.",
"guide.ammc_ref": "AMMC referens: https://www.ammconverter.eu/docs/intro/quick-start/",
"error.backend_offline": "Backend offline: {msg}",
"error.sync_failed": "Synk misslyckades: {msg}",
"error.health_failed": "Hälsokontroll misslyckades: {msg}",
"error.ws_invalid": "Ogiltig WebSocket URL: {msg}",
"error.decoder_connection": "Decoder-anslutningsfel.",
"error.passing_save_failed": "Sparning av passering misslyckades: {msg}",
"error.ammc_load_failed": "Kunde inte läsa AMMC-status: {msg}",
"error.ammc_save_failed": "Kunde inte spara AMMC-konfig: {msg}",
"error.ammc_start_failed": "Kunde inte starta AMMC: {msg}",
"error.ammc_stop_failed": "Kunde inte stoppa AMMC: {msg}",
"error.print_blocked": "Popup blockerad. Tillåt popup-fönster för att skriva ut.",
"error.pdf_export_failed": "PDF-export misslyckades: {msg}"
},
en: {
"nav.dashboard": "Dashboard",
"nav.dashboard_sub": "Overview and live status",
"nav.race_day": "Race Day",
"nav.race_day_sub": "Preflight, heat queue, and race operation",
"race_day.current": "Running / selected",
"race_day.next": "Next",
"race_day.after_next": "After next",
"race_day.none": "None",
"race_day.no_session": "No session selected",
"race_day.no_session_hint": "Create sessions in Race Setup, then select a heat here.",
"race_day.control": "Race Control",
"race_day.control_hint": "Start only when preflight is green. Advanced configuration remains in Race Setup.",
"race_day.ready": "Ready to start",
"race_day.not_ready": "Start blocked",
"race_day.activate": "Select session",
"race_day.finish": "Finish heat",
"race_day.start_list": "Start list",
"race_day.live_title": "Live: {name}",
"race_day.live_title_done": "Result: {name}",
"race_day.live_hint": "Updated every second. Purple = the heat's fastest lap, green = a personal best on the last lap, the bar = how far into the lap the car is (red = late).",
"race_day.live_pos": "Pos",
"race_day.live_driver": "Driver",
"race_day.live_laps": "Laps",
"race_day.live_last": "Last",
"race_day.live_best": "Best",
"race_day.live_gap": "To car ahead",
"race_day.live_leader": "To leader",
"race_day.live_estimate": "Estimated finish",
"race_day.live_result": "Result",
"race_day.live_seed": "Seeding",
"race_day.live_empty": "No laps yet.",
"race_day.no_start_list": "No start list is available for this session.",
"sync.connecting": "Connecting to server",
"sync.connected": "Server connected",
"sync.saved": "Changes saved",
"sync.pending": "Changes waiting to save",
"sync.saving": "Saving to server…",
"sync.error": "Save failed",
"sync.offline": "Server disconnected",
"sync.stale": "Server status is stale",
"sync.retry": "Retry",
"sync.loaded": "Data loaded {time}",
"sync.saved_at": "Saved {time}",
"sync.stale_hint": "Displayed data may be out of date.",
"race_day.preflight": "Preflight",
"race_day.check_summary": "{blockers} blocking start · {warnings} warnings",
"race_day.heat_queue": "Heat queue",
"race_day.select": "Select",
"race_day.open_practice_any": "All incoming transponders are allowed",
"race_day.count": "{count} registered",
"race_day.missing_count": "{count} missing transponder",
"race_day.not_required": "Not required",
"race_day.check_ok": "OK",
"race_day.check_warning": "Check before start",
"race_day.check_error": "Must be fixed",
"race_day.check_session": "Session selected",
"race_day.check_backend": "Backend and automatic backup",
"race_day.check_decoder_clock": "Decoder clock",
"race_day.decoder_clock_ahead": "{amount} ahead of the computer – set the decoder's clock (summer/winter time?). A heat's first lap and passes in the mobile profile go wrong.",
"race_day.decoder_clock_behind": "{amount} behind the computer – set the decoder's clock (summer/winter time?). A heat's first lap and passes in the mobile profile go wrong.",
"race_day.check_decoder": "Main decoder",
"race_day.check_split_decoder": "Split decoder",
"race_day.check_pit_decoders": "Pit decoders",
"race_day.check_lap_window": "Min/max lap time",
"race_day.check_participants": "Participants",
"race_day.check_transponders": "Transponders",
"race_day.check_duplicate_transponders": "Duplicate transponders",
"race_day.check_duplicate_team_members": "Driver/car on multiple teams",
"race_day.check_grid": "Start grid",
"race_day.check_audio": "Race audio",
"race_day.lap_window_edit": "Adjust lap limits",
"race_day.lap_window_hint": "Min rejects shortcuts. Max ends the statistics stint while the lap still counts in the race. Applies to new passings.",
"race_day.min_lap_sec": "Min sec",
"race_day.max_lap_sec": "Max sec",
"race_day.lap_window_invalid": "Max must be greater than min and both values must be positive.",
"race_day.backup_failed_confirm": "Automatic backup failed: {msg}\n\nStart anyway?",
"race_day.start_failed": "The session could not be started.",
"nav.group_start": "Start",
"nav.group_create": "Create",
"nav.group_run": "Run and follow",
"nav.group_register": "Directory",
"nav.group_system": "System and help",
"nav.events": "Sponsor Events",
"nav.events_sub": "Sponsor events and shared cars",
"nav.series": "Series / cup",
"nav.series_sub": "Points across several races",
"series.title": "Series and cups",
"series.hint": "Group several races into a series with points per place. Choose classes, points table and how many results count. Standings are per class.",
"series.new": "New series",
"series.new_name": "Series {year}",
"series.none": "No series yet.",
"series.unnamed": "Unnamed series",
"series.settings": "Settings",
"series.step1": "1 · Name and classes",
"series.step1_hint": "Tick the classes that are part of the series. Each class gets its own standings.",
"series.step2": "2 · Points",
"series.step2_hint": "Who scores, the points table and how many results count.",
"series.step3": "3 · Rounds ({count})",
"series.step4": "4 · Standings",
"series.classes_all": "All",
"dashboard.quick_title": "Common tasks",
"dashboard.quick_practice": "Start practice",
"dashboard.quick_practice_hint": "Continues the running Open Practice or starts a new one - straight to Race Day.",
"dashboard.quick_race": "Create race",
"dashboard.quick_race_hint": "Qualifying and finals for one event.",
"dashboard.quick_series": "Create series",
"dashboard.quick_series_hint": "Several rounds with points and standings.",
"timing.run_on_race_day": "Start, pause, finish and new practice day are done on Race Day.",
"timing.open_race_day": "Go to Race Day",
"race_day.quick_title": "Quick actions",
"race_day.start_practice": "Start practice",
"race_day.pause_practice": "Pause",
"race_day.resume_practice": "Resume",
"race_day.finish_practice": "Finish practice",
"race_day.quick_practice_new": "Start practice",
"race_day.quick_practice_continue": "Continue practice: {name}",
"race_day.quick_practice_show": "Practice running: {name}",
"race_day.quick_layout": "New track layout",
"race_day.quick_race": "Create race",
"race_day.pick_session": "Session",
"race_day.show_all_sessions": "Show all sessions",
"race_day.go_next": "Next: {name}",
"race_day.hidden_sessions": "({count} from other days hidden)",
"race_day.restart_session": "Run again",
"race_day.reset_session_hint": "A stopped or finished heat, qualifier or final: laps, results and clock are reset and it can be started again.",
"race_day.reset_session_confirm": "Run \"{name}\" again?\n\nEvery lap and result is cleared and the clock is back at zero - then press Start. This cannot be undone.",
"race_day.new_practice_day": "Reset – new practice day",
"race_day.new_practice_day_hint": "Clears today's laps in timing. Every lap stays in the training statistics.",
"race_day.new_practice_day_confirm": "Start a new practice day in \"{name}\"?\n\nToday's laps are cleared in timing (the leaderboard starts over). Every lap stays in the training statistics.",
"timing.live_elsewhere": "Laps are being recorded on \"{name}\", which is running - not on the selected session.",
"timing.show_live": "Show it",
"overlay.obs_show_position_change": "Places since the start (▲/▼) in races",
"overlay.position_change_title": "Places gained (▲) or lost (▼) since the start",
"settings.public_address_title": "Public address (domain / DynDNS)",
"settings.public_address_hint": "Used for every driver's mobile profile: links and QR codes are built with this address, e.g. https://club.dyndns.org or https://club.example:8443. Leave empty to use this computer's local network address (works on the same wifi only).",
"settings.public_address_in_use": "In use: {url}",
"settings.public_address_local": "No public address - links and QR codes use this computer's local network address.",
"training.public_address_local": "the local network (no public address set)",
"training.public_address_change": "Change in Settings",
"series.round_participants": "Drivers: {count} of {total} in the class",
"series.copy_previous": "Copy from previous",
"series.no_previous_round": "No earlier round in the same class.",
"series.no_class_drivers": "No drivers in the class yet - add one below.",
"series.new_driver_name": "New driver - name",
"series.add_driver": "Add",
"series.no_rounds": "No rounds yet - create them above.",
"series.col_date": "Date",
"series.col_race": "Race",
"series.col_drivers": "Drivers",
"series.col_qual": "Qualifying rounds",
"series.col_qual_short": "Qualifying",
"series.col_qual_hint": "Number of qualifying rounds. The number of heats per round follows the number of drivers.",
"series.col_finals": "Finals",
"series.col_per_heat": "Max cars/heat",
"series.col_status": "Status",
"series.base_format": "Format",
"series.seed_practice": "Seeding practice before qualifying",
"series.seed_practice_min": "Practice, minutes",
"series.seed_method": "Seed on",
"series.seed_laps": "Number of laps (N)",
"series.seed_best_lap": "Best single lap",
"series.seed_practice_name": "Seeding practice",
"series.seed_hint": "Each round gets a practice first. \"Generate qualifying\" then splits the heats on the practice times, so drivers of equal pace run together. \"Reseed upcoming qualifying\" in the race re-splits on the qualifying standings.",
"series.make_qualifying": "Create qualifying",
"series.make_finals": "Create finals",
"series.open_race": "Open",
"series.result_button": "Result",
"series.result_title": "Correct the round's result",
"series.result_hint": "Set the right finishing order for the day, winner first. It replaces the calculated result in the standings, e.g. when the qualifying went wrong. Drivers not listed get no points for the round.",
"series.result_up": "Move up",
"series.result_down": "Move down",
"series.result_remove": "Remove",
"series.result_add": "Add driver",
"series.result_save": "Save result",
"series.result_clear": "Use the calculated result",
"series.result_clear_confirm": "Remove the corrected result and score the round from its heats again?",
"series.result_manual": "Corrected result",
"series.remove_round": "Remove from the series (the race is kept)",
"series.remove_round_confirm": "Remove the round from the series? The race and its results are kept.",
"series.no_participants": "Pick at least one driver first (click the number of drivers).",
"series.heats_made": "{heats} heats per round",
"series.status_not_started": "Not started",
"series.status_qual_ready": "Qualifying created",
"series.status_qual_running": "Qualifying running",
"series.status_qual_done": "Qualifying done",
"series.status_finals": "Finals",
"series.status_done": "Done",
"series.add_existing": "Add an existing race",
"series.add_existing_pick": "Pick a race ...",
"series.no_date": "no date",
"series.delete": "Delete series",
"series.classes_none": "None",
"series.classes_hint": "{count} selected.",
"series.autosave": "Changes are saved straight away.",
"series.name": "Name",
"series.name_placeholder": "e.g. Winter Championship 2026/2027",
"series.scoring": "Who scores series points",
"series.scoring_all": "Every driver (open series)",
"series.scoring_club": "Club members only",
"series.club": "Club",
"series.club_placeholder": "e.g. Östersunds RC",
"series.club_hint": "Drivers from other clubs race and appear in the day result but get no series points; members are re-ranked without them. The club comes from the driver register.",
"series.subtitle_members": "members of {club} only",
"series.classes": "Classes (one table per class)",
"series.no_classes": "Create classes first under Classes.",
"series.points_preset": "Points table",
"series.preset_orc": "100, 90, 82, 75, 69 ... (-4, min 10)",
"series.preset_hundred": "100, 80, 70, 60, 50 ... (-5, min 5)",
"series.preset_f1": "F1: 25, 18, 15, 12, 10 ...",
"series.preset_custom": "Custom",
"series.points_table": "Points for place 1, 2, 3 ...",
"series.points_table_hint": "Comma separated, e.g. 100, 80, 70, 60.",
"series.points_after": "After the table: minus per place / minimum",
"series.points_after_hint": "0 / 0 = no points after the table.",
"series.count_mode": "Counted results",
"series.count_best": "Best N count",
"series.count_drop": "All completed except the X worst",
"series.count_value": "N or X",
"series.count_hint": "E.g. best 9 of 12, or drop 3 (adjusts automatically if a race is cancelled). Absence = 0 and can be dropped.",
"series.count_rule": "counted: {rule}",
"series.count_best_value": "best {count}",
"series.count_drop_value": "all but the {count} worst",
"series.events": "Rounds ({count})",
"series.events_hint": "Create all rounds in one go (one race per date and class). Then run each round from here: pick drivers, change the number of qualifying rounds and finals, create qualifying - heats are split by how many drivers take part - and then finals.",
"series.no_events": "No races in the selected classes yet - create them below.",
"series.create_dates": "Create rounds for dates",
"series.create_dates_hint": "One date per line (YYYY-MM-DD). One race is created per date and selected class.",
"series.create_dates_invalid": "Enter at least one date as YYYY-MM-DD.",
"series.create_events": "Create rounds",
"series.pick_classes_first": "Choose at least one class in step 1 first.",
"series.standings": "Standings",
"series.print": "Print",
"series.starts": "Starts",
"series.total": "Total",
"series.counted_of": "{counted} counted of {completed} run ({total} planned)",
"series.no_results": "No rounds run yet.",
"series.legend": "Number = series points. (In brackets) = dropped result. – = did not take part. Ties: most wins, then 2nd places etc., then the latest common round.",
"series.delete_confirm": "Delete the series \"{name}\"?",
"series.delete_races_confirm": "Also delete the series' {count} races from Race Setup, with heats and results?\n\nOK = delete the races\nCancel = keep the races (e.g. for the results archive)",
"series.created_rounds": "{count} races created. They are listed below and under Race Setup.",
"series.created_none": "No new races were created: the series' classes already have races on those dates.",
"series.run_seeding": "Seeding practice",
"series.run_seeding_groups": "Seeding practice ({count} groups)",
"series.seed_group_size": "Max drivers per seeding group",
"series.col_seed_group": "Max drivers/seed group",
"series.col_seed_group_hint": "The most drivers in each seeding group, not the number of groups: 10 drivers with 5 give 2 groups (0 = all together). The groups are split on the series standings when you press ▶ Seeding practice.",
"series.run_session": "Run {name}",
"series.show_live": "Running: {name}",
"series.skip_seeding": "Skip – generate qualifying",
"series.run_hint": "Selects the session and opens Race Day - press Start there.",
"nav.race_setup": "Race Setup",
"nav.race_setup_sub": "Open Practice, club races and endurance",
"nav.overlay": "Overlay",
"nav.overlay_sub": "External leaderboard screen",
"nav.classes": "Classes",
"nav.classes_sub": "Manage competition classes",
"nav.drivers": "Drivers",
"nav.drivers_sub": "Drivers and personal transponders",
"nav.cars": "Cars",
"nav.cars_sub": "Track cars with fixed transponders",
"nav.training": "Training stats",
"nav.training_sub": "Development, milestones and rewards per driver",
"nav.archive": "Results archive",
"nav.archive_sub": "Search completed races without going through Race Setup",
"archive.title": "Results archive",
"archive.hint": "Search all completed sessions by date, class or driver.",
"archive.search": "Search",
"archive.search_placeholder": "Event or session name",
"archive.class": "Class",
"archive.all_classes": "All classes",
"archive.driver": "Driver",
"archive.all_drivers": "All drivers",
"archive.date_from": "From date",
"archive.date_to": "To date",
"archive.date": "Date",
"archive.event": "Event",
"archive.session": "Session",
"archive.layout": "Layout",
"archive.drivers": "Drivers",
"archive.winner": "Winner",
"archive.penalties_short": "Penalties",
"archive.view": "View",
"archive.no_results": "No completed sessions match the filters.",
"archive.standings": "Results",
"archive.no_standings": "No results recorded.",
"archive.penalties": "Penalties and corrections",
"archive.action": "Action",
"archive.detail": "Detail",
"archive.no_penalties": "No penalties or corrections recorded for this session.",
"archive.adjustment_correction": "Correction",
"archive.adjustment_invalid": "Invalidation",
"archive.adjustment_undo": "Undone",
"archive.lap_history": "Lap history per driver",
"archive.close": "Close",
"archive.export_pdf": "Export PDF",
"archive.export_json": "Export race package (JSON)",
"nav.timing": "Timing",
"nav.timing_sub": "Live timing board",
"nav.judging": "Judging",
"nav.judging_sub": "Corrections and penalties",
"nav.settings": "Settings",
"nav.settings_sub": "Decoder, backend and storage",
"nav.guide": "Guide",
"nav.guide_sub": "Documentation and setup",
"ui.language": "Language",
"ui.theme": "Theme",
"ui.theme_dark": "RaceCore",
"ui.theme_nord": "Nord",
"ui.theme_light": "Light",
"brand.title": "RC RaceCore",
"brand.subtitle": "Live Timing & Race Control",
"ui.no_active_session": "No Active Session",
"ui.event": "Event",
"ui.decoder_online": "Decoder Online",
"ui.decoder_offline": "Decoder Offline",
"training.eyebrow": "Driver development",
"training.intro": "Track practice across sessions and make progress visible between race days.",
"training.overview_title": "Practice overview",
"training.overview_intro": "Review recorded club practice by driver and class. Select a driver for personal goals, recommendations, and detailed statistics.",
"training.select_driver": "Select driver...",
"training.back_overview": "Back to overview",
"training.registered_drivers": "Registered drivers",
"training.active_drivers": "Drivers with practice",
"training.profile_count_note": "Unique driver profiles",
"training.with_training_data": "With valid practice laps",
"training.overview_class_hint": "Every class is listed separately so lap times and statistics from categories such as 2WD and 4WD are never combined.",
"training.driver": "Driver",
"training.class": "Class",
"training.no_drivers_title": "No driver registered",
"training.no_drivers_body": "Create a driver first. Training statistics require passings linked to a registered driver.",
"training.total_laps": "Total laps",
"training.valid_laps": "Valid recorded laps",
"training.sessions": "Sessions",
"training.recorded_sessions": "With recorded driver laps",
"training.best_lap": "Best lap",
"training.personal_best": "Personal best in stored data",
"training.consistency": "Spread",
"training.last_30_laps": "P10-P90, latest 30 laps",
"training.recommendation": "Recommended practice session",
"training.plan_baseline_title": "Build a baseline",
"training.plan_baseline_body": "Drive calmly and consistently until at least 10 clean laps are recorded. Repeat the same line and braking point every lap.",
"training.plan_consistency_title": "Raise your minimum level",
"training.plan_consistency_body": "Lap spread is high. Run the first block near maximum pace, then a controlled block at 80-90 percent where clean, repeatable laps matter more than one fast lap.",
"training.plan_progression_title": "Balance pace and control",
"training.plan_progression_body": "You have a stable baseline. Run one block at maximum focus and finish with a controlled block aiming for an unbroken sequence of consistent laps.",
"training.plan_target": "Control target around {lap}",
"training.plan_no_target": "Record more laps to calculate a target",
"training.block_push": "Maximum focus: find the limit",
"training.block_control": "80-90%: raise the floor",
"training.flexible_duration": "Custom time",
"training.block_one": "Block 1",
"training.block_two": "Block 2",
"training.new_goal": "New milestone",
"training.manage_goals_sharing": "Goals and mobile profile",
"training.manage_goals_sharing_hint": "Create reward goals or manage the driver's share link.",
"training.target_laps": "Target laps",
"training.quick_targets": "Quick lap targets",
"training.goal_type": "Goal type",
"training.goal_type_laps": "Number of laps",
"training.goal_type_evenLaps": "Completed Even laps sessions",
"training.goal_type_stepTraining": "Completed Step training sessions",
"training.goal_type_timer": "Completed practice sessions (timer)",
"training.target_sessions": "Number of sessions",
"training.exercise_kind_timer": "Practice session",
"training.exercise_kind_evenLaps": "Even laps",
"training.exercise_kind_stepTraining": "Step training",
"training.exercise_history_title": "Completed training sessions",
"training.exercise_history_hint": "Even laps, Step training and regular practice sessions the driver has completed - see progress over time.",
"training.exercise_history_empty": "No completed training sessions yet for this driver and class.",
"training.exercise_history_evenLaps": "{streak}-lap streak at target {lap}",
"training.exercise_history_stepTraining": "{steps} steps, {laps} laps",
"training.exercise_history_timer": "{laps} laps, average {lap}",
"training.goal_name": "Milestone name",
"training.goal_name_placeholder": "For example Bronze level",
"training.reward": "Reward",
"training.reward_placeholder": "For example a new body or club badge",
"training.add_goal": "Add milestone",
"training.goals": "Milestones and rewards",
"training.no_goals": "This driver has no milestones yet.",
"training.default_goal_title": "Reach {laps} laps",
"training.default_goal_title_sessions": "Complete {count} {kind} sessions",
"training.goal_progress": "Milestone progress",
"training.goal_remaining": "{laps} laps remaining",
"training.goal_remaining_sessions": "{count} sessions remaining",
"training.goal_reached": "Milestone reached",
"training.goal_claimed": "Reward delivered",
"training.claim_reward": "Mark reward delivered",
"training.training_days": "Practice days",
"training.sessions_count": "{sessions} recorded sessions",
"training.next_level": "Next automatic level",
"training.next_level_target": "Reach {laps} laps",
"training.average_lap": "Average lap",
"training.recent_average": "Latest 30 average",
"training.controlled_streak": "Flow streak",
"training.control_zone": "Control zone",
"training.outlier_laps": "Outlier laps",
"training.strong_finishes": "Strong finishes",
"training.lap_count": "{laps} laps",
"training.last_activity": "Latest activity",
"training.no_activity": "No activity yet",
"training.history": "Daily practice history",
"training.detailed_stats": "More statistics",
"training.detailed_stats_hint": "30-minute pace, setup changes, stint analysis, split timing, pit stops, and history.",
"training.pace_30_title": "Pace per active 30-minute block",
"training.pace_30_hint": "Only blocks with driving are shown. Pace uses a trimmed average so isolated crashes do not control the block.",
"training.no_pace_data": "There are not enough laps for a pace map yet.",
"training.weekday_pace": "Pace by weekday",
"training.weekday_hint": "Shown after at least three practice days and includes only days with driving.",
"training.weekday_needs_days": "At least three practice days are required for a meaningful comparison.",
"training.add_marker": "Mark a car change",
"training.add_marker_hint": "The marker is saved now for the selected driver and class. The system compares 30 minutes before and after.",
"training.marker_type": "Change type",
"training.marker_setup": "New setup",
"training.marker_tires": "Changed tires",
"training.marker_suspension": "Changed suspension",
"training.marker_car": "Changed car",
"training.marker_note": "Custom note",
"training.marker_description": "Description",
"training.marker_placeholder": "For example softer front springs",
"training.mark_now": "Mark change now",
"training.no_markers": "There are no setup markers in this class.",
"training.marker_collecting": "Collecting data ({before} before / {after} after)",
"training.marker_improved": "{lap} faster after the change",
"training.marker_slower": "{lap} slower after the change",
"training.stint": "Stint",
"training.start": "Start",
"training.trimmed_pace": "Normal pace",
"training.race_pace_10": "Race pace 10",
"training.mistakes": "Outlier laps",
"training.start_end": "Pace retention",
"training.strong_finish": "Strong finish",
"training.insufficient_data": "Not enough data",
"training.no_stints": "No stints are available yet.",
"training.stint_faster": "{lap} faster",
"training.stint_slower": "{lap} slower",
"training.stint_same": "Unchanged",
"training.stint_analysis": "Stint analysis",
"training.stint_analysis_hint": "A passing over the configured maximum lap time, or a break over two minutes without a max limit, starts a new stint. The transition lap counts in the race but not in pace. The 5-minute result covers 300 seconds plus the final started lap.",
"training.best_stint": "Best stint {stint}: {laps} laps, {pace}",
"training.stint_five_minute": "5-minute result",
"training.stint_duration": "Stint duration",
"training.average_short": "avg",
"training.show_all_stints": "Show all {count} stints",
"training.stats_method": "Normal pace uses a trimmed average. An outlier lap is more than 15% slower than the stint median. A strong finish means the closing pace is at least 99% of the starting pace. At least 3 laps are required for consistency and 10 for Race pace 10.",
"training.split_passings": "Split passings",
"training.best_split": "Best split",
"training.latest_sector_gain": "Latest sector improvement",
"training.average_split": "Average split",
"training.pit_stops": "Pit stops",
"training.total_pit_time": "Total pit time",
"training.average_pit_stop": "Average pit stop",
"training.best_pit_stop": "Best pit stop",
"training.recent_pit_stops": "Recent pit stops",
"training.no_history": "No practice history is available yet.",
"training.date": "Date",
"training.laps": "Laps",
"training.pb_improvement": "Latest 30: {lap} faster",
"training.public_profile": "Driver mobile profile",
"training.public_profile_active": "Active",
"training.public_profile_off": "Disabled",
"training.public_profile_help": "Create a personal mobile view with practice statistics, goals, rewards, a timer, and a restricted car-change marker.",
"training.public_profile_private": "The link contains a unique secret key. It does not show transponder IDs, other drivers or admin controls.",
"training.public_sections": "Visible in mobile profile",
"training.public_sections_hint": "Changes are saved immediately. Disabled sections are not sent to the public profile.",
"training.public_section_progress": "Development and chart",
"training.public_section_achievements": "Achievements",
"training.public_section_performance": "Stints and performance",
"training.public_section_goals": "Goals and rewards",
"training.public_section_history": "Practice history",
"training.public_profile_link": "Personal share link",
"training.public_base_url": "Public address or FQDN",
"training.public_base_url_hint": "Example: https://training.example.org. Leave empty to use the address where RaceCore was opened.",
"training.save_public_url": "Save address",
"training.detect_public_ip": "Detect public IP",
"training.detecting_public_ip": "Detecting public IP...",
"training.detected_public_ip": "Public IP found: {address}. Use the FQDN when the certificate has a domain name, then save.",
"training.detect_public_ip_failed": "Could not detect the public IP. Enter the FQDN manually.",
"training.public_url_invalid": "Enter a complete http or https address.",
"training.local_profile_qr": "Local QR code",
"training.local_profile_qr_hint": "RaceCore server LAN address",
"training.public_profile_qr": "Public QR code",
"training.public_profile_qr_hint": "The local QR works on the same network. The public QR uses the saved FQDN or public IP.",
"training.copy_link": "Copy link",
"training.open_profile": "Open profile",
"training.replace_link": "Create new link",
"training.disable_profile": "Disable profile",
"training.enable_profile": "Enable mobile profile",
"training.replace_link_confirm": "The old link will stop working immediately. Create a new one?",
"training.club_progress": "Club practice overview",
"training.club_progress_hint": "Follow activity, total laps, and each personal target without driver ranking.",
"training.next_target": "Next target",
"training.start_personal": "Open personal training",
"training.copy_mobile_link": "Copy mobile link",
"training.create_personal_link": "Create personal training link",
"training.live_now": "Live now",
"training.active_practice": "Active practice",
"training.shared_practice": "Shared practice",
"training.session_laps": "Session laps",
"training.latest_lap": "Latest lap",
"training.live_practice_hint": "Everyone can keep driving in the same Open/Free Practice. This card shows only the selected driver's valid laps since the current session started.",
"training.evenlaps_eyebrow": "Exercise",
"training.evenlaps_title": "Even laps",
"training.evenlaps_hint": "Set a target lap time and tolerance below to get started. Every lap within tolerance extends the streak.",
"training.evenlaps_streak": "{current}/{target} even laps",
"training.evenlaps_new_streak": "New streak - try to beat your best",
"training.evenlaps_start_hint": "Run your first lap to start a streak.",
"training.evenlaps_best_today": "Best streak today: {best}",
"training.evenlaps_target": "Target",
"training.evenlaps_last_lap": "Latest lap",
"training.evenlaps_target_label": "Target lap time (seconds)",
"training.evenlaps_tolerance_label": "Tolerance ± (seconds)",
"training.evenlaps_lapcount_label": "Laps in the streak",
"training.evenlaps_save": "Save",
"training.evenlaps_suggestion_hint": "Suggested from your best lap: {lap}",
"training.steptraining_eyebrow": "Exercise",
"training.steptraining_title": "Step training",
"training.steptraining_hint": "Build your step sequence below to get started. The default is the classic pyramid: calm, controlled, fast, controlled, calm.",
"training.steptraining_complete": "Sequence complete - nice work!",
"training.steptraining_current": "Step {step}/{total}: {effort}",
"training.steptraining_remaining": "{laps} laps remaining",
"training.steptraining_controlled_compare": "Controlled step 1: {first} · Controlled step 2: {last} ({diff})",
"training.steptraining_config_hint": "Set 0 laps to skip a step. Calm/controlled/fast is a feel, not an exact time - the system can't measure how hard you're pushing.",
"training.steptraining_save": "Save",
"training.steptraining_effort_calm": "Calm",
"training.steptraining_effort_controlled": "Controlled",
"training.steptraining_effort_fast": "Fast",
"training.stints": "Stints",
"training.best_three": "Best 3 consecutive",
"training.best_five": "Best 5 min",
"training.five_avg_pace": "Average pace, best 5 min",
"training.your_progress": "Your own curve",
"training.recent_trend": "Recent development",
"training.pace_trend": "Average pace",
"training.consistency_trend": "Consistency",
"training.trend_collecting": "Collecting comparable data",
"training.trend_collecting_short": "At least 20 laps required",
"training.trend_faster": "{lap} faster per lap",
"training.trend_slower": "{lap} slower right now",
"training.trend_stable": "Stable level",
"training.consistency_better": "{value} percentage points more consistent",
"training.consistency_building": "Keep building consistency",
"training.trend_hint": "Compares the latest 30 valid laps with the preceding 30 in the same class. This is personal development, not a comparison with other drivers.",
"training.personal_credit": "Progress that counts",
"training.achievements": "Achievements",
"training.achievement_unlocked": "Unlocked",
"training.achievement_next": "Next milestone",
"training.achievement_empty": "Complete the first practice session to start collecting achievements.",
"training.achievement_first_session": "First practice session",
"training.achievement_laps_100": "100 practice laps",
"training.achievement_laps_250": "250 practice laps",
"training.achievement_laps_500": "500 practice laps",
"training.achievement_laps_1000": "1,000 practice laps",
"training.achievement_laps_1500": "1,500 practice laps",
"training.achievement_days_3": "3 practice days",
"training.achievement_days_10": "10 practice days",
"training.achievement_sessions_5": "5 completed practice sessions",
"training.achievement_controlled_5": "5 controlled laps in a row",
"training.achievement_controlled_10": "10 controlled laps in a row",
"training.achievement_five_minute": "Completed five-minute stint",
"training.achievement_five_minutes_3": "3 completed five-minute stints",
"training.achievement_consistency_5": "Consistency below 5 percent",
"training.achievement_strong_finish": "Strong finish",
"training.achievement_clean_five_minute": "Five minutes without outlier laps",
"training.achievement_pace_gain": "Improved average pace",
"training.credit_eyebrow": "Your practice counts",
"training.credit_today_title": "Good work, {driver}!",
"training.credit_today_body": "Every completed lap builds experience. These are today's wins.",
"training.credit_ready_title": "Ready when you are, {driver}",
"training.credit_ready_body": "You do not need to beat anyone else. Start with one calm lap and build from there.",
"training.highlight_today_laps": "{laps} valid laps today",
"training.highlight_personal_best": "Personal best improved by {lap}",
"training.highlight_pace_gain": "Average pace improved by {lap} per lap",
"training.highlight_consistency_gain": "{value} percentage points more consistent",
"training.highlight_controlled_streak": "{laps} controlled laps in a row today",
"training.highlight_five_minute": "{count} completed five-minute stint today",
"training.highlight_sector_gain": "Sector time improved by {lap}",
"training.highlight_strong_finish": "{count} strong finish today",
"training.highlight_clean_five_minute": "{count} five-minute run without outlier laps",
"training.highlight_keep_building": "{laps} laps have already built your experience",
"training.highlight_ready": "Your first valid lap starts the development journey",
"training.optional_challenges": "Optional, no pressure",
"training.daily_missions": "Today's challenges",
"training.daily_missions_hint": "Three small goals reset every day. They recognize volume, control, and endurance in the selected class.",
"training.mission_laps_today": "Collect 20 laps",
"training.mission_controlled_today": "Run 5 controlled laps in a row",
"training.mission_five_minute_today": "Complete a five-minute stint",
"training.mission_progress": "{current} / {target}",
"training.together": "Everyone contributes",
"training.club_goal": "Shared club goal",
"training.club_goal_active": "Club challenge",
"training.club_goal_reached": "Goal reached",
"training.club_goal_celebrated": "Goal celebrated",
"training.club_goal_default": "Together to {laps} laps",
"training.club_goal_default_sessions": "Together to {count} {kind} sessions",
"training.club_goal_remaining": "{laps} club laps remaining",
"training.club_goal_remaining_sessions": "{count} club sessions remaining",
"training.club_goal_empty": "Start a shared target where every valid practice lap from every driver contributes.",
"training.club_goal_create": "Create club goal",
"training.club_goal_new": "Start a new club goal",
"training.club_goal_name_placeholder": "For example Club to 10,000",
"training.club_goal_reward_placeholder": "For example a shared pizza night",
"training.club_goal_start": "Start club goal",
"training.club_goal_baseline_hint": "The target starts at zero when saved. Earlier practice laps remain in statistics but do not count toward the new club goal.",
"training.club_goal_mark_celebrated": "Mark as celebrated",
"training.club_goal_delete": "Delete club goal",
"training.progress_feed": "Latest club progress",
"training.progress_not_positions": "Development, not position",
"training.feed_personal_best": "new PB, improved by {lap}",
"training.feed_average_gain": "average improved by {lap}",
"training.feed_five_minute": "completed 5 minutes with {laps} laps",
"training.feed_controlled_streak": "{laps} controlled laps in a row",
"training.feed_practice_laps": "{laps} valid practice laps",
"training.feed_empty": "Personal progress appears here when drivers start practicing.",
"mode.track": "Track Event",
"mode.race": "Race",
"dashboard.events": "Events",
"dashboard.drivers": "Drivers",
"dashboard.cars": "Cars",
"dashboard.passings": "Passings",
"dashboard.created": "Created",
"dashboard.registered": "Registered",
"dashboard.track_fleet": "Track Fleet",
"dashboard.captured": "Captured",
"dashboard.live_session": "Live Session",
"dashboard.idle": "idle",
"dashboard.duration": "Duration",
"dashboard.no_session": "No session is active. Go to Events or Timing to create/start one.",
"dashboard.quick_actions": "Quick Actions",
"dashboard.create_event": "Create Event",
"dashboard.open_race_day": "Open Race Day",
"dashboard.open_timing": "Open Timing Board",
"dashboard.connect_decoder": "Connect Decoder",
"dashboard.recent_sessions": "Recent Sessions",
"dashboard.free_practice": "Free Practice",
"dashboard.open_practice": "Open Practice",
"dashboard.live_board": "Live Board",
"dashboard.decoder_feed": "Decoder feed",
"dashboard.backend_link": "Backend link",
"dashboard.audio_profile": "Audio profile",
"dashboard.schedule_drift": "Schedule drift",
"dashboard.schedule_plan": "Planned time",
"dashboard.schedule_actual": "Actual time",
"dashboard.on_time": "On time",
"dashboard.ahead": "Ahead of schedule",
"dashboard.behind": "Behind schedule",
"dashboard.live_note": "Quick operations panel for connection, overlay and audio. Deeper configuration remains under Settings.",
"dashboard.get_started": "Getting started",
"dashboard.get_started_hint": "Follow this order for initial setup. For a normal practice evening, the Start practice button above is all you need.",
"dashboard.step_system": "1. Connect the system",
"dashboard.step_system_hint": "Configure backend, decoder and AMMC in Settings.",
"dashboard.step_register": "2. Build the directory",
"dashboard.step_register_hint": "Add classes, drivers and cars when named results are required.",
"dashboard.step_create": "3. Create a run",
"dashboard.step_create_hint": "Start a simple Open Practice or build club races, endurance and sponsor events.",
"dashboard.step_run": "4. Run and display",
"dashboard.step_run_hint": "Start, pause and finish on Race Day. Follow the times in Timing and open Overlay on an external display.",
"dashboard.open_settings": "Open Settings",
"dashboard.open_register": "Open Drivers",
"dashboard.open_race_setup": "Open Practice / Race Setup",
"dashboard.open_overlay": "Open Overlay",
"dashboard.untimed": "No time limit",
"session.none_yet": "No sessions yet.",
"classes.create": "Create Class",
"classes.placeholder": "Class name (e.g. 2WD Buggy)",
"classes.add": "Add Class",
"classes.title": "Classes",
"drivers.create": "Create Driver",
"drivers.name_placeholder": "Driver name",
"drivers.brand_placeholder": "Team / brand (optional)",
"drivers.brand_filter_placeholder": "Search name / transponder / brand / club / country",
"drivers.transponder_placeholder": "Personal transponder (optional)",
"drivers.transponder_conflict_confirm": "Transponder {tp} is already used by {name} ({class}). Save anyway?",
"drivers.speech_name": "Spoken name",
"drivers.voice_test": "🔊 Test pronunciation",
"drivers.speech_name_placeholder": "Pronunciation for announcements (optional)",
"drivers.speech_name_hint": "Enter the name as the voice should pronounce it, or a nickname. Leave blank to use the regular driver name. Try it with 🔊.",
"drivers.training_profile": "Practice profile",
"drivers.training_profile_hint": "Link multiple class and transponder entries for the same person to one shared practice profile.",
"drivers.training_profile_auto": "Automatic: same name or new profile",
"drivers.training_profile_new": "New separate profile",
"drivers.training_profile_separate": "Unlink to a new separate profile",
"drivers.club": "Club",
"drivers.club_placeholder": "Club (optional)",
"drivers.country": "Country",
"drivers.country_placeholder": "Country (optional)",
"drivers.add": "Add Driver",
"drivers.title": "Drivers",
"cars.create": "Create Track Car",
"cars.name_placeholder": "Car name or number",
"cars.brand_placeholder": "Brand / model (optional)",
"cars.brand_filter_placeholder": "Search name / transponder / brand",
"cars.transponder_placeholder": "Car transponder",
"cars.add": "Add Car",
"cars.title": "Cars",
"events.create": "Create Event",
"events.create_race": "Create Race",
"events.create_competition_race": "Create competition race",
"events.quick_open_practice_title": "Quick Open Practice",
"events.quick_open_practice_intro": "For continuous timing without a race format. Create the session and run it until you stop it.",
"events.quick_open_practice_default": "Open Practice",
"events.quick_open_practice_create": "Create and open Timing",
"events.open_practice_untimed": "Untimed",
"events.open_practice_all_transponders": "All transponders",
"events.open_practice_no_registration": "Works without registered drivers",
"events.open_practice_until_stopped": "Runs until you stop it",
"events.name_placeholder": "Event name",
"events.field_name": "Event name",
"events.field_name_hint": "Name shown in lists, overlays and results.",
"events.field_date": "Date",
"events.field_date_hint": "Event or race date used for planning and sorting.",
"events.field_class": "Class",
"events.field_class_hint": "Class used for this event or sponsor format.",
"events.add": "Add Event",
"events.add_race": "Add Race",
"events.mode_race_option": "Race (driver transponders)",
"events.mode_track_option": "Track Event (shared cars)",
"events.title": "Events",
"events.race_title": "Races",
"events.list_search": "Search races…",
"events.list_empty": "No races created yet.",
"events.list_no_date": "No date",
"events.progress_empty": "No heats yet",
"events.progress_done": "Done",
"events.progress_next": "Next: {name}",
"events.progress_count": "{done}/{total} run",
"events.group_today": "Today",
"events.group_upcoming": "Upcoming",
"events.group_nothing_planned": "Nothing planned today or later.",
"events.group_done": "Done ({count})",
"events.track_only_intro": "Create sponsor events with shared cars/transponders here.",
"events.race_only_intro": "Create proper races with personal driver transponders here.",
"events.manage": "Manage",
"events.open_timing": "Open Timing",
"events.edit": "Edit",
"events.sessions": "Sessions",
"events.participants": "Participants",
"events.select_participants": "Select race participants",
"events.select_all_participants": "Select all",
"events.clear_participants": "Clear participants",
"events.reseed_qualifying": "Reseed upcoming qualifying",
"events.reseed_done": "Upcoming qualifying heats reseeded from current standings.",
"events.no_reseed_done": "No upcoming qualifying heats could be reseeded.",
"events.reseed_locked": "{count} heats were skipped because manual grid is locked.",
"events.reseed_mismatched": "The number of participants no longer matches the generated heats in {count} round(s) - regenerate qualifying instead of relying on a partial reseed.",
"events.dns": "Did not start (DNS)",
"events.reserve_bump_slots": "Reserve bump slots in finals",
"events.bump_reserved_note": "If bump-up is used, finals can reserve slots in upper mains from the start.",
"events.actions": "Actions",
"events.manage_title": "Manage",
"events.wizard_hint": "Build the race in four steps: basics, participants, session plan and confirmation. Fine tuning happens later in Manage.",
"events.wizard_step_1": "Basics",
"events.wizard_step_2": "Participants",
"events.wizard_step_3": "Session plan",
"events.wizard_step_4": "Confirm",
"events.wizard_no_class_drivers": "No drivers exist in the selected class yet. Add drivers first or switch class.",
"events.wizard_create": "Create race",
"events.wizard_use_practice": "Create practice sessions",
"events.wizard_practice_sessions": "Practice session count",
"events.wizard_use_qualifying": "Create qualifying rounds",
"events.wizard_qualifying_rounds": "Qualifying rounds",
"events.wizard_use_team_race": "Create endurance / Team Race session",
"events.wizard_team_duration": "Team Race duration (min)",
"events.wizard_finals_note": "Finals are generated later from qualifying standings via Race actions, not directly in the wizard.",
"events.wizard_summary_title": "New race",
"events.wizard_summary_sessions": "Sessions to create",
"events.manage_step_setup": "1. Setup",
"events.manage_step_setup_hint": "Participants and teams for this race.",
"events.manage_step_format": "2. Format",
"events.manage_step_format_hint": "Practice, qualifying, finals and validation.",
"events.manage_step_generate": "3. Generation",
"events.manage_step_generate_hint": "Generate qualifying/finals, reseed and bump-up.",
"events.manage_step_live": "4. Live / results",
"events.manage_step_live_hint": "Grid and standings.",
"events.manage_tab_setup": "Participants & teams",
"events.manage_tab_format": "Format",
"events.manage_tab_live": "Live & results",
"events.manage_tab_schedule": "Schedule & print",
"events.branding": "Branding for this event",
"events.branding_note": "Leave fields empty to inherit global branding from Settings. The logo is used in overlay and embedded in PDF exports when it can be converted.",
"events.brand_name": "Brand name",
"events.brand_tagline": "Brand tagline",
"events.brand_footer": "PDF footer",
"events.brand_theme": "PDF theme",
"events.brand_logo": "Event logo",
"events.branding_use_global": "Use global default theme",
"events.branding_save": "Save branding",
"events.session_name": "Session name",
"events.duration_placeholder": "Duration (min)",
"events.max_cars_placeholder": "Max cars (optional)",
"events.start_mode": "Start mode",
"events.seed_best_laps": "Best laps for seeding",
"events.seed_method": "Seed method",
"events.seed_method_hint": "How best laps should be evaluated when seedBestLapCount is greater than 0.",
"events.seed_method_best_sum": "Best N laps, total",
"events.seed_method_average": "Best N laps, average",
"events.seed_method_consecutive": "Best N consecutive laps",
"events.stagger_gap_sec": "Stagger gap (sec)",
"events.session_settings": "Session settings",
"events.edit_session": "Settings",
"events.move_session_up": "Run earlier (move up in the running order)",
"events.move_session_down": "Run later (move down in the running order)",
"events.start_mode_mass": "Mass start",
"events.start_mode_position": "Position start",
"events.start_mode_staggered": "Staggered / individual start",
"events.start_mode_flying": "Flying start",
"events.seed_best_laps_hint": "0 = off, 2 or 3 for practice/qualifying seeding",
"events.race_format": "Race format",
"events.race_format_intro": "Set how qualifying and finals should be generated and scored for this race.",
"events.setup_mode_basic": "Basic",
"events.setup_mode_advanced": "Advanced",
"events.practice_block": "Practice / qualifying",
"events.practice_block_hint": "Build seeding, qualifying rounds and points/tie-break rules here.",
"events.finals_block": "Finals",
"events.finals_block_hint": "Control A/B/C finals, start mode, legs and bump-up here.",
"events.rules_block": "Validation and finish logic",
"events.rules_block_hint": "Min/max lap and follow-up affect both live timing and statistics.",
"events.race_summary": "Summary",
"events.race_summary_hint": "Quick check of what will actually be generated and raced.",
"events.race_summary_preset": "Preset",
"events.race_summary_participants": "Participants",
"events.race_summary_created_sessions": "Created sessions",
"events.race_summary_qualifying": "Qualifying setup",
"events.race_summary_finals": "Finals setup",
"events.race_summary_validation": "Lap window",
"events.race_summary_follow_up": "Follow-up",
"events.race_summary_focus": "Focus",
"events.race_summary_generation": "Generation",
"events.race_actions_title": "Race actions",
"events.race_actions_hint": "Generation and reseeding live separately from the format fields so setup is easier to read.",
"events.export_race_package": "Export race package",
"events.import_race_package": "Import race package",
"events.race_package_hint": "Export or import a single race with its sessions, results, and referenced directory data.",
"events.context_standard_title": "Club race mode",
"events.context_standard_hint": "Start with a preset and Basic mode. When participants and timings look right, use Race Actions for qualifying, reseeding and finals.",
"events.context_endurance_title": "Endurance mode",
"events.context_endurance_hint": "Basic mode hides most qualifying and finals fields here because endurance is normally built around Team Race. Open Advanced if the event also needs support heats or finals.",
"events.context_rules_title": "Validation example",
"events.context_rules_hint": "Example for a short technical track: 11s min / 60s max. Adjust to the real lap pace so stats and stints remain meaningful.",
"events.status_complete": "Complete",
"events.status_pending": "Pending",
"events.status_attention": "Needs action",
"events.summary_warnings_title": "Checkpoints",
"events.summary_warning_no_participants": "No race participants are selected yet.",
"events.summary_warning_no_sessions": "No sessions exist yet. Create them in the wizard or via Race Actions.",
"events.summary_warning_no_qualifying": "No qualifying sessions exist yet.",
"events.summary_warning_no_finals": "No finals exist yet.",
"events.summary_warning_no_teams": "Endurance/Team Race has no teams yet. Add teams in Setup before running.",
"events.summary_warning_invalid_lap_window": "The min/max lap window looks invalid. Max must be greater than min.",
"events.detail_drivers": "drivers",
"events.detail_teams": "teams",
"events.detail_sessions": "sessions",
"events.detail_results": "results",
"events.detail_active": "active",
"guide.manage_steps_6": "6. The status badges show whether each step is complete, pending, or needs action. The summary on the right also warns when participants, teams, or sessions are missing.",
"guide.manage_steps_7": "7. Click a warning in the summary to jump straight to the matching Manage section instead of hunting for it manually.",
"guide.manage_steps_8": "8. The step cards at the top also work as quick jumps. Click Setup, Format, Generation or Live / results to move straight to the right block - they switch tabs automatically if the block is behind a different tab.",
"guide.manage_steps_9": "9. The race Manage page is split into the Participants & teams, Format, Live & results and Schedule & print tabs instead of one long scroll. Track/sponsor events keep the simple, untabbed layout.",
"guide.schedule_title": "Race day time schedule",
"guide.card_schedule_blurb": "Set a start time and a gap between sessions, and every session's clock time is worked out automatically.",
"guide.videos_title": "Video guides",
"guide.card_videos_blurb": "Short narrated screen recordings showing how to do the most common things.",
"guide.video_connect_decoder": "Connect a decoder",
"guide.video_add_drivers_cars": "Add drivers and cars",
"guide.video_create_race": "Create a race",
"guide.video_run_session": "Run a session on Race Day",
"guide.video_settings_tabs": "The Settings tabs",
"guide.video_event_manager_tabs": "The Event Manager tabs",
"guide.video_event_schedule": "The race day schedule",
"guide.tab_start": "Getting started",
"guide.tab_create": "Create a race",
"guide.tab_run": "Run a race",
"guide.tab_training": "Training & results",
"guide.tab_series": "Series / cup",
"guide.series_title": "Series / cup",
"guide.card_series_blurb": "Group several races into a series with points per place, dropped results and standings per class.",
"guide.series_create_title": "Create a series",
"guide.series_create_1": "1. First add classes and drivers (in the right class). For a members-only series, each driver's club must be filled in under Drivers.",
"guide.series_create_2": "2. Menu Series / cup -> New series. Step 1: name and which classes are included. Each class gets its own standings; points never mix between classes.",
"guide.series_create_3": "3. Step 2: who scores (every driver, or club members only), the points table (e.g. 100, 90, 82 ... or your own list) and how many results count (best N, or all but the X worst).",
"guide.series_create_4": "4. Step 3: paste the dates (one per line) and pick a format, e.g. ÖRC Winter (3 five-minute qualifying rounds with a staggered start where most laps in the time wins, 6 per heat, 3 finals). Tick Seeding practice before qualifying (5 min, best 3 laps) and choose the heat order (fastest heat last). Press Create rounds: one race per date and class is created, and the button says how many.",
"guide.series_create_5": "5. Every change is saved straight away. An existing race can also be added to the series from the list under the table. Deleting a series asks whether its races should be removed from Race Setup too.",
"guide.series_day_title": "Each race day",
"guide.series_day_1": "1. Everything is done in the table in step 3, one row per race (date and class).",
"guide.series_day_2": "2. Click the number of drivers and untick those not racing. Copy from previous takes the field of the previous round in the class; New driver registers a late entry and ticks them.",
"guide.series_day_3": "3. Change qualifying rounds, finals and max cars per heat for that round if needed - it can differ between rounds and classes.",
"guide.series_day_4": "4. The button on the row shows the next step. Start with ▶ Seeding practice: it splits today's drivers into seeding groups (max per the Max drivers/seed group column, on the series standings - entry order in the first round), selects the first group and opens Race Day - press Start. Then ▶ Seeding practice 2 and so on. The groups are re-split until the first one has started, so late entries are included.",
"guide.series_day_5": "5. Create qualifying: the heats are split on the practice times (equal pace together, fastest heat last) and evenly by the field (9 drivers, max 6 -> 5 + 4). The row then shows ▶ Run Q1 H1, Q1 H2 ... and on Race Day ▶ Next selects the next heat. Reseed upcoming qualifying (in the race under Race Setup) re-splits on the qualifying standings.",
"guide.series_day_6": "6. When qualifying is done: Create finals, then ▶ Run C Final 1, B Final 1, A Final 1, C Final 2 ... Status shows where the round is. Open goes to the race in Race Setup. The standings in step 4 update by themselves. Did something go wrong (e.g. the qualifying)? ✎ Result on the row sets the day's finishing order by hand, and the standings follow it.",
"guide.series_points_title": "Points and standings",
"guide.series_points_1": "A round's placing: the final standings (A final before B final), then drivers without a final in qualifying order. Without finals, the qualifying order is used.",
"guide.series_points_2": "Members only: drivers from other clubs race and appear in the day result but get no points, and members are re-ranked without them.",
"guide.series_points_3": "A driver with no registered lap gets 0 points. Absence counts as 0 and can be dropped.",
"guide.series_points_4": "Best N count, or all run rounds except the X worst - then a cancelled round lowers the count by itself. Dropped results are shown in brackets.",
"guide.series_points_5": "Ties: most wins among counted results, then 2nd places etc., then the latest common round. Otherwise a shared position.",
"guide.series_points_6": "The standings can be printed or exported as PDF (wide tables switch to landscape A4). No contact details are shown.",
"guide.series_example_title": "Example: the club's winter series",
"guide.series_example_1": "12 Sundays, classes 2WD, 4WD and Rookie, points 100, 90, 82, 75, 69, 64, 60, 56, 52, 48 then -4 per place down to 10, best 9 of 12, club members only.",
"guide.series_example_2": "Step 1: tick 2WD, 4WD and Rookie. Step 2: Club members only + the club, points table 100, 90, 82 ... (-4, min 10), Best N count = 9.",
"guide.series_example_3": "Step 3: paste the 12 dates, format ÖRC Winter, seeding practice on, fastest heat last -> 36 races (12 dates × 3 classes).",
"guide.series_example_4": "Each Sunday: pick drivers per class and follow the button on the row: seeding practice, create qualifying, run the heats, create finals, run the finals. The standings per class are ready right after the last final.",
"guide.tab_videos": "Video guides",
"warmup.title": "Transponder check",
"warmup.hint": "The track is open during the count-down. Green tick = the transponder has crossed the line since the count-down began. If someone is missing, change their transponder right here, or link an unknown transponder that just crossed.",
"prologue.length": "Count-down",
"prologue.option_go": "Go - start now",
"prologue.start": "Start",
"prologue.to_start": "to the start",
"prologue.running": "Counting down",
"prologue.held": "On hold",
"prologue.hold": "Hold",
"prologue.resume": "Resume",
"prologue.plus_minute": "+1 min",
"prologue.to_30": "To 30 s",
"prologue.to_10": "To 10 s",
"prologue.go": "Go now",
"prologue.cancel": "Cancel",
"events.qual_prologue": "Count-down before qualifying",
"events.final_prologue": "Count-down before finals",
"events.prologue_hint": "Time from Start on Race Day to the start. The track is open, the announcer calls the time (EFRA: 2 min, 1 min, 30 s, 10 s) and the transponder check shows who has crossed. Can be put on hold while cars are placed on the grid.",
"warmup.seen_count": "{seen} of {total} seen",
"warmup.no_transponder": "No transponder",
"warmup.assign_unknown": "Link unknown transponder...",
"warmup.new_transponder": "New transponder",
"warmup.save": "Save",
"warmup.unknown_seen": "Unknown transponders that crossed",
"warmup.start_missing": "Not seen during the count-down: {names}. Start anyway?",
"warmup.transponder_conflict": "Transponder {transponder} is already used by {name}. Save anyway?",
"race_day.check_transponder_check": "Transponder check",
"layouts.bar_current": "Track layout: {label} - since {date}",
"layouts.bar_none": "No track layout set yet",
"layouts.new": "New layout",
"layouts.min_lap": "Min lap time (s)",
"training.source": "Based on",
"training.race_sessions": "Race sessions 🏁",
"training.race_sessions_hint": "A race runs for a fixed time and isn't split into stints. Each qualifying heat, heat and final is shown on its own.",
"training.race_session": "Race · session · series",
"training.no_race_sessions": "No race sessions yet.",
"training.source_practice": "Practice",
"training.source_race": "Races (qualifying, heats, finals) 🏁",
"training.source_all": "All",
"layouts.new_min_lap_prompt": "Minimum lap time in seconds for the new layout (empty = from the event, can be changed in Settings):",
"layouts.max_lap": "Max lap time (s)",
"layouts.lap_from_event": "from the event",
"layouts.lap_window_hint": "Optional per layout: applies to practice (Open/Free practice) on that layout. Empty = the event's min/max. Qualifying, heats and finals always use the event's values.",
"layouts.new_prompt": "Name for the new track layout (active from now). Laps driven after the switch count toward the new layout - even in an Open Practice that is already running.",
"layouts.stats_for": "Stats for",
"layouts.option_current": "Current layout",
"layouts.option_none": "No layout (before the first layout)",
"layouts.option_all": "All layouts",
"tts.title": "Voice engine",
"tts.hint": "The local voice (Piper) sounds more natural than the browser voice and works with no internet at all. Install once (needs internet just then), after that everything runs locally. If Piper is missing or slow, the browser voice is used automatically.",
"tts.engine": "Voice engine",
"tts.engine_browser": "Browser voice",
"tts.engine_piper": "Local voice (Piper, offline)",
"tts.status_ready": "Piper is installed.",
"tts.status_missing": "Piper or voices missing - click Install.",
"tts.cached": "{count} lines cached",
"tts.install": "Install Piper + Swedish/English voices",
"tts.reinstall": "Check installation",
"tts.pregenerate": "Pre-generate phrases and driver names",
"tts.pregenerate_progress": "Pre-generated {done} of {total} ({failed} failed)",
"tts.test": "Test the voice",
"tts.voice_sv": "Swedish voice",
"tts.voice_en": "English voice",
"tts.voice_auto": "Automatic",
"tts.gender_male": "male",
"tts.gender_female": "female",
"tts.accent_us": "American",
"tts.accent_gb": "British",
"tts.accent_gb_north": "Northern English",
"tts.accent_scottish": "Scottish",
"tts.more_voices": "More voices",
"tts.more_voices_hint": "Downloaded one at a time (about 63 MB each, internet only needed while downloading). Then pick the voice above and test it.",
"tts.download": "Download",
"tts.downloading": "Downloading...",
"tts.test_failed": "Could not play the local voice - check the installation.",
"auth.title": "Admin PIN",
"auth.hint": "Protects every change (races, results, settings, updates) with a PIN. Reading and public overlay/training links are unaffected. The login is remembered in this browser for 30 days.",
"auth.state_off": "Off - anyone on the network can make changes.",
"auth.state_on_logged_in": "On - you are logged in in this browser.",
"auth.state_on_logged_out": "On - you are not logged in in this browser.",
"auth.new_pin": "New PIN (at least 4 characters)",
"auth.new_pin_change": "Change to new PIN",
"auth.confirm_pin": "Repeat PIN",
"auth.enable": "Turn on PIN protection",
"auth.change_pin": "Change PIN",
"auth.logout": "Log out",
"auth.disable": "Turn off PIN protection",
"auth.disable_confirm": "Turn off PIN protection? Anyone on the network will be able to make changes again.",
"auth.pin_mismatch": "The PINs do not match.",
"auth.login_required": "Log in with the current PIN first.",
"auth.status_error": "Could not read PIN status from the server.",
"auth.login_title": "Log in",
"auth.login_hint": "Changes are PIN protected. Enter the admin PIN to continue.",
"auth.login": "Log in",
"auth.cancel": "Cancel",
"auth.wrong_pin": "Wrong PIN.",
"auth.too_many": "Too many failed attempts. Wait a few minutes.",
"guide.schedule_1": "1. Open Manage -> the Schedule & print tab for a race event. Set a start time and the gap between sessions (default 3 minutes) and click Save schedule.",
"guide.schedule_2": "2. Every session's planned clock time is worked out in running order (practice, then qualifying, then finals) from the start time, each session's own duration/follow-up, and the gap between sessions.",
"guide.schedule_3": "3. As soon as a session actually starts or finishes, the rest of the schedule automatically shifts to match reality - a late start or a session that runs long (including any pause) pushes the rest of the day forward with no manual recalculation. A session that started more than a minute late is marked \"Delayed\".",
"guide.schedule_4": "4. The planned clock time is also printed on the start lists (Print/PDF start lists) so drivers can see roughly when their session begins.",
"guide.race_wizard_title": "Create Race Wizard",
"guide.race_wizard_1": "1. Start in Race Setup and use the wizard when creating a new race instead of building everything directly in Manage.",
"guide.race_wizard_2": "2. Step 1 sets name, date, class and preset. The preset fills sensible defaults before you fine-tune anything.",
"guide.race_wizard_3": "3. Step 2 selects exactly which drivers should be valid for this race. They then become the race-specific participant scope for timing and seeding.",
"guide.race_wizard_4": "4. Step 3 chooses which sessions should be created immediately: practice, qualifying and/or team race depending on the preset.",
"guide.race_wizard_5": "5. The wizard creates the initial sessions automatically. Finals are generated later from Race Actions after qualifying or practice is complete.",
"guide.race_wizard_6": "6. After creation, continue in Manage for race format, generation, grid, standings and print/export.",
"guide.race_wizard_7": "7. In Manage -> Race Actions you can export or import a single race package when you want to move just that race to another installation.",
"guide.manage_steps_title": "Manage Race In Four Steps",
"guide.manage_steps_1": "1. Setup: choose race participants and build any teams for team race or endurance.",
"guide.manage_steps_2": "2. Format: adjust Race Format in Basic or Advanced mode. Practice/qualifying, finals and validation are split into separate blocks.",
"guide.manage_steps_3": "3. Generation: create qualifying, reseed upcoming heats, generate finals and apply bump-ups from a separate Race Actions panel.",
"guide.manage_steps_4": "4. Live / results: use the grid editor, standings, finals matrix, print and PDF after the competition structure is built.",
"guide.manage_steps_5": "5. The summary card on the right acts as a quick sanity check before you start generating or running races.",
"events.qualifying_scoring_hint": "Choose whether qualifying should rank by round points or by the single best result.",
"events.qualifying_scoring": "Qualifying scoring",
"events.qualifying_scoring_points": "Points per round",
"events.qualifying_scoring_best": "Best round / rank",
"events.qualifying_rounds": "Qualifying rounds",
"events.qualifying_rounds_hint": "How many qualifying rounds should be generated in total.",
"events.cars_per_heat": "Drivers per qualifying heat",
"events.cars_per_heat_hint": "How many drivers go into each qualifying heat.",
"events.qual_duration": "Qualifying duration (min)",
"events.qual_duration_hint": "Length of each qualifying heat in minutes.",
"events.qual_start_mode": "Qualifying start",
"events.qual_start_mode_hint": "Flying start (EFRA) - everyone drives, each car's time starts at its first crossing after the start signal. Staggered - cars released one by one. Or mass/position.",
"events.qual_seed_laps": "Qualifying best laps",
"events.qual_seed_laps_hint": "0 = most laps in the time wins (most common). Above 0 = the heat is ranked on that many best laps instead.",
"events.qual_seed_method": "Qualifying seed method",
"events.qual_seed_method_hint": "How qualifying heats evaluate laps when best-lap mode is used.",
"events.counted_qual_rounds": "Counted qualifying rounds",
"events.counted_qual_rounds_hint": "How many qualifying rounds count toward the final ranking.",
"events.qual_points_table": "Points table",
"events.qual_points_table_hint": "Choose how each qualifying round awards points when Qualifying scoring uses points.",
"events.qual_points_rank": "Placement values (1,2,3...)",
"events.qual_points_desc": "Descending by field size",
"events.qual_points_ifmar": "10-9-8-7-6-5-4-3-2-1",
"events.qual_tie_break": "Tie-break",
"events.qual_tie_break_hint": "Choose which rule resolves equal results in qualifying standings.",
"events.qual_tie_break_rounds": "Compare counted rounds",
"events.qual_tie_break_best_lap": "Best single lap",
"events.qual_tie_break_best_round": "Best round / heat result",
"events.race_preset": "Preset",
"events.race_preset_hint": "Quick start for track/class. Apply the preset and then fine tune manually.",
"events.apply_preset": "Apply preset",
"events.save_preset": "Save club preset",
"events.delete_preset": "Delete club preset",
"events.preset_name": "Preset name",
"events.preset_custom": "Custom / current values",
"events.preset_short_technical": "Short technical track 16s",
"events.preset_club_qualifying": "Club race qual + finals",
"events.preset_orc_winter": "ÖRC Winter (3 quals, 6/heat, 3 finals)",
"events.heat_order": "Heat order",
"events.heat_order_hint": "Qualifying heats are seeded from practice (then from the qualifying standings on reseed). Choose whether the fastest heat runs first or last.",
"events.heat_order_fastest_last": "Fastest heat last",
"events.heat_order_fastest_first": "Fastest heat first",
"events.preset_ifmar": "IFMAR-style qual/finals",
"events.preset_endurance": "Endurance / team race",
"events.tie_break_note": "Tie-break",
"events.counted_rounds_label": "Counted rounds",
"events.tie_break_won": "Won against",
"events.tie_break_lost": "Lost against",
"events.invalid_recent": "Latest hit invalid",
"timing.invalid_manual": "Manually invalidated",
"timing.invalidate_last_lap": "Invalidate last lap",
"events.cars_per_final": "Drivers per final",
"events.cars_per_final_hint": "Maximum number of drivers in each A/B/C final.",
"events.final_legs": "Final heats per main",
"events.final_legs_hint": "How many final legs should be generated per main.",
"events.counted_final_legs": "Counted final heats",
"events.counted_final_legs_hint": "How many final legs count in the combined final standings.",
"events.final_duration": "Final duration (min)",
"events.final_duration_hint": "Length of each final leg in minutes.",
"events.final_start_mode": "Final start",
"events.final_start_mode_hint": "Start mode for finals, often position start.",
"events.bump_count": "Bump-up per main",
"events.bump_count_hint": "How many drivers can move up from a lower final into the next main.",
"events.save_race_format": "Save race format",
"events.open_grid": "Grid",
"events.grid_editor": "Grid editor",
"events.grid_editor_hint": "Drag drivers up or down to change the manual start order for position start.",
"events.grid_reset": "Reset from participant list",
"events.grid_lock": "Lock grid",
"events.grid_unlock": "Unlock grid",
"events.grid_locked": "Manual grid is locked against auto-reseed.",
"events.grid_unlocked": "Grid follows auto seed/reseed until you lock it.",
"events.grid_empty": "No grid available to edit yet.",
"events.print_heat_sheet": "Print heat sheet",
"events.export_heat_sheet": "Export heat sheet",
"events.pdf_heat_sheet": "PDF heat sheet",
"events.free_practice_note": "Free Practice shows rolling lap times and is not used for seeding.",
"events.open_practice_note": "Open Practice shows all incoming transponders live. If no driver matches, only the transponder is shown.",
"events.generate_qualifying": "Generate qualifying from practice",
"events.clear_generated_qualifying": "Clear generated qualifying",
"events.generate_finals": "Generate finals from qualifying",
"events.clear_generated_finals": "Clear generated finals",
"events.apply_bumps": "Apply bump-ups",
"events.practice_standings": "Practice standings",
"events.qualifying_standings": "Qualifying standings",
"events.final_standings": "Final standings",
"events.generated_qualifying": "Qualifying heats generated from standings.",
"events.finals_generated": "Finals generated from standings.",
"events.bumps_applied": "Bump-ups applied to the next main.",
"events.no_bumps_applied": "No bump-ups could be applied yet.",
"events.no_practice_results": "No practice results yet.",
"events.no_qualifying_results": "No qualifying results yet.",
"events.no_final_results": "No final results yet.",
"events.schedule_title": "Schedule",
"events.schedule_hint": "Set a start time for the day and each session's planned clock time is worked out automatically from its duration, follow-up, and the gap between sessions. If a session runs long or gets paused, the rest of the schedule shifts forward automatically.",
"events.schedule_start_time": "Start time",
"events.schedule_gap": "Gap between sessions (min)",
"events.schedule_save": "Save schedule",
"events.schedule_clear": "Clear schedule",
"events.schedule_not_set": "No schedule set yet. Set a start time above.",
"events.schedule_planned": "Planned time",
"events.schedule_actual": "Actual time",
"events.schedule_delayed": "Delayed",
"events.final_matrix": "Final matrix",
"events.print_startlists": "Print start lists",
"events.print_results": "Print results",
"events.pdf_startlists": "PDF start lists",
"events.pdf_results": "PDF results",
"events.reserved_slot": "Reserved bump slot",
"events.position_grid": "Grid / start order",
"events.start_lists": "Start lists",
"events.no_final_matrix": "No finals generated yet.",
"events.results_overview": "Results overview",
"events.main": "Main",
"events.slot": "Slot",
"events.leg_status": "Leg status",
"events.source_for_finals": "Source for finals",
"events.finals_from_qualifying": "Qualifying standings",
"events.finals_from_practice": "Practice standings",
"events.finals_source_hint": "Choose whether finals should be seeded from practice or qualifying.",
"events.follow_up_sec": "Follow-up time (sec)",
"events.follow_up_sec_hint": "Extra time after race duration so the last cars can finish before the session closes.",
"events.min_lap_time": "Min lap time (sec)",
"events.min_lap_time_hint": "Laps faster than this are ignored as shortcuts or false hits.",
"events.max_lap_time": "Max lap time (sec)",
"events.max_lap_time_hint": "A passing over max starts a new statistics stint and is excluded from pace averages. The lap still counts in race results.",
"events.race_driver_scope": "Race mode uses all drivers in the event class unless a session has its own participant list.",
"events.reserve_bump_slots_hint": "Reserve empty slots in higher finals so bumped drivers can be inserted without overwriting seeded spots.",
"events.team_race": "Team Race",
"events.team_race_intro": "Create endurance teams. All passings from the team's drivers or cars are added to the team's total laps in Team Race sessions.",
"events.team_name": "Team name",
"events.add_team": "Add team",
"events.teams": "Teams",
"events.team_drivers": "Team drivers",
"events.team_cars": "Team cars",
"events.team_hint": "Select at least one driver or car per team. Team Race sessions sum the team's total laps across the whole race duration, for example 4 hours.",
"events.team_steps": "1. Enter the team name. 2. Tick drivers and/or cars below. 3. Click Add team. 4. Use Edit team for later changes.",
"events.team_form_drivers": "Select team drivers before saving the team.",
"events.team_form_cars": "Select team cars before saving the team.",
"events.team_driver_fallback": "No drivers matched the race class or participant list. Showing all drivers as fallback.",
"events.team_member_elsewhere": "Already on {team} - checking this moves them here",
"events.heat_drivers": "Heat drivers",
"events.heat_drivers_hint": "Tick/untick to change who races this heat. A driver already on another heat in the same round is moved here automatically when you save.",
"events.heat_member_elsewhere": "Already on {heat} - checking this moves them here",
"events.no_teams": "No teams created yet.",
"events.team_standings": "Team standings",
"events.no_team_results": "No team results yet.",
"events.edit_team": "Edit team",
"events.team_stint_log": "Stint and driver-change log",
"events.team_report": "Team report",
"events.print_team_results": "Print team report",
"events.pdf_team_results": "PDF team report",
"events.add_session": "Add Session",
"events.session_type_label": "Session type",
"events.session_type_hint_track": "Choose which part of the sponsor event you are creating: practice, qualifying, heat or final. The event itself is already a sponsor event.",
"events.session_type_hint_race": "Choose which race session you are creating: practice, qualifying, heat, final or team race.",
"events.session_duration_label": "Duration (min)",
"events.session_duration_hint": "Main running time for the session in minutes.",
"events.session_followup_label": "Follow-up (sec)",
"events.session_followup_hint": "Extra time after the main timer so the last cars can finish.",
"events.session_start_mode_label": "Start mode",
"events.session_start_mode_hint": "Mass start, position start, staggered start or flying start.",
"events.session_seed_laps_label": "Seed best laps",
"events.session_seed_laps_hint": "0 = off. Use 2 or 3 for practice/qualifying seeding.",
"events.session_seed_method_label": "Seed method",
"events.session_seed_method_hint": "How to count the best laps: sum, average or consecutive laps.",
"events.session_stagger_gap_label": "Stagger gap (sec)",
"events.session_stagger_gap_hint": "Only used for staggered starts. 0 = no extra gap.",
"events.session_max_cars_label": "Max cars (optional)",
"events.session_max_cars_hint": "Set a limit if this session should only allow a certain number of cars.",
"events.edit_session_help": "Edit the session name, type, timing and seed/start settings here.",
"events.set_active": "Set Active",
"events.delete_race_confirm": "Delete the race \"{name}\"?\n\nThis deletes {sessions} sessions, {run} of them with laps run. It cannot be undone.",
"events.delete_session_confirm": "Delete \"{name}\"? Its laps and result are deleted too. It cannot be undone.",
"events.more_actions": "More: print, export, grid, delete",
"events.step_practice": "Practice / seeding",
"events.step_qual_round": "Qualifying round {round}",
"events.step_qual": "Qualifying",
"events.step_finals": "Finals",
"events.step_count": "{done}/{total} run",
"events.assignments": "Assignments",
"events.na": "n/a",
"events.sponsor_tools": "Sponsor Event Tools",
"events.qual_rounds": "Qualification rounds",
"events.heat_rounds": "Heat rounds",
"events.final_rounds": "Final rounds",
"events.round_duration": "Round duration (min)",
"events.create_rounds": "Create Rounds",
"events.tp_rule": "Same transponder can be reused across sessions (Heat 1 -> Heat 2 -> Final 1). In a running session, each active car must have a unique transponder.",
"events.assign_title": "Track Assignments (Driver -> Car)",
"events.assign": "Assign",
"events.auto_assign": "Auto Assign Selected Session",
"events.clear_assign": "Clear Selected Session",
"events.no_assignments": "No assignments",
"events.duplicate_car": "That car is already assigned in this session.",
"events.duplicate_driver": "That driver is already assigned in this session.",
"events.duplicate_tp": "Duplicate transponder in same session is not allowed. Reuse in next heat/final.",
"timing.decoder_connection": "Decoder Connection",
"timing.connect": "Connect Decoder",
"timing.disconnect": "Disconnect",
"timing.simulate": "Simulate Passing",
"timing.session_replay": "Session replay",
"timing.session_replay_hint": "Replay saved passings without a decoder. The source session, results, and training statistics are never changed.",
"timing.replay_isolated": "Isolated test mode",
"timing.replay_select": "Select saved session",
"timing.replay_load": "Load replay",
"timing.replay_play": "Play",
"timing.replay_pause": "Pause",
"timing.replay_reset": "Back to start",
"timing.replay_speed": "Speed",
"timing.replay_latest": "Latest passing",
"timing.replay_load_hint": "Select a session and load its passings.",
"timing.replay_empty": "No saved sessions with passings are available.",
"timing.replay_no_visible_passings": "Replay has not reached a passing yet.",
"timing.replay_status_idle": "Not loaded",
"timing.replay_status_empty": "Empty",
"timing.replay_status_paused": "Paused",
"timing.replay_status_running": "Playing",
"timing.replay_status_finished": "Finished",
"timing.status": "Status",
"timing.connected": "Connected",
"timing.disconnected": "Disconnected",
"timing.last_message": "Last message",
"timing.main_decoder": "Main start/finish",
"timing.split_decoder": "Split timing",
"timing.pit_decoders": "Pit entry/exit",
"timing.pit_entry_decoder": "Pit entry",
"timing.pit_exit_decoder": "Pit exit",
"timing.pit_active": "IN PIT",
"timing.personal_time_up": "Done",
"timing.channel_analysis": "Split timing and pit stops",
"timing.channel_analysis_hint": "Split timing does not count laps. Pit time is measured from Pit entry to Pit exit and attributed to the driver and car at entry.",
"timing.channel_analysis_race_hint": "Summary and complete pit log per heat. Use it, for example, to review every stop in a 45-minute race.",
"timing.split_count": "Split count",
"timing.best_split": "Best split",
"timing.average_split": "Average split",
"timing.pit_stops": "Pit stops",
"timing.total_pit": "Total pit time",
"timing.average_pit": "Average pit stop",
"timing.best_pit": "Best pit stop",
"timing.pit_stop_log": "Pit stop log",
"timing.pit_in": "Pit entry",
"timing.pit_out": "Pit exit",
"timing.control": "Session Control",
"timing.speaker_panel": "Speaker panel",
"timing.speaker_panel_hint": "These toggles enable or disable cues live for the current session and overlay without leaving Timing.",
"timing.select_session": "Select session",
"timing.other_sessions": "Other",
"timing.set_active": "Set Active",
"timing.start": "Start",
"timing.stop": "Stop",
"timing.reset": "Reset Data",
"timing.lap_remove": "Remove",
"timing.corrections_in_judging": "Penalties and lap changes are made by the judge in the Judging view (logged and undoable).",
"timing.open_in_judging": "Open in Judging",
"timing.lap_restore": "Restore",
"timing.lap_removed": "removed",
"suspect.title": "Suspiciously short laps ({count})",
"suspect.hint": "Much quicker than the driver's own pace - maybe a shortcut. The lap counts as usual (best lap and stats too) until you remove it. Approve only drops the flag.",
"suspect.approve": "Approve",
"suspect.flag_title": "Suspiciously short lap waiting for review",
"timing.total_passings": "Total passings",
"timing.started": "Started",
"timing.remaining": "Countdown",
"timing.elapsed": "Elapsed",
"timing.race_finished": "Race is finished",
"timing.race_started_voice": "Race started",
"timing.race_finished_voice": "Race finished",
"timing.practice_started_voice": "Practice started",
"timing.practice_finished_voice": "Practice finished",
"timing.follow_up": "Follow-up",
"timing.follow_up_active": "Follow-up active",
"timing.no_active": "No active session selected.",
"timing.leaderboard": "Live Leaderboard",
"timing.recent_passings": "Recent Passings",
"timing.no_laps": "No laps yet.",
"timing.no_session_selected": "No session selected.",
"timing.no_passings": "No passings recorded.",
"timing.details": "Details",
"timing.add_driver": "Add driver",
"timing.add_car": "Add car",
"timing.quick_add_hint": "Quick-register transponder",
"timing.quick_add_title": "Quick add",
"timing.quick_add_driver_title": "Add driver from transponder",
"timing.quick_add_car_title": "Add car from transponder",
"timing.open_overlay": "Open overlay",
"timing.open_speaker_overlay": "Speaker overlay",
"timing.open_results_overlay": "Results overlay",
"timing.open_tv_overlay": "TV overlay",
"timing.open_team_overlay": "Team overlay",
"timing.open_obs_overlay": "OBS overlay",
"timing.close_details": "Close",
"timing.detail_title": "Leaderboard details",
"timing.lap_history": "Lap history",
"timing.no_lap_history": "No laps to show.",
"timing.manual_corrections": "Manual corrections",
"timing.lap_adjustment": "Lap adjustment",
"timing.time_penalty": "Time penalty",
"timing.penalty_add_lap": "+1 lap",
"timing.penalty_remove_lap": "-1 lap",
"timing.penalty_add_sec": "+1 sec",
"timing.penalty_add_5sec": "+5 sec",
"timing.penalty_remove_sec": "-1 sec",
"timing.penalty_reset": "Reset correction",
"timing.restore_last_invalid": "Restore latest manually invalidated lap",
"timing.no_manual_invalid": "No manually invalidated lap was found.",
"timing.valid_passing": "Valid lap",
"timing.invalid_short": "Short lap",
"timing.invalid_long": "Over max lap",
"timing.long_lap_stint": "Long lap · counted · new stint",
"judging.title": "Judging view",
"judging.active_session": "Active session",
"judging.no_active_session": "No active session selected.",
"judging.select_competitor": "Select driver or team",
"judging.manual_actions": "Manual actions",
"judging.action_log": "Judging log",
"judging.no_action_log": "No manual actions registered yet.",
"judging.selected_none": "No row selected.",
"judging.restore_done": "The latest manually invalidated lap was restored.",
"judging.filter_competitors": "Filter rows",
"judging.filter_log": "Filter log",
"judging.filter_all": "All",
"judging.filter_invalid": "Invalid",
"judging.filter_corrected": "Corrected",
"judging.filter_team": "Team race",
"judging.filter_log_corrections": "Corrections",
"judging.filter_log_invalidations": "Invalidate/restore",
"judging.filter_log_undo": "Undo",
"judging.export_log": "Export judging log",
"judging.undo_last": "Undo latest",
"judging.undo_action": "Undo",
"judging.undo_done": "The latest manual action was undone.",
"judging.no_undo": "No action to undo.",
"timing.total_time": "Total time",
"timing.clear_confirm": "Clear all timing data for this session? The laps stay in the training stats.",
"timing.prompt_transponder": "Transponder",
"timing.first_crossing_start": "First crossing set personal start",
"timing.seeding_mode": "Seeding",
"timing.position_grid_hint": "The grid shows the start order for position start in the active session.",
"settings.tab_connection": "Connection",
"settings.tab_audio": "Audio",
"settings.tab_appearance": "Appearance & overlay",
"settings.tab_system": "System & backup",
"settings.decoder": "Decoder",
"settings.main_ws_url": "Main WebSocket URL",
"settings.enable_split_decoder": "Enable split decoder",
"settings.split_ws_url": "Split WebSocket URL",
"settings.enable_pit_decoders": "Enable pit decoders",
"settings.decoder_roles_hint": "Client WebSocket URLs must use the backend host IP, not a physical decoder IP. Main counts laps; split and pit channels never do.",
"settings.decoder_setup_title": "Choose decoder setup",
"settings.decoder_setup_hint": "Choose a preset to enable the correct extra channels. Main is always used. Check the URLs, then click Save.",
"settings.decoder_layout_main": "1 decoder: Main",
"settings.decoder_layout_split": "2 decoders: Main + split",
"settings.decoder_layout_pit": "3 decoders: Main + pit",
"settings.decoder_layout_full": "4 decoders: Full system",
"settings.role_required": "Required",
"settings.role_enabled": "Enabled",
"settings.role_disabled": "Disabled",
"settings.main_role_hint": "Start/finish. The only channel that counts laps.",
"settings.split_role_hint": "One additional physical decoder for split timing. It never counts laps.",
"settings.pit_role_hint": "Requires two additional physical decoders: one at pit entry and one at pit exit.",
"settings.connection_title": "Backend and connection",
"settings.backend_url_hint": "Web/API on the computer running npm start, normally port 8081.",
"settings.backend_url_mismatch": "This page was opened via {origin}, but the Backend URL below is a different address. The browser will block sync and backups (CORS) - they must be identical.",
"settings.backend_url_use_current": "Use {origin}",
"settings.managed_channels_hint": "Decoder IP / host fields below are physical decoder addresses. The backend starts one AMMC process per role on unique ports: main 9000, split 9001, pit entry 9002, and pit exit 9003.",
"settings.pit_entry_ws_url": "Pit entry WebSocket URL",
"settings.pit_exit_ws_url": "Pit exit WebSocket URL",
"settings.split_decoder_host": "Split decoder IP / host",
"settings.split_ws_port": "Split WebSocket port",
"settings.pit_entry_decoder_host": "Pit entry decoder IP / host",
"settings.pit_entry_ws_port": "Pit entry WebSocket port",
"settings.pit_exit_decoder_host": "Pit exit decoder IP / host",
"settings.pit_exit_ws_port": "Pit exit WebSocket port",
"settings.auto_reconnect": "Auto reconnect",
"settings.save": "Save",
"settings.connect_now": "Connect Now",
"settings.expected_json": "Expected AMMC JSON format",
"settings.managed_ammc": "Managed AMMC",
"settings.managed_ammc_sub": "Start local AMMC from the backend on this machine.",
"settings.enable_managed": "Enable managed AMMC",
"settings.auto_start_ammc": "Auto-start AMMC when backend starts",
"settings.decoder_host": "Decoder IP / host",
"settings.ws_port": "AMMC WebSocket port",
"settings.executable_path": "AMMC executable",
"settings.working_dir": "Working directory (optional)",
"settings.extra_args": "Extra arguments (optional)",
"settings.save_ammc": "Save AMMC",
"settings.start_ammc": "Start AMMC",
"settings.stop_ammc": "Stop AMMC",
"settings.refresh_ammc": "Refresh status",
"settings.ammc_status": "AMMC status",
"settings.running": "Running",
"settings.stopped": "Stopped",
"settings.server_platform": "Server OS",
"settings.pid": "PID",
"settings.started_at": "Started at",
"settings.stopped_at": "Stopped at",
"settings.last_error": "Last error",
"settings.output": "Recent AMMC log",
"settings.executable_found": "Executable found",
"settings.executable_missing": "Executable missing",
"settings.bundled_hint": "The bundled app path is used automatically when present.",
"settings.use_server_ws": "Use server WS URL",
"settings.audio": "Audio",
"common.off": "Off",
"audio.race_sounds": "Race sounds and announcements",
"audio.enabled": "Enable new race audio",
"audio.mute": "Mute all",
"audio.language": "Announcement language",
"audio.voice_select": "Race voice",
"audio.voice_auto": "Automatic voice for selected language",
"audio.voice_rate": "Race voice speed",
"audio.voice_pitch": "Race voice pitch",
"audio.start_countdown": "Pre-start countdown",
"audio.master_volume": "Master volume",
"audio.effects_volume": "Effects volume",
"audio.voice_volume": "Voice volume",
"audio.passing_volume": "Passing volume",
"audio.start_lights": "Start lights",
"audio.random_delay": "Random start delay",
"audio.min_delay": "Minimum delay (seconds)",
"audio.max_delay": "Maximum delay (seconds)",
"audio.per_competitor": "Different passing tone per driver/car",
"audio.race_callouts": "Calls during a race",
"audio.practice_pb_warmup": "Practice: silent personal best for first laps",
"audio.practice_pb_cooldown": "Practice: seconds between PB calls per driver",
"audio.practice_pb_min_gain": "Practice: minimum improvement to call (s)",
"audio.practice_pb_hint": "Open Practice. On fresh packs everyone beats their best almost every lap early in the day. The best lap is still shown on screen and in the overlay. 0 turns a rule off.",
"audio.race_callouts_passing": "Passing tone only (like timing systems)",
"audio.race_callouts_full": "Speaker - names, best laps, new leader",
"audio.test": "Test",
"audio.note": "Fixed effects use WAV files from the sound pack. Voice announcements use the voice engine chosen above - the local Piper voice or the browser's system voices. Changes save automatically; critical announcements interrupt lower-priority speech.",
"audio.effect": "Effect",
"audio.voice": "Voice",
"audio.track_call": "TRACK CALL",
"audio.track_clear": "Track clear",
"audio.red_flag": "Red flag",
"audio.race_pause": "Pause race",
"audio.race_resume": "Resume race",
"audio.false_start": "False start",
"audio.marshal_warning": "Marshal warning",
"audio.passing_sound": "Custom passing sound",
"audio.pass_default": "Default/fallback",
"settings.audio_enabled": "Enable browser audio",
"settings.speaker_passing_cue": "Speaker cue on passing",
"settings.speaker_leader_cue": "Speaker cue on new leader",
"settings.speaker_finish_cue": "Speaker cue on finish",
"settings.speaker_bestlap_cue": "Speaker cue on new best lap",
"settings.speaker_top3_cue": "Speaker cue on top 3 change",
"settings.speaker_start_cue": "Speaker cue on session start",
"settings.passing_sound": "Passing sound",
"settings.passing_sound_off": "Off",
"settings.passing_sound_beep": "Beep",
"settings.passing_sound_name": "Speak driver name",
"settings.finish_voice": "Announce start and finish",
"settings.start_sound": "Start signal",
"settings.finish_sound": "Finish signal",
"settings.speech_voice": "Speech voice",
"settings.system_default_voice": "Automatic voice for selected language",
"settings.speech_rate": "Speech rate",
"settings.speech_pitch": "Speech pitch",
"settings.test_start": "Test start",
"settings.test_finish": "Test finish",
"settings.test_driver_voice": "Test driver name",
"settings.driver_voice_sample": "Test driver",
"settings.test_audio": "Test audio",
"settings.audio_note": "Browsers usually require a click first before sound/speech is allowed.",
"settings.voice_note": "Voices are provided by the operating system. Select a matching local voice and set a separate spoken name under Drivers when pronunciation needs help.",
"settings.branding": "Club branding / UI / PDF",
"settings.branding_note": "Club name, tagline, and logo are used in the main menu, overlays, public training profiles, and PDF exports.",
"settings.save_branding": "Save branding",
"settings.club_name": "Club name",
"settings.club_tagline": "Club tagline",
"settings.pdf_footer": "PDF footer",
"settings.pdf_theme": "PDF theme",
"settings.pdf_theme_classic": "Classic",
"settings.pdf_theme_minimal": "Minimal",
"settings.pdf_theme_motorsport": "Motorsport",
"settings.logo": "Club logo",
"settings.logo_upload": "Upload logo",
"settings.logo_clear": "Clear logo",
"settings.logo_note": "The logo is shown in the main menu, overlays, and public training profiles. PDF export attempts to embed it via the backend.",
"settings.track_layouts": "Track layouts",
"settings.track_layouts_hint": "Add a new track layout every time the track gets rebuilt (e.g. running indoors in the same building), so personal bests, the track record and the \"stable pace\" cue only compare against laps run on the same layout. Each practice lap counts toward the layout active when that lap was driven - switch layout in the middle of a running Open Practice and laps before and after the switch land on the right layout. Layouts only change around practice: not while a race session (qualifying, heat, final) is running. The quickest way is New layout on Training stats, Race Day or the Dashboard. With no layouts added, everything behaves exactly as it does today.",
"settings.track_layout_label": "Name (optional)",
"settings.track_layout_started_at": "Active from",
"settings.track_layout_add": "Add layout",
"settings.track_layout_none": "No track layouts added yet.",
"settings.track_layout_unnamed": "Unnamed layout",
"settings.track_layout_invalid_date": "Invalid date.",
"settings.track_layout_date_error": "A new layout must start after the latest layout's start date ({date}).",
"settings.track_layout_delete_confirm": "Delete the track layout \"{label}\"?",
"settings.track_layout_delete_blocked": "Can't delete - sessions or practice laps are already linked to this layout.",
"settings.track_layout_race_running": "Can't change the track layout while {name} is running - layouts only change between or during practice sessions. Finish the race session first.",
"settings.update_title": "Updates",
"settings.update_current_version": "Installed version",
"settings.update_checking": "Checking for a new version...",
"settings.update_up_to_date": "You have the latest version.",
"settings.update_available": "Version {version} is available.",
"settings.update_available_sidebar": "New version v{version} - update",
"settings.update_error": "Could not check for updates: {msg}",
"settings.update_check_now": "Check now",
"settings.update_run_now": "Update now",
"settings.update_confirm": "Update RC RaceCore to version {version}?\n\nThe server will stop, pull the new code and restart automatically. This usually takes under a minute, and the page reloads on its own once the server is back.",
"settings.update_confirm_active_session": "Note: a race/session is currently active. Updating stops the server during the update and interrupts timing. Only update between heats.",
"settings.update_started": "Update started. The server is restarting - the page will reload automatically once it's back.",
"settings.update_failed": "Update failed: {msg}",
"settings.storage": "Storage",
"settings.server_backups": "Server SQLite backups",
"settings.server_backups_hint": "A backup is created automatically before every session start. The latest 30 are retained in data/backups.",
"settings.create_backup": "Create backup now",
"settings.refresh_backups": "Refresh list",
"settings.loading_backups": "Loading backup history...",
"settings.no_backups": "No server backups have been created yet.",
"settings.backup_reason_pre_start": "Before start",
"settings.backup_reason_pre_change": "Before major change",
"settings.backup_reason_pre_restore": "Before restore",
"settings.backup_reason_manual": "Manual",
"settings.backup_reason_unknown": "Unknown",
"settings.backup_created": "SQLite backup created.",
"settings.backup_failed": "Backup failed: {msg}",
"settings.safety_backup_failed_confirm": "Safety backup failed: {msg}\n\nContinue anyway?",
"settings.restore_backup_hint": "Restore locally on the server while RC RaceCore is stopped. Web restore remains disabled until administration access control is available.",
"settings.race_presets": "Club presets",
"settings.race_presets_note": "Export or import local club presets between installations.",
"settings.export_presets": "Export presets",
"settings.import_presets": "Import presets",
"settings.backend_url": "Backend URL",
"settings.backend_status": "Backend status",
"settings.online": "Online",
"settings.offline": "Offline",
"settings.last_sync": "Last sync",
"settings.test_backend": "Test Backend",
"settings.sync_now": "Sync Now",
"settings.export_json": "Export JSON",
"settings.export_all_data": "Export all race data",
"settings.import_all_data": "Import all race data",
"settings.export_directory": "Export drivers/classes/cars",
"settings.import_directory": "Import drivers/classes/cars",
"settings.export_drivers_csv": "Export drivers CSV",
"settings.export_cars_csv": "Export cars CSV",
"settings.import_drivers_csv": "Import drivers CSV",
"settings.import_cars_csv": "Import cars CSV",
"settings.download_drivers_csv_template": "Download driver template",
"settings.driver_csv_guide_title": "Driver import format",
"settings.driver_csv_required": "Required: name. Rows without a driver name are skipped.",
"settings.driver_csv_columns": "The recommended minimum is name, transponder, and class. Optional columns are id, brand, spoken_name, club, country, and profile_id.",
"settings.driver_csv_behavior": "Optional columns and values may be omitted. They remain empty and do not overwrite existing data. Unknown extra columns are ignored.",
"settings.driver_csv_example": "Semicolon-delimited example",
"settings.import_csv_success": "{type}: {added} added, {updated} updated, and {skipped} skipped rows.",
"settings.csv_type_drivers": "Drivers imported",
"settings.csv_type_cars": "Cars imported",
"settings.storage_note_full": "Full data package contains classes, drivers, cars, races/events, sessions and results.",
"settings.storage_note_directory": "Directory package only contains classes, drivers and cars and merges into existing data.",
"settings.storage_note_csv": "CSV can be exported or imported from Excel and LibreOffice. Comma, semicolon, and tab delimiters are supported. Import merges by ID, transponder, or name instead of replacing the directory.",
"settings.clear_data_title": "Clear data",
"settings.clear_data_note": "A SQLite backup is created automatically before clearing. Clearing cannot be undone, but system, decoder, theme, and branding settings are retained. Raw SQLite passings remain as an audit log.",
"settings.clear_drivers": "Clear drivers",
"settings.clear_cars": "Clear cars",
"settings.clear_classes": "Clear classes",
"settings.clear_races": "Clear races and sessions",
"settings.clear_training": "Clear training statistics",
"settings.clear_all": "Clear all competition data",
"settings.clear_drivers_confirm": "Clear all drivers, their training data, and driver references in races? This cannot be undone.",
"settings.clear_cars_confirm": "Clear all cars and car references in races? This cannot be undone.",
"settings.clear_classes_confirm": "Clear all classes and unlink them from drivers and races? This cannot be undone.",
"settings.clear_races_confirm": "Clear all events, races, sessions, and results? Existing training laps are archived first. This cannot be undone.",
"settings.clear_training_confirm": "Clear all training statistics, goals, rewards, and public profile links? This cannot be undone.",
"settings.clear_all_confirm": "Clear all classes, drivers, cars, races, sessions, results, and training statistics? System settings are retained. This cannot be undone.",
"settings.clear_success": "The selected data has been cleared.",
"settings.import_full_confirm": "Import \"{name}\"?\n\nAll current race data (classes, drivers, cars, races, sessions and results) is replaced with the file's contents. A backup is taken first and is listed under Server SQLite backups.",
"settings.import_full_success": "Race data imported and replaced the current competition data.",
"settings.import_directory_success": "Classes, drivers and cars were imported into the existing data.",
"settings.import_failed": "Import failed: {msg}",
"table.name": "Name",
"table.brand": "Brand",
"table.class": "Class",
"table.transponder": "Transponder",
"table.delete": "Delete",
"table.car": "Car",
"table.date": "Date",
"table.mode": "Mode",
"table.start_mode": "Start",
"table.seeding": "Seeding",
"table.score": "Score",
"table.session": "Session",
"table.type": "Type",
"table.duration": "Duration",
"table.status": "Status",
"table.time": "Time",
"table.driver": "Driver",
"table.loop": "Loop",
"table.strength": "Strength",
"table.pos": "Pos",
"table.laps": "Laps",
"table.last_lap": "Last Lap",
"table.best_lap": "Best Lap",
"table.split": "Split",
"table.pit": "Pit",
"table.gap": "Gap",
"table.event": "Event",
"table.result": "Result",
"table.lap": "Lap",
"table.leader_gap": "Leader gap",
"table.ahead_gap": "Gap ahead",
"table.own_delta": "Own delta",
"common.delete": "Delete",
"common.cancel": "Cancel",
"common.save": "Save",
"common.edit": "Edit",
"common.unknown_driver": "Unknown Driver",
"common.unknown_car": "Unknown Car",
"common.unknown": "Unknown",
"common.unassigned_driver": "Unassigned Driver",
"common.driver_car": "Driver Car",
"common.unknown_event": "Unknown Event",
"common.no_rows": "No rows",
"common.no_entries": "No entries.",
"common.previous": "Back",
"common.next": "Next",
"common.reset": "Reset",
"status.ready": "ready",
"status.running": "running",
"status.paused": "paused",
"status.finished": "finished",
"status.leader": "LEADER",
"status.seeded": "SEED",
"status.free_practice": "FREE",
"status.open_practice": "OPEN",
"session.open_practice": "open practice",
"session.free_practice": "free practice",
"session.practice": "practice",
"session.qualification": "qualification",
"session.heat": "heat",
"session.final": "final",
"session.team_race": "team race",
"validation.no_assignments": "No driver/car assignments in this session.",
"validation.missing_tp": "One or more assigned cars are missing transponder ID.",
"validation.duplicate_tp": "Duplicate transponder(s) in session: {ids}.",
"validation.invalid_date": "Date must be in YYYY-MM-DD format.",
"validation.invalid_selection": "Select a valid option.",
"validation.required_name": "Name is required.",
"validation.required_transponder": "Transponder is required.",
"validation.required_date": "Date is required.",
"validation.required_duration": "Duration must be at least 1 minute.",
"edit.class_name": "Edit class name",
"edit.driver_name": "Edit driver name",
"edit.driver_class": "Edit driver class",
"edit.new_driver_name": "New driver name",
"edit.driver_transponder": "Edit personal transponder (can be empty)",
"edit.car_name": "Edit car name",
"edit.new_car_name": "New car name",
"edit.car_transponder": "Edit car transponder",
"edit.event_name": "Edit event name",
"edit.event_date": "Edit event date (YYYY-MM-DD)",
"guide.title": "Guide and Documentation",
"guide.intro": "Step-by-step setup for sponsor events, regular race mode, training statistics and the Create Race Wizard in Race Setup. The guide also explains how the Manage flow is split up and where Managed AMMC actually runs.",
"guide.card_sponsor_blurb": "Shared cars, rotating drivers and heat/final flow for sponsor or try-out events.",
"guide.card_race_blurb": "Personal transponders, qualifying/finals, race format and seeding for competition racing.",
"guide.card_team_blurb": "Team race and endurance with teams, stint logs and total laps over long sessions.",
"guide.card_training_blurb": "Driver development, durable lap history, practice goals and rewards in a mobile-friendly view.",
"guide.card_decoder_blurb": "AMMC, backend, WebSocket, Windows/Linux and local SQLite storage.",
"guide.audio_title": "Race audio, start lights, and race control",
"guide.audio_1": "1. Open Settings -> Race sounds and announcements. Select Swedish or English and set master, effects, voice, and passing volume.",
"guide.audio_2": "2. Enable effect and voice separately for every event. Each row has an exact event test; missing WAV files are skipped or use the passing fallback.",
"guide.audio_3": "3. Select a 0, 10, 30, or 60 second pre-start. A race then runs drivers stand by, the start phrase, five start lights, random wait, and start tone.",
"guide.audio_4": "4. The official race clock starts in the same callback as the start tone. Only Quick Open Practice and free practice start immediately without the race sequence - a scheduled \"Practice\" session inside a race/sponsor event gets the same countdown, lights, and start tone as qualifying/heat/final.",
"guide.audio_5": "5. Timing provides manual controls for Track call, Track clear, Red flag, False start, and Marshal warning. Critical announcements interrupt lower-priority speech.",
"guide.audio_6": "6. Drivers and Cars can select pass_01.wav through pass_08.wav. A missing file uses the default; add short custom files under rc-race-sound-pack/sounds/effects/.",
"guide.audio_7": "7. Personal best, fastest lap, track record, leader changes, time warnings, pit entry/exit, finish, and podium reuse existing timing events.",
"guide.audio_8": "8. Audio plays in the operator browser. Use Test before racing, verify the audio output, and keep the Timing tab open.",
"guide.audio_9": "9. A staggered start in a qualifying heat calls out each car's transponder number in grid order, about 3 seconds apart, right after the official start - a mass/position start never calls out individual cars.",
"guide.audio_10": "10. Better voice without internet: under Settings -> Audio -> Voice engine, click Install once (downloads Piper plus Swedish and English voices, needs internet just then) and choose Local voice. Pick a male or female voice per language under Swedish voice / English voice and listen with Test the voice. Then click Pre-generate phrases and driver names before race day. Everything then runs locally; if Piper is missing or slow the browser voice is used automatically.",
"guide.sponsor_title": "Create Sponsor Event: 10 drivers, 4 cars",
"guide.sponsor_1": "1. Add 4 cars in Cars with unique transponder IDs. You can also store brand/model in the brand field.",
"guide.sponsor_2": "2. Add 10 drivers in Drivers. You can also store team/brand in the brand field and filter by it later.",
"guide.sponsor_3": "3. Create event in Track Event mode.",
"guide.sponsor_4": "4. Click Manage and create rounds (qualification/heat/final).",
"guide.sponsor_5": "5. Assign 4 drivers to 4 cars in Heat 1, rotate drivers for Heat 2/3, then finals.",
"guide.sponsor_6": "6. On Race Day: pick the session and press Start, Pause and Finish. Timing shows the times.",
"guide.race_title": "Create regular race (driver transponders)",
"guide.race_1": "1. Add drivers with personal transponder IDs. The brand field can be used for team, sponsor or car brand.",
"guide.race_2": "2. Create event in Race mode.",
"guide.race_3": "3. Click Manage on the race and select exactly which drivers should be valid for this race.",
"guide.race_4": "4. Go through Race Format and choose qualifying rounds, drivers per heat, times, start mode and how finals should be seeded.",
"guide.race_4a": "4a. Start in Basic mode with a preset. Open Advanced only when you need tie-breaks, custom points, reserved bump slots or fine-grained seeding.",
"guide.race_5": "5. Run practice if you want to use practice as the first seeding step.",
"guide.race_6": "6. Click Generate qualifying from practice to build qualifying heats from practice standings or the class list.",
"guide.race_7": "7. Run the qualifying rounds. If you want to reshuffle upcoming heats from current standings, click Reseed upcoming qualifying.",
"guide.race_8": "8. Click Generate finals from qualifying when qualifying is done.",
"guide.race_9": "9. Run the finals. If bump-up is used, click Apply bump-ups between mains after a lower final is completed.",
"guide.race_10": "10. Use Final Matrix and Print start lists/results to verify and share the setup.",
"guide.race_format_title": "Race Format Explained",
"guide.race_format_0": "Race Format is split into blocks for Practice/Qualifying, Finals and Validation. A summary card on the right shows what will be generated before you create heats and finals.",
"guide.race_format_1": "Qualifying scoring decides whether ranking is built from round points or the single best qualifying result.",
"guide.race_format_2": "Qualifying rounds and Drivers per qualifying heat control how many heats are created and how they are filled.",
"guide.race_format_3": "Qualifying duration, Qualifying start and Counted qualifying rounds control how qualifying is run and which rounds count.",
"guide.race_format_4": "Drivers per final, Final heats per main and Counted final heats control how A/B/C finals are built and scored.",
"guide.race_format_5": "Final duration and Final start control each final leg, often with position start.",
"guide.race_format_6": "Bump-up per main and Reserve bump slots are used if drivers should move from a lower final into the next main.",
"guide.race_format_7": "Source for finals decides whether finals are seeded from practice or qualifying standings.",
"guide.race_format_8": "Follow-up time adds an extra collection period after the scheduled race time before the heat is actually closed.",
"guide.race_format_9": "Min lap time filters out shortcuts and false hits. Example: on a 16-second track you can set 11 seconds as the minimum.",
"guide.race_format_10": "Max lap time is a statistics boundary. A longer passing ends the stint and is excluded from pace averages, but the lap still counts in the race. Example: 120 seconds starts a new stint after a two-minute break.",
"guide.race_format_11": "Preset lets you quickly fill the race format with sensible defaults for a short technical track, club race, IFMAR-like setup or endurance.",
"guide.race_format_11a": "In Basic mode, the endurance preset hides most qualifying and finals fields so the UI stays focused on Team Race. Open Advanced if the event also needs support heats or normal finals.",
"guide.race_format_12": "You can apply a preset and then adjust individual fields manually before saving the race format.",
"guide.race_format_13": "Save club preset stores your own local race formats so you can reuse them on the same installation without rebuilding everything each time.",
"guide.race_format_14": "Club presets can also be exported and imported from Settings if you want to move them between different servers or laptops.",
"guide.free_practice_title": "Free Practice",
"guide.free_practice_1": "Use the free practice session type when you only want to show live lap times.",
"guide.free_practice_2": "Free Practice does not affect seeding for qualifying or finals.",
"guide.free_practice_3": "The leaderboard shows laps, last lap, best lap, gap to the car ahead and your own delta versus the previous lap.",
"guide.open_practice_title": "Open Practice",
"guide.open_practice_1": "Use Open Practice when you want the system to simply list every transponder that comes in.",
"guide.open_practice_2": "If the transponder does not match a registered driver, the transponder number is shown as the name.",
"guide.open_practice_3": "Open Practice does not affect seeding, qualifying or finals.",
"guide.open_practice_4": "Go to Race Setup and use Quick Open Practice. Only a name is required; class, participants, preset and race duration are not needed.",
"guide.open_practice_5": "Easiest: press Start practice on the Dashboard or Race Day - it continues a running Open Practice or creates and starts a new one. Reset – new practice day on Race Day clears the day's laps without losing statistics, and New track layout is among the quick actions.",
"guide.team_title": "Team Race / Endurance",
"guide.team_1": "Go to Race Setup and create a race in the correct class.",
"guide.team_2": "Open Manage and go to the Teams section.",
"guide.team_3": "Enter the team name and tick drivers and/or cars in the same team block before you click Add team.",
"guide.team_4": "After the team is created, click Edit team to change drivers or cars.",
"guide.team_5": "Create a session with type Team Race and set the time, for example 240 minutes for 4 hours.",
"guide.team_6": "Start the session in Timing. All passings from the team's members are added to the team's total laps.",
"guide.validation_title": "Invalid laps, follow-up and manual corrections",
"guide.validation_1": "Recent Passings shows invalid shortcuts as Short lap. Passings over max are marked Long lap · counted · new stint and remain in the race result.",
"guide.validation_2": "Invalid short laps under the minimum threshold do not count in the leaderboard or statistics.",
"guide.validation_3": "Invalid long laps over the maximum threshold do not count as laps, but they can reset the lap base so the next valid lap starts correctly.",
"guide.validation_4": "When the scheduled time ends, the session can enter Follow-up active if Follow-up time has been configured in race format or on the session.",
"guide.validation_5": "Penalties (+1/-1 lap, +1/+5/-1 seconds) exist only in races (qualifying, heats, finals) and are given by the judge in the Judging view. The leaderboard updates immediately. Timing -> Details shows the corrections and has an Open in Judging button.",
"guide.validation_6": "In practice, remove, restore or approve any lap right in Timing -> Details. Suspiciously short laps (shortcuts) are flagged with ⚠ and listed with Approve / Remove on Timing and Race Day.",
"guide.validation_7": "The Judging view has the leaderboard, lap history with Remove / Restore per lap, penalties (races only) and the judging log with undo for the current session.",
"guide.validation_8": "The Judging view can filter invalid rows, corrected rows or team race rows, export the judging log and undo multiple recent manual actions via undo buttons.",
"guide.qualifying_title": "Seeding, points tables and tie-break",
"guide.qualifying_1": "Practice and qualifying can now use three seed methods: best N laps as total, best N laps as average or best N consecutive laps.",
"guide.qualifying_2": "Race format controls both Qualifying seed laps and Qualifying seed method when new qualifying heats are generated from practice or the participant list.",
"guide.qualifying_3": "Qualifying scoring can combine points mode with a points table: placement values, descending by field size or IFMAR 10-9-8-7-6-5-4-3-2-1.",
"guide.qualifying_4": "Qualifying tie-break can now be resolved by counted rounds, best single lap or best round / heat result.",
"guide.qualifying_5": "The leaderboard now shows seeded results in the correct format, for example 3/00:48.321, 3 avg 16.107 or 3 con 00:49.005.",
"guide.qualifying_6": "In a flying start (EFRA, the default for qualifying) and a staggered start, each driver's own timing window begins at their own first crossing after the start signal. A car that hasn't crossed in time gets its clock started anyway: flying start at the latest 150 % of the first lap anyone completes, staggered when the first car completes a full lap or at the latest 1 minute after the start (EFRA 9.3, IFMAR 4.2.3) - and a green \"Done\" flag appears next to their name in Timing and overlays as soon as their window has elapsed, even while the heat is still running for others.",
"guide.qualifying_7": "The heat's shared clock automatically extends for a staggered start to cover the full call-out schedule (driver count minus one, times the seconds between each car) on top of the normal duration - otherwise the last-called driver could be cut off before their full time is up.",
"guide.race_day_title": "Race Day and safe start",
"guide.card_race_day_blurb": "Preflight, start list, heat queue, automatic backup, and focused race operation.",
"guide.race_day_1": "1. Create the race and sessions in Race Setup, then open Race Day from the Start group.",
"guide.race_day_2": "2. Select the current heat. The list shows today's races (Show all sessions shows the rest). Running, Next and After next follow the running order: practice, qualifying round by round, finals from the lowest. ▶ Next selects the next heat when one is done. A heat deleted and made again lands in its right place, and ▲▼ on the sessions in Race Setup change the order by hand.",
"guide.race_day_3": "3. Preflight lists blockers first, then warnings and passed checks. Buttons beside issues open the relevant menu; min/max can be corrected directly in Race Day. Preflight blocks start when the Main decoder is offline, participants or transponders are missing, transponders are duplicated, the lap window is invalid, or a position grid is incomplete.",
"guide.race_day_4": "4. Yellow checks are warnings. Optional split/pit decoders, backend, and audio are visible but do not change normal lap counting.",
"guide.race_day_5": "5. Starting synchronizes state to the backend and creates a consistent SQLite backup in data/backups before the existing audio and start-tone sequence runs. The latest 30 are retained.",
"guide.race_day_6": "6. Use Race Day for start, pause, resume, and finish. The menu shows server/save status separately from the decoder. On save failure, keep the tab open and click Retry; pending changes are not confirmed saved on the server. Timing, Judging, and Overlay remain one click away. Local restore requires a stopped server and npm run backup:restore -- <file.sqlite> --confirm. A stopped or finished heat, qualifier or final is run again with ↻ Run again: laps, results and clock are reset, then press Start. While the heat runs, Race Day shows the race live under the clock: order, laps, last and best lap, gaps and estimated finish - the race controller needs no other view.",
"guide.race_day_7": "7. Session replay in Timing replays saved passings in an isolated test mode. Select a session, load it, and run at 1x, 2x, 5x, or 10x without modifying source results or training statistics.",
"guide.race_day_8": "8. Already when you register or edit a driver under Drivers, the system warns if the transponder is already used by a different driver (e.g. in the wrong class) and names who - a complement to the preflight's duplicate-transponder check within a single heat. The same person racing multiple classes on their own transponder is never flagged.",
"guide.race_day_9": "9. Running on a network others can reach (e.g. the venue WiFi)? Turn on the Admin PIN under Settings -> System & backup. Every change then needs the PIN - results, settings and updates - while viewing and public overlay/training links work as usual. Each browser logs in once and is remembered for 30 days.",
"guide.race_day_10": "10. Start with a count-down (as EFRA/IFMAR): pick a length (Go, 30 s, 1, 1:30, 2, 3 or 5 min - the default per event is set in Race Setup) and press Start. The track is open and the announcer calls the time (every minute, 30 s, 10 s; for a grid start also \"cars to the grid\" at 30 s and 9..3). Hold while cars are placed on the grid, +1 min, To 30 s (grid restart), To 10 s, Go now or Cancel. When the time runs out the heat starts by itself: a grid start gets the start lights and a random signal, a flying start gets the signal and \"Clock is running\". The transponder check shows a green tick for everyone who has crossed since the count-down began - if someone is missing, change their transponder right in the panel or pick an unknown transponder that crossed. Go now warns if someone wasn't seen.",
"guide.race_day_11": "11. Today's schedule (at the bottom of Race Day) shows every class that day in one running order with times. Set the first start and the break between heats; ▲▼ change the order. A heat that starts late or is paused moves the rest of the day. 🖨 Print running order gives a list with times and drivers for the board in the pits, and 📺 Drivers' board (/public-overlay/schedule) shows drivers the next heats and who drives them. Calls: when a heat is 10 minutes away (set under Call), Race Day asks whether to call it – 📢 Call now reads the heat and its drivers over the speakers and marks it Called on the drivers' board; Later asks again in 2 minutes. ▶ Run the day automatically starts each heat's count-down on its own when it is due and then calls the heats itself (keep this browser open); ■ Stop autopilot lets you run heats by hand and turn it back on later; ⏸ Pause the day pauses the heat on track and the autopilot until you resume.",
"guide.dashboard_title": "Schedule drift on overview",
"guide.dashboard_1": "Overview now shows the difference between planned time and actual elapsed time for all started sessions.",
"guide.dashboard_2": "Planned time includes session duration plus follow-up. Actual time uses real time from start to stop, or the current time if the heat is still running.",
"guide.dashboard_3": "That makes it easier to see whether the race day is running ahead or behind schedule directly from the dashboard.",
"guide.dashboard_4": "The Getting started cards and grouped side navigation follow the same order: connect the system, register entries when needed, create a run, then open Timing/Overlay.",
"guide.training_title": "Practice, development and rewards",
"guide.training_1": "1. Register the driver and transponder under Drivers. Club and country are optional profile fields. If the person races several classes, select the same Practice profile on every driver entry.",
"guide.training_2": "2. Run Free Practice or Open Practice. Valid laps are copied automatically to a durable training ledger; invalid short or long laps do not count. Laps from qualifying, heats and finals are kept too but only count when you pick Based on: Races or All - they are marked 🏁 with race, session and series, and shown per race session instead of as stints.",
"guide.training_3": "3. Open Training and select a driver. The default view only shows total laps, practice days, personal best, consistency, the next target and today's session. Open More statistics or Club practice overview only when needed.",
"guide.training_4": "4. The next automatic level needs no configuration. Add custom milestones when the club or a parent wants to attach a physical reward to targets such as 500, 1000 or 1500 laps.",
"guide.training_5": "5. When a target is reached, mark its reward as delivered. Bookmark `/?view=training&driver=<id>` on the driver's phone for direct access.",
"guide.training_6": "6. The training ledger follows judging corrections while the source session exists, but remains when that session is later deleted. Full data export in Settings includes both ledger and goals.",
"guide.training_7": "7. Open Goals and mobile profile, then click Enable mobile profile. Copy the personal link and open it on the driver's or parent's phone.",
"guide.training_8": "8. The mobile profile only shows the selected driver's statistics. The driver chooses Maximum focus and Controlled minutes and may mark a car change for the selected class. Race and register settings cannot be changed.",
"guide.training_9": "9. The mobile status line shows the last retrieval and warns about stale data or failed updates. Finish active input and use Retry if needed; loaded statistics remain visible. Click Create new link or Disable profile if the link is shared incorrectly. Expose only `/public-training/*`, `/src/public_training.js` and `/src/public_training.css` externally, never the full admin site or `/api/state`.",
"guide.training_10": "10. While Open Practice, Free Practice, or Practice is running, Training shows a live card for the selected driver with laps, best lap, average, and latest lap. Every driver still uses the same shared session.",
"guide.training_11": "11. The top action creates or opens the selected driver's personal mobile link. The driver configures and starts an individual timer on the phone without restarting or changing the shared practice session. Time is stored separately per driver and class.",
"guide.training_12": "12. A gap longer than 2 minutes between passings automatically starts a new stint. A long return lap defines the boundary but is excluded from stint performance metrics.",
"guide.training_13": "13. Best 5 min uses 300 seconds. A final lap counts when it started before 5:00 even if it finishes later. The stint table shows the 5-minute result separately from full stint duration, and different transponder sources are never mixed into one result.",
"guide.training_14": "14. One personal profile and mobile link can contain several classes, but 2WD/4WD statistics, stints, lap times, and recommendations are always shown separately for the selected class.",
"guide.training_15": "15. The development card compares the latest 30 valid laps with the preceding 30 in the same class. A positive value means faster average pace or a smaller spread; insufficient data is shown as collecting rather than an unreliable trend.",
"guide.training_16": "16. Achievements and the club progress feed recognize practice sessions, lap milestones, controlled driving, and completed five-minute stints. The feed follows recent activity and is not a ranking between drivers.",
"guide.training_17": "17. Open More statistics for active 30-minute pace, setup changes, stint analysis, split timing, pit stops, and history. Empty periods are hidden and pace uses a trimmed average.",
"guide.training_18": "18. Before changing the car, select New setup, tires, suspension, car, or a custom note and click Mark change now. The marker is stored only for the selected personal profile and class.",
"guide.training_19": "19. Once at least three valid laps exist within 30 minutes both before and after the marker, the change is compared automatically. Only compare runs with similar track conditions.",
"guide.training_20": "20. Stint analysis uses gaps longer than two minutes as boundaries. Normal pace is a trimmed average, outlier laps are more than 15 percent slower than the stint median, and Race pace 10 requires ten consecutive laps.",
"guide.training_21": "21. Today's challenges are optional and reset per calendar day and selected class: 20 valid laps, 5 controlled laps in a row, and one completed five-minute stint. They never affect race results or timing.",
"guide.training_22": "22. The motivation card recognizes today's laps, personal bests, improved average pace, consistency, and endurance. It only compares the driver with their own history in the selected class.",
"guide.training_23": "23. Create a club goal from Practice overview. The target starts at zero when saved and then aggregates every valid registered practice lap. Once reached, it can be marked as celebrated and replaced with a new goal.",
"guide.training_24": "24. The training stable pace audio event provides optional personal voice feedback after five controlled laps in one practice stint. It uses the driver spoken name, has a two-minute cooldown, and can be enabled separately under Race sounds and announcements.",
"guide.training_25": "25. The control zone runs from the personal best to 8 percent slower. Flow streaks reset on an outlier lap, a new stint, or a new session. Strong finishes, clean five-minute runs, and improved split times provide positive feedback but never affect race results.",
"guide.training_26": "26. Under Goals and mobile profile, choose which public sections are visible. Stints/performance also contains car-change marking and pace per active 30-minute block. Open sections remain open during live updates.",
"guide.training_27": "27. Under Training, for the selected driver/class, you can configure the two guided exercises \"Jämna varv\" (even laps: target lap time, tolerance and lap count) and \"Stegträning\" (step training: calm/controlled/fast sequence). Both run inside the already-active Open Practice session without disturbing other drivers or restarting timing.",
"guide.training_28": "28. Both exercises can also be configured, started and stopped directly from the driver's own mobile link, independent of whether the admin side has Training open. Live status (current streak or step) is shown where the driver is actually running.",
"guide.training_29": "29. When the driver's 5-minute timer on the mobile link finishes, a summary appears automatically: pace and consistency compared to recent sessions, any goal or lap milestone reached with its reward text, and one suggested next goal. The summary is dismissed with Close and reappears after the next finished pass.",
"guide.training_30": "30. Completed sessions (timer, Even laps and Step training) are saved permanently under Completed training sessions, both on the driver's mobile profile and here in admin - so past progress can be reviewed later. A completed session is always verified against the driver's real lap data before being saved, it can never simply be claimed by the mobile page.",
"guide.training_31": "31. Milestones and the club goal can target either a number of laps or a number of completed sessions of a specific exercise (for example 10 completed Step training sessions towards a reward) - the same reward flow works for both.",
"guide.archive_title": "Results archive",
"guide.card_archive_blurb": "Search and open completed races by date, class or driver without going through Race Setup.",
"guide.archive_1": "1. Open Results archive in the menu to see every completed session in one place, regardless of which event it belongs to.",
"guide.archive_2": "2. Search by event or session name, or filter by class, driver and date range.",
"guide.archive_3": "3. Click View on a row to see that session's results, penalties/corrections and per-driver lap history.",
"guide.archive_4": "4. Export the same PDF and race-package (JSON) files already available in Manage Event, directly from the archive.",
"guide.archive_5": "5. Deleting an event or session removes the race's data everywhere, including the raw lap rows in the database - but never affects a driver's durable training statistics, which are already stored separately.",
"guide.archive_6": "6. Running your club across several track layouts (e.g. indoors in the same building) - press New layout (on Training stats, Race Day or the Dashboard) when the track has been rebuilt; it works even in the middle of a running Open Practice. The archive shows which layout each session ran on, and personal bests/track records only compare against the same layout. On Training stats and in the driver's mobile profile, pick Stats for: the current layout, an older layout, or All layouts.",
"overlay.title": "Overlay",
"overlay.subtitle": "External leaderboard screen",
"overlay.no_active": "No active session selected.",
"overlay.last_passings": "Recent passings",
"overlay.window_title": "RC RaceCore Overlay",
"overlay.mode_leaderboard": "Leaderboard",
"overlay.mode_speaker": "Speaker",
"overlay.mode_results": "Results",
"overlay.mode_tv": "TV",
"overlay.mode_team": "Team",
"overlay.mode_schedule": "Drivers' board: today's schedule",
"day.title": "Today's schedule · {date}",
"day.hint": "Every class in running order with planned times. A heat that starts late or is paused moves the rest of the day. ▲▼ change the order.",
"day.print": "Print running order",
"day.board": "Drivers' board",
"day.start_time": "First start",
"day.gap": "Break between heats (min)",
"day.show_done": "✓ {count} heats run – show",
"day.hide_done": "Hide run heats ({count})",
"day.next": "Next",
"day.call_min": "Call (min before)",
"day.call_title": "{name} starts at {time} (in {min} min) – time to call it",
"day.call_now": "Call now",
"day.call_later": "Later",
"day.called_at": "Called {time}",
"day.autopilot_on": "Run the day automatically",
"day.autopilot_off": "Stop autopilot",
"day.autopilot_confirm": "Run the day automatically? Each heat starts its own count-down when the schedule says so. You can pause the day or take over at any time. Keep this browser open.",
"day.autopilot_elsewhere": "The autopilot runs on another computer.",
"day.pause": "Pause the day",
"day.resume": "Resume the day",
"day.col_time": "Time",
"day.col_session": "Class · heat",
"day.col_drivers": "Drivers",
"day.state_done": "Done",
"day.state_live": "Running",
"day.state_paused": "Paused",
"day.in_min": "in {min} min",
"day.auto_until": "Next: {name} at {time} – count-down starts in {min} min",
"day.auto_running": "Waiting for the heat on track to finish",
"day.auto_paused": "The day is paused",
"day.auto_done": "Every heat in the schedule has been run",
"day.auto_decoder": "Waiting: the decoder is not connected ({name} is next)",
"day.auto_preflight": "Waiting: {name} is not ready – see the checks",
"day.print_title": "Running order {date}",
"day.print_hint": "Times are planned and can move if something runs long. Follow the drivers' board for current times.",
"day.board_title": "Today's schedule {date}",
"day.board_now": "starting now",
"day.board_heads_up": "Called – get ready!",
"day.board_on_track": "On track",
"day.board_all_done": "Every heat has been run today.",
"day.board_none": "No schedule for today.",
"overlay.mode_obs": "OBS",
"overlay.fastest_lap": "Fastest Lap",
"overlay.fullscreen": "Fullscreen",
"overlay.leaderboard_live": "Live leaderboard",
"overlay.rotating_panel": "Display panel",
"overlay.next_predicted_lap": "Next lap",
"overlay.event_markers": "Event markers",
"overlay.obs_config": "OBS config",
"overlay.obs_public_hint": "Build a minimal public overlay URL for OBS or an external website.",
"overlay.obs_rows": "Rows",
"overlay.obs_show_clock": "Show race clock",
"overlay.obs_show_fastest": "Show fastest lap",
"overlay.obs_show_grid": "Show start grid when the race is ready",
"overlay.obs_show_laps": "Show laps",
"overlay.obs_show_result": "Show result/time",
"overlay.obs_show_best": "Show best lap",
"overlay.obs_show_gap": "Show gap",
"overlay.obs_copy_url": "Copy OBS URL",
"overlay.obs_layout": "OBS layout",
"overlay.obs_theme": "OBS theme",
"overlay.obs_public_token": "Public token",
"overlay.obs_public_token_hint": "Optional client token appended to the public overlay URL.",
"overlay.obs_layout_leaderboard": "Leaderboard",
"overlay.obs_layout_grid": "Start grid",
"overlay.obs_layout_lowerthird": "Lower third",
"overlay.obs_theme_panel": "Panel",
"overlay.obs_theme_transparent": "Transparent",
"overlay.obs_theme_chroma": "Chroma",
"overlay.team_battle": "Team battle",
"overlay.active_member": "Active driver/car",
"overlay.open_training_stats": "Click to see this driver's training stats",
"overlay.top_three": "Top 3",
"guide.host_title": "How Managed AMMC Runs",
"guide.decoder_roles_title": "Decoder roles, IP addresses, and ports",
"guide.decoder_roles_1": "1. Main start/finish is required and is the only channel allowed to count laps. Example: decoder `192.168.1.10` -> AMMC port `9000` -> `ws://server-ip:9000`.",
"guide.decoder_roles_2": "2. Split timing is optional and records time from the latest main crossing without incrementing laps. Example: `192.168.1.11` -> `9001`.",
"guide.decoder_roles_3": "3. Pit timing needs two loops: Pit entry opens the stop and Pit exit closes it. Example: `192.168.1.12` -> `9002`, and `192.168.1.13` -> `9003`.",
"guide.decoder_roles_4": "4. Decoder IP is the physical decoder address. The WebSocket port belongs to the AMMC process on the backend host. Do not confuse these two addresses.",
"guide.decoder_roles_5": "5. Every physical decoder needs a unique IP and every enabled AMMC process needs a unique port. Main/split/pit must never share a WebSocket port.",
"guide.decoder_roles_6": "6. In Settings, enable only physically installed extra channels, save Managed AMMC, and click Start AMMC. Then use the server WS URLs and Connect decoder. Open Decoder / socket diagnostics for incoming messages, errors and the latest 50 channel events. Pause/clear affect diagnostics only, never timing.",
"guide.decoder_roles_7": "7. Allow TCP 9000 and optional ports 9001-9003 through the backend host firewall when the browser runs on another machine. Port 8081 serves the web UI/API.",
"guide.decoder_roles_8": "8. Verify in Timing that every enabled role is Connected. If main is offline no laps are counted; an offline optional channel does not stop normal lap counting.",
"guide.decoder_roles_9": "9. Timing shows a live summary and pit-stop log. Race Setup shows the same data per heat, and result PDFs include stop count, total pit time, and every pit entry/exit.",
"guide.decoder_roles_10": "10. Training statistics and the personal mobile profile show sanitized split/pit aggregates per selected class. The mobile profile does not expose transponders or the raw pit log. During a driver change, the stop remains attributed to the driver and car at Pit entry.",
"guide.decoder_roles_11": "11. Choose a layout: 1 decoder = Main; 2 = Main + Split; 3 = Main + Pit entry/exit; 4 = every role. Pit timing always needs both entry and exit.",
"guide.decoder_roles_12": "12. Example: backend 192.168.1.100, main decoder .10, split .11, pit entry .12, and pit exit .13. Decoder host fields receive .10-.13; client WS URLs always use backend .100 with ports 9000-9003.",
"guide.decoder_roles_13": "13. Start order: ping decoders from backend, start backend, start Managed AMMC, inspect the AMMC log, use server WS URLs, then connect in Timing.",
"guide.decoder_roles_14": "14. Functional test: Main increments laps, Split does not, Pit entry shows IN PIT, and Pit exit creates a timed stop. See docs/decoder-setup.md for the complete guide.",
"guide.decoder_roles_15": "15. Settings is split into the Connection (decoder + Managed AMMC), Audio, Appearance & overlay and System & backup tabs instead of one long scroll - the decoder settings above are under Connection.",
"guide.host_1": "1. AMMC always runs on the backend host (`npm.cmd start` on Windows or `npm start` on Linux).",
"guide.host_2": "2. If you only browse from a laptop/browser, no process is started there. The browser only controls the backend over HTTP.",
"guide.host_3": "3. Run the backend on Linux -> the Linux binary is used: `AMMC/linux_x86-64/ammc-amb`.",
"guide.host_4": "4. Run the backend on Windows -> the Windows binary is used: `AMMC/windows64/ammc-amb.exe`.",
"guide.host_5": "5. The `AMMC executable` field in Settings is a path on the backend host, not on the client laptop.",
"guide.host_6": "6. Prefer publishing only `/public-overlay/*` and selected `/public-training/*` routes through a reverse proxy, not the full admin UI or `/api/state`.",
"guide.host_7": "7. The OBS overlay is available at `/public-overlay/obs` and can be configured from the Overlay menu.",
"guide.host_8": "8. Set `PUBLIC_OVERLAY_TOKEN` on the server if public overlay links should require `?token=...`.",
"guide.windows_title": "Windows + AMMC + npm",
"guide.windows_1": "1. Use 64-bit Windows 11. Double-click `windows/install.bat`; it installs Node.js LTS with winget when needed, runs `npm.cmd ci`, and restarts the backend.",
"guide.windows_2": "2. Setup requires Node 22 or 24 LTS and automatically verifies Express, SQLite, and `AMMC/windows64`.",
"guide.windows_3": "3. `windows/install.bat` runs `npm.cmd restart` automatically. Otherwise start with `npm.cmd start` or `windows/start_backend.bat`, check with `npm.cmd run status`, and restart with `npm.cmd restart`.",
"guide.windows_4": "4. In Settings, `Decoder IP / host` is the decoder address, for example `192.168.1.10`. Managed AMMC runs on the Windows host.",
"guide.windows_5": "5. Other devices use `http://<windows-host>:8081` and `ws://<windows-host>:9000`. See `windows/README.md` for firewall and troubleshooting.",
"guide.linux_title": "Linux + npm",
"guide.linux_1": "1. Install Node 22 LTS, build-essential and python3 on the Linux host.",
"guide.linux_2": "2. All programs in `AMMC/linux_x86-64` require GLIBC 2.39 or newer. Check with `ldd --version` or `npm run verify`; verification also checks executable permissions.",
"guide.linux_3": "3. Run `npm install`, `npm start`. Server listens on 0.0.0.0:8081. `ammc-sim` can act as a fake decoder with selected transponder IDs; see the decoder guide.",
"guide.sqlite_title": "SQLite storage",
"guide.sqlite_1": "Database file: data/rc_timing.sqlite",
"guide.sqlite_2": "API endpoints: /api/state, /api/passings and /api/passings/purge",
"guide.sqlite_3": "In Settings -> Storage you can export a full race package for backup or moving to another server or laptop.",
"guide.sqlite_4": "You can also export or import only classes, drivers and cars if you want to reset race data but keep the directory.",
"guide.sqlite_5": "Driver and car CSV files can both be exported and imported. Drivers only need name, transponder, and class; only name is required. Native exports preserve IDs and external lists merge by transponder or by name and class.",
"guide.sqlite_6": "Clear data can remove drivers, cars, classes, races, or training statistics separately. Clear all competition data retains decoder, theme, branding, and server settings. Deleting a race or session, or clearing drivers/cars/all competition data, also removes the raw SQLite passing rows for the affected sessions - a driver's durable training statistics are never affected. Export a backup first.",
"guide.ammc_ref": "AMMC reference: https://www.ammconverter.eu/docs/intro/quick-start/",
"error.backend_offline": "Backend offline: {msg}",
"error.sync_failed": "Sync failed: {msg}",
"error.health_failed": "Health check failed: {msg}",
"error.ws_invalid": "Invalid WebSocket URL: {msg}",
"error.decoder_connection": "Decoder connection error.",
"error.passing_save_failed": "Passing save failed: {msg}",
"error.ammc_load_failed": "Could not load AMMC status: {msg}",
"error.ammc_save_failed": "Could not save AMMC config: {msg}",
"error.ammc_start_failed": "Could not start AMMC: {msg}",
"error.ammc_stop_failed": "Could not stop AMMC: {msg}",
"error.print_blocked": "Popup blocked. Allow popups to print.",
"error.pdf_export_failed": "PDF export failed: {msg}"
}
};
const urlParams = new URLSearchParams(window.location.search);
const allowedOverlayModes = ["leaderboard", "speaker", "results", "tv", "team", "obs", "schedule"];
const publicOverlayMatch = window.location.pathname.match(/^\/public-overlay(?:\/([a-z0-9_-]+))?\/?$/i);
const routeOverlayMode = String(publicOverlayMatch?.[1] || "").toLowerCase();
const queryOverlayMode = String(urlParams.get("overlayMode") || "").toLowerCase();
const overlayMode = urlParams.get("view") === "overlay" || Boolean(publicOverlayMatch);
const overlayViewMode = allowedOverlayModes.includes(routeOverlayMode)
? routeOverlayMode
: allowedOverlayModes.includes(queryOverlayMode)
? queryOverlayMode
: "leaderboard";
const publicOverlayMode = Boolean(publicOverlayMatch);
const state = loadState();
const sessionReplay = createSessionReplayRuntime();
const requestedView = String(urlParams.get("view") || "").toLowerCase();
let currentView = overlayMode ? "overlay" : NAV_ITEMS.some((item) => item.id === requestedView) ? requestedView : "dashboard";
let wsClients = { main: null, split: null, pit_entry: null, pit_exit: null };
let reconnectTimers = { main: null, split: null, pit_entry: null, pit_exit: null };
let backendSyncTimer = null;
let appVersionPollTimer = null;
let baselineAppVersion = "";
let pendingAppVersion = "";
let localStateVersion = 0;
let syncedStateVersion = 0;
let localStateDirty = false;
let selectedClassEditId = null;
let selectedLeaderboardKey = null;
let selectedGridSessionId = null;
let selectedDriverEditId = null;
let selectedCarEditId = null;
let selectedEventEditId = null;
let selectedSessionEditId = null;
let selectedTeamEditId = null;
let selectedJudgeKey = null;
let selectedTrainingDriverId = String(urlParams.get("driver") || "");
let selectedTrainingClassId = String(urlParams.get("class") || "");
let judgingCompetitorFilter = "all";
let judgingLogFilter = "all";
let quickAddDraft = null;
let driverBrandFilter = "";
let carBrandFilter = "";
let raceFormatAdvanced = false;
function getObsLayouts() {
return ["leaderboard", "grid", "lowerthird"];
}
function getObsThemes() {
return ["panel", "transparent", "chroma"];
}
const OBS_LAYOUTS = getObsLayouts();
const OBS_THEMES = getObsThemes();
function createDefaultObsOverlaySettings() {
return {
rows: 10,
showClock: true,
showFastest: true,
showGrid: true,
showLaps: true,
showResult: true,
showBest: true,
showGap: true,
showPositionChange: true,
layout: "leaderboard",
theme: "panel",
publicToken: "",
};
}
const DEFAULT_OBS_OVERLAY_SETTINGS = Object.freeze(createDefaultObsOverlaySettings());
function normalizeObsOverlaySettings(raw = {}) {
const defaults = createDefaultObsOverlaySettings();
const rowValue = Number(raw?.rows);
const rows = Number.isFinite(rowValue) ? Math.max(3, Math.min(12, Math.round(rowValue))) : defaults.rows;
const layoutOptions = getObsLayouts();
const themeOptions = getObsThemes();
const layout = layoutOptions.includes(String(raw?.layout || "").toLowerCase()) ? String(raw.layout).toLowerCase() : defaults.layout;
const theme = themeOptions.includes(String(raw?.theme || "").toLowerCase()) ? String(raw.theme).toLowerCase() : defaults.theme;
return {
rows,
showClock: raw?.showClock !== false,
showFastest: raw?.showFastest !== false,
showGrid: raw?.showGrid !== false,
showLaps: raw?.showLaps !== false,
showResult: raw?.showResult !== false,
showBest: raw?.showBest !== false,
showGap: raw?.showGap !== false,
showPositionChange: raw?.showPositionChange !== false,
layout,
theme,
publicToken: String(raw?.publicToken || "").trim(),
};
}
function normalizeDriver(driver = {}) {
return {
id: String(driver?.id || uid("driver")),
name: String(driver?.name || "").trim(),
classId: String(driver?.classId || "").trim(),
transponder: String(driver?.transponder || "").trim(),
brand: String(driver?.brand || "").trim(),
speechName: String(driver?.speechName || "").trim(),
profileId: String(driver?.profileId || "").trim(),
club: String(driver?.club || "").trim(),
country: String(driver?.country || "").trim(),
passSound: String(driver?.passSound || "").trim(),
};
}
function normalizeCar(car = {}) {
return {
id: String(car?.id || uid("car")),
name: String(car?.name || "").trim(),
transponder: String(car?.transponder || "").trim(),
brand: String(car?.brand || "").trim(),
passSound: String(car?.passSound || "").trim(),
};
}
function normalizeSession(session = {}) {
const type = SESSION_TYPES.includes(String(session?.type || "").toLowerCase())
? String(session.type).toLowerCase()
: "practice";
const status = ["ready", "running", "paused", "stopped", "finished"].includes(String(session?.status || "").toLowerCase())
? String(session.status).toLowerCase()
: "ready";
const seedMethod = ["best_sum", "average", "consecutive"].includes(String(session?.seedMethod || "").toLowerCase())
? String(session.seedMethod).toLowerCase()
: "best_sum";
const assignments = Array.isArray(session?.assignments)
? session.assignments
.map((assignment) => ({
id: String(assignment?.id || uid("as")),
driverId: String(assignment?.driverId || "").trim(),
carId: String(assignment?.carId || "").trim(),
}))
.filter((assignment) => assignment.driverId || assignment.carId)
: [];
return {
...session,
id: String(session?.id || uid("session")),
eventId: String(session?.eventId || "").trim(),
name: String(session?.name || "").trim(),
type,
durationMin: Math.max(1, Number(session?.durationMin || 1) || 1),
followUpSec: Math.max(0, Number(session?.followUpSec || 0) || 0),
startMode: normalizeStartMode(session?.startMode || "mass"),
seedBestLapCount: Math.max(0, Number(session?.seedBestLapCount || 0) || 0),
seedMethod,
staggerGapSec: Math.max(0, Number(session?.staggerGapSec || 0) || 0),
maxCars: session?.maxCars ? Math.max(1, Number(session.maxCars) || 1) : null,
mode: session?.mode === "track" ? "track" : "race",
status,
startedAt: Number.isFinite(Number(session?.startedAt)) ? Number(session.startedAt) : null,
endedAt: Number.isFinite(Number(session?.endedAt)) ? Number(session.endedAt) : null,
finishedByTimer: session?.finishedByTimer === true,
pausedAt: Number.isFinite(Number(session?.pausedAt)) ? Number(session.pausedAt) : null,
totalPausedMs: Math.max(0, Number(session?.totalPausedMs || 0) || 0),
followUpPausedMs: Math.max(0, Number(session?.followUpPausedMs || 0) || 0),
audioAnnouncements: Array.isArray(session?.audioAnnouncements) ? session.audioAnnouncements.map(String).filter(Boolean) : [],
assignments,
driverIds: Array.isArray(session?.driverIds) ? session.driverIds.map(String).filter(Boolean) : [],
manualGridIds: Array.isArray(session?.manualGridIds) ? session.manualGridIds.map(String).filter(Boolean) : [],
gridCustomized: session?.gridCustomized === true,
generated: session?.generated === true,
trackLayoutId: String(session?.trackLayoutId || "").trim(),
};
}
function parseOverlayBooleanParam(name, fallback) {
const raw = urlParams.get(name);
if (raw == null) {
return fallback;
}
return ["1", "true", "yes", "on"].includes(String(raw).toLowerCase());
}
function getObsOverlayConfig() {
const base = normalizeObsOverlaySettings(state.settings?.obsOverlay || DEFAULT_OBS_OVERLAY_SETTINGS);
return normalizeObsOverlaySettings({
...base,
rows: urlParams.get("rows") ?? base.rows,
showClock: parseOverlayBooleanParam("showClock", base.showClock),
showFastest: parseOverlayBooleanParam("showFastest", base.showFastest),
showGrid: parseOverlayBooleanParam("showGrid", base.showGrid),
showLaps: parseOverlayBooleanParam("showLaps", base.showLaps),
showResult: parseOverlayBooleanParam("showResult", base.showResult),
showBest: parseOverlayBooleanParam("showBest", base.showBest),
showGap: parseOverlayBooleanParam("showGap", base.showGap),
showPositionChange: parseOverlayBooleanParam("showPositionChange", base.showPositionChange),
layout: getObsLayouts().includes(String(urlParams.get("layout") || "").toLowerCase()) ? String(urlParams.get("layout")).toLowerCase() : base.layout,
theme: getObsThemes().includes(String(urlParams.get("obsTheme") || "").toLowerCase()) ? String(urlParams.get("obsTheme")).toLowerCase() : base.theme,
publicToken: String(urlParams.get("token") || base.publicToken || "").trim(),
});
}
function writeObsOverlayParams(url, config) {
const normalized = normalizeObsOverlaySettings(config);
url.searchParams.set("rows", String(normalized.rows));
url.searchParams.set("showClock", normalized.showClock ? "1" : "0");
url.searchParams.set("showFastest", normalized.showFastest ? "1" : "0");
url.searchParams.set("showGrid", normalized.showGrid ? "1" : "0");
url.searchParams.set("showLaps", normalized.showLaps ? "1" : "0");
url.searchParams.set("showResult", normalized.showResult ? "1" : "0");
url.searchParams.set("showBest", normalized.showBest ? "1" : "0");
url.searchParams.set("showGap", normalized.showGap ? "1" : "0");
url.searchParams.set("showPositionChange", normalized.showPositionChange ? "1" : "0");
url.searchParams.set("layout", normalized.layout);
url.searchParams.set("obsTheme", normalized.theme);
if (normalized.publicToken) {
url.searchParams.set("token", normalized.publicToken);
}
}
let raceWizardStep = 1;
let raceWizardDraft = null;
let archiveFilters = { search: "", classId: "", driverId: "", dateFrom: "", dateTo: "" };
let archiveSelectedSessionId = "";
let overlaySyncTimer = null;
let overlayRotationTimer = null;
let overlayLiveRefreshTimer = null;
let backgroundHydrationTimer = null;
let overlayRotationIndex = 0;
let overlayEvents = [];
let lastOverlayLeaderKeyBySession = {};
let lastOverlayTop3BySession = {};
let lastOverlayBestLapByKey = {};
let activeModalEscapeHandler = null;
let settingsStorageNotice = "";
let settingsStorageNoticeIsError = false;
let settingsDraftActive = false;
let serverBackups = [];
let serverBackupsLoaded = false;
let updateStatus = null;
let updateStatusLoaded = false;
let updateCheckPending = false;
let updateNotice = "";
let updateNoticeIsError = false;
// Set once the first load from the server has finished (or failed): until then the state is
// only this browser's local copy, so a driver from a link (?driver=) may simply not be known
// yet - views must not treat that as "doesn't exist" and clear the selection.
let initialLoadDone = false;
const backend = {
available: false,
lastSyncAt: null,
lastError: "",
};
let audioCtx = null;
let lastFinishAnnouncementSessionId = null;
const raceAudioEngine = createRaceAudioEngine({
getSettings: () => state.settings.raceAudio,
speak: (text, options = {}) => new Promise((resolve) => {
let settled = false;
const done = (value) => { if (!settled) { settled = true; resolve(value); } };
const started = speakText(text, { ...options, voiceUri: state.settings.raceAudio?.voiceUri || "", rate: state.settings.raceAudio?.voiceRate, pitch: state.settings.raceAudio?.voicePitch, onEnd: () => done(true), onError: () => done(false) });
if (!started) done(false);
else setTimeout(() => done(true), 15000);
}),
log: (entry) => {
if (!Array.isArray(state.audioEventLog)) state.audioEventLog = [];
state.audioEventLog.unshift(entry);
if (state.audioEventLog.length > 500) state.audioEventLog.length = 500;
},
});
const ammc = {
config: createDefaultAmmcConfig(),
status: null,
lastError: "",
loaded: false,
};
const dom = {
nav: document.getElementById("nav"),
view: document.getElementById("view"),
pageTitle: document.getElementById("pageTitle"),
pageSubtitle: document.getElementById("pageSubtitle"),
activeSessionChip: document.getElementById("activeSessionChip"),
connectionBadge: document.getElementById("connectionBadge"),
clock: document.getElementById("clock"),
};
init();
async function init() {
installListSorting(document.body);
document.body.classList.toggle("overlay-mode", overlayMode);
["focusin", "input", "change"].forEach((eventName) => {
dom.view.addEventListener(eventName, markSettingsDraftActive);
});
if ("speechSynthesis" in window) {
window.speechSynthesis.addEventListener("voiceschanged", () => {
if (currentView === "settings") renderViewFromBackground();
});
}
installAuthFetchGuard({
onAuthRequired: () => showPinDialog({
t,
escapeHtml,
onSuccess: async () => {
if (localStateDirty || backend.writeError) await syncStateToBackend();
updateSyncStatus();
mountAuthSettings(document.getElementById("authSettings"), { t, escapeHtml });
},
}),
});
seedDefaultData();
applyTheme();
renderNav();
renderView();
setupLanguageControl();
updateHeaderState();
updateConnectionBadge();
tickClock();
setInterval(tickClock, 1000);
updateSyncStatus();
setInterval(updateSyncStatus, 1000);
document.getElementById("syncStatusRetry")?.addEventListener("click", async () => {
if (backend.pendingWrites) return;
if (localStateDirty || backend.writeError || backend.passingError) {
await syncStateToBackend();
if (!backend.writeError && !localStateDirty) backend.passingError = "";
}
await checkAppVersion();
updateSyncStatus();
});
startAppVersionPolling();
document.getElementById("appUpdateAvailable")?.addEventListener("click", navigateToSettings);
setInterval(() => refreshUpdateStatus({ render: currentView === "settings" }), 20 * 60 * 1000);
Promise.allSettled([hydrateFromBackend({ initial: true }), loadAmmcConfigFromBackend(), refreshServerBackups({ render: false }), refreshUpdateStatus({ render: false })]).finally(() => {
initialLoadDone = true;
applyTheme();
renderNav();
renderViewFromBackground();
setupLanguageControl();
updateHeaderState();
updateConnectionBadge();
if (state.settings.wsUrl && state.settings.autoReconnect && !state.decoder.connected) {
connectDecoder();
}
});
// One listener for the overlay's driver links: the overlay re-renders every tick.
document.addEventListener("click", (event) => {
const link = event.target instanceof Element ? event.target.closest("[data-training-driver]") : null;
if (link) openDriverTrainingStats(String(link.dataset.trainingDriver || ""));
});
startOverlaySync();
startBackgroundHydration();
startOverlayRotation();
startOverlayLiveRefresh();
if (overlayMode && state.settings.wsUrl && !state.decoder.connected) {
connectDecoder();
}
}
function updateSyncStatus() {
const container = document.getElementById("syncStatus");
if (!container) return;
const status = getSyncStatus(backend, localStateDirty);
container.dataset.state = status.kind;
const label = document.getElementById("syncStatusLabel");
const text = t("sync." + status.kind);
if (label.textContent !== text) label.textContent = text;
const detail = document.getElementById("syncStatusDetail");
const parts = [];
if (backend.lastLoadedAt) parts.push(t("sync.loaded", { time: new Date(backend.lastLoadedAt).toLocaleTimeString() }));
if (backend.lastSavedAt) parts.push(t("sync.saved_at", { time: new Date(backend.lastSavedAt).toLocaleTimeString() }));
if (!backend.available || status.kind === "stale") parts.push(t("sync.stale_hint"));
detail.textContent = parts.join(" · ");
const warning = document.getElementById("syncWarning");
if (warning) {
warning.hidden = !["offline", "stale", "error"].includes(status.kind);
warning.textContent = `${text}. ${t("sync.stale_hint")}`;
}
container.title = backend.writeError || backend.passingError || backend.lastError || "";
const retry = document.getElementById("syncStatusRetry");
retry.textContent = t("sync.retry");
retry.hidden = !status.canRetry;
retry.disabled = Boolean(backend.pendingWrites);
}
function markSettingsDraftActive(event) {
if (currentView !== "settings") return;
const target = event.target;
if (target instanceof HTMLInputElement || target instanceof HTMLSelectElement || target instanceof HTMLTextAreaElement) {
settingsDraftActive = true;
}
}
function seedDefaultData() {
if (!state.classes.length) {
state.classes.push(
{ id: uid("class"), name: "Stock 17.5T" },
{ id: uid("class"), name: "Modified" }
);
}
if (!state.settings.wsUrl) {
state.settings.wsUrl = "ws://127.0.0.1:9000";
}
if (!state.settings.backendUrl) {
state.settings.backendUrl = getDefaultBackendUrl();
}
state.settings.publicBaseUrl = String(state.settings.publicBaseUrl || "").trim().replace(/\/$/, "");
if (!state.settings.language) {
state.settings.language = DEFAULT_LANGUAGE;
}
if (!AVAILABLE_THEMES.includes(String(state.settings.theme || "").toLowerCase())) {
state.settings.theme = DEFAULT_THEME;
}
if (typeof state.settings.audioEnabled !== "boolean") {
state.settings.audioEnabled = true;
}
if (!state.settings.passingSoundMode) {
state.settings.passingSoundMode = "beep";
}
if (typeof state.settings.finishVoiceEnabled !== "boolean") {
state.settings.finishVoiceEnabled = true;
}
if (typeof state.settings.startSoundEnabled !== "boolean") {
state.settings.startSoundEnabled = true;
}
if (typeof state.settings.finishSoundEnabled !== "boolean") {
state.settings.finishSoundEnabled = true;
}
state.settings.speechVoiceUri = String(state.settings.speechVoiceUri || "");
state.settings.speechRate = Math.max(0.65, Math.min(1.35, Number(state.settings.speechRate || 0.95) || 0.95));
state.settings.speechPitch = Math.max(0.7, Math.min(1.3, Number(state.settings.speechPitch || 1) || 1));
if (typeof state.settings.speakerPassingCueEnabled !== "boolean") {
state.settings.speakerPassingCueEnabled = false;
}
if (typeof state.settings.speakerLeaderCueEnabled !== "boolean") {
state.settings.speakerLeaderCueEnabled = true;
}
if (typeof state.settings.speakerFinishCueEnabled !== "boolean") {
state.settings.speakerFinishCueEnabled = true;
}
const storedClubName = String(state.settings.clubName || "").trim();
if (!storedClubName || ["JMK RB RaceController", "RC RaceCore"].includes(storedClubName)) {
state.settings.clubName = "JMK RB";
}
const storedClubTagline = String(state.settings.clubTagline || "").trim();
if (!storedClubTagline || storedClubTagline === "RC Timing System") {
state.settings.clubTagline = "Live Timing & Race Control";
}
const storedPdfFooter = String(state.settings.pdfFooter || "").trim();
if (!storedPdfFooter || storedPdfFooter === "Generated by JMK RB RaceController") {
state.settings.pdfFooter = "Generated by RC RaceCore";
}
if (!state.settings.pdfTheme) {
state.settings.pdfTheme = "classic";
}
if (typeof state.settings.speakerBestLapCueEnabled !== "boolean") {
state.settings.speakerBestLapCueEnabled = true;
}
if (typeof state.settings.speakerTop3CueEnabled !== "boolean") {
state.settings.speakerTop3CueEnabled = false;
}
if (typeof state.settings.speakerSessionStartCueEnabled !== "boolean") {
state.settings.speakerSessionStartCueEnabled = true;
}
if (!state.settings.logoDataUrl) {
state.settings.logoDataUrl = "";
}
if (!Array.isArray(state.settings.racePresets)) {
state.settings.racePresets = [];
}
state.settings.obsOverlay = normalizeObsOverlaySettings(state.settings.obsOverlay);
state.settings.raceAudio = normalizeRaceAudioSettings(state.settings.raceAudio);
state.drivers = state.drivers.map((driver) => normalizeDriver(driver)).filter((driver) => driver.name);
state.cars = state.cars.map((car) => normalizeCar(car)).filter((car) => car.name);
state.events = state.events.map((event) => normalizeEvent(event));
state.sessions = state.sessions.map((session) => normalizeSession(session));
state.training = normalizeTrainingState(state.training);
state.trackLayouts = normalizeTrackLayouts(state.trackLayouts, { uid });
state.series = normalizeSeriesList(state.series);
state.raceDays = normalizeRaceDays(state.raceDays);
saveState({ skipBackend: true });
}
function loadState() {
const raw = localStorage.getItem(STORAGE_KEY);
if (raw) {
try {
const parsed = JSON.parse(raw);
return {
classes: parsed.classes || [],
drivers: parsed.drivers || [],
cars: parsed.cars || [],
events: parsed.events || [],
sessions: parsed.sessions || [],
resultsBySession: parsed.resultsBySession || {},
audioEventLog: Array.isArray(parsed.audioEventLog) ? parsed.audioEventLog.slice(0, 500) : [],
training: normalizeTrainingState(parsed.training),
activeSessionId: parsed.activeSessionId || null,
trackLayouts: normalizeTrackLayouts(parsed.trackLayouts, { uid }),
series: normalizeSeriesList(parsed.series),
raceDays: normalizeRaceDays(parsed.raceDays),
settings: {
wsUrl: parsed.settings?.wsUrl || "ws://127.0.0.1:9000",
splitDecoderEnabled: parsed.settings?.splitDecoderEnabled === true,
splitWsUrl: String(parsed.settings?.splitWsUrl || "ws://127.0.0.1:9001"),
pitDecoderEnabled: parsed.settings?.pitDecoderEnabled === true,
pitEntryWsUrl: String(parsed.settings?.pitEntryWsUrl || "ws://127.0.0.1:9002"),
pitExitWsUrl: String(parsed.settings?.pitExitWsUrl || "ws://127.0.0.1:9003"),
backendUrl: parsed.settings?.backendUrl || getDefaultBackendUrl(),
publicBaseUrl: String(parsed.settings?.publicBaseUrl || ""),
language: parsed.settings?.language || DEFAULT_LANGUAGE,
theme: AVAILABLE_THEMES.includes(String(parsed.settings?.theme || "").toLowerCase()) ? String(parsed.settings.theme).toLowerCase() : DEFAULT_THEME,
autoReconnect: parsed.settings?.autoReconnect !== false,
audioEnabled: parsed.settings?.audioEnabled !== false,
passingSoundMode: parsed.settings?.passingSoundMode || "beep",
finishVoiceEnabled: parsed.settings?.finishVoiceEnabled !== false,
startSoundEnabled: parsed.settings?.startSoundEnabled !== false,
finishSoundEnabled: parsed.settings?.finishSoundEnabled !== false,
speechVoiceUri: String(parsed.settings?.speechVoiceUri || ""),
speechRate: Math.max(0.65, Math.min(1.35, Number(parsed.settings?.speechRate || 0.95) || 0.95)),
speechPitch: Math.max(0.7, Math.min(1.3, Number(parsed.settings?.speechPitch || 1) || 1)),
ttsEngine: parsed.settings?.ttsEngine === "piper" ? "piper" : "browser",
ttsVoiceSv: String(parsed.settings?.ttsVoiceSv || ""),
ttsVoiceEn: String(parsed.settings?.ttsVoiceEn || ""),
speakerPassingCueEnabled: parsed.settings?.speakerPassingCueEnabled === true,
speakerLeaderCueEnabled: parsed.settings?.speakerLeaderCueEnabled !== false,
speakerFinishCueEnabled: parsed.settings?.speakerFinishCueEnabled !== false,
speakerBestLapCueEnabled: parsed.settings?.speakerBestLapCueEnabled !== false,
speakerTop3CueEnabled: parsed.settings?.speakerTop3CueEnabled === true,
speakerSessionStartCueEnabled: parsed.settings?.speakerSessionStartCueEnabled !== false,
clubName: parsed.settings?.clubName || "JMK RB",
clubTagline: parsed.settings?.clubTagline || "Live Timing & Race Control",
pdfFooter: parsed.settings?.pdfFooter || "Generated by RC RaceCore",
pdfTheme: parsed.settings?.pdfTheme || "classic",
logoDataUrl: parsed.settings?.logoDataUrl || "",
racePresets: Array.isArray(parsed.settings?.racePresets)
? parsed.settings.racePresets.map((preset) => normalizeStoredRacePreset(preset)).filter((preset) => preset.name)
: [],
obsOverlay: normalizeObsOverlaySettings(parsed.settings?.obsOverlay),
raceAudio: normalizeRaceAudioSettings(parsed.settings?.raceAudio),
},
decoder: {
connected: false,
splitConnected: false,
pitEntryConnected: false,
pitExitConnected: false,
lastMessageAt: null,
splitLastMessageAt: null,
pitEntryLastMessageAt: null,
pitExitLastMessageAt: null,
lastError: "",
splitLastError: "",
pitEntryLastError: "",
pitExitLastError: "",
},
};
} catch {
// fall through to defaults
}
}
return {
classes: [],
drivers: [],
cars: [],
events: [],
sessions: [],
resultsBySession: {},
audioEventLog: [],
training: normalizeTrainingState(),
activeSessionId: null,
trackLayouts: [],
series: [],
raceDays: [],
settings: {
wsUrl: "ws://127.0.0.1:9000",
splitDecoderEnabled: false,
splitWsUrl: "ws://127.0.0.1:9001",
pitDecoderEnabled: false,
pitEntryWsUrl: "ws://127.0.0.1:9002",
pitExitWsUrl: "ws://127.0.0.1:9003",
backendUrl: getDefaultBackendUrl(),
publicBaseUrl: "",
language: DEFAULT_LANGUAGE,
theme: DEFAULT_THEME,
autoReconnect: true,
audioEnabled: true,
passingSoundMode: "beep",
finishVoiceEnabled: true,
startSoundEnabled: true,
finishSoundEnabled: true,
speechVoiceUri: "",
speechRate: 0.95,
speechPitch: 1,
ttsEngine: "browser",
ttsVoiceSv: "",
ttsVoiceEn: "",
speakerPassingCueEnabled: false,
speakerLeaderCueEnabled: true,
speakerFinishCueEnabled: true,
speakerBestLapCueEnabled: true,
speakerTop3CueEnabled: false,
speakerSessionStartCueEnabled: true,
clubName: "JMK RB",
clubTagline: "Live Timing & Race Control",
pdfFooter: "Generated by RC RaceCore",
pdfTheme: "classic",
logoDataUrl: "",
racePresets: [],
obsOverlay: normalizeObsOverlaySettings(),
raceAudio: normalizeRaceAudioSettings(),
},
decoder: {
connected: false,
splitConnected: false,
pitEntryConnected: false,
pitExitConnected: false,
lastMessageAt: null,
splitLastMessageAt: null,
pitEntryLastMessageAt: null,
pitExitLastMessageAt: null,
lastError: "",
splitLastError: "",
pitEntryLastError: "",
pitExitLastError: "",
},
};
}
function saveState(options = {}) {
const persistable = buildPersistableState();
const cached = writeLocalCache(localStorage, STORAGE_KEY, persistable);
if (!cached.ok && !localCacheFull) console.warn("Browser storage is full; the local cache is dropped and the server's state is used.", cached.error);
localCacheFull = !cached.ok;
if (!options.skipBackend) {
localStateVersion += 1;
localStateDirty = true;
scheduleBackendSync();
updateSyncStatus();
}
}
async function startOperationalSession(session, callbacks = {}) {
if (!session) return { ok: false, message: t("race_day.start_failed") };
const { requirePreflight = false, onTone, ...sequenceCallbacks } = callbacks;
if (session.mode === "track") {
const validation = validateTrackSessionForStart(session);
if (!validation.ok) return { ok: false, message: validation.message };
}
if (requirePreflight) {
const preflight = buildRaceDayPreflight(state, session, { backendAvailable: backend.available });
if (!preflight.ready) return { ok: false, message: t("race_day.not_ready") };
}
ensureAudioContext();
startsInProgress += 1;
try {
return await runOperationalStart(session, sequenceCallbacks, onTone);
} finally {
startsInProgress -= 1;
}
}
let startsInProgress = 0;
async function runOperationalStart(session, sequenceCallbacks, onTone) {
let backup = null;
try {
backup = await createServerBackup("pre_start", session);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (!window.confirm(t("race_day.backup_failed_confirm", { msg: message }))) {
return { ok: false, message };
}
}
let committed = false;
const commitStart = () => {
if (committed) return;
committed = true;
// The state may have been reloaded during the start sequence: start the heat that is in it.
session = state.sessions.find((item) => item.id === session.id) || session;
state.activeSessionId = session.id;
beginSessionControl(session);
session.trackLayoutId = getTrackLayoutIdAt(state.trackLayouts);
lastFinishAnnouncementSessionId = null;
lastOverlayLeaderKeyBySession[session.id] = null;
lastOverlayTop3BySession[session.id] = [];
overlayEvents = [];
ensureSessionResult(session.id);
announceRaceStarted(session);
saveState();
updateHeaderState();
onTone?.();
renderView();
};
try {
const started = await startSessionWithAudio(session, { ...sequenceCallbacks, onTone: commitStart });
if (started === false) return { ok: false, message: t("race_day.start_failed"), backup };
if (!committed) commitStart();
return { ok: true, backup };
} catch (error) {
commitStart();
return { ok: true, backup, audioWarning: error instanceof Error ? error.message : String(error) };
}
}
function saveOperationalLapWindow(session, minLapSec, maxLapSec) {
const event = state.events.find((item) => item.id === session?.eventId);
const minLapMs = Math.round(Number(minLapSec) * 1000);
const maxLapMs = Math.round(Number(maxLapSec) * 1000);
// Practice on a layout: the lap window belongs to that layout, not to the event.
if (isPracticeSessionType(session?.type) && session.trackLayoutId && state.trackLayouts?.some((layout) => layout.id === session.trackLayoutId)) {
if (!Number.isFinite(minLapMs) || !Number.isFinite(maxLapMs) || minLapMs <= 0 || maxLapMs <= minLapMs) return false;
const result = updateTrackLayoutLapWindow(session.trackLayoutId, minLapMs, maxLapMs);
if (result.ok) renderView();
return result.ok;
}
if (!event || !Number.isFinite(minLapMs) || !Number.isFinite(maxLapMs) || minLapMs <= 0 || maxLapMs <= minLapMs) return false;
event.raceConfig = { ...(event.raceConfig || {}), minLapMs, maxLapMs };
saveState();
renderView();
return true;
}
function finishOperationalSession(session) {
if (!session) return false;
cancelRaceStart();
state.activeSessionId = session.id;
finishSessionControl(session);
lastFinishAnnouncementSessionId = session.id;
announceRaceFinished();
saveState();
updateHeaderState();
renderView();
return true;
}
function pauseOperationalSession(session) {
if (!pauseSessionControl(session)) return false;
triggerRaceAudio("race_paused", { interrupt: true, force: true, logData: { raceId: session.eventId, sessionId: session.id } });
saveState();
renderView();
return true;
}
function resumeOperationalSession(session) {
if (!resumeSessionControl(session)) return false;
triggerRaceAudio("race_resumed", { interrupt: true, force: true, logData: { raceId: session.eventId, sessionId: session.id } });
saveState();
renderView();
return true;
}
function uid(prefix) {
return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
}
function currentLanguage() {
return state.settings.language === "en" ? "en" : "sv";
}
function currentTheme() {
return AVAILABLE_THEMES.includes(String(state.settings.theme || "").toLowerCase()) ? String(state.settings.theme).toLowerCase() : DEFAULT_THEME;
}
function applyTheme() {
document.body.dataset.theme = currentTheme();
}
function t(key, vars = {}) {
const lang = currentLanguage();
const dict = TRANSLATIONS[lang] || TRANSLATIONS.en;
const template = dict[key] ?? TRANSLATIONS.en[key] ?? key;
return String(template).replace(/\{(\w+)\}/g, (_, token) => String(vars[token] ?? ""));
}
function setupLanguageControl() {
const themeLabel = document.getElementById("themeLabel");
if (themeLabel) {
themeLabel.textContent = t("ui.theme");
}
const themeSelect = document.getElementById("themeSelect");
if (themeSelect instanceof HTMLSelectElement) {
themeSelect.value = currentTheme();
Array.from(themeSelect.options).forEach((option) => {
option.textContent = t(`ui.theme_${option.value}`);
});
themeSelect.onchange = () => {
state.settings.theme = AVAILABLE_THEMES.includes(themeSelect.value) ? themeSelect.value : DEFAULT_THEME;
applyTheme();
saveState();
};
}
const label = document.getElementById("languageLabel");
if (label) {
label.textContent = t("ui.language");
}
updateAppBranding();
const select = document.getElementById("languageSelect");
if (!(select instanceof HTMLSelectElement)) {
return;
}
select.value = currentLanguage();
select.onchange = () => {
state.settings.language = select.value === "en" ? "en" : "sv";
saveState();
renderNav();
renderView();
updateConnectionBadge();
updateHeaderState();
setupLanguageControl();
};
}
function updateAppBranding() {
const clubName = String(state.settings?.clubName || "").trim() || PRODUCT_NAME;
const clubTagline = String(state.settings?.clubTagline || "").trim() || t("brand.subtitle");
const logoDataUrl = String(state.settings?.logoDataUrl || "").trim();
const hasLogo = /^data:image\/(?:png|jpeg|webp);base64,/i.test(logoDataUrl);
const brandTitle = document.getElementById("brandTitle");
const brandSubtitle = document.getElementById("brandSubtitle");
const brandMark = document.getElementById("brandMark");
const brandLogo = document.getElementById("brandLogo");
if (brandTitle) brandTitle.textContent = clubName;
if (brandSubtitle) brandSubtitle.textContent = clubTagline;
if (brandMark) brandMark.classList.toggle("has-logo", hasLogo);
if (brandLogo instanceof HTMLImageElement) {
brandLogo.hidden = !hasLogo;
if (hasLogo) brandLogo.src = logoDataUrl;
else brandLogo.removeAttribute("src");
}
document.title = clubName === PRODUCT_NAME ? PRODUCT_NAME : `${clubName} | ${PRODUCT_NAME}`;
}
function buildPersistableState() {
syncTrainingLedger();
return {
classes: state.classes,
drivers: state.drivers.map((driver) => normalizeDriver(driver)),
cars: state.cars.map((car) => normalizeCar(car)),
events: state.events,
sessions: state.sessions.map((session) => normalizeSession(session)),
resultsBySession: state.resultsBySession,
audioEventLog: Array.isArray(state.audioEventLog) ? state.audioEventLog.slice(0, 500) : [],
training: normalizeTrainingState(state.training),
activeSessionId: state.activeSessionId,
settings: state.settings,
trackLayouts: normalizeTrackLayouts(state.trackLayouts, { uid }),
series: normalizeSeriesList(state.series),
raceDays: normalizeRaceDays(state.raceDays),
};
}
function normalizeImportedClass(classItem) {
return {
id: String(classItem?.id || uid("class")),
name: String(classItem?.name || "").trim(),
};
}
function buildExportMeta(exportType) {
return {
app: "RC RaceCore",
schemaVersion: EXPORT_SCHEMA_VERSION,
exportType,
exportedAt: new Date().toISOString(),
};
}
function sanitizeFilenameSegment(value) {
return String(value || "")
.trim()
.replace(/[^a-z0-9_-]+/gi, "_")
.replace(/^_+|_+$/g, "") || "export";
}
function downloadBlobFile(filename, blob) {
const url = URL.createObjectURL(blob);
const link = document.createElement("a");
link.href = url;
link.download = filename;
link.click();
URL.revokeObjectURL(url);
}
function downloadJsonFile(filename, payload) {
downloadBlobFile(filename, new Blob([JSON.stringify(payload, null, 2)], { type: "application/json" }));
}
function rowToCsv(row) {
return row.map((value) => `"${String(value || "").replaceAll('"', '""')}"`).join(",");
}
function downloadCsvFile(filename, rows) {
const csv = rows.map((row) => rowToCsv(row)).join("\n");
downloadBlobFile(filename, new Blob([csv], { type: "text/csv;charset=utf-8" }));
}
function buildDataExportPayload() {
return {
...buildExportMeta("full_data"),
classes: state.classes,
drivers: state.drivers,
cars: state.cars,
events: state.events,
sessions: state.sessions,
resultsBySession: state.resultsBySession,
training: normalizeTrainingState(state.training),
};
}
function buildDirectoryExportPayload() {
return {
...buildExportMeta("directory"),
classes: state.classes,
drivers: state.drivers,
cars: state.cars,
};
}
function buildDriversCsvRows() {
return [
["id", "name", "class", "brand", "transponder", "spoken_name", "club", "country", "profile_id"],
...state.drivers.map((driver) => [driver.id, driver.name, getClassName(driver.classId), driver.brand || "", driver.transponder || "", driver.speechName || "", driver.club || "", driver.country || "", driver.profileId || ""]),
];
}
function buildCarsCsvRows() {
return [
["id", "name", "brand", "transponder"],
...state.cars.map((car) => [car.id, car.name, car.brand || "", car.transponder || ""]),
];
}
function importDirectoryCsv(text, type) {
try {
if (type === "drivers") {
const result = importDriversCsv(text, { classes: state.classes, drivers: state.drivers, uid });
state.classes = result.classes.map((item) => normalizeImportedClass(item)).filter((item) => item.name);
state.drivers = result.drivers.map((item) => normalizeDriver(item)).filter((item) => item.name);
settingsStorageNotice = t("settings.import_csv_success", {
type: t("settings.csv_type_drivers"),
added: result.added,
updated: result.updated,
skipped: result.skipped,
});
} else if (type === "cars") {
const result = importCarsCsv(text, { cars: state.cars, uid });
state.cars = result.cars.map((item) => normalizeCar(item)).filter((item) => item.name);
settingsStorageNotice = t("settings.import_csv_success", {
type: t("settings.csv_type_cars"),
added: result.added,
updated: result.updated,
skipped: result.skipped,
});
} else {
throw new Error("Unsupported CSV import type");
}
settingsStorageNoticeIsError = false;
saveState();
} catch (error) {
settingsStorageNotice = t("settings.import_failed", { msg: error instanceof Error ? error.message : String(error) });
settingsStorageNoticeIsError = true;
}
renderView();
}
function clearDataScope(scope) {
// drivers/cars/races/all all reset resultsBySession entirely below (not scoped to just the
// affected driver/car), so the raw SQLite passing rows behind every current session become
// orphaned the same way a single deleted event/session's rows would - purge them all here too.
const sessionIdsBeforeClear = state.sessions.map((session) => session.id);
const clearDriverReferences = () => {
state.events = state.events.map((event) => ({
...event,
raceConfig: {
...(event.raceConfig || {}),
driverIds: [],
teams: (event.raceConfig?.teams || []).map((team) => ({ ...team, driverIds: [] })),
},
}));
state.sessions = state.sessions.map((session) => ({
...session,
driverIds: [],
manualGridIds: [],
assignments: (session.assignments || []).map((assignment) => ({ ...assignment, driverId: "" })),
}));
};
const clearCarReferences = () => {
state.events = state.events.map((event) => ({
...event,
raceConfig: {
...(event.raceConfig || {}),
teams: (event.raceConfig?.teams || []).map((team) => ({ ...team, carIds: [] })),
},
}));
state.sessions = state.sessions.map((session) => ({
...session,
assignments: (session.assignments || []).map((assignment) => ({ ...assignment, carId: "" })),
}));
};
if (scope === "drivers") {
state.drivers = [];
state.training = normalizeTrainingState({});
state.resultsBySession = {};
clearDriverReferences();
} else if (scope === "cars") {
state.cars = [];
state.resultsBySession = {};
clearCarReferences();
} else if (scope === "classes") {
state.classes = [];
state.drivers = state.drivers.map((driver) => ({ ...driver, classId: "" }));
state.events = state.events.map((event) => ({ ...event, classId: "" }));
} else if (scope === "races") {
syncTrainingLedger();
state.events = [];
state.sessions = [];
state.resultsBySession = {};
state.activeSessionId = null;
} else if (scope === "training") {
state.training = normalizeTrainingState({});
} else if (scope === "all") {
state.classes = [];
state.drivers = [];
state.cars = [];
state.events = [];
state.sessions = [];
state.resultsBySession = {};
state.training = normalizeTrainingState({});
state.activeSessionId = null;
} else {
return;
}
settingsStorageNotice = t("settings.clear_success");
settingsStorageNoticeIsError = false;
saveState();
if (["drivers", "cars", "races", "all"].includes(scope)) void purgeSessionPassings(sessionIdsBeforeClear);
renderNav();
renderView();
}
function collectEventPackageReferences(event, sessions) {
const driverIds = new Set(event.classId ? getDriversForClass(event.classId).map((driver) => driver.id) : []);
const carIds = new Set();
(event?.raceConfig?.driverIds || []).forEach((driverId) => driverIds.add(driverId));
(event?.raceConfig?.teams || []).forEach((team) => {
(team.driverIds || []).forEach((driverId) => driverIds.add(driverId));
(team.carIds || []).forEach((carId) => carIds.add(carId));
});
(sessions || []).forEach((session) => {
(session.driverIds || []).forEach((driverId) => driverIds.add(driverId));
(session.manualGridIds || []).forEach((driverId) => driverIds.add(driverId));
(session.assignments || []).forEach((assignment) => {
if (assignment.driverId) driverIds.add(assignment.driverId);
if (assignment.carId) carIds.add(assignment.carId);
});
});
return {
classes: state.classes.filter((item) => item.id === event.classId),
drivers: state.drivers.filter((driver) => driverIds.has(driver.id)),
cars: state.cars.filter((car) => carIds.has(car.id)),
};
}
function buildRacePackagePayload(eventId) {
const event = state.events.find((item) => item.id === eventId);
if (!event) {
throw new Error("Event not found");
}
const sessions = getSessionsForEvent(eventId);
const refs = collectEventPackageReferences(event, sessions);
const resultsBySession = {};
sessions.forEach((session) => {
if (state.resultsBySession[session.id]) {
resultsBySession[session.id] = state.resultsBySession[session.id];
}
});
return {
...buildExportMeta("race_package"),
classes: refs.classes,
drivers: refs.drivers,
cars: refs.cars,
event,
sessions,
resultsBySession,
};
}
function mergeCollectionById(currentItems, incomingItems, normalizer) {
const map = new Map((currentItems || []).map((item) => [item.id, normalizer(item)]));
(incomingItems || []).map((item) => normalizer(item)).forEach((item) => {
if (item && item.id) {
map.set(item.id, item);
}
});
return [...map.values()];
}
function importRacePackagePayload(parsed) {
const importedEvent = parsed?.event ? normalizeEvent(parsed.event) : null;
const incomingClasses = Array.isArray(parsed?.classes) ? parsed.classes : [];
const incomingDrivers = Array.isArray(parsed?.drivers) ? parsed.drivers : [];
const incomingCars = Array.isArray(parsed?.cars) ? parsed.cars : [];
const incomingSessions = Array.isArray(parsed?.sessions) ? parsed.sessions.map((item) => normalizeSession(item)) : [];
if (!importedEvent || !incomingSessions.length) {
throw new Error("No race package found");
}
state.classes = mergeCollectionById(state.classes, incomingClasses, normalizeImportedClass).filter((item) => item.name);
state.drivers = mergeCollectionById(state.drivers, incomingDrivers, normalizeDriver).filter((driver) => driver.name);
state.cars = mergeCollectionById(state.cars, incomingCars, normalizeCar).filter((car) => car.name);
const newEventId = uid("event");
const sessionIdMap = new Map();
const clonedEvent = normalizeEvent({
...importedEvent,
id: newEventId,
});
const clonedSessions = incomingSessions.map((session) => {
const newSessionId = uid("session");
sessionIdMap.set(session.id, newSessionId);
return normalizeSession({
...session,
id: newSessionId,
eventId: newEventId,
status: "ready",
startedAt: null,
endedAt: null,
finishedByTimer: false,
});
});
const importedResults = parsed?.resultsBySession && typeof parsed.resultsBySession === "object" ? parsed.resultsBySession : {};
Object.entries(importedResults).forEach(([oldSessionId, value]) => {
const newSessionId = sessionIdMap.get(oldSessionId);
if (newSessionId) {
state.resultsBySession[newSessionId] = value;
}
});
state.events.push(clonedEvent);
state.sessions.push(...clonedSessions);
saveState();
renderView();
renderEventManager(newEventId);
}
function importDataPayload(parsed, mode = "full") {
const incomingClasses = Array.isArray(parsed?.classes) ? parsed.classes : [];
const incomingDrivers = Array.isArray(parsed?.drivers) ? parsed.drivers : [];
const incomingCars = Array.isArray(parsed?.cars) ? parsed.cars : [];
if (mode === "directory") {
state.classes = mergeCollectionById(state.classes, incomingClasses, normalizeImportedClass).filter((item) => item.name);
state.drivers = mergeCollectionById(state.drivers, incomingDrivers, normalizeDriver).filter((driver) => driver.name);
state.cars = mergeCollectionById(state.cars, incomingCars, normalizeCar).filter((car) => car.name);
settingsStorageNotice = t("settings.import_directory_success");
settingsStorageNoticeIsError = false;
saveState();
renderView();
return;
}
const incomingEvents = Array.isArray(parsed?.events) ? parsed.events : [];
const incomingSessions = Array.isArray(parsed?.sessions) ? parsed.sessions : [];
if (!incomingClasses.length && !incomingDrivers.length && !incomingCars.length && !incomingEvents.length && !incomingSessions.length) {
throw new Error("No importable data found");
}
state.classes = incomingClasses.map((item) => normalizeImportedClass(item)).filter((item) => item.name);
state.drivers = incomingDrivers.map((item) => normalizeDriver(item)).filter((item) => item.name);
state.cars = incomingCars.map((item) => normalizeCar(item)).filter((item) => item.name);
state.events = incomingEvents.map((item) => normalizeEvent(item));
state.sessions = incomingSessions.map((item) => normalizeSession(item));
state.resultsBySession = parsed?.resultsBySession && typeof parsed.resultsBySession === "object" ? parsed.resultsBySession : {};
state.training = normalizeTrainingState(parsed?.training);
if (!state.sessions.some((session) => session.id === state.activeSessionId)) {
state.activeSessionId = null;
}
settingsStorageNotice = t("settings.import_full_success");
settingsStorageNoticeIsError = false;
saveState();
renderNav();
renderView();
}
function getDefaultBackendUrl() {
if (window.location.protocol.startsWith("http") && window.location.hostname) {
return window.location.origin;
}
return "http://127.0.0.1:8081";
}
function getBackendUrl() {
return String(state.settings.backendUrl || getDefaultBackendUrl()).replace(/\/+$/, "");
}
async function refreshServerBackups({ render = true } = {}) {
try {
const response = await fetch(`${getBackendUrl()}/api/backups`, { cache: "no-store" });
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const payload = await response.json();
serverBackups = Array.isArray(payload.backups) ? payload.backups : [];
serverBackupsLoaded = true;
} catch (error) {
serverBackupsLoaded = true;
backend.lastError = error instanceof Error ? error.message : String(error);
}
if (render && currentView === "settings") renderView();
return serverBackups;
}
function addTrackLayout(label, startedAtMs = Date.now(), { minLapMs = 0, maxLapMs = 0 } = {}) {
const blocking = findRaceSessionBlockingLayoutChange(state.sessions);
if (blocking) return { ok: false, message: t("settings.track_layout_race_running", { name: blocking.name }) };
const layouts = normalizeTrackLayouts(state.trackLayouts, { uid });
const latest = layouts.at(-1);
if (latest && startedAtMs <= latest.startedAt) {
return { ok: false, message: t("settings.track_layout_date_error", { date: new Date(latest.startedAt).toLocaleString() }) };
}
const lapWindow = validateLayoutLapWindow(minLapMs, maxLapMs);
if (!lapWindow.ok) return lapWindow;
const layout = { id: uid("layout"), label: String(label || "").trim() || nextTrackLayoutLabel(layouts), startedAt: startedAtMs, minLapMs: lapWindow.minLapMs, maxLapMs: lapWindow.maxLapMs };
layouts.push(layout);
state.trackLayouts = normalizeTrackLayouts(layouts, { uid });
// A practice session that keeps running across the switch moves onto the new layout;
// its earlier laps stay on the old one because training laps are tagged per lap.
// Its best laps start over too: personal bests, session fastest and the leaderboard's best
// lap are per layout, so the old layout's times can't block or fake a new best.
if (startedAtMs <= Date.now()) {
state.sessions.forEach((session) => {
if (!isPracticeSessionType(session.type) || !["running", "paused"].includes(session.status)) return;
session.trackLayoutId = layout.id;
Object.values(state.resultsBySession?.[session.id]?.competitors || {}).forEach((entry) => {
entry.bestLapMs = null;
entry.bestLapLayoutId = layout.id;
delete lastOverlayBestLapByKey[`${session.id}:${entry.key}`];
});
});
}
saveState();
return { ok: true, layout };
}
// 0 / empty = not set (the event's value applies); when both are set, max must exceed min.
function validateLayoutLapWindow(minLapMs, maxLapMs) {
const min = Math.max(0, Math.round(Number(minLapMs) || 0));
const max = Math.max(0, Math.round(Number(maxLapMs) || 0));
if (min && max && max <= min) return { ok: false, message: t("race_day.lap_window_invalid") };
return { ok: true, minLapMs: min, maxLapMs: max };
}
function updateTrackLayoutLapWindow(id, minLapMs, maxLapMs) {
const lapWindow = validateLayoutLapWindow(minLapMs, maxLapMs);
if (!lapWindow.ok) return lapWindow;
const layouts = normalizeTrackLayouts(state.trackLayouts, { uid });
const layout = layouts.find((item) => item.id === id);
if (!layout) return { ok: false, message: t("common.unknown") };
Object.assign(layout, { minLapMs: lapWindow.minLapMs, maxLapMs: lapWindow.maxLapMs });
state.trackLayouts = layouts;
saveState();
return { ok: true, layout };
}
function deleteTrackLayout(id) {
if (isTrackLayoutInUse(id, { sessions: state.sessions, ledger: state.training?.ledger || [] })) {
return { ok: false, message: t("settings.track_layout_delete_blocked") };
}
state.trackLayouts = normalizeTrackLayouts(state.trackLayouts, { uid }).filter((layout) => layout.id !== id);
saveState();
return { ok: true };
}
async function refreshUpdateStatus({ render = true, force = false } = {}) {
updateCheckPending = true;
try {
const response = await fetch(`${getBackendUrl()}/api/update-status${force ? "?force=1" : ""}`, { cache: "no-store" });
if (!response.ok) throw new Error(`HTTP ${response.status}`);
updateStatus = await response.json();
} catch (error) {
updateStatus = { checked: false, available: false, error: error instanceof Error ? error.message : String(error) };
}
updateStatusLoaded = true;
updateCheckPending = false;
refreshSidebarUpdateLink();
if (render && currentView === "settings") renderView();
return updateStatus;
}
function refreshSidebarUpdateLink() {
const link = document.getElementById("appUpdateAvailable");
if (!link) return;
if (updateStatus?.available && updateStatus.remoteVersion) {
link.textContent = t("settings.update_available_sidebar", { version: updateStatus.remoteVersion });
link.hidden = false;
} else {
link.hidden = true;
}
}
function navigateToSettings() {
openSettingsTab("system", "settingsUpdateSection");
currentView = "settings";
updateViewUrl(currentView);
renderNav();
renderView();
}
async function runUpdateNow() {
const response = await fetch(`${getBackendUrl()}/api/update/run`, { method: "POST" });
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
return payload;
}
async function createServerBackup(reason = "manual", session = null) {
await syncStateToBackend();
if (!backend.available) throw new Error(backend.lastError || "Backend offline");
const response = await fetch(`${getBackendUrl()}/api/backups`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ reason, sessionId: session?.id || "", eventId: session?.eventId || "" }),
});
const payload = await response.json().catch(() => ({}));
if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
if (payload.backup) {
serverBackups = [payload.backup, ...serverBackups.filter((item) => item.fileName !== payload.backup.fileName)].slice(0, 30);
}
return payload.backup || null;
}
// The raw passing rows behind a deleted event/session live only in SQLite, outside
// buildPersistableState()/POST /api/state entirely, so deleting the event/session locally
// can't reach them - this is a best-effort side call to ask the server to clean them up too.
// A failure here (offline, etc.) is not worth blocking or rolling back the deletion itself.
async function purgeSessionPassings(sessionIds) {
const ids = (Array.isArray(sessionIds) ? sessionIds : [sessionIds]).filter(Boolean);
if (!ids.length) return;
try {
await fetch(`${getBackendUrl()}/api/passings/purge`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ sessionIds: ids }),
});
} catch {
// best-effort cleanup only
}
}
// `settingsTab` opens Settings on that tab (Race Day's "fix" buttons, for instance).
function navigateToView(view, { settingsTab = "" } = {}) {
if (view === "settings" && settingsTab) openSettingsTab(settingsTab);
currentView = view;
updateViewUrl(view);
renderNav();
renderView();
}
// Overlay: a click on a driver opens their own training stats. In the menu's Overlay it switches
// view; the stand-alone overlay window stays up and opens the stats in a new tab. The public
// overlay has no links: the driver's mobile profile link is personal and can also write.
function openDriverTrainingStats(driverId) {
if (publicOverlayMode || !driverId) return;
const classId = String(state.drivers.find((driver) => driver.id === driverId)?.classId || "");
if (overlayMode) {
const url = new URL("/", window.location.origin);
url.searchParams.set("view", "training");
url.searchParams.set("driver", driverId);
if (classId) url.searchParams.set("class", classId);
window.open(url.toString(), "_blank");
return;
}
selectedTrainingDriverId = driverId;
selectedTrainingClassId = classId;
currentView = "training";
updateViewUrl("training", driverId, classId);
renderNav();
renderView();
}
function selectOperationalSession(sessionId, options = {}) {
const session = state.sessions.find((item) => item.id === sessionId);
if (!session) return false;
state.activeSessionId = session.id;
saveState();
updateHeaderState();
if (options.render !== false) renderView();
return true;
}
function renderNav() {
if (overlayMode) {
dom.nav.innerHTML = "";
return;
}
dom.nav.innerHTML = "";
let currentGroupKey = "";
NAV_ITEMS.forEach((item) => {
if (item.groupKey && item.groupKey !== currentGroupKey) {
currentGroupKey = item.groupKey;
const groupLabel = document.createElement("div");
groupLabel.className = "nav-group-label";
groupLabel.textContent = t(currentGroupKey);
dom.nav.appendChild(groupLabel);
}
const button = document.createElement("button");
button.className = `nav-item ${item.id === currentView ? "active" : ""}`;
button.textContent = t(item.titleKey);
button.addEventListener("click", () => {
if (item.id === "training") {
selectedTrainingDriverId = "";
selectedTrainingClassId = "";
}
currentView = item.id;
updateViewUrl(currentView);
renderNav();
renderView();
});
dom.nav.appendChild(button);
});
}
function updateViewUrl(view, driverId = "", classId = "") {
if (overlayMode) return;
const nextUrl = new URL(window.location.href);
if (view && view !== "dashboard") nextUrl.searchParams.set("view", view);
else nextUrl.searchParams.delete("view");
if (view === "training" && driverId) nextUrl.searchParams.set("driver", driverId);
else nextUrl.searchParams.delete("driver");
if (view === "training" && classId) nextUrl.searchParams.set("class", classId);
else nextUrl.searchParams.delete("class");
window.history.replaceState({}, "", nextUrl);
}
function renderView() {
updateAppBranding();
if (currentView === "settings") settingsDraftActive = false;
clearModalEscapeHandler();
const navMeta = NAV_ITEMS.find((x) => x.id === currentView);
dom.pageTitle.textContent = navMeta ? t(navMeta.titleKey) : "";
dom.pageSubtitle.textContent = navMeta ? t(navMeta.subtitleKey) : "";
const languageLabel = document.getElementById("languageLabel");
if (languageLabel) {
languageLabel.textContent = t("ui.language");
}
const themeLabel = document.getElementById("themeLabel");
if (themeLabel) {
themeLabel.textContent = t("ui.theme");
}
try {
switch (currentView) {
case "dashboard":
renderDashboard();
break;
case "race_day":
renderRaceDay();
break;
case "events":
renderEvents();
break;
case "race_setup":
renderRaceSetup();
break;
case "classes":
renderClasses();
break;
case "drivers":
renderDrivers();
break;
case "cars":
renderCars();
break;
case "training":
renderTraining();
break;
case "archive":
renderArchive();
break;
case "series":
renderSeries();
break;
case "timing":
renderTiming();
break;
case "judging":
renderJudging();
break;
case "overlay":
if (overlayViewMode === "schedule") renderBoard();
else renderOverlay();
break;
case "settings":
renderSettings({
dom,
ammc,
state,
t,
backend,
settingsStorageNotice,
settingsStorageNoticeIsError,
getManagedWsUrl,
getBackendUrl,
getDefaultBackendUrl,
escapeHtml,
saveState,
renderView,
connectDecoder,
playPassingBeep,
playFinishSiren,
playStartCue,
speakText,
getSpeechVoices,
openOverlayWindow,
buildOverlayUrl,
normalizeObsOverlaySettings,
DEFAULT_OBS_OVERLAY_SETTINGS,
OBS_LAYOUTS,
OBS_THEMES,
pingBackend,
syncStateToBackend,
buildDataExportPayload,
downloadJsonFile,
importDataPayload,
buildDirectoryExportPayload,
downloadCsvFile,
buildDriversCsvRows,
buildCarsCsvRows,
importDirectoryCsv,
clearDataScope,
buildExportMeta,
normalizeStoredRacePreset,
saveAmmcConfigToBackend,
refreshAmmcStatus,
startManagedAmmc,
stopManagedAmmc,
normalizeRaceAudioSettings,
raceAudioEventDefinitions: RACE_AUDIO_EVENT_DEFINITIONS,
triggerRaceAudio,
serverBackups,
serverBackupsLoaded,
createManualServerBackup: () => createServerBackup("manual"),
createSafetyServerBackup: () => createServerBackup("pre_change"),
refreshServerBackups,
trackLayouts: state.trackLayouts,
nextTrackLayoutLabel: () => nextTrackLayoutLabel(state.trackLayouts),
addTrackLayout,
deleteTrackLayout,
updateTrackLayoutLapWindow,
updateStatus,
updateStatusLoaded,
updateCheckPending,
updateNotice,
updateNoticeIsError,
refreshUpdateStatus,
runUpdateNow,
setUpdateNotice: (message, isError = false) => { updateNotice = message; updateNoticeIsError = isError; },
});
break;
case "guide":
renderGuide();
break;
default:
renderDashboard();
}
} catch (error) {
console.error("renderView failed", error);
dom.view.innerHTML = `
<section class="panel">
<div class="panel-header"><h3>Render error</h3></div>
<div class="panel-body">
<p>${escapeHtml(error instanceof Error ? error.message : String(error))}</p>
</div>
</section>
`;
}
updateHeaderState();
}
function renderViewFromBackground() {
if (currentView === "settings" && settingsDraftActive) return;
renderView();
}
function clearModalEscapeHandler() {
if (activeModalEscapeHandler) {
document.removeEventListener("keydown", activeModalEscapeHandler);
activeModalEscapeHandler = null;
}
}
function bindModalShell(overlayId, onClose, focusSelector = 'input, select, textarea, button') {
const overlay = document.getElementById(overlayId);
if (!overlay) {
clearModalEscapeHandler();
return;
}
const focusTarget = overlay.querySelector(focusSelector);
window.setTimeout(() => {
if (focusTarget instanceof HTMLElement) {
focusTarget.focus();
if (focusTarget instanceof HTMLInputElement) {
focusTarget.select();
}
}
}, 0);
clearModalEscapeHandler();
activeModalEscapeHandler = (event) => {
if (event.key === "Escape") {
event.preventDefault();
onClose();
}
};
document.addEventListener("keydown", activeModalEscapeHandler);
}
function setFormError(errorId, message) {
const errorNode = document.getElementById(errorId);
if (!errorNode) {
return;
}
errorNode.textContent = message || "";
errorNode.hidden = !message;
}
function updateHeaderState() {
const session = getActiveSession();
if (!session) {
dom.activeSessionChip.textContent = t("ui.no_active_session");
return;
}
const event = state.events.find((e) => e.id === session.eventId);
dom.activeSessionChip.textContent = `${event?.name || t("ui.event")} • ${getSessionTypeLabel(session.type).toUpperCase()} • ${getStatusLabel(
session.status
).toUpperCase()}`;
}
function updateConnectionBadge() {
const isOnline = state.decoder.connected;
const enabledExtraCount = Number(state.settings.splitDecoderEnabled) + (state.settings.pitDecoderEnabled ? 2 : 0);
const connectedExtraCount = Number(state.decoder.splitConnected) + Number(state.decoder.pitEntryConnected) + Number(state.decoder.pitExitConnected);
const extraStatus = enabledExtraCount ? ` • ${connectedExtraCount}/${enabledExtraCount}` : "";
dom.connectionBadge.textContent = `${isOnline ? t("ui.decoder_online") : t("ui.decoder_offline")}${extraStatus}`;
dom.connectionBadge.className = `badge ${isOnline ? "badge-online" : "badge-offline"}`;
}
function renderEvents() {
renderEventWorkspace("track");
}
function renderRaceSetup() {
renderEventWorkspace("race");
}
function renderEventWorkspace(mode) {
renderEventWorkspaceView({
mode,
state,
dom,
t,
escapeHtml,
renderTable,
renderRaceWizardStepsView,
renderRaceWizardContentView,
getRaceWizardDraft: () => raceWizardDraft,
setRaceWizardDraft: (value) => { raceWizardDraft = value; },
getRaceWizardStep: () => raceWizardStep,
setRaceWizardStep: (value) => { raceWizardStep = value; },
ensureRaceWizardDraft,
getDriversForClass,
getRaceWizardPreset,
getSessionsForEvent,
getClassName,
getModeLabel,
getSelectedEventEditId: () => selectedEventEditId,
setSelectedEventEditId: (value) => { selectedEventEditId = value; },
renderView,
renderEventManager,
uid,
normalizeEvent,
applyRaceFormatPreset,
buildOpenPracticeBundle,
buildRaceSessionsFromWizard,
buildDefaultRaceWizardDraft,
applyRaceWizardPresetDefaults,
setSelectedTeamEditId: (value) => { selectedTeamEditId = value; },
setSelectedSessionEditId: (value) => { selectedSessionEditId = value; },
setFormError,
bindModalShell,
isValidIsoDate,
saveState,
purgeSessionPassings,
// Opens the session where it is run: Race Day (start/pause/finish moved there from Timing).
openTimingSession: (sessionId) => {
state.activeSessionId = sessionId;
saveState();
currentView = "race_day";
updateViewUrl(currentView);
renderNav();
updateHeaderState();
renderView();
},
});
}
function renderEventManager(eventId) {
renderEventManagerView({
eventId,
state,
t,
escapeHtml,
normalizeEvent,
ensureRaceParticipantsConfigured,
getSessionsForEvent,
buildEventSchedule,
getSelectedTeamEditId: () => selectedTeamEditId,
setSelectedTeamEditId: (value) => { selectedTeamEditId = value; },
getSelectedSessionEditId: () => selectedSessionEditId,
setSelectedSessionEditId: (value) => { selectedSessionEditId = value; },
getSelectedGridSessionId: () => selectedGridSessionId,
setSelectedGridSessionId: (value) => { selectedGridSessionId = value; },
getRaceFormatAdvanced: () => raceFormatAdvanced,
setRaceFormatAdvanced: (value) => { raceFormatAdvanced = value; },
getEventDrivers,
getTeamDriverPool,
getEventTeams,
reassignTeamMembers,
moveDriversIntoQualifyingHeat,
parseQualifyingHeatName,
normalizeBrandingConfig,
getSessionTypeChoices,
getRaceFormatPresets,
getRaceSummaryItems,
getRaceSummaryWarnings,
getRaceManageStatuses,
normalizeStartMode,
renderEventManagerMarkup,
getSessionEntrants,
getSessionTypeLabel,
getStartModeLabel,
getStatusLabel,
renderManageStatusBadgeView,
getDriverDisplayById,
renderRaceFormatContextCardView,
renderRaceFormatFieldView,
renderGridEditor,
renderRaceStandingsTableView,
buildPracticeStandings,
buildQualifyingStandings,
buildFinalStandings,
renderTeamRaceStandings,
renderSessionChannelAnalysis,
renderFinalMatrix,
getModeLabel,
renderTable,
bindModalShell,
setFormError,
saveState,
purgeSessionPassings,
renderView,
rerenderEventManager: renderEventManager,
updateHeaderState,
uid,
normalizeSession,
buildSessionHeatSheetHtml,
openPrintWindow,
exportSessionHeatSheet,
exportSessionHeatSheetPdf,
getSelectedAssignmentSessionId,
autoAssignTrackSession,
renderAssignmentList,
normalizeRaceTeam,
buildRaceFormatConfigFromForm,
applyRaceFormatPreset,
normalizeStoredRacePreset,
generateQualifyingForRace,
clearGeneratedQualifying,
reseedUpcomingQualifying,
generateFinalsForRace,
clearGeneratedFinals,
applyBumpsForRace,
buildRacePackagePayload,
downloadJsonFile,
sanitizeFilenameSegment,
importRacePackagePayload,
buildRaceStartListsHtml,
buildRaceResultsHtml,
buildTeamRaceResultsHtml,
exportRaceStartListsPdf,
exportRaceResultsPdf,
exportTeamRaceResultsPdf,
ensureSessionDriverOrder,
reorderList,
getEventName,
});
}
function getFreePracticeSessions(eventId) {
return getSessionsForEvent(eventId).filter((session) => session.type === "free_practice");
}
function renderSimpleList(items, labelFn, idFn) {
if (!items.length) {
return `<p>${t("common.no_entries")}</p>`;
}
return `
<ul class="simple-list">
${items
.map(
(item) => `
<li>
<span>${labelFn(item)}</span>
<button class="btn btn-danger btn-mini" id="${idFn(item)}">${t("common.delete")}</button>
</li>
`
)
.join("")}
</ul>
`;
}
function renderTable(headers, rowHtml) {
return `
<table class="data-table">
<thead>
<tr>
${headers.map((h) => `<th>${escapeHtml(h)}</th>`).join("")}
</tr>
</thead>
<tbody>
${rowHtml.join("") || `<tr><td colspan="${headers.length}">${t("common.no_rows")}</td></tr>`}
</tbody>
</table>
`;
}
function getDriversForClass(classId) {
return state.drivers.filter((driver) => !classId || driver.classId === classId);
}
function ensureRaceWizardDraft() {
if (!raceWizardDraft) {
raceWizardDraft = applyRaceWizardPresetDefaults(buildDefaultRaceWizardDraft(), "club_qualifying");
}
if (!state.classes.some((item) => item.id === raceWizardDraft.classId)) {
raceWizardDraft.classId = state.classes[0]?.id || "";
raceWizardDraft.driverIds = getDriversForClass(raceWizardDraft.classId).map((driver) => driver.id);
}
if (!raceWizardDraft.date) {
raceWizardDraft.date = new Date().toISOString().slice(0, 10);
}
}
function formatLap(ms) {
if (!ms && ms !== 0) {
return "-";
}
const total = Math.max(0, Math.floor(ms));
const m = Math.floor(total / 60000);
const s = Math.floor((total % 60000) / 1000)
.toString()
.padStart(2, "0");
const t = Math.floor(total % 1000)
.toString()
.padStart(3, "0");
return `${m}:${s}.${t}`;
}
function formatPredictedLapDelta(ms) {
if (ms === null || ms === undefined || Number.isNaN(ms)) {
return "-";
}
if (ms >= 0) {
return formatLap(ms);
}
const cappedOverdueMs = Math.min(Math.abs(ms), 60000);
return `+${formatLap(cappedOverdueMs)}`;
}
function formatCountdown(ms) {
const total = Math.max(0, Math.floor(ms));
const m = Math.floor(total / 60000)
.toString()
.padStart(2, "0");
const s = Math.floor((total % 60000) / 1000)
.toString()
.padStart(2, "0");
return `${m}:${s}`;
}
function formatElapsedClock(ms) {
const total = Math.max(0, Math.floor(ms / 1000));
const h = Math.floor(total / 3600)
.toString()
.padStart(1, "0");
const m = Math.floor((total % 3600) / 60)
.toString()
.padStart(2, "0");
const s = Math.floor(total % 60)
.toString()
.padStart(2, "0");
return `${h}:${m}:${s}`;
}
function formatRaceClock(ms) {
const total = Math.max(0, Math.floor(ms));
const m = Math.floor(total / 60000)
.toString()
.padStart(2, "0");
const s = Math.floor((total % 60000) / 1000)
.toString()
.padStart(2, "0");
const millis = Math.floor(total % 1000)
.toString()
.padStart(3, "0");
return `${m}:${s}.${millis}`;
}
function getSeedMethodLabel(method) {
const normalized = ["best_sum", "average", "consecutive"].includes(String(method || "").toLowerCase())
? String(method).toLowerCase()
: "best_sum";
return t(`events.seed_method_${normalized}`);
}
function formatSeedMetric(metric) {
if (!metric) {
return "-";
}
if (metric.method === "average") {
return `${metric.lapCount} avg ${formatLap(metric.averageMs)}`;
}
if (metric.method === "consecutive") {
return `${metric.lapCount} con ${formatRaceClock(metric.totalMs)}`;
}
return `${metric.lapCount}/${formatRaceClock(metric.totalMs)}`;
}
function clearGeneratedQualifying(eventId) {
const generatedIds = state.sessions
.filter((session) => session.eventId === eventId && session.type === "qualification" && session.generated)
.map((session) => session.id);
state.sessions = state.sessions.filter((session) => !generatedIds.includes(session.id));
generatedIds.forEach((sessionId) => {
delete state.resultsBySession[sessionId];
if (state.activeSessionId === sessionId) {
state.activeSessionId = null;
}
});
}
function clearGeneratedFinals(eventId) {
const generatedIds = state.sessions.filter((session) => session.eventId === eventId && session.type === "final" && session.generated).map((session) => session.id);
state.sessions = state.sessions.filter((session) => !generatedIds.includes(session.id));
generatedIds.forEach((sessionId) => {
delete state.resultsBySession[sessionId];
if (state.activeSessionId === sessionId) {
state.activeSessionId = null;
}
});
}
function openPrintWindow(title, bodyHtml) {
// noopener/noreferrer force window.open() to return null even when the window opens
// successfully (WHATWG spec, all modern browsers), which made the blocked-popup check
// below always fire and this always exit before writing any content. The opened window
// only ever holds first-party generated HTML, so dropping both flags is safe here.
const printWindow = window.open("", "_blank", "width=1200,height=900");
if (!printWindow) {
alert(t("error.print_blocked"));
return;
}
printWindow.document.write(`
<!doctype html>
<html lang="${escapeHtml(state.settings.language || DEFAULT_LANGUAGE)}">
<head>
<meta charset="utf-8" />
<title>${escapeHtml(title)}</title>
<style>
@page { size: A4 portrait; margin: 14mm; }
body { font-family: Arial, sans-serif; padding: 0; color: #10131a; }
h1, h2, h3 { margin: 0 0 12px; }
h1 { font-size: 28px; }
h2 { font-size: 18px; border-bottom: 2px solid #10131a; padding-bottom: 4px; }
p { margin: 0 0 12px; color: #44506b; }
.print-header { display: flex; justify-content: space-between; gap: 24px; align-items: flex-start; padding-bottom: 16px; border-bottom: 4px solid #10131a; }
.print-kicker { text-transform: uppercase; letter-spacing: 0.08em; color: #5b677f; font-size: 12px; }
.print-meta { text-align: right; font-size: 13px; }
.print-brand-block { display: flex; align-items: center; justify-content: flex-end; gap: 12px; }
.print-brand-block p { margin: 0; }
.print-logo { max-width: 92px; max-height: 52px; object-fit: contain; }
.print-block { margin-top: 24px; break-inside: avoid; }
table { width: 100%; border-collapse: collapse; margin-top: 12px; }
th, td { border: 1px solid #b9c2d4; padding: 8px; text-align: left; }
th { background: #eef2f8; font-size: 12px; text-transform: uppercase; letter-spacing: 0.04em; }
tbody tr:nth-child(even) { background: #f8faff; }
</style>
</head>
<body>
${bodyHtml}
</body>
</html>
`);
printWindow.document.close();
printWindow.focus();
setTimeout(() => {
printWindow.print();
}, 150);
}
function buildPdfSection(title, headers, rows) {
return { title, headers, rows };
}
async function requestPdfExport(payload) {
try {
const response = await fetch(`${getBackendUrl()}/api/export/pdf`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(payload),
});
if (!response.ok) {
const errorPayload = await response.json().catch(() => ({}));
throw new Error(errorPayload.error || `HTTP ${response.status}`);
}
const blob = await response.blob();
const url = URL.createObjectURL(blob);
const link = document.createElement("a");
link.href = url;
link.download = payload.filename || "export.pdf";
link.click();
URL.revokeObjectURL(url);
} catch (error) {
alert(t("error.pdf_export_failed", { msg: error instanceof Error ? error.message : String(error) }));
}
}
function loadImageElement(src) {
return new Promise((resolve, reject) => {
const image = new Image();
image.onload = () => resolve(image);
image.onerror = () => reject(new Error("Image load failed"));
image.src = src;
});
}
async function ensurePdfLogoDataUrl(dataUrl) {
if (!dataUrl) {
return "";
}
if (/^data:image\/jpeg;base64,/i.test(dataUrl)) {
return dataUrl;
}
try {
const image = await loadImageElement(dataUrl);
const canvas = document.createElement("canvas");
const width = Math.max(1, image.naturalWidth || image.width || 1);
const height = Math.max(1, image.naturalHeight || image.height || 1);
canvas.width = width;
canvas.height = height;
const context = canvas.getContext("2d");
if (!context) {
return "";
}
context.fillStyle = "#ffffff";
context.fillRect(0, 0, width, height);
context.drawImage(image, 0, 0, width, height);
return canvas.toDataURL("image/jpeg", 0.92);
} catch {
return "";
}
}
async function exportRaceStartListsPdf(event) {
const branding = resolveEventBranding(event);
const sessions = getSessionsForEvent(event.id)
.filter((session) => session.mode === "race")
.sort((left, right) => {
const weightDiff = getSessionSortWeight(left) - getSessionSortWeight(right);
if (weightDiff !== 0) {
return weightDiff;
}
return String(left.name || "").localeCompare(String(right.name || ""));
});
const sections = sessions.map((session) =>
buildPdfSection(
`${session.name} • ${getSessionTypeLabel(session.type)}`,
[t("events.slot"), t("table.driver"), t("table.brand"), t("table.transponder")],
getSessionGridEntries(session).map((entry) => {
const driver = state.drivers.find((item) => item.id === entry.id);
return [String(entry.slot), entry.name, driver?.brand || "-", entry.meta || "-"];
})
)
);
await requestPdfExport({
filename: `${event.name.replaceAll(/\s+/g, "_")}_startlists.pdf`,
title: event.name,
subtitle: `${getClassName(event.classId)} • ${event.date || "-"}`,
brandName: branding.brandName,
brandTagline: branding.brandTagline,
footer: branding.pdfFooter,
theme: branding.pdfTheme,
logoDataUrl: await ensurePdfLogoDataUrl(branding.logoDataUrl),
sections,
});
}
async function exportRaceResultsPdf(event) {
const branding = resolveEventBranding(event);
const channelSections = getSessionsForEvent(event.id).flatMap((session) => buildSessionChannelPdfSections(session));
await requestPdfExport({
filename: `${event.name.replaceAll(/\s+/g, "_")}_results.pdf`,
title: event.name,
subtitle: `${getClassName(event.classId)} • ${event.date || "-"}`,
brandName: branding.brandName,
brandTagline: branding.brandTagline,
footer: branding.pdfFooter,
theme: branding.pdfTheme,
logoDataUrl: await ensurePdfLogoDataUrl(branding.logoDataUrl),
sections: [
buildPdfSection(
t("events.practice_standings"),
[t("table.pos"), t("table.driver"), t("table.score")],
buildPracticeStandings(event).map((row) => [String(row.rank), row.driverName || "-", row.score || "-"])
),
buildPdfSection(
t("events.qualifying_standings"),
[t("table.pos"), t("table.driver"), t("table.score")],
buildQualifyingStandings(event).map((row) => [
String(row.rank),
row.driverName || "-",
row.scoreNote ? `${row.score || "-"} | ${row.scoreNote}` : row.score || "-",
])
),
buildPdfSection(
t("events.final_standings"),
[t("table.pos"), t("table.driver"), t("table.score")],
buildFinalStandings(event).map((row) => [String(row.rank), row.driverName || "-", row.score || "-"])
),
...buildTeamRaceStandings(event).map(({ session, rows }) =>
buildPdfSection(
`${t("events.team_standings")} • ${session.name}`,
[t("table.pos"), t("events.team_name"), t("table.laps"), t("table.result"), t("table.best_lap"), t("timing.pit_stops"), t("timing.total_pit")],
rows.map((row, index) => {
const channel = buildSessionChannelStats(session).competitors.find((item) => item.competitorKey === row.key) || {};
return [
String(index + 1),
row.displayName || row.driverName || "-",
String(row.laps || 0),
row.resultDisplay || "-",
formatLap(row.bestLapMs),
String(channel.pitStopCount || 0),
channel.pitStopCount ? formatRaceClock(channel.totalPitMs) : "-",
];
})
)
),
...channelSections,
],
});
}
function buildSessionChannelPdfSections(session) {
const stats = buildSessionChannelStats(session);
if (!stats.splitCount && !stats.pitStopCount) {
return [];
}
const sections = [
buildPdfSection(
`${timingSessionPdfTitle(session)} • ${t("timing.channel_analysis")}`,
[t("table.driver"), t("timing.split_count"), t("timing.best_split"), t("timing.average_split"), t("timing.pit_stops"), t("timing.total_pit"), t("timing.average_pit"), t("timing.best_pit")],
stats.competitors.map((row) => [
row.displayName || "-",
String(row.splitCount || 0),
row.splitCount ? formatLap(row.bestSplitMs) : "-",
row.splitCount ? formatLap(row.averageSplitMs) : "-",
String(row.pitStopCount || 0),
row.pitStopCount ? formatRaceClock(row.totalPitMs) : "-",
row.pitStopCount ? formatLap(row.averagePitStopMs) : "-",
row.pitStopCount ? formatLap(row.bestPitStopMs) : "-",
])
),
];
if (stats.pitStops.length) {
sections.push(
buildPdfSection(
`${timingSessionPdfTitle(session)} • ${t("timing.pit_stop_log")}`,
["#", t("events.team_name"), t("table.driver"), t("table.car"), t("timing.pit_in"), t("timing.pit_out"), t("table.duration")],
stats.pitStops.map((stop) => [
String(stop.index),
stop.displayName || "-",
stop.driverName || "-",
stop.carName || "-",
stop.enteredAt ? new Date(stop.enteredAt).toLocaleTimeString() : "-",
stop.exitedAt ? new Date(stop.exitedAt).toLocaleTimeString() : "-",
formatLap(stop.pitStopMs),
])
)
);
}
return sections;
}
function timingSessionPdfTitle(session) {
return `${session.name} • ${getSessionTypeLabel(session.type)}`;
}
async function exportTeamRaceResultsPdf(event) {
const branding = resolveEventBranding(event);
const sections = [];
buildTeamRaceStandings(event).forEach(({ session, rows }) => {
const channelRows = new Map(buildSessionChannelStats(session).competitors.map((row) => [row.competitorKey, row]));
sections.push(
buildPdfSection(
`${t("events.team_report")} • ${session.name}`,
[t("table.pos"), t("events.team_name"), t("table.laps"), t("table.result"), t("table.best_lap"), t("timing.pit_stops"), t("timing.total_pit")],
rows.map((row, index) => {
const channel = channelRows.get(row.key) || {};
return [
String(index + 1),
row.displayName || row.driverName || "-",
String(row.laps || 0),
row.resultDisplay || "-",
formatLap(row.bestLapMs),
String(channel.pitStopCount || 0),
channel.pitStopCount ? formatRaceClock(channel.totalPitMs) : "-",
];
})
)
);
rows.forEach((row) => {
const stints = buildTeamStintLog(session, row);
sections.push(
buildPdfSection(
`${session.name} • ${row.displayName || row.driverName} • ${t("events.team_stint_log")}`,
[t("events.slot"), t("table.driver"), t("table.car"), t("table.time"), t("table.duration"), t("table.laps")],
stints.map((stint) => [
String(stint.index),
stint.driverName || "-",
stint.carName || "-",
new Date(stint.startTs).toLocaleTimeString(),
formatRaceClock(stint.durationMs),
String(stint.laps || 0),
])
)
);
});
sections.push(...buildSessionChannelPdfSections(session));
});
await requestPdfExport({
filename: `${event.name.replaceAll(/\s+/g, "_")}_team_report.pdf`,
title: event.name,
subtitle: `${t("events.team_report")} • ${getClassName(event.classId)} • ${event.date || "-"}`,
brandName: branding.brandName,
brandTagline: branding.brandTagline,
footer: branding.pdfFooter,
theme: branding.pdfTheme,
logoDataUrl: await ensurePdfLogoDataUrl(branding.logoDataUrl),
sections,
});
}
async function exportSessionHeatSheetPdf(session) {
const event = state.events.find((item) => item.id === session.eventId);
const branding = resolveEventBranding(event);
await requestPdfExport({
filename: `${(event?.name || "event").replaceAll(/\s+/g, "_")}_${session.name.replaceAll(/\s+/g, "_")}.pdf`,
title: event?.name || t("common.unknown_event"),
subtitle: `${getSessionTypeLabel(session.type)} • ${session.name} • ${getClassName(event?.classId || "")}`,
brandName: branding.brandName,
brandTagline: branding.brandTagline,
footer: branding.pdfFooter,
theme: branding.pdfTheme,
logoDataUrl: await ensurePdfLogoDataUrl(branding.logoDataUrl),
sections: [
buildPdfSection(
`${session.name} • ${getSessionTypeLabel(session.type)}`,
[t("events.slot"), t("table.driver"), t("table.brand"), t("table.transponder")],
getSessionGridEntries(session).map((entry) => {
const driver = state.drivers.find((item) => item.id === entry.id);
return [String(entry.slot), entry.name, driver?.brand || "-", entry.meta || "-"];
})
),
],
});
}
function reorderList(items, fromIndex, toIndex) {
const copy = [...items];
const [moved] = copy.splice(fromIndex, 1);
copy.splice(toIndex, 0, moved);
return copy;
}
function buildSessionHeatSheetHtml(session) {
const event = state.events.find((item) => item.id === session.eventId);
const branding = resolveEventBranding(event);
const entries = getSessionGridEntries(session);
return `
<header class="print-header">
<div>
<p class="print-kicker">${escapeHtml(getClassName(event?.classId || ""))}</p>
<h1>${escapeHtml(event?.name || t("common.unknown_event"))}</h1>
<p>${escapeHtml(session.name)} • ${escapeHtml(getSessionTypeLabel(session.type))}</p>
</div>
<div class="print-meta">
${buildPrintBrandBlock(branding)}
</div>
</header>
<p>${t("table.start_mode")}: ${escapeHtml(getStartModeLabel(session.startMode))} • ${t("table.duration")}: ${session.durationMin} min</p>
${
entries.length
? renderTable(
[t("events.slot"), t("table.driver"), t("table.brand"), t("table.transponder")],
entries.map((entry) => {
const driver = state.drivers.find((item) => item.id === entry.id);
return `
<tr>
<td>${entry.slot}</td>
<td>${escapeHtml(entry.name)}</td>
<td>${escapeHtml(driver?.brand || "-")}</td>
<td>${escapeHtml(entry.meta || "-")}</td>
</tr>
`;
})
)
: `<p>${t("common.no_entries")}</p>`
}
`;
}
function exportSessionHeatSheet(session) {
const event = state.events.find((item) => item.id === session.eventId);
const entries = getSessionGridEntries(session);
const rows = [
["event", "class", "session", "type", "start_mode", "duration_min", "slot", "driver", "brand", "transponder"],
...entries.map((entry) => [
event?.name || "",
getClassName(event?.classId || ""),
session.name,
getSessionTypeLabel(session.type),
getStartModeLabel(session.startMode),
String(session.durationMin || ""),
String(entry.slot),
entry.name,
state.drivers.find((item) => item.id === entry.id)?.brand || "",
entry.meta || "",
]),
];
const csv = rows
.map((row) => row.map((value) => `"${String(value || "").replaceAll('"', '""')}"`).join(","))
.join("\n");
const blob = new Blob([csv], { type: "text/csv;charset=utf-8" });
const url = URL.createObjectURL(blob);
const link = document.createElement("a");
link.href = url;
link.download = `${(event?.name || "event").replaceAll(/\s+/g, "_")}_${session.name.replaceAll(/\s+/g, "_")}.csv`;
link.click();
URL.revokeObjectURL(url);
}
function buildOverlayUrl(mode = "leaderboard", options = {}) {
const normalizedMode = allowedOverlayModes.includes(String(mode || "").toLowerCase()) ? String(mode).toLowerCase() : "leaderboard";
const url = new URL(window.location.href);
if (options.public) {
url.pathname = `/public-overlay/${normalizedMode}`;
url.search = "";
if (normalizedMode === "obs") {
writeObsOverlayParams(url, state.settings.obsOverlay);
}
return url.toString();
}
url.searchParams.set("view", "overlay");
url.searchParams.set("overlayMode", normalizedMode);
if (normalizedMode === "obs") {
writeObsOverlayParams(url, state.settings.obsOverlay);
}
return url.toString();
}
function openOverlayWindow(mode = "leaderboard", options = {}) {
const width = Math.max(1280, window.screen?.availWidth || 1600);
const height = Math.max(720, window.screen?.availHeight || 900);
// noopener/noreferrer force window.open() to return null even when the window opens
// successfully (WHATWG spec, all modern browsers), which made the blocked-popup check
// below always fire and overlayWindow.focus() below unreachable. The overlay URL is
// always same-origin (see buildOverlayUrl), so dropping both flags is safe here.
const overlayWindow = window.open(
buildOverlayUrl(mode, options),
"_blank",
`popup=yes,left=0,top=0,width=${width},height=${height}`
);
if (!overlayWindow) {
alert(t("error.print_blocked"));
return;
}
overlayWindow.focus();
}
function chunkArray(items, size) {
const chunks = [];
for (let index = 0; index < items.length; index += size) {
chunks.push(items.slice(index, index + size));
}
return chunks;
}
function isValidIsoDate(value) {
return /^\d{4}-\d{2}-\d{2}$/.test(String(value || ""));
}
function getSelectedAssignmentSessionId() {
const form = document.getElementById("assignForm");
if (!(form instanceof HTMLFormElement)) {
return "";
}
const formData = new FormData(form);
return String(formData.get("sessionId") || "");
}
function autoAssignTrackSession(event, sessionId) {
const session = state.sessions.find((x) => x.id === sessionId);
if (!session) {
return;
}
const driversForClass = state.drivers.filter((d) => d.classId === event.classId);
const drivers = shuffle([...driversForClass.length ? driversForClass : state.drivers]);
const uniqueCars = uniqueCarsByTransponder(state.cars);
session.assignments = [];
const limit = Math.min(uniqueCars.length, drivers.length);
for (let i = 0; i < limit; i += 1) {
session.assignments.push({
id: uid("as"),
driverId: drivers[i].id,
carId: uniqueCars[i].id,
});
}
}
function uniqueCarsByTransponder(cars) {
const seen = new Set();
const output = [];
cars.forEach((car) => {
const key = String(car.transponder || "").trim();
if (!key) {
return;
}
if (seen.has(key)) {
return;
}
seen.add(key);
output.push(car);
});
return output;
}
function shuffle(items) {
for (let i = items.length - 1; i > 0; i -= 1) {
const j = Math.floor(Math.random() * (i + 1));
const temp = items[i];
items[i] = items[j];
items[j] = temp;
}
return items;
}
function validateTrackSessionForStart(session) {
// Open Practice never requires pre-assignments here or in the Race Day preflight
// (src/race_day_logic.js): anonymous transponders register as drivers on passing.
if (session.type === "open_practice") {
return { ok: true, message: "" };
}
const assignments = session.assignments || [];
if (!assignments.length) {
return { ok: false, message: t("validation.no_assignments") };
}
const missingTransponder = assignments.find((assignment) => {
const car = state.cars.find((c) => c.id === assignment.carId);
return !String(car?.transponder || "").trim();
});
if (missingTransponder) {
return { ok: false, message: t("validation.missing_tp") };
}
const duplicateTransponders = findDuplicateSessionTransponders(session);
if (duplicateTransponders.length) {
return {
ok: false,
message: t("validation.duplicate_tp", { ids: duplicateTransponders.join(", ") }),
};
}
return { ok: true, message: "" };
}
function findDuplicateSessionTransponders(session) {
const counts = {};
(session.assignments || []).forEach((assignment) => {
const car = state.cars.find((c) => c.id === assignment.carId);
const tp = String(car?.transponder || "").trim();
if (!tp) {
return;
}
counts[tp] = (counts[tp] || 0) + 1;
});
return Object.keys(counts).filter((tp) => counts[tp] > 1);
}
async function persistSessionResultToBackend(sessionId) {
if (!sessionId || !state.resultsBySession[sessionId]) return;
try {
const res = await fetch(`${getBackendUrl()}/api/session-results`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ sessionId, sessionResult: state.resultsBySession[sessionId] }),
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
} catch {
// The regular state save still carries the correction once the session is no longer hot.
}
}
async function persistPassingToBackend(sessionId, passing) {
backend.pendingWrites = (backend.pendingWrites || 0) + 1;
try {
const res = await fetch(`${getBackendUrl()}/api/passings`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ sessionId, passing, sessionResult: state.resultsBySession[sessionId] || null }),
});
if (!res.ok) {
throw new Error(`HTTP ${res.status}`);
}
backend.available = true;
backend.lastError = "";
} catch (error) {
backend.available = false;
backend.lastError = t("error.passing_save_failed", { msg: error instanceof Error ? error.message : String(error) });
backend.passingError = backend.lastError;
} finally {
backend.pendingWrites = Math.max(0, (backend.pendingWrites || 1) - 1);
}
}