From cf89086dff4180b050a63243563c303bcb2766f3 Mon Sep 17 00:00:00 2001 From: larssand Date: Thu, 10 Sep 2026 22:33:57 +0200 Subject: [PATCH] Add a time-of-day race day schedule to Event Manager Events can now be given a start time and a gap between sessions on a new "Schedule" panel; every session's planned clock time cascades automatically in running order (practice, qualifying, finals), and once a session actually starts or finishes, everything after it re-anchors to that real time - a late start or a session that ran long (including any pause) pushes the rest of the day forward with no manual reschedule step. The scheduled time now also shows on the printed/PDF start lists. Printable start lists and manually moving a driver to start last in their own heat (for a mechanic-time request) already existed, so this only builds the missing piece: the schedule itself. Also fixes a real pre-existing bug in the same session-ordering logic this feature relies on: getSessionSortWeight used `order[type] || 99`, which silently treated open_practice's own weight of 0 as falsy and sorted practice sessions dead last instead of first in print/PDF output. Co-Authored-By: Claude Sonnet 5 --- CHANGELOG.md | 10 ++++++ ROADMAP.md | 17 ++++++++++ package-lock.json | 4 +-- package.json | 2 +- src/app.js | 26 +++++++++++++-- src/event_manager_controller.js | 27 ++++++++++++++++ src/event_manager_view.js | 45 ++++++++++++++++++++++++++ src/event_race_logic.js | 51 ++++++++++++++++++++++++++++++ src/race_render_helpers.js | 15 +++++++-- src/styles.css | 5 +++ tests/race_timing_logic.test.js | 56 +++++++++++++++++++++++++++++++++ 11 files changed, 250 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d629459..8f48de1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,16 @@ The application version is maintained in `package.json` and displayed in the adm No changes recorded yet. +## 1.16.0 - 2026-09-10 + +### Added + +- Events can now have a time-of-day schedule: set a start time and a gap between sessions on the "Schedule" panel in Event Manager, and every session's planned clock time is worked out automatically in running order (practice, then qualifying, then finals). Once a session actually starts or finishes, everything after it shifts forward to match reality - a late start or a session that runs long (including any pause) automatically pushes the rest of the day's plan, no manual "reschedule" step needed. The scheduled time is now also shown on the printed/PDF start lists. + +### Fixed + +- `getSessionSortWeight`, which decides run order for printed start lists/results and the new schedule above, silently sorted `open_practice` sessions (weight 0) dead last instead of first, because `0 || 99` treats a valid zero weight as missing and falls back to the "unknown type" bucket. Practice sessions now correctly sort first, matching how a race day actually runs. + ## 1.15.0 - 2026-09-10 ### Changed diff --git a/ROADMAP.md b/ROADMAP.md index 151d345..2bacb7f 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -367,6 +367,23 @@ Reported 2026-09-10 by the user: the "select session" dropdown (Timing) and the Verified 2026-09-10 with a live headless-browser check against a real, isolated server: seeded 3 events with a mix of practice/qualifying/final sessions and confirmed the rendered ` + +
+ + ${event.raceConfig?.scheduleStartAt ? `` : ""} +
+ + ${eventSchedule && eventSchedule.length + ? renderTable( + [t("table.session"), t("table.type"), t("events.schedule_planned"), t("events.schedule_actual"), ""], + eventSchedule.map((row) => { + const session = sessions.find((item) => item.id === row.sessionId); + if (!session) return ""; + return ` + + ${escapeHtml(session.name)} + ${escapeHtml(getSessionTypeLabel(session.type))} + ${escapeHtml(formatClockTime(row.plannedStart))} - ${escapeHtml(formatClockTime(row.plannedEnd))} + ${row.actualStart ? escapeHtml(formatClockTime(row.actualStart)) + (row.actualEnd ? ` - ${escapeHtml(formatClockTime(row.actualEnd))}` : "") : "-"} + ${row.delayed ? `${t("events.schedule_delayed")}` : ""} + + `; + }) + ) + : `

${t("events.schedule_not_set")}

`} + + +

${t("events.final_matrix")}

diff --git a/src/event_race_logic.js b/src/event_race_logic.js index 04928f9..24cf529 100644 --- a/src/event_race_logic.js +++ b/src/event_race_logic.js @@ -231,6 +231,10 @@ export function normalizeEvent(event, { normalizeBrandingConfig, normalizeStartM finalsSource: event?.raceConfig?.finalsSource === "practice" ? "practice" : "qualifying", teams: Array.isArray(event?.raceConfig?.teams) ? event.raceConfig.teams.map((team) => normalizeRaceTeam(team)).filter((team) => team.name) : [], practiceOnly: event?.raceConfig?.practiceOnly === true, + scheduleStartAt: Number(event?.raceConfig?.scheduleStartAt) > 0 ? Number(event.raceConfig.scheduleStartAt) : null, + // 0 is a valid gap (back-to-back sessions), so this can't use || - only a genuinely + // non-numeric/missing value should fall back to the 3-minute default. + scheduleGapMin: Math.max(0, Number.isFinite(Number(event?.raceConfig?.scheduleGapMin)) ? Number(event.raceConfig.scheduleGapMin) : 3), }, }; } @@ -950,3 +954,50 @@ export function applyBumpsForRace(event, { buildFinalStandings, getSessionsForEv return applied; } + + + +// A planned run-of-day schedule: given a start time and a gap between sessions, each +// session gets a planned clock time in running order (practice, then qualifying, then +// finals - the same order the printed start lists already use). Once a session has +// actually started or finished, everything after it re-anchors to that real time instead +// of the original plan - a heat that started late or ran long (including any pause; a +// paused session's real endedAt already reflects the full wall-clock time it took) +// automatically pushes the rest of the day forward, with no separate "reschedule" step. +export function buildEventSchedule(event, sessions, { getSessionSortWeight }) { + const scheduleStartAt = Number(event?.raceConfig?.scheduleStartAt || 0) || null; + if (!scheduleStartAt) { + return []; + } + const gapMs = Math.max(0, Number(event?.raceConfig?.scheduleGapMin ?? 3) || 0) * 60000; + const ordered = [...sessions] + .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 || "")); + }); + + let cursor = scheduleStartAt; + return ordered.map((session) => { + const plannedStart = cursor; + const durationMs = Math.max(1, Number(session.durationMin || 0)) * 60000 + Math.max(0, Number(session.followUpSec || 0)) * 1000; + const plannedEnd = plannedStart + durationMs; + const actualStart = Number(session.startedAt || 0) || null; + const actualEnd = session.status === "finished" ? Number(session.endedAt || 0) || null : null; + const effectiveEnd = actualEnd || (actualStart ? actualStart + durationMs : plannedEnd); + cursor = effectiveEnd + gapMs; + return { + sessionId: session.id, + plannedStart, + plannedEnd, + actualStart, + actualEnd, + // A session that actually started more than a minute after its own planned time is + // worth flagging - small drift is normal and not worth calling out row by row. + delayed: Boolean(actualStart && actualStart > plannedStart + 60000), + }; + }); +} diff --git a/src/race_render_helpers.js b/src/race_render_helpers.js index f18eb06..a4e3067 100644 --- a/src/race_render_helpers.js +++ b/src/race_render_helpers.js @@ -159,7 +159,11 @@ export function getSessionSortWeight(session) { final: 5, team_race: 6, }; - return order[String(session?.type || "").toLowerCase()] || 99; + // Nullish coalescing, not ||: open_practice's own weight is 0, which || would treat as + // falsy and collapse to the 99 fallback - sorting practice sessions dead last (tied with + // genuinely unknown types) everywhere this drives print/PDF/schedule ordering, instead + // of first. + return order[String(session?.type || "").toLowerCase()] ?? 99; } export function getDriverDisplayById(driverId, { state, t }) { @@ -359,7 +363,7 @@ export function buildPrintBrandBlock(branding, { escapeHtml }) { `; } -export function buildRaceStartListsHtml(event, { t, state, escapeHtml, resolveEventBranding, getSessionsForEvent, getSessionSortWeight, getClassName, buildPrintBrandBlock, getSessionGridEntries, getSessionTypeLabel, getStartModeLabel, renderTable }) { +export function buildRaceStartListsHtml(event, { t, state, escapeHtml, resolveEventBranding, getSessionsForEvent, getSessionSortWeight, getClassName, buildPrintBrandBlock, getSessionGridEntries, getSessionTypeLabel, getStartModeLabel, renderTable, buildEventSchedule }) { const branding = resolveEventBranding(event); const sessions = getSessionsForEvent(event.id) .filter((session) => session.mode === "race") @@ -370,6 +374,11 @@ export function buildRaceStartListsHtml(event, { t, state, escapeHtml, resolveEv } return String(left.name || "").localeCompare(String(right.name || "")); }); + const schedule = typeof buildEventSchedule === "function" ? buildEventSchedule(event) : []; + const plannedTimeFor = (sessionId) => { + const row = schedule.find((item) => item.sessionId === sessionId); + return row ? new Date(row.plannedStart).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", hour12: false }) : ""; + }; return `
@@ -388,7 +397,7 @@ export function buildRaceStartListsHtml(event, { t, state, escapeHtml, resolveEv const entries = getSessionGridEntries(session); return `
-

${escapeHtml(session.name)} • ${escapeHtml(getSessionTypeLabel(session.type))}

+

${escapeHtml(session.name)} • ${escapeHtml(getSessionTypeLabel(session.type))}${plannedTimeFor(session.id) ? ` • ${escapeHtml(plannedTimeFor(session.id))}` : ""}

${t("table.start_mode")}: ${escapeHtml(getStartModeLabel(session.startMode))} • ${t("table.duration")}: ${session.durationMin} min

${ entries.length diff --git a/src/styles.css b/src/styles.css index 4c1d016..b59c52c 100644 --- a/src/styles.css +++ b/src/styles.css @@ -3585,6 +3585,11 @@ select:focus { color: #b7ffd4; } +.pill-warn { + border-color: rgba(245, 166, 35, 0.6); + color: #f5a623; +} + .pos-pill { display: inline-grid; place-items: center; diff --git a/tests/race_timing_logic.test.js b/tests/race_timing_logic.test.js index 0c991d3..1289dbd 100644 --- a/tests/race_timing_logic.test.js +++ b/tests/race_timing_logic.test.js @@ -3,6 +3,7 @@ import assert from "node:assert/strict"; import { applyBumpsForRace, + buildEventSchedule, buildOpenPracticeBundle, buildRaceFormatConfigFromForm, buildRaceSessionsFromWizard, @@ -35,6 +36,7 @@ import { isUntimedSession, ensureSessionResult, } from "../src/timing_logic.js"; +import { getSessionSortWeight } from "../src/race_render_helpers.js"; const testFormatLap = (ms) => (Number.isFinite(ms) ? `${ms}ms` : "-"); const testFormatRaceClock = (ms) => `${ms}ms`; @@ -211,6 +213,60 @@ test("getEventDrivers follows the order participants were selected in, not the d assert.deepEqual(getEventDrivers(unconfigured, { state }).map((driver) => driver.id), ["d1", "d2", "d3", "d4"], "before participants are configured, falls back to every driver in the class"); }); +// Found while building buildEventSchedule below (which relies on this for running order): +// open_practice's own weight is 0, which `order[key] || 99` treated as falsy and silently +// replaced with the 99 "unknown type" fallback - sorting practice sessions dead last +// instead of first everywhere this drives ordering (print/PDF start lists and results, +// and now the schedule). +test("getSessionSortWeight puts open_practice first, not last (0 is a valid weight, not a missing one)", () => { + assert.equal(getSessionSortWeight({ type: "open_practice" }), 0); + assert.ok(getSessionSortWeight({ type: "open_practice" }) < getSessionSortWeight({ type: "qualification" })); + assert.ok(getSessionSortWeight({ type: "qualification" }) < getSessionSortWeight({ type: "final" })); + assert.equal(getSessionSortWeight({ type: "something_unknown" }), 99, "a genuinely unknown type still falls back to last"); +}); + +// Regression coverage for the user's feature request: a time-of-day schedule for the +// whole race day, with each session's planned clock time worked out automatically, that +// shifts forward on its own once reality (a late start, a session running long or being +// paused) diverges from the plan - no separate "reschedule" step needed. +test("buildEventSchedule cascades planned times in running order and re-anchors to reality once a session actually happens", () => { + const event = { id: "ev1", mode: "race", raceConfig: { scheduleGapMin: 3 } }; + const practice = { id: "s_practice", eventId: "ev1", mode: "race", type: "open_practice", name: "Open Practice", durationMin: 5 }; + const qual = { id: "s_qual", eventId: "ev1", mode: "race", type: "qualification", name: "Q1 H1", durationMin: 5 }; + const final = { id: "s_final", eventId: "ev1", mode: "race", type: "final", name: "A Final 1", durationMin: 8 }; + const trackSession = { id: "s_track", eventId: "ev1", mode: "track", type: "heat", name: "Track Heat", durationMin: 5 }; + const sessions = [practice, qual, final, trackSession]; + + assert.deepEqual(buildEventSchedule({ ...event, raceConfig: { ...event.raceConfig, scheduleStartAt: null } }, sessions, { getSessionSortWeight }), [], "no schedule at all until a start time is set"); + + const scheduleStartAt = 1_000_000; + const plan = buildEventSchedule({ ...event, raceConfig: { ...event.raceConfig, scheduleStartAt } }, sessions, { getSessionSortWeight }); + assert.equal(plan.length, 3, "track-mode sessions are excluded from the race-day schedule"); + assert.deepEqual(plan.map((row) => row.sessionId), ["s_practice", "s_qual", "s_final"], "running order: practice, then qualifying, then finals"); + assert.equal(plan[0].plannedStart, 1_000_000); + assert.equal(plan[0].plannedEnd, 1_300_000, "5 minutes after the day's start time"); + assert.equal(plan[1].plannedStart, 1_480_000, "starts 3 minutes (the gap) after practice's planned end"); + assert.equal(plan[1].plannedEnd, 1_780_000); + assert.equal(plan[2].plannedStart, 1_960_000, "again 3 minutes after qualifying's planned end"); + assert.equal(plan[2].plannedEnd, 2_440_000, "8 minutes for the final"); + assert.ok(plan.every((row) => row.delayed === false), "nothing has actually started yet, so nothing is flagged delayed"); + + // Practice started 2 minutes late (well past the 1-minute delay threshold) and is still + // running - everything after it must re-anchor to this real start, not the original plan. + const lateStart = { ...event, raceConfig: { ...event.raceConfig, scheduleStartAt } }; + const lateSessions = [{ ...practice, startedAt: 1_120_000 }, qual, final]; + const latePlan = buildEventSchedule(lateStart, lateSessions, { getSessionSortWeight }); + assert.equal(latePlan[0].delayed, true, "started more than a minute after its own planned time"); + assert.equal(latePlan[1].plannedStart, 1_600_000, "qualifying's plan shifts forward by practice's own 2-minute delay"); + + // Practice actually finished, having run 50s over (e.g. a track call) - the real endedAt + // (which already reflects any pause) is what the rest of the day anchors to, not the + // nominal 5-minute duration. + const finishedSessions = [{ ...practice, startedAt: 1_000_000, status: "finished", endedAt: 1_350_000 }, qual, final]; + const finishedPlan = buildEventSchedule(lateStart, finishedSessions, { getSessionSortWeight }); + assert.equal(finishedPlan[1].plannedStart, 1_530_000, "1,350,000 (real end) + 180,000 (3-minute gap)"); +}); + test("race wizard creates configured practice, qualifying, and endurance sessions", () => { const event = { id: "event_1",