refactor(runtime): derive the group timer on the server

The group timer was derived in the client, which meant every view that wanted it
had to depend on the rundown query. That coupling was already awkward for the PiP
timer, whose separate react root needed its own query client, and it would have
spread to every remaining view.

Moving the derivation to the server removes the coupling. The value is still the
running event timer offset by the content scheduled around it, so the group keeps
behaving as if it were a single event containing all its children.

Because the group timer is the event timer offset by a constant, it changes exactly
when the event timer does and can share its broadcast throttling.

- add RuntimeStore.groupTimer, null unless the running group opted in
- split the group around the loaded event when the group is loaded, so the per tick
  cost is an addition rather than a walk of the rundown
- derive on the getState() projection so it cannot drift from the timer it is built on
- reduce the client to a plain selector, dropping the PiP query client workaround

Also fixes elapsed time, which was calculated from the group duration and so clamped
to zero for as long as time added to an event kept the group in credit. It is now
derived symmetrically with the remaining time, and the two always add up to the total.

Timer and PiP shared eight identical branches for choosing between the two timers.
These now go through a single resolver. A group has no warning or danger thresholds,
so it only reports as running or overtime, and feeding that phase through the existing
modifiers makes the suppression of warning and danger a consequence of what a group is
rather than something each view has to remember.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Kniqs443KUNCRABwVJwT7K

apps/client/src/common/hooks/useGroupTimer.ts

@@ -1,52 +0,0 @@
-import type { MaybeNumber } from 'ontime-types';
-import { useMemo } from 'react';
-
-import useRundown from '../hooks-query/useRundown';
-import { getRemainingGroupTime } from '../utils/groupTimer';
-import { useGroupTimerData } from './useSocket';
-
-export type GroupTimerState = {
-  /** whether views should display the group timer instead of the event timer */
-  isActive: boolean;
-  /** time remaining in the group, mirrors the semantics of timer.current */
-  current: MaybeNumber;
-  /** time already spent in the group, mirrors the semantics of timer.elapsed */
-  elapsed: MaybeNumber;
-  /** scheduled duration of the group, used as the progress bar target */
-  duration: MaybeNumber;
-};
-
-const inactiveGroupTimer: GroupTimerState = { isActive: false, current: null, elapsed: null, duration: null };
-
-/**
- * Derives a shared timer for the running group.
- *
- * The value is the running event timer plus the content still scheduled after it,
- * which makes the group behave as if it were a single event containing all its children.
- * Deriving it from the event timer (instead of from the clock) means pause, added time,
- * overtime, roll and midnight rollovers are all inherited for free.
- */
-export function useGroupTimer(): GroupTimerState {
-  const { group, currentEventId, current } = useGroupTimerData();
-  const { data: rundown } = useRundown();
-
-  return useMemo(() => {
-    if (!group?.useGroupTimer || currentEventId === null || current === null) {
-      return inactiveGroupTimer;
-    }
-
-    // the loaded event could be outside the group while the group data is still settling
-    if (!group.entries.includes(currentEventId)) {
-      return inactiveGroupTimer;
-    }
-
-    const groupCurrent = current + getRemainingGroupTime(group, rundown.entries, currentEventId);
-
-    return {
-      isActive: true,
-      current: groupCurrent,
-      elapsed: Math.max(0, group.duration - groupCurrent),
-      duration: group.duration,
-    };
-  }, [group, currentEventId, current, rundown.entries]);
-}

apps/client/src/common/hooks/useSocket.ts

@@ -154,12 +154,8 @@ export const useTimer = createSelector((state: RuntimeStore) => ({
   ...state.timer,
 }));
 
-/** Runtime data needed to derive the shared group timer, see useGroupTimer */
-export const useGroupTimerData = createSelector((state: RuntimeStore) => ({
-  group: state.groupNow,
-  currentEventId: state.eventNow?.id ?? null,
-  current: state.timer.current,
-}));
+/** Shared timer for the running group, null unless the group opted in */
+export const useGroupTimer = createSelector((state: RuntimeStore) => state.groupTimer);
 
 export const useNextFlag = createSelector((state: RuntimeStore) => ({
   id: state.eventFlag?.id ?? null,

apps/client/src/common/utils/__tests__/groupTimer.test.ts

@@ -1,93 +0,0 @@
-import type { EntryId, OntimeEntry, OntimeEvent, OntimeGroup } from 'ontime-types';
-import { SupportedEntry } from 'ontime-types';
-
-import { getRemainingGroupTime } from '../groupTimer';
-
-function makeEvent(id: EntryId, patch: Partial<OntimeEvent> = {}): OntimeEvent {
-  return {
-    id,
-    type: SupportedEntry.Event,
-    duration: 0,
-    gap: 0,
-    skip: false,
-    parent: 'group',
-    ...patch,
-  } as OntimeEvent;
-}
-
-function makeGroup(entries: EntryId[]): OntimeGroup {
-  return { id: 'group', type: SupportedEntry.Group, entries } as OntimeGroup;
-}
-
-function makeEntries(...entries: OntimeEntry[]): Record<EntryId, OntimeEntry> {
-  return Object.fromEntries(entries.map((entry) => [entry.id, entry]));
-}
-
-describe('getRemainingGroupTime()', () => {
-  it('sums the duration of the events after the current one', () => {
-    const group = makeGroup(['1', '2', '3']);
-    const entries = makeEntries(
-      makeEvent('1', { duration: 10 }),
-      makeEvent('2', { duration: 20 }),
-      makeEvent('3', { duration: 30 }),
-    );
-
-    expect(getRemainingGroupTime(group, entries, '1')).toBe(50);
-    expect(getRemainingGroupTime(group, entries, '2')).toBe(30);
-  });
-
-  it('accounts for the gaps between events', () => {
-    const group = makeGroup(['1', '2', '3']);
-    const entries = makeEntries(
-      makeEvent('1', { duration: 10 }),
-      makeEvent('2', { duration: 20, gap: 5 }),
-      makeEvent('3', { duration: 30, gap: 7 }),
-    );
-
-    expect(getRemainingGroupTime(group, entries, '1')).toBe(20 + 5 + 30 + 7);
-  });
-
-  it('adds up to the group duration when the first event is loaded', () => {
-    // mirrors the aggregation the server uses to calculate group.duration
-    const group = makeGroup(['1', '2', '3']);
-    const first = makeEvent('1', { duration: 10 });
-    const entries = makeEntries(first, makeEvent('2', { duration: 20, gap: 5 }), makeEvent('3', { duration: 30 }));
-
-    const groupDuration = 10 + 20 + 5 + 30;
-    expect(first.duration + getRemainingGroupTime(group, entries, '1')).toBe(groupDuration);
-  });
-
-  it('returns 0 on the last event of the group', () => {
-    const group = makeGroup(['1', '2']);
-    const entries = makeEntries(makeEvent('1', { duration: 10 }), makeEvent('2', { duration: 20 }));
-
-    expect(getRemainingGroupTime(group, entries, '2')).toBe(0);
-  });
-
-  it('skips entries which are not playable events', () => {
-    const group = makeGroup(['1', '2', '3', '4']);
-    const entries = makeEntries(
-      makeEvent('1', { duration: 10 }),
-      makeEvent('2', { duration: 20, skip: true }),
-      { id: '3', type: SupportedEntry.Milestone, parent: 'group' } as OntimeEntry,
-      makeEvent('4', { duration: 40 }),
-    );
-
-    expect(getRemainingGroupTime(group, entries, '1')).toBe(40);
-  });
-
-  it('returns 0 when the loaded event is not part of the group', () => {
-    const group = makeGroup(['1', '2']);
-    const entries = makeEntries(makeEvent('1', { duration: 10 }), makeEvent('2', { duration: 20 }));
-
-    expect(getRemainingGroupTime(group, entries, 'elsewhere')).toBe(0);
-    expect(getRemainingGroupTime(group, entries, null)).toBe(0);
-  });
-
-  it('tolerates ids which are missing from the rundown', () => {
-    const group = makeGroup(['1', 'missing', '3']);
-    const entries = makeEntries(makeEvent('1', { duration: 10 }), makeEvent('3', { duration: 30 }));
-
-    expect(getRemainingGroupTime(group, entries, '1')).toBe(30);
-  });
-});

apps/client/src/common/utils/groupTimer.ts

@@ -1,48 +0,0 @@
-import type { EntryId, OntimeEntry, OntimeGroup } from 'ontime-types';
-import { isOntimeEvent, isPlayableEvent } from 'ontime-types';
-
-/**
- * Calculates the amount of playable content remaining in a group
- * after (and excluding) the currently loaded event.
- *
- * The group timer treats the group as if it were a single event, so the displayed
- * value is the running event timer plus whatever is still scheduled after it.
- * Keeping this relative to the event timer means the group timer inherits pause,
- * added time, overtime and roll behaviour without duplicating any of that logic.
- *
- * The aggregation mirrors the group duration calculated in the server
- * (apps/server/src/api-data/rundown/rundown.dao.ts): non playable entries are
- * skipped and the gap is accounted for in every entry other than the first.
- */
-export function getRemainingGroupTime(
-  group: OntimeGroup,
-  entries: Record<EntryId, OntimeEntry | undefined>,
-  currentEventId: EntryId | null,
-): number {
-  if (currentEventId === null) {
-    return 0;
-  }
-
-  const currentIndex = group.entries.indexOf(currentEventId);
-  if (currentIndex === -1) {
-    return 0;
-  }
-
-  let remaining = 0;
-
-  for (let i = currentIndex + 1; i < group.entries.length; i++) {
-    const entry = entries[group.entries[i]];
-    if (!entry || !isOntimeEvent(entry) || !isPlayableEvent(entry)) {
-      continue;
-    }
-
-    // the first entry of the group has no gap to account for,
-    // any other entry could be preceded by idle time
-    if (i > 0) {
-      remaining += entry.gap;
-    }
-    remaining += entry.duration;
-  }
-
-  return remaining;
-}

apps/client/src/features/control/message/TimerPreview.tsx

@@ -5,8 +5,7 @@ import { LuArrowDownToLine } from 'react-icons/lu';
 import { CornerWithPip } from '../../../common/components/editor-utils/EditorUtils';
 import Tooltip from '../../../common/components/tooltip/Tooltip';
 import useViewSettings from '../../../common/hooks-query/useViewSettings';
-import { useGroupTimer } from '../../../common/hooks/useGroupTimer';
-import { useMessagePreview } from '../../../common/hooks/useSocket';
+import { useGroupTimer, useMessagePreview } from '../../../common/hooks/useSocket';
 import { handleLinks } from '../../../common/utils/linkUtils';
 import { cx, timerPlaceholder } from '../../../common/utils/styleUtils';
 import PipRoot from '../../../views/editor/pip-timer/PipRoot';
@@ -23,7 +22,7 @@ const secondarySourceLabels: Record<string, string> = {
 export default function TimerPreview() {
   const { blink, blackout, countToEnd, phase, secondarySource, showTimerMessage, timerType } = useMessagePreview();
   const { data } = useViewSettings();
-  const { isActive: isGroupTimerActive } = useGroupTimer();
+  const isGroupTimerActive = useGroupTimer() !== null;
 
   const main = (() => {
     if (showTimerMessage) return 'Message';

apps/client/src/views/editor/pip-timer/PipHost.tsx

@@ -1,10 +1,8 @@
 import { ErrorBoundary } from '@sentry/react';
-import { QueryClientProvider } from '@tanstack/react-query';
 import { createRoot } from 'react-dom/client';
 
 import { CornerPipButton } from '../../../common/components/editor-utils/EditorUtils';
 import useViewSettings from '../../../common/hooks-query/useViewSettings';
-import { ontimeQueryClient } from '../../../common/queryClient';
 import { PipTimer } from './PipTimer';
 
 export default function PipTimerHost() {
@@ -57,10 +55,7 @@ export default function PipTimerHost() {
 
     pipRoot.render(
       <ErrorBoundary>
-        {/* the PiP document is a separate react root, it needs its own provider to reach the query cache */}
-        <QueryClientProvider client={ontimeQueryClient}>
-          <PipTimer viewSettings={data} />
-        </QueryClientProvider>
+        <PipTimer viewSettings={data} />
       </ErrorBoundary>,
     );
   };

apps/client/src/views/editor/pip-timer/PipTimer.tsx

@@ -1,9 +1,8 @@
-import { TimerPhase, ViewSettings } from 'ontime-types';
+import { ViewSettings } from 'ontime-types';
 
 import { FitText } from '../../../common/components/fit-text/FitText';
 import MultiPartProgressBar from '../../../common/components/multi-part-progress-bar/MultiPartProgressBar';
-import { useGroupTimer } from '../../../common/hooks/useGroupTimer';
-import { useTimerSocket } from '../../../common/hooks/useSocket';
+import { useGroupTimer, useTimerSocket } from '../../../common/hooks/useSocket';
 import { cx } from '../../../common/utils/styleUtils';
 import { getFormattedTimer, getTimerByType } from '../../common/viewUtils';
 import {
@@ -11,9 +10,8 @@ import {
   getIsPlaying,
   getSecondaryDisplay,
   getShowMessage,
-  getShowModifiers,
   getShowProgressBar,
-  getTotalTime,
+  resolveTimerDisplay,
 } from '../../timer/timer.utils';
 import { getTimerColour } from '../../utils/presentation.utils';
 
@@ -29,26 +27,23 @@ export function PipTimer({ viewSettings }: PipTimerProps) {
 
   // gather modifiers
   const showOverlay = getShowMessage(message.timer);
-  const {
-    showFinished: eventShowFinished,
-    showWarning: eventShowWarning,
-    showDanger: eventShowDanger,
-  } = getShowModifiers(timerTypeNow, countToEndNow, time.phase, false, '', false);
-
-  /**
-   * warning and danger thresholds belong to the event, they carry no meaning against a group duration.
-   * overtime is kept, but only once the group itself has run out of time
-   */
-  const showWarning = eventShowWarning && !groupTimer.isActive;
-  const showDanger = eventShowDanger && !groupTimer.isActive;
-  const showFinished = eventShowFinished && (!groupTimer.isActive || (groupTimer.current ?? 0) <= 0);
+  const timerDisplay = resolveTimerDisplay({
+    time,
+    groupTimer,
+    event: eventNow,
+    timerType: timerTypeNow,
+    countToEnd: countToEndNow,
+    freezeOvertime: false,
+    freezeMessage: '',
+    hidePhase: false,
+  });
+  const { showFinished, showWarning, showDanger } = timerDisplay;
 
   const isPlaying = getIsPlaying(time.playback);
   const showProgressBar = getShowProgressBar(timerTypeNow);
 
   // gather timer data
-  const totalTime = groupTimer.isActive ? groupTimer.duration : getTotalTime(time.duration, time.addedTime);
-  const stageTimer = getTimerByType(false, timerTypeNow, clock, groupTimer.isActive ? groupTimer : time, timerTypeNow);
+  const stageTimer = getTimerByType(false, timerTypeNow, clock, timerDisplay.source, timerTypeNow);
   const display = getFormattedTimer(stageTimer, timerTypeNow, 'min', {
     removeSeconds: false,
     removeLeadingZero: false,
@@ -88,11 +83,11 @@ export function PipTimer({ viewSettings }: PipTimerProps) {
         <div
           className={cx(['timer', !isPlaying && 'timer--paused', showFinished && 'timer--finished'])}
           style={{ fontSize: `${timerFontSize}vw` }}
-          data-phase={groupTimer.isActive ? TimerPhase.Default : time.phase}
+          data-phase={timerDisplay.phase}
         >
           {display}
         </div>
-        {groupTimer.isActive && <div className='group-indicator'>group</div>}
+        {timerDisplay.isGroup && <div className='group-indicator'>group</div>}
         <div className={cx(['secondary', !secondaryContent && 'secondary--hidden'])}>
           <FitText mode='multi' min={12} max={256}>
             {secondaryContent}
@@ -103,12 +98,12 @@ export function PipTimer({ viewSettings }: PipTimerProps) {
       {showProgressBar && (
         <MultiPartProgressBar
           className={cx(['progress-container', !isPlaying && 'progress-container--paused'])}
-          now={groupTimer.isActive ? groupTimer.current : time.current}
-          complete={totalTime}
+          now={timerDisplay.source.current}
+          complete={timerDisplay.total}
           normalColor={viewSettings.normalColor}
-          warning={groupTimer.isActive ? undefined : eventNow?.timeWarning}
+          warning={timerDisplay.warning}
           warningColor={viewSettings.warningColor}
-          danger={groupTimer.isActive ? undefined : eventNow?.timeDanger}
+          danger={timerDisplay.danger}
           dangerColor={viewSettings.dangerColor}
           hideOvertime={!showFinished}
         />

apps/client/src/views/timer/Timer.tsx

@@ -1,4 +1,4 @@
-import { MaybeString, OntimeView, TimerPhase, TimerType } from 'ontime-types';
+import { MaybeString, OntimeView, TimerType } from 'ontime-types';
 import { useMemo } from 'react';
 
 import { FitText } from '../../common/components/fit-text/FitText';
@@ -8,8 +8,7 @@ import TitleCard from '../../common/components/title-card/TitleCard';
 import ViewLogo from '../../common/components/view-logo/ViewLogo';
 import ViewParamsEditor from '../../common/components/view-params-editor/ViewParamsEditor';
 import { useAutoTickingClock } from '../../common/hooks/useAutoTickingClock';
-import { useGroupTimer } from '../../common/hooks/useGroupTimer';
-import { useTimerSocket } from '../../common/hooks/useSocket';
+import { useGroupTimer, useTimerSocket } from '../../common/hooks/useSocket';
 import { useWindowTitle } from '../../common/hooks/useWindowTitle';
 import { cx } from '../../common/utils/styleUtils';
 import { formatTime, getDefaultFormat } from '../../common/utils/time';
@@ -26,9 +25,8 @@ import {
   getSecondaryDisplay,
   getShowClock,
   getShowMessage,
-  getShowModifiers,
   getShowProgressBar,
-  getTotalTime,
+  resolveTimerDisplay,
 } from './timer.utils';
 import { TimerData, useTimerData } from './useTimerData';
 
@@ -81,20 +79,17 @@ function Timer({ customFields, projectData, isMirrored, settings, viewSettings,
   // gather modifiers
   const viewTimerType = timerType ?? timerTypeNow;
   const showOverlay = getShowMessage(message.timer);
-  const {
-    showEndMessage,
-    showFinished: eventShowFinished,
-    showWarning: eventShowWarning,
-    showDanger: eventShowDanger,
-  } = getShowModifiers(timerTypeNow, countToEndNow, time.phase, freezeOvertime, freezeMessage, hidePhase);
-
-  /**
-   * warning and danger thresholds belong to the event, they carry no meaning against a group duration.
-   * overtime is kept, but only once the group itself has run out of time
-   */
-  const showWarning = eventShowWarning && !groupTimer.isActive;
-  const showDanger = eventShowDanger && !groupTimer.isActive;
-  const showFinished = eventShowFinished && (!groupTimer.isActive || (groupTimer.current ?? 0) <= 0);
+  const timerDisplay = resolveTimerDisplay({
+    time,
+    groupTimer,
+    event: eventNow,
+    timerType: timerTypeNow,
+    countToEnd: countToEndNow,
+    freezeOvertime,
+    freezeMessage,
+    hidePhase,
+  });
+  const { showEndMessage, showFinished, showWarning, showDanger } = timerDisplay;
   const isPlaying = getIsPlaying(time.playback);
   const showClock = !hideClock && getShowClock(viewTimerType);
   const showProgressBar = !hideProgress && getShowProgressBar(viewTimerType);
@@ -111,9 +106,7 @@ function Timer({ customFields, projectData, isMirrored, settings, viewSettings,
   );
 
   // gather timer data
-  const totalTime = groupTimer.isActive ? groupTimer.duration : getTotalTime(time.duration, time.addedTime);
-  const timerSource = groupTimer.isActive ? groupTimer : time;
-  const stageTimer = getTimerByType(freezeOvertime, timerTypeNow, clock, timerSource, timerType);
+  const stageTimer = getTimerByType(freezeOvertime, timerTypeNow, clock, timerDisplay.source, timerType);
   const display = getFormattedTimer(stageTimer, viewTimerType, localisedMinutes, {
     removeSeconds: hideTimerSeconds,
     removeLeadingZero: removeLeadingZeros,
@@ -188,12 +181,12 @@ function Timer({ customFields, projectData, isMirrored, settings, viewSettings,
             className={cx(['timer', subduePaused && 'timer--paused', showFinished && 'timer--finished'])}
             style={{ fontSize: `${timerFontSize}vw` }}
             data-type={viewTimerType}
-            data-phase={groupTimer.isActive ? TimerPhase.Default : time.phase}
+            data-phase={timerDisplay.phase}
           >
             {display}
           </div>
         )}
-        {groupTimer.isActive && !showEndMessage && <div className='group-indicator'>group</div>}
+        {timerDisplay.isGroup && !showEndMessage && <div className='group-indicator'>group</div>}
         <div className={cx(['secondary', !secondaryContent && 'secondary--hidden'])}>
           <FitText mode='multi' min={64} max={256}>
             {secondaryContent}
@@ -204,12 +197,12 @@ function Timer({ customFields, projectData, isMirrored, settings, viewSettings,
       {showProgressBar && (
         <MultiPartProgressBar
           className={cx(['progress-container', !isPlaying && 'progress-container--paused'])}
-          now={groupTimer.isActive ? groupTimer.current : time.current}
-          complete={totalTime}
+          now={timerDisplay.source.current}
+          complete={timerDisplay.total}
           normalColor={viewSettings.normalColor}
-          warning={groupTimer.isActive ? undefined : eventNow?.timeWarning}
+          warning={timerDisplay.warning}
           warningColor={viewSettings.warningColor}
-          danger={groupTimer.isActive ? undefined : eventNow?.timeDanger}
+          danger={timerDisplay.danger}
           dangerColor={viewSettings.dangerColor}
           hideOvertime={!showFinished}
         />

apps/client/src/views/timer/timer.utils.ts

@@ -1,4 +1,5 @@
 import {
+  GroupTimerState,
   MaybeNumber,
   MessageState,
   OntimeEvent,
@@ -6,6 +7,7 @@ import {
   RundownEntries,
   TimerMessage,
   TimerPhase,
+  TimerState,
   TimerType,
 } from 'ontime-types';
 import { isPlaybackActive } from 'ontime-utils';
@@ -114,6 +116,57 @@ export function getShowModifiers(
   };
 }
 
+interface ResolveTimerDisplayOptions {
+  time: TimerState;
+  /** when present, views show the group instead of the running event */
+  groupTimer: GroupTimerState | null;
+  event: Pick<OntimeEvent, 'timeWarning' | 'timeDanger'> | null;
+  timerType: TimerType;
+  countToEnd: boolean;
+  freezeOvertime: boolean;
+  freezeMessage: string;
+  hidePhase: boolean;
+}
+
+/**
+ * Resolves which timer a view should display, and the modifiers that go with it.
+ *
+ * A group has no warning or danger thresholds of its own, so it only ever reports as
+ * running or overtime. Feeding that phase through `getShowModifiers` means the warning
+ * and danger states are suppressed as a consequence of what a group is, rather than
+ * every view having to remember to special case them.
+ */
+export function resolveTimerDisplay({
+  time,
+  groupTimer,
+  event,
+  timerType,
+  countToEnd,
+  freezeOvertime,
+  freezeMessage,
+  hidePhase,
+}: ResolveTimerDisplayOptions) {
+  const isGroup = groupTimer !== null;
+  const phase = isGroup
+    ? groupTimer.current <= 0
+      ? TimerPhase.Overtime
+      : TimerPhase.Default
+    : time.phase;
+
+  return {
+    isGroup,
+    phase,
+    /** the values to render, shaped for getTimerByType */
+    source: isGroup ? groupTimer : time,
+    /** the target of a progress bar */
+    total: isGroup ? groupTimer.duration : getTotalTime(time.duration, time.addedTime),
+    // thresholds belong to the event, they carry no meaning against a group duration
+    warning: isGroup ? undefined : event?.timeWarning,
+    danger: isGroup ? undefined : event?.timeDanger,
+    ...getShowModifiers(timerType, countToEnd, phase, freezeOvertime, freezeMessage, hidePhase),
+  };
+}
+
 /**
  * What, if anything, should be displayed in the secondary field
  */