refactor: finish of count-to-end is plan or start time

refactor(rundown): improve visibility of count to end
refactor(time control): improve handling of overtime and count to end
2026-07-26 10:38:55 +00:00 · 2026-07-17 22:24:59 +02:00 · 2026-07-17 11:04:36 +02:00 · 2026-07-17 11:01:40 +02:00 · 2026-07-14 14:31:08 +02:00 · 2026-07-14 14:31:08 +02:00
94 changed files with 3160 additions and 908 deletions
@@ -0,0 +1,14 @@
+.kbd {
+  display: inline-block;
+  min-width: 1.5rem;
+  padding: 0.0625rem 0.375rem;
+  border-radius: 2px;
+  background-color: $gray-1100;
+  color: $ui-white;
+  box-shadow: 0 0 3px rgba(0, 0, 0, 0.4);
+  font-family: monospace;
+  font-size: calc(1rem - 4px);
+  line-height: 1.5;
+  text-align: center;
+  white-space: nowrap;
+}
@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+
+import style from './Kbd.module.scss';
+
+export default function Kbd({ children }: PropsWithChildren) {
+  return <kbd className={style.kbd}>{children}</kbd>;
+}
@@ -38,8 +38,6 @@ $progress-bar-br: 3px;
 .multiprogress-bar__indicator-bar {
  background-color: var(--background-color-override, $ui-black);
  opacity: 0.8;
-  transition: 1s linear;
-  transition-property: width;

  .multiprogress-bar--ignore-css-override & {
    background-color: $ui-black;
@@ -1,5 +1,6 @@
 import { MaybeNumber } from 'ontime-types';

+import { useAnimatedProgress } from '../../hooks/useAnimatedProgress';
 import { getProgress } from '../../utils/getProgress';
 import { cx } from '../../utils/styleUtils';

@@ -34,7 +35,7 @@ export default function MultiPartProgressBar(props: MultiPartProgressBar) {
    className = '',
  } = props;

-  const percentRemaining = 100 - getProgress(now, complete);
+  const percentRemaining = 100 - useAnimatedProgress(now, complete);
  const dangerWidth = danger ? 100 - getProgress(danger, complete) : 0;
  const warningWidth = warning ? 100 - dangerWidth - getProgress(warning, complete) : 0;
  const isOvertime = now !== null && now < 0;
@@ -1,6 +1,8 @@
 import { useDisclosure, useHotkeys } from '@mantine/hooks';
 import { memo } from 'react';
+import { useSearchParams } from 'react-router';

+import { hasCustomParams, useSavedViewParams } from '../../stores/savedViewParams';
 import { useViewParamsEditorStore } from '../view-params-editor/viewParamsEditor.store';
 import FloatingNavigation from './floating-navigation/FloatingNavigation';
 import NavigationMenu from './NavigationMenu';
@@ -17,6 +19,9 @@ export default memo(ViewNavigationMenu);
 function ViewNavigationMenu({ isNavigationLocked, suppressSettings }: ViewNavigationMenuProps) {
  const [isMenuOpen, menuHandler] = useDisclosure();
  const { open: showEditFormDrawer } = useViewParamsEditorStore();
+  const [searchParams] = useSearchParams();
+  const savedParams = useSavedViewParams((store) => store.params);
+  const hasSavedChanges = hasCustomParams(searchParams) || Object.keys(savedParams).length > 0;

  useHotkeys([
    [
@@ -46,6 +51,7 @@ function ViewNavigationMenu({ isNavigationLocked, suppressSettings }: ViewNaviga
      <FloatingNavigation
        toggleMenu={isNavigationLocked ? undefined : menuHandler.toggle}
        toggleSettings={suppressSettings ? undefined : showEditFormDrawer}
+        hasSavedChanges={hasSavedChanges}
      />
      {!isNavigationLocked && <NavigationMenu isOpen={isMenuOpen} onClose={menuHandler.close} />}
    </>
@@ -1,4 +1,29 @@
-.linkIcon {
+.trailing {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
  margin-left: auto;
+}
+
+.linkIcon {
  @include rotate-fourty-five;
 }
+
+.indicator {
+  width: 0.5rem;
+  height: 0.5rem;
+  border-radius: 50%;
+  background-color: $active-indicator;
+  pointer-events: none;
+  flex-shrink: 0;
+}
+
+.clear {
+  opacity: 0.6;
+  transition: opacity $transition-time-action;
+
+  &:hover,
+  &:focus-visible {
+    opacity: 1;
+  }
+}
@@ -1,9 +1,16 @@
-import { PropsWithChildren } from 'react';
-import { IoArrowUp } from 'react-icons/io5';
-import { useNavigate } from 'react-router';
+import { MouseEvent, PropsWithChildren } from 'react';
+import { IoArrowUp, IoCloseOutline } from 'react-icons/io5';
+import { useLocation, useNavigate, useSearchParams } from 'react-router';

 import { useElectronEvent } from '../../../hooks/useElectronEvent';
+import {
+  hasCustomParams,
+  reservedParams,
+  stripReservedParams,
+  useSavedViewParams,
+} from '../../../stores/savedViewParams';
 import { handleLinks } from '../../../utils/linkUtils';
+import IconButton from '../../buttons/IconButton';
 import NavigationMenuItem from '../navigation-menu-item/NavigationMenuItem';

 import style from './ClientLink.module.scss';
@@ -16,32 +23,100 @@ interface ClientLinkProps {

 export default function ClientLink({ current, to, postAction, children }: PropsWithChildren<ClientLinkProps>) {
  const { isElectron } = useElectronEvent();
-  const navigate = useNavigate();

  if (isElectron) {
    return (
-      <NavigationMenuItem
-        active={current}
-        onClick={() => {
-          handleLinks(to);
-          postAction?.();
-        }}
-      >
+      <ElectronNavigationItem current={current} to={to} postAction={postAction}>
        {children}
-        <IoArrowUp className={style.linkIcon} />
-      </NavigationMenuItem>
+      </ElectronNavigationItem>
    );
  }

  return (
-    <NavigationMenuItem
-      active={current}
-      onClick={() => {
-        navigate(`/${to}`);
-        postAction?.();
-      }}
-    >
+    <BrowserNavigationItem current={current} to={to} postAction={postAction}>
      {children}
+    </BrowserNavigationItem>
+  );
+}
+
+function ElectronNavigationItem({ current, to, postAction, children }: PropsWithChildren<ClientLinkProps>) {
+  const navigateToLink = () => {
+    handleLinks(to);
+    postAction?.();
+  };
+
+  return (
+    <NavigationMenuItem active={current} onClick={navigateToLink}>
+      {children}
+      <span className={style.trailing}>
+        <IoArrowUp className={style.linkIcon} />
+      </span>
+    </NavigationMenuItem>
+  );
+}
+
+function BrowserNavigationItem({ current, to, postAction, children }: PropsWithChildren<ClientLinkProps>) {
+  const navigate = useNavigate();
+  const location = useLocation();
+  const [searchParams, setSearchParams] = useSearchParams();
+  const { params: savedParams, save, clear } = useSavedViewParams();
+
+  /**
+   * Save the params of the view we are leaving and resolve the destination,
+   * restoring any params previously saved for the target view.
+   */
+  const resolveDestination = () => {
+    const currentView = location.pathname.replace(/^\//, '');
+    save(currentView, stripReservedParams(location.search));
+    const restored = savedParams[to];
+    return `${to}${restored ? `?${restored}` : ''}`;
+  };
+
+  const isCustomised = current ? hasCustomParams(searchParams) : Boolean(savedParams[to]);
+
+  const navigateToLink = () => {
+    const destination = resolveDestination();
+    navigate(`/${destination}`);
+    postAction?.();
+  };
+
+  /**
+   * Clear the saved settings for this route without navigating to it.
+   * When it is the current view, also reset the live URL to its defaults.
+   */
+  const clearViewSettings = (event: MouseEvent) => {
+    event.stopPropagation();
+    clear(to);
+
+    // if mounted, clear the URL params
+    if (current) {
+      const preserved = new URLSearchParams();
+      reservedParams.forEach((key) => {
+        const value = searchParams.get(key);
+        if (value !== null) preserved.set(key, value);
+      });
+      setSearchParams(preserved);
+    }
+  };
+
+  return (
+    <NavigationMenuItem active={current} onClick={navigateToLink}>
+      {children}
+      {isCustomised && (
+        <span className={style.trailing}>
+          <span className={style.indicator} aria-hidden data-testid='client-link__saved-indicator' />
+          <IconButton
+            variant='ghosted-white'
+            size='small'
+            className={style.clear}
+            aria-label='Clear saved view settings'
+            title='Clear saved view settings'
+            onClick={clearViewSettings}
+          >
+            <IoCloseOutline />
+          </IconButton>
+        </span>
+      )}
    </NavigationMenuItem>
  );
 }
@@ -22,3 +22,19 @@
  top: 0;
  z-index: $zindex-nav;
 }
+
+.buttonWithIndicator {
+  position: relative;
+  display: inline-flex;
+}
+
+.indicator {
+  position: absolute;
+  top: -0.15rem;
+  right: -0.15rem;
+  width: 0.6rem;
+  height: 0.6rem;
+  border-radius: 50%;
+  background-color: $active-indicator;
+  pointer-events: none;
+}
@@ -9,9 +9,10 @@ import style from './FloatingNavigation.module.scss';
 interface FloatingNavigationProps {
  toggleMenu?: () => void;
  toggleSettings?: () => void;
+  hasSavedChanges?: boolean;
 }

-export default function FloatingNavigation({ toggleMenu, toggleSettings }: FloatingNavigationProps) {
+export default function FloatingNavigation({ toggleMenu, toggleSettings, hasSavedChanges }: FloatingNavigationProps) {
  const isButtonShown = useFadeOutOnInactivity(true);

  return (
@@ -20,15 +21,18 @@ export default function FloatingNavigation({ toggleMenu, toggleSettings }: Float
      className={cx([style.fadeable, style.buttonContainer, !isButtonShown && style.hidden])}
    >
      {toggleMenu && (
-        <IconButton
-          variant='subtle-white'
-          size='xlarge'
-          onClick={toggleMenu}
-          aria-label='toggle menu'
-          data-testid='navigation__toggle-menu'
-        >
-          <IoApps />
-        </IconButton>
+        <div className={style.buttonWithIndicator}>
+          <IconButton
+            variant='subtle-white'
+            size='xlarge'
+            onClick={toggleMenu}
+            aria-label='toggle menu'
+            data-testid='navigation__toggle-menu'
+          >
+            <IoApps />
+          </IconButton>
+          {hasSavedChanges && <span className={style.indicator} data-testid='navigation__saved-indicator' />}
+        </div>
      )}
      {toggleSettings && (
        <IconButton
@@ -14,6 +14,4 @@ $progress-bar-br: 3px;
 .progress-bar__indicator {
  height: $progress-bar-size;
  background-color: var(--timer-progress-override, $accent-color);
-  transition: 1s linear;
-  transition-property: width;
 }
@@ -1,6 +1,6 @@
 import { MaybeNumber } from 'ontime-types';

-import { getProgress } from '../../utils/getProgress';
+import { useAnimatedProgress } from '../../hooks/useAnimatedProgress';

 import './ProgressBar.scss';

@@ -12,7 +12,7 @@ interface ProgressBarProps {

 export default function ProgressBar(props: ProgressBarProps) {
  const { current, duration, className } = props;
-  const progress = getProgress(current, duration);
+  const progress = useAnimatedProgress(current, duration);

  return (
    <div className={`progress-bar__bg ${className}`}>
@@ -4,7 +4,9 @@
  color: $white-10;

  .empty {
-    width: 100%;
+    display: block;
+    width: min(100%, 24rem);
+    margin-inline: auto;
    opacity: 0.8;
  }

@@ -13,6 +15,6 @@
    margin-inline: auto;
    font-weight: 600;
    font-size: 2em;
-    max-width: 600px;
+    max-width: min(100%, 600px);
  }
 }
@@ -0,0 +1,41 @@
+import { MaybeNumber, Playback } from 'ontime-types';
+import { useEffect, useRef, useState } from 'react';
+
+import { getProgress } from '../utils/getProgress';
+import { usePlayback } from './useSocket';
+
+/**
+ * Returns the live completion percentage (0–100) of a countdown, interpolated locally.
+ */
+export function useAnimatedProgress(current: MaybeNumber, duration: MaybeNumber): number {
+  const playback = usePlayback();
+  const isRunning = playback === Playback.Play || playback === Playback.Roll;
+
+  const baseline = useRef({ current, at: performance.now() });
+  const [, setTick] = useState(0);
+
+  // there is only something to animate while a running timer is counting down towards 0
+  const shouldAnimate = isRunning && current !== null && current > 0 && duration !== null;
+
+  // re-anchor to the authoritative value whenever the server pushes a new timer update
+  useEffect(() => {
+    baseline.current = { current, at: performance.now() };
+  }, [current, duration, playback]);
+
+  // while counting down, re-render every animation frame so the derived progress stays smooth
+  useEffect(() => {
+    if (!shouldAnimate) {
+      return;
+    }
+    let frame = requestAnimationFrame(function tick() {
+      setTick((value) => value + 1);
+      frame = requestAnimationFrame(tick);
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [shouldAnimate]);
+
+  // derive from the anchor plus elapsed time at render; frozen to the anchor when not running
+  const anchored = baseline.current.current;
+  const value = isRunning && anchored !== null ? anchored - (performance.now() - baseline.current.at) : anchored;
+  return getProgress(value, duration);
+}
@@ -139,6 +139,17 @@ export const setEventPlayback = {
  pause: () => sendSocket('pause', undefined),
 };

+export const useTimerProgress = createSelector((state: RuntimeStore) => ({
+  playback: state.timer.playback,
+  phase: state.timer.phase,
+  addedTime: state.timer.addedTime,
+  secondaryTimer: state.timer.secondaryTimer,
+  current: state.timer.current,
+  expectedFinish: state.timer.expectedFinish,
+  startedAt: state.timer.startedAt,
+  isCountToEnd: state.eventNow?.countToEnd ?? false,
+}));
+
 export const useTimer = createSelector((state: RuntimeStore) => ({
  ...state.timer,
 }));
@@ -0,0 +1,87 @@
+import { hasCustomParams, stripReservedParams, useSavedViewParams } from '../savedViewParams';
+
+describe('savedViewParams store', () => {
+  beforeEach(() => {
+    useSavedViewParams.getState().clearAll();
+  });
+
+  it('saves and restores params per view', () => {
+    useSavedViewParams.getState().save('timer', 'hideSeconds=true');
+    useSavedViewParams.getState().save('backstage', 'showProgress=false');
+
+    expect(useSavedViewParams.getState().params.timer).toBe('hideSeconds=true');
+    expect(useSavedViewParams.getState().params.backstage).toBe('showProgress=false');
+  });
+
+  it('overwrites the saved params for a view on subsequent saves', () => {
+    useSavedViewParams.getState().save('timer', 'hideSeconds=true');
+    useSavedViewParams.getState().save('timer', 'hideSeconds=false');
+
+    expect(useSavedViewParams.getState().params.timer).toBe('hideSeconds=false');
+  });
+
+  it('does not store an entry for an empty search string', () => {
+    useSavedViewParams.getState().save('timer', '');
+
+    expect(useSavedViewParams.getState().params).toEqual({});
+  });
+
+  it('removes a previously saved entry when saved with an empty search string', () => {
+    useSavedViewParams.getState().save('timer', 'hideSeconds=true');
+    useSavedViewParams.getState().save('timer', '');
+
+    expect(useSavedViewParams.getState().params).toEqual({});
+  });
+
+  it('ignores empty view keys', () => {
+    useSavedViewParams.getState().save('', 'hideSeconds=true');
+
+    expect(useSavedViewParams.getState().params).toEqual({});
+  });
+
+  it('clears the saved params for a single view without touching others', () => {
+    useSavedViewParams.getState().save('timer', 'hideSeconds=true');
+    useSavedViewParams.getState().save('backstage', 'showProgress=false');
+    useSavedViewParams.getState().clear('timer');
+
+    expect(useSavedViewParams.getState().params).toEqual({ backstage: 'showProgress=false' });
+  });
+
+  it('is a no-op when clearing a view without saved params', () => {
+    useSavedViewParams.getState().save('backstage', 'showProgress=false');
+    useSavedViewParams.getState().clear('timer');
+
+    expect(useSavedViewParams.getState().params).toEqual({ backstage: 'showProgress=false' });
+  });
+
+  it('clears all saved params', () => {
+    useSavedViewParams.getState().save('timer', 'hideSeconds=true');
+    useSavedViewParams.getState().clearAll();
+
+    expect(useSavedViewParams.getState().params).toEqual({});
+  });
+});
+
+describe('stripReservedParams', () => {
+  it('removes reserved auth/preset params while keeping view customisation', () => {
+    expect(stripReservedParams('hideSeconds=true&token=abc&n=1&alias=my')).toBe('hideSeconds=true');
+  });
+
+  it('returns an empty string when only reserved params are present', () => {
+    expect(stripReservedParams('token=abc&n=1&alias=my')).toBe('');
+  });
+});
+
+describe('hasCustomParams', () => {
+  it('is true when a non-reserved param is present', () => {
+    expect(hasCustomParams(new URLSearchParams('hideSeconds=true&token=abc'))).toBe(true);
+  });
+
+  it('is false when only reserved params are present', () => {
+    expect(hasCustomParams(new URLSearchParams('token=abc&n=1&alias=my'))).toBe(false);
+  });
+
+  it('is false when there are no params', () => {
+    expect(hasCustomParams(new URLSearchParams(''))).toBe(false);
+  });
+});
@@ -0,0 +1,62 @@
+import { create } from 'zustand';
+
+// params that are auth/preset markers, not user view customisation (see common/utils/urlPresets.ts)
+export const reservedParams = new Set(['token', 'n', 'alias']);
+
+interface SavedViewParamsStore {
+  params: Record<string, string>; // view key (e.g. "timer") -> search string without leading "?"
+  save: (view: string, search: string) => void;
+  clear: (view: string) => void;
+  clearAll: () => void;
+}
+
+/**
+ * Remembers the last view parameters used for each view so they can be
+ * restored when the user navigates back to that view through the menu.
+ * In-memory only: persists across SPA navigation, resets on a full page reload.
+ */
+export const useSavedViewParams = create<SavedViewParamsStore>((set) => ({
+  params: {},
+  save: (view, search) =>
+    set((state) => {
+      // ignore empty view keys and do not store empty entries, so the
+      // "saved changes" indicator only reflects genuine customisation
+      if (!view) return state;
+      const params = { ...state.params };
+      if (search) {
+        params[view] = search;
+      } else {
+        delete params[view];
+      }
+      return { params };
+    }),
+  clear: (view) =>
+    set((state) => {
+      if (!state.params[view]) return state;
+      const params = { ...state.params };
+      delete params[view];
+      return { params };
+    }),
+  clearAll: () => set({ params: {} }),
+}));
+
+/**
+ * Removes reserved (auth/preset) params from a search string, keeping only
+ * genuine view customisation.
+ */
+export function stripReservedParams(search: string): string {
+  const sp = new URLSearchParams(search);
+  reservedParams.forEach((key) => sp.delete(key));
+  return sp.toString();
+}
+
+/**
+ * Whether the search params contain any genuine view customisation,
+ * ignoring reserved params.
+ */
+export function hasCustomParams(searchParams: URLSearchParams): boolean {
+  for (const key of searchParams.keys()) {
+    if (!reservedParams.has(key)) return true;
+  }
+  return false;
+}
@@ -1,4 +1,4 @@
-import { linkToOtherHost } from '../linkUtils';
+import { hostToBaseUrl, linkToOtherHost } from '../linkUtils';

 describe('linkToOTherHost', () => {
  it('should handle electron links', () => {
@@ -22,3 +22,18 @@ describe('linkToOTherHost', () => {
    expect(destination).toBe('https://app.getontime.no/user-hash/path');
  });
 });
+
+describe('hostToBaseUrl', () => {
+  it('uses http when the page is plain http', () => {
+    expect(hostToBaseUrl('192.168.10.166', 4001, 'http://localhost:4001')).toBe('http://192.168.10.166:4001');
+  });
+
+  it('keeps https when the page reaches the server over TLS on the same port', () => {
+    expect(hostToBaseUrl('192.168.10.166', 4001, 'https://localhost:4001')).toBe('https://192.168.10.166:4001');
+  });
+
+  it('falls back to http when the page is https on a different port (TLS proxy)', () => {
+    // the raw server port does not speak TLS, an https link to it would fail
+    expect(hostToBaseUrl('192.168.10.166', 4001, 'https://ontime.example.com')).toBe('http://192.168.10.166:4001');
+  });
+});
@@ -37,7 +37,12 @@ export function handleLinks(
  event?.preventDefault();

  const destination = new URL(externalServerUrl);
-  destination.pathname = externalBaseURI ? `${externalBaseURI}/${location}` : location;
+  // split off any query string so it is not encoded into the pathname
+  const [pathname, search] = location.split('?');
+  destination.pathname = externalBaseURI ? `${externalBaseURI}/${pathname}` : pathname;
+  if (search) {
+    destination.search = search;
+  }
  openLink(destination.toString());
 }

@@ -54,3 +59,17 @@ export function linkToOtherHost(
  }
  return destination.toString();
 }
+
+/**
+ * Builds a base URL for reaching the Ontime server on a given network interface.
+ * The Ontime server itself only speaks HTTP, so we only keep https when the page
+ * already reaches the server over TLS on that same port (eg. a proxy in front of it);
+ * any other explicit server port gets http.
+ * externalServerUrl is used for testing
+ */
+export function hostToBaseUrl(host: string, port: number, externalServerUrl: string = serverURL): string {
+  const page = new URL(externalServerUrl);
+  const pagePort = page.port === '' ? (page.protocol === 'https:' ? 443 : 80) : Number(page.port);
+  const scheme = page.protocol === 'https:' && pagePort === port ? 'https' : 'http';
+  return `${scheme}://${host}:${port}`;
+}
@@ -4,6 +4,7 @@ import {
  MILLIS_PER_MINUTE,
  MILLIS_PER_SECOND,
  formatFromMillis,
+  getExpectedEnd,
  getExpectedStart,
 } from 'ontime-utils';

@@ -172,23 +173,28 @@ export function getExpectedTimesFromExtendedEvent(
 ) {
  if (event === null) return { expectedStart: 0, timeToStart: 0, expectedEnd: 0, plannedEnd: 0 };

+  const expectedStartState = {
+    totalGap: event.totalGap,
+    isLinkedToLoaded: event.isLinkedToLoaded,
+    ...state,
+  };
+
  const expectedStart = getExpectedStart(
    { timeStart: event.timeStart, delay: event.delay, dayOffset: event.dayOffset },
-    {
-      totalGap: event.totalGap,
-      isLinkedToLoaded: event.isLinkedToLoaded,
-      ...state,
-    },
+    expectedStartState,
  );

-  const plannedEnd = event.timeStart + event.duration + event.delay;
+  // count to end events are fixed to the scheduled end and ignore delays
+  const delayToAdd = event.countToEnd ? 0 : event.delay;
+  const plannedEnd = event.timeStart + event.duration + delayToAdd;
+
+  // we let timeToStart go negative to allow the UI to show due timers
+  const timeToStart = expectedStart - state.clock;

  return {
    expectedStart,
-    timeToStart: expectedStart - state.clock,
-    expectedEnd: event.countToEnd
-      ? Math.max(expectedStart + event.duration, plannedEnd)
-      : expectedStart + event.duration,
+    timeToStart,
+    expectedEnd: getExpectedEnd(event, expectedStartState),
    plannedEnd,
  };
 }
@@ -38,7 +38,7 @@ $inner-padding: 1rem;
 .section {
  position: relative;
  margin-top: 2rem;
-  max-width: 850px;
+  max-width: 1024px;
 }

 .indent {
@@ -2,33 +2,23 @@ import { useEffect, useState } from 'react';

 import { generateUrl } from '../../../../common/api/session';
 import CopyTag from '../../../../common/components/copy-tag/CopyTag';
-import useInfo from '../../../../common/hooks-query/useInfo';
-import { isOntimeCloud, serverURL } from '../../../../externals';
+import { serverURL } from '../../../../externals';
 import * as Panel from '../../panel-utils/PanelUtils';

 export default function McpSection() {
-  const { data: infoData } = useInfo();
  const [mcpEndpointUrl, setMcpEndpointUrl] = useState('');

  // generate url
  useEffect(() => {
-    const baseUrl = (() => {
-      if (isOntimeCloud) return serverURL;
-
-      // for local setups we prefer the localhost IP to avoid remote access
-      if (infoData.networkInterfaces.length > 0) {
-        return `http://${infoData.networkInterfaces[0].address}:${infoData.serverPort}`;
-      }
-      return serverURL;
-    })();
-
+    // the page origin is reachable wherever the user is browsing from,
+    // and follows the deployment (cloud, reverse proxy, port mappings)
    // we are reusing the endpoint, so locking config and nav have no effect
-    generateUrl({ baseUrl, path: 'mcp', authenticate: true, lockConfig: false, lockNav: false })
+    generateUrl({ baseUrl: serverURL, path: 'mcp', authenticate: true, lockConfig: false, lockNav: false })
      .then(setMcpEndpointUrl)
      .catch(() => {
        setMcpEndpointUrl('');
      });
-  }, [infoData]);
+  }, []);

  const mcpClientConfig = mcpEndpointUrl
    ? JSON.stringify({ mcpServers: { ontime: { url: mcpEndpointUrl } } }, null, 2)
@@ -40,14 +30,19 @@ export default function McpSection() {
        <Panel.SubHeader>MCP Server</Panel.SubHeader>
        <Panel.Paragraph>Connect any MCP-compatible AI agent to Ontime using the endpoint below.</Panel.Paragraph>
        <Panel.Divider />
-        <Panel.Field title='Endpoint URL' description='Add this URL to your MCP client settings' />
-        {mcpEndpointUrl && <CopyTag copyValue={mcpEndpointUrl}>{mcpEndpointUrl}</CopyTag>}
-        <Panel.Divider />
-        <Panel.Field
-          title='Client configuration snippet'
-          description='Paste this into your AI agent settings under "mcpServers"'
-        />
-        {mcpEndpointUrl && <CopyTag copyValue={mcpClientConfig}>{mcpClientConfig}</CopyTag>}
+        <Panel.ListGroup>
+          <Panel.ListItem>
+            <Panel.Field title='Endpoint URL' description='Add this URL to your MCP client settings' />
+            {mcpEndpointUrl && <CopyTag copyValue={mcpEndpointUrl}>{mcpEndpointUrl}</CopyTag>}
+          </Panel.ListItem>
+          <Panel.ListItem>
+            <Panel.Field
+              title='Client configuration snippet'
+              description='Paste this into your AI agent settings under "mcpServers"'
+            />
+            {mcpEndpointUrl && <CopyTag copyValue={mcpClientConfig}>{mcpClientConfig}</CopyTag>}
+          </Panel.ListItem>
+        </Panel.ListGroup>
      </Panel.Card>
    </Panel.Section>
  );
@@ -73,6 +73,10 @@
  margin-right: 0.25rem;
 }

+.tagOvertime {
+  color: $playback-over;
+}
+
 .time {
  color: $section-white;
  font-size: $text-body-size;
@@ -1,11 +1,12 @@
 import { MaybeNumber, Playback, TimerPhase } from 'ontime-types';
-import { dayInMs, millisToString } from 'ontime-utils';
+import { millisToString } from 'ontime-utils';
 import { PropsWithChildren } from 'react';

 import AppLink from '../../../../common/components/link/app-link/AppLink';
 import Tooltip from '../../../../common/components/tooltip/Tooltip';
 import useReport from '../../../../common/hooks-query/useReport';
-import { useTimer } from '../../../../common/hooks/useSocket';
+import { useTimerProgress } from '../../../../common/hooks/useSocket';
+import { cx } from '../../../../common/utils/styleUtils';
 import { formatDuration } from '../../../../common/utils/time';
 import TimerDisplay from '../timer-display/TimerDisplay';

@@ -24,15 +25,14 @@ function resolveAddedTimeLabel(addedTime: number) {
 }

 export default function PlaybackTimer({ children }: PropsWithChildren) {
-  const timer = useTimer();
+  'use memo';
+  const timer = useTimerProgress();

  const isRolling = timer.playback === Playback.Roll;
  const isWaiting = timer.phase === TimerPhase.Pending;
  const isOvertime = timer.phase === TimerPhase.Overtime;
  const hasAddedTime = Boolean(timer.addedTime);
-
  const rollLabel = isRolling ? 'Roll mode active' : '';
-
  const addedTimeLabel = resolveAddedTimeLabel(timer.addedTime);

  return (
@@ -51,7 +51,13 @@ export default function PlaybackTimer({ children }: PropsWithChildren) {
        {isWaiting ? (
          <span className={style.rolltag}>Roll: Countdown to start</span>
        ) : (
-          <RunningStatus startedAt={timer.startedAt} expectedFinish={timer.expectedFinish} playback={timer.playback} />
+          <RunningStatus
+            startedAt={timer.startedAt}
+            expectedFinish={timer.expectedFinish}
+            isStopped={timer.playback === Playback.Stop}
+            isCountToEnd={timer.isCountToEnd}
+            isOvertime={isOvertime}
+          />
        )}
      </div>
      {children}
@@ -62,16 +68,18 @@ export default function PlaybackTimer({ children }: PropsWithChildren) {
 interface RunningStatusProps {
  startedAt: MaybeNumber;
  expectedFinish: MaybeNumber;
-  playback: Playback;
+  isStopped: boolean;
+  isCountToEnd: boolean;
+  isOvertime: boolean;
 }
-function RunningStatus({ startedAt, expectedFinish, playback }: RunningStatusProps) {
-  if (playback === Playback.Stop) {
+
+function RunningStatus({ startedAt, expectedFinish, isStopped, isCountToEnd, isOvertime }: RunningStatusProps) {
+  if (isStopped) {
    return <StoppedStatus />;
  }

  const started = millisToString(startedAt);
-  const finishedMs = expectedFinish !== null ? expectedFinish % dayInMs : null;
-  const finish = millisToString(finishedMs);
+  const finish = millisToString(expectedFinish);

  return (
    <>
@@ -80,7 +88,9 @@ function RunningStatus({ startedAt, expectedFinish, playback }: RunningStatusPro
        <span className={style.time}>{started}</span>
      </span>
      <span className={style.finish}>
-        <span className={style.tag}>Expect end</span>
+        <span className={cx([style.tag, isOvertime && style.tagOvertime])}>
+          {isCountToEnd ? 'Scheduled end' : 'Expected end'}
+        </span>
        <span className={style.time}>{finish}</span>
      </span>
    </>
@@ -180,7 +180,13 @@ function Operator({ rundown, rundownMetadata, customFields, settings }: Operator

            return (
              <Fragment key={entry.id}>
-                <OperatorGroup key={entry.id} title={entry.title} />
+                <OperatorGroup
+                  key={entry.id}
+                  title={entry.title}
+                  colour={entry.colour}
+                  count={entry.entries.length}
+                  duration={entry.duration}
+                />
                {entry.entries.map((nestedEntryId) => {
                  const nestedEntry = rundown.entries[nestedEntryId];
                  if (!isOntimeEvent(nestedEntry)) {
@@ -217,6 +223,7 @@ function Operator({ rundown, rundownMetadata, customFields, settings }: Operator
                      isLinkedToLoaded={isLinkedToLoaded}
                      isSelected={isLoaded}
                      isPast={isPast}
+                      groupColour={entry.colour}
                      selectedRef={isLoaded ? selectedRef : undefined}
                      showStart={showStart}
                      subscribed={subscribedData}
@@ -22,17 +22,39 @@
    background-color: $gray-1250;
  }

+  &.grouped {
+    position: relative;
+    padding-left: 0.35rem;
+    background:
+      linear-gradient(90deg, color-mix(in srgb, transparent 88%, var(--group-colour, $gray-500) 12%), transparent 8rem),
+      $viewer-card-bg-color;
+  }
+
  &.running {
    border-top: 1px solid $gray-1300;
    background-color: var(--operator-running-bg-override, $active-green);
  }

+  &.grouped.running {
+    background:
+      linear-gradient(90deg, color-mix(in srgb, transparent 82%, var(--group-colour, $gray-500) 18%), transparent 8rem),
+      var(--operator-running-bg-override, $active-green);
+  }
+
  &.past {
    border-top: 1px solid transparent;
    opacity: 0.2;
  }
 }

+.groupRail {
+  position: absolute;
+  inset-block: 0;
+  left: 0;
+  width: 0.35rem;
+  background-color: var(--group-colour, $gray-500);
+}
+
 .binder {
  grid-area: binder;
  color: $section-white;
@@ -74,6 +96,9 @@
 .plannedStart,
 .timeUntil,
 .runningTime {
+  display: flex;
+  align-items: center;
+  gap: 0.25rem;
  border-radius: $component-border-radius-md;
  padding: 0.25rem 0.5rem;
  line-height: 1;
@@ -95,6 +120,21 @@
  letter-spacing: 1px;
 }

+.live {
+  color: $ui-black;
+  background-color: $ui-white;
+}
+
+.due {
+  color: $ui-black;
+  background-color: $orange-500;
+}
+
+.done {
+  color: $white-60;
+  background-color: $white-7;
+}
+
 .runningTime {
  grid-area: running;
  font-size: 1.25rem;
@@ -25,6 +25,7 @@ interface OperatorEventProps {
  isLinkedToLoaded: boolean;
  isSelected: boolean;
  isPast: boolean;
+  groupColour?: string;
  selectedRef?: RefObject<HTMLDivElement | null>;
  showStart: boolean;
  subscribed: Subscribed;
@@ -46,6 +47,7 @@ function OperatorEvent({
  isLinkedToLoaded,
  isSelected,
  isPast,
+  groupColour,
  selectedRef,
  showStart,
  subscribed,
@@ -68,7 +70,12 @@ function OperatorEvent({
  const mouseHandlers = useLongPress(handleLongPress);
  const cueColours = colour && getAccessibleColour(colour);

-  const operatorClasses = cx([style.event, isSelected && style.running, isPast && style.past]);
+  const operatorClasses = cx([
+    style.event,
+    groupColour && style.grouped,
+    isSelected && style.running,
+    isPast && style.past,
+  ]);

  const hasFields = subscribed.some((field) => field.value);
  const columnCount = subscribed.length ? Math.min(subscribed.length, 4) : 0;
@@ -85,8 +92,10 @@ function OperatorEvent({
      data-testid={cue}
      ref={selectedRef}
      onContextMenu={handleLongPress}
+      style={groupColour ? ({ '--group-colour': groupColour } as CSSProperties) : undefined}
      {...mouseHandlers}
    >
+      {groupColour && <div className={style.groupRail} />}
      <div className={style.binder} style={{ ...cueColours }}>
        <span className={style.cue}>{cue}</span>
      </div>
@@ -153,11 +162,11 @@ function OperatorEventSchedule({
  isLinkedToLoaded,
 }: OperatorEventScheduleProps) {
  if (isPast) {
-    return <span className={style.timeUntil}>DONE</span>;
+    return <span className={cx([style.timeUntil, style.done])}>DONE</span>;
  }

  if (isSelected) {
-    return <span className={style.timeUntil}>LIVE</span>;
+    return <span className={cx([style.timeUntil, style.live])}>LIVE</span>;
  }

  return (
@@ -186,7 +195,7 @@ function TimeUntil({ timeStart, delay, dayOffset, totalGap, isLinkedToLoaded }:
  const timeUntilString = isDue ? 'DUE' : `${formatDuration(Math.abs(timeUntil), timeUntil > 2 * MILLIS_PER_MINUTE)}`;

  return (
-    <span className={style.timeUntil} data-testid='time-until'>
+    <span className={cx([style.timeUntil, isDue && style.due])} data-testid='time-until'>
      {timeUntilString}
    </span>
  );
@@ -1,13 +1,33 @@
 .group {
  width: 100%;
-  padding: 0.25rem 0.5rem;
+  min-height: 2.5rem;
+  padding: 0.4rem 0.75rem;
+  border-left: 0.35rem solid var(--group-colour, $gray-500);
  background-color: $gray-1350;
+  background: color-mix(in srgb, transparent 88%, var(--group-colour, $gray-500) 12%);
  font-size: 1.25rem;
+  font-weight: 600;
+
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  letter-spacing: 0;
 }

-// tablet
-@media (min-width: $min-tablet) {
-  .group {
-    padding: 0.25rem 1rem;
-  }
+.title {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.meta {
+  display: flex;
+  flex: 0 0 auto;
+  align-items: center;
+  gap: 0.5rem;
+  color: color-mix(in srgb, currentColor 60%, transparent);
+  font-size: 0.875rem;
+  font-weight: 500;
 }
@@ -1,12 +1,29 @@
-import { memo } from 'react';
+import { CSSProperties, memo } from 'react';
+
+import { getAccessibleColour } from '../../../common/utils/styleUtils';
+import { formatDuration } from '../../../common/utils/time';

 import style from './OperatorGroup.module.scss';

 interface OperatorGroup {
  title: string;
+  colour: string;
+  count: number;
+  duration: number;
 }

 export default memo(OperatorGroup);
-function OperatorGroup({ title }: OperatorGroup) {
-  return <div className={style.group}>{title}</div>;
+function OperatorGroup({ title, colour, count, duration }: OperatorGroup) {
+  const groupColour = colour || '#929292';
+  const groupColours = getAccessibleColour(groupColour);
+
+  return (
+    <div className={style.group} style={{ ...groupColours, '--group-colour': groupColour } as CSSProperties}>
+      <span className={style.title}>{title}</span>
+      <span className={style.meta}>
+        <span>{`${count} ${count === 1 ? 'event' : 'events'}`}</span>
+        <span>{formatDuration(duration)}</span>
+      </span>
+    </div>
+  );
 }
@@ -3,58 +3,94 @@
  height: 100%;
  max-height: 100%;
  overflow-y: auto;
-  padding: 0.5rem;
+  padding: 1rem 1.5rem;

  display: flex;
  flex-direction: column;
-  overflow-x: auto;
 }

 .shortcutSection {
  flex: 1;
-  margin-top: 15vh;
+  width: min(100%, 48rem);
+  margin-top: clamp(1.5rem, 8vh, 5rem);
  margin-inline: auto;
-  gap: 1rem;
 }

 .shortcuts {
-  font-size: calc(1rem - 3px);
-  border-collapse: separate;
-  border-spacing: 4rem 0;
+  display: grid;
+  gap: 0.875rem;
+  margin-top: 0.875rem;
+}

-  tr {
-    white-space: nowrap;
-    td:nth-child(odd) {
-      text-align: left;
-    }
-    td:nth-child(even) {
-      text-align: right;
-    }
+.shortcutGroup {
+  h3 {
+    margin: 0 0 0.375rem;
+    color: $ui-white;
+    font-size: calc(1rem - 3px);
+    font-weight: 600;
+    text-transform: uppercase;
  }
 }

-.spacer {
-  height: 1rem;
+.shortcutList {
+  display: grid;
+  gap: 0.25rem;
+}
+
+.shortcutRow {
+  min-height: 1.625rem;
+  display: grid;
+  grid-template-columns: minmax(10rem, 1fr) minmax(0, auto);
+  align-items: center;
+  gap: 0.75rem;
+  font-size: calc(1rem - 3px);
+}
+
+.shortcutLabel {
+  min-width: 0;
+  line-height: 1.2;
+}
+
+.shortcutKeys {
+  display: inline-flex;
+  align-items: center;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 0.25rem 0.5rem;
+  min-width: 0;
+}
+
+.keyCombo {
+  display: inline-flex;
+  align-items: center;
+  flex-wrap: nowrap;
+  gap: 0.25rem 0;
+}
+
+.separator {
+  color: $gray-500;
+  font-size: calc(1rem - 5px);
 }

 .prompt {
-  margin-left: 4rem;
-}
-
-.divider {
-  display: inline-block;
-  text-align: center;
-  width: 1em;
-}
-
-.kbd {
-  font-family: monospace;
-  white-space: nowrap;
-  font-size: calc(1rem - 2px);
-  padding: 0.125rem 0.5rem;
-  background-color: $gray-1200;
  color: $ui-white;
-  border-radius: 2px;
-  font-weight: 400;
-  box-shadow: 0px 0px 3px 0px rgba(0, 0, 0, 0.4);
+}
+
+@media (max-width: 680px) {
+  .entryEditor {
+    padding: 0.75rem 1rem;
+  }
+
+  .shortcutSection {
+    margin-top: 1rem;
+  }
+
+  .shortcutRow {
+    grid-template-columns: 1fr;
+    gap: 0.25rem;
+  }
+
+  .shortcutKeys {
+    justify-content: flex-start;
+  }
 }
@@ -1,6 +1,7 @@
 import { PropsWithChildren, memo } from 'react';

 import * as Editor from '../../../common/components/editor-utils/EditorUtils';
+import Kbd from '../../../common/components/kbd/Kbd';
 import { deviceAlt, deviceMod } from '../../../common/utils/deviceUtils';

 import style from './EventEditorEmpty.module.scss';
@@ -12,216 +13,124 @@ function EventEditorEmpty() {
    <div className={style.entryEditor} data-testid='editor-container'>
      <div className={style.shortcutSection}>
        <Editor.Title className={style.prompt}>Rundown shortcuts</Editor.Title>
-        <table className={style.shortcuts}>
-          <tbody>
-            <tr>
-              <td>Find in rundown</td>
-              <td>
-                <Kbd>{deviceMod}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>F</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Open Settings</td>
-              <td>
-                <Kbd>{deviceMod}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>,</Kbd>
-              </td>
-            </tr>
-            <tr className={style.spacer} />
-            <tr>
-              <td>Select entry</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>↑</Kbd>
-                <AuxKey>/</AuxKey>
-                <Kbd>↓</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Select group</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>Shift</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>↑</Kbd>
-                <AuxKey>/</AuxKey>
-                <Kbd>↓</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Jump to top / bottom</td>
-              <td>
-                <Kbd>Home</Kbd>
-                <AuxKey>/</AuxKey>
-                <Kbd>End</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Page up / down</td>
-              <td>
-                <Kbd>PgUp</Kbd>
-                <AuxKey>/</AuxKey>
-                <Kbd>PgDn</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Deselect entry</td>
-              <td>
-                <Kbd>Esc</Kbd>
-              </td>
-            </tr>
-            <tr className={style.spacer} />
-            <tr>
-              <td>Reorder selected entry</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>{deviceMod}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>↑</Kbd>
-                <AuxKey>/</AuxKey>
-                <Kbd>↓</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Copy selected entry</td>
-              <td>
-                <Kbd>{deviceMod}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>C</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Cut selected entry</td>
-              <td>
-                <Kbd>{deviceMod}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>X</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Paste above</td>
-              <td>
-                <Kbd>{deviceMod}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>Shift</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>V</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Paste below</td>
-              <td>
-                <Kbd>{deviceMod}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>V</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Clone selected entry</td>
-              <td>
-                <Kbd>{deviceMod}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>D</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Delete selected entry</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>Backspace</Kbd>
-              </td>
-            </tr>
-            <tr className={style.spacer} />
-            <tr>
-              <td>Add event below</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>E</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Add event above</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>Shift</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>E</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Add group below</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>G</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Add group above</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>Shift</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>G</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Add milestone below</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>M</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Add milestone above</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>Shift</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>M</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Add delay below</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>D</Kbd>
-              </td>
-            </tr>
-            <tr>
-              <td>Add delay above</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>Shift</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>D</Kbd>
-              </td>
-            </tr>
-          </tbody>
-        </table>
+        <div className={style.shortcuts}>
+          <ShortcutGroup title='Search'>
+            <Shortcut label='Find in rundown'>
+              <Combo keys={[deviceMod, 'F']} />
+            </Shortcut>
+            <Shortcut label='Open settings'>
+              <Combo keys={[deviceMod, ',']} />
+            </Shortcut>
+          </ShortcutGroup>
+
+          <ShortcutGroup title='Navigation'>
+            <Shortcut label='Select entry'>
+              <Combo keys={[deviceAlt, '↑']} />
+              <Separator />
+              <Combo keys={[deviceAlt, '↓']} />
+            </Shortcut>
+            <Shortcut label='Select group'>
+              <Combo keys={[deviceAlt, 'Shift', '↑']} />
+              <Separator />
+              <Combo keys={[deviceAlt, 'Shift', '↓']} />
+            </Shortcut>
+            <Shortcut label='Jump to top / bottom'>
+              <Combo keys={['Home']} />
+              <Separator />
+              <Combo keys={['End']} />
+            </Shortcut>
+            <Shortcut label='Page up / down'>
+              <Combo keys={['PgUp']} />
+              <Separator />
+              <Combo keys={['PgDn']} />
+            </Shortcut>
+            <Shortcut label='Deselect entry'>
+              <Combo keys={['Esc']} />
+            </Shortcut>
+          </ShortcutGroup>
+
+          <ShortcutGroup title='Editing'>
+            <Shortcut label='Reorder selected entry'>
+              <Combo keys={[deviceAlt, deviceMod, '↑']} />
+              <Separator />
+              <Combo keys={[deviceAlt, deviceMod, '↓']} />
+            </Shortcut>
+            <Shortcut label='Copy selected entry'>
+              <Combo keys={[deviceMod, 'C']} />
+            </Shortcut>
+            <Shortcut label='Cut selected entry'>
+              <Combo keys={[deviceMod, 'X']} />
+            </Shortcut>
+            <Shortcut label='Paste below'>
+              <Combo keys={[deviceMod, 'V']} />
+            </Shortcut>
+            <Shortcut label='Paste above'>
+              <Combo keys={[deviceMod, 'Shift', 'V']} />
+            </Shortcut>
+            <Shortcut label='Clone selected entry'>
+              <Combo keys={[deviceMod, 'D']} />
+            </Shortcut>
+            <Shortcut label='Delete selected entry'>
+              <Combo keys={[deviceAlt, 'Backspace']} />
+            </Shortcut>
+          </ShortcutGroup>
+
+          <ShortcutGroup title='Insert'>
+            <Shortcut label='Add event below / above'>
+              <Combo keys={[deviceAlt, 'E']} />
+              <Separator />
+              <Combo keys={[deviceAlt, 'Shift', 'E']} />
+            </Shortcut>
+            <Shortcut label='Add group below / above'>
+              <Combo keys={[deviceAlt, 'G']} />
+              <Separator />
+              <Combo keys={[deviceAlt, 'Shift', 'G']} />
+            </Shortcut>
+            <Shortcut label='Add milestone below / above'>
+              <Combo keys={[deviceAlt, 'M']} />
+              <Separator />
+              <Combo keys={[deviceAlt, 'Shift', 'M']} />
+            </Shortcut>
+            <Shortcut label='Add delay below / above'>
+              <Combo keys={[deviceAlt, 'D']} />
+              <Separator />
+              <Combo keys={[deviceAlt, 'Shift', 'D']} />
+            </Shortcut>
+          </ShortcutGroup>
+        </div>
      </div>
    </div>
  );
 }

-function AuxKey({ children }: PropsWithChildren) {
-  return <span className={style.divider}>{children}</span>;
+function ShortcutGroup({ title, children }: PropsWithChildren<{ title: string }>) {
+  return (
+    <section className={style.shortcutGroup}>
+      <h3>{title}</h3>
+      <div className={style.shortcutList}>{children}</div>
+    </section>
+  );
 }

-function Kbd({ children }: PropsWithChildren) {
-  return <span className={style.kbd}>{children}</span>;
+function Shortcut({ label, children }: PropsWithChildren<{ label: string }>) {
+  return (
+    <div className={style.shortcutRow}>
+      <span className={style.shortcutLabel}>{label}</span>
+      <span className={style.shortcutKeys}>{children}</span>
+    </div>
+  );
+}
+
+function Combo({ keys }: { keys: string[] }) {
+  return (
+    <span className={style.keyCombo}>
+      {keys.map((key) => (
+        <Kbd key={key}>{key}</Kbd>
+      ))}
+    </span>
+  );
+}
+
+function Separator() {
+  return <span className={style.separator}>/</span>;
 }
@@ -7,6 +7,7 @@ $skip-opacity: 0.2;
  background-color: $block-bg;
  margin-block: 0.25rem;
  overflow: initial;
+  position: relative;

  display: grid;
  grid-template-areas:
@@ -35,6 +36,10 @@ $skip-opacity: 0.2;
    background-color: $gray-1325;
  }

+  &.countToEnd {
+    --status-color-active-override: #{$orange-400};
+  }
+
  &.play {
    background-color: $active-green;
    @include declare-overrides;
@@ -155,7 +160,7 @@ $skip-opacity: 0.2;
  align-items: center;
  justify-content: space-between;

-  .nextTag {
+  .warningMeta {
    font-size: 1rem;
    color: $orange-500;
    letter-spacing: 0.03px;
@@ -18,7 +18,7 @@ import { TbFlagFilled, TbListNumbers } from 'react-icons/tb';
 import { useEntryActionsContext } from '../../../common/context/EntryActionsContext';
 import { useContextMenu } from '../../../common/hooks/useContextMenu';
 import { useEntryCopy } from '../../../common/stores/entryCopyStore';
-import { deviceMod } from '../../../common/utils/deviceUtils';
+import { deviceAlt, deviceMod } from '../../../common/utils/deviceUtils';
 import { cx, getAccessibleColour } from '../../../common/utils/styleUtils';
 import { useRenumberCuesDialogStore } from '../renumber-cues-dialog/RenumberCuesDialog';
 import { useEventIdSwapping } from '../useEventIdSwapping';
@@ -156,7 +156,7 @@ export default function RundownEvent({
            type: 'item',
            label: 'Delete',
            icon: IoTrash,
-            shortcut: `${deviceMod}+Del`,
+            shortcut: `${deviceAlt}+Backspace`,
            onClick: () => {
              clearSelectedEvents();
              deleteEntry(Array.from(selectedEvents));
@@ -202,7 +202,7 @@ export default function RundownEvent({
            type: 'item',
            label: 'Delete',
            icon: IoTrash,
-            shortcut: `${deviceMod}+Del`,
+            shortcut: `${deviceAlt}+Backspace`,
            onClick: () => {
              deleteEntry([eventId]);
              unselect(eventId);
@@ -253,6 +253,7 @@ export default function RundownEvent({

  const blockClasses = cx([
    style.rundownEvent,
+    countToEnd && style.countToEnd,
    skip && style.skip,
    isPast && style.past,
    loaded && style.loaded,
@@ -120,7 +120,8 @@ function RundownEventInner({
      </div>
      <div className={style.titleSection}>
        <TitleEditor title={title} entryId={eventId} placeholder='Event title' className={style.eventTitle} />
-        {isNext && <span className={style.nextTag}>UP NEXT</span>}
+        {isNext && <span className={style.warningMeta}>UP NEXT</span>}
+        {!isNext && countToEnd && <span className={style.warningMeta}>COUNT TO END</span>}
      </div>
      <EventBlockPlayback
        eventId={eventId}
@@ -3,7 +3,5 @@
  width: 0;
  border-radius: 1px 0 0 1px;

-  transition: 1s linear;
-  transition-property: width;
  background-color: $gray-200;
 }
@@ -1,12 +1,12 @@
+import { useAnimatedProgress } from '../../../../common/hooks/useAnimatedProgress';
 import { useTimer } from '../../../../common/hooks/useSocket';
-import { getProgress } from '../../../../common/utils/getProgress';

 import style from './RundownEventProgressBar.module.scss';

 export default function RundownEventProgressBar() {
  const timer = useTimer();

-  const progress = getProgress(timer.current, timer.duration);
+  const progress = useAnimatedProgress(timer.current, timer.duration);

  return <div className={style.progressBar} style={{ width: `${progress}%` }} />;
 }
@@ -82,6 +82,17 @@
  margin-right: 0.25rem;
  color: $ui-white;
 }
+
+.duration {
+  display: flex;
+  align-items: center;
+  gap: 0.25rem;
+}
+
+.lockIcon {
+  opacity: 0.6;
+}
+
 .over {
  color: $playback-over;
  .strike {
@@ -8,6 +8,7 @@ import {
  IoChevronUp,
  IoDuplicateOutline,
  IoFolderOpenOutline,
+  IoLockClosed,
  IoReorderTwo,
  IoTrash,
 } from 'react-icons/io5';
@@ -17,7 +18,7 @@ import Tag from '../../../common/components/tag/Tag';
 import { useEntryActionsContext } from '../../../common/context/EntryActionsContext';
 import { useContextMenu } from '../../../common/hooks/useContextMenu';
 import { useEntryCopy } from '../../../common/stores/entryCopyStore';
-import { deviceMod } from '../../../common/utils/deviceUtils';
+import { deviceAlt, deviceMod } from '../../../common/utils/deviceUtils';
 import { getOffsetState } from '../../../common/utils/offset';
 import { cx, getAccessibleColour } from '../../../common/utils/styleUtils';
 import { formatDuration, formatTime } from '../../../common/utils/time';
@@ -65,7 +66,7 @@ export default function RundownGroup({ data, hasCursor, collapsed, onCollapse }:
      type: 'item',
      label: 'Delete Group',
      icon: IoTrash,
-      shortcut: `${deviceMod}+Del`,
+      shortcut: `${deviceAlt}+Backspace`,
      onClick: () => deleteEntry([data.id]),
    },
  ]);
@@ -176,14 +177,17 @@ export default function RundownGroup({ data, hasCursor, collapsed, onCollapse }:
          </div>
          <div className={style.metaEntry}>
            <div className={style.metaLabel}>Duration</div>
-            {planOffset === null ? (
-              <div>{formatDuration(data.duration)}</div>
-            ) : (
-              <div className={cx([planOffsetLabel && style[planOffsetLabel]])}>
-                <span className={style.strike}>{formatDuration(data.duration)}</span>
-                <Tag className={style.offsetLabel}>{planOffset}</Tag>
-              </div>
-            )}
+            <div className={style.duration}>
+              {planOffset === null ? (
+                formatDuration(data.duration)
+              ) : (
+                <span className={cx([planOffsetLabel && style[planOffsetLabel]])}>
+                  <span className={style.strike}>{formatDuration(data.duration)}</span>
+                  <Tag className={style.offsetLabel}>{planOffset}</Tag>
+                </span>
+              )}
+              {data.targetDuration !== null && <IoLockClosed className={style.lockIcon} />}
+            </div>
          </div>
        </div>
      </div>
@@ -9,7 +9,7 @@ import useReactiveTextInput from '../../../common/components/input/text-input/us
 import { useEntryActionsContext } from '../../../common/context/EntryActionsContext';
 import { useContextMenu } from '../../../common/hooks/useContextMenu';
 import { useEntryCopy } from '../../../common/stores/entryCopyStore';
-import { deviceMod } from '../../../common/utils/deviceUtils';
+import { deviceAlt } from '../../../common/utils/deviceUtils';
 import { cx, getAccessibleColour } from '../../../common/utils/styleUtils';
 import { useEventSelection } from '../useEventSelection';

@@ -38,7 +38,7 @@ export default function RundownMilestone({ colour, cue, entryId, hasCursor, titl
      type: 'item',
      label: 'Delete',
      icon: IoTrash,
-      shortcut: `${deviceMod}+Del`,
+      shortcut: `${deviceAlt}+Backspace`,
      onClick: () => deleteEntry([entryId]),
    },
  ]);
@@ -27,7 +27,6 @@ interface TimeInputFlowProps {
 export default memo(TimeInputFlow);
 function TimeInputFlow({
  eventId,
-  countToEnd,
  timeStart,
  timeEnd,
  duration,
@@ -56,10 +55,6 @@ function TimeInputFlow({
    warnings.push('Over midnight');
  }

-  if (countToEnd) {
-    warnings.push('Count to End');
-  }
-
  const hasDelay = delay !== 0;
  const isLockedEnd = timeStrategy === TimeStrategy.LockEnd;
  const isLockedDuration = timeStrategy === TimeStrategy.LockDuration;
@@ -3,6 +3,7 @@ import { useMemo } from 'react';

 import useInfo from '../../common/hooks-query/useInfo';
 import useUrlPresets from '../../common/hooks-query/useUrlPresets';
+import { hostToBaseUrl } from '../../common/utils/linkUtils';
 import GenerateLinkForm from './GenerateLinkForm';

 interface GenerateLinkFormExportProps {
@@ -21,7 +22,7 @@ export default function GenerateLinkFormExport({ lockedPath }: GenerateLinkFormE
   */
  const hostOptions = useMemo(() => {
    return infoData.networkInterfaces.map((nif) => ({
-      value: `http://${nif.address}:${infoData.serverPort}`,
+      value: hostToBaseUrl(nif.address, infoData.serverPort),
      label: `${nif.name} - ${nif.address}`,
    }));
  }, [infoData.networkInterfaces, infoData.serverPort]);
@@ -18,6 +18,7 @@ export const langDe: TranslationObject = {
  'common.no_data': 'Keine Daten',
  'countdown.ended': 'Veranstaltung endete um',
  'countdown.running': 'Veranstaltung läuft',
+  'countdown.group_running': 'Veranstaltung in Gruppe läuft',
  'countdown.loaded': 'Veranstaltung geladen',
  'countdown.select_event': 'Wählen Sie eine Veranstaltung aus, um sie zu verfolgen',
  'countdown.to_start': 'Zeit bis zum Start',
@@ -18,6 +18,7 @@ export const langEs: TranslationObject = {
  'common.no_data': 'Sin datos',
  'countdown.ended': 'Evento finalizado a las',
  'countdown.running': 'Evento en curso',
+  'countdown.group_running': 'Evento en grupo en curso',
  'countdown.loaded': 'Evento está cargado', //TODO: check translation
  'countdown.select_event': 'Seleccionar un evento para seguir',
  'countdown.to_start': 'Tiempo para comenzar',
@@ -18,6 +18,7 @@ export const langFr: TranslationObject = {
  'common.no_data': 'Aucune donnée',
  'countdown.ended': 'Évènement terminé à',
  'countdown.running': 'Évènement en cours',
+  'countdown.group_running': 'Évènement du groupe en cours',
  'countdown.loaded': 'Évènement chargé',
  'countdown.select_event': 'Sélectionnez un évènement à suivre',
  'countdown.to_start': 'Évènement commence dans',
@@ -18,6 +18,7 @@ export const langIt: TranslationObject = {
  'common.no_data': 'Nessun dato disponibile',
  'countdown.ended': 'Evento finito alle',
  'countdown.running': 'Evento in corso',
+  'countdown.group_running': 'Evento nel gruppo in corso',
  'countdown.loaded': 'Evento caricato', //TODO: check translation
  'countdown.select_event': 'Seleziona un evento da seguire',
  'countdown.to_start': 'Tempo alla partenza',
@@ -18,6 +18,7 @@ export const langPt: TranslationObject = {
  'common.no_data': 'Sem dados',
  'countdown.ended': 'Evento encerrado às',
  'countdown.running': 'Evento em andamento',
+  'countdown.group_running': 'Evento em grupo em andamento',
  'countdown.loaded': 'Evento carregado', //TODO: check translation
  'countdown.select_event': 'Selecione um evento para acompanhar',
  'countdown.to_start': 'Tempo para iniciar',
@@ -7,6 +7,7 @@ import {
  useCallback,
  useEffect,
  useLayoutEffect,
+  useMemo,
  useRef,
  useState,
 } from 'react';
@@ -140,25 +141,23 @@ export const ScheduleProvider = ({ children, selectedEventId }: PropsWithChildre
    return () => clearInterval(paginator.current);
  }, [cycleInterval, numPages, stopCycle, visiblePage]);

-  let selectedEventIndex = events.findIndex((event) => event.id === selectedEventId);
-
  // we want to show the event after the current
-  const viewEvents = events.slice(selectedEventIndex + 1);
-  selectedEventIndex = 0;
+  const viewEvents = useMemo(() => {
+    const selectedEventIndex = events.findIndex((event) => event.id === selectedEventId);
+    return (events as ExtendedEntry<OntimeEvent>[]).slice(selectedEventIndex + 1);
+  }, [events, selectedEventId]);

-  return (
-    <ScheduleContext
-      value={{
-        events: viewEvents as ExtendedEntry<OntimeEvent>[],
-        selectedEventId,
-        numPages,
-        visiblePage,
-        containerRef,
-      }}
-    >
-      {children}
-    </ScheduleContext>
-  );
+  const value = useMemo(() => {
+    return {
+      events: viewEvents,
+      selectedEventId,
+      numPages,
+      visiblePage,
+      containerRef,
+    };
+  }, [viewEvents, selectedEventId, numPages, visiblePage, containerRef]);
+
+  return <ScheduleContext value={value}>{children}</ScheduleContext>;
 };

 export const useSchedule = () => {
@@ -59,6 +59,7 @@ $item-height: 3.5rem;
    right: $view-inline-padding;

    display: flex;
+    align-items: center;
    justify-content: end;
    gap: 2rem;

@@ -72,14 +73,27 @@ $item-height: 3.5rem;
  }

  /* ========================= LIST ========================*/
-  .empty-container {
+  .empty-state {
+    min-height: min(56vh, 36rem);
+    padding-top: clamp(4rem, 14vh, 9rem);
    text-align: center;
    display: flex;
    flex-direction: column;
    align-items: center;

    button {
-      margin-top: 2rem;
+      margin-top: 1.75rem;
+    }
+  }
+
+  .empty-state__content {
+    max-width: none;
+
+    span {
+      max-width: none;
+      white-space: nowrap;
+      font-size: clamp(1.5rem, 4vw, 2.25rem);
+      line-height: 1.1;
    }
  }

@@ -88,7 +102,7 @@ $item-height: 3.5rem;
    flex-direction: column;
    overflow-y: auto;

-    padding-bottom: 60vh;
+    padding-bottom: max(8rem, calc(5rem + env(safe-area-inset-bottom)));
  }

  /* ====================== LIST-ITEM ======================*/
@@ -104,6 +118,7 @@ $item-height: 3.5rem;
    column-gap: 1rem;
    background-color: var(--card-background-color-override, $viewer-card-bg-color);
    padding-right: 1rem;
+    border: 1px solid transparent;
    border-radius: $element-border-radius;

    &:hover {
@@ -115,18 +130,41 @@ $item-height: 3.5rem;

  .sub--selected {
    background: $blue-700;
+    box-shadow: inset 0 0 0 1px $blue-500;
  }

  .sub--live {
    background-color: $active-green;
+    box-shadow: inset 0 0 0 1px color-mix(in srgb, $active-green 75%, $ui-white);
  }

  .sub--armed {
    background-color: $gray-1325;
  }

+  .sub--in-group {
+    position: relative;
+    margin-left: 1rem;
+
+    &::before {
+      content: '';
+      position: absolute;
+      left: -0.5rem;
+      top: -0.25rem;
+      bottom: -0.25rem;
+      width: 2px;
+      border-radius: 1px;
+      background: var(--group-color, transparent);
+    }
+
+    .sub__binder {
+      box-shadow: inset 3px 0 0 var(--group-color, transparent);
+    }
+  }
+
  .sub__binder {
    background: var(--user-color, var(--card-background-color-override, $viewer-card-bg-color));
+    border-radius: $element-border-radius 0 0 $element-border-radius;
    grid-area: binder;
  }

@@ -138,6 +176,8 @@ $item-height: 3.5rem;
    gap: 0.25em;
    font-size: $timer-label-size;
    color: var(--label-color-override, $viewer-label-color);
+    white-space: nowrap;
+    font-variant-numeric: tabular-nums;
  }

  .sub__schedule--delayed {
@@ -156,22 +196,73 @@ $item-height: 3.5rem;
    color: $playback-under;
  }

+  .sub--group {
+    box-shadow: inset 0 0 0 1px var(--user-color, $gray-1325);
+    background:
+      linear-gradient(90deg, color-mix(in srgb, var(--user-color, transparent) 18%, transparent), transparent 42%),
+      var(--card-background-color-override, $viewer-card-bg-color);
+
+    .sub__binder {
+      background: var(--user-color, var(--card-background-color-override, $viewer-card-bg-color));
+      box-shadow: none;
+    }
+
+    .sub__title {
+      font-weight: 700;
+    }
+
+    .sub__schedule,
+    .sub__status,
+    .sub__label {
+      color: var(--secondary-color-override, $viewer-secondary-color);
+    }
+  }
+
+  .sub--group.sub--selected {
+    box-shadow: inset 0 0 0 1px $blue-500;
+    background:
+      linear-gradient(90deg, color-mix(in srgb, var(--user-color, transparent) 22%, transparent), transparent 42%),
+      $blue-700;
+
+    .sub__schedule,
+    .sub__status,
+    .sub__label,
+    .sub__eyebrow {
+      color: $ui-white;
+    }
+  }
+
  .sub__title {
    grid-area: title;
    padding-bottom: 0.5rem;
+    min-width: 0;

    font-size: $title-font-size;
    line-height: 1.1em;
+    overflow-wrap: anywhere;
+  }
+
+  .sub__eyebrow {
+    display: block;
+    margin-bottom: 0.15rem;
+    color: var(--secondary-color-override, $viewer-secondary-color);
+    font-size: $timer-label-size;
+    font-weight: 700;
+    line-height: 1;
+    text-transform: uppercase;
  }

  .sub__secondary {
    grid-area: secondary;
    padding-bottom: 0.5rem;
+    min-width: 0;

    font-size: $base-font-size;
    line-height: 1.1em;
+    color: var(--label-color-override, $viewer-label-color);
    // allow multi-line text but trim before
    white-space: pre-line;
+    overflow-wrap: anywhere;
  }

  .sub__status {
@@ -181,6 +272,7 @@ $item-height: 3.5rem;
    font-size: $timer-label-size;
    text-align: right;
    text-transform: uppercase;
+    white-space: nowrap;
  }

  .sub__label {
@@ -190,6 +282,7 @@ $item-height: 3.5rem;
    font-size: $timer-label-size;
    color: var(--label-color-override, $viewer-label-color);
    text-align: right;
+    white-space: nowrap;
  }

  .sub__timer {
@@ -199,6 +292,16 @@ $item-height: 3.5rem;
    line-height: 1.1em;
    font-weight: 600;
    text-align: right;
+    white-space: nowrap;
+    font-variant-numeric: tabular-nums;
+  }
+
+  .selection-count {
+    color: var(--label-color-override, $viewer-label-color);
+    font-size: $timer-label-size;
+    font-weight: 600;
+    text-transform: uppercase;
+    white-space: nowrap;
  }

  /* ====================== MODIFIERS ======================*/
@@ -1,4 +1,14 @@
-import { EntryId, OntimeEvent, OntimeView, PlayableEvent, isOntimeEvent, isPlayableEvent } from 'ontime-types';
+import {
+  EntryId,
+  OntimeEntry,
+  OntimeEvent,
+  OntimeGroup,
+  OntimeView,
+  PlayableEvent,
+  isOntimeEvent,
+  isOntimeGroup,
+  isPlayableEvent,
+} from 'ontime-types';
 import { useMemo, useState } from 'react';
 import { IoAdd } from 'react-icons/io5';

@@ -15,7 +25,7 @@ import { useTranslation } from '../../translation/TranslationProvider';
 import Loader from '../common/loader/Loader';
 import SuperscriptTime from '../common/superscript-time/SuperscriptTime';
 import { getCountdownOptions, useCountdownOptions } from './countdown.options';
-import { getOrderedSubscriptions } from './countdown.utils';
+import { getOrderedSubscriptions, resolveSubscriptionTarget } from './countdown.utils';
 import CountdownSelect from './CountdownSelect';
 import CountdownSubscriptions from './CountdownSubscriptions';
 import SingleEventCountdown from './SingleEventCountdown';
@@ -45,13 +55,19 @@ function Countdown({ customFields, rundownData, projectData, isMirrored, setting

  const [editMode, setEditMode] = useState(false);

-  // gather rundown data
-  const playableEvents = rundownData.filter((entry): entry is ExtendedEntry<PlayableEvent> => {
-    return isOntimeEvent(entry) && isPlayableEvent(entry);
+  // gather subscribable items: playable events and groups that contain at least one playable child
+  const candidates = rundownData.filter((entry): entry is ExtendedEntry<PlayableEvent | OntimeGroup> => {
+    if (isOntimeEvent(entry)) {
+      return isPlayableEvent(entry);
+    }
+    if (isOntimeGroup(entry)) {
+      return rundownData.some((item) => isOntimeEvent(item) && isPlayableEvent(item) && item.parent === entry.id);
+    }
+    return false;
  });

  // gather presentation data
-  const hasEvents = playableEvents.length > 0;
+  const hasEvents = candidates.length > 0;

  // gather option data
  const defaultFormat = getDefaultFormat(settings?.timeFormat);
@@ -69,15 +85,20 @@ function Countdown({ customFields, rundownData, projectData, isMirrored, setting
        <CountdownClock />
      </div>

-      {!hasEvents && <Empty text={getLocalizedString('common.no_data')} className='empty-container' />}
+      {!hasEvents && (
+        <div className='empty-state'>
+          <Empty text={getLocalizedString('common.no_data')} className='empty-state__content' />
+        </div>
+      )}

      {hasEvents && editMode && (
-        <CountdownSelect events={playableEvents} subscriptions={subscriptions} disableEdit={() => setEditMode(false)} />
+        <CountdownSelect events={candidates} subscriptions={subscriptions} disableEdit={() => setEditMode(false)} />
      )}

      {hasEvents && !editMode && (
        <CountdownContents
-          playableEvents={playableEvents}
+          candidates={candidates}
+          rundownData={rundownData}
          subscriptions={subscriptions}
          goToEditMode={() => setEditMode(true)}
        />
@@ -87,19 +108,20 @@ function Countdown({ customFields, rundownData, projectData, isMirrored, setting
 }

 interface CountdownContentsProps {
-  playableEvents: ExtendedEntry<OntimeEvent>[];
+  candidates: ExtendedEntry<OntimeEvent | OntimeGroup>[];
+  rundownData: ExtendedEntry<OntimeEntry>[];
  subscriptions: EntryId[];
  goToEditMode: () => void;
 }

-function CountdownContents({ playableEvents, subscriptions, goToEditMode }: CountdownContentsProps) {
+function CountdownContents({ candidates, rundownData, subscriptions, goToEditMode }: CountdownContentsProps) {
  const { getLocalizedString } = useTranslation();
  const { hidePast } = useCountdownOptions();

  if (subscriptions.length === 0) {
    return (
-      <div className='empty-container'>
-        <Empty text={getLocalizedString('countdown.select_event')} className='empty-container' />
+      <div className='empty-state'>
+        <Empty text={getLocalizedString('countdown.select_event')} className='empty-state__content' />
        <Button variant='primary' size='xlarge' onClick={goToEditMode}>
          <IoAdd /> Add
        </Button>
@@ -107,13 +129,15 @@ function CountdownContents({ playableEvents, subscriptions, goToEditMode }: Coun
    );
  }

-  const subscribedEvents = getOrderedSubscriptions(subscriptions, playableEvents);
+  const subscribedEvents = getOrderedSubscriptions(subscriptions, candidates)
+    .map((entry) => resolveSubscriptionTarget(entry, rundownData))
+    .filter((target): target is NonNullable<typeof target> => target !== null);
  const eventsToShow = !hidePast ? subscribedEvents : subscribedEvents.filter((event) => !event.isPast);

  if (subscribedEvents.length === 0) {
    return (
-      <div className='empty-container'>
-        <Empty text={getLocalizedString('countdown.select_event')} className='empty-container' />
+      <div className='empty-state'>
+        <Empty text={getLocalizedString('countdown.select_event')} className='empty-state__content' />
        <Button variant='primary' size='xlarge' onClick={goToEditMode}>
          <IoAdd /> Add
        </Button>
@@ -129,8 +153,8 @@ function CountdownContents({ playableEvents, subscriptions, goToEditMode }: Coun

  if (eventsToShow.length === 0) {
    return (
-      <div className='empty-container'>
-        <Empty text={getLocalizedString('countdown.all_have_finished')} className='empty-container' />
+      <div className='empty-state'>
+        <Empty text={getLocalizedString('countdown.all_have_finished')} className='empty-state__content' />
      </div>
    );
  }
@@ -1,4 +1,4 @@
-import { EntryId, PlayableEvent } from 'ontime-types';
+import { EntryId, OntimeEvent, OntimeGroup, isOntimeGroup } from 'ontime-types';
 import { useState } from 'react';
 import { IoArrowBack, IoClose, IoSaveOutline } from 'react-icons/io5';
 import { useNavigate } from 'react-router';
@@ -12,7 +12,7 @@ import { makeSubscriptionsUrl } from './countdown.utils';
 import './Countdown.scss';

 interface CountdownSelectProps {
-  events: ExtendedEntry<PlayableEvent>[];
+  events: ExtendedEntry<OntimeEvent | OntimeGroup>[];
  subscriptions: EntryId[];
  disableEdit: () => void;
 }
@@ -52,13 +52,15 @@ export default function CountdownSelect({ events, subscriptions, disableEdit }:

  return (
    <div className='list-container'>
-      {events.map((event, index) => {
+      {events.map((event) => {
        const title = event.title || '{no title}';
        const isSelected = selectedIds.has(event.id);
+        const isGroup = isOntimeGroup(event);
+        const isGroupedEvent = !isGroup && Boolean(event.parent);

        return (
          <div
-            key={index}
+            key={event.id}
            role='button'
            tabIndex={0}
            onClick={() => toggleSelect(event.id)}
@@ -68,21 +70,33 @@ export default function CountdownSelect({ events, subscriptions, disableEdit }:
                e.stopPropagation();
              }
            }}
-            className={cx(['sub', isSelected && 'sub--selected'])}
+            className={cx([
+              'sub',
+              isSelected && 'sub--selected',
+              isGroup && 'sub--group',
+              isGroupedEvent && 'sub--in-group',
+            ])}
          >
-            <div className='sub__binder' style={{ '--user-color': event?.colour ?? '' }} />
+            <div
+              className='sub__binder'
+              style={{ '--user-color': event?.colour ?? '', '--group-color': event.groupColour ?? 'transparent' }}
+            />
            <div className='sub__schedule'>
              <ClockTime value={event.timeStart} preferredFormat12='h:mm a' preferredFormat24='HH:mm' />
              →
              <ClockTime value={event.timeEnd} preferredFormat12='h:mm a' preferredFormat24='HH:mm' />
            </div>
            <div className='sub__label'>{isSelected ? 'Click to remove' : 'Click to add'}</div>
-            <div className='sub__title'>{title}</div>
+            <div className='sub__title'>
+              {isGroup && <span className='sub__eyebrow'>Group</span>}
+              {title}
+            </div>
          </div>
        );
      })}

      <div className='fab-container'>
+        <div className='selection-count'>{selected.length} selected</div>
        <Button variant='subtle' size='xlarge' onClick={disableEdit}>
          <IoArrowBack /> Go back
        </Button>
@@ -19,6 +19,7 @@ import { getPropertyValue } from '../common/viewUtils';
 import { useCountdownOptions } from './countdown.options';
 import {
  CountdownEvent,
+  CountdownTarget,
  extendEventData,
  getIsLive,
  isOutsideRange,
@@ -30,7 +31,7 @@ import {
 import './Countdown.scss';

 interface CountdownSubscriptionsProps {
-  subscribedEvents: ExtendedEntry<OntimeEvent>[];
+  subscribedEvents: CountdownTarget[];
  goToEditMode: () => void;
 }

@@ -98,22 +99,39 @@ export default function CountdownSubscriptions({ subscribedEvents, goToEditMode
  return (
    <div className='list-container' onWheel={handleScroll} onTouchMove={handleScroll} ref={scrollRef}>
      {subscribedEvents.map((event) => {
-        const secondaryData = getPropertyValue(event, secondarySource);
-        const isLive = getIsLive(event.id, selectedEventId, playback);
-        const isArmed = !isLive && event.id === selectedEventId;
+        // while a group is live, surface the running event's title as the secondary line
+        const liveTitle = event.isGroup && event.liveEntry ? event.liveEntry.title : undefined;
+        const secondaryData = liveTitle ?? getPropertyValue(event, secondarySource);
+        const isGroupedEvent = !event.isGroup && Boolean(event.parent);
+        const activeEntryId = event.isGroup ? (event.liveEntry?.id ?? event.targetId) : event.id;
+        // a subscribed group is live when any of its children is the selected/running event
+        const isLive = activeEntryId ? getIsLive(activeEntryId, selectedEventId, playback) : false;
+        const isArmed = !isLive && activeEntryId === selectedEventId;
        const countdownEvent = extendEventData(event, currentDay, actualStart, plannedStart, offset, mode, reportData);
        const displayTitle = getPropertyValue(event, mainSource ?? 'title');
        return (
          <div
            key={event.id}
            ref={isLive ? selectedRef : undefined}
-            className={cx(['sub', isLive && 'sub--live', isArmed && 'sub--armed'])}
+            className={cx([
+              'sub',
+              isLive && 'sub--live',
+              isArmed && 'sub--armed',
+              event.isGroup && 'sub--group',
+              isGroupedEvent && 'sub--in-group',
+            ])}
            data-testid={event.cue}
          >
-            <div className='sub__binder' style={{ '--user-color': event.colour }} />
+            <div
+              className='sub__binder'
+              style={{ '--user-color': event.colour, '--group-color': event.groupColour ?? 'transparent' }}
+            />
            <ScheduleTime event={countdownEvent} showExpected={showExpected} />
            <SubscriptionStatus event={countdownEvent} />
-            <div className={cx(['sub__title', !displayTitle && 'subdued'])}>{displayTitle}</div>
+            <div className={cx(['sub__title', !displayTitle && 'subdued'])}>
+              {event.isGroup && <span className='sub__eyebrow'>Group</span>}
+              {displayTitle}
+            </div>
            {secondaryData && <div className='sub__secondary'>{secondaryData}</div>}
          </div>
        );
@@ -133,9 +151,8 @@ type ScheduleTimeProps = {
  showExpected: boolean;
 };
 //TODO: consider relative mode
-export function ScheduleTime(props: ScheduleTimeProps) {
-  const { event, showExpected } = props;
-  const { timeStart, duration, delay, expectedStart, countToEnd } = event;
+export function ScheduleTime({ event, showExpected }: ScheduleTimeProps) {
+  const { timeStart, duration, delay, expectedStart, expectedEnd, countToEnd } = event;

  const plannedStart = timeStart + delay + event.dayOffset * dayInMs;

@@ -145,8 +162,14 @@ export function ScheduleTime(props: ScheduleTimeProps) {
  const plannedStateClass = isExpectedValueShow ? 'sub__schedule--strike' : delay !== 0 ? 'sub__schedule--delayed' : '';

  const expectedStateClass = `sub__schedule--${getOffsetState(expectedStart - plannedStart)}`;
-  const plannedEnd = plannedStart + duration + delay;
-  const expectedEnd = countToEnd ? Math.max(expectedStart + duration, plannedEnd) : expectedStart + duration;
+
+  // count to end events are fixed to the scheduled end and ignore delays
+  const plannedEnd = (() => {
+    if (countToEnd) {
+      return timeStart + event.dayOffset * dayInMs + duration;
+    }
+    return plannedStart + duration;
+  })();
  const expectedEndClass = `sub__schedule--${getOffsetState(expectedEnd - plannedEnd)}`;

  return (
@@ -1,5 +1,4 @@
 import { MaybeNumber, OntimeEvent } from 'ontime-types';
-import { getExpectedStart } from 'ontime-utils';
 import { IoPencil } from 'react-icons/io5';

 import Button from '../../common/components/buttons/Button';
@@ -11,13 +10,13 @@ import { cx } from '../../common/utils/styleUtils';
 import SuperscriptTime from '../common/superscript-time/SuperscriptTime';
 import { getPropertyValue } from '../common/viewUtils';
 import { useCountdownOptions } from './countdown.options';
-import { useSubscriptionDisplayData } from './countdown.utils';
+import { CountdownTarget, extendEventData, useSubscriptionDisplayData } from './countdown.utils';
 import { ScheduleTime } from './CountdownSubscriptions';

 import './SingleEventCountdown.scss';

 interface SingleEventCountdownProps {
-  subscribedEvent: ExtendedEntry<OntimeEvent>;
+  subscribedEvent: CountdownTarget;
  goToEditMode: () => void;
 }

@@ -27,22 +26,20 @@ export default function SingleEventCountdown({ subscribedEvent, goToEditMode }:
  const { data: reportData } = useReport();

  const { offset, currentDay, actualStart, plannedStart, mode } = useExpectedStartData();
-  const { totalGap, isLinkedToLoaded } = subscribedEvent;
-  const expectedStart = getExpectedStart(subscribedEvent, {
+  const countdownEvent = extendEventData(
+    subscribedEvent,
    currentDay,
-    totalGap,
    actualStart,
    plannedStart,
-    isLinkedToLoaded,
    offset,
    mode,
-  });
-
-  const { endedAt } = reportData[subscribedEvent.id] ?? { endedAt: null };
-  const countdownEvent = { ...subscribedEvent, expectedStart, endedAt };
+    reportData,
+  );
  const titleTmp = getPropertyValue(subscribedEvent, mainSource ?? 'title');
  const title = titleTmp?.length ? titleTmp : ' '; // insert utf-8 empty space to avoid the line collapsing;
-  const secondaryData = getPropertyValue(subscribedEvent, secondarySource);
+  // while a group is live, surface the running event's title as the secondary line
+  const liveTitle = subscribedEvent.isGroup && subscribedEvent.liveEntry ? subscribedEvent.liveEntry.title : undefined;
+  const secondaryData = liveTitle ?? getPropertyValue(subscribedEvent, secondarySource);

  return (
    <div className='single-container' data-testid='countdown-event'>
@@ -80,7 +80,7 @@ export const getCountdownOptions = (
        {
          id: 'sub',
          title: 'Event subscription',
-          description: 'The events to follow',
+          description: 'The events and groups to follow',
          values: persistedSubscriptions,
          type: 'persist',
        },
@@ -0,0 +1,128 @@
+import { OntimeEntry, OntimeEvent, OntimeGroup, SupportedEntry } from 'ontime-types';
+
+import { ExtendedEntry } from '../../common/utils/rundownMetadata';
+import { resolveSubscriptionTarget } from './countdown.utils';
+
+/**
+ * Minimal builders for the extended (metadata enriched) entries the countdown view consumes.
+ * Only the fields exercised by resolveSubscriptionTarget are provided; the rest are cast away.
+ */
+function makeEvent(patch: Partial<ExtendedEntry<OntimeEvent>>): ExtendedEntry<OntimeEvent> {
+  return {
+    id: 'event',
+    type: SupportedEntry.Event,
+    title: 'event title',
+    cue: '1',
+    colour: '',
+    skip: false,
+    parent: null,
+    timeStart: 0,
+    timeEnd: 0,
+    duration: 0,
+    delay: 0,
+    dayOffset: 0,
+    gap: 0,
+    countToEnd: false,
+    custom: {},
+    note: '',
+    // metadata
+    totalGap: 0,
+    isLinkedToLoaded: false,
+    isLoaded: false,
+    isPast: false,
+    ...patch,
+  } as ExtendedEntry<OntimeEvent>;
+}
+
+function makeGroup(patch: Partial<ExtendedEntry<OntimeGroup>>): ExtendedEntry<OntimeGroup> {
+  return {
+    id: 'group',
+    type: SupportedEntry.Group,
+    title: 'group title',
+    colour: '#abcdef',
+    note: 'group note',
+    entries: [],
+    duration: 0,
+    custom: {},
+    timeStart: 0,
+    timeEnd: 0,
+    isPast: false,
+    isLoaded: false,
+    ...patch,
+  } as ExtendedEntry<OntimeGroup>;
+}
+
+describe('resolveSubscriptionTarget()', () => {
+  it('returns events unchanged', () => {
+    const event = makeEvent({ id: 'e1' });
+    const result = resolveSubscriptionTarget(event, [event]);
+    expect(result).toBe(event);
+  });
+
+  it('derives group timing from the first playable child while keeping the group identity', () => {
+    const group = makeGroup({ id: 'g1', title: 'Session A', colour: '#123456', duration: 5000 });
+    const child1 = makeEvent({ id: 'c1', parent: 'g1', timeStart: 1000, delay: 100, dayOffset: 0, title: 'Pres 1' });
+    const child2 = makeEvent({ id: 'c2', parent: 'g1', timeStart: 3000, title: 'Pres 2' });
+    const flat: ExtendedEntry<OntimeEntry>[] = [group, child1, child2];
+
+    const result = resolveSubscriptionTarget(group, flat);
+
+    expect(result).not.toBeNull();
+    // group identity and display
+    expect(result?.id).toBe('g1');
+    expect(result?.title).toBe('Session A');
+    expect(result?.colour).toBe('#123456');
+    expect(result?.isGroup).toBe(true);
+    // timing comes from the first child, duration from the group
+    expect(result?.timeStart).toBe(1000);
+    expect(result?.delay).toBe(100);
+    expect(result?.duration).toBe(5000);
+    expect(result?.countToEnd).toBe(false);
+    // state checks target the first child before any child is loaded
+    expect(result?.targetId).toBe('c1');
+    // report lookup targets the last child (session end)
+    expect(result?.reportId).toBe('c2');
+  });
+
+  it('returns null for a group with no playable children', () => {
+    const group = makeGroup({ id: 'g1' });
+    const result = resolveSubscriptionTarget(group, [group]);
+    expect(result).toBeNull();
+  });
+
+  it('skips skipped children when picking the first child', () => {
+    const group = makeGroup({ id: 'g1' });
+    const skipped = {
+      ...makeEvent({ id: 'c0', parent: 'g1', timeStart: 500 }),
+      skip: true,
+    } as ExtendedEntry<OntimeEntry>;
+    const playable = makeEvent({ id: 'c1', parent: 'g1', timeStart: 1500 });
+    const result = resolveSubscriptionTarget(group, [group, skipped, playable]);
+    expect(result?.timeStart).toBe(1500);
+    expect(result?.reportId).toBe('c1');
+  });
+
+  it('is live while any child is loaded and not past', () => {
+    const group = makeGroup({ id: 'g1' });
+    const child1 = makeEvent({ id: 'c1', parent: 'g1', isPast: true });
+    const child2 = makeEvent({ id: 'c2', parent: 'g1', isLoaded: true });
+    const child3 = makeEvent({ id: 'c3', parent: 'g1' });
+    const result = resolveSubscriptionTarget(group, [group, child1, child2, child3]);
+
+    expect(result?.isLoaded).toBe(true);
+    expect(result?.isPast).toBe(false);
+    expect(result?.liveEntry?.id).toBe('c2');
+  });
+
+  it('is past only once the last child is past and nothing is loaded', () => {
+    const group = makeGroup({ id: 'g1' });
+    const child1 = makeEvent({ id: 'c1', parent: 'g1', isPast: true });
+    const child2 = makeEvent({ id: 'c2', parent: 'g1', isPast: true });
+    const result = resolveSubscriptionTarget(group, [group, child1, child2]);
+
+    expect(result?.isLoaded).toBe(false);
+    expect(result?.isPast).toBe(true);
+    expect(result?.targetId).toBe('c1');
+    expect(result?.liveEntry).toBeNull();
+  });
+});
@@ -1,5 +1,18 @@
-import { EntryId, MaybeNumber, OffsetMode, OntimeEntry, OntimeEvent, OntimeReport, Playback } from 'ontime-types';
-import { MILLIS_PER_MINUTE, getExpectedStart, millisToString, removeLeadingZero } from 'ontime-utils';
+import {
+  EntryId,
+  MaybeNumber,
+  OffsetMode,
+  OntimeEntry,
+  OntimeEvent,
+  OntimeGroup,
+  OntimeReport,
+  Playback,
+  PlayableEvent,
+  isOntimeEvent,
+  isOntimeGroup,
+  isPlayableEvent,
+} from 'ontime-types';
+import { MILLIS_PER_MINUTE, getExpectedEnd, getExpectedStart, millisToString, removeLeadingZero } from 'ontime-utils';

 import { useCountdownSocket } from '../../common/hooks/useSocket';
 import { ExtendedEntry } from '../../common/utils/rundownMetadata';
@@ -40,7 +53,7 @@ export const timerProgress: TimerMessage = {
 * Handles events in different days but disregards whether an event has actually played
 */
 export function useSubscriptionDisplayData(
-  subscribedEvent: ExtendedEntry<OntimeEvent> & { endedAt: MaybeNumber; expectedStart: number },
+  subscribedEvent: CountdownTarget & { endedAt: MaybeNumber; expectedStart: number },
 ): { status: ProgressStatus; statusDisplay: string; timeDisplay: string } {
  const { playback, current, clock } = useCountdownSocket();
  const { getLocalizedString } = useTranslation();
@@ -67,7 +80,11 @@ export function useSubscriptionDisplayData(

    return {
      status: 'live',
-      statusDisplay: getLocalizedString(timerProgress['live']),
+      statusDisplay: getLocalizedString(
+        subscribedEvent.parent || (subscribedEvent.isGroup && subscribedEvent.liveEntry)
+          ? 'countdown.group_running'
+          : timerProgress['live'],
+      ),
      timeDisplay: bigDuration(current ?? 0),
    };
  }
@@ -168,10 +185,79 @@ export function isOutsideRange(a: number, b: number): boolean {
  return Math.abs(a - b) > MILLIS_PER_MINUTE;
 }

-export type CountdownEvent = ExtendedEntry<OntimeEvent> & { expectedStart: number; endedAt: MaybeNumber };
+/**
+ * A subscription target normalised to the event-shaped object the countdown display consumes.
+ * For events this is a pass-through; for groups it carries the group identity and display data
+ * while deriving timing from the group's first playable child (see resolveSubscriptionTarget).
+ */
+export type CountdownTarget = ExtendedEntry<OntimeEvent> & {
+  isGroup?: boolean;
+  targetId?: EntryId; // child entry used for countdown/live/armed state checks
+  reportId?: EntryId; // entry used for the report lookup (e.g. last child of a group)
+  liveEntry?: ExtendedEntry<OntimeEvent> | null; // the running child while a group is live
+};
+
+export type CountdownEvent = CountdownTarget & {
+  expectedStart: number;
+  expectedEnd: number;
+  endedAt: MaybeNumber;
+};
+
+/**
+ * Resolves a subscription (event or group) into an event-shaped countdown target.
+ * - Events are returned unchanged.
+ * - Groups count down to their first playable child while displaying the group identity.
+ *   Status is group-aware: live while any child is loaded, past only once the whole group has finished.
+ * Returns null when a group has no playable children (nothing to count down to).
+ */
+export function resolveSubscriptionTarget(
+  entry: ExtendedEntry<OntimeEvent | OntimeGroup>,
+  flatRundown: ExtendedEntry<OntimeEntry>[],
+): CountdownTarget | null {
+  if (!isOntimeGroup(entry)) {
+    return entry;
+  }
+
+  const children = flatRundown.filter(
+    (item): item is ExtendedEntry<PlayableEvent> =>
+      isOntimeEvent(item) && isPlayableEvent(item) && item.parent === entry.id,
+  );
+
+  if (children.length === 0) {
+    return null;
+  }
+
+  const firstChild = children[0];
+  const lastChild = children[children.length - 1];
+  const liveEntry = children.find((child) => child.isLoaded) ?? null;
+  const isLoaded = liveEntry !== null;
+  const isPast = !isLoaded && lastChild.isPast;
+
+  return {
+    // timing derives from the first playable child
+    ...firstChild,
+    // group identity and display data
+    id: entry.id,
+    parent: null,
+    title: entry.title,
+    colour: entry.colour,
+    note: entry.note,
+    custom: entry.custom,
+    duration: entry.duration,
+    countToEnd: false,
+    // group-aware status
+    isLoaded,
+    isPast,
+    // group markers
+    isGroup: true,
+    targetId: firstChild.id,
+    reportId: lastChild.id,
+    liveEntry,
+  };
+}

 export function extendEventData(
-  event: ExtendedEntry<OntimeEvent>,
+  event: CountdownTarget,
  currentDay: number,
  actualStart: MaybeNumber,
  plannedStart: MaybeNumber,
@@ -180,7 +266,7 @@ export function extendEventData(
  reportData: OntimeReport,
 ): CountdownEvent {
  const { totalGap, isLinkedToLoaded } = event;
-  const expectedStart = getExpectedStart(event, {
+  const expectedStartState = {
    currentDay,
    totalGap,
    actualStart,
@@ -188,7 +274,9 @@ export function extendEventData(
    isLinkedToLoaded,
    offset,
    mode,
-  });
-  const { endedAt } = reportData[event.id] ?? { endedAt: null };
-  return { ...event, expectedStart, endedAt };
+  };
+  const expectedStart = getExpectedStart(event, expectedStartState);
+  const expectedEnd = getExpectedEnd(event, expectedStartState);
+  const { endedAt } = reportData[event.reportId ?? event.id] ?? { endedAt: null };
+  return { ...event, expectedStart, expectedEnd, endedAt };
 }
@@ -1,32 +0,0 @@
-import { parseField } from '../cuesheet.utils';
-
-describe('parseField()', () => {
-  it('returns a string from given millis on timeStart, TimeEnd and duration', () => {
-    const testData1 = 1000;
-    const testData2 = 60000;
-    const testData3 = 600000;
-    expect(parseField('timeStart', testData1)).toBe('00:00:01');
-    expect(parseField('timeEnd', testData2)).toBe('00:01:00');
-    expect(parseField('duration', testData3)).toBe('00:10:00');
-  });
-
-  it('returns an empty string on undefined fields', () => {
-    // @ts-expect-error -- testing user data with missing fields
-    expect(parseField('title')).toBe('');
-  });
-
-  describe('simply returns any other value in any other field', () => {
-    const testFields = [
-      { field: 'nothing', value: '123' },
-      { field: 'title', value: 'test' },
-      { field: 'note', value: 'test' },
-      { field: 'colour', value: 'test' },
-    ];
-
-    testFields.forEach((testCase) => {
-      test(`${testCase.field}:${testCase.value}`, () => {
-        expect(parseField(testCase.field, testCase.value)).toBe(testCase.value);
-      });
-    });
-  });
-});
@@ -1,23 +0,0 @@
-import { CustomFields, MaybeNumber, OntimeEntryCommonKeys } from 'ontime-types';
-import { millisToString } from 'ontime-utils';
-
-type CsvHeaderKey = OntimeEntryCommonKeys | keyof CustomFields;
-
-/**
- * @description parses a field for export
- * @param {string} field
- * @param {*} data
- * @return {string}
- */
-
-export const parseField = (field: CsvHeaderKey, data: unknown): string => {
-  if (field === 'timeStart' || field === 'timeEnd' || field === 'duration') {
-    return millisToString(data as MaybeNumber, { fallback: '' });
-  }
-
-  if (field === 'skip') {
-    return data ? 'x' : '';
-  }
-
-  return String(data ?? '');
-};
@@ -54,17 +54,51 @@
 }

 .footer {
+  width: 100%;
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 1rem;
  font-size: calc(1rem - 2px);
  color: $label-gray;
 }

+.filterHint {
+  text-align: right;
+}
+
 .em {
  color: $ui-white;
  margin-inline: 0.25rem;
 }

+.hints {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem 1rem;
+  color: $label-gray;
+  font-size: calc(1rem - 3px);
+}
+
+.hintItem {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+}
+
 .scrollContainer {
  max-height: 70vh;
  overflow: auto;
  padding-top: 1rem;
 }
+
+@media (max-width: 680px) {
+  .footer {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .filterHint {
+    text-align: left;
+  }
+}
@@ -3,6 +3,7 @@ import { SupportedEntry } from 'ontime-types';
 import { KeyboardEvent, useState } from 'react';

 import Input from '../../../common/components/input/input/Input';
+import Kbd from '../../../common/components/kbd/Kbd';
 import Modal from '../../../common/components/modal/Modal';
 import useFinder from './useFinder';

@@ -96,8 +97,25 @@ export default function Finder({ isOpen, onClose }: FinderProps) {
      }
      footerElements={
        <div className={style.footer}>
-          Use the keywords <span className={style.em}>cue</span>, <span className={style.em}>index</span> or
-          <span className={style.em}>title</span> to filter search.
+          <div className={style.hints}>
+            <span className={style.hintItem}>
+              <Kbd>↑</Kbd>
+              <Kbd>↓</Kbd>
+              Navigate
+            </span>
+            <span className={style.hintItem}>
+              <Kbd>Enter</Kbd>
+              Go
+            </span>
+            <span className={style.hintItem}>
+              <Kbd>Esc</Kbd>
+              Close
+            </span>
+          </div>
+          <div className={style.filterHint}>
+            Filter by <span className={style.em}>cue</span>, <span className={style.em}>index</span>, or
+            <span className={style.em}>title</span>
+          </div>
        </div>
      }
    />
@@ -1,8 +1,8 @@
 import { Day } from 'ontime-types';
 import { CSSProperties, RefObject } from 'react';

+import { useAnimatedProgress } from '../../common/hooks/useAnimatedProgress';
 import { useExpectedStartData, useTimer } from '../../common/hooks/useSocket';
-import { getProgress } from '../../common/utils/getProgress';
 import { alpha, cx } from '../../common/utils/styleUtils';
 import { formatDuration, formatTime, getExpectedTimesFromExtendedEvent } from '../../common/utils/time';
 import { useTranslation } from '../../translation/TranslationProvider';
@@ -169,7 +169,7 @@ function TimelineEntryStatus({
 /** Generates a block level progress bar */
 function ActiveBlock() {
  const { current, duration } = useTimer();
-  const progress = getProgress(current, duration);
+  const progress = useAnimatedProgress(current, duration);
  return (
    <div data-status='live' className={style.timelineBlock} style={{ '--progress': `${progress}%` } as CSSProperties} />
  );
@@ -71,6 +71,11 @@ export default defineConfig({
        changeOrigin: true,
        configure: logProxyRequests,
      },
+      '^/mcp': {
+        target: 'http://localhost:4001/',
+        changeOrigin: true,
+        configure: logProxyRequests,
+      },
      '^/ws*': {
        target: 'http://localhost:4001/',
        changeOrigin: true,
@@ -20,7 +20,7 @@
  "license": "AGPL-3.0-only",
  "devDependencies": {
    "ontime-types": "workspace:^4.2.1",
-    "tsdown": "^0.21.5",
+    "tsdown": "^0.22.4",
    "typescript": "catalog:"
  },
  "files": [
@@ -1,6 +1,7 @@
 {
  "extends": "./tsconfig.json",
  "compilerOptions": {
-    "ignoreDeprecations": "6.0"
+    "isolatedDeclarations": true,
+    "allowJs": false
  }
 }
@@ -42,7 +42,7 @@
  "scripts": {
    "addversion": "node -p \"'export const ONTIME_VERSION = ' + JSON.stringify(require('../../package.json').version) + ';'\" > src/ONTIME_VERSION.js",
    "postinstall": "pnpm addversion",
-    "dev": "cross-env NODE_ENV=development tsx watch --tsconfig tsconfig.app.json ./src/index.ts",
+    "dev": "cross-env PORT=4001 NODE_ENV=development tsx watch --tsconfig tsconfig.app.json ./src/index.ts",
    "dev:electron": "pnpm dev",
    "dev:inspect": "cross-env NODE_ENV=development tsx watch --tsconfig tsconfig.app.json --inspect ./src/index.ts",
    "lint": "oxlint --quiet --type-aware",
@@ -6,11 +6,13 @@ const editEntryMock = vi.hoisted(() => vi.fn());
 const groupEntriesMock = vi.hoisted(() => vi.fn());
 const ungroupEntriesMock = vi.hoisted(() => vi.fn());
 const getCurrentRundownMock = vi.hoisted(() => vi.fn());
+const getProjectCustomFieldsMock = vi.hoisted(() => vi.fn());
+const createCustomFieldMock = vi.hoisted(() => vi.fn());

 vi.mock('../../api-data/rundown/rundown.dao.js', () => ({
  getCurrentRundown: getCurrentRundownMock,
  getCurrentRundownId: vi.fn(() => 'loaded-rundown'),
-  getProjectCustomFields: vi.fn(() => ({})),
+  getProjectCustomFields: getProjectCustomFieldsMock,
 }));

 vi.mock('../../classes/data-provider/DataProvider.js', () => ({
@@ -20,6 +22,7 @@ vi.mock('../../classes/data-provider/DataProvider.js', () => ({
 vi.mock('../../api-data/rundown/rundown.service.js', () => ({
  addEntry: addEntryMock,
  batchEditEntries: vi.fn(),
+  createCustomField: createCustomFieldMock,
  deleteEntries: vi.fn(),
  editEntry: editEntryMock,
  groupEntries: groupEntriesMock,
@@ -27,7 +30,8 @@ vi.mock('../../api-data/rundown/rundown.service.js', () => ({
  ungroupEntries: ungroupEntriesMock,
 }));

-const { batchCreateEntriesForMcp, groupEntriesForMcp, ungroupEntryForMcp } = await import('../mcp.service.js');
+const { batchCreateEntriesForMcp, createCustomFieldForMcp, createEntryForMcp, groupEntriesForMcp, ungroupEntryForMcp } =
+  await import('../mcp.service.js');

 function makeRundown(entries: Rundown['entries'], order: string[] = Object.keys(entries)): Rundown {
  return {
@@ -44,6 +48,7 @@ describe('mcp.service', () => {
  beforeEach(() => {
    vi.clearAllMocks();
    getCurrentRundownMock.mockReturnValue(makeRundown({}));
+    getProjectCustomFieldsMock.mockReturnValue({});

    let id = 0;
    addEntryMock.mockImplementation(async (_rundownId: string, payload: EventPostPayload) => {
@@ -252,4 +257,42 @@ describe('mcp.service', () => {
    expect(ungroupEntriesMock).toHaveBeenCalledWith('loaded-rundown', 'group');
    expect(result).toMatchObject({ ungrouped: 'group', order: ['entry-1'] });
  });
+
+  describe('createCustomFieldForMcp', () => {
+    it('creates a field and returns the derived key', async () => {
+      createCustomFieldMock.mockResolvedValue({
+        Camera_Angle: { label: 'Camera Angle', type: 'text', colour: '#3E75E8' },
+      });
+
+      const result = await createCustomFieldForMcp({ label: 'Camera Angle', type: 'text', colour: '#3E75E8' });
+
+      expect(createCustomFieldMock).toHaveBeenCalledWith({ label: 'Camera Angle', type: 'text', colour: '#3E75E8' });
+      expect(result.key).toBe('Camera_Angle');
+    });
+
+    it('rejects labels the editor UI would not accept', async () => {
+      await expect(createCustomFieldForMcp({ label: 'Camera/GFX', type: 'text', colour: '#000000' })).rejects.toThrow(
+        'Invalid label',
+      );
+      expect(createCustomFieldMock).not.toHaveBeenCalled();
+    });
+
+    it('rejects case-insensitive duplicates and points at the existing key', async () => {
+      getProjectCustomFieldsMock.mockReturnValue({ Camera: { label: 'Camera', type: 'text', colour: '' } });
+
+      await expect(createCustomFieldForMcp({ label: 'camera', type: 'text', colour: '#000000' })).rejects.toThrow(
+        'A custom field with key "Camera" (label "Camera") already exists.',
+      );
+      expect(createCustomFieldMock).not.toHaveBeenCalled();
+    });
+  });
+
+  it('suggests the correctly cased key when custom values use the wrong casing', async () => {
+    getProjectCustomFieldsMock.mockReturnValue({ Camera: { label: 'Camera', type: 'text', colour: '' } });
+
+    await expect(createEntryForMcp({ title: 'Talk', custom: { camera: 'CAM 2' } })).rejects.toThrow(
+      'Keys are case-sensitive — did you mean: "camera" → "Camera"?',
+    );
+    expect(addEntryMock).not.toHaveBeenCalled();
+  });
 });
@@ -0,0 +1,56 @@
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('../../api-data/project-data/projectData.dao.js', () => ({
+  getProjectData: vi.fn(() => ({ title: 'Test project' })),
+}));
+
+vi.mock('../../api-data/rundown/rundown.dao.js', () => ({
+  getCurrentRundown: vi.fn(() => ({
+    id: 'rundown-1',
+    title: 'Test',
+    order: [],
+    flatOrder: [],
+    entries: {},
+    revision: 0,
+  })),
+  getProjectCustomFields: vi.fn(() => ({})),
+}));
+
+vi.mock('../../classes/data-provider/DataProvider.js', () => ({
+  getDataProvider: vi.fn(() => ({ getProjectRundowns: () => ({}) })),
+}));
+
+const { PROMPT_DEFINITIONS, handleGetPrompt } = await import('../mcp.prompts.js');
+const { RESOURCE_DEFINITIONS, handleReadResource } = await import('../mcp.resources.js');
+
+describe('MCP resource wiring', () => {
+  it('serves non-empty content for every listed resource', () => {
+    for (const resource of RESOURCE_DEFINITIONS) {
+      const result = handleReadResource(resource.uri);
+      expect(result.contents).toHaveLength(1);
+      expect(result.contents[0].uri).toBe(resource.uri);
+      expect(result.contents[0].mimeType).toBe(resource.mimeType);
+      expect((result.contents[0].text as string).length).toBeGreaterThan(0);
+    }
+  });
+
+  it('rejects unknown resource URIs', () => {
+    expect(() => handleReadResource('ontime://nope')).toThrow('Unknown resource URI: ontime://nope');
+  });
+});
+
+describe('MCP prompt wiring', () => {
+  it('resolves every listed prompt', () => {
+    for (const prompt of PROMPT_DEFINITIONS) {
+      const args = Object.fromEntries((prompt.arguments ?? []).map((arg) => [arg.name, 'test value']));
+      const result = handleGetPrompt(prompt.name, args);
+      expect(result.messages.length).toBeGreaterThan(0);
+      const content = result.messages[0].content;
+      expect(content.type).toBe('text');
+    }
+  });
+
+  it('rejects unknown prompts', () => {
+    expect(() => handleGetPrompt('nope', {})).toThrow('Unknown prompt: nope');
+  });
+});
@@ -0,0 +1,103 @@
+/**
+ * Agent-facing Ontime guidance documents.
+ *
+ * These markdown resources teach agents rundown craft (ontime://style-guide)
+ * and Ontime's view ecosystem (ontime://views). Guidance should be concise and
+ * clear — verbosity distracts agents and users alike. Keep each document short.
+ */
+
+// The palette mirrors the editor colour picker swatches in
+// apps/client/src/common/components/input/colour-input/SwatchSelect.tsx — keep in sync.
+export const ONTIME_STYLE_GUIDE_MARKDOWN = `# Ontime rundown style guide
+
+Conventions for tidy, scannable rundowns. Read before creating or restyling a rundown. Follow the user's own conventions when they have them; otherwise prefer these. When communicating with the user, be concise — short proposals beat long explanations.
+
+## Structure
+
+- Group events into blocks matching the show's segments; 10+ ungrouped events is a wall — propose groups.
+- Set \`targetDuration\` on groups so operators can track time to block completion.
+- Use \`milestone\` for non-timed markers (doors open, broadcast start), not zero-duration events.
+- Use \`delay\` only to model schedule drift, never as padding.
+- Schedule changeovers and buffers as real events (grey; orange when technical), not invisible gaps — 5–10 min between major segments stops one overrun cascading through the day.
+- Model contingency segments as \`skip: true\` events: visible in the rundown, excluded from playback, one edit to activate.
+- Before show day, duplicate the rundown for rehearsal so the show copy stays clean.
+
+## Colours
+
+Prefer Ontime's default palette — the editor's swatches — so colours look native. Each hue has a dark/light tone pair:
+
+| Hue | Dark | Light | Use |
+| --- | --- | --- | --- |
+| Red | \`#ED3333\` | \`#FF7878\` | attention: curfews, hard deadlines, broadcast-critical |
+| Orange | \`#FFAB33\` | \`#FFCC78\` | technical changeovers, resets |
+| Green | \`#339E4E\` | \`#77C785\` | normal show content |
+| Blue | \`#3E75E8\` | \`#779BE7\` | normal show content |
+| Violet | \`#8064E1\` | \`#A790F5\` | normal show content |
+| Grey | \`#9d9d9d\` | \`#ececec\` | breaks, housekeeping |
+
+- Normal segments use the calm hues (green, blue, violet). Reserve red for what genuinely needs attention and orange for changeovers.
+- Use tones for hierarchy: dark tone on a group, the light tone of the same hue on its child events.
+- One convention per project, applied consistently.
+
+## Cues and titles
+
+- Cues follow ONE convention per rundown: numeric (\`1, 2, 3\` or \`10, 20, 30\`, leaving room for insertions), semantic (\`Preset\`, \`Key 1\`, \`Lunch\`), or a deliberate mix. Dense technical shows often prefix by department (\`LX1\`, \`SND2\`, \`VID3\`). Match what the rundown already uses; ask if nothing is established.
+- Cues are automation handles — external systems (Companion, OSC/HTTP) trigger events by cue name. Keep them unique and stable; warn before renaming cues on an existing show.
+- Title = what happens on stage, under ~50 characters. Department/tech data goes in custom fields; \`note\` is for free-text human context.
+
+## Custom fields
+
+- Structured per-department data (camera, graphics, audio, speaker) belongs in custom fields — one per department, coloured to match. This powers the cuesheet and operator views.
+- Reuse existing fields; never create near-duplicates (\`Cam\`, \`camera\`, \`Cameras\`).
+- Data repeated in titles or notes ("CAM 2") is a sign it belongs in a custom field.
+- Write values to be scannable mid-show: "CAM 2 close-up", not sentences.
+
+## Timing
+
+- \`linkStart\` events inside a block so schedule edits propagate.
+- \`flag\` sparingly — it marks critical moments and dilutes with overuse.
+- Set \`timeWarning\` where a moderator would signal the speaker to wrap (commonly 5 min); \`timeDanger\` for the final push (e.g. 1 min). Scale both down for short items.
+- Hard out? Backtime: build the closing items from the end with \`timeEnd\` + \`duration\` (Ontime calculates \`timeStart\`), protect their ends with \`timeStrategy: lock-end\`, and use \`countToEnd\` for true curfew items.
+
+After tidying, read \`ontime://views\` and suggest views that use the new structure.
+`;
+
+export const ONTIME_VIEWS_MARKDOWN = `# Ontime views and sharing guide
+
+Ontime renders the rundown into role-specific views at \`http://<host>:<port>/<view>\`. Recommend the right view when the user mentions a role, device, or sharing need. Prefer sharing live view links over exporting static documents — everyone sees the current version, ending the conflicting-copies problem of circulated spreadsheets. The agent cannot create views or presets — give exact URLs and point to the editor settings.
+
+| View | Path | For |
+| --- | --- | --- |
+| Timer | \`/timer\` | speakers/presenters on stage |
+| Backstage | \`/backstage\` | crew following schedule + notes |
+| Operator | \`/op\` | department operators on phone/tablet |
+| Cuesheet | \`/cuesheet\` | cross-department table editing |
+| Timeline | \`/timeline\` | producers, whole-show overview |
+| Countdown | \`/countdown\` | following selected events or a group |
+| Studio clock | \`/studio\` | on-air studio environments |
+| Project info | \`/info\` | sharing event logistics widely |
+
+Most views are configured via URL parameters (editor and cuesheet in-app); the view's cog icon exposes the options and encodes them into the URL.
+
+## Operator view parameters
+
+- \`main\` / \`secondary-src\`: the two text lines — \`title\`, \`note\`, or \`custom-<fieldKey>\`.
+- \`subscribe=<fieldKey>\`: highlight a custom field (repeatable).
+- \`shouldEdit=true\`: long-press editing of the highlighted field.
+- \`hidePast=true\`, \`showStart=true\`: trim and annotate the list.
+
+Example for a camera operator:
+\`/op?main=title&secondary-src=custom-Camera&subscribe=Camera&hidePast=true\`
+
+Offer a link like this after creating a department custom field.
+
+## URL presets
+
+Presets bundle a configured view under a short alias (e.g. \`/camera-op\`), optionally shown in the nav menu. Managed in **Editor → Settings → URL presets**. When recommending a configured view, spell out the view and query string and suggest saving it as a preset.
+Docs: https://docs.getontime.no/features/url-presets/
+
+## Custom views
+
+For branding or layouts beyond the built-in options: files in Ontime's \`external\` folder are served at \`/external/…\` and can use Ontime's APIs for live data. Recommend for sponsor branding, unusual layouts, or LED wall graphics.
+Docs: https://docs.getontime.no/features/custom-views/
+`;
@@ -33,6 +33,18 @@ export const PROMPT_DEFINITIONS: ListPromptsResult['prompts'] = [
      },
    ],
  },
+  {
+    name: 'tidy_rundown',
+    description:
+      'Audit the rundown for readability (colours, grouping, cue naming, custom field usage) and propose improvements',
+    arguments: [
+      {
+        name: 'focus',
+        description: 'Optional area to focus on, e.g. "colours only" or "grouping"',
+        required: false,
+      },
+    ],
+  },
  {
    name: 'manage_custom_fields',
    description: 'List, create, rename, recolour, or delete project-level custom field definitions',
@@ -105,15 +117,17 @@ Flags (flag):
 - Set \`flag: true\` on events that are critical operational markers (keynote starts, broadcast moments, VIP arrivals).
 - The operator view shows a countdown to the next flagged event — use sparingly for maximum impact.

-Colours:
- Ask the user what colour convention they use before applying any colours.
- Common pattern: one colour per event type (keynotes, panels, breaks, meals).
- Colours are hex strings: \`#RRGGBB\`.
+Structure and colours:
+- Read the ontime://style-guide resource before deciding on structure or colours.
+- Propose a group per agenda section (morning block, keynotes, breaks) rather than a flat list — in ontime_batch_create_entries this is just a group entry with \`children\`.
+- Ask the user what colour convention they use; if they have none, propose one from the default Ontime palette in the style guide: calm hues for normal content, red only for attention items, orange for changeovers, dark tone on a group with the light tone of the same hue on its children. Colours are hex strings: \`#RRGGBB\`.

 Custom fields (custom):
 - Call ontime_get_custom_fields for the project's field keys (cuesheet-style columns such as camera, graphics, speaker).
- Store values per entry at \`custom: { <fieldKey>: <value> }\` — only use keys that exist in the project.
- If the user's requested field is ambiguous, show the existing field list before choosing a key, so you avoid duplicate concepts such as \`Cam\`, \`camera\`, and \`Cameras\`.
+- Store values per entry at \`custom: { <fieldKey>: <value> }\` — keys are case-sensitive.
+- Reuse an existing field when it covers the concept (avoid duplicates such as \`Cam\`, \`camera\`, \`Cameras\`); when the agenda carries structured data with no matching field (speakers, locations), create it with ontime_create_custom_field and use the returned key — no confirmation needed.
+
+After creating the rundown, read ontime://views and suggest how the team can follow it — e.g. a timer view for speakers, a backstage view for crew, or an operator view subscribed to a department custom field.

 Agenda:
 ${args.agenda}`,
@@ -162,6 +176,7 @@ Schedule integrity:
 - Events with \`duration\` of 0 or negative
 - Events with \`gap < 0\`: overlaps the previous timed event and is a conflict
 - Large unexplained positive gaps between consecutive timed events (> 30 min): check whether these are intentional
+- Long segments scheduled back-to-back with no changeover or buffer between them: one overrun will cascade — suggest a buffer event
 - Events where \`timeEnd < timeStart\`: these cross midnight; confirm this is intentional
 - Events whose \`timeStart\` is the same as or earlier than the previous playable event's \`timeStart\`: Ontime schedules these on the next day; confirm this is intentional

@@ -181,6 +196,13 @@ Skipped events:
 Totals:
 - Total rundown duration and whether it matches the user's expected show length (ask if unknown)

+Readability (report at INFO level; see ontime://style-guide for the conventions):
+- Colour usage without a consistent convention, or key segments left uncoloured
+- Long runs of related ungrouped events that would read better as groups
+- Duplicate cues (cues are automation handles and should be unique) or mixed cue naming conventions
+- Structured department data in titles/notes that belongs in custom fields
+- If several readability issues surface, suggest running the tidy_rundown prompt to fix them systematically
+
 Present issues grouped by severity: ERROR (breaks playback), WARNING (likely mistake), INFO (worth confirming).`,
    );
  }
@@ -215,6 +237,34 @@ Efficiency tip: plan moves in the direction of the target position to minimise r
    );
  }

+  if (name === 'tidy_rundown') {
+    const focus = args.focus ? `\nFocus specifically on: "${args.focus}".` : '';
+    return userPrompt(
+      'Audit and improve rundown readability',
+      `Audit the current Ontime rundown for readability and tidiness, then propose improvements.${focus}
+
+Steps:
+1. Read the ontime://style-guide resource — it defines the conventions to audit against, including the standard colour palette.
+2. Call ontime_list_rundowns and identify the target rundown. If the user wants a background rundown, pass its \`rundownId\` in all entry read/write calls instead of loading it.
+3. Call ontime_get_rundown with the chosen \`rundownId\`, and ontime_get_custom_fields for the project field definitions.
+4. Call ontime_get_timer_state. If playback is not \`stop\` and the target is the loaded rundown, explain that MCP edits affect the live rundown and ask the user to confirm before changing it.
+
+Audit for:
+- Colour consistency: entries coloured outside a discernible convention, missing colours on key segments, red/orange used for normal content (the style guide reserves them for attention items and changeovers), or group/children colours that ignore the dark/light tone pairing. Prefer the default Ontime palette.
+- Grouping: long runs (roughly 4+) of related consecutive top-level events that would read better as a named group; groups missing \`targetDuration\`.
+- Buffers: long segments back-to-back with no changeover event between them; propose short buffer events so one overrun cannot cascade.
+- Cue naming: mixed conventions (numeric vs semantic) without apparent intent, duplicate cues, or gaps that suggest mistakes. Remember cues are automation handles — renaming them can break external triggers, so flag renames explicitly.
+- Data in the wrong place: structured department data buried in titles or notes (e.g. "CAM 2", "GFX: lower third") that belongs in a custom field; overlong titles (over ~50 chars).
+- Entry types: zero-duration events that should be milestones; milestones that carry timing expectations and should be events.
+- Flags: \`flag: true\` on many events dilutes its meaning — critical markers only.
+
+Then:
+5. Present the findings as a short, scannable proposal (what changes, on which entries, and why) and WAIT for the user to approve before mutating anything. Be concise — a tight list beats prose.
+6. Apply approved changes with the cheapest calls: ontime_group_entries to group existing entries, ontime_batch_update_entries when several entries get the same values (e.g. recolouring), ontime_update_entry for per-entry changes, ontime_create_custom_field when moving data into a new field.
+7. Finish by reading ontime://views and suggesting views that put the improved structure to work — e.g. an operator view subscribed to a department custom field, or a cuesheet for cross-department editing.`,
+    );
+  }
+
  if (name === 'manage_custom_fields') {
    return userPrompt(
      'List, create, rename, recolour, or delete custom field definitions',
@@ -223,14 +273,14 @@ Efficiency tip: plan moves in the direction of the target position to minimise r
 Custom fields are project-scoped. They appear as columns in the cuesheet and can be set on any event, milestone, or group. Changes apply to all rundowns in the project.

 Steps:
-1. Call ontime_get_custom_fields to see what fields already exist. This is mandatory before creating — to avoid duplicates such as "Cam", "camera", and "Cameras".
-2. Carry out the instruction using the tools below. Confirm destructive changes (rename, delete) with the user before calling.
+1. Call ontime_get_custom_fields to see what fields already exist. Reuse an existing field when it covers the concept — avoid duplicates such as "Cam", "camera", and "Cameras".
+2. Carry out the instruction using the tools below. Creating a field is non-destructive — do it directly. Confirm destructive changes (rename, delete) with the user before calling.

 Creating a field:
 - Call ontime_create_custom_field with { label, type, colour }.
- label: human-readable name (alphanumeric with spaces). The key is auto-derived: spaces → underscores (e.g. "Camera Angle" → "Camera_Angle"). Confirm the derived key with the user before creating.
+- label: human-readable name (letters, numbers and spaces). The key is auto-derived: spaces → underscores (e.g. "Camera Angle" → "Camera_Angle").
 - type: "text" for short string values, "image" for image URLs. Cannot be changed after creation.
- colour: hex colour (#RRGGBB) used to visually identify this column in the cuesheet. Ask the user what colour to use if not specified.
+- colour: hex colour (#RRGGBB) used to visually identify this column in the cuesheet. If unspecified, pick one from the default Ontime palette matching the department.
 - Returns: { key, customFields } — use the returned key when setting values on entries.

 Renaming or recolouring a field:
@@ -242,7 +292,9 @@ Deleting a field:
 - Call ontime_delete_custom_field with { key }.
 - Warning: this permanently removes the field definition and its values from every entry in all rundowns. Confirm with the user before deleting.

-After any mutation, call ontime_get_custom_fields again to confirm the result and show the user the updated field list with their keys.`,
+After any mutation, call ontime_get_custom_fields again to confirm the result and show the user the updated field list with their keys.
+
+When a field was created for a department (camera, graphics, audio…), read ontime://views and offer the views that surface it: the cuesheet shows the field as a column for cross-department editing, and the operator view can display or highlight it for that department, e.g. /op?main=title&secondary-src=custom-<key>&subscribe=<key>.`,
    );
  }

@@ -4,6 +4,7 @@ import { getProjectData } from '../api-data/project-data/projectData.dao.js';
 import { getCurrentRundown, getProjectCustomFields } from '../api-data/rundown/rundown.dao.js';
 import { normalisedToRundownArray } from '../api-data/rundown/rundown.utils.js';
 import { getDataProvider } from '../classes/data-provider/DataProvider.js';
+import { ONTIME_STYLE_GUIDE_MARKDOWN, ONTIME_VIEWS_MARKDOWN } from './mcp.guides.js';
 import { ONTIME_DOCS_MARKDOWN, ONTIME_SCHEMA_MARKDOWN } from './mcp.schema.js';

 export const RESOURCE_DEFINITIONS: ListResourcesResult['resources'] = [
@@ -45,6 +46,22 @@ export const RESOURCE_DEFINITIONS: ListResourcesResult['resources'] = [
      'Map of custom field keys to their label, type, and colour. Events reference these keys in their `custom` object.',
    mimeType: 'application/json',
  },
+  {
+    uri: 'ontime://style-guide',
+    name: 'ontime-style-guide',
+    title: 'Rundown style guide',
+    description:
+      'Best practices for tidy, easy-to-read rundowns: grouping, colour conventions and the default Ontime palette, cue naming, custom fields vs notes, timing hygiene. Read before creating or restyling a rundown.',
+    mimeType: 'text/markdown',
+  },
+  {
+    uri: 'ontime://views',
+    name: 'ontime-views',
+    title: 'Views and sharing guide',
+    description:
+      'What each Ontime view (timer, backstage, operator, cuesheet, timeline, countdown, studio clock, project info) is for, key URL parameters, URL presets, and custom views. Read when recommending how a team member should follow or edit the show.',
+    mimeType: 'text/markdown',
+  },
  {
    uri: 'ontime://docs',
    name: 'ontime-docs',
@@ -57,6 +74,8 @@ export const RESOURCE_DEFINITIONS: ListResourcesResult['resources'] = [

 const RESOURCE_READERS: Record<string, { mimeType: string; read: () => string }> = {
  'ontime://schema': { mimeType: 'text/markdown', read: () => ONTIME_SCHEMA_MARKDOWN },
+  'ontime://style-guide': { mimeType: 'text/markdown', read: () => ONTIME_STYLE_GUIDE_MARKDOWN },
+  'ontime://views': { mimeType: 'text/markdown', read: () => ONTIME_VIEWS_MARKDOWN },
  'ontime://docs': { mimeType: 'text/markdown', read: () => ONTIME_DOCS_MARKDOWN },
  'ontime://rundown/current': {
    mimeType: 'application/json',
@@ -49,7 +49,8 @@ export const EVENT_WRITABLE_FIELDS = {
  note: { type: 'string', description: 'Free-text note for production notes or references' },
  colour: {
    type: 'string',
-    description: 'Hex colour (#RRGGBB) for visual grouping — ask the user what colour convention they use',
+    description:
+      'Hex colour (#RRGGBB) for visual grouping — ask the user what colour convention they use, and prefer the default Ontime palette from ontime://style-guide so colours match the editor swatches',
  },
  skip: { type: 'boolean', description: 'If true, event is skipped during playback' },
  flag: {
@@ -60,7 +61,7 @@ export const EVENT_WRITABLE_FIELDS = {
    type: 'object',
    additionalProperties: { type: 'string' },
    description:
-      'Custom field values keyed by existing project field key, e.g. { "camera": "CAM 2" }. Get available keys with ontime_get_custom_fields. Adding new custom field definitions is a separate project-level operation.',
+      'Custom field values keyed by project field key, e.g. { "Camera": "CAM 2" }. Keys are case-sensitive — get them with ontime_get_custom_fields, and create missing fields with ontime_create_custom_field.',
  },
  ...EVENT_TIMER_FIELDS,
 } as const;
@@ -180,12 +181,11 @@ Events, milestones and groups store values at \`entry.custom[fieldKey]\`.

 Managing field definitions:
 - Read: \`ontime_get_custom_fields\` — returns \`{ [key]: { label, type, colour } }\`
- Create: \`ontime_create_custom_field { label, type, colour }\` — key is auto-derived from label (spaces → underscores). Confirm the derived key before creating. Returns \`{ key, customFields }\`.
+- Create: \`ontime_create_custom_field { label, type, colour }\` — key is auto-derived from label (spaces → underscores). Returns \`{ key, customFields }\`.
 - Rename/recolour: \`ontime_update_custom_field { key, label?, colour? }\` — renaming the label changes the derived key and cascades to all entry references across all rundowns. Type cannot be changed.
 - Delete: \`ontime_delete_custom_field { key }\` — removes the field definition and its values from every entry in all rundowns. Destructive, confirm first.

-When setting \`custom\` values on entries, only use existing field keys. If a key does not exist, create it with \`ontime_create_custom_field\` first.
-Show the existing field list before creating to avoid duplicates such as \`Cam\`, \`camera\`, and \`Cameras\`.
+Keys are case-sensitive. When setting \`custom\` values, reuse an existing field when it covers the concept; otherwise create the missing field — creation is non-destructive and needs no confirmation. Rename and delete are the destructive operations: confirm those with the user.

 ## Targeting rundowns
 Entry read/write tools accept an optional \`rundownId\`.
@@ -199,6 +199,8 @@ When playback is not \`stop\`, mutations to the loaded rundown affect the live r

 ## Available resources
 - \`ontime://schema\` — this document
+- \`ontime://style-guide\` — rundown design best practices: grouping, colour palette, cue naming, custom field usage. Read before creating or restyling a rundown.
+- \`ontime://views\` — Ontime's role-specific views, URL parameters, URL presets, and custom views. Read when recommending how a team member should follow or edit the show.
 - \`ontime://rundown/current\` — the currently loaded rundown (JSON)
 - \`ontime://rundowns\` — all rundowns in the project (JSON)
 - \`ontime://project/info\` — project metadata (JSON)
@@ -234,6 +236,16 @@ Main site: https://docs.getontime.no
 - OSC Integration: https://docs.getontime.no/api/osc/
 - Make custom views: https://docs.getontime.no/features/custom-views/

+## Views
+- Configuring views: https://docs.getontime.no/quick-tips/configuring-views/
+- Operator view: https://docs.getontime.no/interface/production/operator/
+- Cuesheet: https://docs.getontime.no/interface/production/cuesheet/
+- Render views in third-party apps: https://docs.getontime.no/quick-tips/render-elsewhere/
+
+## Quick tips
+- Managing delays: https://docs.getontime.no/quick-tips/managing-delays/
+- Smart time entry: https://docs.getontime.no/quick-tips/smart-time-entry/
+
 ## Helpful references
 - Ontime Cloud: https://docs.getontime.no/ontime-cloud/
 - Connect to companion module: https://docs.getontime.no/additional-notes/companion-module/
@@ -12,6 +12,7 @@ import {
  Rundown,
  SupportedEntry,
 } from 'ontime-types';
+import { checkRegex, customFieldLabelToKey } from 'ontime-utils';

 import { getCurrentRundown, getCurrentRundownId, getProjectCustomFields } from '../api-data/rundown/rundown.dao.js';
 import {
@@ -110,11 +111,21 @@ export function assertKnownCustomFields(...customValues: Array<EntryFieldArgs['c
    const available = Object.keys(customFields);
    const hint =
      available.length > 0 ? `Available keys: ${available.join(', ')}.` : 'No custom fields are defined yet.';
+
+    // keys are case-sensitive; a near-miss on casing is the most common mistake
+    const suggestions = [...unknownKeys]
+      .map((key) => {
+        const match = available.find((existing) => existing.toLowerCase() === key.toLowerCase());
+        return match ? `"${key}" → "${match}"` : null;
+      })
+      .filter(Boolean);
+    const caseHint =
+      suggestions.length > 0 ? ` Keys are case-sensitive — did you mean: ${suggestions.join(', ')}?` : '';
+
    throw new Error(
-      `Unknown custom field key(s): ${missing}. ${hint} ` +
+      `Unknown custom field key(s): ${missing}. ${hint}${caseHint} ` +
        `Call ontime_create_custom_field with { label, type, colour } to create a missing field — ` +
-        `the key is auto-derived from the label (spaces → underscores, e.g. label "Camera" → key "Camera"). ` +
-        `Call ontime_get_custom_fields to list existing keys.`,
+        `the key is auto-derived from the label (spaces → underscores, e.g. label "Mix Output" → key "Mix_Output").`,
    );
  }
 }
@@ -333,8 +344,23 @@ export async function batchUpdateEntriesForMcp(args: TargetRundownArgs & { ids:
 }

 export async function createCustomFieldForMcp(args: { label: string; type: 'text' | 'image'; colour: string }) {
-  const updated = await createCustomField({ label: args.label, type: args.type, colour: args.colour });
-  const key = Object.keys(updated).find((k) => updated[k].label === args.label) ?? args.label;
+  const label = args.label?.trim();
+  // same constraint the HTTP route enforces in customFields.validation.ts
+  if (!label || !checkRegex.isAlphanumericWithSpace(label)) {
+    throw new Error('Invalid label: use letters, numbers and spaces only, e.g. "Camera Angle".');
+  }
+
+  const key = customFieldLabelToKey(label);
+  const existingFields = getProjectCustomFields();
+  const clash = Object.keys(existingFields).find((existing) => existing.toLowerCase() === key.toLowerCase());
+  if (clash) {
+    throw new Error(
+      `A custom field with key "${clash}" (label "${existingFields[clash].label}") already exists. ` +
+        `Reuse it in entry.custom["${clash}"] instead of creating a duplicate, or pick a clearly different label.`,
+    );
+  }
+
+  const updated = await createCustomField({ label, type: args.type, colour: args.colour });
  return { key, customFields: updated };
 }

@@ -186,7 +186,11 @@ export const TOOL_DEFINITIONS = [
        ids: { type: 'array', items: { type: 'string' }, description: 'Existing top-level entry IDs to group' },
        title: { type: 'string', description: 'Group title shown in the rundown and views' },
        note: { type: 'string', description: 'Free-text group note for production notes or references' },
-        colour: { type: 'string', description: 'Hex colour (#RRGGBB) for the group' },
+        colour: {
+          type: 'string',
+          description:
+            'Hex colour (#RRGGBB) for the group — prefer the default Ontime palette from ontime://style-guide',
+        },
        custom: {
          type: 'object',
          additionalProperties: { type: 'string' },
@@ -377,7 +381,7 @@ export const TOOL_DEFINITIONS = [
  {
    name: 'ontime_create_custom_field',
    description:
-      'Create a new project-level custom field definition. Custom fields add typed columns to every entry in all rundowns. The key is auto-derived from the label (spaces → underscores, e.g. "Camera Angle" → "Camera_Angle"). After creation, use the key in entry.custom when creating or updating entries.',
+      'Create a new project-level custom field definition. Custom fields add typed columns to every entry in all rundowns. The key is auto-derived from the label (spaces → underscores, e.g. "Camera Angle" → "Camera_Angle"). Creation is non-destructive — check ontime_get_custom_fields for an existing field covering the concept, and if none exists create directly without asking the user. After creation, use the returned key in entry.custom.',
    inputSchema: {
      type: 'object',
      required: ['label', 'type', 'colour'],
@@ -385,7 +389,7 @@ export const TOOL_DEFINITIONS = [
        label: {
          type: 'string',
          description:
-            'Human-readable label (alphanumeric with spaces, e.g. "Camera"). Determines the key — ask the user to confirm before creating to avoid duplicates like "Cam", "camera", "Cameras".',
+            'Human-readable label (letters, numbers and spaces, e.g. "Camera"). Determines the key. Reuse an existing field over creating near-duplicates like "Cam", "camera", "Cameras".',
        },
        type: {
          type: 'string',
@@ -395,7 +399,8 @@ export const TOOL_DEFINITIONS = [
        },
        colour: {
          type: 'string',
-          description: 'Hex colour (#RRGGBB) used to visually identify this column in the cuesheet.',
+          description:
+            'Hex colour (#RRGGBB) used to visually identify this column in the cuesheet — for department fields, match the department colour convention (see ontime://style-guide).',
        },
      },
    },
@@ -7,11 +7,21 @@ import { initRundown } from '../../api-data/rundown/rundown.service.js';
 import { loadRoll } from '../rollUtils.js';

 vi.mock('../../classes/data-provider/DataProvider.js', () => {
+  let automation = {
+    enabledAutomations: false,
+    enabledOscIn: false,
+    oscPortIn: 8888,
+    triggers: [],
+    automations: {},
+  };
+
  return {
    getDataProvider: vi.fn().mockImplementation(() => {
      return {
+        getAutomation: vi.fn().mockImplementation(() => automation),
        setCustomFields: vi.fn().mockImplementation((newData) => newData),
        setRundown: vi.fn().mockImplementation((newData) => newData),
+        setAutomation: vi.fn().mockImplementation((newData) => (automation = newData)),
      };
    }),
  };
@@ -5,6 +5,7 @@ import type { RuntimeState } from '../../stores/runtimeState.js';
 import {
  findDayOffset,
  getCurrent,
+  getElapsed,
  getExpectedFinish,
  getRuntimeOffset,
  getTimerPhase,
@@ -15,6 +16,56 @@ import {

 const asTimeOfDay = (value: number): RuntimeState['clock'] => value as RuntimeState['clock'];

+describe('getElapsed()', () => {
+  it('returns active elapsed time from startedAt without add-time adjustments', () => {
+    const state = {
+      clock: 5 * MILLIS_PER_MINUTE,
+      timer: {
+        addedTime: -10 * MILLIS_PER_MINUTE,
+        current: 15 * MILLIS_PER_MINUTE,
+        duration: 20 * MILLIS_PER_MINUTE,
+        startedAt: 2 * MILLIS_PER_MINUTE,
+      },
+      _timer: {
+        pausedAt: null,
+        pausedDuration: 0,
+      },
+    } as RuntimeState;
+
+    expect(getElapsed(state)).toBe(3 * MILLIS_PER_MINUTE);
+  });
+
+  it('subtracts accumulated pause time', () => {
+    const state = {
+      clock: 10 * MILLIS_PER_MINUTE,
+      timer: {
+        startedAt: 2 * MILLIS_PER_MINUTE,
+      },
+      _timer: {
+        pausedAt: null,
+        pausedDuration: 5 * MILLIS_PER_MINUTE,
+      },
+    } as RuntimeState;
+
+    expect(getElapsed(state)).toBe(3 * MILLIS_PER_MINUTE);
+  });
+
+  it('uses the current pause start while paused', () => {
+    const state = {
+      clock: 10 * MILLIS_PER_MINUTE,
+      timer: {
+        startedAt: 2 * MILLIS_PER_MINUTE,
+      },
+      _timer: {
+        pausedAt: 7 * MILLIS_PER_MINUTE,
+        pausedDuration: 1 * MILLIS_PER_MINUTE,
+      },
+    } as RuntimeState;
+
+    expect(getElapsed(state)).toBe(4 * MILLIS_PER_MINUTE);
+  });
+});
+
 describe('getExpectedFinish()', () => {
  it('is null if we havent started', () => {
    const state = {
@@ -174,7 +225,7 @@ describe('getExpectedFinish()', () => {
    expect(calculatedFinish).toBe(10);
  });
  describe('on timers of type time-to-end', () => {
-    it('finish time is as schedule + added time', () => {
+    it('finish time is the fixed end, ignoring added time', () => {
      const state = {
        eventNow: {
          timeEnd: 30,
@@ -191,32 +242,57 @@ describe('getExpectedFinish()', () => {
        },
      } as RuntimeState;

+      // the end is anchored: added time surfaces as offset, it does not move the finish
      const calculatedFinish = getExpectedFinish(state);
-      expect(calculatedFinish).toBe(40);
+      expect(calculatedFinish).toBe(30);
    });
-    it('handles events that finish the day after', () => {
+
+    it('finish time is the fixed end, ignoring pauses', () => {
      const state = {
        eventNow: {
-          timeEnd: 600000, // 00:10:00
+          timeEnd: 30,
+          countToEnd: true,
+        },
+        clock: 25,
+        timer: {
+          addedTime: 0,
+          duration: dayInMs,
+          startedAt: 10,
+        },
+        _timer: {
+          pausedAt: 20, // paused 5 ago - wall clock keeps approaching the fixed end
+          hasFinished: false,
+        },
+      } as RuntimeState;
+
+      const calculatedFinish = getExpectedFinish(state);
+      expect(calculatedFinish).toBe(30);
+    });
+
+    it('returns the start time for count to end times which started late', () => {
+      const state = {
+        eventNow: {
+          timeStart: 20 * MILLIS_PER_HOUR, // 20:00:00
+          timeEnd: 21 * MILLIS_PER_MINUTE, // 21:00:00
          countToEnd: true,
        },
        timer: {
          addedTime: 0,
-          startedAt: 79200000, // 22:00:00
+          startedAt: 22 * MILLIS_PER_HOUR, // 22:00:00 <--------------
        },
        _timer: {
          pausedAt: null,
          hasFinished: false,
        },
        rundown: {
-          actualStart: 79200000,
-          plannedEnd: 600000,
+          actualStart: 20 * MILLIS_PER_HOUR, // 20:00:00
+          plannedEnd: 21 * MILLIS_PER_HOUR, // 21:00:00
        },
      } as RuntimeState;

      const calculatedFinish = getExpectedFinish(state);
-      // expected finish is not a duration but a point in time
-      expect(calculatedFinish).toBe(600000);
+      // timeEnd is numerically before startedAt for overnight events, so expectedFinish is clamped to startedAt
+      expect(calculatedFinish).toBe(22 * MILLIS_PER_HOUR);
    });
  });
 });
@@ -400,7 +476,7 @@ describe('getCurrent()', () => {
      expect(current).toBe(70);
    });

-    it('current time is the time to end + added time', () => {
+    it('current time is the time to end, ignoring added time', () => {
      const state = {
        eventNow: {
          timeEnd: 100,
@@ -421,8 +497,9 @@ describe('getCurrent()', () => {
        },
      } as RuntimeState;

+      // counts to the fixed end; added time surfaces as offset, not extra countdown
      const current = getCurrent(state);
-      expect(current).toBe(77);
+      expect(current).toBe(70);
    });

    it('handles events that finish the day after', () => {
@@ -431,6 +508,7 @@ describe('getCurrent()', () => {
          timeStart: 79200000, // 22:00:00
          timeEnd: 600000, // 00:10:00
          countToEnd: true,
+          dayOffset: 0,
        },
        clock: 79500000, // 22:05:00
        timer: {
@@ -441,6 +519,7 @@ describe('getCurrent()', () => {
        rundown: {
          actualStart: 79200000,
          plannedEnd: 600000,
+          currentDay: 0,
        },
        _timer: {
          pausedAt: null,
@@ -452,6 +531,35 @@ describe('getCurrent()', () => {
      expect(current).toBe(dayInMs - 79500000 + 600000);
    });

+    it('handles overnight count-to-end after midnight', () => {
+      const state = {
+        eventNow: {
+          timeStart: 23 * MILLIS_PER_HOUR, // 23:00:00
+          timeEnd: 1 * MILLIS_PER_HOUR, // 01:00:00
+          countToEnd: true,
+          dayOffset: 0,
+        },
+        clock: 30 * MILLIS_PER_MINUTE, // 00:30:00 on day 1
+        timer: {
+          addedTime: 0,
+          duration: Infinity,
+          startedAt: 23 * MILLIS_PER_HOUR,
+        },
+        rundown: {
+          actualStart: 23 * MILLIS_PER_HOUR,
+          plannedEnd: 1 * MILLIS_PER_HOUR,
+          currentDay: 1,
+        },
+        _timer: {
+          pausedAt: null,
+          hasFinished: false,
+        },
+      } as RuntimeState;
+
+      const current = getCurrent(state);
+      expect(current).toBe(30 * MILLIS_PER_MINUTE);
+    });
+
    it('handles events that were started late', () => {
      const state = {
        clock: 82000000, // 22:46:40 <--- starting 16 min after the scheduled end
@@ -1022,7 +1130,7 @@ describe('getRuntimeOffset()', () => {
    expect(absolute).toBe(0);
  });

-  it('with time-to-end, offset is the overtime', () => {
+  it('with time-to-end, offset combines overtime and added time', () => {
    const state = {
      clock: 82000000, // 22:46:40
      eventNow: {
@@ -1075,7 +1183,45 @@ describe('getRuntimeOffset()', () => {
    } as RuntimeState;

    const { absolute } = getRuntimeOffset(state);
-    expect(absolute).toBe(400000); // <--- offset is always the overtime
+    // overtime (400000) plus the operator's added time (-200000)
+    expect(absolute).toBe(200000);
+  });
+
+  it('with time-to-end, added time surfaces as offset', () => {
+    const state = {
+      clock: 80000000, // 22:13:20 - before the scheduled end, not in overtime
+      eventNow: {
+        id: 'd6a2ce',
+        timeStart: 77400000, // 21:30:00
+        timeEnd: 81000000, // 22:30:00
+        duration: 3600000, // 01:00:00
+        timeStrategy: TimeStrategy.LockEnd,
+        countToEnd: true,
+        dayOffset: 0,
+        delay: 0,
+      },
+      rundown: {
+        plannedStart: 77400000, // 21:30:00
+        plannedEnd: 81000000, // 22:30:00
+        actualStart: 78000000, // 21:40:00
+        currentDay: 0,
+      },
+      offset: {
+        absolute: 0,
+      },
+      timer: {
+        addedTime: 300000, // operator added 5 minutes
+        current: 1000000, // still counting down, no overtime
+        duration: 3600000,
+        startedAt: 78000000,
+      },
+      _startDayOffset: 0,
+      _timer: { pausedAt: null },
+    } as RuntimeState;
+
+    // the end is anchored, so the added 5 minutes shows up purely as offset
+    const { absolute } = getRuntimeOffset(state);
+    expect(absolute).toBe(300000);
  });

  it('handles time-to-end started after the end time', () => {
@@ -0,0 +1,9 @@
+/**
+ * Expose errors where we reach invalid states
+ * used mostly in shouldCrashDev patterns
+ */
+export class InvalidStateError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}
@@ -47,6 +47,23 @@ describe('isRestorePoint()', () => {
    expect(isRestorePoint(restorePoint)).toBe(true);
  });

+  it('accepts optional paused duration', () => {
+    const restorePoint: RestorePoint = {
+      playback: Playback.Roll,
+      selectedEventId: '123',
+      startedAt: 1,
+      addedTime: 2,
+      pausedAt: null,
+      pausedDuration: 3000,
+      firstStart: 1,
+      startEpoch: asInstant(1),
+      currentDay: 0,
+    };
+
+    expect(isRestorePoint(restorePoint)).toBe(true);
+    expect(isRestorePoint({ ...restorePoint, pausedDuration: '3000' })).toBe(false);
+  });
+
  describe('rejects a badly formatted file', () => {
    it('with invalid playback value', () => {
      const restorePoint = {
@@ -46,6 +46,10 @@ export function isRestorePoint(restorePoint: unknown): restorePoint is RestorePo
    return false;
  }

+  if ('pausedDuration' in restorePoint && !is.number(restorePoint.pausedDuration)) {
+    return false;
+  }
+
  if (!is.number(restorePoint.firstStart) && restorePoint.firstStart !== null) {
    return false;
  }
@@ -6,6 +6,7 @@ export type RestorePoint = {
  startedAt: MaybeNumber;
  addedTime: number;
  pausedAt: MaybeNumber;
+  pausedDuration?: number;
  firstStart: MaybeNumber;
  startEpoch: Maybe<Instant>;
  currentDay: MaybeNumber;
@@ -760,6 +760,7 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
          startedAt: state.timer.startedAt,
          addedTime: state.timer.addedTime,
          pausedAt: state._timer.pausedAt,
+          pausedDuration: state._timer.pausedDuration,
          firstStart: state.rundown.actualStart,
          startEpoch: state._startEpoch,
          currentDay: state.rundown.currentDay,
@@ -33,7 +33,8 @@ export function getShouldClockUpdate(previousUpdate: number, now: number): boole
 * Checks whether we should update the timer values
 * - `current` and `secondaryTimer` trigger on seconds roll over
 * - the rest trigger on any change
- * - `elapsed` and `expectedFinish` is not checked
+ * - `elapsed` changes alongside `current`
+ * - `expectedFinish` is not checked
 */
 export function getShouldTimerUpdate(previousValue: TimerState | undefined, currentValue: TimerState): boolean {
  if (previousValue === undefined) return true;
@@ -48,7 +49,7 @@ export function getShouldTimerUpdate(previousValue: TimerState | undefined, curr
    previousValue.phase !== currentValue.phase ||
    previousValue.playback !== currentValue.playback ||
    previousValue.startedAt !== currentValue.startedAt
-    // elapsed - this would be the direct invert of current value so no need to check
+    // elapsed - this is derived from current / duration / addedTime, so the fields above cover it
    // expectedFinish - this will be moved out by the current value going into over time, no need to check
  );
 }
@@ -2,6 +2,7 @@ import { Day, MaybeNumber, TimeOfDay, TimerPhase } from 'ontime-types';
 import { MILLIS_PER_HOUR, checkIsNow, dayInMs, isPlaybackActive } from 'ontime-utils';

 import type { RuntimeState } from '../stores/runtimeState.js';
+import { InvalidStateError } from './generic.errors.js';

 /**
 * handle events that span over midnight
@@ -24,35 +25,35 @@ export function hasCrossedMidnight(previous: TimeOfDay, current: TimeOfDay): boo
 * @returns {number | null} new current time or null if nothing is running
 */
 export function getExpectedFinish(state: RuntimeState): MaybeNumber {
-  const { startedAt, duration, addedTime } = state.timer;
-
-  if (state.eventNow === null) {
+  // if there is a loaded event it must have started
+  // either way, we have no expected finish if nothing is playing
+  if (state.eventNow === null || state.timer.startedAt === null) {
    return null;
  }

-  const { countToEnd, timeEnd } = state.eventNow;
-  const { pausedAt } = state._timer;
-  const { clock } = state;
-
-  if (startedAt === null) {
-    return null;
+  if (state.eventNow.countToEnd) {
+    // count to end events are anchored to their fixed end: added time and pauses
+    // do not move the end, they surface as offset instead (see getRuntimeOffset)
+    return Math.max(state.eventNow.timeEnd, state.timer.startedAt);
  }

-  const pausedTime = pausedAt != null ? clock - pausedAt : 0;
+  const pausedTime = state._timer.pausedAt != null ? state.clock - state._timer.pausedAt : 0;

-  if (countToEnd) {
-    return timeEnd + addedTime + pausedTime;
+  DEV: {
+    if (state.timer.duration === null) {
+      throw new InvalidStateError('a running timer cannot have null duration');
+    }
  }

  // handle events that finish the day after
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- duration exists if ther eis a timer
-  const expectedFinish = startedAt + duration! + addedTime + pausedTime;
+  const expectedFinish = state.timer.startedAt + state.timer.duration + state.timer.addedTime + pausedTime;
  if (expectedFinish > dayInMs) {
    return expectedFinish - dayInMs;
  }

  // an event cannot finish before it started (user added too much negative time)
-  return Math.max(expectedFinish, startedAt);
+  return Math.max(expectedFinish, state.timer.startedAt);
 }

 /**
@@ -74,9 +75,12 @@ export function getCurrent(state: RuntimeState): number {
  const { clock } = state;

  if (countToEnd) {
-    const isEventOverMidnight = timeStart > timeEnd;
-    const correctDay = isEventOverMidnight ? dayInMs : 0;
-    return correctDay - clock + timeEnd + addedTime;
+    // count to end runs to its fixed end, so added time does not stretch the countdown
+    const dayOffset = state.eventNow.dayOffset ?? 0;
+    const currentDay =
+      state.rundown.currentDay ?? (timeStart > timeEnd && clock <= timeEnd ? dayOffset + 1 : dayOffset);
+    const endDay = timeStart > timeEnd ? dayOffset + 1 : dayOffset;
+    return timeEnd + endDay * dayInMs - (clock + currentDay * dayInMs);
  }

  if (startedAt === null) {
@@ -92,6 +96,33 @@ export function getCurrent(state: RuntimeState): number {
  return startedAt + duration + addedTime - clock - correctDay;
 }

+/**
+ * Calculates active time elapsed since the timer started.
+ */
+export function getElapsed(state: RuntimeState): MaybeNumber {
+  const { clock } = state;
+  const { startedAt } = state.timer;
+  const { pausedAt, pausedDuration } = state._timer;
+
+  if (startedAt === null) {
+    return null;
+  }
+
+  const referenceClock = pausedAt ?? clock;
+  const elapsedSinceStart = getTimeSinceStart(referenceClock, startedAt);
+  const activeElapsed = elapsedSinceStart - pausedDuration;
+
+  return Math.max(0, activeElapsed);
+}
+
+function getTimeSinceStart(clock: TimeOfDay, startedAt: number): number {
+  if (clock < startedAt) {
+    return clock + dayInMs - startedAt;
+  }
+
+  return clock - startedAt;
+}
+
 /**
 * Checks whether we have skipped out of the event
 * @param {RuntimeState} state runtime state
@@ -153,13 +184,14 @@ export function getRuntimeOffset(state: RuntimeState): { absolute: number; relat
  const pausedTime = state._timer.pausedAt === null ? 0 : clock - state._timer.pausedAt;

  // absolute offset is difference between schedule and playback time
-  const absolute = eventStartOffset + overtime + pausedTime + addedTime;
+  // count to end is anchored to its fixed end, so it absorbs the late start (eventStartOffset)
+  // and the pause (already reflected in overtime); added time surfaces here as offset
+  const absolute = countToEnd ? overtime + addedTime : eventStartOffset + overtime + pausedTime + addedTime;

  // the relative offset is the same as the absolute but adjusted relative to the actual start time
  const relative = absolute + plannedStart - actualStart - _startDayOffset * dayInMs;

-  // in case of count to end, the absolute offset is just the overtime
-  return countToEnd ? { absolute: overtime, relative } : { absolute, relative };
+  return { absolute, relative };
 }

 /**
@@ -40,6 +40,7 @@ const baseState: RuntimeState = {
  _timer: {
    forceFinish: null,
    pausedAt: null,
+    pausedDuration: 0,
    secondaryTarget: null,
    hasFinished: false,
  },
@@ -56,11 +56,21 @@ const mockState = {
 } as RuntimeState;

 vi.mock('../../classes/data-provider/DataProvider.js', () => {
+  let automation = {
+    enabledAutomations: false,
+    enabledOscIn: false,
+    oscPortIn: 8888,
+    triggers: [],
+    automations: {},
+  };
+
  return {
    getDataProvider: vi.fn().mockImplementation(() => {
      return {
+        getAutomation: vi.fn().mockImplementation(() => automation),
        setCustomFields: vi.fn().mockImplementation((newData) => newData),
        setRundown: vi.fn().mockImplementation((newData) => newData),
+        setAutomation: vi.fn().mockImplementation((newData) => (automation = newData)),
      };
    }),
  };
@@ -168,6 +178,79 @@ describe('mutation on runtimeState', () => {
      });
      expect(newState.rundown.actualStart).toBeNull();
    });
+
+    test('elapsed remains active time when adding and removing time', async () => {
+      clearState();
+      const event = {
+        ...mockEvent,
+        id: 'elapsed-add-time',
+        timeStart: 0,
+        timeEnd: 10 * MILLIS_PER_MINUTE,
+        duration: 10 * MILLIS_PER_MINUTE,
+      };
+      const mockRundown = makeRundown({
+        entries: { [event.id]: event },
+        order: [event.id],
+      });
+
+      await initRundown(mockRundown, {});
+      vi.runAllTimers();
+
+      const { metadata, rundown } = rundownCache.get();
+      vi.setSystemTime('jan 1 00:00');
+      load(event, rundown, metadata);
+      start();
+
+      vi.setSystemTime('jan 1 00:02');
+      update();
+
+      addTime(5 * MILLIS_PER_MINUTE);
+      let state = getState();
+      expect(state.timer.elapsed).toBe(2 * MILLIS_PER_MINUTE);
+      expect(state.timer.duration! - state.timer.current!).toBe(-3 * MILLIS_PER_MINUTE);
+
+      addTime(-8 * MILLIS_PER_MINUTE);
+      state = getState();
+      expect(state.timer.elapsed).toBe(2 * MILLIS_PER_MINUTE);
+      expect(state.timer.duration! - state.timer.current!).toBe(5 * MILLIS_PER_MINUTE);
+    });
+
+    test('elapsed excludes time spent paused after resume', async () => {
+      clearState();
+      const event = {
+        ...mockEvent,
+        id: 'elapsed-pause',
+        timeStart: 0,
+        timeEnd: 10 * MILLIS_PER_MINUTE,
+        duration: 10 * MILLIS_PER_MINUTE,
+      };
+      const mockRundown = makeRundown({
+        entries: { [event.id]: event },
+        order: [event.id],
+      });
+
+      await initRundown(mockRundown, {});
+      vi.runAllTimers();
+
+      const { metadata, rundown } = rundownCache.get();
+      vi.setSystemTime('jan 1 00:00');
+      load(event, rundown, metadata);
+      start();
+
+      vi.setSystemTime('jan 1 00:02');
+      update();
+      pause();
+
+      vi.setSystemTime('jan 1 00:07');
+      start();
+      let state = getState();
+      expect(state.timer.elapsed).toBe(2 * MILLIS_PER_MINUTE);
+
+      vi.setSystemTime('jan 1 00:08');
+      update();
+      state = getState();
+      expect(state.timer.elapsed).toBe(3 * MILLIS_PER_MINUTE);
+    });
  });

  test('runtime offset', async () => {
@@ -245,6 +328,121 @@ describe('mutation on runtimeState', () => {
    expect(newState.offset.expectedRundownEnd).toBeNull();
  });

+  test('a countToEnd last event absorbs overtime into its fixed rundown end', async () => {
+    const entries = {
+      event1: {
+        ...mockEvent,
+        id: 'event1',
+        timeStart: 10 * MILLIS_PER_HOUR,
+        timeEnd: 11 * MILLIS_PER_HOUR,
+        duration: MILLIS_PER_HOUR,
+        parent: null,
+      },
+      event2: {
+        ...mockEvent,
+        id: 'event2',
+        timeStart: 11 * MILLIS_PER_HOUR,
+        timeEnd: 12 * MILLIS_PER_HOUR,
+        duration: MILLIS_PER_HOUR,
+        countToEnd: true,
+        linkStart: true,
+        parent: null,
+      },
+    };
+    const mockRundown = makeRundown({ entries, order: ['event1', 'event2'] });
+
+    await initRundown(mockRundown, {});
+    vi.runAllTimers();
+
+    const { metadata, rundown } = rundownCache.get();
+
+    // start event1 five minutes behind schedule
+    vi.setSystemTime('jan 1 10:05');
+    load(entries.event1, rundown, metadata);
+    start();
+    update();
+
+    const newState = getState();
+    expect(newState.offset.absolute).toBe(5 * MILLIS_PER_MINUTE);
+
+    // without countToEnd the rundown would end at 12h + 5min, but the countToEnd
+    // event absorbs the overtime so the rundown is still expected to end at 12h
+    expect(newState.offset.expectedRundownEnd).toBe(12 * MILLIS_PER_HOUR);
+  });
+
+  test('adding time to a running countToEnd event surfaces as offset and end remains fixed', async () => {
+    const entries = {
+      event1: {
+        ...mockEvent,
+        id: 'event1',
+        timeStart: 10 * MILLIS_PER_HOUR,
+        timeEnd: 12 * MILLIS_PER_HOUR,
+        duration: 2 * MILLIS_PER_HOUR,
+        countToEnd: true,
+        parent: null,
+      },
+    };
+    const mockRundown = makeRundown({ entries, order: ['event1'] });
+
+    await initRundown(mockRundown, {});
+    vi.runAllTimers();
+
+    const { metadata, rundown } = rundownCache.get();
+
+    // start on time
+    vi.setSystemTime('jan 1 10:00');
+    load(entries.event1, rundown, metadata);
+    start();
+    update();
+
+    let state = getState();
+    expect(state.offset.absolute).toBe(0);
+    expect(state.timer.expectedFinish).toBe(12 * MILLIS_PER_HOUR);
+    expect(state.offset.expectedRundownEnd).toBe(12 * MILLIS_PER_HOUR);
+
+    // operator adds 5 minutes
+    addTime(5 * MILLIS_PER_MINUTE);
+
+    state = getState();
+    // the end cant move, so the added time is added to the offset
+    expect(state.offset.absolute).toBe(5 * MILLIS_PER_MINUTE);
+    expect(state.timer.expectedFinish).toBe(12 * MILLIS_PER_HOUR);
+    expect(state.offset.expectedRundownEnd).toBe(12 * MILLIS_PER_HOUR);
+  });
+
+  test('subtracting more than the remaining time does not finish a countToEnd event', async () => {
+    const entries = {
+      event1: {
+        ...mockEvent,
+        id: 'event1',
+        timeStart: 10 * MILLIS_PER_HOUR,
+        timeEnd: 12 * MILLIS_PER_HOUR,
+        duration: 2 * MILLIS_PER_HOUR,
+        countToEnd: true,
+        parent: null,
+      },
+    };
+    const mockRundown = makeRundown({ entries, order: ['event1'] });
+
+    await initRundown(mockRundown, {});
+    vi.runAllTimers();
+
+    const { metadata, rundown } = rundownCache.get();
+
+    vi.setSystemTime('jan 1 10:00');
+    load(entries.event1, rundown, metadata);
+    start();
+    update();
+
+    // removing longer than the remaining time cannot finish the event since the end is fixed
+    addTime(-3 * MILLIS_PER_HOUR);
+    update();
+
+    const state = getState();
+    expect(state.timer.playback).toBe(Playback.Play);
+    expect(state.timer.expectedFinish).toBe(12 * MILLIS_PER_HOUR);
+  });
+
  test('resume restores currentDay from restore point', async () => {
    clearState();
    const mockRundown = makeRundown({
@@ -956,4 +1154,32 @@ describe('loadGroupFlagAndEnd()', () => {
      eventNow: rundown.entries[0],
    });
  });
+
+  test('a countToEnd event breaks the link chain for the events that follow it', () => {
+    // chain: A (loaded) -> B (countToEnd, flagged) -> C (linked, last event)
+    // the chain stays intact up to and including B, but breaks for C since it follows a countToEnd event
+    const rundown = makeRundown({
+      entries: {
+        A: makeOntimeEvent({ id: 'A', parent: null, linkStart: false, countToEnd: false, gap: 0 }),
+        B: makeOntimeEvent({ id: 'B', parent: null, linkStart: true, countToEnd: true, gap: 0, flag: true }),
+        C: makeOntimeEvent({ id: 'C', parent: null, linkStart: true, countToEnd: false, gap: 0 }),
+      },
+      order: ['A', 'B', 'C'],
+    });
+
+    const state = {
+      groupNow: null,
+      eventNow: rundown.entries.A,
+      rundown: { actualGroupStart: null },
+    } as RuntimeState;
+
+    const metadata = { playableEventOrder: ['A', 'B', 'C'], flags: ['B'] } as RundownMetadata;
+
+    loadGroupFlagAndEnd(rundown, metadata, 0, state);
+
+    // the flag (B) is still part of the chain
+    expect(state._flag).toMatchObject({ event: rundown.entries.B, isLinkedToLoaded: true });
+    // the rundown end (C) follows the countToEnd event, so the chain is broken
+    expect(state._end).toMatchObject({ event: rundown.entries.C, isLinkedToLoaded: false });
+  });
 });
@@ -23,6 +23,7 @@ import {
  calculateDuration,
  checkIsNow,
  dayInMs,
+  getExpectedEnd,
  getExpectedStart,
  getLastEventNormal,
  isPlaybackActive,
@@ -36,12 +37,14 @@ import { loadRoll, normaliseRollStart } from '../services/rollUtils.js';
 import {
  findDayOffset,
  getCurrent,
+  getElapsed,
  getExpectedFinish,
  getRuntimeOffset,
  getTimerPhase,
  hasCrossedMidnight,
 } from '../services/timerUtils.js';
 import { timerConfig } from '../setup/config.js';
+import { shouldCrashDev } from '../utils/development.js';

 type ExpectedMetadata = {
  event: OntimeEvent;
@@ -62,6 +65,7 @@ export type RuntimeState = {
  _timer: {
    forceFinish: Maybe<TimeOfDay>; // whether we should declare an event as finished, will contain the finish time
    pausedAt: Maybe<TimeOfDay>;
+    pausedDuration: number;
    secondaryTarget: Maybe<TimeOfDay>;
    hasFinished: boolean;
  };
@@ -87,6 +91,7 @@ const runtimeState: RuntimeState = {
  _timer: {
    forceFinish: null,
    pausedAt: null,
+    pausedDuration: 0,
    secondaryTarget: null,
    hasFinished: false,
  },
@@ -138,6 +143,7 @@ export function clearEventData() {
  // when clearing, we maintain the total delay from the rundown
  runtimeState._timer.forceFinish = null;
  runtimeState._timer.pausedAt = null;
+  runtimeState._timer.pausedDuration = 0;
  runtimeState._timer.secondaryTarget = null;
  runtimeState._timer.hasFinished = false;
 }
@@ -170,6 +176,7 @@ export function clearState() {
  // when clearing, we maintain the total delay from the rundown
  runtimeState._timer.forceFinish = null;
  runtimeState._timer.pausedAt = null;
+  runtimeState._timer.pausedDuration = 0;
  runtimeState._timer.secondaryTarget = null;
  runtimeState._timer.hasFinished = false;

@@ -426,6 +433,7 @@ export function start(state: RuntimeState = runtimeState): boolean {
  if (state._timer.pausedAt) {
    const timeToAdd = state.clock - state._timer.pausedAt;
    state.timer.addedTime += timeToAdd;
+    state._timer.pausedDuration += timeToAdd;
    state._timer.pausedAt = null;
  }

@@ -435,7 +443,7 @@ export function start(state: RuntimeState = runtimeState): boolean {

  state.timer.playback = Playback.Play;
  state.timer.expectedFinish = getExpectedFinish(state);
-  state.timer.elapsed = 0;
+  state.timer.elapsed = getElapsed(state);

  if (state.rundown.actualStart === null) {
    state._startDayOffset = (findDayOffset(state.eventNow.timeStart, state.clock) + state.eventNow.dayOffset) as Day;
@@ -503,23 +511,32 @@ export function addTime(amount: number) {
    }
  }

-  // handle edge cases
-  // !!! we need to handle side effects before updating the state
-  const willGoNegative = amount < 0 && Math.abs(amount) > runtimeState.timer.current;
-
-  if (willGoNegative && !runtimeState._timer.hasFinished) {
-    // set finished time so side effects are triggered
-    runtimeState._timer.forceFinish = timeCore.timeOfDayNow();
+  if (runtimeState.eventNow?.countToEnd) {
+    // count to end is anchored to its fixed end: added time cannot move the end or finish
+    // the event early, it only surfaces as offset. `current` is derived from the wall clock
+    // by the update loop, so we must not bump it here.
+    runtimeState.timer.addedTime += amount;
  } else {
-    const willGoPositive = runtimeState.timer.current < 0 && runtimeState.timer.current + amount > 0;
-    if (willGoPositive) {
-      runtimeState._timer.hasFinished = false;
+    // handle edge cases
+    // !!! we need to handle side effects before updating the state
+    const willGoNegative = amount < 0 && Math.abs(amount) > runtimeState.timer.current;
+
+    if (willGoNegative && !runtimeState._timer.hasFinished) {
+      // set finished time so side effects are triggered
+      runtimeState._timer.forceFinish = timeCore.timeOfDayNow();
+    } else {
+      const willGoPositive = runtimeState.timer.current < 0 && runtimeState.timer.current + amount > 0;
+      if (willGoPositive) {
+        runtimeState._timer.hasFinished = false;
+      }
    }
+
+    // we can update the state after handling the side effects
+    runtimeState.timer.addedTime += amount;
+    runtimeState.timer.current += amount;
  }

-  // we can update the state after handling the side effects
-  runtimeState.timer.addedTime += amount;
-  runtimeState.timer.current += amount;
+  runtimeState.timer.elapsed = getElapsed(runtimeState);

  // update runtime delays: over - under
  const { absolute, relative } = getRuntimeOffset(runtimeState);
@@ -575,7 +592,7 @@ export function update(): UpdateResult {
  runtimeState.timer.current = getCurrent(runtimeState);
  runtimeState.timer.expectedFinish = getExpectedFinish(runtimeState);
  runtimeState.timer.phase = getTimerPhase(runtimeState);
-  runtimeState.timer.elapsed = runtimeState.timer.duration - runtimeState.timer.current;
+  runtimeState.timer.elapsed = getElapsed(runtimeState);

  // update runtime, needs up-to-date timer state
  const { absolute, relative } = getRuntimeOffset(runtimeState);
@@ -824,7 +841,6 @@ function getExpectedTimes(state = runtimeState) {
  state.offset.expectedRundownEnd = null;
  state.offset.expectedGroupEnd = null;
  state.offset.expectedFlagStart = null;
-  state.offset.expectedRundownEnd = null;

  const { offset } = state;
  const { plannedStart, actualStart } = state.rundown;
@@ -834,9 +850,11 @@ function getExpectedTimes(state = runtimeState) {

  if (state.groupNow) {
    const { _group } = state;
-    if (_group !== null) {
-      const { event: lastEvent, accumulatedGap, isLinkedToLoaded } = _group;
-      const lastEventExpectedStart = getExpectedStart(lastEvent, {
+    DEV: shouldCrashDev(_group === null, 'groupNow is set but _group is null');
+
+    if (_group) {
+      const { event, accumulatedGap, isLinkedToLoaded } = _group;
+      state.offset.expectedGroupEnd = getExpectedEnd(event, {
        currentDay: state.rundown.currentDay!,
        totalGap: accumulatedGap,
        isLinkedToLoaded,
@@ -845,15 +863,16 @@ function getExpectedTimes(state = runtimeState) {
        plannedStart,
        actualStart,
      });
-      state.offset.expectedGroupEnd = lastEventExpectedStart + lastEvent.duration;
    }
  }

  if (state.eventFlag) {
    const { _flag } = state;
+    DEV: shouldCrashDev(_flag === null, 'eventFlag is set but _flag is null');
+
    if (_flag) {
      const { event, accumulatedGap, isLinkedToLoaded } = _flag;
-      const expectedStart = getExpectedStart(event, {
+      state.offset.expectedFlagStart = getExpectedStart(event, {
        currentDay: state.rundown.currentDay!,
        totalGap: accumulatedGap,
        isLinkedToLoaded,
@@ -862,13 +881,13 @@ function getExpectedTimes(state = runtimeState) {
        plannedStart,
        actualStart,
      });
-      state.offset.expectedFlagStart = expectedStart;
    }
  }

  if (state._end) {
    const { event, accumulatedGap, isLinkedToLoaded } = state._end;
-    const expectedStart = getExpectedStart(event, {
+
+    state.offset.expectedRundownEnd = getExpectedEnd(event, {
      currentDay: state.rundown.currentDay!,
      totalGap: accumulatedGap,
      isLinkedToLoaded,
@@ -877,7 +896,6 @@ function getExpectedTimes(state = runtimeState) {
      plannedStart,
      actualStart,
    });
-    state.offset.expectedRundownEnd = expectedStart + event.duration;
  }
 }

@@ -920,6 +938,8 @@ export function loadGroupFlagAndEnd(

  let accumulatedGap = 0;
  let isLinkedToLoaded = true;
+  // a countToEnd event absorbs overtime and breaks the chain
+  let previousWasCountToEnd = false;

  for (let idx = currentIndex; idx < playableEventOrder.length; idx++) {
    const entry = entries[playableEventOrder[idx]];
@@ -928,7 +948,7 @@ export function loadGroupFlagAndEnd(
      if (idx !== currentIndex) {
        // we only accumulate data after the loaded event
        accumulatedGap += entry.gap;
-        isLinkedToLoaded = isLinkedToLoaded && entry.linkStart;
+        isLinkedToLoaded = isLinkedToLoaded && entry.linkStart && !previousWasCountToEnd;

        // and the loaded event is not allowed to be the next flag
        if (!foundFlag && metadata.flags.includes(entry.id)) {
@@ -942,6 +962,8 @@ export function loadGroupFlagAndEnd(
        foundGroupEnd = true;
        state._group = { event: lastEventInGroup, isLinkedToLoaded, accumulatedGap };
      }
+
+      previousWasCountToEnd = entry.countToEnd;
    }
  }

@@ -83,7 +83,7 @@ export type OntimeActionKey =
  | OntimeMessageSet
  | OntimeMessageSecondary;

-export const ontimeActionKeyValues = [
+export const ontimeActionKeyValues: string[] = [
  ...ontimeAuxTriggerAction,
  ...ontimePlaybackAction,
  ...ontimeAuxSetAction,
@@ -12,4 +12,4 @@ export enum TimerLifeCycle {

 export type TimerLifeCycleKey = keyof typeof TimerLifeCycle;

-export const timerLifecycleValues = Object.keys(TimerLifeCycle);
+export const timerLifecycleValues: string[] = Object.keys(TimerLifeCycle);
@@ -10,7 +10,7 @@ export const runtimeStorePlaceholder: Readonly<RuntimeStore> = {
    addedTime: 0,
    current: null, // changes on every update
    duration: null, // only changes if event changes
-    elapsed: null, // changes on every update
+    elapsed: null, // active time from start, changes on every update
    expectedFinish: null, // change can only be initiated by user, can roll over midnight
    phase: TimerPhase.None, // can change on update or user action
    playback: Playback.Stop, // change initiated by user
@@ -21,7 +21,7 @@ export type TimerState = {
  current: MaybeNumber;
  /** Total duration of the running event */
  duration: MaybeNumber;
-  /** Time elapsed since the timer started */
+  /** Active time elapsed since the timer started */
  elapsed: MaybeNumber;
  /** Timestamp of the expected finish time */
  expectedFinish: MaybeNumber;
@@ -16,6 +16,7 @@ export const langEn = {
  'common.no_data': 'No data',
  'countdown.ended': 'Event ended at',
  'countdown.running': 'Event running',
+  'countdown.group_running': 'Event in group running',
  'countdown.loaded': 'Event loaded',
  'countdown.select_event': 'Select an event to follow',
  'countdown.to_start': 'Time to start',
@@ -80,7 +80,7 @@ export { validateEndAction, validateTimerType } from './src/validate-events/vali

 // feature business logic

-export { getExpectedStart } from './src/date-utils/getExpectedStart.js';
+export { getExpectedStart, getExpectedEnd } from './src/date-utils/getExpected.js';

 // feature business logic - rundown
 export { checkIsNow } from './src/date-utils/checkIsNow.js';
@@ -1,7 +1,7 @@
 import { Day, OffsetMode } from 'ontime-types';

 import { MILLIS_PER_HOUR, dayInMs } from './conversionUtils';
-import { getExpectedStart } from './getExpectedStart';
+import { getExpectedEnd, getExpectedStart } from './getExpected';

 describe('getExpectedStart()', () => {
  describe('Absolute offset mode', () => {
@@ -99,6 +99,36 @@ describe('getExpectedStart()', () => {
      expect(getExpectedStart(testEvent, { ...testState, isLinkedToLoaded: false })).toBe(110); // <-- when gap is not enough to compensate for the running behind it absorbs at much as possible
      // expect(getExpectedStart(testEvent, { ...testState, isLinkedToLoaded: true })).toBe(70); This should not be possible
    });
+
+    test('negative delay cannot move a day 0 event before the rundown start', () => {
+      const testState = {
+        currentDay: 0,
+        totalGap: 0,
+        offset: 0,
+        mode: OffsetMode.Absolute,
+        actualStart: null,
+        plannedStart: null,
+        isLinkedToLoaded: true,
+      };
+
+      expect(getExpectedStart({ timeStart: 0, delay: -5, dayOffset: 0 as Day }, testState)).toBe(0);
+      expect(getExpectedStart({ timeStart: 10, delay: -5, dayOffset: 0 as Day }, testState)).toBe(5);
+    });
+
+    test('negative delay can move a later-day event back to the previous day', () => {
+      const testState = {
+        currentDay: 0,
+        totalGap: 0,
+        offset: 0,
+        mode: OffsetMode.Absolute,
+        actualStart: null,
+        plannedStart: null,
+        isLinkedToLoaded: true,
+      };
+
+      expect(getExpectedStart({ timeStart: 0, delay: -5, dayOffset: 1 as Day }, testState)).toBe(dayInMs - 5);
+      expect(getExpectedStart({ timeStart: 10, delay: -20, dayOffset: 1 as Day }, testState)).toBe(dayInMs - 10);
+    });
  });

  describe('Relative offset mode', () => {
@@ -315,3 +345,137 @@ describe('getExpectedStart()', () => {
    expect(getExpectedStart(testEvent, { ...testState, currentDay: 0 })).toBe(23 * MILLIS_PER_HOUR + 5);
  });
 });
+
+describe('getExpectedEnd()', () => {
+  const baseState = {
+    currentDay: 0,
+    totalGap: 0,
+    mode: OffsetMode.Absolute,
+    actualStart: null,
+    plannedStart: null,
+    isLinkedToLoaded: true,
+  };
+
+  test('a regular event ends at its expected start plus duration', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 0,
+      dayOffset: 0 as Day,
+      countToEnd: false,
+    };
+
+    // on schedule
+    expect(getExpectedEnd(testEvent, { ...baseState, offset: 0 })).toBe(150);
+    // running 20 behind pushes the end out
+    expect(getExpectedEnd(testEvent, { ...baseState, offset: 20 })).toBe(170);
+  });
+
+  test('a countToEnd event pins to the planned end while in overtime', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 0,
+      dayOffset: 0 as Day,
+      countToEnd: true,
+    };
+
+    // overtime would otherwise push the end to 170, but countToEnd absorbs it and pins to 150
+    expect(getExpectedEnd(testEvent, { ...baseState, offset: 20 })).toBe(150);
+  });
+
+  test('an overnight countToEnd event returns a normalised end', () => {
+    // event starts at 23:00 and counts to 01:00 the next day -> duration spans midnight
+    const timeStart = 23 * MILLIS_PER_HOUR;
+    const duration = 2 * MILLIS_PER_HOUR;
+    const testEvent = {
+      timeStart,
+      duration,
+      delay: 0,
+      dayOffset: 0 as Day,
+      countToEnd: true,
+    };
+
+    expect(getExpectedEnd(testEvent, { ...baseState, offset: 0 })).toBe(timeStart + duration);
+  });
+
+  test('a countToEnd event ignores upstream delays and stays pinned to its fixed end', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 20,
+      dayOffset: 0 as Day,
+    };
+
+    // events shift their schedule based on delay...
+    expect(getExpectedEnd({ ...testEvent, countToEnd: false }, { ...baseState, offset: 0 })).toBe(170);
+    // ... but count to end events stay pinned to the scheduled end
+    expect(getExpectedEnd({ ...testEvent, countToEnd: true }, { ...baseState, offset: 0 })).toBe(150);
+  });
+
+  test('a countToEnd event drifts when a delay pushes its start past the fixed end', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 60,
+      dayOffset: 0 as Day,
+      countToEnd: true,
+    };
+
+    // the delayed start (160) is past the fixed end (150), so the event can no longer
+    // finish on time and the end follows the compromised start
+    expect(getExpectedEnd(testEvent, { ...baseState, offset: 0 })).toBe(160);
+  });
+
+  test('a countToEnd event on a later day keeps the day offset on the end', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 0,
+      dayOffset: 1 as Day,
+      countToEnd: true,
+    };
+
+    // the scheduled end must include the day offset (timeStart + dayInMs + duration),
+    // not collapse to the day-shifted start
+    expect(getExpectedEnd(testEvent, { ...baseState, currentDay: 0, offset: 0 })).toBe(150 + dayInMs);
+    // when the running event is already on the same day, no extra day is added
+    expect(getExpectedEnd({ ...testEvent, dayOffset: 0 as Day }, { ...baseState, currentDay: 0, offset: 0 })).toBe(150);
+  });
+
+  test('a countToEnd event with negative delay can start on the previous day but keeps its fixed end', () => {
+    const testEvent = {
+      timeStart: 0,
+      duration: 50,
+      delay: -10,
+      dayOffset: 1 as Day,
+      countToEnd: true,
+    };
+
+    expect(getExpectedStart(testEvent, { ...baseState, currentDay: 0, offset: 0 })).toBe(dayInMs - 10);
+    expect(getExpectedEnd(testEvent, { ...baseState, currentDay: 0, offset: 0 })).toBe(dayInMs + 50);
+  });
+
+  test('a countToEnd event is anchored to its wall-clock end in relative mode', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 0,
+      dayOffset: 0 as Day,
+      countToEnd: true,
+    };
+
+    const relativeState = {
+      ...baseState,
+      mode: OffsetMode.Relative,
+      actualStart: 30,
+      plannedStart: 0,
+      offset: 0,
+    };
+
+    // a regular event in the same state is shifted by the relative-start offset to 180
+    expect(getExpectedEnd({ ...testEvent, countToEnd: false }, relativeState)).toBe(180);
+    // the countToEnd event stays pinned to its wall-clock end (150), not shifted
+    expect(getExpectedEnd(testEvent, relativeState)).toBe(150);
+  });
+});
@@ -0,0 +1,75 @@
+import type { MaybeNumber, OntimeEvent } from 'ontime-types';
+import { OffsetMode } from 'ontime-types';
+
+import { dayInMs } from './conversionUtils.js';
+
+/**
+ * Runtime context shared by the expected start/end calculations
+ */
+type ExpectedTimesState = {
+  currentDay: number; // the current day from the rundown
+  totalGap: number; // accumulated gap from the current event
+  isLinkedToLoaded: boolean; // is this event part of a chain linking back to the loaded event
+  offset: number;
+  mode: OffsetMode;
+  actualStart: MaybeNumber;
+  plannedStart: MaybeNumber;
+};
+
+export function getExpectedStart(
+  event: Pick<OntimeEvent, 'timeStart' | 'dayOffset' | 'delay'>,
+  state: ExpectedTimesState,
+): number {
+  const { timeStart, dayOffset, delay } = event;
+  const { currentDay, totalGap, isLinkedToLoaded, offset, mode, actualStart, plannedStart } = state;
+
+  const absoluteDelayedStart = Math.max(0, dayOffset * dayInMs + timeStart + delay);
+  const normalisedTimeStart = absoluteDelayedStart - currentDay * dayInMs;
+
+  let relativeStartOffset = 0;
+
+  if (mode === OffsetMode.Relative) {
+    relativeStartOffset = (actualStart ?? 0) + currentDay * dayInMs - (plannedStart ?? 0);
+  }
+
+  const scheduledStartTime = normalisedTimeStart + relativeStartOffset;
+
+  const offsetStartTime = scheduledStartTime + offset;
+
+  if (isLinkedToLoaded) {
+    //if we are directly linked back to the loaded event we just follow the offset
+    return offsetStartTime;
+  }
+
+  const gapsCanCompensateForOffset = totalGap > offset;
+  if (gapsCanCompensateForOffset) {
+    // if we are ahead of schedule or the gap can compensate for the amount we are behind then expect to start at the scheduled time
+    return scheduledStartTime;
+  }
+
+  // otherwise consume as much of the offset as possible with the gap
+  const offsetStartTimeBufferedByGaps = offsetStartTime - totalGap;
+  return offsetStartTimeBufferedByGaps;
+}
+
+export function getExpectedEnd(
+  event: Pick<OntimeEvent, 'timeStart' | 'dayOffset' | 'delay' | 'duration' | 'countToEnd'>,
+  state: ExpectedTimesState,
+): number {
+  // expected start includes the delay and any offset compensation
+  const expectedStart = getExpectedStart(event, state);
+
+  /**
+   * Count to end events are a special case
+   * - the end time is always the wall clock
+   */
+  if (event.countToEnd) {
+    const plannedEnd = event.dayOffset * dayInMs + event.timeStart + event.duration - state.currentDay * dayInMs;
+
+    // count to end should finish on the planned time or on start
+    return Math.max(expectedStart, plannedEnd);
+  }
+
+  // for normal events, the expected end is when we would start + its duration
+  return expectedStart + event.duration;
+}
@@ -1,62 +0,0 @@
-import type { MaybeNumber, OntimeEvent } from 'ontime-types';
-import { OffsetMode } from 'ontime-types';
-
-import { dayInMs } from './conversionUtils.js';
-
-/**
- * @param event the event that we are counting to
- * @param currentDay the day offset of the currently running event
- * @param totalGap accumulated gap from the current event
- * @param isLinkedToLoaded is this event part of a chain linking back to the current loaded event
- * @param clock
- * @param offset
- * @returns
- */
-export function getExpectedStart(
-  event: Pick<OntimeEvent, 'timeStart' | 'dayOffset' | 'delay'>,
-  state: {
-    currentDay: number; // the current day from the rundown
-    totalGap: number;
-    isLinkedToLoaded: boolean;
-    offset: number;
-    mode: OffsetMode;
-    actualStart: MaybeNumber;
-    plannedStart: MaybeNumber;
-  },
-): number {
-  const { timeStart, dayOffset, delay } = event;
-  const { currentDay, totalGap, isLinkedToLoaded, offset, mode, actualStart, plannedStart } = state;
-
-  //How many days from the currently running event to this one
-  const relativeDayOffset = dayOffset - currentDay;
-
-  const delayedStart = Math.max(0, timeStart + delay);
-
-  //The normalised start time of this event relative to the currently running event
-  const normalisedTimeStart = delayedStart + relativeDayOffset * dayInMs;
-
-  let relativeStartOffset = 0;
-
-  if (mode === OffsetMode.Relative) {
-    relativeStartOffset = (actualStart ?? 0) + currentDay * dayInMs - (plannedStart ?? 0);
-  }
-
-  const scheduledStartTime = normalisedTimeStart + relativeStartOffset;
-
-  const offsetStartTime = scheduledStartTime + offset;
-
-  if (isLinkedToLoaded) {
-    //if we are directly linked back to the loaded event we just follow the offset
-    return offsetStartTime;
-  }
-
-  const gapsCanCompensateForOffset = totalGap > offset;
-  if (gapsCanCompensateForOffset) {
-    // if we are ahead of schedule or the gap can compensate for the amount we are behind then expect to start at the scheduled time
-    return scheduledStartTime;
-  }
-
-  // otherwise consume as much of the offset as possible with the gap
-  const offsetStartTimeBufferedByGaps = offsetStartTime - totalGap;
-  return offsetStartTimeBufferedByGaps;
-}
@@ -6,7 +6,7 @@ catalog:
  '@types/node': 22.19.11
  rimraf: 6.0.1
  ts-essentials: 10.1.1
-  typescript: 6.0.2
+  typescript: 7.0.2
  vitest: 4.0.17

 allowBuilds:
Author	SHA1	Message	Date
Carlos Valente	8aa22ebc09	refactor: finish of count-to-end is plan or start time	2026-07-17 22:24:59 +02:00
Carlos Valente	41d3031a39	refactor(rundown): improve visibility of count to end	2026-07-17 11:04:36 +02:00
Carlos Valente	73a61887a6	refactor(time control): improve handling of overtime and count to end	2026-07-17 11:01:40 +02:00
Carlos Valente	e1f6b22d19	fix: delays account for midnight	2026-07-14 14:31:08 +02:00
Carlos Valente	0ff226f0ec	fix: count-to-end events break link chain	2026-07-14 14:31:08 +02:00
Carlos Valente	daa032e92c	ux(finder): add navigation shortcuts	2026-07-14 12:04:44 +02:00
Carlos Valente	ae65ec97d6	fix(shortcut): correct shortcut to delete	2026-07-14 12:04:44 +02:00
Carlos Valente	e7e4302100	refactor(shortcuts): improve readability of info element	2026-07-14 12:04:44 +02:00
Carlos Valente	7e7d35980a	refactor(op): improve status recognition	2026-07-14 11:58:59 +02:00
Carlos Valente	5001dda284	feat(op): add group visual relation	2026-07-14 11:58:59 +02:00
Carlos Valente	a75d35bdc0	refactor(op): improve delay indicator styles	2026-07-14 11:58:59 +02:00
Claude	2e631194e1	fix(ui): improve progress bar with local interpolation Co-authored-by: Carlos Valente <34649812+cpvalente@users.noreply.github.com>	2026-07-14 11:25:22 +02:00
Carlos Valente	f39892dc6e	feat(navigation): persist view params customisation	2026-07-13 18:44:38 +02:00
Carlos Valente	6bcfd87851	refactor(rundown): show locked duration group indicator	2026-07-13 17:34:11 +02:00
Claude	4addb50ca4	feat(countdown): allow counting down to a group	2026-07-13 17:29:56 +02:00
Carlos Valente	161ab3fe13	refactor(timer): elapsed is active time from start	2026-07-13 15:34:31 +02:00
Carlos Valente	4f4626a163	refactor: allow larger settings panels	2026-07-13 15:33:23 +02:00
Claude	82d5f02ea0	refactor(mcp): guide agents through creating clean rundowns	2026-07-13 15:33:23 +02:00
Claude	05aaeddf22	resolver: drop dead ignoreDeprecations from tsconfig.dts.json Confirmed empirically that it now suppresses nothing under TS 7.0.2: compiling tsconfig.dts.json directly with this flag set to "6.0", "7.0", or removed entirely all produce identical (clean) output. It was a leftover suppression the previous tsdown mode never actually needed once nothing in the config triggers a deprecation warning.	2026-07-13 14:27:31 +02:00
Claude	949ab2b7dc	Upgrade TypeScript to 7.0.2 (native Go compiler) TypeScript 7 ships as a native Go binary and drastically trims the package's public JS API surface (no more `main`, and `exports['.']` now only resolves to lib/version.cjs) since the programmatic compiler API isn't stable again until 7.1. This broke apps/resolver's tsdown build, which used rolldown-plugin-dts' tsc-program mode (import ts from 'typescript'; ts.createProgram(...)) for declaration generation. Fix by switching that build to isolatedDeclarations, which lets rolldown-plugin-dts generate .d.ts via its oxc-based path instead of the TS compiler API entirely. That surfaced two isolatedDeclarations violations in ontime-types (array/Object.keys initializers lacking explicit annotations), fixed with explicit `string[]` types matching their existing inferred type. Also bumped tsdown to pick up its latest rolldown-plugin-dts, and disabled allowJs in tsconfig.dts.json since it's incompatible with isolatedDeclarations. Full workspace typecheck, lint, build, and test suite (1186 tests) pass under TypeScript 7.0.2.	2026-07-13 14:27:31 +02:00
Alex Christoffer Rasmussen	f12d3ca59c	Small cleanup (#2114 ) * refactor: propper memo for `ScheduleContext` value * chore: removed unused file `cuesheet.utils.ts` * fix: memoize event in ScheduleProvider	2026-07-11 22:20:32 +02:00