bump version to 3.5.0

* fix: stop log incorrectly

* prevent start if already playing

.husky/pre-commit

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-pnpm lint-staged

Dockerfile

@@ -22,7 +22,6 @@ COPY --from=builder /app/apps/client/build ./client/
 
 # Prepare Backend
 COPY --from=builder /app/apps/server/dist/ ./server/
-COPY ./demo-db/ ./preloaded-db/
 COPY --from=builder /app/apps/server/src/external/ ./external/
 
 # Export default ports

apps/cli/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@getontime/cli",
-    "version": "3.4.0",
+    "version": "3.5.0",
     "author": "Carlos Valente",
     "description": "Time keeping for live events",
     "repository": "https://github.com/cpvalente/ontime",
@@ -20,8 +20,8 @@
         "server"
     ],
     "devDependencies": {
-        "eslint": "^8.53.0",
-        "eslint-config-prettier": "^9.0.0",
-        "prettier": "^3.0.3"
+        "eslint": "catalog:",
+        "eslint-config-prettier": "catalog:",
+        "prettier": "catalog:"
     }
 }

apps/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ontime-ui",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "private": true,
   "type": "module",
   "dependencies": {
@@ -13,7 +13,7 @@
     "@fontsource/open-sans": "^5.0.28",
     "@mantine/hooks": "^7.6.2",
     "@react-icons/all-files": "^4.1.0",
-    "@sentry/react": "^7.92.0",
+    "@sentry/react": "^8.19.0",
     "@tanstack/react-query": "^5.17.9",
     "@tanstack/react-query-devtools": "^5.17.9",
     "@tanstack/react-table": "^8.11.3",
@@ -22,9 +22,9 @@
     "color": "^4.2.3",
     "csv-stringify": "^6.4.5",
     "framer-motion": "^10.10.0",
-    "react": "^18.2.0",
+    "react": "^18.3.1",
     "react-colorful": "^5.6.1",
-    "react-dom": "^18.2.0",
+    "react-dom": "^18.3.1",
     "react-fast-compare": "^3.2.2",
     "react-hook-form": "^7.49.2",
     "react-qr-code": "^2.0.12",
@@ -42,7 +42,6 @@
     "build:docker": "vite build",
     "build:localdocker": "cross-env NODE_ENV=local vite build",
     "lint": "eslint . --quiet",
-    "lint-staged": "eslint",
     "test": "vitest",
     "test:pipeline": "vitest run",
     "cleanup": "rm -rf .turbo && rm -rf node_modules && rm -rf build",
@@ -70,13 +69,13 @@
     "@types/react": "^18.0.26",
     "@types/react-dom": "^18.0.10",
     "@types/testing-library__jest-dom": "^5.14.5",
-    "@typescript-eslint/eslint-plugin": "^v7.16.1",
-    "@typescript-eslint/parser": "^7.16.1",
+    "@typescript-eslint/eslint-plugin": "catalog:",
+    "@typescript-eslint/parser": "catalog:",
     "@vitejs/plugin-react": "^4.2.1",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint": "catalog:",
+    "eslint-config-prettier": "catalog:",
     "eslint-plugin-jest": "^28.6.0",
-    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-prettier": "catalog:",
     "eslint-plugin-react": "^7.32.0",
     "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-simple-import-sort": "^8.0.0",
@@ -84,9 +83,9 @@
     "jsdom": "^21.1.0",
     "ontime-types": "workspace:*",
     "ontime-utils": "workspace:*",
-    "prettier": "^3.3.1",
+    "prettier": "catalog:",
     "sass": "^1.57.1",
-    "typescript": "^5.5.3",
+    "typescript": "catalog:",
     "vite": "^5.2.11",
     "vite-plugin-compression2": "^0.12.0",
     "vite-plugin-svgr": "^4.2.0",

apps/client/src/AppRouter.tsx

@@ -1,24 +1,36 @@
-import { lazy, Suspense } from 'react';
-import { Navigate, Route, Routes } from 'react-router-dom';
+import React from 'react';
+import {
+  createRoutesFromChildren,
+  matchRoutes,
+  Navigate,
+  Route,
+  Routes,
+  useLocation,
+  useNavigationType,
+} from 'react-router-dom';
+import * as Sentry from '@sentry/react';
 
 import { useClientPath } from './common/hooks/useClientPath';
 import Log from './features/log/Log';
 import withPreset from './features/PresetWrapper';
 import withData from './features/viewers/ViewWrapper';
+import { ONTIME_VERSION } from './ONTIME_VERSION';
+import { sentryDsn, sentryRecommendedIgnore } from './sentry.config';
 
-const Editor = lazy(() => import('./features/editors/ProtectedEditor'));
-const Cuesheet = lazy(() => import('./features/cuesheet/ProtectedCuesheet'));
-const Operator = lazy(() => import('./features/operator/OperatorExport'));
+const Editor = React.lazy(() => import('./features/editors/ProtectedEditor'));
+const Cuesheet = React.lazy(() => import('./features/cuesheet/ProtectedCuesheet'));
+const Operator = React.lazy(() => import('./features/operator/OperatorExport'));
 
-const TimerView = lazy(() => import('./features/viewers/timer/Timer'));
-const MinimalTimerView = lazy(() => import('./features/viewers/minimal-timer/MinimalTimer'));
-const ClockView = lazy(() => import('./features/viewers/clock/Clock'));
-const Countdown = lazy(() => import('./features/viewers/countdown/Countdown'));
+const TimerView = React.lazy(() => import('./features/viewers/timer/Timer'));
+const MinimalTimerView = React.lazy(() => import('./features/viewers/minimal-timer/MinimalTimer'));
+const ClockView = React.lazy(() => import('./features/viewers/clock/Clock'));
+const Countdown = React.lazy(() => import('./features/viewers/countdown/Countdown'));
 
-const Backstage = lazy(() => import('./features/viewers/backstage/Backstage'));
-const Public = lazy(() => import('./features/viewers/public/Public'));
-const Lower = lazy(() => import('./features/viewers/lower-thirds/LowerThird'));
-const StudioClock = lazy(() => import('./features/viewers/studio/StudioClock'));
+const Backstage = React.lazy(() => import('./features/viewers/backstage/Backstage'));
+const Timeline = React.lazy(() => import('./features/viewers/timeline/TimelinePage'));
+const Public = React.lazy(() => import('./features/viewers/public/Public'));
+const Lower = React.lazy(() => import('./features/viewers/lower-thirds/LowerThird'));
+const StudioClock = React.lazy(() => import('./features/viewers/studio/StudioClock'));
 
 const STimer = withPreset(withData(TimerView));
 const SMinimalTimer = withPreset(withData(MinimalTimerView));
@@ -28,41 +40,56 @@ const SBackstage = withPreset(withData(Backstage));
 const SPublic = withPreset(withData(Public));
 const SLowerThird = withPreset(withData(Lower));
 const SStudio = withPreset(withData(StudioClock));
+const STimeline = withPreset(withData(Timeline));
 
-const EditorFeatureWrapper = lazy(() => import('./features/EditorFeatureWrapper'));
-const RundownPanel = lazy(() => import('./features/rundown/RundownExport'));
-const TimerControl = lazy(() => import('./features/control/playback/TimerControlExport'));
-const MessageControl = lazy(() => import('./features/control/message/MessageControlExport'));
+const EditorFeatureWrapper = React.lazy(() => import('./features/EditorFeatureWrapper'));
+const RundownPanel = React.lazy(() => import('./features/rundown/RundownExport'));
+const TimerControl = React.lazy(() => import('./features/control/playback/TimerControlExport'));
+const MessageControl = React.lazy(() => import('./features/control/message/MessageControlExport'));
+
+Sentry.init({
+  dsn: sentryDsn,
+  integrations: [
+    Sentry.reactRouterV6BrowserTracingIntegration({
+      useEffect: React.useEffect,
+      useLocation,
+      useNavigationType,
+      createRoutesFromChildren,
+      matchRoutes,
+    }),
+  ],
+  tracesSampleRate: 0.3,
+  release: ONTIME_VERSION,
+  enabled: import.meta.env.PROD,
+  ignoreErrors: [...sentryRecommendedIgnore, /Unable to preload CSS/i, /dynamically imported module/i],
+  denyUrls: [/extensions\//i, /^chrome:\/\//i, /^chrome-extension:\/\//i],
+});
+
+const SentryRoutes = Sentry.withSentryReactRouterV6Routing(Routes);
 
 export default function AppRouter() {
   // handle client path changes
   useClientPath();
 
   return (
-    <Suspense fallback={null}>
-      <Routes>
+    <React.Suspense fallback={null}>
+      <SentryRoutes>
         <Route path='/' element={<Navigate to='/timer' />} />
         <Route path='/timer' element={<STimer />} />
-
+        <Route path='/public' element={<SPublic />} />
         <Route path='/minimal' element={<SMinimalTimer />} />
-
         <Route path='/clock' element={<SClock />} />
 
         <Route path='/countdown' element={<SCountdown />} />
-
         <Route path='/backstage' element={<SBackstage />} />
-
-        <Route path='/public' element={<SPublic />} />
-
         <Route path='/studio' element={<SStudio />} />
-
         <Route path='/lower' element={<SLowerThird />} />
-
-        <Route path='/op' element={<Operator />} />
+        <Route path='/timeline' element={<STimeline />} />
 
         {/*/!* Protected Routes *!/*/}
         <Route path='/editor' element={<Editor />} />
         <Route path='/cuesheet' element={<Cuesheet />} />
+        <Route path='/op' element={<Operator />} />
 
         {/*/!* Protected Routes - Elements *!/*/}
         <Route
@@ -99,7 +126,7 @@ export default function AppRouter() {
         />
         {/*/!* Send to default if nothing found *!/*/}
         <Route path='*' element={<STimer />} />
-      </Routes>
-    </Suspense>
+      </SentryRoutes>
+    </React.Suspense>
   );
 }

apps/client/src/common/components/client-modal/RedirectClientModal.tsx

@@ -38,7 +38,7 @@ export function RedirectClientModal(props: RedirectClientModalProps) {
     onClose();
   };
 
-  const host = `${window.location.origin}/`;
+  const host = window.location.origin;
   const canSubmit = path !== currentPath && path !== '';
 
   return (

apps/client/src/common/components/identify-overlay/IdentifyOverlay.tsx

@@ -54,7 +54,6 @@ function Overlay() {
     };
   }, [showOverlay, id, setIdentify, handleClose]);
 
-    console.log('here2');
   return (
     <div className={style.overlay} data-testid='identify-overlay' onClick={handleClose}>
       <div className={style.name}>{name}</div>

apps/client/src/common/components/multi-part-progress-bar/MultiPartProgressBar.tsx

@@ -1,12 +1,12 @@
 import { MaybeNumber } from 'ontime-types';
 
-import { clamp } from '../../utils/math';
+import { getProgress } from '../../utils/getProgress';
 
 import './MultiPartProgressBar.scss';
 
 interface MultiPartProgressBar {
   now: MaybeNumber;
-  complete: number;
+  complete: MaybeNumber;
   normalColor: string;
   warning?: MaybeNumber;
   warningColor: string;
@@ -31,10 +31,9 @@ export default function MultiPartProgressBar(props: MultiPartProgressBar) {
     className = '',
   } = props;
 
-  const percentRemaining = complete === 0 ? 0 : 100 - clamp(100 - (Math.max(now ?? 0, 0) * 100) / complete, 0, 100);
-
-  const dangerWidth = danger ? clamp((danger / complete) * 100, 0, 100) : 0;
-  const warningWidth = warning ? clamp((warning / complete) * 100 - dangerWidth, 0, 100) : 0;
+  const percentRemaining = 100 - getProgress(now, complete);
+  const dangerWidth = danger ? 100 - getProgress(danger, complete) : 0;
+  const warningWidth = warning ? 100 - dangerWidth - getProgress(warning, complete) : 0;
 
   return (
     <div

apps/client/src/common/components/progress-bar/ProgressBar.tsx

@@ -1,22 +1,23 @@
-import { clamp } from '../../utils/math';
+import { MaybeNumber } from 'ontime-types';
+
+import { getProgress } from '../../utils/getProgress';
 
 import './ProgressBar.scss';
 
 interface ProgressBarProps {
-  now?: number;
-  complete?: number;
+  current: MaybeNumber;
+  duration: MaybeNumber;
   hidden?: boolean;
   className?: string;
 }
 
 export default function ProgressBar(props: ProgressBarProps) {
-  const { now = 0, complete = 100, hidden, className = '' } = props;
-
-  const percentComplete = clamp(100 - (Math.max(now, 0) * 100) / complete, 0, 100);
+  const { current, duration, hidden, className = '' } = props;
+  const progress = getProgress(current, duration);
 
   return (
     <div className={`progress-bar__bg ${hidden ? 'progress-bar__bg--hidden' : ''} ${className}`}>
-      <div className='progress-bar__indicator' style={{ width: `${percentComplete}%` }} />
+      <div className='progress-bar__indicator' style={{ width: `${progress}%` }} />
     </div>
   );
 }

apps/client/src/common/components/view-params-editor/ViewParamsEditor.tsx

@@ -51,6 +51,7 @@ interface EditFormDrawerProps {
   viewOptions: ViewOption[];
 }
 
+// TODO: this is a good candidate for memoisation, but needs the paramFields to be stable
 export default function ViewParamsEditor({ viewOptions }: EditFormDrawerProps) {
   const [searchParams, setSearchParams] = useSearchParams();
   const { isOpen, onClose, onOpen } = useDisclosure();

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

@@ -12,9 +12,7 @@ export const useClientPath = () => {
 
   // notify of client path changes
   useEffect(() => {
-    //remove leading '/' from path
-    const fullPath = (pathname.startsWith('/') ? pathname.slice(1) : pathname) + search;
-    socketSendJson('set-client-path', fullPath);
+    socketSendJson('set-client-path', pathname + search);
   }, [pathname, search]);
 
   // navigate to new path when received from server

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

@@ -50,6 +50,7 @@ export const usePlaybackControl = () => {
     playback: state.timer.playback,
     selectedEventIndex: state.runtime.selectedEventIndex,
     numEvents: state.runtime.numEvents,
+    timerPhase: state.timer.phase,
   });
 
   return useRuntimeStore(featureSelector);
@@ -115,6 +116,7 @@ export const setAuxTimer = {
 export const useCuesheet = () => {
   const featureSelector = (state: RuntimeStore) => ({
     playback: state.timer.playback,
+    currentBlockId: state.currentBlock.block?.id ?? null,
     selectedEventId: state.eventNow?.id ?? null,
     selectedEventIndex: state.runtime.selectedEventIndex,
     numEvents: state.runtime.numEvents,
@@ -149,7 +151,6 @@ export const useClock = () => {
 /** Used by the progress bar components */
 export const useProgressData = () => {
   const featureSelector = (state: RuntimeStore) => ({
-    addedTime: state.timer.addedTime,
     current: state.timer.current,
     duration: state.timer.duration,
     timeWarning: state.eventNow?.timeWarning ?? null,
@@ -179,6 +180,26 @@ export const useRuntimePlaybackOverview = () => {
     numEvents: state.runtime.numEvents,
     selectedEventIndex: state.runtime.selectedEventIndex,
     offset: state.runtime.offset,
+
+    currentBlock: state.currentBlock,
+  });
+
+  return useRuntimeStore(featureSelector);
+};
+
+export const useTimelineOverview = () => {
+  const featureSelector = (state: RuntimeStore) => ({
+    plannedStart: state.runtime.plannedStart,
+    plannedEnd: state.runtime.plannedEnd,
+  });
+
+  return useRuntimeStore(featureSelector);
+};
+
+export const useTimelineStatus = () => {
+  const featureSelector = (state: RuntimeStore) => ({
+    clock: state.clock,
+    offset: state.runtime.offset,
   });
 
   return useRuntimeStore(featureSelector);

apps/client/src/common/stores/runtime.ts

@@ -38,6 +38,10 @@ export const runtimeStorePlaceholder: RuntimeStore = {
     actualStart: null,
     expectedEnd: null,
   },
+  currentBlock: {
+    block: null,
+    startedAt: null,
+  },
   eventNow: null,
   eventNext: null,
   publicEventNow: null,
@@ -48,6 +52,7 @@ export const runtimeStorePlaceholder: RuntimeStore = {
     duration: 0,
     playback: SimplePlayback.Stop,
   },
+  frozen: false,
 };
 
 const deepCompare = <T>(a: T, b: T) => isEqual(a, b);

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

@@ -0,0 +1,23 @@
+import { MaybeNumber } from 'ontime-types';
+
+import { clamp } from './math';
+
+/**
+ * Returns completion percentage of a progress bar
+ * This code assumes the current time and duration have addedTime already applied
+ */
+export function getProgress(current: MaybeNumber, duration: MaybeNumber) {
+  if (current === null || duration === null) {
+    return 0;
+  }
+
+  if (current <= 0) {
+    return 100;
+  }
+
+  if (current >= duration) {
+    return 0;
+  }
+
+  return clamp(((duration - current) / duration) * 100, 0, 100);
+}

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

@@ -36,7 +36,8 @@ export const connectSocket = () => {
     }
 
     socketSendJson('set-client-type', 'ontime');
-    socketSendJson('set-client-path', location.pathname);
+
+    socketSendJson('set-client-path', location.pathname + location.search);
   };
 
   websocket.onclose = () => {
@@ -150,6 +151,11 @@ export const connectSocket = () => {
           updateDevTools({ eventNow: payload });
           break;
         }
+        case 'ontime-currentBlock': {
+          patchRuntime('currentBlock', payload);
+          updateDevTools({ currentBlock: payload });
+          break;
+        }
         case 'ontime-publicEventNow': {
           patchRuntime('publicEventNow', payload);
           updateDevTools({ publicEventNow: payload });

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

@@ -34,3 +34,16 @@ export const enDash = '–';
 
 export const timerPlaceholder = '––:––:––';
 export const timerPlaceholderMin = '––:––';
+
+/**
+ * Adds opacity to a given colour if possible
+ */
+export function alpha(colour: string, amount: number): string {
+  try {
+    const withAlpha = Color(colour).alpha(amount).hexa();
+    return withAlpha;
+  } catch (_error) {
+    /* we do not handle errors here */
+  }
+  return colour;
+}

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

@@ -1,25 +1,25 @@
 import { MaybeNumber, Settings, TimeFormat } from 'ontime-types';
-import { formatFromMillis } from 'ontime-utils';
+import { formatFromMillis, MILLIS_PER_HOUR, MILLIS_PER_MINUTE, MILLIS_PER_SECOND } from 'ontime-utils';
 
 import { FORMAT_12, FORMAT_24 } from '../../viewerConfig';
 import { APP_SETTINGS } from '../api/constants';
 import { ontimeQueryClient } from '../queryClient';
 
 /**
- * Returns current time in milliseconds
+ * Returns current time in milliseconds from midnight
  * @returns {number}
  */
-export const nowInMillis = () => {
+export function nowInMillis(): number {
   const now = new Date();
 
   // extract milliseconds since midnight
-  let elapsed = now.getHours() * 3600000;
-  elapsed += now.getMinutes() * 60000;
-  elapsed += now.getSeconds() * 1000;
+  let elapsed = now.getHours() * MILLIS_PER_HOUR;
+  elapsed += now.getMinutes() * MILLIS_PER_MINUTE;
+  elapsed += now.getSeconds() * MILLIS_PER_SECOND;
   elapsed += now.getMilliseconds();
 
   return elapsed;
-};
+}
 
 /**
  * @description Resolves format from url and store
@@ -95,3 +95,33 @@ export const formatTime = (
   const isNegative = milliseconds < 0;
   return `${isNegative ? '-' : ''}${display}`;
 };
+
+/**
+ * Handles case for formatting a duration time
+ * @param duration
+ * @returns
+ */
+export function formatDuration(duration: number, hideSeconds = true): string {
+  // durations should never be negative, we handle it here to flag if there is an issue in future
+  if (duration <= 0) {
+    return '0h 0m';
+  }
+
+  const hours = Math.floor(duration / MILLIS_PER_HOUR);
+  const minutes = Math.floor((duration % MILLIS_PER_HOUR) / MILLIS_PER_MINUTE);
+  let result = '';
+  if (hours > 0) {
+    result += `${hours}h`;
+  }
+  if (minutes > 0) {
+    result += `${minutes}m`;
+  }
+
+  if (!hideSeconds) {
+    const seconds = Math.floor((duration % MILLIS_PER_MINUTE) / MILLIS_PER_SECOND);
+    if (seconds > 0) {
+      result += `${seconds}s`;
+    }
+  }
+  return result;
+}

apps/client/src/features/app-settings/panel/general-panel/GeneralPanelForm.tsx

@@ -148,6 +148,7 @@ export default function GeneralPanelForm() {
                 <option value='en'>English</option>
                 <option value='fr'>French</option>
                 <option value='de'>German</option>
+                <option value='hu'>Hungarian</option>
                 <option value='it'>Italian</option>
                 <option value='no'>Norwegian</option>
                 <option value='pt'>Portuguese</option>

apps/client/src/features/app-settings/panel/sources-panel/import-map/ImportMapForm.tsx

@@ -78,7 +78,7 @@ export default function ImportMapForm(props: ImportMapFormProps) {
 
   const isLoading = Boolean(loading);
   const canSubmitSpreadsheet = isSpreadsheet && !isLoading;
-  const canSubmitGSheet = !isLoading;
+  const canSubmitGSheet = !isLoading && !stepData.worksheet.error;
   const canSubmit = !hasErrors && isValid && (canSubmitSpreadsheet || canSubmitGSheet);
 
   return (

apps/client/src/features/control/playback/PlaybackControl.tsx

@@ -21,6 +21,7 @@ export default function PlaybackControl() {
         playback={data.playback}
         numEvents={data.numEvents}
         selectedEventIndex={data.selectedEventIndex}
+        timerPhase={data.timerPhase}
       />
       <AuxTimer />
     </div>

apps/client/src/features/control/playback/playback-buttons/PlaybackButtons.tsx

@@ -6,7 +6,7 @@ import { IoPlaySkipForward } from '@react-icons/all-files/io5/IoPlaySkipForward'
 import { IoReload } from '@react-icons/all-files/io5/IoReload';
 import { IoStop } from '@react-icons/all-files/io5/IoStop';
 import { IoTime } from '@react-icons/all-files/io5/IoTime';
-import { Playback } from 'ontime-types';
+import { Playback, TimerPhase } from 'ontime-types';
 import { validatePlayback } from 'ontime-utils';
 
 import { setPlayback } from '../../../../common/hooks/useSocket';
@@ -19,10 +19,11 @@ interface PlaybackButtonsProps {
   playback: Playback;
   numEvents: number;
   selectedEventIndex: number | null;
+  timerPhase: TimerPhase;
 }
 
 export default function PlaybackButtons(props: PlaybackButtonsProps) {
-  const { playback, numEvents, selectedEventIndex } = props;
+  const { playback, numEvents, selectedEventIndex, timerPhase } = props;
 
   const isRolling = playback === Playback.Roll;
   const isPlaying = playback === Playback.Play;
@@ -37,7 +38,7 @@ export default function PlaybackButtons(props: PlaybackButtonsProps) {
   const disableNext = isRolling || noEvents || isLast;
   const disablePrev = isRolling || noEvents || isFirst;
 
-  const playbackCan = validatePlayback(playback);
+  const playbackCan = validatePlayback(playback, timerPhase);
   const disableStart = !playbackCan.start;
   const disablePause = !playbackCan.pause;
   const disableRoll = !playbackCan.roll || noEvents;

apps/client/src/features/cuesheet/Cuesheet.tsx

@@ -21,11 +21,11 @@ interface CuesheetProps {
   columns: ColumnDef<OntimeRundownEntry>[];
   handleUpdate: (rowIndex: number, accessor: keyof OntimeRundownEntry, payload: unknown) => void;
   selectedId: string | null;
+  currentBlockId: string | null;
 }
 
-export default function Cuesheet({ data, columns, handleUpdate, selectedId }: CuesheetProps) {
+export default function Cuesheet({ data, columns, handleUpdate, selectedId, currentBlockId }: CuesheetProps) {
   const { followSelected, showSettings, showDelayBlock, showPrevious, showIndexColumn } = useCuesheetSettings();
-
   const {
     columnVisibility,
     columnOrder,
@@ -114,11 +114,16 @@ export default function Cuesheet({ data, columns, handleUpdate, selectedId }: Cu
               }
 
               if (isOntimeBlock(row.original)) {
+                if (isPast && !showPrevious && key !== currentBlockId) {
+                  return null;
+                }
                 return <BlockRow key={key} title={row.original.title} />;
               }
               if (isOntimeDelay(row.original)) {
+                if (isPast && !showPrevious) {
+                  return null;
+                }
                 const delayVal = row.original.duration;
-
                 if (!showDelayBlock || delayVal === 0) {
                   return null;
                 }
@@ -128,9 +133,6 @@ export default function Cuesheet({ data, columns, handleUpdate, selectedId }: Cu
               if (isOntimeEvent(row.original)) {
                 eventIndex++;
                 const isSelected = key === selectedId;
-                if (isSelected) {
-                  isPast = false;
-                }
 
                 if (isPast && !showPrevious) {
                   return null;

apps/client/src/features/cuesheet/CuesheetWrapper.tsx

@@ -107,6 +107,7 @@ export default function CuesheetWrapper() {
         columns={columns}
         handleUpdate={handleUpdate}
         selectedId={featureData.selectedEventId}
+        currentBlockId={featureData.currentBlockId}
       />
     </div>
   );

apps/client/src/features/cuesheet/cuesheet-progress/CuesheetProgress.tsx

@@ -6,18 +6,17 @@ import styles from './CuesheetProgress.module.scss';
 
 export default function CuesheetProgress() {
   const { data } = useViewSettings();
-  const { addedTime, current, duration, timeWarning, timeDanger } = useProgressData();
-  const totalTime = (duration ?? 0) + (addedTime ?? 0);
+  const { current, duration, timeWarning, timeDanger } = useProgressData();
 
   return (
     <MultiPartProgressBar
       now={current}
-      complete={totalTime}
-      normalColor={data!.normalColor}
+      complete={duration}
+      normalColor={data.normalColor}
       warning={timeWarning}
-      warningColor={data!.warningColor}
+      warningColor={data.warningColor}
       danger={timeDanger}
-      dangerColor={data!.dangerColor}
+      dangerColor={data.dangerColor}
       className={styles.progressOverride}
       ignoreCssOverride
     />

apps/client/src/features/operator/Operator.tsx

@@ -170,9 +170,12 @@ export default function Operator() {
             const mainField = main ? getPropertyValue(entry, main) ?? '' : entry.title;
             const secondaryField = getPropertyValue(entry, secondary) ?? '';
             const subscribedData = subscriptions
-              ? subscriptions.map((id) => {
+              ? subscriptions.flatMap((id) => {
+                  if (!customFields[id]) {
+                    return [];
+                  }
                   const { label, colour } = customFields[id];
-                  return { id, label, colour, value: entry.custom[id] };
+                  return [{ id, label, colour, value: entry.custom[id] }];
                 })
               : null;
 

apps/client/src/features/operator/operator-event/OperatorEvent.module.scss

@@ -30,7 +30,7 @@
 
   &.running {
     border-top: 1px solid $gray-1300;
-    background-color: var(--operator-running-bg-override, $red-700);
+    background-color: var(--operator-running-bg-override, $active-red);
   }
 
   &.past {
@@ -99,7 +99,6 @@
   display: flex;
   flex-wrap: wrap;
 
-
   .field {
     font-weight: 600;
     padding-inline: 0.25rem;

apps/client/src/features/operator/operator.options.tsx

@@ -45,7 +45,7 @@ export const getOperatorOptions = (customFields: CustomFields, timeFormat: strin
     {
       id: 'hidepast',
       title: 'Hide Past Events',
-      description: 'Whether to events that have passed',
+      description: 'Whether to hide events that have passed',
       type: 'boolean',
       defaultValue: false,
     },

apps/client/src/features/operator/status-bar/StatusBarProgress.tsx

@@ -11,13 +11,12 @@ interface StatusBarProgressProps {
 
 export default function StatusBarProgress(props: StatusBarProgressProps) {
   const { viewSettings } = props;
-  const { addedTime, current, duration, timeWarning, timeDanger } = useProgressData();
-  const totalTime = (duration ?? 0) + (addedTime ?? 0);
+  const { current, duration, timeWarning, timeDanger } = useProgressData();
 
   return (
     <MultiPartProgressBar
       now={current}
-      complete={totalTime}
+      complete={duration}
       normalColor={viewSettings.normalColor}
       warning={timeWarning}
       warningColor={viewSettings.warningColor}

apps/client/src/features/overview/Overview.tsx

@@ -33,6 +33,7 @@ function _EditorOverview({ children }: { children: React.ReactNode }) {
             <TimeRow label='Actual start' value={formatedTime(actualStart)} className={style.start} />
           </div>
           <ProgressOverview />
+          <CurrentBlockOverview />
           <RuntimeOverview />
           <div>
             <TimeRow label='Planned end' value={plannedEndText} className={style.end} daySpan={maybePlannedDaySpan} />
@@ -94,6 +95,14 @@ function TitlesOverview() {
   );
 }
 
+function CurrentBlockOverview() {
+  const { currentBlock, clock } = useRuntimePlaybackOverview();
+
+  const timeInBlock = formatedTime(currentBlock.startedAt === null ? null : clock - currentBlock.startedAt);
+
+  return <TimeColumn label='Time in block' value={timeInBlock} className={style.clock} />;
+}
+
 function TimerOverview() {
   const { current } = useTimer();
 

apps/client/src/features/rundown/Rundown.tsx

@@ -2,8 +2,24 @@ import { Fragment, lazy, useCallback, useEffect, useRef, useState } from 'react'
 import { closestCenter, DndContext, DragEndEvent, PointerSensor, useSensor, useSensors } from '@dnd-kit/core';
 import { arrayMove, SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable';
 import { useHotkeys } from '@mantine/hooks';
-import { isOntimeEvent, MaybeNumber, Playback, RundownCached, SupportedEvent } from 'ontime-types';
-import { getFirstNormal, getLastNormal, getNextNormal, getPreviousNormal } from 'ontime-utils';
+import {
+  isOntimeBlock,
+  isOntimeEvent,
+  isPlayableEvent,
+  PlayableEvent,
+  Playback,
+  RundownCached,
+  SupportedEvent,
+} from 'ontime-types';
+import {
+  getFirstNormal,
+  getLastNormal,
+  getNextBlockNormal,
+  getNextNormal,
+  getPreviousBlockNormal,
+  getPreviousNormal,
+  isNewLatest,
+} from 'ontime-utils';
 
 import { useEventAction } from '../../common/hooks/useEventAction';
 import useFollowComponent from '../../common/hooks/useFollowComponent';
@@ -98,28 +114,61 @@ export default function Rundown({ data }: RundownProps) {
     [rundown, order, addEvent],
   );
 
+  const selectBlock = useCallback(
+    (cursor: string | null, direction: 'up' | 'down') => {
+      if (order.length < 1) {
+        return;
+      }
+      let newCursor = cursor;
+      if (cursor === null) {
+        // there is no cursor, we select the first or last depending on direction
+        const selected = direction === 'up' ? getLastNormal(rundown, order) : getFirstNormal(rundown, order);
+
+        if (isOntimeBlock(selected)) {
+          setSelectedEvents({ id: selected.id, selectMode: 'click', index: direction === 'up' ? order.length : 0 });
+          return;
+        }
+        newCursor = selected?.id ?? null;
+      }
+
+      if (newCursor === null) {
+        return;
+      }
+
+      // otherwise we select the next or previous
+      const selected =
+        direction === 'up'
+          ? getPreviousBlockNormal(rundown, order, newCursor)
+          : getNextBlockNormal(rundown, order, newCursor);
+
+      if (selected.entry !== null && selected.index !== null) {
+        setSelectedEvents({ id: selected.entry.id, selectMode: 'click', index: selected.index });
+      }
+    },
+    [order, rundown, setSelectedEvents],
+  );
+
   const selectEntry = useCallback(
     (cursor: string | null, direction: 'up' | 'down') => {
       if (order.length < 1) {
         return;
       }
-      let newCursor: string | null;
-      let newIndex: number | null;
+
       if (cursor === null) {
         // there is no cursor, we select the first or last depending on direction if it exists
-        newCursor =
-          (direction === 'up' ? getLastNormal(rundown, order)?.id : getFirstNormal(rundown, order)?.id) ?? null;
-        newIndex = direction === 'up' ? order.length : 0;
-      } else {
-        // otherwise we select the next or previous
-        const selected =
-          direction === 'up' ? getPreviousNormal(rundown, order, cursor) : getNextNormal(rundown, order, cursor);
-        newCursor = selected.entry?.id ?? null;
-        newIndex = selected.index;
+        const selected = direction === 'up' ? getLastNormal(rundown, order) : getFirstNormal(rundown, order);
+        if (selected !== null) {
+          setSelectedEvents({ id: selected.id, selectMode: 'click', index: direction === 'up' ? order.length : 0 });
+        }
+        return;
       }
 
-      if (newCursor && newIndex !== null) {
-        setSelectedEvents({ id: newCursor, selectMode: 'click', index: newIndex });
+      // otherwise we select the next or previous
+      const selected =
+        direction === 'up' ? getPreviousNormal(rundown, order, cursor) : getNextNormal(rundown, order, cursor);
+
+      if (selected.entry !== null && selected.index !== null) {
+        setSelectedEvents({ id: selected.entry.id, selectMode: 'click', index: selected.index });
       }
     },
     [order, rundown, setSelectedEvents],
@@ -145,6 +194,10 @@ export default function Rundown({ data }: RundownProps) {
   useHotkeys([
     ['alt + ArrowDown', () => selectEntry(cursor, 'down'), { preventDefault: true }],
     ['alt + ArrowUp', () => selectEntry(cursor, 'up'), { preventDefault: true }],
+
+    ['alt + shift + ArrowDown', () => selectBlock(cursor, 'down'), { preventDefault: true }],
+    ['alt + shift + ArrowUp', () => selectBlock(cursor, 'up'), { preventDefault: true }],
+
     ['alt + mod + ArrowDown', () => moveEntry(cursor, 'down'), { preventDefault: true }],
     ['alt + mod + ArrowUp', () => moveEntry(cursor, 'up'), { preventDefault: true }],
 
@@ -203,11 +256,9 @@ export default function Rundown({ data }: RundownProps) {
     return <RundownEmpty handleAddNew={() => insertAtId(SupportedEvent.Event, cursor)} />;
   }
 
-  let previousStart: MaybeNumber = null;
-  let previousEnd: MaybeNumber = null;
+  let lastEntry: PlayableEvent | undefined; // used by indicators
+  let thisEntry: PlayableEvent | undefined;
   let previousEventId: string | undefined;
-  let thisStart: MaybeNumber = null;
-  let thisEnd: MaybeNumber = null;
   let thisId = previousEventId;
 
   let eventIndex = 0;
@@ -235,13 +286,14 @@ export default function Rundown({ data }: RundownProps) {
               if (isOntimeEvent(event)) {
                 // event indexes are 1 based in frontend
                 eventIndex++;
-                previousStart = thisStart;
-                previousEnd = thisEnd;
                 previousEventId = thisId;
+                lastEntry = thisEntry;
 
-                if (!event.skip) {
-                  thisStart = event.timeStart;
-                  thisEnd = event.timeEnd;
+                if (isPlayableEvent(event)) {
+                  // populate previous entry
+                  if (isNewLatest(event.timeStart, event.timeEnd, lastEntry?.timeStart, lastEntry?.timeEnd)) {
+                    thisEntry = event;
+                  }
                   thisId = eventId;
                 }
               }
@@ -268,8 +320,8 @@ export default function Rundown({ data }: RundownProps) {
                         loaded={isLoaded}
                         hasCursor={hasCursor}
                         isNext={isNext}
-                        previousStart={previousStart}
-                        previousEnd={previousEnd}
+                        previousStart={lastEntry?.timeStart}
+                        previousEnd={lastEntry?.timeEnd}
                         previousEventId={previousEventId}
                         playback={isLoaded ? featureData.playback : undefined}
                         isRolling={featureData.playback === Playback.Roll}

apps/client/src/features/rundown/RundownEntry.tsx

@@ -1,5 +1,5 @@
 import { useCallback } from 'react';
-import { MaybeNumber, OntimeEvent, OntimeRundownEntry, Playback, SupportedEvent } from 'ontime-types';
+import { OntimeEvent, OntimeRundownEntry, Playback, SupportedEvent } from 'ontime-types';
 
 import { useEventAction } from '../../common/hooks/useEventAction';
 import useMemoisedFn from '../../common/hooks/useMemoisedFn';
@@ -32,8 +32,8 @@ interface RundownEntryProps {
   eventIndex: number;
   hasCursor: boolean;
   isNext: boolean;
-  previousStart: MaybeNumber;
-  previousEnd: MaybeNumber;
+  previousStart?: number;
+  previousEnd?: number;
   previousEventId?: string;
   playback?: Playback; // we only care about this if this event is playing
   isRolling: boolean; // we need to know even if not related to this event

apps/client/src/features/rundown/event-block/EventBlock.tsx

@@ -8,7 +8,7 @@ import { IoPeopleOutline } from '@react-icons/all-files/io5/IoPeopleOutline';
 import { IoReorderTwo } from '@react-icons/all-files/io5/IoReorderTwo';
 import { IoSwapVertical } from '@react-icons/all-files/io5/IoSwapVertical';
 import { IoTrash } from '@react-icons/all-files/io5/IoTrash';
-import { EndAction, MaybeNumber, MaybeString, OntimeEvent, Playback, TimerType, TimeStrategy } from 'ontime-types';
+import { EndAction, MaybeString, OntimeEvent, Playback, TimerType, TimeStrategy } from 'ontime-types';
 
 import { useContextMenu } from '../../../common/hooks/useContextMenu';
 import { cx, getAccessibleColour } from '../../../common/utils/styleUtils';
@@ -36,8 +36,8 @@ interface EventBlockProps {
   title: string;
   note: string;
   delay: number;
-  previousStart: MaybeNumber;
-  previousEnd: MaybeNumber;
+  previousStart?: number;
+  previousEnd?: number;
   colour: string;
   isPast: boolean;
   isNext: boolean;

apps/client/src/features/rundown/event-block/EventBlock.utils.ts

@@ -1,5 +1,13 @@
-import { MaybeNumber } from 'ontime-types';
-import { checkIsNextDay, dayInMs, millisToString, removeLeadingZero, removeTrailingZero } from 'ontime-utils';
+import {
+  calculateDuration,
+  checkIsNextDay,
+  dayInMs,
+  getTimeFromPrevious,
+  millisToString,
+  removeTrailingZero,
+} from 'ontime-utils';
+
+import { formatDuration } from '../../../common/utils/time';
 
 export function formatDelay(timeStart: number, delay: number): string | undefined {
   if (!delay) return;
@@ -10,31 +18,24 @@ export function formatDelay(timeStart: number, delay: number): string | undefine
   return `New start ${timeTag}`;
 }
 
-export function formatOverlap(
-  previousStart: MaybeNumber,
-  previousEnd: MaybeNumber,
-  timeStart: number,
-): string | undefined {
-  const noPreviousElement = previousEnd === null || previousStart === null;
+export function formatOverlap(timeStart: number, previousStart?: number, previousEnd?: number): string | undefined {
+  const noPreviousElement = previousEnd === undefined || previousStart === undefined;
   if (noPreviousElement) return;
 
-  const overlap = previousEnd - timeStart;
-  if (overlap === 0) return;
+  const normalisedDuration = calculateDuration(previousStart, previousEnd);
+  const timeFromPrevious = getTimeFromPrevious(timeStart, previousStart, previousEnd, normalisedDuration);
+  if (timeFromPrevious === 0) return;
 
-  const previousCrossMidnight = previousStart > previousEnd;
-  const isNextDay = previousCrossMidnight
-    ? checkIsNextDay(previousEnd, timeStart) || previousEnd == 0 // exception for when previousEnd is precisely midnight
-    : checkIsNextDay(previousStart, timeStart);
+  if (checkIsNextDay(previousStart, timeStart, normalisedDuration)) {
+    const previousCrossMidnight = previousStart > previousEnd;
+    const normalisedPreviousEnd = previousCrossMidnight ? previousEnd + dayInMs : previousEnd;
 
-  const correctedPreviousEnd = previousCrossMidnight ? previousEnd + dayInMs : previousEnd;
-
-  if (isNextDay) {
-    const gap = dayInMs - correctedPreviousEnd + timeStart;
+    const gap = dayInMs - normalisedPreviousEnd + timeStart;
     if (gap === 0) return;
-    const gapString = removeLeadingZero(millisToString(Math.abs(gap)));
+    const gapString = formatDuration(Math.abs(gap), false);
     return `Gap ${gapString} (next day)`;
   }
 
-  const overlapString = removeLeadingZero(millisToString(Math.abs(overlap)));
-  return `${overlap > 0 ? 'Overlap' : 'Gap'} ${overlapString}`;
+  const overlapString = formatDuration(Math.abs(timeFromPrevious), false);
+  return `${timeFromPrevious < 0 ? 'Overlap' : 'Gap'} ${overlapString}`;
 }

apps/client/src/features/rundown/event-block/RundownIndicators.tsx

@@ -1,20 +1,18 @@
-import { MaybeNumber } from 'ontime-types';
-
 import { formatDelay, formatOverlap } from './EventBlock.utils';
 
 import style from './RundownIndicators.module.scss';
 
 interface RundownIndicatorProps {
   timeStart: number;
-  previousStart: MaybeNumber;
-  previousEnd: MaybeNumber;
+  previousStart?: number;
+  previousEnd?: number;
   delay: number;
 }
 
 export default function RundownIndicators(props: RundownIndicatorProps) {
   const { timeStart, previousStart, previousEnd, delay } = props;
 
-  const hasOverlap = formatOverlap(previousStart, previousEnd, timeStart);
+  const hasOverlap = formatOverlap(timeStart, previousStart, previousEnd);
   const hasDelay = formatDelay(timeStart, delay);
 
   return (

apps/client/src/features/rundown/event-block/__tests__/EventBlock.utils.test.ts

@@ -16,47 +16,63 @@ describe('formatOverlap()', () => {
     const previousStart = 0;
     const previousEnd = 60000; // 1 min
     const timeStart = 30000; // 30 sec
-    const result = formatOverlap(previousStart, previousEnd, timeStart);
-    expect(result).toEqual('Overlap 0:30');
+    const result = formatOverlap(timeStart, previousStart, previousEnd);
+    expect(result).toEqual('Overlap 30s');
   });
 
   it('bug #949 recognises an overlap between two times', () => {
     const previousStart = 46800000; // 13:00:00
     const previousEnd = 48600000; // 13:30:00
     const timeStart = 48300000; // 13:25:00
-    const result = formatOverlap(previousStart, previousEnd, timeStart);
-    expect(result).toEqual('Overlap 5:00');
+    const result = formatOverlap(timeStart, previousStart, previousEnd);
+    expect(result).toEqual('Overlap 5m');
   });
 
   it('handles events the day after, without overlap', () => {
     const previousStart = 11 * MILLIS_PER_HOUR;
     const previousEnd = 12 * MILLIS_PER_HOUR;
     const timeStart = 6 * MILLIS_PER_HOUR;
-    const result = formatOverlap(previousStart, previousEnd, timeStart);
-    expect(result).toBe('Gap 18:00:00 (next day)');
+    const result = formatOverlap(timeStart, previousStart, previousEnd);
+    expect(result).toBe('Gap 18h (next day)');
   });
 
   it('handles events the day after, with gap', () => {
     const previousStart = 17 * MILLIS_PER_HOUR;
     const previousEnd = 23 * MILLIS_PER_HOUR;
     const timeStart = 9 * MILLIS_PER_HOUR;
-    const result = formatOverlap(previousStart, previousEnd, timeStart);
-    expect(result).toBe('Gap 10:00:00 (next day)');
+    const result = formatOverlap(timeStart, previousStart, previousEnd);
+    expect(result).toBe('Gap 10h (next day)');
   });
 
   it('handles events the day after, with previous ending at midnight', () => {
     const previousStart = 23 * MILLIS_PER_HOUR; // 23:00:00
     const previousEnd = 0; // 00:00:00
     const timeStart = 1 * MILLIS_PER_HOUR; // 01:00:00
-    const result = formatOverlap(previousStart, previousEnd, timeStart);
-    expect(result).toBe('Gap 01:00:00 (next day)');
+    const result = formatOverlap(timeStart, previousStart, previousEnd);
+    expect(result).toBe('Gap 1h (next day)');
   });
 
-  it('handles events the day after, with previous ending over midnight', () => {
+  it('handles sequential events the day after, with previous ending over midnight', () => {
+    const previousStart = 23 * MILLIS_PER_HOUR;
+    const previousEnd = 1 * MILLIS_PER_HOUR;
+    const timeStart = 1 * MILLIS_PER_HOUR;
+    const result = formatOverlap(timeStart, previousStart, previousEnd);
+    expect(result).toBeUndefined();
+  });
+
+  it('handles events the day after, with previous ending over midnight with overlap', () => {
+    const previousStart = 23 * MILLIS_PER_HOUR;
+    const previousEnd = 2 * MILLIS_PER_HOUR;
+    const timeStart = 1 * MILLIS_PER_HOUR;
+    const result = formatOverlap(timeStart, previousStart, previousEnd);
+    expect(result).toBe('Overlap 1h');
+  });
+
+  it('handles events the day after, with previous ending over midnight with gap', () => {
     const previousStart = 23 * MILLIS_PER_HOUR;
     const previousEnd = 1 * MILLIS_PER_HOUR;
     const timeStart = 2 * MILLIS_PER_HOUR;
-    const result = formatOverlap(previousStart, previousEnd, timeStart);
-    expect(result).toBe('Gap 01:00:00');
+    const result = formatOverlap(timeStart, previousStart, previousEnd);
+    expect(result).toBe('Gap 1h');
   });
 });

apps/client/src/features/rundown/event-block/composite/EventBlockProgressBar.tsx

@@ -1,29 +1,12 @@
-import { MaybeNumber } from 'ontime-types';
-
 import { useTimer } from '../../../../common/hooks/useSocket';
-import { clamp } from '../../../../common/utils/math';
+import { getProgress } from '../../../../common/utils/getProgress';
 
 import style from './EventBlockProgressBar.module.scss';
 
-export function getPercentComplete(remaining: MaybeNumber, total: MaybeNumber): number {
-  if (remaining === null || total === null) {
-    return 0;
-  }
-
-  if (remaining <= 0) {
-    return 100;
-  }
-
-  if (remaining === total) {
-    return 0;
-  }
-
-  return clamp(100 - (remaining * 100) / total, 0, 100);
-}
-
 export default function EventBlockProgressBar() {
   const timer = useTimer();
 
-  const progress = `${getPercentComplete(timer.current, timer.duration)}%`;
-  return <div className={style.progressBar} style={{ width: progress }} />;
+  const progress = getProgress(timer.current, timer.duration);
+
+  return <div className={style.progressBar} style={{ width: `${progress}%` }} />;
 }

apps/client/src/features/rundown/event-block/composite/__tests__/EventBlockProgressBar.test.ts

@@ -1,27 +0,0 @@
-import { dayInMs } from 'ontime-utils';
-
-import { getPercentComplete } from '../EventBlockProgressBar';
-
-describe('getPercentComplete()', () => {
-  describe('calculates progress in normal cases', () => {
-    const testScenarios = [
-      { current: 0, duration: 0, expect: 100 },
-      { current: 0, duration: 100, expect: 100 },
-      { current: 0, duration: dayInMs, expect: 100 },
-      { current: 10, duration: 100, expect: 90 },
-      { current: 50, duration: 100, expect: 50 },
-      { current: 100, duration: 100, expect: 0 },
-    ];
-
-    testScenarios.forEach((testCase) => {
-      it(`handles ${testCase.current} / ${testCase.duration}`, () => {
-        const progress = getPercentComplete(testCase.current, testCase.duration);
-        expect(progress).toBe(testCase.expect);
-      });
-    });
-  });
-  it('is 0 if we dont have a current or duration', () => {
-    const progress = getPercentComplete(null, null);
-    expect(progress).toBe(0);
-  });
-});

apps/client/src/features/rundown/event-editor/EventEditorEmpty.module.scss

@@ -28,6 +28,7 @@
     }
     td:nth-child(even) {
       text-align: right;
+      white-space: nowrap;
     }
   }
 }

apps/client/src/features/rundown/event-editor/EventEditorEmpty.tsx

@@ -24,6 +24,18 @@ function EventEditorEmpty() {
                 <Kbd>↓</Kbd>
               </td>
             </tr>
+            <tr>
+              <td>Select block</td>
+              <td>
+                <Kbd>{deviceAlt}</Kbd>
+                <AuxKey>+</AuxKey>
+                <Kbd>Shift</Kbd>
+                <AuxKey>+</AuxKey>
+                <Kbd>↑</Kbd>
+                <AuxKey>/</AuxKey>
+                <Kbd>↓</Kbd>
+              </td>
+            </tr>
             <tr>
               <td>Deselect entry</td>
               <td>

apps/client/src/features/viewers/ViewWrapper.tsx

@@ -39,7 +39,7 @@ type WithDataProps = {
   publicSelectedId: string | null;
   runtime: Runtime;
   selectedId: string | null;
-  settings: Settings | undefined;
+  settings: Settings | undefined; // TODO: what is the case for this being undefined?
   time: ViewExtendedTimer;
   viewSettings: ViewSettings;
 };

apps/client/src/features/viewers/backstage/Backstage.tsx

@@ -94,7 +94,6 @@ export default function Backstage(props: BackstageProps) {
   let stageTimer = millisToString(time.current, { fallback: timerPlaceholderMin });
   stageTimer = removeLeadingZero(stageTimer);
 
-  const totalTime = (time.duration ?? 0) + (time.addedTime ?? 0);
   const defaultFormat = getDefaultFormat(settings?.timeFormat);
   const backstageOptions = getBackstageOptions(defaultFormat, customFields);
 
@@ -111,8 +110,8 @@ export default function Backstage(props: BackstageProps) {
 
       <ProgressBar
         className='progress-container'
-        now={time.current ?? undefined}
-        complete={totalTime}
+        current={time.current}
+        duration={time.duration}
         hidden={!showProgress}
       />
 

apps/client/src/features/viewers/lower-thirds/lowerThird.options.ts

@@ -14,18 +14,6 @@ export const getLowerThirdOptions = (customFields: CustomFields): ViewOption[] =
   });
 
   return [
-    { section: 'View behaviour' },
-    {
-      id: 'trigger',
-      title: 'Animation Trigger',
-      description: '',
-      type: 'option',
-      values: {
-        event: 'Event Load',
-        manual: 'Manual',
-      },
-      defaultValue: 'manual',
-    },
     { section: 'Data sources' },
     {
       id: 'top-src',

apps/client/src/features/viewers/timeline/Timeline.module.scss

@@ -0,0 +1,112 @@
+@use '../../../theme/viewerDefs' as *;
+
+$timeline-entry-height: 20px;
+$lane-height: 120px;
+$timeline-height: 1rem;
+
+.timeline {
+  flex: 1;
+  font-weight: 600;
+  color: $ui-white;
+  background-color: $ui-black;
+}
+
+.timelineEvents {
+  position: relative;
+  height: 100%;
+}
+
+.column {
+  display: flex;
+  flex-direction: column;
+  position: absolute;
+  border-left: 1px solid $ui-black;
+  // avoiding content being larger than the view
+  height: calc(100% - 3rem);
+
+  // decorate timeline element
+  &::before {
+    content: '';
+    position: absolute;
+    box-sizing: content-box;
+    top: -$timeline-height;
+    left: 0;
+    right: 0;
+    height: $timeline-height;
+    background-color: $white-40;
+  }
+}
+
+.smallArea {
+  .content {
+    gap: 0rem;
+    writing-mode: vertical-rl;
+  }
+
+  .timeOverview {
+    opacity: 0;
+  }
+}
+
+.hide {
+  // hide text elements
+  & > div {
+    display: none;
+  }
+}
+
+.content {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+  padding-top: 0.25rem;
+  padding-inline-start: 0.25rem;
+  overflow: hidden;
+  line-height: 1rem;
+
+  background-color: var(--lighter, $viewer-card-bg-color);
+  border-bottom: 2px solid $ui-black;
+  box-shadow: 0 0.25rem 0 0 var(--color, $gray-300);
+
+  &[data-status='done'] {
+    opacity: $opacity-disabled;
+  }
+
+  &[data-status='live'] {
+    box-shadow: 0 0.25rem 0 0 $active-red;
+  }
+}
+
+.delay {
+  margin-top: -2rem;
+  margin-bottom: -1rem;
+}
+
+.timeOverview {
+  padding-top: 0.25rem;
+  padding-inline-start: 0.25em;
+  text-transform: capitalize;
+  white-space: normal;
+  height: 6rem;
+
+  &[data-status='done'] {
+    opacity: $opacity-disabled;
+  }
+
+  &[data-status='live'] {
+    .status {
+      color: $active-red;
+    }
+  }
+
+  &[data-status='future'] {
+    .status {
+      color: $green-500;
+    }
+  }
+}
+
+.cross {
+  text-decoration: line-through;
+}

apps/client/src/features/viewers/timeline/Timeline.tsx

@@ -0,0 +1,96 @@
+import { memo } from 'react';
+import { useViewportSize } from '@mantine/hooks';
+import { isOntimeEvent, MaybeNumber, OntimeEvent } from 'ontime-types';
+import { checkIsNextDay, dayInMs, getLastEvent, MILLIS_PER_HOUR } from 'ontime-utils';
+
+import { useTimelineOverview } from '../../../common/hooks/useSocket';
+
+import TimelineMarkers from './timeline-markers/TimelineMarkers';
+import ProgressBar from './timeline-progress-bar/TimelineProgressBar';
+import { getElementPosition, getEndHour, getStartHour } from './timeline.utils';
+import { ProgressStatus, TimelineEntry } from './TimelineEntry';
+
+import style from './Timeline.module.scss';
+
+interface TimelineProps {
+  selectedEventId: string | null;
+  rundown: OntimeEvent[];
+}
+
+export default memo(Timeline);
+
+function Timeline(props: TimelineProps) {
+  const { selectedEventId, rundown } = props;
+  const { width: screenWidth } = useViewportSize();
+  const { plannedStart, plannedEnd } = useTimelineOverview();
+
+  if (plannedStart === null || plannedEnd === null) {
+    return null;
+  }
+
+  const { lastEvent } = getLastEvent(rundown);
+  const startHour = getStartHour(plannedStart);
+  const endHour = getEndHour(plannedEnd + (lastEvent?.delay ?? 0));
+
+  let hasTimelinePassedMidnight = false;
+  let previousEventStartTime: MaybeNumber = null;
+  // we use selectedEventId as a signifier on whether the timeline is live
+  let eventStatus: ProgressStatus = selectedEventId ? 'done' : 'future';
+
+  return (
+    <div className={style.timeline}>
+      <TimelineMarkers startHour={startHour} endHour={endHour} />
+      <ProgressBar startHour={startHour} endHour={endHour} />
+      <div className={style.timelineEvents}>
+        {rundown.map((event) => {
+          // for now we dont render delays and blocks
+          if (!isOntimeEvent(event)) {
+            return null;
+          }
+
+          // keep track of progress of rundown
+          if (eventStatus === 'live') {
+            eventStatus = 'future';
+          }
+          if (event.id === selectedEventId) {
+            eventStatus = 'live';
+          }
+
+          if (!hasTimelinePassedMidnight) {
+            // we need to offset the start to account for midnight
+            hasTimelinePassedMidnight = previousEventStartTime !== null && event.timeStart < previousEventStartTime;
+          }
+          // TODO: timeline must accumulate normalised time over days
+          const isNextDay =
+            previousEventStartTime !== null
+              ? checkIsNextDay(previousEventStartTime, event.timeStart, event.duration)
+              : false;
+          const normalisedStart = hasTimelinePassedMidnight || isNextDay ? event.timeStart + dayInMs : event.timeStart;
+          previousEventStartTime = normalisedStart;
+
+          const { left: elementLeftPosition, width: elementWidth } = getElementPosition(
+            startHour * MILLIS_PER_HOUR,
+            endHour * MILLIS_PER_HOUR,
+            normalisedStart + (event.delay ?? 0),
+            event.duration,
+            screenWidth,
+          );
+
+          return (
+            <TimelineEntry
+              key={event.id}
+              colour={event.colour}
+              delay={event.delay ?? 0}
+              duration={event.duration}
+              left={elementLeftPosition}
+              status={eventStatus}
+              start={normalisedStart} // dataset solves issues related to crossing midnight
+              title={event.title}
+              width={elementWidth}
+            />
+          );
+        })}
+      </div>
+    </div>
+  );
+}

apps/client/src/features/viewers/timeline/TimelineEntry.tsx

@@ -0,0 +1,94 @@
+import { useTimelineStatus } from '../../../common/hooks/useSocket';
+import { alpha, cx } from '../../../common/utils/styleUtils';
+import { formatDuration, formatTime } from '../../../common/utils/time';
+import { useTranslation } from '../../../translation/TranslationProvider';
+
+import { getStatusLabel } from './timeline.utils';
+
+import style from './Timeline.module.scss';
+
+export type ProgressStatus = 'done' | 'live' | 'future';
+
+interface TimelineEntryProps {
+  colour: string;
+  delay: number;
+  duration: number;
+  left: number;
+  status: ProgressStatus;
+  start: number;
+  title: string;
+  width: number;
+}
+
+const formatOptions = {
+  format12: 'hh:mm a',
+  format24: 'HH:mm',
+};
+
+export function TimelineEntry(props: TimelineEntryProps) {
+  const { colour, delay, duration, left, status, start, title, width } = props;
+
+  const formattedStartTime = formatTime(start, formatOptions);
+  const formattedDuration = formatDuration(duration);
+  const delayedStart = start + delay;
+  const hasDelay = delay > 0;
+
+  const lighterColour = alpha(colour, 0.7);
+  const columnClasses = cx([style.column, width < 40 && style.smallArea]);
+  const contentClasses = cx([style.content, width < 20 && style.hide]);
+  const showTitle = width > 25;
+
+  return (
+    <div
+      className={columnClasses}
+      style={{
+        '--color': colour,
+        '--lighter': lighterColour ?? '',
+        left: `${left}px`,
+        width: `${width}px`,
+      }}
+    >
+      <div
+        className={contentClasses}
+        data-status={status}
+        style={{
+          '--color': colour,
+        }}
+      >
+        <div className={hasDelay ? style.cross : undefined}>{formattedStartTime}</div>
+        {hasDelay && <div className={style.delay}>{formatTime(delayedStart, formatOptions)}</div>}
+        {showTitle && <div>{title}</div>}
+      </div>
+      <div className={style.timeOverview} data-status={status}>
+        {status !== 'done' && (
+          <>
+            <div className={style.duration}>{formattedDuration}</div>
+            <TimelineEntryStatus status={status} start={delayedStart} />
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+interface TimelineEntryStatusProps {
+  status: ProgressStatus;
+  start: number;
+}
+
+// we isolate this component to avoid isolate re-renders provoked by the clock changes
+function TimelineEntryStatus(props: TimelineEntryStatusProps) {
+  const { status, start } = props;
+  const { clock, offset } = useTimelineStatus();
+  const { getLocalizedString } = useTranslation();
+
+  // start times need to be normalised in a rundown that crosses midnight
+  let statusText = getStatusLabel(start - clock + offset, status);
+  if (statusText === 'live') {
+    statusText = getLocalizedString('timeline.live');
+  } else if (statusText === 'pending') {
+    statusText = getLocalizedString('timeline.due');
+  }
+
+  return <div className={style.status}>{statusText}</div>;
+}

apps/client/src/features/viewers/timeline/TimelinePage.scss

@@ -0,0 +1,101 @@
+@use '../../../theme/viewerDefs' as *;
+
+.timeline {
+  width: 100vw;
+  height: 100vh;
+  padding-top: 0.5rem;
+
+  font-family: var(--font-family-override, $viewer-font-family);
+  background: var(--background-color-override, $viewer-background-color);
+  color: var(--color-override, $viewer-color);
+
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+
+  .project-header {
+    padding-inline: 2rem;
+    font-size: clamp(32px, 4.5vw, 64px);
+    font-weight: 600;
+    display: flex;
+    justify-content: space-between;
+  }
+
+  .clock-container {
+    .label {
+      font-size: clamp(16px, 1.5vw, 24px);
+      font-weight: 600;
+      color: var(--label-color-override, $viewer-label-color);
+      text-transform: uppercase;
+    }
+
+    .time {
+      font-size: clamp(32px, 3.5vw, 50px);
+      font-weight: 600;
+      color: var(--secondary-color-override, $viewer-secondary-color);
+      letter-spacing: 0.05em;
+      line-height: 0.95em;
+    }
+  }
+
+  .title-grid {
+    display: grid;
+    grid-template-columns: 2fr 3fr;
+    row-gap: 1rem;
+    column-gap: 2rem;
+    grid-template-areas:
+      'now next'
+      'now following';
+    padding-inline: 2rem;
+  }
+
+  .section {
+    background-color: var(--card-background-color-override, $viewer-card-bg-color);
+    padding: 0.5rem 1rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    border-radius: $element-border-radius;
+  }
+
+  .section--now {
+    grid-area: now;
+  }
+
+  .section-title {
+    line-height: 1em;
+    font-size: 1.5rem;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    font-weight: 600;
+  }
+
+  .section-title__label {
+    text-transform: uppercase;
+  }
+
+  .section-title__status {
+    color: $green-500;
+  }
+
+  .section-content {
+    min-height: 2em;
+    line-height: 1em;
+    font-size: 3rem;
+    text-transform: uppercase;
+    font-weight: 600;
+  }
+
+  .section-content--now {
+    color: $red-500;
+  }
+
+  .section-content--next {
+    color: $green-500;
+  }
+
+  .section-content--subdue {
+    opacity: $opacity-disabled;
+  }
+}

apps/client/src/features/viewers/timeline/TimelinePage.tsx

@@ -0,0 +1,92 @@
+import { useMemo } from 'react';
+import { MaybeString, OntimeEvent, ProjectData, Settings, ViewSettings } from 'ontime-types';
+
+import { overrideStylesURL } from '../../../common/api/constants';
+import ViewParamsEditor from '../../../common/components/view-params-editor/ViewParamsEditor';
+import { useRuntimeStylesheet } from '../../../common/hooks/useRuntimeStylesheet';
+import { useWindowTitle } from '../../../common/hooks/useWindowTitle';
+import { ViewExtendedTimer } from '../../../common/models/TimeManager.type';
+import { formatTime, getDefaultFormat } from '../../../common/utils/time';
+import { useTranslation } from '../../../translation/TranslationProvider';
+import SuperscriptTime from '../common/superscript-time/SuperscriptTime';
+
+import Section from './timeline-section/TimelineSection';
+import Timeline from './Timeline';
+import { getTimelineOptions } from './timeline.options';
+import { getFormattedTimeToStart, getScopedRundown, getUpcomingEvents } from './timeline.utils';
+
+import './TimelinePage.scss';
+
+interface TimelinePageProps {
+  backstageEvents: OntimeEvent[];
+  general: ProjectData;
+  selectedId: MaybeString;
+  settings: Settings | undefined;
+  time: ViewExtendedTimer;
+  viewSettings: ViewSettings;
+}
+
+/**
+ * since we inherit from viewPage
+ * which refreshes at least once a second
+ * There is little point splitting or memoising top level elements
+ */
+export default function TimelinePage(props: TimelinePageProps) {
+  const { backstageEvents, general, selectedId, settings, time, viewSettings } = props;
+  const { shouldRender } = useRuntimeStylesheet(viewSettings?.overrideStyles && overrideStylesURL);
+
+  const { getLocalizedString } = useTranslation();
+  const clock = formatTime(time.clock);
+
+  // holds copy of the rundown with only relevant events
+  const scopedRundown = useMemo(() => {
+    return getScopedRundown(backstageEvents, selectedId);
+  }, [backstageEvents, selectedId]);
+
+  const { now, next, followedBy } = useMemo(() => {
+    return getUpcomingEvents(scopedRundown, selectedId);
+  }, [scopedRundown, selectedId]);
+
+  useWindowTitle('Timeline');
+
+  if (!shouldRender) {
+    return null;
+  }
+
+  // populate options
+  const defaultFormat = getDefaultFormat(settings?.timeFormat);
+  const progressOptions = getTimelineOptions(defaultFormat);
+
+  const titleNow = now?.title ?? '-';
+  const dueText = getLocalizedString('timeline.due').toUpperCase();
+  const nextText = next !== null ? next.title : '-';
+  const followedByText = followedBy !== null ? followedBy.title : '-';
+
+  const nextStatus = next !== null ? getFormattedTimeToStart(next, time.clock, dueText) : undefined;
+  const followedByStatus = followedBy !== null ? getFormattedTimeToStart(followedBy, time.clock, dueText) : undefined;
+
+  return (
+    <div className='timeline'>
+      <ViewParamsEditor viewOptions={progressOptions} />
+      <div className='project-header'>
+        {general.title}
+        <div className='clock-container'>
+          <div className='label'>{getLocalizedString('common.time_now')}</div>
+          <SuperscriptTime time={clock} className='time' />
+        </div>
+      </div>
+
+      <div className='title-grid'>
+        <Section title={getLocalizedString('timeline.live')} content={titleNow} category='now' />
+        <Section title={getLocalizedString('common.next')} status={nextStatus} content={nextText} category='next' />
+        <Section
+          title={getLocalizedString('timeline.followedby')}
+          status={followedByStatus}
+          content={followedByText}
+          category='next'
+        />
+      </div>
+      <Timeline selectedEventId={selectedId} rundown={scopedRundown} />
+    </div>
+  );
+}

apps/client/src/features/viewers/timeline/__tests__/timeline.utils.test.ts

@@ -0,0 +1,66 @@
+import { dayInMs } from 'ontime-utils';
+
+import { getElementPosition, makeTimelineSections } from '../timeline.utils';
+
+describe('getCSSPosition()', () => {
+  it('accounts for rundown with one event', () => {
+    const scheduleStart = 0;
+    const scheduleEnd = dayInMs;
+    const eventStart = 0;
+    const eventDuration = dayInMs;
+    const containerWidth = 100;
+
+    const result = getElementPosition(scheduleStart, scheduleEnd, eventStart, eventDuration, containerWidth);
+    expect(result.left).toBe(0);
+    expect(result.width).toBe(containerWidth);
+  });
+
+  it('accounts for an event that starts halfway and ends at end', () => {
+    const scheduleStart = 0;
+    const scheduleEnd = 100;
+    const eventStart = 50;
+    const eventDuration = 50;
+    const containerWidth = 100;
+
+    const result = getElementPosition(scheduleStart, scheduleEnd, eventStart, eventDuration, containerWidth);
+    expect(result.left).toBe(50);
+    expect(result.width).toBe(50);
+  });
+
+  it('accounts for an event that starts first and ends halfway', () => {
+    const scheduleStart = 0;
+    const scheduleEnd = 100;
+    const eventStart = 0;
+    const eventDuration = 50;
+    const containerWidth = 100;
+
+    const result = getElementPosition(scheduleStart, scheduleEnd, eventStart, eventDuration, containerWidth);
+    expect(result.left).toBe(0);
+    expect(result.width).toBe(50);
+  });
+
+  it('accounts for an event that is in the middle of the rundown', () => {
+    const scheduleStart = 7;
+    const scheduleEnd = 23;
+    const eventStart = 10;
+    const eventDuration = 1;
+    const containerWidth = 1000;
+
+    // 16 hour event, this gives 62.5px per hour
+    const result = getElementPosition(scheduleStart, scheduleEnd, eventStart, eventDuration, containerWidth);
+    expect(result.left).toBe(187.5); // 3 * 62.5
+    expect(result.width).toBe(62.5);
+  });
+});
+
+describe('makeTmelineSections', () => {
+  it('creates an array between the hours given, end excluded', () => {
+    const result = makeTimelineSections(11, 17);
+    expect(result).toEqual(['11:00', '12:00', '13:00', '14:00', '15:00', '16:00']);
+  });
+
+  it('wraps around midnight', () => {
+    const result = makeTimelineSections(22, 26);
+    expect(result).toEqual(['22:00', '23:00', '00:00', '01:00']);
+  });
+});

apps/client/src/features/viewers/timeline/timeline-markers/TimelineMarkers.module.scss

@@ -0,0 +1,16 @@
+.markers {
+  width: 100%;
+  color: $ui-white;
+  display: flex;
+  height: 1rem;
+  line-height: 1rem;
+  margin-bottom: 0.25rem;
+  font-size: calc(1rem - 2px);
+  justify-content: space-evenly;
+
+  & > span {
+    flex-grow: 1;
+    border-left: 1px solid $white-7;
+    height: 100vh;
+  }
+}

apps/client/src/features/viewers/timeline/timeline-markers/TimelineMarkers.tsx

@@ -0,0 +1,22 @@
+import { makeTimelineSections } from '../timeline.utils';
+
+import style from './TimelineMarkers.module.scss';
+
+interface TimelineMarkersProps {
+  startHour: number;
+  endHour: number;
+}
+
+export default function TimelineMarkers(props: TimelineMarkersProps) {
+  const { startHour, endHour } = props;
+
+  const elements = makeTimelineSections(startHour, endHour);
+
+  return (
+    <div className={style.markers}>
+      {elements.map((tag, index) => {
+        return <span key={`${index}-${tag}`}>{tag}</span>;
+      })}
+    </div>
+  );
+}

apps/client/src/features/viewers/timeline/timeline-progress-bar/TimelineProgressBar.module.scss

@@ -0,0 +1,19 @@
+.progressBar {
+  width: 100%;
+  height: 1rem;
+  position: relative;
+
+  background-color: $gray-1000;
+}
+
+.progress {
+  height: 100%;
+  position: absolute;
+  left: 0;
+  top: 0;
+  z-index: 2;
+  
+  background-color: $active-red;
+  transition-duration: 0.3s; 
+  transition-property: width;
+}

apps/client/src/features/viewers/timeline/timeline-progress-bar/TimelineProgressBar.tsx

@@ -0,0 +1,25 @@
+import { MILLIS_PER_HOUR } from 'ontime-utils';
+
+import { useClock } from '../../../../common/hooks/useSocket';
+import { getRelativePositionX } from '../timeline.utils';
+
+import style from './TimelineProgressBar.module.scss';
+
+interface ProgressBarProps {
+  startHour: number;
+  endHour: number;
+}
+
+export default function ProgressBar(props: ProgressBarProps) {
+  const { startHour, endHour } = props;
+  // TODO: how to account for days?
+  const { clock } = useClock();
+
+  const width = getRelativePositionX(startHour * MILLIS_PER_HOUR, endHour * MILLIS_PER_HOUR, clock);
+
+  return (
+    <div className={style.progressBar}>
+      <div className={style.progress} style={{ width: `${width}%` }} />
+    </div>
+  );
+}

apps/client/src/features/viewers/timeline/timeline-section/TimelineSection.tsx

@@ -0,0 +1,29 @@
+import { memo } from 'react';
+import { MaybeString } from 'ontime-types';
+
+import { cx } from '../../../../common/utils/styleUtils';
+
+interface SectionProps {
+  category: 'now' | 'next';
+  content: MaybeString;
+  title: string;
+  status?: string;
+}
+
+export default memo(Section);
+
+export function Section(props: SectionProps) {
+  const { category, content, title, status } = props;
+
+  const sectionClasses = cx(['section', category === 'now' && 'section--now']);
+  const contentClasses = cx(['section-content', content ? `section-content--${category}` : 'section-content--subdue']);
+  return (
+    <div className={sectionClasses}>
+      <div className='section-title'>
+        <span className='section-title__label'>{title}</span>
+        {status && <span className='section-title__status'>{status}</span>}
+      </div>
+      <div className={contentClasses}>{content ?? '-'}</div>
+    </div>
+  );
+}

apps/client/src/features/viewers/timeline/timeline.options.ts

@@ -0,0 +1,22 @@
+import { getTimeOption } from '../../../common/components/view-params-editor/constants';
+import { ViewOption } from '../../../common/components/view-params-editor/types';
+
+export const getTimelineOptions = (timeFormat: string): ViewOption[] => {
+  return [
+    getTimeOption(timeFormat),
+    {
+      id: 'hidePast',
+      title: 'Hide Past Events',
+      description: 'Whether to hide events that have passed',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'hideBackstage',
+      title: 'Hide Private Events',
+      description: 'Whether to hide non-public events',
+      type: 'boolean',
+      defaultValue: false,
+    },
+  ];
+};

apps/client/src/features/viewers/timeline/timeline.utils.ts

@@ -0,0 +1,154 @@
+import { isOntimeEvent, MaybeString, OntimeEvent } from 'ontime-types';
+import {
+  dayInMs,
+  getEventWithId,
+  getFirstEvent,
+  getNextEvent,
+  MILLIS_PER_HOUR,
+  millisToString,
+  removeSeconds,
+} from 'ontime-utils';
+
+import { clamp } from '../../../common/utils/math';
+import { formatDuration } from '../../../common/utils/time';
+import { isStringBoolean } from '../common/viewUtils';
+
+import type { ProgressStatus } from './TimelineEntry';
+
+type CSSPosition = {
+  left: number;
+  width: number;
+};
+
+/**
+ * Calculates the position (in %) of an element relative to a schedule
+ */
+export function getRelativePositionX(scheduleStart: number, scheduleEnd: number, now: number): number {
+  return clamp(((now - scheduleStart) / (scheduleEnd - scheduleStart)) * 100, 0, 100);
+}
+
+/**
+ * Calculates an absolute position of an element based on a schedule
+ */
+export function getElementPosition(
+  scheduleStart: number,
+  scheduleEnd: number,
+  eventStart: number,
+  eventDuration: number,
+  containerWidth: number,
+): CSSPosition {
+  const normalEnd = scheduleEnd < scheduleStart ? scheduleEnd + dayInMs : scheduleEnd;
+  const totalDuration = normalEnd - scheduleStart;
+  const width = (eventDuration * containerWidth) / totalDuration;
+  const left = ((eventStart - scheduleStart) * containerWidth) / totalDuration;
+
+  return { left, width };
+}
+
+/**
+ * Gets rounded down hour for a given time
+ */
+export function getStartHour(startTime: number): number {
+  const hours = Math.floor(startTime / MILLIS_PER_HOUR);
+  return hours;
+}
+
+/**
+ * Gets rounded up hour for a given time
+ */
+export function getEndHour(endTime: number): number {
+  const hours = Math.ceil(endTime / MILLIS_PER_HOUR);
+  return hours;
+}
+
+/**
+ * converts a time span into an array of hours
+ */
+export function makeTimelineSections(firstHour: number, lastHour: number) {
+  const timelineSections = [];
+  for (let i = firstHour; i < lastHour; i++) {
+    timelineSections.push(removeSeconds(millisToString((i % 24) * MILLIS_PER_HOUR)));
+  }
+  return timelineSections;
+}
+
+/**
+ * Returns a formatted label for a progress status
+ */
+export function getStatusLabel(timeToStart: number, status: ProgressStatus): string {
+  if (status === 'done' || status === 'live') {
+    return status;
+  }
+
+  if (timeToStart < 0) {
+    return 'pending';
+  }
+
+  return formatDuration(timeToStart);
+}
+
+export function getScopedRundown(rundown: OntimeEvent[], selectedEventId: MaybeString): OntimeEvent[] {
+  if (rundown.length === 0) {
+    return [];
+  }
+
+  const params = new URL(document.location.href).searchParams;
+  const hideBackstage = isStringBoolean(params.get('hideBackstage'));
+  const hidePast = isStringBoolean(params.get('hidePast'));
+
+  let scopedRundown = [...rundown];
+
+  if (hidePast && selectedEventId) {
+    const currentIndex = rundown.findIndex((event) => event.id === selectedEventId);
+    if (currentIndex >= 0) {
+      scopedRundown = scopedRundown.slice(currentIndex);
+    }
+  }
+
+  if (hideBackstage) {
+    scopedRundown = scopedRundown.filter((event) => event.isPublic);
+  }
+
+  return scopedRundown;
+}
+
+type UpcomingEvents = {
+  now: OntimeEvent | null;
+  next: OntimeEvent | null;
+  followedBy: OntimeEvent | null;
+};
+
+/**
+ * Returns upcoming events from current: now, next and followedBy
+ */
+export function getUpcomingEvents(events: OntimeEvent[], selectedId: MaybeString): UpcomingEvents {
+  if (events.length === 0) {
+    return { now: null, next: null, followedBy: null };
+  }
+
+  const now = selectedId ? getEventWithId(events, selectedId) : getFirstEvent(events)?.firstEvent;
+
+  if (!isOntimeEvent(now)) {
+    return { now: null, next: null, followedBy: null };
+  }
+
+  const next = getNextEvent(events, now.id)?.nextEvent;
+  const followedBy = next ? getNextEvent(events, next.id)?.nextEvent : null;
+
+  // Return the titles, handling nulls appropriately
+  return {
+    now,
+    next,
+    followedBy,
+  };
+}
+
+export function getFormattedTimeToStart(event: OntimeEvent, now: number, dueText: string): string {
+  const timeToStart = event.timeStart - now;
+
+  if (timeToStart < 0) {
+    return dueText;
+  }
+
+  return `T - ${formatDuration(timeToStart)}`;
+}

apps/client/src/index.tsx

@@ -1,51 +1,13 @@
 import { StrictMode } from 'react';
 import { createRoot } from 'react-dom/client';
-// skipcq: JS-C1003 - sentry does not expose itself as an ES Module.
-import * as Sentry from '@sentry/react';
 
 import App from './App';
-import { ONTIME_VERSION } from './ONTIME_VERSION';
 
 import './index.scss';
 
 const container = document.getElementById('root');
 const root = createRoot(container as Element);
 
-// https://docs.sentry.io/platforms/javascript/configuration/filtering/#decluttering-sentry
-const sentryRecommendedIgnore = [
-  // Random plugins/extensions
-  'top.GLOBALS',
-  // See: http://blog.errorception.com/2012/03/tale-of-unfindable-js-error.html
-  'originalCreateNotification',
-  'canvas.contentDocument',
-  'MyApp_RemoveAllHighlights',
-  'http://tt.epicplay.com',
-  "Can't find variable: ZiteReader",
-  'jigsaw is not defined',
-  'ComboSearch is not defined',
-  'http://loading.retry.widdit.com/',
-  'atomicFindClose',
-  // Facebook borked
-  'fb_xd_fragment',
-  // ISP "optimizing" proxy - `Cache-Control: no-transform` seems to
-  // reduce this. (thanks @acdha)
-  // See http://stackoverflow.com/questions/4113268
-  'bmi_SafeAddOnload',
-  'EBCallBackMessageReceived',
-  // See http://toolbar.conduit.com/Developer/HtmlAndGadget/Methods/JSInjection.aspx
-  'conduitPage',
-];
-
-Sentry.init({
-  dsn: 'https://5e4d2c4b57ab409cb98d4c08b2014755@o4504288369836032.ingest.sentry.io/4504288371343360',
-  integrations: [new Sentry.BrowserTracing()],
-  tracesSampleRate: 0.3,
-  release: ONTIME_VERSION,
-  enabled: import.meta.env.PROD,
-  ignoreErrors: [...sentryRecommendedIgnore, /Unable to preload CSS/i, /dynamically imported module/i],
-  denyUrls: [/extensions\//i, /^chrome:\/\//i, /^chrome-extension:\/\//i],
-});
-
 root.render(
   <StrictMode>
     <App />

apps/client/src/sentry.config.ts

@@ -0,0 +1,25 @@
+// https://docs.sentry.io/platforms/javascript/configuration/filtering/#decluttering-sentry
+export const sentryRecommendedIgnore = [
+  // Random plugins/extensions
+  'top.GLOBALS',
+  // See: http://blog.errorception.com/2012/03/tale-of-unfindable-js-error.html
+  'originalCreateNotification',
+  'canvas.contentDocument',
+  'MyApp_RemoveAllHighlights',
+  'http://tt.epicplay.com',
+  "Can't find variable: ZiteReader",
+  'jigsaw is not defined',
+  'ComboSearch is not defined',
+  'http://loading.retry.widdit.com/',
+  'atomicFindClose',
+  // Facebook borked
+  'fb_xd_fragment',
+  // ISP "optimizing" proxy - `Cache-Control: no-transform` seems to
+  // reduce this. (thanks @acdha)
+  // See http://stackoverflow.com/questions/4113268
+  'bmi_SafeAddOnload',
+  'EBCallBackMessageReceived',
+  // See http://toolbar.conduit.com/Developer/HtmlAndGadget/Methods/JSInjection.aspx
+  'conduitPage',
+];
+export const sentryDsn = 'https://5e4d2c4b57ab409cb98d4c08b2014755@o4504288369836032.ingest.sentry.io/4504288371343360';

apps/client/src/theme/_ontimeColours.scss

@@ -7,6 +7,7 @@ $white-9: rgba(255, 255, 255, 0.09);
 $white-10: rgba(255, 255, 255, 0.10);
 $white-13: rgba(255, 255, 255, 0.13);
 $white-20: rgba(255, 255, 255, 0.20);
+$white-40: rgba(255, 255, 255, 0.40);
 $white-60: rgba(255, 255, 255, 0.60);
 $white-90: rgba(255, 255, 255, 0.90);
 

apps/client/src/theme/_ontimeStyles.scss

@@ -15,6 +15,7 @@ $ontime-color: #ff7597;
 $error-red: $red-500;
 $warning-orange: $orange-500;
 $opacity-disabled: 0.4;
+$active-red: $red-700;
 
 // playback colours
 $playback-start: $green-600;

apps/client/src/translation/TranslationProvider.tsx

@@ -6,6 +6,7 @@ import { langDe } from './languages/de';
 import { langEn } from './languages/en';
 import { langEs } from './languages/es';
 import { langFr } from './languages/fr';
+import { langHu } from './languages/hu';
 import { langIt } from './languages/it';
 import { langNo } from './languages/no';
 import { langPl } from './languages/pl';
@@ -16,6 +17,7 @@ const translationsList = {
   en: langEn,
   es: langEs,
   fr: langFr,
+  hu: langHu,
   it: langIt,
   de: langDe,
   no: langNo,

apps/client/src/translation/languages/de.ts

@@ -19,4 +19,8 @@ export const langDe: TranslationObject = {
   'countdown.to_start': 'Zeit bis zum Start',
   'countdown.waiting': 'Warten auf den Veranstaltungsbeginn',
   'countdown.overtime': 'überfällig',
+  'timeline.live': 'live',
+  'timeline.done': 'Beendet',
+  'timeline.due': 'fällig',
+  'timeline.followedby': 'Gefolgt von',
 };

apps/client/src/translation/languages/en.ts

@@ -17,6 +17,10 @@ export const langEn = {
   'countdown.to_start': 'Time to start',
   'countdown.waiting': 'Waiting for event start',
   'countdown.overtime': 'in overtime',
+  'timeline.live': 'live',
+  'timeline.done': 'done',
+  'timeline.due': 'due',
+  'timeline.followedby': 'Followed by',
 };
 
 export type TranslationObject = Record<keyof typeof langEn, string>;

apps/client/src/translation/languages/es.ts

@@ -19,4 +19,8 @@ export const langEs: TranslationObject = {
   'countdown.to_start': 'Tiempo para comenzar',
   'countdown.waiting': 'Esperando el inicio del evento',
   'countdown.overtime': 'en tiempo extra',
+  'timeline.live': 'live',
+  'timeline.done': 'Terminado',
+  'timeline.due': 'pendiente',
+  'timeline.followedby': 'Seguido por',
 };

apps/client/src/translation/languages/fr.ts

@@ -19,4 +19,8 @@ export const langFr: TranslationObject = {
   'countdown.to_start': 'Évènement commence dans',
   'countdown.waiting': 'En attente du début de l’évènement',
   'countdown.overtime': 'en dépassement',
+  'timeline.live': 'live',
+  'timeline.done': 'Terminé',
+  'timeline.due': 'dû',
+  'timeline.followedby': 'Suivi de',
 };

apps/client/src/translation/languages/hu.ts

@@ -0,0 +1,26 @@
+import { TranslationObject } from './en';
+
+export const langHu: TranslationObject = {
+  'common.expected_finish': 'Várható befejezés',
+  'common.minutes': 'perc',
+  'common.now': 'Most',
+  'common.next': 'Következő',
+  'common.public_message': 'Nyilvános közlemény',
+  'common.scheduled_start': 'Ütemezett kezdés',
+  'common.scheduled_end': 'Ütemezett befejezés',
+  'common.projected_start': 'Várható kezdés',
+  'common.projected_end': 'Várható befejezés',
+  'common.stage_timer': 'Színpadi időzítő',
+  'common.started_at': 'Kezdődött',
+  'common.time_now': 'Jelenlegi idő',
+  'countdown.ended': 'Esemény véget ért',
+  'countdown.running': 'Esemény folyamatban',
+  'countdown.select_event': 'Válassza ki a követendő eseményt',
+  'countdown.to_start': 'Idő kezdésig',
+  'countdown.waiting': 'Várakozás az esemény kezdetére',
+  'countdown.overtime': 'csúszik',
+  'timeline.live': 'élő',
+  'timeline.done': 'kész',
+  'timeline.due': 'esedékes',
+  'timeline.followedby': 'Követi',
+};

apps/client/src/translation/languages/it.ts

@@ -19,4 +19,8 @@ export const langIt: TranslationObject = {
   'countdown.to_start': 'Tempo alla partenza',
   'countdown.waiting': "In attesa dell'inizio dell'evento",
   'countdown.overtime': 'in ritardo',
+  'timeline.live': 'live',
+  'timeline.done': 'Terminato',
+  'timeline.due': 'previsto',
+  'timeline.followedby': 'Seguito da',
 };

apps/client/src/translation/languages/no.ts

@@ -19,4 +19,8 @@ export const langNo: TranslationObject = {
   'countdown.to_start': 'Tid til start',
   'countdown.waiting': 'Venter på start',
   'countdown.overtime': 'i overtiden',
+  'timeline.live': 'live',
+  'timeline.done': 'Ferdig',
+  'timeline.due': 'Venter',
+  'timeline.followedby': 'Etterfulgt av',
 };

apps/client/src/translation/languages/pl.ts

@@ -19,4 +19,8 @@ export const langPl: TranslationObject = {
   'countdown.to_start': 'Do rozpoczęcia',
   'countdown.waiting': 'Oczekiwanie na start',
   'countdown.overtime': 'ponad czasem',
+  'timeline.live': 'live',
+  'timeline.done': 'Zakończony',
+  'timeline.due': 'termin',
+  'timeline.followedby': 'Następnie',
 };

apps/client/src/translation/languages/pt.ts

@@ -19,4 +19,8 @@ export const langPt: TranslationObject = {
   'countdown.to_start': 'Tempo para iniciar',
   'countdown.waiting': 'Aguardando o início do evento',
   'countdown.overtime': 'em tempo extra',
+  'timeline.live': 'live',
+  'timeline.done': 'Concluído',
+  'timeline.due': 'Pendente',
+  'timeline.followedby': 'Seguido por',
 };

apps/client/src/translation/languages/sv.ts

@@ -19,4 +19,8 @@ export const langSv: TranslationObject = {
   'countdown.to_start': 'Tid till start',
   'countdown.waiting': 'Väntar på att evenemanget ska starta',
   'countdown.overtime': 'i övertid',
+  'timeline.live': 'live',
+  'timeline.done': 'Avslutad',
+  'timeline.due': 'Väntande',
+  'timeline.followedby': 'Följt av',
 };

apps/client/src/viewerConfig.ts

@@ -3,6 +3,7 @@ export const navigatorConstants = [
   { url: '/clock', label: 'Clock' },
   { url: '/minimal', label: 'Minimal Timer' },
   { url: '/backstage', label: 'Backstage' },
+  { url: '/timeline', label: 'Timeline (beta)' },
   { url: '/public', label: 'Public' },
   { url: '/lower', label: 'Lower Thirds' },
   { url: '/studio', label: 'Studio Clock' },

apps/electron/main.js

@@ -1,6 +1,7 @@
 const { app, BrowserWindow, Menu, globalShortcut, Tray, dialog, ipcMain, shell, Notification } = require('electron');
 const path = require('path');
 const electronConfig = require('./electron.config');
+const { version } = require('./package.json');
 const { getApplicationMenu } = require('./src/menu/applicationMenu.js');
 
 const env = process.env.NODE_ENV || 'production';
@@ -187,7 +188,9 @@ app.whenReady().then(() => {
         ? electronConfig.reactAppUrl.production(port)
         : electronConfig.reactAppUrl.development(port);
 
-      const template = getApplicationMenu(isMac, askToQuit, clientUrl);
+      const template = getApplicationMenu(isMac, askToQuit, clientUrl, `v${version}`, (path) => {
+        win.loadURL(`${clientUrl}/${path}`);
+      });
       const menu = Menu.buildFromTemplate(template);
       Menu.setApplicationMenu(menu);
 

apps/electron/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ontime",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "author": "Carlos Valente",
   "description": "Time keeping for live events",
   "repository": "https://github.com/cpvalente/ontime",
@@ -14,15 +14,14 @@
   "devDependencies": {
     "electron": "^31.2.0",
     "electron-builder": "^24.13.3",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "prettier": "^3.0.3",
+    "eslint": "catalog:",
+    "eslint-config-prettier": "catalog:",
+    "prettier": "catalog:",
     "wait-on": "^7.2.0"
   },
   "scripts": {
     "postinstall": "",
     "lint": "eslint . --quiet",
-    "lint-staged": "eslint",
     "dev": "wait-on http://localhost:3000 && cross-env NODE_ENV=development electron .",
     "dist-win": "electron-builder --publish=never --x64 --win",
     "dist-mac": "electron-builder --publish=never --mac",

apps/electron/src/menu/applicationMenu.js

@@ -4,7 +4,7 @@ const { shell } = require('electron');
  * @param {boolean} isMac - Whether the target platform is mac
  * @param {function} askToQuit - function for quitting process
  */
-function getApplicationMenu(isMac, askToQuit, urlBase) {
+function getApplicationMenu(isMac, askToQuit, urlBase, version, redirectWindow) {
   return [
     ...(isMac
       ? [
@@ -59,6 +59,19 @@ function getApplicationMenu(isMac, askToQuit, urlBase) {
         {
           label: 'Ontime Views (opens in browser)',
           submenu: [
+            {
+              label: 'Public',
+              click: async () => {
+                await shell.openExternal(`${urlBase}/public`);
+              },
+            },
+            {
+              label: 'Lower Thirds',
+              click: async () => {
+                await shell.openExternal(`${urlBase}/lower`);
+              },
+            },
+            { type: 'separator' },
             {
               label: 'Timer',
               accelerator: 'CmdOrCtrl+V',
@@ -85,15 +98,9 @@ function getApplicationMenu(isMac, askToQuit, urlBase) {
               },
             },
             {
-              label: 'Public',
+              label: 'Timeline (beta)',
               click: async () => {
-                await shell.openExternal(`${urlBase}/public`);
-              },
-            },
-            {
-              label: 'Lower Thirds',
-              click: async () => {
-                await shell.openExternal(`${urlBase}/lower`);
+                await shell.openExternal(`${urlBase}/timeline`);
               },
             },
             {
@@ -150,6 +157,14 @@ function getApplicationMenu(isMac, askToQuit, urlBase) {
     {
       role: 'help',
       submenu: [
+        {
+          label: 'About',
+          click: () => redirectWindow('editor?settings=about'),
+        },
+        {
+          label: version,
+          click: () => redirectWindow('editor?settings=about'),
+        },
         {
           label: 'See on github',
           click: async () => {

apps/server/package.json

@@ -2,7 +2,7 @@
   "name": "ontime-server",
   "type": "module",
   "main": "src/index.ts",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "exports": "./src/index.js",
   "dependencies": {
     "@googleapis/sheets": "^5.0.5",
@@ -27,41 +27,37 @@
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.17",
     "@types/multer": "^1.4.11",
-    "@types/node": "^20.14.10",
+    "@types/node": "catalog:",
     "@types/node-osc": "^6.0.2",
     "@types/websocket": "^1.0.5",
     "@types/ws": "^8.5.10",
-    "@typescript-eslint/eslint-plugin": "^v7.16.1",
-    "@typescript-eslint/parser": "^7.16.1",
+    "@typescript-eslint/eslint-plugin": "catalog:",
+    "@typescript-eslint/parser": "catalog:",
     "esbuild": "^0.19.10",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.1.3",
+    "eslint": "catalog:",
+    "eslint-plugin-prettier": "catalog:",
     "ontime-types": "workspace:*",
-    "prettier": "^3.3.1",
+    "prettier": "catalog:",
     "server-timing": "^3.3.3",
     "shx": "^0.3.4",
     "ts-essentials": "^9.4.1",
     "tsx": "^4.16.2",
-    "typescript": "^5.5.3",
+    "typescript": "catalog:",
     "vitest": "^1.6.0"
   },
   "scripts": {
     "addversion": "node -p \"'export const ONTIME_VERSION = ' + JSON.stringify(require('../../package.json').version) + ';'\" > src/ONTIME_VERSION.js",
-    "set:demoproject": "shx cp ../../demo-db/db.json src/preloaded-db/db.json",
-    "set:testproject": "shx cp ../../demo-db/db.json test-db/db.json",
-    "postinstall": "pnpm addversion && pnpm set:demoproject && pnpm set:testproject",
+    "postinstall": "pnpm addversion",
     "dev": "cross-env NODE_ENV=development tsx watch ./src/index.ts",
     "dev:inspect": "cross-env NODE_ENV=development tsx watch --inspect ./src/index.ts",
     "dev:test": "cross-env IS_TEST=true tsx ./src/index.ts",
-    "prebuild": "pnpm set:demoproject",
-    "build": "pnpm prebuild && esbuild src/app.ts --log-level=error --platform=node --format=cjs --bundle --minify --legal-comments=external --outfile=dist/index.cjs",
-    "build:electron": "pnpm prebuild && esbuild src/app.ts --log-level=error --platform=node --format=cjs --bundle --minify --legal-comments=external --outfile=dist/index.cjs",
-    "build:local": "pnpm prebuild && esbuild src/app.ts --log-level=error --platform=node --format=cjs --bundle --minify --legal-comments=external --outfile=dist/index.cjs",
-    "build:docker": "pnpm prebuild && esbuild src/index.ts --log-level=error --platform=node --format=cjs --minify --bundle --legal-comments=external --outfile=dist/docker.cjs",
-    "build:localdocker": "cross-env NODE_ENV=local pnpm prebuild && esbuild src/index.ts --log-level=error --platform=node --format=cjs --minify --bundle --legal-comments=external --outfile=dist/docker.cjs",
-    "build:debug": "pnpm prebuild && esbuild src/app.ts --platform=node --format=cjs --bundle --legal-comments=external --outfile=dist/index.cjs",
+    "build": "esbuild src/app.ts --log-level=error --platform=node --format=cjs --bundle --minify --legal-comments=external --drop-labels=DEV --outfile=dist/index.cjs",
+    "build:electron": "esbuild src/app.ts --log-level=error --platform=node --format=cjs --bundle --minify --legal-comments=external --drop-labels=DEV --outfile=dist/index.cjs",
+    "build:local": "esbuild src/app.ts --log-level=error --platform=node --format=cjs --bundle --minify --legal-comments=external --drop-labels=DEV --outfile=dist/index.cjs",
+    "build:docker": "esbuild src/index.ts --log-level=error --platform=node --format=cjs --minify --bundle --legal-comments=external --drop-labels=DEV --outfile=dist/docker.cjs",
+    "build:localdocker": "cross-env NODE_ENV=local esbuild src/index.ts --log-level=error --platform=node --format=cjs --minify --bundle --legal-comments=external --drop-labels=DEV --outfile=dist/docker.cjs",
+    "build:debug": "esbuild src/app.ts --platform=node --format=cjs --bundle --legal-comments=external --outfile=dist/index.cjs",
     "lint": "eslint . --quiet",
-    "lint-staged": "eslint",
     "test": "cross-env IS_TEST=true vitest",
     "test:pipeline": "cross-env IS_TEST=true vitest run",
     "typecheck": "tsc --noEmit",

apps/server/src/api-data/rundown/rundown.controller.ts

@@ -1,4 +1,11 @@
-import { ErrorResponse, MessageResponse, OntimeRundownEntry, RundownCached, RundownPaginated } from 'ontime-types';
+import {
+  ErrorResponse,
+  MessageResponse,
+  OntimeRundown,
+  OntimeRundownEntry,
+  RundownCached,
+  RundownPaginated,
+} from 'ontime-types';
 import { getErrorMessage } from 'ontime-utils';
 
 import { Request, Response } from 'express';
@@ -12,6 +19,7 @@ import {
   deleteEvent,
   editEvent,
   reorderEvent,
+  setFrozenState,
   swapEvents,
 } from '../../services/rundown-service/RundownService.js';
 import {
@@ -21,6 +29,11 @@ import {
   getRundown,
 } from '../../services/rundown-service/rundownUtils.js';
 
+export async function rundownGetAll(_req: Request, res: Response<OntimeRundown>) {
+  const rundown = getRundown();
+  res.json(rundown);
+}
+
 export async function rundownGetNormalised(_req: Request, res: Response<RundownCached>) {
   const cachedRundown = getNormalisedRundown();
   res.json(cachedRundown);
@@ -114,6 +127,17 @@ export async function rundownBatchPut(req: Request, res: Response<MessageRespons
   }
 }
 
+export async function rundownFrozenPost(req: Request, res: Response<MessageResponse | ErrorResponse>) {
+  try {
+    const { frozen } = req.body;
+    setFrozenState(frozen);
+    res.status(200).send({ message: 'Rundown frozen state updated.' });
+  } catch (error) {
+    const message = getErrorMessage(error);
+    res.status(400).send({ message });
+  }
+}
+
 export async function rundownReorder(req: Request, res: Response<OntimeRundownEntry | ErrorResponse>) {
   if (failEmptyObjects(req.body, res)) {
     return;

apps/server/src/api-data/rundown/rundown.middleware.ts

@@ -0,0 +1,9 @@
+import { eventStore } from '../../stores/EventStore.js';
+
+export const preventIfFrozen = function (req, res, next) {
+  if (eventStore.get('frozen')) {
+    res.status(403).send({ message: 'Rundown is frozen' });
+  } else {
+    next();
+  }
+};

apps/server/src/api-data/rundown/rundown.router.ts

@@ -5,6 +5,8 @@ import {
   rundownApplyDelay,
   rundownBatchPut,
   rundownDelete,
+  rundownFrozenPost,
+  rundownGetAll,
   rundownGetById,
   rundownGetNormalised,
   rundownGetPaginated,
@@ -17,27 +19,31 @@ import {
   paramsMustHaveEventId,
   rundownArrayOfIds,
   rundownBatchPutValidator,
+  rundownFrozenPostValidator,
   rundownGetPaginatedQueryParams,
   rundownPostValidator,
   rundownPutValidator,
   rundownReorderValidator,
   rundownSwapValidator,
 } from './rundown.validation.js';
+import { preventIfFrozen } from './rundown.middleware.js';
 
 export const router = express.Router();
 
-router.get('/', rundownGetPaginatedQueryParams, rundownGetPaginated); // not used in Ontime frontend
+router.get('/', rundownGetAll); // not used in Ontime frontend
+router.get('/paginated', rundownGetPaginatedQueryParams, rundownGetPaginated); // not used in Ontime frontend
 router.get('/normalised', rundownGetNormalised);
 router.get('/:eventId', paramsMustHaveEventId, rundownGetById); // not used in Ontime frontend
 
 router.post('/', rundownPostValidator, rundownPost);
+router.post('/frozen', rundownFrozenPostValidator, rundownFrozenPost);
 
 router.put('/', rundownPutValidator, rundownPut);
 router.put('/batch', rundownBatchPutValidator, rundownBatchPut);
 
-router.patch('/reorder/', rundownReorderValidator, rundownReorder);
-router.patch('/swap', rundownSwapValidator, rundownSwap);
+router.patch('/reorder/', rundownReorderValidator, preventIfFrozen, rundownReorder);
+router.patch('/swap', rundownSwapValidator, preventIfFrozen, rundownSwap);
 router.patch('/applydelay/:eventId', paramsMustHaveEventId, rundownApplyDelay);
 
-router.delete('/', rundownArrayOfIds, deletesEventById);
-router.delete('/all', rundownDelete);
+router.delete('/', rundownArrayOfIds, preventIfFrozen, deletesEventById);
+router.delete('/all', preventIfFrozen, rundownDelete);

apps/server/src/api-data/rundown/rundown.validation.ts

@@ -21,6 +21,15 @@ export const rundownPutValidator = [
   },
 ];
 
+export const rundownFrozenPostValidator = [
+  body('frozen').isBoolean().exists(),
+  (req: Request, res: Response, next: NextFunction) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) return res.status(422).json({ errors: errors.array() });
+    next();
+  },
+]
+
 export const rundownBatchPutValidator = [
   body('data').isObject().exists(),
   body('ids').isArray().exists(),

apps/server/src/api-integration/integration.controller.ts

@@ -54,18 +54,15 @@ const actionHandlers: Record<string, ActionHandler> = {
       if (typeof property !== 'string' || value === undefined) {
         throw new Error('Invalid property or value');
       }
-
       // parseProperty is async because of the data lock
-      parseProperty(property, value).then((newObjectProperty) => {
-        const key = Object.keys(newObjectProperty)[0] as keyof OntimeEvent;
-        shouldThrottle = willCauseRegeneration(key) || shouldThrottle;
-
-        if (patchEvent.custom && newObjectProperty.custom) {
-          Object.assign(patchEvent.custom, newObjectProperty.custom);
-        } else {
-          Object.assign(patchEvent, newObjectProperty);
-        }
-      });
+      const newObjectProperty = parseProperty(property, value);
+      const key = Object.keys(newObjectProperty)[0] as keyof OntimeEvent;
+      shouldThrottle = shouldThrottle || willCauseRegeneration(key);
+      if (patchEvent.custom && newObjectProperty.custom) {
+        Object.assign(patchEvent.custom, newObjectProperty.custom);
+      } else {
+        Object.assign(patchEvent, newObjectProperty);
+      }
     });
 
     if (shouldThrottle) {

apps/server/src/api-integration/integration.utils.ts

@@ -42,7 +42,7 @@ const propertyConversion = {
   timeEnd: (value: unknown) => clampDuration(coerceNumber(value)),
 };
 
-export async function parseProperty(property: string, value: unknown) {
+export function parseProperty(property: string, value: unknown) {
   if (property.startsWith('custom:')) {
     const customKey = property.split(':')[1].toLocaleLowerCase(); // all custom fields keys are lowercase
     const customFields = getDataProvider().getCustomFields();

apps/server/src/app.ts

@@ -19,7 +19,7 @@ import {
   resolvePublicDirectoy,
 } from './setup/index.js';
 import { ONTIME_VERSION } from './ONTIME_VERSION.js';
-import { consoleSuccess, consoleHighlight } from './utils/console.js';
+import { consoleSuccess, consoleHighlight, consoleError } from './utils/console.js';
 
 // Import Routers
 import { appRouter } from './api-data/index.js';
@@ -179,6 +179,10 @@ export const startServer = async (
     message: messageService.getState(),
     runtime: state.runtime,
     eventNow: state.eventNow,
+    currentBlock: {
+      block: null,
+      startedAt: null,
+    },
     publicEventNow: state.publicEventNow,
     eventNext: state.eventNext,
     publicEventNext: state.publicEventNext,
@@ -188,6 +192,7 @@ export const startServer = async (
       playback: SimplePlayback.Stop,
       direction: SimpleDirection.CountDown,
     },
+    frozen: false,
   });
 
   // initialise logging service, escalateErrorFn is only exists in electron
@@ -263,6 +268,7 @@ export const shutdown = async (exitCode = 0) => {
   // clear the restore file if it was a normal exit
   // 0 means it was a SIGNAL
   // 1 means crash -> keep the file
+  // 2 means dev crash -> do nothing
   // 99 means there was a shutdown request from the UI
   if (exitCode === 0 || exitCode === 99) {
     await restoreService.clear();
@@ -279,12 +285,18 @@ export const shutdown = async (exitCode = 0) => {
 process.on('exit', (code) => consoleHighlight(`Ontime shutdown with code: ${code}`));
 
 process.on('unhandledRejection', async (error) => {
+  if (!isProduction && error instanceof Error && error.stack) {
+    consoleError(error.stack);
+  }
   generateCrashReport(error);
   logger.crash(LogOrigin.Server, `Uncaught exception | ${error}`);
   await shutdown(1);
 });
 
 process.on('uncaughtException', async (error) => {
+  if (!isProduction && error instanceof Error && error.stack) {
+    consoleError(error.stack);
+  }
   generateCrashReport(error);
   logger.crash(LogOrigin.Server, `Uncaught exception | ${error}`);
   await shutdown(1);

apps/server/src/classes/data-provider/DataProvider.ts

@@ -13,24 +13,19 @@ import {
 import type { Low } from 'lowdb';
 import { JSONFilePreset } from 'lowdb/node';
 
-import { isProduction, isTest } from '../../setup/index.js';
+import { isTest } from '../../setup/index.js';
 import { isPath } from '../../utils/fileManagement.js';
-import { consoleError } from '../../utils/console.js';
 
 import { safeMerge } from './DataProvider.utils.js';
+import { shouldCrashDev } from '../../utils/development.js';
 
 type ReadonlyPromise<T> = Promise<Readonly<T>>;
 
 let db = {} as Low<DatabaseModel>;
 
 export async function initPersistence(filePath: string, fallbackData: DatabaseModel) {
-  if (!isProduction) {
-    if (!isPath(filePath)) {
-      consoleError(filePath);
-      consoleError(new Error('initPersistence should be called with a path').stack);
-      process.exit(0);
-    }
-  }
+  // eslint-disable-next-line no-unused-labels -- dev code path
+  DEV: shouldCrashDev(!isPath(filePath), 'initPersistence should be called with a path');
   const newDb = await JSONFilePreset<DatabaseModel>(filePath, fallbackData);
 
   // Read the database to initialize it

apps/server/src/preloaded-db/.keep

@@ -1 +0,0 @@
-This directory holds the demo file shipped with Ontime

apps/server/src/services/EventTimer.ts

@@ -1,21 +1,21 @@
-import { OntimeEvent } from 'ontime-types';
-
 import * as runtimeState from '../stores/runtimeState.js';
 import type { UpdateResult } from '../stores/runtimeState.js';
 import { timerConfig } from '../config/config.js';
 
+type UpdateCallbackFn = (updateResult: UpdateResult) => void;
+
 /**
  * Service manages Ontime's main timer
  */
-export class TimerService {
+export class EventTimer {
   private readonly _interval: NodeJS.Timeout;
   /** how often we recalculate */
   static _refreshInterval: number;
 
   /** when timer will be finished */
-  private endCallback: NodeJS.Timeout;
+  private endCallback: NodeJS.Timeout | undefined = undefined;
 
-  private onUpdateCallback: (updateResult: UpdateResult) => void;
+  private onUpdateCallback: UpdateCallbackFn | undefined = undefined;
 
   /**
    * @constructor
@@ -23,17 +23,18 @@ export class TimerService {
    * @param {number} [timerConfig.updateInterval] how often we update the socket
    * @param {function} [timerConfig.onUpdateCallback] how often we update the socket
    */
-  constructor(timerConfig: {
-    refresh: number;
-    updateInterval: number;
-    onUpdateCallback: (updateResult: UpdateResult) => void;
-  }) {
-    TimerService._refreshInterval = timerConfig.refresh;
-
-    this.onUpdateCallback = timerConfig.onUpdateCallback;
+  constructor(timerConfig: { refresh: number; updateInterval: number }) {
+    EventTimer._refreshInterval = timerConfig.refresh;
     this._interval = setInterval(() => {
       this.update();
-    }, TimerService._refreshInterval);
+    }, EventTimer._refreshInterval);
+  }
+
+  /**
+   * Allows setting a callback for when the timer updates
+   */
+  setOnUpdateCallback(callback: (updateResult: UpdateResult) => void) {
+    this.onUpdateCallback = callback;
   }
 
   start() {
@@ -69,7 +70,6 @@ export class TimerService {
 
   /**
    * Adds time to running timer by given amount
-   * @param {number} amount
    */
   addTime(amount: number): boolean {
     if (!runtimeState.addTime(amount)) {
@@ -79,6 +79,12 @@ export class TimerService {
     // renew end callback
     clearTimeout(this.endCallback);
     const state = runtimeState.getState();
+    // eslint-disable-next-line no-unused-labels -- dev code path
+    DEV: {
+      if (state.timer.expectedFinish === null) {
+        throw new Error('TimerService.addTime: expectedFinish is negative');
+      }
+    }
     this.endCallback = setTimeout(() => this.update(), state.timer.expectedFinish);
     return true;
   }
@@ -89,15 +95,7 @@ export class TimerService {
   update() {
     const updateResult = runtimeState.update();
     // pass the result to the parent
-    this.onUpdateCallback(updateResult);
-  }
-
-  /**
-   * Loads roll information into timer service
-   * @param {OntimeEvent[]} rundown -- list of events to run
-   */
-  roll(rundown: OntimeEvent[]) {
-    runtimeState.roll(rundown);
+    this.onUpdateCallback?.(updateResult);
   }
 
   shutdown() {

apps/server/src/services/RestoreService.ts

@@ -11,6 +11,7 @@ export type RestorePoint = {
   addedTime: number;
   pausedAt: MaybeNumber;
   firstStart: MaybeNumber;
+  blockStartAt: MaybeNumber;
 };
 
 /**
@@ -45,7 +46,11 @@ export function isRestorePoint(obj: unknown): obj is RestorePoint {
     return false;
   }
 
-  if (typeof restorePoint.firstStart !== 'number' && restorePoint.pausedAt !== null) {
+  if (typeof restorePoint.firstStart !== 'number' && restorePoint.firstStart !== null) {
+    return false;
+  }
+
+  if (typeof restorePoint.blockStartAt !== 'number' && restorePoint.blockStartAt !== null) {
     return false;
   }
 

apps/server/src/services/__tests__/RestoreService.test.ts

@@ -14,6 +14,7 @@ describe('isRestorePoint()', () => {
       addedTime: 2,
       pausedAt: 3,
       firstStart: 1,
+      blockStartAt: 10,
     };
     expect(isRestorePoint(restorePoint)).toBe(true);
 
@@ -24,6 +25,7 @@ describe('isRestorePoint()', () => {
       addedTime: 0,
       pausedAt: null,
       firstStart: 1,
+      blockStartAt: null,
     };
     expect(isRestorePoint(restorePoint)).toBe(true);
   });
@@ -36,6 +38,7 @@ describe('isRestorePoint()', () => {
         startedAt: null,
         addedTime: 0,
         pausedAt: null,
+        blockStartAt: 10,
       };
       expect(isRestorePoint(restorePoint)).toBe(false);
     });
@@ -45,6 +48,7 @@ describe('isRestorePoint()', () => {
         startedAt: null,
         addedTime: 0,
         pausedAt: null,
+        blockStartAt: 10,
       };
       expect(isRestorePoint(restorePoint)).toBe(false);
     });
@@ -55,6 +59,7 @@ describe('isRestorePoint()', () => {
         startedAt: 'testing',
         addedTime: 0,
         pausedAt: null,
+        blockStartAt: 10,
       };
       expect(isRestorePoint(restorePoint)).toBe(false);
     });
@@ -71,6 +76,7 @@ describe('RestoreService()', () => {
         addedTime: 5678,
         pausedAt: 9087,
         firstStart: 1234,
+        blockStartAt: 1652,
       };
 
       const restoreService = new RestoreService('/path/to/restore/file');
@@ -88,6 +94,7 @@ describe('RestoreService()', () => {
         addedTime: 0,
         pausedAt: null,
         firstStart: 1234,
+        blockStartAt: null,
       };
 
       const restoreService = new RestoreService('/path/to/restore/file');
@@ -105,6 +112,7 @@ describe('RestoreService()', () => {
         addedTime: 1234,
         pausedAt: 1234,
         firstStart: 1234,
+        blockStartAt: 10,
       };
 
       const restoreService = new RestoreService('/path/to/restore/file');
@@ -124,6 +132,7 @@ describe('RestoreService()', () => {
         addedTime: 1234,
         pausedAt: 1234,
         firstStart: 1234,
+        blockStartAt: null,
       };
 
       const restoreService = new RestoreService('/path/to/restore/file');

apps/server/src/services/__tests__/rollUtils.test.ts

@@ -0,0 +1,448 @@
+import { OntimeEvent, SupportedEvent } from 'ontime-types';
+import { MILLIS_PER_HOUR, MILLIS_PER_MINUTE } from 'ontime-utils';
+
+import { loadRoll } from '../rollUtils.js';
+
+const baseEvent = {
+  type: SupportedEvent.Event,
+  skip: false,
+};
+
+function makeOntimeEvent(patch: Partial<OntimeEvent>): OntimeEvent {
+  return {
+    ...baseEvent,
+    ...patch,
+  } as OntimeEvent;
+}
+
+function prepareTimedEvents(events: Partial<OntimeEvent>[]): OntimeEvent[] {
+  return events.map(makeOntimeEvent);
+}
+
+describe('loadRoll()', () => {
+  const eventlist = [
+    {
+      id: '1',
+      timeStart: 5,
+      timeEnd: 10,
+      isPublic: false,
+    },
+    {
+      id: '2',
+      timeStart: 10,
+      timeEnd: 20,
+      isPublic: false,
+    },
+    {
+      id: '3',
+      timeStart: 20,
+      timeEnd: 30,
+      isPublic: false,
+    },
+    {
+      id: '4',
+      timeStart: 30,
+      timeEnd: 40,
+      isPublic: false,
+    },
+    {
+      id: '5',
+      timeStart: 40,
+      timeEnd: 50,
+      isPublic: true,
+    },
+    {
+      id: '6',
+      timeStart: 50,
+      timeEnd: 60,
+      isPublic: false,
+    },
+    {
+      id: '7',
+      timeStart: 60,
+      timeEnd: 70,
+      isPublic: true,
+    },
+    {
+      id: '8',
+      timeStart: 70,
+      timeEnd: 80,
+      isPublic: false,
+    },
+  ];
+  const timedEvents = prepareTimedEvents(eventlist);
+
+  it('should roll to the day after if timer is at 100', () => {
+    const now = 100;
+    const expected = {
+      event: timedEvents[0],
+      index: 0,
+      isPending: true,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should be waiting to start if timer is at 0', () => {
+    const now = 0;
+    const expected = {
+      event: timedEvents[0],
+      index: 0,
+      isPending: true,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should start the first event if timer is at 5', () => {
+    const now = 5;
+    const expected = {
+      event: timedEvents[0],
+      index: 0,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should start the second event if timer is at 15', () => {
+    const now = 15;
+    const expected = {
+      event: timedEvents[1],
+      index: 1,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should start the third event if timer is at 10', () => {
+    const now = 20;
+    const expected = {
+      event: timedEvents[2],
+      index: 2,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should start the fifth event if timer is at 49', () => {
+    const now = 49;
+    const expected = {
+      event: timedEvents[4],
+      index: 4,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should start the seventh event if timer is at 63', () => {
+    const now = 63;
+    const expected = {
+      event: timedEvents[6],
+      index: 6,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should start the eight event if timer is at 75', () => {
+    const now = 75;
+    const expected = {
+      event: timedEvents[7],
+      index: 7,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+});
+
+describe('loadRoll() handle edge cases with midnight', () => {
+  it('should find an event that crosses midnight', () => {
+    const now = 23 * MILLIS_PER_HOUR;
+    const eventlist = [
+      {
+        id: '0',
+        timeStart: 9 * MILLIS_PER_HOUR,
+        timeEnd: 10 * MILLIS_PER_HOUR,
+        isPublic: true,
+      },
+      {
+        id: '1',
+        timeStart: 20 * MILLIS_PER_HOUR,
+        timeEnd: 22 * MILLIS_PER_HOUR,
+        isPublic: true,
+      },
+      {
+        id: '2',
+        timeStart: 22 * MILLIS_PER_HOUR,
+        timeEnd: 1 * MILLIS_PER_HOUR,
+        isPublic: true,
+      },
+      {
+        id: '3',
+        timeStart: 1 * MILLIS_PER_HOUR,
+        timeEnd: 1 * MILLIS_PER_HOUR + 10 * MILLIS_PER_MINUTE,
+        isPublic: true,
+      },
+      {
+        id: '4',
+        timeStart: 1 * MILLIS_PER_HOUR,
+        timeEnd: 2 * MILLIS_PER_HOUR,
+        isPublic: true,
+      },
+    ];
+    const timedEvents = prepareTimedEvents(eventlist);
+
+    const expected = {
+      event: timedEvents[2],
+      index: 2,
+    };
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should not skip to the second day', () => {
+    /**
+     * NOTE: this is a potentially contentious decision
+     *
+     * The idea here is that it makes no sense for us to jump to the second / third day on activating roll
+     * if the user wants to skip a portion of the rundown, they can manually jump to the event and activate roll
+     *
+     * On our side, this simplifies logic and makes behaviour more predictable
+     */
+    const now = 8 * MILLIS_PER_HOUR;
+    const eventlist = [
+      {
+        id: '0',
+        timeStart: 21 * MILLIS_PER_HOUR,
+        timeEnd: 22 * MILLIS_PER_HOUR,
+      },
+      {
+        id: '1',
+        timeStart: 22 * MILLIS_PER_HOUR,
+        timeEnd: 3 * MILLIS_PER_HOUR,
+      },
+      {
+        id: '2',
+        timeStart: 3 * MILLIS_PER_HOUR,
+        timeEnd: 10 * MILLIS_PER_HOUR,
+      },
+    ];
+    const timedEvents = prepareTimedEvents(eventlist);
+    const expected = {
+      event: timedEvents[0],
+      index: 0,
+      isPending: true,
+    };
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+});
+
+describe('loadRoll() handle edge cases with before and after start', () => {
+  it('should prepare first event, if we are not yet in the rundown start', () => {
+    const now = 7 * MILLIS_PER_HOUR;
+    const singleEventList = [
+      makeOntimeEvent({
+        id: '1',
+        timeStart: 10 * MILLIS_PER_HOUR,
+        timeEnd: 11 * MILLIS_PER_HOUR,
+        isPublic: true,
+      }),
+    ];
+
+    const expected = {
+      event: singleEventList[0],
+      index: 0,
+      isPending: true,
+    };
+    const state = loadRoll(singleEventList, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should prepare first event, if we are over the rundown end', () => {
+    const now = 18 * MILLIS_PER_HOUR;
+    const singleEventList = [
+      makeOntimeEvent({
+        id: '1',
+        timeStart: 10 * MILLIS_PER_HOUR,
+        timeEnd: 11 * MILLIS_PER_HOUR,
+        isPublic: true,
+      }),
+    ];
+
+    const expected = {
+      event: singleEventList[0],
+      index: 0,
+      isPending: true,
+    };
+    const state = loadRoll(singleEventList, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('should account for a rundown that goes through midnight', () => {
+    const now = 1 * MILLIS_PER_HOUR;
+    const singleEventList = [
+      makeOntimeEvent({
+        id: '1',
+        timeStart: 10 * MILLIS_PER_HOUR,
+        timeEnd: 2 * MILLIS_PER_HOUR,
+        isPublic: true,
+      }),
+    ];
+    const expected = {
+      event: singleEventList[0],
+      index: 0,
+    };
+    const state = loadRoll(singleEventList, now);
+    expect(state.isPending).toBeUndefined();
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('loads upcoming event while waiting to roll', () => {
+    const now = 6000; // 00:01
+    const singleEventList = [
+      makeOntimeEvent({
+        id: '1',
+        timeStart: 72000000, // 20:00
+        timeEnd: 72010000, // 20:10
+        isPublic: true,
+      }),
+    ];
+    const expected = {
+      event: singleEventList[0],
+      index: 0,
+      isPending: true,
+    };
+    const state = loadRoll(singleEventList, now);
+    expect(state).toStrictEqual(expected);
+  });
+});
+
+describe('loadRoll() test that roll behaviour with overlapping times', () => {
+  const eventlist = [
+    {
+      id: '1',
+      timeStart: 10,
+      timeEnd: 10,
+      isPublic: false,
+    },
+    {
+      id: '2',
+      timeStart: 10,
+      timeEnd: 20,
+      isPublic: true,
+    },
+    {
+      id: '3',
+      timeStart: 10,
+      timeEnd: 30,
+      isPublic: false,
+    },
+  ];
+  const timedEvents = prepareTimedEvents(eventlist);
+
+  it('if timer is at 0', () => {
+    const now = 0;
+    const expected = {
+      event: timedEvents[0],
+      index: 0,
+      isPending: true,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('if timer is at 10, it ignores events with 0 duration', () => {
+    const now = 10;
+    const expected = {
+      event: timedEvents[1],
+      index: 1,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('if timer is at 15', () => {
+    const now = 15;
+    const expected = {
+      event: timedEvents[1],
+      index: 1,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('if timer is at 20', () => {
+    const now = 20;
+    const expected = {
+      event: timedEvents[2],
+      index: 2,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('if timer is at 25', () => {
+    const now = 25;
+    const expected = {
+      event: timedEvents[2],
+      index: 2,
+    };
+
+    const state = loadRoll(timedEvents, now);
+    expect(state).toStrictEqual(expected);
+  });
+});
+
+// issue #58
+describe('loadRoll() test that roll behaviour multi day event edge cases', () => {
+  it('should recognise a playing event where its schedule spans over midnight', () => {
+    const now = 66600000; // 19:30
+    const eventlist = [
+      makeOntimeEvent({
+        id: '1',
+        timeStart: 66000000, // 19:20
+        timeEnd: 54600000, // 16:10
+        isPublic: false,
+      }),
+    ];
+    const expected = {
+      event: eventlist[0],
+      index: 0,
+    };
+
+    const state = loadRoll(eventlist, now);
+    expect(state).toStrictEqual(expected);
+  });
+
+  it('if the start time is the day after end time, and both are later than now', () => {
+    const now = 66840000; // 19:34
+    const eventlist = [
+      makeOntimeEvent({
+        id: '1',
+        timeStart: 67200000, // 19:40
+        timeEnd: 66900000, // 19:35
+        isPublic: false,
+      }),
+    ];
+    const expected = {
+      event: eventlist[0],
+      index: 0,
+    };
+
+    const state = loadRoll(eventlist, now);
+    expect(state).toStrictEqual(expected);
+  });
+});

apps/server/src/services/__tests__/timerUtils.test.ts

@@ -1,16 +1,14 @@
 import { MILLIS_PER_HOUR, dayInMs, millisToString } from 'ontime-utils';
-import { EndAction, OntimeEvent, Playback, TimeStrategy, TimerPhase, TimerType } from 'ontime-types';
+import { EndAction, Playback, TimeStrategy, TimerPhase, TimerType } from 'ontime-types';
 
 import {
   getCurrent,
   getExpectedFinish,
-  getRollTimers,
   getRuntimeOffset,
   getTimerPhase,
   getTotalDuration,
   normaliseEndTime,
   skippedOutOfEvent,
-  updateRoll,
 } from '../timerUtils.js';
 import { RuntimeState } from '../../stores/runtimeState.js';
 
@@ -697,520 +695,6 @@ describe('skippedOutOfEvent()', () => {
   });
 });
 
-describe('getRollTimers()', () => {
-  const eventlist: Partial<OntimeEvent>[] = [
-    {
-      id: '1',
-      timeStart: 5,
-      timeEnd: 10,
-      isPublic: false,
-    },
-    {
-      id: '2',
-      timeStart: 10,
-      timeEnd: 20,
-      isPublic: false,
-    },
-    {
-      id: '3',
-      timeStart: 20,
-      timeEnd: 30,
-      isPublic: false,
-    },
-    {
-      id: '4',
-      timeStart: 30,
-      timeEnd: 40,
-      isPublic: false,
-    },
-    {
-      id: '5',
-      timeStart: 40,
-      timeEnd: 50,
-      isPublic: true,
-    },
-    {
-      id: '6',
-      timeStart: 50,
-      timeEnd: 60,
-      isPublic: false,
-    },
-    {
-      id: '7',
-      timeStart: 60,
-      timeEnd: 70,
-      isPublic: true,
-    },
-    {
-      id: '8',
-      timeStart: 70,
-      timeEnd: 80,
-      isPublic: false,
-    },
-  ];
-
-  it('if timer is at 0', () => {
-    const now = 0;
-    const expected = {
-      nowIndex: null,
-      nowId: null,
-      publicIndex: null,
-      nextIndex: 0,
-      publicNextIndex: 4,
-      timeToNext: 5,
-      nextEvent: eventlist[0],
-      nextPublicEvent: eventlist[4],
-      currentEvent: null,
-      currentPublicEvent: null,
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 5', () => {
-    const now = 5;
-    const expected = {
-      nowIndex: 0,
-      nowId: eventlist[0].id,
-      publicIndex: null,
-      nextIndex: 1,
-      publicNextIndex: 4,
-      timeToNext: 5,
-      nextEvent: eventlist[1],
-      nextPublicEvent: eventlist[4],
-      currentEvent: eventlist[0],
-      currentPublicEvent: null,
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 15', () => {
-    const now = 15;
-    const expected = {
-      nowIndex: 1,
-      nowId: eventlist[1].id,
-      publicIndex: null,
-      nextIndex: 2,
-      publicNextIndex: 4,
-      timeToNext: 5,
-      nextEvent: eventlist[2],
-      nextPublicEvent: eventlist[4],
-      currentEvent: eventlist[1],
-      currentPublicEvent: null,
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 20', () => {
-    const now = 20;
-    const expected = {
-      nowIndex: 2,
-      nowId: eventlist[2].id,
-      publicIndex: null,
-      nextIndex: 3,
-      publicNextIndex: 4,
-      timeToNext: 10,
-      nextEvent: eventlist[3],
-      nextPublicEvent: eventlist[4],
-      currentEvent: eventlist[2],
-      currentPublicEvent: null,
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 49', () => {
-    const now = 49;
-    const expected = {
-      nowIndex: 4,
-      nowId: eventlist[4].id,
-      publicIndex: 4,
-      nextIndex: 5,
-      publicNextIndex: 6,
-      timeToNext: 1,
-      nextEvent: eventlist[5],
-      nextPublicEvent: eventlist[6],
-      currentEvent: eventlist[4],
-      currentPublicEvent: eventlist[4],
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 63', () => {
-    const now = 63;
-    const expected = {
-      nowIndex: 6,
-      nowId: eventlist[6].id,
-      publicIndex: 6,
-      nextIndex: 7,
-      publicNextIndex: null,
-      timeToNext: 7,
-      nextEvent: eventlist[7],
-      nextPublicEvent: null,
-      currentEvent: eventlist[6],
-      currentPublicEvent: eventlist[6],
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 75', () => {
-    const now = 75;
-    const expected = {
-      nowIndex: 7,
-      nowId: eventlist[7].id,
-      publicIndex: 6,
-      nextIndex: null,
-      publicNextIndex: null,
-      timeToNext: null,
-      nextEvent: null,
-      nextPublicEvent: null,
-      currentEvent: eventlist[7],
-      currentPublicEvent: eventlist[6],
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 100 we roll to day after', () => {
-    const now = 100;
-    const expected = {
-      nowIndex: null,
-      nowId: null,
-      publicIndex: null,
-      nextIndex: 0,
-      publicNextIndex: 4,
-      timeToNext: dayInMs - now + eventlist[0].timeStart!,
-      nextEvent: eventlist[0],
-      nextPublicEvent: eventlist[4],
-      currentEvent: null,
-      currentPublicEvent: null,
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('handles rolls to next day with real values', () => {
-    const singleEventList: Partial<OntimeEvent>[] = [
-      {
-        id: '1',
-        timeStart: 36000000, // 10:00
-        timeEnd: 39600000, // 11:00
-        isPublic: true,
-      },
-    ];
-    const now = 64800000; // 18:00
-    const expected = {
-      nowIndex: null,
-      nowId: null,
-      publicIndex: null,
-      nextIndex: 0,
-      publicNextIndex: 0,
-      timeToNext: dayInMs - now + singleEventList[0].timeStart!,
-      nextEvent: singleEventList[0],
-      nextPublicEvent: singleEventList[0],
-      currentEvent: null,
-      currentPublicEvent: null,
-    };
-    const state = getRollTimers(singleEventList as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('handles rolls to next day with real values', () => {
-    const singleEventList: Partial<OntimeEvent>[] = [
-      {
-        id: '1',
-        timeStart: 36000000, // 10:00
-        timeEnd: 3600000, // 01:00
-        isPublic: true,
-      },
-    ];
-    const now = 60000; // 00:01
-    const expected = {
-      nowIndex: 0,
-      nowId: singleEventList[0].id,
-      publicIndex: 0,
-      nextIndex: null,
-      publicNextIndex: null,
-      timeToNext: null,
-      nextEvent: null,
-      nextPublicEvent: null,
-      currentEvent: singleEventList[0],
-      currentPublicEvent: singleEventList[0],
-    };
-    const state = getRollTimers(singleEventList as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-  it('handles rolls to next day with real values', () => {
-    const singleEventList: Partial<OntimeEvent>[] = [
-      {
-        id: '1',
-        timeStart: 36000000, // 10:00
-        timeEnd: 3600000, // 01:00
-        isPublic: true,
-      },
-    ];
-    const now = 60000; // 00:01
-    const expected = {
-      nowIndex: 0,
-      nowId: singleEventList[0].id,
-      publicIndex: 0,
-      nextIndex: null,
-      publicNextIndex: null,
-      timeToNext: null,
-      nextEvent: null,
-      nextPublicEvent: null,
-      currentEvent: singleEventList[0],
-      currentPublicEvent: singleEventList[0],
-    };
-    const state = getRollTimers(singleEventList as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('loads upcoming event while waiting to roll', () => {
-    const singleEventList: Partial<OntimeEvent>[] = [
-      {
-        id: '1',
-        timeStart: 72000000, // 20:00
-        timeEnd: 72010000, // 20:10
-        isPublic: true,
-      },
-    ];
-    const now = 6000; // 00:01
-    const expected = {
-      nowIndex: null,
-      nowId: null,
-      publicIndex: null,
-      nextIndex: 0,
-      publicNextIndex: 0,
-      timeToNext: 72000000 - now,
-      nextEvent: singleEventList[0],
-      nextPublicEvent: singleEventList[0],
-      currentEvent: null,
-      currentPublicEvent: null,
-    };
-    const state = getRollTimers(singleEventList as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('handles roll that goes over midnight', () => {
-    const singleEventList: Partial<OntimeEvent>[] = [
-      {
-        id: '1',
-        timeStart: 72000000, // 20:00
-        timeEnd: 60000, // 00:10
-        isPublic: true,
-      },
-    ];
-    const now = 6000; // 00:01
-    const expected = {
-      nowIndex: 0,
-      nowId: singleEventList[0].id,
-      publicIndex: 0,
-      nextIndex: null,
-      publicNextIndex: null,
-      timeToNext: null,
-      nextEvent: null,
-      nextPublicEvent: null,
-      currentEvent: singleEventList[0],
-      currentPublicEvent: singleEventList[0],
-    };
-    const state = getRollTimers(singleEventList as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-});
-
-describe('getRollTimers() test that roll behaviour with overlapping times', () => {
-  const eventlist: Partial<OntimeEvent>[] = [
-    {
-      id: '1',
-      timeStart: 10,
-      timeEnd: 10,
-      isPublic: false,
-    },
-    {
-      id: '2',
-      timeStart: 10,
-      timeEnd: 20,
-      isPublic: true,
-    },
-    {
-      id: '3',
-      timeStart: 10,
-      timeEnd: 30,
-      isPublic: false,
-    },
-  ];
-
-  it('if timer is at 0', () => {
-    const now = 0;
-    const expected = {
-      nowIndex: null,
-      nowId: null,
-      publicIndex: null,
-      nextIndex: 0,
-      publicNextIndex: 1,
-      timeToNext: 10,
-      nextEvent: eventlist[0],
-      nextPublicEvent: eventlist[1],
-      currentEvent: null,
-      currentPublicEvent: null,
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 10', () => {
-    const now = 10;
-    const expected = {
-      nowIndex: 1,
-      nowId: eventlist[1].id,
-      publicIndex: 1,
-      nextIndex: 2,
-      publicNextIndex: null,
-      timeToNext: 0,
-      nextEvent: eventlist[2],
-      nextPublicEvent: null,
-      currentEvent: eventlist[1],
-      currentPublicEvent: eventlist[1],
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 15', () => {
-    const now = 15;
-    const expected = {
-      nowIndex: 1,
-      nowId: eventlist[1].id,
-      publicIndex: 1,
-      nextIndex: 2,
-      publicNextIndex: null,
-      timeToNext: -5,
-      nextEvent: eventlist[2],
-      nextPublicEvent: null,
-      currentEvent: eventlist[1],
-      currentPublicEvent: eventlist[1],
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 20', () => {
-    const now = 20;
-    const expected = {
-      nowIndex: 2,
-      nowId: eventlist[2].id,
-      publicIndex: 1,
-      nextIndex: null,
-      publicNextIndex: null,
-      timeToNext: null,
-      nextEvent: null,
-      nextPublicEvent: null,
-      currentEvent: eventlist[2],
-      currentPublicEvent: eventlist[1],
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if timer is at 25', () => {
-    const now = 25;
-    const expected = {
-      nowIndex: 2,
-      nowId: eventlist[2].id,
-      publicIndex: 1,
-      nextIndex: null,
-      publicNextIndex: null,
-      timeToNext: null,
-      nextEvent: null,
-      nextPublicEvent: null,
-      currentEvent: eventlist[2],
-      currentPublicEvent: eventlist[1],
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-});
-
-// issue #58
-describe('getRollTimers() test that roll behaviour multi day event edge cases', () => {
-  it('if the start time is the day after end time, and start time is earlier than now', () => {
-    const now = 66600000; // 19:30
-    const eventlist: Partial<OntimeEvent>[] = [
-      {
-        id: '1',
-        timeStart: 66000000, // 19:20
-        timeEnd: 54600000, // 16:10
-        isPublic: false,
-      },
-    ];
-    const expected = {
-      nowIndex: 0,
-      nowId: '1',
-      publicIndex: null,
-      nextIndex: null,
-      publicNextIndex: null,
-      timeToNext: null,
-      nextEvent: null,
-      nextPublicEvent: null,
-      currentEvent: eventlist[0],
-      currentPublicEvent: null,
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-
-  it('if the start time is the day after end time, and both are later than now', () => {
-    const now = 66840000; // 19:34
-    const eventlist: Partial<OntimeEvent>[] = [
-      {
-        id: '1',
-        timeStart: 67200000, // 19:40
-        timeEnd: 66900000, // 19:35
-        isPublic: false,
-      },
-    ];
-    const expected = {
-      currentEvent: {
-        id: '1',
-        isPublic: false,
-        timeEnd: 66900000,
-        timeStart: 67200000,
-      },
-      currentPublicEvent: null,
-      nextEvent: null,
-      nextIndex: null,
-      nextPublicEvent: null,
-      nowId: '1',
-      nowIndex: 0,
-      publicIndex: null,
-      publicNextIndex: null,
-      timeToNext: null,
-    };
-
-    const state = getRollTimers(eventlist as OntimeEvent[], now);
-    expect(state).toStrictEqual(expected);
-  });
-});
-
 test('normaliseEndTime()', () => {
   const t1 = {
     start: 10,
@@ -1237,196 +721,6 @@ test('normaliseEndTime()', () => {
   expect(normaliseEndTime(t3.start, t3.end)).toBe(t3_expected);
 });
 
-describe('updateRoll()', () => {
-  it('it updates running events correctly', () => {
-    const timers = {
-      eventNow: {
-        id: '1',
-      },
-      clock: 11,
-      timer: {
-        current: 10,
-        expectedFinish: 100,
-        secondaryTimer: null,
-        startedAt: 1,
-      },
-      _timer: {
-        secondaryTarget: null,
-      },
-    } as RuntimeState;
-
-    const expected = {
-      updatedTimer: 100 - 11,
-      updatedSecondaryTimer: null, // usually clock - expectedFinish
-      doRollLoad: false,
-      isFinished: false,
-    };
-
-    expect(updateRoll(timers)).toStrictEqual(expected);
-
-    // test that it can jump time
-    timers.timer.expectedFinish = 1000;
-    timers.clock = 600;
-    expected.updatedTimer = 1000 - 600;
-
-    expect(updateRoll(timers)).toStrictEqual(expected);
-  });
-
-  it('it updates secondary timer', () => {
-    const timers = {
-      eventNow: null,
-      clock: 11,
-      timer: {
-        current: null,
-        expectedFinish: null,
-        secondaryTimer: 1,
-      },
-      _timer: {
-        secondaryTarget: 15,
-      },
-    } as RuntimeState;
-
-    const expected = {
-      updatedTimer: null,
-      updatedSecondaryTimer: 15 - 11, // countdown to secondary
-      doRollLoad: false,
-      isFinished: false,
-    };
-
-    expect(updateRoll(timers)).toStrictEqual(expected);
-  });
-
-  it('flags an event end', () => {
-    const timers = {
-      eventNow: {
-        id: '1',
-      },
-      clock: 12,
-      timer: {
-        startedAt: 0,
-        current: 10,
-        expectedFinish: 11,
-        secondaryTimer: null,
-      },
-      _timer: {
-        secondaryTarget: null,
-      },
-    } as RuntimeState;
-
-    const expected = {
-      updatedTimer: -1,
-      updatedSecondaryTimer: null,
-      doRollLoad: true,
-      isFinished: true,
-    };
-
-    expect(updateRoll(timers)).toStrictEqual(expected);
-  });
-
-  it('secondary events do not trigger event ends', () => {
-    const timers = {
-      eventNow: null,
-      clock: 16,
-      timer: {
-        startedAt: null,
-        current: null,
-        expectedFinish: null,
-        secondaryTimer: 1,
-      },
-      _timer: {
-        secondaryTarget: 15,
-      },
-    } as RuntimeState;
-
-    const expected = {
-      updatedTimer: null,
-      updatedSecondaryTimer: -1,
-      doRollLoad: true,
-      isFinished: false,
-    };
-
-    expect(updateRoll(timers)).toStrictEqual(expected);
-  });
-
-  it('when a secondary timer is finished, it prompts for new event load', () => {
-    const timers = {
-      eventNow: null,
-      clock: 15,
-      timer: {
-        current: null,
-        expectedFinish: null,
-        secondaryTimer: 0,
-      },
-      _timer: {
-        secondaryTarget: 15,
-      },
-    } as RuntimeState;
-
-    const expected = {
-      updatedTimer: null,
-      updatedSecondaryTimer: 0,
-      doRollLoad: true,
-      isFinished: false,
-    };
-
-    expect(updateRoll(timers)).toStrictEqual(expected);
-  });
-
-  it('counts over midnight', () => {
-    const timers = {
-      eventNow: {
-        id: '1',
-      },
-      clock: dayInMs - 10,
-      timer: {
-        current: 25,
-        expectedFinish: 10,
-        startedAt: 1000,
-        secondaryTimer: null,
-      },
-      _timer: {
-        secondaryTarget: null,
-      },
-    } as RuntimeState;
-
-    const expected = {
-      updatedTimer: 20,
-      updatedSecondaryTimer: null,
-      doRollLoad: false,
-      isFinished: false,
-    };
-
-    expect(updateRoll(timers)).toStrictEqual(expected);
-  });
-
-  it('rolls over midnight', () => {
-    const timers = {
-      eventNow: {
-        id: '1',
-      },
-      clock: 10,
-      timer: {
-        current: dayInMs,
-        expectedFinish: 10,
-        startedAt: 1000,
-        secondaryTimer: null,
-      },
-      _timer: {
-        secondaryTarget: null,
-      },
-    } as RuntimeState;
-
-    const expected = {
-      updatedTimer: dayInMs,
-      updatedSecondaryTimer: null,
-      doRollLoad: false,
-      isFinished: false,
-    };
-
-    expect(updateRoll(timers)).toStrictEqual(expected);
-  });
-});
-
 describe('getRuntimeOffset()', () => {
   it('is the difference between scheduled and when we actually started', () => {
     const state = {
@@ -1554,7 +848,7 @@ describe('getRuntimeOffset()', () => {
         secondaryTimer: null,
         startedAt: null,
       },
-      _timer: { pausedAt: null, secondaryTarget: null },
+      _timer: { pausedAt: null },
     } as RuntimeState;
 
     const offset = getRuntimeOffset(state);
@@ -1595,7 +889,7 @@ describe('getRuntimeOffset()', () => {
         secondaryTimer: null,
         startedAt: null,
       },
-      _timer: { pausedAt: null, secondaryTarget: null },
+      _timer: { pausedAt: null },
     } as RuntimeState;
 
     const offset = getRuntimeOffset(state);
@@ -1630,7 +924,7 @@ describe('getRuntimeOffset()', () => {
       runtime: {
         selectedEventIndex: 0,
         numEvents: 1,
-        offset: null,
+        offset: 0,
         plannedStart: 77400000, // 21:30:00
         plannedEnd: 81000000, // 22:30:00
         actualStart: 78000000, // 21:40:00
@@ -1647,7 +941,7 @@ describe('getRuntimeOffset()', () => {
         secondaryTimer: null,
         startedAt: 78000000,
       },
-      _timer: { pausedAt: null, secondaryTarget: null },
+      _timer: { pausedAt: null },
     } as RuntimeState;
 
     const offset = getRuntimeOffset(state);
@@ -1682,7 +976,7 @@ describe('getRuntimeOffset()', () => {
       runtime: {
         selectedEventIndex: 0,
         numEvents: 1,
-        offset: null,
+        offset: 0,
         plannedStart: 77400000, // 21:30:00
         plannedEnd: 81000000, // 22:30:00
         actualStart: 78000000, // 21:40:00
@@ -1699,7 +993,7 @@ describe('getRuntimeOffset()', () => {
         secondaryTimer: null,
         startedAt: 78000000,
       },
-      _timer: { pausedAt: null, secondaryTarget: null },
+      _timer: { pausedAt: null },
     } as RuntimeState;
 
     const offset = getRuntimeOffset(state);
@@ -1722,7 +1016,7 @@ describe('getRuntimeOffset()', () => {
       runtime: {
         selectedEventIndex: 0,
         numEvents: 1,
-        offset: null,
+        offset: 0,
         plannedStart: 77400000, // 21:30:00
         plannedEnd: 81000000, // 22:30:00
         actualStart: 82000000, // 22:46:40 <--- started now
@@ -1739,7 +1033,7 @@ describe('getRuntimeOffset()', () => {
         secondaryTimer: null,
         startedAt: 82000000, // <--- started now
       },
-      _timer: { pausedAt: null, secondaryTarget: null },
+      _timer: { pausedAt: null },
     } as RuntimeState;
 
     const updateCurrent = getCurrent(state);
@@ -1887,7 +1181,7 @@ describe('getTimerPhase()', () => {
       runtime: {
         selectedEventIndex: null,
         numEvents: 1,
-        offset: null,
+        offset: 0,
         plannedStart: 55860000,
         plannedEnd: 55880000,
         actualStart: null,
@@ -1909,7 +1203,6 @@ describe('getTimerPhase()', () => {
         forceFinish: null,
         totalDelay: 0,
         pausedAt: null,
-        secondaryTarget: 55860000,
       },
     } as RuntimeState;
 
@@ -1927,7 +1220,7 @@ describe('getTimerPhase()', () => {
       runtime: {
         selectedEventIndex: null,
         numEvents: 1,
-        offset: null,
+        offset: 0,
         plannedStart: 55860000,
         plannedEnd: 55880000,
         actualStart: null,
@@ -1949,7 +1242,6 @@ describe('getTimerPhase()', () => {
         forceFinish: null,
         totalDelay: 0,
         pausedAt: null,
-        secondaryTarget: 55860000,
       },
     } as RuntimeState;
 

apps/server/src/services/app-state-service/AppStateService.ts

@@ -1,9 +1,9 @@
 import { Low } from 'lowdb';
 import { JSONFile } from 'lowdb/node';
 
-import { appStatePath, isProduction, isTest } from '../../setup/index.js';
+import { appStatePath, isTest } from '../../setup/index.js';
 import { isPath } from '../../utils/fileManagement.js';
-import { consoleError } from '../../utils/console.js';
+import { shouldCrashDev } from '../../utils/development.js';
 
 interface AppState {
   lastLoadedProject?: string;
@@ -27,13 +27,8 @@ export async function getLastLoadedProject(): Promise<string | undefined> {
 
 export async function setLastLoadedProject(filename: string): Promise<void> {
   if (isTest) return;
-  if (!isProduction) {
-    if (isPath(filename)) {
-      consoleError(filename);
-      consoleError(new Error('setLastLoadedProject should not be called with a path').stack);
-      process.exit(0);
-    }
-  }
+  // eslint-disable-next-line no-unused-labels -- dev code path
+  DEV: shouldCrashDev(isPath(filename), 'setLastLoadedProject should not be called with a path');
 
   config.data.lastLoadedProject = filename;
   await config.write();

apps/server/src/services/rollUtils.ts

@@ -0,0 +1,93 @@
+import { dayInMs, getFirstEvent, getLastEvent } from 'ontime-utils';
+import { OntimeEvent, MaybeNumber, PlayableEvent, isPlayableEvent } from 'ontime-types';
+
+import { normaliseEndTime } from './timerUtils.js';
+
+/**
+ * Finds current event in a rolling rundown
+ */
+export function loadRoll(
+  timedEvents: OntimeEvent[],
+  timeNow: number,
+): {
+  event: PlayableEvent | null;
+  index: MaybeNumber;
+  isPending?: boolean;
+} {
+  const { firstEvent } = getFirstEvent(timedEvents);
+  const { lastEvent } = getLastEvent(timedEvents);
+
+  if (!firstEvent || !lastEvent) {
+    return { event: null, index: null };
+  }
+
+  // check that the rundown wraps around midnight
+  const wrapsAroundMidnight = firstEvent.timeStart > lastEvent.timeEnd;
+
+  if (!wrapsAroundMidnight) {
+    // check whether we are before or after the rundown
+    const lastNormalEnd = normaliseEndTime(lastEvent.timeStart, lastEvent.timeEnd);
+    const isAfterRundown = timeNow > lastNormalEnd;
+    const isBeforeRundown = timeNow < firstEvent.timeStart && !isAfterRundown;
+
+    if (isAfterRundown || isBeforeRundown) {
+      return { event: firstEvent, index: 0, isPending: true };
+    }
+  }
+
+  // we know we are in the middle of the rundown and we need to find the current event
+  // account for number of times we went over midnight
+  let daySpan = 0;
+
+  for (let i = 0; i < timedEvents.length; i++) {
+    const event = timedEvents[i];
+
+    if (!isPlayableEvent(event)) {
+      continue;
+    }
+
+    // we check if event crosses midnight
+    if (event.timeStart > event.timeEnd) {
+      daySpan++;
+    }
+
+    const correctedDays = dayInMs * daySpan;
+    const correctedStart = event.timeStart + correctedDays;
+    const correctedEnd = event.timeEnd + correctedDays;
+
+    /**
+     * there are 3 possible states for an event
+     * 1. event is already finished
+     * 2. event is running
+     * 3. event is in the future
+     */
+
+    // 1. event is already finished
+    // when does the event end (handle midnight)
+    const normalEnd = normaliseEndTime(correctedStart, correctedEnd);
+    if (normalEnd <= timeNow) {
+      continue;
+    }
+
+    // 2. event is running and is the first event in our time slot
+    const isFromDayBefore = normalEnd > dayInMs && timeNow < event.timeEnd;
+    const hasStarted = isFromDayBefore || timeNow >= event.timeStart;
+    if (hasStarted) {
+      return { event, index: i };
+    }
+
+    // 3. event will run in the future
+    // we set the isPending flag to indicate that the event is currently playing
+    return { event, index: i, isPending: true };
+  }
+
+  // in case we were unable to find anything, we load the first event
+  return { event: firstEvent, index: 0, isPending: true };
+}
+
+/**
+ * Utility function, checks whether the event start is the day after
+ */
+export function normaliseRollStart(start: number, clock: number) {
+  return start < clock ? start + dayInMs : start;
+}

apps/server/src/services/rundown-service/RundownService.ts

@@ -20,17 +20,19 @@ import { updateRundownData } from '../../stores/runtimeState.js';
 import { runtimeService } from '../runtime-service/RuntimeService.js';
 
 import * as cache from './rundownCache.js';
-import { getPlayableEvents } from './rundownUtils.js';
+import { getPlayableEvents, getTimedEvents } from './rundownUtils.js';
+import { eventStore } from '../../stores/EventStore.js';
 
 type PatchWithId = (Partial<OntimeEvent> | Partial<OntimeBlock> | Partial<OntimeDelay>) & { id: string };
 
-type CompleteEntry<T> = T extends Partial<OntimeEvent>
-  ? OntimeEvent
-  : T extends Partial<OntimeDelay>
-  ? OntimeDelay
-  : T extends Partial<OntimeBlock>
-  ? OntimeBlock
-  : never;
+type CompleteEntry<T> =
+  T extends Partial<OntimeEvent>
+    ? OntimeEvent
+    : T extends Partial<OntimeDelay>
+      ? OntimeDelay
+      : T extends Partial<OntimeBlock>
+        ? OntimeBlock
+        : never;
 
 function generateEvent<T extends Partial<OntimeEvent> | Partial<OntimeDelay> | Partial<OntimeBlock>>(
   eventData: T,
@@ -213,8 +215,8 @@ export async function swapEvents(from: string, to: string) {
  * Called when we make changes to the rundown object
  */
 function updateRuntimeOnChange() {
-  const playableEvents = getPlayableEvents();
-  const numEvents = playableEvents.length;
+  const timedEvents = getTimedEvents();
+  const numEvents = timedEvents.length;
   const metadata = cache.getMetadata();
 
   // schedule an update for the end of the event loop
@@ -239,7 +241,7 @@ function notifyChanges(options: { timer?: boolean | string[]; external?: boolean
       // notify timer service of changed events
       // timer can be true or an array of changed IDs
       const affected = Array.isArray(options.timer) ? options.timer : undefined;
-      runtimeService.maybeUpdate(playableEvents, affected);
+      runtimeService.notifyOfChangedEvents(affected);
     }
   }
 
@@ -262,3 +264,7 @@ export async function initRundown(rundown: Readonly<OntimeRundown>, customFields
   // notify timer of change
   notifyChanges({ timer: true });
 }
+
+export async function setFrozenState(state: boolean) {
+  eventStore.set('frozen', state);
+}

apps/server/src/services/rundown-service/__tests__/rundownCache.test.ts

@@ -10,7 +10,7 @@ import {
   TimeStrategy,
   TimerType,
 } from 'ontime-types';
-import { MILLIS_PER_HOUR, dayInMs, millisToString } from 'ontime-utils';
+import { MILLIS_PER_HOUR, MILLIS_PER_MINUTE, dayInMs } from 'ontime-utils';
 
 import { calculateRuntimeDelays, getDelayAt, calculateRuntimeDelaysFrom } from '../delayUtils.js';
 import {
@@ -70,13 +70,13 @@ describe('generate()', () => {
 
   it('accounts for gaps in rundown when calculating delays', () => {
     const testRundown: OntimeRundown = [
-      { type: SupportedEvent.Event, id: '1', timeStart: 100, timeEnd: 200 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '1', timeStart: 100, timeEnd: 200, duration: 100 } as OntimeEvent,
       { type: SupportedEvent.Delay, id: 'delay', duration: 200 } as OntimeDelay,
-      { type: SupportedEvent.Event, id: '2', timeStart: 200, timeEnd: 300 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '2', timeStart: 200, timeEnd: 300, duration: 100 } as OntimeEvent,
       { type: SupportedEvent.Block, id: 'block', title: 'break' } as OntimeBlock,
-      { type: SupportedEvent.Event, id: '3', timeStart: 400, timeEnd: 500 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '3', timeStart: 400, timeEnd: 500, duration: 100 } as OntimeEvent,
       { type: SupportedEvent.Block, id: 'another-block', title: 'another-break' } as OntimeBlock,
-      { type: SupportedEvent.Event, id: '4', timeStart: 600, timeEnd: 700 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '4', timeStart: 600, timeEnd: 700, duration: 100 } as OntimeEvent,
     ];
 
     const initResult = generate(testRundown);
@@ -89,15 +89,74 @@ describe('generate()', () => {
     expect(initResult.totalDuration).toBe(700 - 100);
   });
 
+  it('accounts for overlaps in rundown', () => {
+    const testRundown: OntimeRundown = [
+      { type: SupportedEvent.Event, id: '1', timeStart: 9000, timeEnd: 10000, duration: 1000 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '2', timeStart: 9250, timeEnd: 9500, duration: 250 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '3', timeStart: 9500, timeEnd: 10500, duration: 1000 } as OntimeEvent,
+    ];
+
+    const initResult = generate(testRundown);
+    expect(initResult.totalDuration).toBe(10500 - 9000); // last end - first start
+  });
+
+  it('accounts for overlaps in rundown (with added gap)', () => {
+    const testRundown: OntimeRundown = [
+      { type: SupportedEvent.Event, id: '1', timeStart: 9000, timeEnd: 10000, duration: 1000 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '2', timeStart: 9250, timeEnd: 9500, duration: 250 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '3', timeStart: 9500, timeEnd: 10500, duration: 1000 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '4', timeStart: 15000, timeEnd: 20000, duration: 5000 } as OntimeEvent,
+    ];
+
+    const initResult = generate(testRundown);
+    expect(initResult.totalDuration).toBe(20000 - 9000); // last end - first start
+  });
+
+  it('accounts for overlaps in rundown (with multiple days)', () => {
+    const testRundown: OntimeRundown = [
+      {
+        type: SupportedEvent.Event,
+        id: '1',
+        timeStart: 9 * MILLIS_PER_HOUR,
+        timeEnd: 10 * MILLIS_PER_HOUR,
+        duration: MILLIS_PER_HOUR,
+      } as OntimeEvent,
+      {
+        type: SupportedEvent.Event,
+        id: '2',
+        timeStart: 9 * MILLIS_PER_HOUR + 15 * MILLIS_PER_MINUTE,
+        timeEnd: 9 * MILLIS_PER_HOUR + 45 * MILLIS_PER_MINUTE,
+        duration: 30 * MILLIS_PER_MINUTE,
+      } as OntimeEvent,
+      {
+        type: SupportedEvent.Event,
+        id: '3',
+        timeStart: 9 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE,
+        timeEnd: 10 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE,
+        duration: MILLIS_PER_HOUR,
+      } as OntimeEvent,
+      {
+        type: SupportedEvent.Event,
+        id: '4',
+        timeStart: 9 * MILLIS_PER_HOUR,
+        timeEnd: 10 * MILLIS_PER_HOUR,
+        duration: MILLIS_PER_HOUR,
+      } as OntimeEvent,
+    ];
+
+    const initResult = generate(testRundown);
+    expect(initResult.totalDuration).toBe(dayInMs + MILLIS_PER_HOUR); // day + last end - first start
+  });
+
   it('handles negative delays', () => {
     const testRundown: OntimeRundown = [
-      { type: SupportedEvent.Event, id: '1', timeStart: 100, timeEnd: 200 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '1', timeStart: 100, timeEnd: 200, duration: 100 } as OntimeEvent,
       { type: SupportedEvent.Delay, id: 'delay', duration: -200 } as OntimeDelay,
-      { type: SupportedEvent.Event, id: '2', timeStart: 200, timeEnd: 300 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '2', timeStart: 200, timeEnd: 300, duration: 100 } as OntimeEvent,
       { type: SupportedEvent.Block, id: 'block', title: 'break' } as OntimeBlock,
-      { type: SupportedEvent.Event, id: '3', timeStart: 400, timeEnd: 500 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '3', timeStart: 400, timeEnd: 500, duration: 100 } as OntimeEvent,
       { type: SupportedEvent.Block, id: 'another-block', title: 'another-break' } as OntimeBlock,
-      { type: SupportedEvent.Event, id: '4', timeStart: 600, timeEnd: 700 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '4', timeStart: 600, timeEnd: 700, duration: 100 } as OntimeEvent,
     ];
 
     const initResult = generate(testRundown);
@@ -172,10 +231,17 @@ describe('generate()', () => {
 
   it('calculates total duration', () => {
     const testRundown: OntimeRundown = [
-      { type: SupportedEvent.Event, id: '1', timeStart: 100, timeEnd: 200 } as OntimeEvent,
-      { type: SupportedEvent.Event, id: '2', timeStart: 200, timeEnd: 300 } as OntimeEvent,
-      { type: SupportedEvent.Event, id: 'skipped', skip: true, timeStart: 300, timeEnd: 400 } as OntimeEvent,
-      { type: SupportedEvent.Event, id: '3', timeStart: 400, timeEnd: 500 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '1', timeStart: 100, timeEnd: 200, duration: 100 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '2', timeStart: 200, timeEnd: 300, duration: 100 } as OntimeEvent,
+      {
+        type: SupportedEvent.Event,
+        id: 'skipped',
+        skip: true,
+        timeStart: 300,
+        timeEnd: 400,
+        duration: 100,
+      } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '3', timeStart: 400, timeEnd: 500, duration: 100 } as OntimeEvent,
     ];
 
     const initResult = generate(testRundown);
@@ -186,9 +252,16 @@ describe('generate()', () => {
   it('calculates total duration with 0 duration events without causing a next day', () => {
     const testRundown: OntimeRundown = [
       { type: SupportedEvent.Event, id: '1', timeStart: 100, timeEnd: 100, duration: 0 } as OntimeEvent,
-      { type: SupportedEvent.Event, id: '2', timeStart: 100, timeEnd: 300 } as OntimeEvent,
-      { type: SupportedEvent.Event, id: 'skipped', skip: true, timeStart: 300, timeEnd: 400 } as OntimeEvent,
-      { type: SupportedEvent.Event, id: '3', timeStart: 400, timeEnd: 500 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '2', timeStart: 100, timeEnd: 300, duration: 200 } as OntimeEvent,
+      {
+        type: SupportedEvent.Event,
+        id: 'skipped',
+        skip: true,
+        timeStart: 300,
+        timeEnd: 400,
+        duration: 0,
+      } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '3', timeStart: 400, timeEnd: 500, duration: 100 } as OntimeEvent,
     ];
 
     const initResult = generate(testRundown);
@@ -201,27 +274,28 @@ describe('generate()', () => {
       {
         type: SupportedEvent.Event,
         id: '1',
-        timeStart: new Date(0).setHours(9),
-        timeEnd: new Date(0).setHours(23),
+        timeStart: 9 * MILLIS_PER_HOUR,
+        timeEnd: 23 * MILLIS_PER_HOUR,
+        duration: (23 - 9) * MILLIS_PER_HOUR,
       } as OntimeEvent,
       {
         type: SupportedEvent.Event,
         id: '2',
-        timeStart: new Date(0).setHours(9),
-        timeEnd: new Date(0).setHours(23),
+        timeStart: 9 * MILLIS_PER_HOUR,
+        timeEnd: 23 * MILLIS_PER_HOUR,
+        duration: (23 - 9) * MILLIS_PER_HOUR,
       } as OntimeEvent,
       {
         type: SupportedEvent.Event,
         id: '3',
-        timeStart: new Date(0).setHours(9),
-        timeEnd: new Date(0).setHours(23),
+        timeStart: 9 * MILLIS_PER_HOUR,
+        timeEnd: 23 * MILLIS_PER_HOUR,
+        duration: (23 - 9) * MILLIS_PER_HOUR,
       } as OntimeEvent,
     ];
 
     const initResult = generate(testRundown);
-    const expectedDuration = (23 - 9 + 48) * MILLIS_PER_HOUR;
-    expect(millisToString(initResult.totalDuration)).toBe('62:00:00');
-    expect(initResult.totalDuration).toBe(expectedDuration);
+    expect(initResult.totalDuration).toBe((23 - 9 + 48) * MILLIS_PER_HOUR);
   });
 
   it('calculates total duration across days', () => {
@@ -229,20 +303,21 @@ describe('generate()', () => {
       {
         type: SupportedEvent.Event,
         id: '1',
-        timeStart: new Date(0).setHours(12),
-        timeEnd: new Date(0).setHours(22),
+        timeStart: 12 * MILLIS_PER_HOUR,
+        timeEnd: 22 * MILLIS_PER_HOUR,
+        duration: 10 * MILLIS_PER_HOUR,
       } as OntimeEvent,
       {
         type: SupportedEvent.Event,
         id: '2',
-        timeStart: new Date(0).setHours(22),
-        timeEnd: new Date(0).setHours(8),
+        timeStart: 22 * MILLIS_PER_HOUR,
+        timeEnd: 8 * MILLIS_PER_HOUR,
+        duration: (24 - 22 + 8) * MILLIS_PER_HOUR,
       } as OntimeEvent,
     ];
 
     const initResult = generate(testRundown);
     const expectedDuration = 8 * MILLIS_PER_HOUR + (dayInMs - 12 * MILLIS_PER_HOUR);
-    expect(millisToString(initResult.totalDuration)).toBe('20:00:00');
     expect(initResult.totalDuration).toBe(expectedDuration);
   });
 
@@ -346,7 +421,7 @@ describe('generate()', () => {
       ];
       const initResult = generate(testRundown, customProperties);
       expect(initResult.order.length).toBe(2);
-      expect(initResult.assignedCustomProperties).toMatchObject({
+      expect(initResult.assignedCustomFields).toMatchObject({
         lighting: ['1', '2'],
         sound: ['2'],
       });
@@ -482,20 +557,6 @@ describe('swap() mutation', () => {
   });
 });
 
-/**
- *
- *
- *
- *
- *
- *
- *
- *
- *
- *
- *
- */
-
 describe('calculateRuntimeDelays', () => {
   it('calculates all delays in a given rundown', () => {
     const rundown: OntimeRundown = [

apps/server/src/services/rundown-service/rundownCache.ts

@@ -4,16 +4,16 @@ import {
   CustomFields,
   isOntimeDelay,
   isOntimeEvent,
+  isPlayableEvent,
   MaybeNumber,
   OntimeEvent,
   OntimeRundown,
   OntimeRundownEntry,
+  PlayableEvent,
 } from 'ontime-types';
-import { generateId, insertAtIndex, reorderArray, swapEventData, checkIsNextDay } from 'ontime-utils';
-
+import { generateId, insertAtIndex, reorderArray, swapEventData, getTimeFromPrevious, isNewLatest } from 'ontime-utils';
 import { getDataProvider } from '../../classes/data-provider/DataProvider.js';
 import { createPatch } from '../../utils/parser.js';
-import { getTotalDuration } from '../timerUtils.js';
 import { apply } from './delayUtils.js';
 import { handleCustomField, handleLink, hasChanges, isDataStale } from './rundownCacheUtils.js';
 
@@ -83,74 +83,78 @@ export function generate(
   totalDuration = 0;
   totalDelay = 0;
 
-  let accumulatedDelay = 0;
-  let daySpan = 0;
-  let previousStart: MaybeNumber = null;
-  let previousEnd: MaybeNumber = null;
-  let previousDuration: MaybeNumber = null;
+  let lastEntry: PlayableEvent | null = null;
 
   for (let i = 0; i < initialRundown.length; i++) {
-    const currentEvent = initialRundown[i];
-    const updatedEvent = { ...currentEvent };
+    // TODO: filter properties that should not be persisted (eg: delay)
+    // we assign a reference to the current entry, this will be mutated in place
+    const currentEntry = initialRundown[i];
 
-    if (isOntimeEvent(updatedEvent)) {
-      // 1. handle links
-      handleLink(i, initialRundown, updatedEvent, links);
+    if (isOntimeEvent(currentEntry)) {
+      // 1. handle links - mutates updatedEvent
+      handleLink(i, initialRundown, currentEntry, links);
 
-      // 2. handle custom fields
-      handleCustomField(customFields, customFieldChangelog, updatedEvent, assignedCustomFields);
+      // 2. handle custom fields - mutates updatedEvent
+      handleCustomField(customFields, customFieldChangelog, currentEntry, assignedCustomFields);
 
-      // update the persisted event
-      initialRundown[i] = updatedEvent;
-
-      // we need to generate the skip event, but dont want to use its times
-      if (!updatedEvent.skip) {
-        // update rundown duration
+      // update rundown metadata, it only concerns playable events
+      if (isPlayableEvent(currentEntry)) {
+        // fist start is always the first event
         if (firstStart === null) {
-          firstStart = updatedEvent.timeStart;
+          firstStart = currentEntry.timeStart;
         }
-        lastEnd = updatedEvent.timeEnd;
 
-        // check if we go over midnight, account for eventual gaps
-        const gapOverMidnight =
-          previousStart !== null && checkIsNextDay(previousStart, updatedEvent.timeStart, previousDuration);
-        const durationOverMidnight = updatedEvent.timeStart > updatedEvent.timeEnd;
-        if (gapOverMidnight || durationOverMidnight) {
-          daySpan++;
+        const timeFromPrevious: number = getTimeFromPrevious(
+          currentEntry.timeStart,
+          lastEntry?.timeStart,
+          lastEntry?.timeEnd,
+          lastEntry?.duration,
+        );
+
+        if (timeFromPrevious === 0) {
+          // event starts on previous finish, we add its duration
+          totalDuration += currentEntry.duration;
+        } else if (timeFromPrevious > 0) {
+          // event has a gap, we add the gap and the duration
+          totalDuration += timeFromPrevious + currentEntry.duration;
+        } else if (timeFromPrevious < 0) {
+          // there is an overlap, we remove the overlap from the duration
+          // ensuring that the sum is not negative (ie: fully overlapped events)
+          // NOTE: we add the gap since it is a negative number
+          totalDuration += Math.max(currentEntry.duration + timeFromPrevious, 0);
+        }
+
+        // remove eventual gaps from the accumulated delay
+        // we only affect positive delays (time forwards)
+        if (totalDelay > 0 && timeFromPrevious > 0) {
+          totalDelay = Math.max(totalDelay - timeFromPrevious, 0);
+        }
+        // current event delay is the current accumulated delay
+        currentEntry.delay = totalDelay;
+
+        // lastEntry is the event with the latest end time
+        if (isNewLatest(currentEntry.timeStart, currentEntry.timeEnd, lastEntry?.timeStart, lastEntry?.timeEnd)) {
+          lastEntry = currentEntry;
         }
       }
     }
 
     // calculate delays
     // !!! this must happen after handling the links
-    if (isOntimeDelay(updatedEvent)) {
-      accumulatedDelay += updatedEvent.duration;
-    } else if (isOntimeEvent(updatedEvent) && !updatedEvent.skip) {
-      const eventStart = updatedEvent.timeStart;
-
-      // we only affect positive delays (time forwards)
-      if (accumulatedDelay > 0 && previousEnd) {
-        const gap = Math.max(eventStart - previousEnd, 0);
-        accumulatedDelay = Math.max(accumulatedDelay - gap, 0);
-      }
-      updatedEvent.delay = accumulatedDelay;
-      previousStart = updatedEvent.timeStart;
-      previousEnd = updatedEvent.timeEnd;
-      previousDuration = updatedEvent.duration;
+    if (isOntimeDelay(currentEntry)) {
+      totalDelay += currentEntry.duration;
     }
 
-    order.push(updatedEvent.id);
-    rundown[updatedEvent.id] = { ...updatedEvent };
+    // add id to order
+    order.push(currentEntry.id);
+    // add entry to rundown
+    rundown[currentEntry.id] = currentEntry;
   }
 
+  lastEnd = lastEntry?.timeEnd ?? null;
   isStale = false;
   customFieldChangelog.clear();
-  totalDelay = accumulatedDelay;
-  if (lastEnd !== null && firstStart !== null) {
-    totalDuration = getTotalDuration(firstStart, lastEnd, daySpan);
-  }
-
-  return { rundown, order, links, totalDelay, totalDuration, assignedCustomProperties: assignedCustomFields };
+  return { rundown, order, links, totalDelay, totalDuration, assignedCustomFields };
 }
 
 /** Returns an ID guaranteed to be unique */

apps/server/src/services/rundown-service/rundownUtils.ts

@@ -1,14 +1,17 @@
-import { OntimeEvent, OntimeRundown, isOntimeEvent, RundownCached, OntimeRundownEntry } from 'ontime-types';
+import { OntimeEvent, OntimeRundown, RundownCached, OntimeRundownEntry, PlayableEvent } from 'ontime-types';
+import { filterPlayable, filterTimedEvents } from 'ontime-utils';
 
 import * as cache from './rundownCache.js';
 
+/**
+ * returns the normalised rundown
+ */
 export function getNormalisedRundown(): RundownCached {
   return cache.get();
 }
 
 /**
  * returns entire unfiltered rundown
- * @return {array}
  */
 export function getRundown(): OntimeRundown {
   return cache.getPersistedRundown();
@@ -16,32 +19,20 @@ export function getRundown(): OntimeRundown {
 
 /**
  * returns all events of type OntimeEvent
- * @return {array}
  */
 export function getTimedEvents(): OntimeEvent[] {
-  return getRundown().filter((event) => isOntimeEvent(event)) as OntimeEvent[];
+  return filterTimedEvents(getRundown());
 }
 
 /**
  * returns all events that can be loaded
- * @return {array}
  */
-export function getPlayableEvents(): OntimeEvent[] {
-  return getRundown().filter((event) => isOntimeEvent(event) && !event.skip) as OntimeEvent[];
-}
-
-/**
- * returns number of events that can be loaded
- * @return {number}
- */
-export function getNumEvents(): number {
-  return getPlayableEvents().length;
+export function getPlayableEvents(): PlayableEvent[] {
+  return filterPlayable(getRundown());
 }
 
 /**
  * returns an event given its index after filtering for OntimeEvents
- * @param {number} eventIndex
- * @return {OntimeEvent | undefined}
  */
 export function getEventAtIndex(eventIndex: number): OntimeEvent | undefined {
   const timedEvents = getTimedEvents();
@@ -50,8 +41,6 @@ export function getEventAtIndex(eventIndex: number): OntimeEvent | undefined {
 
 /**
  * returns first event that matches a given ID
- * @param {string} eventId
- * @return {object | undefined}
  */
 export function getEventWithId(eventId: string): OntimeRundownEntry | undefined {
   const rundown = getRundown();
@@ -60,17 +49,14 @@ export function getEventWithId(eventId: string): OntimeRundownEntry | undefined
 
 /**
  * returns first event that matches a given cue
- * @param {string} targetCue
- * @param {number} currentEventIndex
- * @return {object | undefined}
  */
 export function getNextEventWithCue(targetCue: string, currentEventIndex = 0): OntimeEvent | undefined {
-  const timedEvents = getPlayableEvents();
+  const playableEvents = getPlayableEvents();
   const lowerCaseCue = targetCue.toLowerCase();
 
-  for (let i = currentEventIndex; i < timedEvents.length; i++) {
-    const event = timedEvents.at(i);
-    if (event && event.cue.toLowerCase() === lowerCaseCue) {
+  for (let i = currentEventIndex; i < playableEvents.length; i++) {
+    const event = playableEvents.at(i);
+    if (event?.cue.toLowerCase() === lowerCaseCue) {
       return event;
     }
   }
@@ -78,43 +64,41 @@ export function getNextEventWithCue(targetCue: string, currentEventIndex = 0): O
 
 /**
  * finds the previous event
- * @return {object | undefined}
  */
 export function findPrevious(currentEventId?: string): OntimeEvent | null {
-  const timedEvents = getPlayableEvents();
-  if (!timedEvents || !timedEvents.length) {
+  const playableEvents = getPlayableEvents();
+  if (!playableEvents || !playableEvents.length) {
     return null;
   }
 
   // if there is no event running, go to first
   if (!currentEventId) {
-    return timedEvents.at(0) ?? null;
+    return playableEvents.at(0) ?? null;
   }
 
-  const currentIndex = timedEvents.findIndex((event) => event.id === currentEventId);
+  const currentIndex = playableEvents.findIndex((event) => event.id === currentEventId);
   const newIndex = Math.max(currentIndex - 1, 0);
-  const previousEvent = timedEvents.at(newIndex) ?? null;
+  const previousEvent = playableEvents.at(newIndex) ?? null;
   return previousEvent;
 }
 
 /**
  * finds the next event
- * @return {object | undefined}
  */
-export function findNext(currentEventId?: string): OntimeEvent | null {
-  const timedEvents = getPlayableEvents();
-  if (!timedEvents || !timedEvents.length) {
+export function findNext(currentEventId?: string): PlayableEvent | null {
+  const playableEvents = getPlayableEvents();
+  if (!playableEvents.length) {
     return null;
   }
 
   // if there is no event running, go to first
   if (!currentEventId) {
-    return timedEvents.at(0) ?? null;
+    return playableEvents.at(0) ?? null;
   }
 
-  const currentIndex = timedEvents.findIndex((event) => event.id === currentEventId);
+  const currentIndex = playableEvents.findIndex((event) => event.id === currentEventId);
   const newIndex = currentIndex + 1;
-  const nextEvent = timedEvents.at(newIndex);
+  const nextEvent = playableEvents.at(newIndex);
   return nextEvent ?? null;
 }
 

apps/server/src/services/runtime-service/RuntimeService.ts

@@ -1,6 +1,7 @@
 import {
   EndAction,
   isOntimeEvent,
+  isPlayableEvent,
   LogOrigin,
   MaybeNumber,
   OntimeEvent,
@@ -8,6 +9,7 @@ import {
   RuntimeStore,
   TimerLifeCycle,
   TimerPhase,
+  TimerState,
 } from 'ontime-types';
 import { millisToString, validatePlayback } from 'ontime-utils';
 
@@ -19,7 +21,7 @@ import type { RuntimeState } from '../../stores/runtimeState.js';
 import { timerConfig } from '../../config/config.js';
 import { eventStore } from '../../stores/EventStore.js';
 
-import { TimerService } from '../TimerService.js';
+import { EventTimer } from '../EventTimer.js';
 import { RestorePoint, restoreService } from '../RestoreService.js';
 import {
   findNext,
@@ -27,46 +29,93 @@ import {
   getEventAtIndex,
   getNextEventWithCue,
   getEventWithId,
-  getPlayableEvents,
+  getRundown,
+  getTimedEvents,
 } from '../rundown-service/rundownUtils.js';
 import { integrationService } from '../integration-service/IntegrationService.js';
+
 import { getForceUpdate, getShouldClockUpdate, getShouldTimerUpdate } from './rundownService.utils.js';
+import { skippedOutOfEvent } from '../timerUtils.js';
 
 /**
  * Service manages runtime status of app
  * Coordinating with necessary services
  */
 class RuntimeService {
-  private eventTimer: TimerService | null = null;
+  private eventTimer: EventTimer;
   private lastIntegrationClockUpdate = -1;
   private lastIntegrationTimerValue = -1;
 
   /** last time we updated the socket */
   static previousTimerUpdate: number;
-  static previousTimerValue: MaybeNumber;
+  static previousTimerValue: MaybeNumber; // previous timer value, could be null
   static previousClockUpdate: number;
+
   /** last known state */
   static previousState: RuntimeState;
 
-  constructor() {
+  constructor(eventTimer: EventTimer) {
+    this.eventTimer = eventTimer;
+
     RuntimeService.previousTimerUpdate = -1;
     RuntimeService.previousTimerValue = -1;
     RuntimeService.previousClockUpdate = -1;
     RuntimeService.previousState = {} as RuntimeState;
   }
 
-  /** Checks result of an update and notifies integrations as needed */
+  /**
+   * Checks result of an update and notifies integrations as needed
+   * This is the only exception of a private method that has broadcast result
+   * */
   @broadcastResult
-  checkTimerUpdate({ shouldCallRoll, hasTimerFinished }: runtimeState.UpdateResult) {
+  private checkTimerUpdate({ hasTimerFinished, hasSecondaryTimerFinished }: runtimeState.UpdateResult) {
     const newState = runtimeState.getState();
-    if (hasTimerFinished) {
+    // 1. find if we need to dispatch integrations related to the phase
+    const timerPhaseChanged = RuntimeService.previousState.timer?.phase !== newState.timer.phase;
+    if (timerPhaseChanged) {
+      if (newState.timer.phase === TimerPhase.Warning) {
+        process.nextTick(() => {
+          integrationService.dispatch(TimerLifeCycle.onWarning);
+        });
+      } else if (newState.timer.phase === TimerPhase.Danger) {
+        process.nextTick(() => {
+          integrationService.dispatch(TimerLifeCycle.onDanger);
+        });
+      }
+    }
+
+    // 2. handle edge cases related to roll
+    if (newState.timer.playback === Playback.Roll) {
+      // check if we need to call any side effects
+      const keepOffset = newState.runtime.offset;
+      if (hasSecondaryTimerFinished) {
+        // if the secondary timer has finished, we need to call roll
+        // since event is already loaded
+        this.rollLoaded(keepOffset);
+      } else if (hasTimerFinished) {
+        // if the timer has finished, we need to load next and keep rolling
+        process.nextTick(() => {
+          integrationService.dispatch(TimerLifeCycle.onFinish);
+        });
+        this.handleLoadNext();
+        this.rollLoaded(keepOffset);
+      } else if (skippedOutOfEvent(newState, this.lastIntegrationClockUpdate, timerConfig.skipLimit)) {
+        // if we have skipped out of the event, we will recall roll
+        // to push the playback to the right place
+        // this comes with the caveat that we will lose our runtime data
+        this.roll(true);
+      }
+    }
+
+    // 3. find if we need to process actions related to the timer finishing
+    if (newState.timer.playback === Playback.Play && hasTimerFinished) {
       process.nextTick(() => {
         integrationService.dispatch(TimerLifeCycle.onFinish);
       });
 
       // handle end action if there was a timer playing
       // actions are added to the queue stack to ensure that the order of operations is maintained
-      if (newState.timer.playback === Playback.Play && newState.eventNow) {
+      if (newState.eventNow) {
         if (newState.eventNow.endAction === EndAction.Stop) {
           setTimeout(this.stop.bind(this), 0);
         } else if (newState.eventNow.endAction === EndAction.LoadNext) {
@@ -77,10 +126,8 @@ class RuntimeService {
       }
     }
 
-    const hasRunningTimer = Boolean(newState.eventNow) && newState.timer.playback === Playback.Play;
-    const shouldUpdateTimer =
-      hasRunningTimer && getShouldTimerUpdate(this.lastIntegrationTimerValue, newState.timer.current);
-
+    // 4. find if we need to update the timer
+    const shouldUpdateTimer = getShouldTimerUpdate(this.lastIntegrationTimerValue, newState.timer.current);
     if (shouldUpdateTimer) {
       process.nextTick(() => {
         integrationService.dispatch(TimerLifeCycle.onUpdate);
@@ -89,6 +136,7 @@ class RuntimeService {
       this.lastIntegrationTimerValue = newState.timer.current ?? -1;
     }
 
+    // 5. find if we need to update the clock
     const shouldUpdateClock = getShouldClockUpdate(this.lastIntegrationClockUpdate, newState.clock);
     if (shouldUpdateClock) {
       process.nextTick(() => {
@@ -97,49 +145,19 @@ class RuntimeService {
 
       this.lastIntegrationClockUpdate = newState.clock;
     }
-
-    if (shouldCallRoll) {
-      // we dont call this.roll because we need to bypass the checks
-      const rundown = getPlayableEvents();
-      this.eventTimer.roll(rundown);
-    }
-
-    const timerPhaseChanged = RuntimeService.previousState.timer?.phase !== newState.timer.phase;
-
-    if (timerPhaseChanged) {
-      switch (newState.timer.phase) {
-        case TimerPhase.Warning:
-          process.nextTick(() => {
-            integrationService.dispatch(TimerLifeCycle.onWarning);
-          });
-          break;
-        case TimerPhase.Danger:
-          process.nextTick(() => {
-            integrationService.dispatch(TimerLifeCycle.onDanger);
-          });
-          break;
-        default:
-          break;
-      }
-    }
   }
 
   /** delay initialisation until we have a restore point */
-  init(resumable: RestorePoint | null) {
+  public init(resumable: RestorePoint | null) {
     logger.info(LogOrigin.Server, 'Runtime service started');
-    // calculate at 30fps, refresh at 1fps
-    this.eventTimer = new TimerService({
-      refresh: timerConfig.updateRate,
-      updateInterval: timerConfig.notificationRate,
-      onUpdateCallback: (updateResult) => this.checkTimerUpdate(updateResult),
-    });
+    this.eventTimer.setOnUpdateCallback((updateResult) => this.checkTimerUpdate(updateResult));
 
     if (resumable) {
       this.resume(resumable);
     }
   }
 
-  shutdown() {
+  public shutdown() {
     if (this.eventTimer) {
       logger.info(LogOrigin.Server, 'Runtime service shutting down');
       this.eventTimer.shutdown();
@@ -164,7 +182,7 @@ class RuntimeService {
   }
 
   private isNewNext() {
-    const timedEvents = getPlayableEvents();
+    const timedEvents = getTimedEvents();
     const state = runtimeState.getState();
     const now = state.eventNow?.id;
     const next = state.eventNext?.id;
@@ -205,7 +223,7 @@ class RuntimeService {
    * Called when the underlying data has changed,
    * we check if the change affects the runtime
    */
-  maybeUpdate(playableEvents: OntimeEvent[], affectedIds?: string[]) {
+  public notifyOfChangedEvents(affectedIds?: string[]) {
     const state = runtimeState.getState();
     const hasLoadedElements = state.eventNow !== null || state.eventNext !== null;
     if (!hasLoadedElements) {
@@ -216,49 +234,55 @@ class RuntimeService {
     // 1. we are not confident that changes do not affect running event (eg. all events where changed)
     const safeOption = typeof affectedIds === 'undefined';
     // 2. the edited event is in memory (now or next) running
+    // behind conditional to avoid doing unnecessary work
     const eventInMemory = safeOption ? false : this.affectsLoaded(affectedIds);
     // 3. the edited event replaces next event
     let isNext = false;
 
+    // if we are not sure, or the event is in memory, we reload
     if (safeOption || eventInMemory) {
-      if (state.timer.playback === Playback.Roll) {
-        this.roll();
-      }
-      // load stuff again, but keep running if our events still exist
-      const eventNow = getEventWithId(state.eventNow.id);
-      if (!isOntimeEvent(eventNow)) {
+      if (state.eventNow !== null) {
+        // load stuff again, but keep running if our events still exist
+        const eventNow = getEventWithId(state.eventNow.id);
+        if (!isOntimeEvent(eventNow) || !isPlayableEvent(eventNow)) {
+          // maybe the event was deleted or the skip state was changed
+          runtimeState.stop();
+          return;
+        }
+        const onlyChangedNow = affectedIds?.length === 1 && affectedIds.at(0) === eventNow.id;
+
+        if (onlyChangedNow) {
+          runtimeState.updateLoaded(eventNow);
+        } else {
+          const rundown = getRundown();
+          runtimeState.updateAll(rundown);
+        }
         return;
       }
-      const onlyChangedNow = affectedIds?.length === 1 && affectedIds.at(0) === eventNow.id;
-      if (onlyChangedNow) {
-        runtimeState.reload(eventNow);
-      } else {
-        runtimeState.reloadAll(eventNow, playableEvents);
-      }
-      return;
     }
 
     // Maybe the event will become the next
     isNext = this.isNewNext();
     if (isNext) {
-      runtimeState.loadNext(playableEvents);
+      const timedEvents = getTimedEvents();
+      runtimeState.loadNext(timedEvents);
     }
   }
 
   /**
    * makes calls for loading and starting given event
-   * @param {OntimeEvent} event
+   * @param {PlayableEvent} event
+   * @param {Partial<TimerState & RestorePoint>} initialData
    * @return {boolean} success - whether an event was loaded
    */
-  @broadcastResult
-  loadEvent(event: OntimeEvent): boolean {
-    if (event.skip) {
+  private loadEvent(event: OntimeEvent, initialData?: Partial<TimerState & RestorePoint>): boolean {
+    if (!isPlayableEvent(event)) {
       logger.warning(LogOrigin.Playback, `Refused skipped event with ID ${event.id}`);
       return false;
     }
 
-    const timedEvents = getPlayableEvents();
-    const success = runtimeState.load(event, timedEvents);
+    const rundown = getRundown();
+    const success = runtimeState.load(event, rundown, initialData);
 
     if (success) {
       logger.info(LogOrigin.Playback, `Loaded event with ID ${event.id}`);
@@ -274,7 +298,8 @@ class RuntimeService {
    * @param {string} eventId
    * @return {boolean} success - whether an event was started
    */
-  startById(eventId: string): boolean {
+  @broadcastResult
+  public startById(eventId: string): boolean {
     const event = getEventWithId(eventId);
     if (!event || !isOntimeEvent(event)) {
       return false;
@@ -283,7 +308,7 @@ class RuntimeService {
     if (!loaded) {
       return false;
     }
-    return this.start();
+    return this.handleStart();
   }
 
   /**
@@ -291,7 +316,8 @@ class RuntimeService {
    * @param {number} eventIndex
    * @return {boolean} success - whether an event was started
    */
-  startByIndex(eventIndex: number): boolean {
+  @broadcastResult
+  public startByIndex(eventIndex: number): boolean {
     const event = getEventAtIndex(eventIndex);
     if (!event) {
       return false;
@@ -300,7 +326,7 @@ class RuntimeService {
     if (!loaded) {
       return false;
     }
-    return this.start();
+    return this.handleStart();
   }
 
   /**
@@ -308,7 +334,8 @@ class RuntimeService {
    * @param {string} cue
    * @return {boolean} success - whether an event was started
    */
-  startByCue(cue: string): boolean {
+  @broadcastResult
+  public startByCue(cue: string): boolean {
     const event = getNextEventWithCue(cue); //TODO: add index
     if (!event) {
       return false;
@@ -317,7 +344,7 @@ class RuntimeService {
     if (!loaded) {
       return false;
     }
-    return this.start();
+    return this.handleStart();
   }
 
   /**
@@ -325,7 +352,8 @@ class RuntimeService {
    * @param {string} eventId
    * @return {boolean} success - whether an event was loaded
    */
-  loadById(eventId: string): boolean {
+  @broadcastResult
+  public loadById(eventId: string): boolean {
     const event = getEventWithId(eventId);
     if (!event || !isOntimeEvent(event)) {
       return false;
@@ -338,7 +366,8 @@ class RuntimeService {
    * @param {number} eventIndex
    * @return {boolean} success - whether an event was loaded
    */
-  loadByIndex(eventIndex: number): boolean {
+  @broadcastResult
+  public loadByIndex(eventIndex: number): boolean {
     const event = getEventAtIndex(eventIndex);
     if (!event) {
       return false;
@@ -351,7 +380,8 @@ class RuntimeService {
    * @param {string} cue
    * @return {boolean} success - whether an event was loaded
    */
-  loadByCue(cue: string): boolean {
+  @broadcastResult
+  public loadByCue(cue: string): boolean {
     const event = getNextEventWithCue(cue); //TODO: add index
     if (!event) {
       return false;
@@ -360,10 +390,12 @@ class RuntimeService {
   }
 
   /**
-   * Loads event before currently selected
-   * @return {boolean} success - whether an event was loaded
+   * Contains logic for loading the previous event
+   *
+   * we need to isolate handleLoadPrevious so we have control over the side effects
+   * startSelected being a private function does not trigger emits
    */
-  loadPrevious(): boolean {
+  private handleLoadPrevious(): boolean {
     const state = runtimeState.getState();
     const previousEvent = findPrevious(state.eventNow?.id);
     if (previousEvent) {
@@ -373,13 +405,28 @@ class RuntimeService {
   }
 
   /**
-   * Loads event after currently selected
-   * @return {boolean} success
+   * Loads event before currently selected
+   * @return {boolean} success - whether an event was loaded
    */
-  loadNext(): boolean {
+  @broadcastResult
+  public loadPrevious(): boolean {
+    return this.handleLoadPrevious();
+  }
+
+  /**
+   * Contains logic for loading the next event
+   *
+   * we need to isolate handleLoadNext so we have control over the side effects
+   * startSelected being a private function does not trigger emits
+   * and pass on runtime offset in case of roll mode
+   */
+  private handleLoadNext(): boolean {
     const state = runtimeState.getState();
     const nextEvent = findNext(state.eventNow?.id);
     if (nextEvent) {
+      if (state.timer.playback === Playback.Roll) {
+        return this.loadEvent(nextEvent, { firstStart: state.runtime.actualStart });
+      }
       return this.loadEvent(nextEvent);
     }
 
@@ -388,18 +435,31 @@ class RuntimeService {
   }
 
   /**
-   * Starts playback on selected event
+   * Loads event after currently selected
+   * @return {boolean} success
    */
   @broadcastResult
-  start(): boolean {
-    const state = runtimeState.getState();
-    const canStart = validatePlayback(state.timer.playback).start;
+  public loadNext(): boolean {
+    return this.handleLoadNext();
+  }
+
+  /**
+   * Contains logic for starting selected event
+   *
+   * we need to isolate handleStart so we have control over the side effects
+   * startSelected being a private function does not trigger emits
+   */
+  private handleStart(): boolean {
+    const previousState = runtimeState.getState();
+    const canStart = validatePlayback(previousState.timer.playback, previousState.timer.phase).start;
     if (!canStart) {
       return false;
     }
 
     const didStart = this.eventTimer?.start() ?? false;
-    logger.info(LogOrigin.Playback, `Play Mode ${state.timer.playback.toUpperCase()}`);
+    const newState = runtimeState.getState();
+    logger.info(LogOrigin.Playback, `Play Mode ${newState.timer.playback.toUpperCase()}`);
+
     if (didStart) {
       process.nextTick(() => {
         integrationService.dispatch(TimerLifeCycle.onStart);
@@ -408,43 +468,52 @@ class RuntimeService {
     return didStart;
   }
 
+  /**
+   * Starts playback on selected event
+   */
+  @broadcastResult
+  public start(): boolean {
+    return this.handleStart();
+  }
+
   /**
    * Starts playback on previous event
    */
-  startPrevious(): boolean {
-    const hasPrevious = this.loadPrevious();
+  @broadcastResult
+  public startPrevious(): boolean {
+    const hasPrevious = this.handleLoadPrevious();
     if (!hasPrevious) {
       return false;
     }
 
-    return this.start();
+    return this.handleStart();
   }
 
   /**
    * Starts playback on next event
    */
-  startNext(): boolean {
-    const hasNext = this.loadNext();
+  @broadcastResult
+  public startNext(): boolean {
+    const hasNext = this.handleLoadNext();
     if (!hasNext) {
       return false;
     }
-
-    return this.start();
+    return this.handleStart();
   }
 
   /**
    * Pauses playback on selected event
    */
   @broadcastResult
-  pause() {
+  public pause() {
     const state = runtimeState.getState();
-    const canPause = validatePlayback(state.timer.playback).pause;
+    const canPause = validatePlayback(state.timer.playback, state.timer.phase).pause;
     if (!canPause) {
       return;
     }
     this.eventTimer?.pause();
-    const newState = state.timer.playback;
-    logger.info(LogOrigin.Playback, `Play Mode ${newState.toUpperCase()}`);
+    const newState = runtimeState.getState();
+    logger.info(LogOrigin.Playback, `Play Mode ${newState.timer.playback.toUpperCase()}`);
     process.nextTick(() => {
       integrationService.dispatch(TimerLifeCycle.onPause);
     });
@@ -454,16 +523,16 @@ class RuntimeService {
    * Stops timer and unloads any events
    */
   @broadcastResult
-  stop(): boolean {
+  public stop(): boolean {
     const state = runtimeState.getState();
-    const canStop = validatePlayback(state.timer.playback).stop;
+    const canStop = validatePlayback(state.timer.playback, state.timer.phase).stop;
     if (!canStop) {
       return false;
     }
     const didStop = this.eventTimer?.stop();
     if (didStop) {
-      const newState = state.timer.playback;
-      logger.info(LogOrigin.Playback, `Play Mode ${newState.toUpperCase()}`);
+      const newState = runtimeState.getState();
+      logger.info(LogOrigin.Playback, `Play Mode ${newState.timer.playback.toUpperCase()}`);
       process.nextTick(() => {
         integrationService.dispatch(TimerLifeCycle.onStop);
       });
@@ -477,16 +546,23 @@ class RuntimeService {
    * Reloads current event
    */
   @broadcastResult
-  reload() {
+  public reload() {
     const state = runtimeState.getState();
     if (state.eventNow) {
-      const eventId = runtimeState.reload();
-      if (eventId) {
-        logger.info(LogOrigin.Playback, `Loaded event with ID ${eventId}`);
-        process.nextTick(() => {
-          integrationService.dispatch(TimerLifeCycle.onLoad);
-        });
-      }
+      return this.loadEvent(state.eventNow);
+    }
+    return false;
+  }
+
+  /**
+   * Handles special case to call roll on a loaded event which we do not want to discard
+   */
+  private rollLoaded(offset?: number) {
+    const rundown = getRundown();
+    try {
+      runtimeState.roll(rundown, offset);
+    } catch (error) {
+      logger.error(LogOrigin.Server, `Roll: ${error}`);
     }
   }
 
@@ -494,24 +570,40 @@ class RuntimeService {
    * Sets playback to roll
    */
   @broadcastResult
-  roll() {
-    const beforeState = runtimeState.getState();
-    const canRoll = validatePlayback(beforeState.timer.playback).roll;
-    if (!canRoll) {
+  public roll(skipCheck: boolean = false) {
+    const previousState = runtimeState.getState();
+    if (!skipCheck) {
+      const canRoll = validatePlayback(previousState.timer.playback, previousState.timer.phase).roll;
+      if (!canRoll) {
+        return;
+      }
+    }
+
+    try {
+      const rundown = getRundown();
+      const result = runtimeState.roll(rundown);
+      if (result.eventId !== previousState.eventNow?.id) {
+        logger.info(LogOrigin.Playback, `Loaded event with ID ${result.eventId}`);
+        process.nextTick(() => {
+          integrationService.dispatch(TimerLifeCycle.onLoad);
+        });
+      }
+
+      if (result.didStart) {
+        process.nextTick(() => {
+          integrationService.dispatch(TimerLifeCycle.onStart);
+        });
+      }
+    } catch (error) {
+      logger.error(LogOrigin.Server, `Roll: ${error}`);
       return;
     }
 
-    const playableEvents = getPlayableEvents();
-    if (playableEvents.length === 0) {
-      logger.warning(LogOrigin.Server, 'Roll: no events found');
-      return;
+    const newState = runtimeState.getState();
+
+    if (previousState.timer.playback !== newState.timer.playback) {
+      logger.info(LogOrigin.Playback, `Play Mode ${newState.timer.playback.toUpperCase()}`);
     }
-
-    this.eventTimer.roll(playableEvents);
-
-    const state = runtimeState.getState();
-    const newState = state.timer.playback;
-    logger.info(LogOrigin.Playback, `Play Mode ${newState.toUpperCase()}`);
   }
 
   /**
@@ -519,7 +611,7 @@ class RuntimeService {
    * @param restorePoint
    */
   @broadcastResult
-  resume(restorePoint: RestorePoint) {
+  public resume(restorePoint: RestorePoint) {
     const { selectedEventId, playback } = restorePoint;
     if (playback === Playback.Roll) {
       this.roll();
@@ -531,14 +623,14 @@ class RuntimeService {
     }
 
     // the db would have to change for the event not to exist
-    // we do not kow the reason for the crash, so we check anyway
+    // we do not know the reason for the crash, so we check anyway
     const event = getEventWithId(selectedEventId);
-    if (!event || !isOntimeEvent(event)) {
+    if (!isOntimeEvent(event) || !isPlayableEvent(event)) {
       return;
     }
 
-    const timedEvents = getPlayableEvents();
-    runtimeState.resume(restorePoint, event, timedEvents);
+    const rundown = getRundown();
+    runtimeState.resume(restorePoint, event, rundown);
     logger.info(LogOrigin.Playback, 'Resuming playback');
   }
 
@@ -546,15 +638,26 @@ class RuntimeService {
    * Adds time to current event
    * @param {number} time - time to add in milliseconds
    */
-  addTime(time: number) {
+  @broadcastResult
+  public addTime(time: number) {
     if (this.eventTimer.addTime(time)) {
       logger.info(LogOrigin.Playback, `${time > 0 ? 'Added' : 'Removed'} ${millisToString(time)}`);
     }
   }
 }
 
-export const runtimeService = new RuntimeService();
+// calculate at 30fps, refresh at 1fps
+const eventTimer = new EventTimer({
+  refresh: timerConfig.updateRate,
+  updateInterval: timerConfig.notificationRate,
+});
+export const runtimeService = new RuntimeService(eventTimer);
 
+/**
+ * Decorator manages side effects from updating the runtime
+ * This should only be applied to functions that are exposed for consumption
+ * ie: whenever an external service makes a request, we update the state with the mutation result
+ */
 function broadcastResult(_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
   const originalMethod = descriptor.value;
 
@@ -566,7 +669,6 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
     // we do the comparison by explicitly for each property
     // to apply custom logic for different datasets
 
-    const shouldUpdateClock = getShouldClockUpdate(RuntimeService.previousClockUpdate, state.clock);
     const shouldForceTimerUpdate = getForceUpdate(RuntimeService.previousTimerUpdate, state.clock);
     const shouldUpdateTimer =
       shouldForceTimerUpdate || getShouldTimerUpdate(RuntimeService.previousTimerValue, state.timer.current);
@@ -600,6 +702,16 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
     updateEventIfChanged('eventNext', state);
     updateEventIfChanged('publicEventNext', state);
 
+    let syncBlockStartAt = false;
+
+    if (!deepEqual(RuntimeService?.previousState.currentBlock, state.currentBlock)) {
+      eventStore.set('currentBlock', state.currentBlock);
+      RuntimeService.previousState.currentBlock = { ...state.currentBlock };
+      syncBlockStartAt = true;
+    }
+
+    const shouldUpdateClock = syncBlockStartAt || getShouldClockUpdate(RuntimeService.previousClockUpdate, state.clock);
+
     if (shouldUpdateClock) {
       RuntimeService.previousClockUpdate = state.clock;
       eventStore.set('clock', state.clock);
@@ -643,6 +755,7 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
         addedTime: state.timer.addedTime,
         pausedAt: state._timer.pausedAt,
         firstStart: state.runtime.actualStart,
+        blockStartAt: state.currentBlock.startedAt,
       });
     }
 

apps/server/src/services/runtime-service/__tests__/rundownService.utils.test.ts

@@ -1,17 +1,26 @@
 import { MILLIS_PER_MINUTE } from 'ontime-utils';
 import { getShouldClockUpdate, getShouldTimerUpdate } from '../rundownService.utils.js';
 
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(0);
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
 describe('getShouldClockUpdate()', () => {
   it('should return true when we slid forwards', () => {
-    const previousUpdate = Date.now() - 2000; // 2 seconds ago
-    const now = Date.now();
+    const previousUpdate = Date.now(); // 2 seconds ago
+    const now = Date.now() + 2000;
     const result = getShouldClockUpdate(previousUpdate, now);
     expect(result).toBe(true);
   });
 
   it('should return true when we slid backwards', () => {
-    const previousUpdate = Date.now();
-    const now = Date.now() - 2000; // 2 seconds ago
+    const previousUpdate = Date.now() + 2000;
+    const now = Date.now(); // 2 seconds ago
     const result = getShouldClockUpdate(previousUpdate, now);
     expect(result).toBe(true);
   });
@@ -24,8 +33,8 @@ describe('getShouldClockUpdate()', () => {
   });
 
   it('should return false when clock is not a second ahead and force update is not required', () => {
-    const previousUpdate = Date.now() - 32;
-    const now = Date.now();
+    const previousUpdate = Date.now();
+    const now = Date.now() + 32;
     const result = getShouldClockUpdate(previousUpdate, now);
     expect(result).toBe(false);
   });

apps/server/src/services/timerUtils.ts

@@ -1,7 +1,6 @@
-import { MaybeNumber, MaybeString, OntimeEvent, Playback, TimerPhase, TimerType } from 'ontime-types';
+import { MaybeNumber, Playback, TimerPhase, TimerType } from 'ontime-types';
 import { dayInMs } from 'ontime-utils';
 import { RuntimeState } from '../stores/runtimeState.js';
-import { timerConfig } from '../config/config.js';
 
 /**
  * handle events that span over midnight
@@ -56,6 +55,12 @@ export function getExpectedFinish(state: RuntimeState): MaybeNumber {
  */
 
 export function getCurrent(state: RuntimeState): number {
+  // eslint-disable-next-line no-unused-labels -- dev code path
+  DEV: {
+    if (state.eventNow === null || state.timer.duration === null) {
+      throw new Error('timerUtils.getCurrent: invalid state received');
+    }
+  }
   const { startedAt, duration, addedTime } = state.timer;
   const { timerType, timeStart, timeEnd } = state.eventNow;
   const { pausedAt } = state._timer;
@@ -88,6 +93,11 @@ export function getCurrent(state: RuntimeState): number {
  * @returns {boolean}
  */
 export function skippedOutOfEvent(state: RuntimeState, previousTime: number, skipLimit: number): boolean {
+  // we cant have skipped if we havent started
+  if (state.timer.expectedFinish === null || state.timer.startedAt === null) {
+    return false;
+  }
+
   const { startedAt, expectedFinish } = state.timer;
   const { clock } = state;
 
@@ -101,199 +111,6 @@ export function skippedOutOfEvent(state: RuntimeState, previousTime: number, ski
   return hasSkipped && (adjustedClock > adjustedExpectedFinish || adjustedClock < startedAt);
 }
 
-type RollTimers = {
-  nowIndex: MaybeNumber;
-  nowId: MaybeString;
-  publicIndex: MaybeNumber;
-  nextIndex: MaybeNumber;
-  publicNextIndex: MaybeNumber;
-  timeToNext: MaybeNumber;
-  nextEvent: OntimeEvent | null;
-  nextPublicEvent: OntimeEvent | null;
-  currentEvent: OntimeEvent | null;
-  currentPublicEvent: OntimeEvent | null;
-};
-
-/**
- * Finds loading information given a current rundown and time
- * @param {OntimeEvent[]} rundown - List of playable events
- * @param {number} timeNow - time now in ms
- */
-export const getRollTimers = (rundown: OntimeEvent[], timeNow: number, currentIndex?: number | null): RollTimers => {
-  let nowIndex: MaybeNumber = null; // index of event now
-  let nowId: MaybeString = null; // id of event now
-  let publicIndex: MaybeNumber = null; // index of public event now
-  let nextIndex: MaybeNumber = null; // index of next event
-  let publicNextIndex: MaybeNumber = null; // index of next public event
-  let timeToNext: MaybeNumber = null; // counter: time for next event
-  let publicTimeToNext: MaybeNumber = null; // counter: time for next public event
-
-  const hasLoaded = currentIndex !== null;
-  const canFilter = hasLoaded && currentIndex === rundown.length - 1;
-  const filteredRundown = canFilter ? rundown.slice(currentIndex) : rundown;
-
-  const lastEvent = filteredRundown.at(-1);
-  const lastNormalEnd = normaliseEndTime(lastEvent.timeStart, lastEvent.timeEnd);
-
-  let nextEvent: OntimeEvent | null = null;
-  let nextPublicEvent: OntimeEvent | null = null;
-  let currentEvent: OntimeEvent | null = null;
-  let currentPublicEvent: OntimeEvent | null = null;
-
-  if (timeNow > lastNormalEnd) {
-    // we are past last end
-    // preload first and find next
-
-    const firstEvent = filteredRundown.at(0);
-    nextIndex = 0;
-    nextEvent = firstEvent;
-    timeToNext = firstEvent.timeStart + dayInMs - timeNow;
-
-    if (firstEvent.isPublic) {
-      nextPublicEvent = firstEvent;
-      publicNextIndex = 0;
-    } else {
-      // look for next public
-      // dev note: we feel that this is more efficient than filtering
-      // since the next event will likely be close to the one playing
-      for (const event of filteredRundown) {
-        if (event.isPublic) {
-          nextPublicEvent = event;
-          // we need the index before this was sorted
-          publicNextIndex = filteredRundown.findIndex((rundownEvent) => rundownEvent.id === event.id);
-          break;
-        }
-      }
-    }
-  } else {
-    // flags: select first event if several overlapping
-    let nowFound = false;
-    // keep track of the end times when looking for public
-    let publicTime = -1;
-
-    for (const event of filteredRundown) {
-      // When does the event end (handle midnight)
-      const normalEnd = normaliseEndTime(event.timeStart, event.timeEnd);
-
-      const hasNotEnded = normalEnd > timeNow;
-      const isFromDayBefore = normalEnd > dayInMs && timeNow < event.timeEnd;
-      const hasStarted = isFromDayBefore || timeNow >= event.timeStart;
-
-      if (normalEnd <= timeNow) {
-        // event ran already
-
-        if (event.isPublic && normalEnd > publicTime) {
-          // public event might not be the one running
-          publicTime = normalEnd;
-          currentPublicEvent = event;
-          publicIndex = filteredRundown.findIndex((rundownEvent) => rundownEvent.id === event.id);
-        }
-      } else if (hasNotEnded && hasStarted && !nowFound) {
-        // event is running
-        currentEvent = event;
-        nowIndex = filteredRundown.findIndex((rundownEvent) => rundownEvent.id === event.id);
-        nowId = event.id;
-        nowFound = true;
-
-        // it could also be public
-        if (event.isPublic) {
-          publicTime = normalEnd;
-          currentPublicEvent = event;
-          publicIndex = filteredRundown.findIndex((rundownEvent) => rundownEvent.id === event.id);
-        }
-      } else if (normalEnd > timeNow) {
-        // event will run
-
-        // we already know whats next and next-public
-        if (nextIndex !== null && publicNextIndex !== null) {
-          continue;
-        }
-
-        // look for next events
-        // check how far the start is from now
-        const timeToEventStart = event.timeStart - timeNow;
-
-        // we don't have a next or this one starts sooner than current next
-        if (nextIndex === null || timeToEventStart < timeToNext) {
-          timeToNext = timeToEventStart;
-          nextEvent = event;
-          nextIndex = filteredRundown.findIndex((rundownEvent) => rundownEvent.id === event.id);
-        }
-
-        if (event.isPublic) {
-          // if we don't have a public next or this one start sooner than assigned next
-          if (publicNextIndex === null || timeToEventStart < publicTimeToNext) {
-            publicTimeToNext = timeToEventStart;
-            nextPublicEvent = event;
-            publicNextIndex = filteredRundown.findIndex((rundownEvent) => rundownEvent.id === event.id);
-          }
-        }
-      }
-    }
-  }
-
-  return {
-    nowIndex,
-    nowId,
-    publicIndex,
-    nextIndex,
-    publicNextIndex,
-    timeToNext,
-    nextEvent,
-    nextPublicEvent,
-    currentEvent,
-    currentPublicEvent,
-  };
-};
-
-/**
- * @description Implements update functions for roll mode
- * @param {RuntimeState}
- * @returns object with selection variables
- */
-export const updateRoll = (state: RuntimeState) => {
-  const { current, expectedFinish, startedAt, secondaryTimer } = state.timer;
-  const { secondaryTarget } = state._timer;
-  const { clock } = state;
-  const selectedEventId = state.eventNow?.id ?? null;
-
-  // timers
-  let updatedTimer = current;
-  let updatedSecondaryTimer = secondaryTimer;
-  // whether rollLoad should be called: force reload of events
-  let doRollLoad = false;
-  // whether finished event should trigger
-  let isPrimaryFinished = false;
-
-  if (selectedEventId && current !== null) {
-    // if we have something selected and a timer, we are running
-
-    const finishAt = expectedFinish >= startedAt ? expectedFinish : expectedFinish + dayInMs;
-    updatedTimer = finishAt - clock;
-
-    if (updatedTimer > dayInMs) {
-      updatedTimer -= dayInMs;
-    }
-
-    if (updatedTimer <= timerConfig.triggerAhead) {
-      isPrimaryFinished = true;
-      // we need a new event
-      doRollLoad = true;
-    }
-  } else if (secondaryTimer >= 0) {
-    // if secondaryTimer is running we are in waiting to roll
-
-    updatedSecondaryTimer = secondaryTarget - clock;
-
-    if (updatedSecondaryTimer <= 0) {
-      // we need a new event
-      doRollLoad = true;
-    }
-  }
-
-  return { updatedTimer, updatedSecondaryTimer, doRollLoad, isFinished: isPrimaryFinished };
-};
-
 /**
  * Calculates difference between the runtime and the schedule of an event
  * Positive offset is time ahead
@@ -305,6 +122,14 @@ export function getRuntimeOffset(state: RuntimeState): number {
     return 0;
   }
 
+  // eslint-disable-next-line no-unused-labels -- dev code path
+  DEV: {
+    // we know current exists as long as eventNow exists
+    if (state.timer.current === null) {
+      throw new Error('timerUtils.calculate: current must be set');
+    }
+  }
+
   const { clock } = state;
   const { timeStart, timerType } = state.eventNow;
   const { addedTime, current, startedAt } = state.timer;
@@ -356,7 +181,7 @@ export function getTotalDuration(firstStart: number, lastEnd: number, daySpan: n
  */
 export function getExpectedEnd(state: RuntimeState): MaybeNumber {
   // there is no expected end if we havent started
-  if (state.runtime.actualStart === null) {
+  if (state.runtime.actualStart === null || state.runtime.plannedEnd === null) {
     return null;
   }
   return state.runtime.plannedEnd - state.runtime.offset + state._timer.totalDelay;
@@ -367,7 +192,7 @@ export function getExpectedEnd(state: RuntimeState): MaybeNumber {
  * @param state
  * @returns
  */
-function isPlaybackActive(state: RuntimeState): boolean {
+export function isPlaybackActive(state: RuntimeState): boolean {
   return (
     state.timer.playback === Playback.Play ||
     state.timer.playback === Playback.Pause ||
@@ -386,7 +211,7 @@ export function getTimerPhase(state: RuntimeState): TimerPhase {
 
   const current = state.timer.current;
 
-  if (current === null || state.eventNow === null) {
+  if (current === null || state.eventNow === null || state.timer.secondaryTimer != null) {
     return TimerPhase.Pending;
   }
 

apps/server/src/setup/config.ts

@@ -5,7 +5,6 @@ export const config = {
   demoProject: 'demo project.json',
   newProject: 'new project.json',
   database: {
-    testdb: 'test-db',
     directory: 'db',
     filename: 'db.json',
   },

apps/server/src/setup/index.ts

@@ -73,7 +73,6 @@ export const resolvedPath = (): string => {
 export const resolvePublicDirectoy = getAppDataPath();
 ensureDirectory(resolvePublicDirectoy);
 
-const testDbStartDirectory = isTest ? '../' : resolvePublicDirectoy;
 export const externalsStartDirectory = isProduction ? resolvePublicDirectoy : join(srcDirectory, 'external');
 // TODO: we only need one when they are all in the same folder
 export const resolveExternalsDirectory = join(isProduction ? resolvePublicDirectoy : srcDirectory, 'external');
@@ -82,13 +81,6 @@ export const resolveExternalsDirectory = join(isProduction ? resolvePublicDirect
 export const appStatePath = join(resolvePublicDirectoy, config.appState);
 export const uploadsFolderPath = join(resolvePublicDirectoy, config.uploads);
 
-// path to public db
-export const resolveDbDirectory = join(testDbStartDirectory, isTest ? `../${config.database.testdb}` : config.projects);
-
-export const pathToStartDb = isTest
-  ? join(srcDirectory, '..', config.database.testdb, config.database.filename)
-  : join(srcDirectory, '/preloaded-db/', config.database.filename);
-
 // path to public styles
 export const resolveStylesDirectory = join(externalsStartDirectory, config.styles.directory);
 export const resolveStylesPath = join(resolveStylesDirectory, config.styles.filename);