bump version to alpha release

feat: progress view
2026-08-04 06:58:02 +00:00 · 2024-06-22 20:17:37 +02:00 · 2024-06-22 20:16:09 +02:00
273 changed files with 11483 additions and 15537 deletions
@@ -14,12 +14,12 @@ jobs:
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18.18.2

      - name: Setup pnpm
        uses: pnpm/action-setup@v3
        with:
-          version: 9
+          version: 8

      - name: Install dependencies
        run: pnpm install --frozen-lockfile
@@ -56,12 +56,12 @@ jobs:
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18.18.2

      - name: Setup pnpm
        uses: pnpm/action-setup@v3
        with:
-          version: 9
+          version: 8

      - name: Install dependencies
        run: pnpm install --frozen-lockfile
@@ -89,12 +89,12 @@ jobs:
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18.18.2

      - name: Setup pnpm
        uses: pnpm/action-setup@v3
        with:
-          version: 9
+          version: 8

      - name: Install dependencies
        run: pnpm install --frozen-lockfile
@@ -1,8 +1,8 @@
 name: Ontime CLI build

 on:
-  release:
-    types: [published]
+  push:
+    tags: [ "*" ]
  workflow_dispatch:

 jobs:
@@ -20,13 +20,13 @@ jobs:
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18.18.2
          registry-url: 'https://registry.npmjs.org'

      - name: Setup pnpm
        uses: pnpm/action-setup@v3
        with:
-          version: 9
+          version: 8

      - name: Install dependencies
        run: pnpm install --frozen-lockfile
@@ -1,8 +1,8 @@
 name: Docker Image CI Ontime

 on:
-  release:
-    types: [published]
+  push:
+    tags: [ "*" ]
  workflow_dispatch:

 jobs:
@@ -14,6 +14,8 @@ jobs:

    steps:
    - uses: actions/checkout@v4
+    - name: Setup env
+      run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV

    - name: Docker Login
      uses: docker/login-action@v2.1.0
@@ -30,10 +32,10 @@ jobs:
      with:
        context: .
        file: ./Dockerfile
-        platforms: linux/amd64,linux/arm64,linux/arm/v7
+        platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/arm/v6
        # Push is a shorthand for --output=type=registry
        push: true
-        tags: ${{ secrets.DOCKERHUB_USERNAME }}/ontime:${{ github.event.release.tag_name }} , ${{ secrets.DOCKERHUB_USERNAME }}/ontime:latest
+        tags: ${{ secrets.DOCKERHUB_USERNAME }}/ontime:${{ env.RELEASE_VERSION  }} , ${{ secrets.DOCKERHUB_USERNAME }}/ontime:latest

    - name: Build and push pre-release
      if: github.event.release.prerelease == true
@@ -41,8 +43,8 @@ jobs:
      with:
        context: .
        file: ./Dockerfile
-        platforms: linux/amd64,linux/arm64,linux/arm/v7
+        platforms: linux/amd64,linux/arm64,linux/arm/v7,linux/arm/v6
        # Push is a shorthand for --output=type=registry
        push: true
-        tags: ${{ secrets.DOCKERHUB_USERNAME }}/ontime:${{ github.event.release.tag_name }} , ${{ secrets.DOCKERHUB_USERNAME }}/ontime:nightly
+        tags: ${{ secrets.DOCKERHUB_USERNAME }}/ontime:${{ env.RELEASE_VERSION  }} , ${{ secrets.DOCKERHUB_USERNAME }}/ontime:nightly

@@ -17,12 +17,12 @@ jobs:
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18.18.2

      - name: Setup pnpm
        uses: pnpm/action-setup@v3
        with:
-          version: 9
+          version: 8

      - name: Install dependencies
        run: pnpm install --frozen-lockfile
@@ -73,12 +73,12 @@ jobs:
      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18.18.2

      - name: Setup pnpm
        uses: pnpm/action-setup@v3
        with:
-          version: 9
+          version: 8

      - name: Install dependencies
        run: pnpm install --frozen-lockfile
@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+pnpm lint-staged
@@ -1 +1 @@
-v20.15.1
+v18.18.2
@@ -9,8 +9,8 @@ Ontime consists of 3 distinct parts
 The steps below will assume you have locally installed the necessary dependencies.
 Other dependencies will be installed as part of the setup

- __node__ (~20)
- __pnpm__ (~9)
+- __node__ (~18.18.2)
+- __pnpm__ (>=8)
 - __docker__ (only necessary to run and build docker images)

 ## LOCAL DEVELOPMENT
@@ -1,19 +1,19 @@
-FROM node:20-bullseye AS builder
+FROM node:18.18-alpine AS builder
 ENV PNPM_HOME="/pnpm"
 ENV PATH="$PNPM_HOME:$PATH"
-RUN npm install -g pnpm@9.5.0
+RUN corepack enable
 COPY . /app
 WORKDIR /app
 RUN pnpm --filter=ontime-ui --filter=ontime-server --filter=ontime-utils install --config.dedupe-peer-dependents=false --frozen-lockfile
 RUN pnpm --filter=ontime-ui --filter=ontime-server run build:docker

-FROM node:20-alpine
+FROM node:18.18-alpine

 # Set environment variables
 # Environment Variable to signal that we are running production
 ENV NODE_ENV=docker
 # Ontime Data path
-ENV ONTIME_DATA=/data/
+ENV ONTIME_DATA=/external/

 WORKDIR /app/

@@ -22,6 +22,7 @@ COPY --from=builder /app/apps/client/build ./client/

 # Prepare Backend
 COPY --from=builder /app/apps/server/dist/ ./server/
+COPY ./demo-db/ ./preloaded-db/
 COPY --from=builder /app/apps/server/src/external/ ./external/

 # Export default ports
@@ -1,7 +1,6 @@
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-green.svg)](https://www.gnu.org/licenses/gpl-3.0)
 ![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/cpvalente/ontime/total)
 ![Docker Pulls](https://img.shields.io/docker/pulls/getontime/ontime)
-![NPM Downloads](https://img.shields.io/npm/dy/%40getontime%2Fcli)
 [![](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86)](https://github.com/sponsors/cpvalente)
 [![](https://img.shields.io/static/v1?label=Buy%20me%20a%20coffee&message=%E2%9D%A4&logo=buymeacoffee&color=%23fe8e86)](https://www.buymeacoffee.com/cpvalente)

@@ -14,10 +13,8 @@
 - Download AppImage for <a href="https://github.com/cpvalente/ontime/releases/latest/download/ontime-linux.AppImage">Linux</a>
 - Get from <a href="https://hub.docker.com/r/getontime/ontime">Docker hub</a>

-## Need help?
-We do our best to have most topics covered by the documentation. However, if your question is not covered, you are welcome to [fill in a bug report in an issue](https://github.com/cpvalente/ontime/issues), [ask a question in GitHub discussions](https://github.com/cpvalente/ontime/discussions) or hop in the [discord server](https://discord.com/invite/eje3CSUEXm) for a chat.
-
 ## Using Ontime?
+
 Let us know!
 Ontime improves from the collaboration with its users. We would like to understand how you use Ontime and appreciate your feedback.

@@ -37,16 +34,6 @@ Ontime is made by entertainment and broadcast engineers and used by
 - Theatres and opera houses
 - Houses of worship

-## Main features
- [x] **Multiplatform**: Available for Windows / MacOS, Linux. You can also self host with the docker image
- [x] **In any device**: Ontime is available in the local network to any device with a browser, eg: tablets, mobile phones, laptops, signage, media servers...
- [x] **Made for teams**: Ontime caters to different roles in your production team: directors, operators, backstage and front of house signage...
- [x] **Delay workflows**: Manage and communicate runtime delays in real-time to your team
- [x] **Automatable**: Ontime can be fully or partially controlled by an operator, or run standalone with the system clock
- [x] **Focus on integrations**: Use one of the APIs provided (OSC, HTTP, Websocket) or the available [Companion module](https://bitfocus.io/connections/getontime-ontime) to integrate into your workflow (vMix, disguise, Qlab, OBS)
-
-... and a lot more ...
-
 ### For live environments

 Ontime is designed for use in live environments. \
@@ -95,7 +82,6 @@ IP.ADDRESS:4001/clock      > Simple clock view
 IP.ADDRESS:4001/backstage  > Stage Manager / Backstage view
 IP.ADDRESS:4001/countdown  > Countdown to anything
 IP.ADDRESS:4001/studio     > Studio Clock
-IP.ADDRESS:4001/timeline   > Timeline
 ```

 ```
@@ -113,13 +99,26 @@ IP.ADDRESS:4001/cuesheet  > realtime cuesheets for collaboration
 IP.ADDRESS:4001/operator  > automated views for operators
 ```

-More information is available [in our docs](https://docs.getontime.no)
+More documentation is available [in our docs](https://docs.getontime.no)
+
+## Main features
+
+- [x] Distribute data over network and render it in the browser
+- [x] Collaborative
+- [x] Extendable
+- [x] Send messages to different screen types
+- [x] Differentiate between backstage and public data
+- [x] Workflow for managing delays
+- [x] Rich protocol integrations for Control and Feedback
+- [x] For servers: use docker to run Ontime in in a server, configure from a browser anywhere
+- [x] Multi-platform (available on Windows, MacOS and Linux)
+- [x] Companion integration [follow link](https://bitfocus.io/connections/getontime-ontime)

 ## Roadmap

 ### Continued development

-Ontime is under active development. We continue adding and improving features in collaboration with users.
+Ontime is under active development. We continue adding and tweaking features in collaboration with users.

 Have an idea? Reach out via [email](mail@getontime.no)
 or [open an issue](https://github.com/cpvalente/ontime/issues/new)
@@ -161,9 +160,8 @@ If you are a developer and would like to contribute with code, please open an is
 Information about the project setup can be found in the [development documentation](./DEVELOPMENT.md)

 ## Links
- [Ontime website](https://getontime.no) 
- [Documentation](https://docs.getontime.no)
- [Ontime discord server](https://discord.com/invite/eje3CSUEXm)
+
+See the [Ontime website](https://getontime.no) here and the link to the [documentation](https://docs.getontime.no)

 ## License

@@ -1,6 +1,6 @@
 {
    "name": "@getontime/cli",
-    "version": "3.6.1",
+    "version": "3.4.0-alpha-timeline",
    "author": "Carlos Valente",
    "description": "Time keeping for live events",
    "repository": "https://github.com/cpvalente/ontime",
@@ -20,8 +20,8 @@
        "server"
    ],
    "devDependencies": {
-        "eslint": "catalog:",
-        "eslint-config-prettier": "catalog:",
-        "prettier": "catalog:"
+        "eslint": "^8.53.0",
+        "eslint-config-prettier": "^9.0.0",
+        "prettier": "^3.0.3"
    }
 }
@@ -1,6 +1,6 @@
 {
  "name": "ontime-ui",
-  "version": "3.6.1",
+  "version": "3.4.0-alpha-timeline",
  "private": true,
  "type": "module",
  "dependencies": {
@@ -13,7 +13,7 @@
    "@fontsource/open-sans": "^5.0.28",
    "@mantine/hooks": "^7.6.2",
    "@react-icons/all-files": "^4.1.0",
-    "@sentry/react": "^8.19.0",
+    "@sentry/react": "^7.92.0",
    "@tanstack/react-query": "^5.17.9",
    "@tanstack/react-query-devtools": "^5.17.9",
    "@tanstack/react-table": "^8.11.3",
@@ -22,9 +22,9 @@
    "color": "^4.2.3",
    "csv-stringify": "^6.4.5",
    "framer-motion": "^10.10.0",
-    "react": "^18.3.1",
+    "react": "^18.2.0",
    "react-colorful": "^5.6.1",
-    "react-dom": "^18.3.1",
+    "react-dom": "^18.2.0",
    "react-fast-compare": "^3.2.2",
    "react-hook-form": "^7.49.2",
    "react-qr-code": "^2.0.12",
@@ -42,6 +42,7 @@
    "build:docker": "vite build",
    "build:localdocker": "cross-env NODE_ENV=local vite build",
    "lint": "eslint . --quiet",
+    "lint-staged": "eslint",
    "test": "vitest",
    "test:pipeline": "vitest run",
    "cleanup": "rm -rf .turbo && rm -rf node_modules && rm -rf build",
@@ -69,13 +70,13 @@
    "@types/react": "^18.0.26",
    "@types/react-dom": "^18.0.10",
    "@types/testing-library__jest-dom": "^5.14.5",
-    "@typescript-eslint/eslint-plugin": "catalog:",
-    "@typescript-eslint/parser": "catalog:",
+    "@typescript-eslint/eslint-plugin": "^v7.12.0",
+    "@typescript-eslint/parser": "^7.12.0",
    "@vitejs/plugin-react": "^4.2.1",
-    "eslint": "catalog:",
-    "eslint-config-prettier": "catalog:",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
    "eslint-plugin-jest": "^28.6.0",
-    "eslint-plugin-prettier": "catalog:",
+    "eslint-plugin-prettier": "^5.1.3",
    "eslint-plugin-react": "^7.32.0",
    "eslint-plugin-react-hooks": "^4.6.0",
    "eslint-plugin-simple-import-sort": "^8.0.0",
@@ -83,9 +84,9 @@
    "jsdom": "^21.1.0",
    "ontime-types": "workspace:*",
    "ontime-utils": "workspace:*",
-    "prettier": "catalog:",
+    "prettier": "^3.3.1",
    "sass": "^1.57.1",
-    "typescript": "catalog:",
+    "typescript": "^5.4.3",
    "vite": "^5.2.11",
    "vite-plugin-compression2": "^0.12.0",
    "vite-plugin-svgr": "^4.2.0",
@@ -1,36 +1,25 @@
-import React from 'react';
-import {
-  createRoutesFromChildren,
-  matchRoutes,
-  Navigate,
-  Route,
-  Routes,
-  useLocation,
-  useNavigationType,
-} from 'react-router-dom';
-import * as Sentry from '@sentry/react';
+import { lazy, Suspense } from 'react';
+import { Navigate, Route, Routes } from 'react-router-dom';

 import { useClientPath } from './common/hooks/useClientPath';
 import Log from './features/log/Log';
 import withPreset from './features/PresetWrapper';
 import withData from './features/viewers/ViewWrapper';
-import { ONTIME_VERSION } from './ONTIME_VERSION';
-import { sentryDsn, sentryRecommendedIgnore } from './sentry.config';

-const Editor = React.lazy(() => import('./features/editors/ProtectedEditor'));
-const Cuesheet = React.lazy(() => import('./features/cuesheet/ProtectedCuesheet'));
-const Operator = React.lazy(() => import('./features/operator/OperatorExport'));
+const Editor = lazy(() => import('./features/editors/ProtectedEditor'));
+const Cuesheet = lazy(() => import('./features/cuesheet/ProtectedCuesheet'));
+const Operator = lazy(() => import('./features/operator/OperatorExport'));

-const TimerView = React.lazy(() => import('./features/viewers/timer/Timer'));
-const MinimalTimerView = React.lazy(() => import('./features/viewers/minimal-timer/MinimalTimer'));
-const ClockView = React.lazy(() => import('./features/viewers/clock/Clock'));
-const Countdown = React.lazy(() => import('./features/viewers/countdown/Countdown'));
+const TimerView = lazy(() => import('./features/viewers/timer/Timer'));
+const MinimalTimerView = lazy(() => import('./features/viewers/minimal-timer/MinimalTimer'));
+const ClockView = lazy(() => import('./features/viewers/clock/Clock'));
+const Countdown = lazy(() => import('./features/viewers/countdown/Countdown'));

-const Backstage = React.lazy(() => import('./features/viewers/backstage/Backstage'));
-const Timeline = React.lazy(() => import('./features/viewers/timeline/TimelinePage'));
-const Public = React.lazy(() => import('./features/viewers/public/Public'));
-const Lower = React.lazy(() => import('./features/viewers/lower-thirds/LowerThird'));
-const StudioClock = React.lazy(() => import('./features/viewers/studio/StudioClock'));
+const Backstage = lazy(() => import('./features/viewers/backstage/Backstage'));
+const Public = lazy(() => import('./features/viewers/public/Public'));
+const Timeline = lazy(() => import('./features/timeline/TimelinePage'));
+const Lower = lazy(() => import('./features/viewers/lower-thirds/LowerThird'));
+const StudioClock = lazy(() => import('./features/viewers/studio/StudioClock'));

 const STimer = withPreset(withData(TimerView));
 const SMinimalTimer = withPreset(withData(MinimalTimerView));
@@ -38,58 +27,46 @@ const SClock = withPreset(withData(ClockView));
 const SCountdown = withPreset(withData(Countdown));
 const SBackstage = withPreset(withData(Backstage));
 const SPublic = withPreset(withData(Public));
+const STimeline = withPreset(withData(Timeline));
 const SLowerThird = withPreset(withData(Lower));
 const SStudio = withPreset(withData(StudioClock));
-const STimeline = withPreset(withData(Timeline));

-const EditorFeatureWrapper = React.lazy(() => import('./features/EditorFeatureWrapper'));
-const RundownPanel = React.lazy(() => import('./features/rundown/RundownExport'));
-const TimerControl = React.lazy(() => import('./features/control/playback/TimerControlExport'));
-const MessageControl = React.lazy(() => import('./features/control/message/MessageControlExport'));
-
-Sentry.init({
-  dsn: sentryDsn,
-  integrations: [
-    Sentry.reactRouterV6BrowserTracingIntegration({
-      useEffect: React.useEffect,
-      useLocation,
-      useNavigationType,
-      createRoutesFromChildren,
-      matchRoutes,
-    }),
-  ],
-  tracesSampleRate: 0.3,
-  release: ONTIME_VERSION,
-  enabled: import.meta.env.PROD,
-  ignoreErrors: [...sentryRecommendedIgnore, /Unable to preload CSS/i, /dynamically imported module/i],
-  denyUrls: [/extensions\//i, /^chrome:\/\//i, /^chrome-extension:\/\//i],
-});
-
-const SentryRoutes = Sentry.withSentryReactRouterV6Routing(Routes);
+const EditorFeatureWrapper = lazy(() => import('./features/EditorFeatureWrapper'));
+const RundownPanel = lazy(() => import('./features/rundown/RundownExport'));
+const TimerControl = lazy(() => import('./features/control/playback/TimerControlExport'));
+const MessageControl = lazy(() => import('./features/control/message/MessageControlExport'));

 export default function AppRouter() {
  // handle client path changes
  useClientPath();

  return (
-    <React.Suspense fallback={null}>
-      <SentryRoutes>
+    <Suspense fallback={null}>
+      <Routes>
        <Route path='/' element={<Navigate to='/timer' />} />
        <Route path='/timer' element={<STimer />} />
-        <Route path='/public' element={<SPublic />} />
+
        <Route path='/minimal' element={<SMinimalTimer />} />
+
        <Route path='/clock' element={<SClock />} />

        <Route path='/countdown' element={<SCountdown />} />
+
        <Route path='/backstage' element={<SBackstage />} />
+
+        <Route path='/public' element={<SPublic />} />
+
        <Route path='/studio' element={<SStudio />} />
+
        <Route path='/lower' element={<SLowerThird />} />
+
+        <Route path='/op' element={<Operator />} />
+
        <Route path='/timeline' element={<STimeline />} />

        {/*/!* Protected Routes *!/*/}
        <Route path='/editor' element={<Editor />} />
        <Route path='/cuesheet' element={<Cuesheet />} />
-        <Route path='/op' element={<Operator />} />

        {/*/!* Protected Routes - Elements *!/*/}
        <Route
@@ -126,7 +103,7 @@ export default function AppRouter() {
        />
        {/*/!* Send to default if nothing found *!/*/}
        <Route path='*' element={<STimer />} />
-      </SentryRoutes>
-    </React.Suspense>
+      </Routes>
+    </Suspense>
  );
 }
@@ -18,7 +18,6 @@ const location = window.location;
 const socketProtocol = location.protocol === 'https:' ? 'wss' : 'ws';
 export const isProduction = import.meta.env.MODE === 'production';
 export const isDev = !isProduction;
-export const isLocalhost = location.hostname === 'localhost' || location.hostname === '127.0.0.1';

 // resolve port
 const STATIC_PORT = 4001;
@@ -11,7 +11,7 @@ const dbPath = `${apiEntryUrl}/db`;
 /**
 * HTTP request to the current DB
 */
-export function getDb(filename: string): Promise<AxiosResponse<DatabaseModel>> {
+async function getDb(filename: string): Promise<AxiosResponse<DatabaseModel>> {
  return axios.post(`${dbPath}/download/`, { filename });
 }

@@ -123,7 +123,7 @@ export async function renameProject(filename: string, newFilename: string): Prom
  const url = `${dbPath}/${filename}/rename`;
  const decodedUrl = decodeURIComponent(url);
  const res = await axios.put(decodedUrl, {
-    newFilename,
+    filename: newFilename,
  });
  return res.data;
 }
@@ -38,7 +38,7 @@ export function RedirectClientModal(props: RedirectClientModalProps) {
    onClose();
  };

-  const host = window.location.origin;
+  const host = `${window.location.origin}/`;
  const canSubmit = path !== currentPath && path !== '';

  return (
@@ -28,11 +28,9 @@ class ErrorBoundary extends React.Component {
    });

    Sentry.withScope((scope) => {
-      scope.setExtras({
-        error,
-        store: runtimeStore.getState(),
-        hasSocket: { hasConnected, shouldReconnect, reconnectAttempts },
-      });
+      scope.setExtras('error', error);
+      scope.setExtras('store', runtimeStore.getState());
+      scope.setExtras('hasSocket', { hasConnected, shouldReconnect, reconnectAttempts });
      const eventId = Sentry.captureException(error);
      this.setState({ eventId, info });
    });
@@ -1,63 +0,0 @@
-/**
- * Copied from
- * https://github.com/namhong2001/react-textfit/blob/master/index.tsx
- */
-
-import { HTMLAttributes, PropsWithChildren, useCallback, useEffect, useRef } from 'react';
-
-import { bsearch } from './fitText.utils';
-
-interface FitTextProps extends HTMLAttributes<HTMLDivElement> {
-  mode?: 'single' | 'multi';
-  min?: number; // inclusive
-  max?: number; // inclusive
-}
-
-export function FitText(props: PropsWithChildren<FitTextProps>) {
-  const { children, mode = 'multi', min = 16, max = 256, ...elementProps } = props;
-  const ref = useRef<HTMLDivElement>(null);
-
-  const isOverflown = useCallback(() => {
-    const el = ref.current;
-    if (!el) return false;
-    return el.scrollHeight > el.clientHeight || el.scrollWidth > el.clientWidth;
-  }, []);
-
-  const setFontSize = useCallback(() => {
-    const el = ref.current;
-    if (!el) return;
-
-    const originVisibility = el.style.visibility;
-
-    el.style.visibility = 'hidden';
-    const fontSize = bsearch(min, max + 1, (mid) => {
-      el.style.fontSize = `${mid}px`;
-      return !isOverflown();
-    });
-    el.style.fontSize = `${fontSize}px`;
-    el.style.visibility = originVisibility;
-  }, [isOverflown, min, max]);
-
-  useEffect(() => {
-    const el = ref.current;
-    if (!el) return;
-
-    setFontSize();
-    const observer = new ResizeObserver(setFontSize);
-    observer.observe(el);
-
-    return () => observer.disconnect();
-  }, [children, mode, setFontSize]);
-
-  return (
-    <div
-      ref={ref}
-      style={{
-        whiteSpace: mode === 'single' ? 'nowrap' : 'normal',
-      }}
-      {...elementProps}
-    >
-      {children}
-    </div>
-  );
-}
@@ -1,18 +0,0 @@
-/**
- * @param low inclusive, must be true on predicate function
- * @param high exclusive,
- * @param predicate predicate function
- */
-export const bsearch = (low: number, high: number, predicate: (mid: number) => boolean): number => {
-  while (low < high) {
-    const mid = Math.floor((low + high) / 2);
-    if (mid === low) break;
-
-    if (predicate(mid)) {
-      low = mid;
-    } else {
-      high = mid;
-    }
-  }
-  return low;
-};
@@ -54,6 +54,7 @@ function Overlay() {
    };
  }, [showOverlay, id, setIdentify, handleClose]);

+    console.log('here2');
  return (
    <div className={style.overlay} data-testid='identify-overlay' onClick={handleClose}>
      <div className={style.name}>{name}</div>
@@ -1,12 +1,12 @@
 import { MaybeNumber } from 'ontime-types';

-import { getProgress } from '../../utils/getProgress';
+import { clamp } from '../../utils/math';

 import './MultiPartProgressBar.scss';

 interface MultiPartProgressBar {
  now: MaybeNumber;
-  complete: MaybeNumber;
+  complete: number;
  normalColor: string;
  warning?: MaybeNumber;
  warningColor: string;
@@ -31,9 +31,10 @@ export default function MultiPartProgressBar(props: MultiPartProgressBar) {
    className = '',
  } = props;

-  const percentRemaining = 100 - getProgress(now, complete);
-  const dangerWidth = danger ? 100 - getProgress(danger, complete) : 0;
-  const warningWidth = warning ? 100 - dangerWidth - getProgress(warning, complete) : 0;
+  const percentRemaining = complete === 0 ? 0 : 100 - clamp(100 - (Math.max(now ?? 0, 0) * 100) / complete, 0, 100);
+
+  const dangerWidth = danger ? clamp((danger / complete) * 100, 0, 100) : 0;
+  const warningWidth = warning ? clamp((warning / complete) * 100 - dangerWidth, 0, 100) : 0;

  return (
    <div
@@ -47,8 +47,6 @@ $button-size: 3rem;
  @include action-link;
  padding: 0.75rem 1.5rem;
  gap: 0.5rem;
-  width: 100%;
-  cursor: pointer;

  &:hover {
    background-color: $menu-hover-bg;
@@ -1,6 +1,6 @@
-import { memo, PropsWithChildren, useRef } from 'react';
+import { memo, useRef } from 'react';
 import { createPortal } from 'react-dom';
-import { Link, useLocation } from 'react-router-dom';
+import { Link } from 'react-router-dom';
 import {
  Drawer,
  DrawerBody,
@@ -19,12 +19,9 @@ import { IoSwapVertical } from '@react-icons/all-files/io5/IoSwapVertical';

 import { navigatorConstants } from '../../../viewerConfig';
 import useClickOutside from '../../hooks/useClickOutside';
-import useElectronEvent from '../../hooks/useElectronEvent';
 import { useClientStore } from '../../stores/clientStore';
 import { useViewOptionsStore } from '../../stores/viewOptions';
 import { isKeyEnter } from '../../utils/keyEvent';
-import { handleLinks } from '../../utils/linkUtils';
-import { cx } from '../../utils/styleUtils';
 import { RenameClientModal } from '../client-modal/RenameClientModal';

 import style from './NavigationMenu.module.scss';
@@ -43,7 +40,6 @@ function NavigationMenu(props: NavigationMenuProps) {
  const { isOpen: isOpenRename, onOpen: onRenameOpen, onClose: onCloseRename } = useDisclosure();
  const { fullscreen, toggle } = useFullscreen();
  const { toggleMirror } = useViewOptionsStore();
-  const location = useLocation();

  const menuRef = useRef<HTMLDivElement | null>(null);

@@ -100,29 +96,38 @@ function NavigationMenu(props: NavigationMenuProps) {
            <hr className={style.separator} />
            <Link
              to='/editor'
+              className={`${style.link} ${location.pathname === '/editor' ? style.current : ''}`}
              tabIndex={0}
-              className={`${style.link} ${location.pathname === '/editor' && style.current}`}
            >
              <IoLockClosedOutline />
              Editor
              <IoArrowUp className={style.linkIcon} />
            </Link>
-            <ClientLink to='cuesheet' current={location.pathname === '/cuesheet'}>
+            <Link
+              to='/cuesheet'
+              className={`${style.link} ${location.pathname === '/cuesheet' ? style.current : ''}`}
+              tabIndex={0}
+            >
              <IoLockClosedOutline />
              Cuesheet
              <IoArrowUp className={style.linkIcon} />
-            </ClientLink>
-            <ClientLink to='op' current={location.pathname === '/op'}>
+            </Link>
+            <Link to='/op' className={`${style.link} ${location.pathname === '/op' ? style.current : ''}`} tabIndex={0}>
              <IoLockClosedOutline />
              Operator
              <IoArrowUp className={style.linkIcon} />
-            </ClientLink>
+            </Link>
            <hr className={style.separator} />
            {navigatorConstants.map((route) => (
-              <ClientLink key={route.url} to={route.url} current={location.pathname === `/${route.url}`}>
+              <Link
+                key={route.url}
+                to={route.url}
+                className={`${style.link} ${route.url === location.pathname ? style.current : undefined}`}
+                tabIndex={0}
+              >
                {route.label}
                <IoArrowUp className={style.linkIcon} />
-              </ClientLink>
+              </Link>
            ))}
          </DrawerBody>
        </DrawerContent>
@@ -132,30 +137,4 @@ function NavigationMenu(props: NavigationMenuProps) {
  );
 }

-interface ClientLinkProps {
-  current: boolean;
-  to: string;
-}
-
-function ClientLink(props: PropsWithChildren<ClientLinkProps>) {
-  const { current, to, children } = props;
-  const { isElectron } = useElectronEvent();
-
-  const classes = cx([style.link, current && style.current]);
-
-  if (isElectron) {
-    return (
-      <button className={classes} tabIndex={0} onClick={(event) => handleLinks(event, to)}>
-        {children}
-      </button>
-    );
-  }
-
-  return (
-    <Link to={`/${to}`} className={classes} tabIndex={0}>
-      {children}
-    </Link>
-  );
-}
-
 export default memo(NavigationMenu);
@@ -1,23 +1,22 @@
-import { MaybeNumber } from 'ontime-types';
-
-import { getProgress } from '../../utils/getProgress';
+import { clamp } from '../../utils/math';

 import './ProgressBar.scss';

 interface ProgressBarProps {
-  current: MaybeNumber;
-  duration: MaybeNumber;
+  now?: number;
+  complete?: number;
  hidden?: boolean;
  className?: string;
 }

 export default function ProgressBar(props: ProgressBarProps) {
-  const { current, duration, hidden, className = '' } = props;
-  const progress = getProgress(current, duration);
+  const { now = 0, complete = 100, hidden, className = '' } = props;
+
+  const percentComplete = clamp(100 - (Math.max(now, 0) * 100) / complete, 0, 100);

  return (
    <div className={`progress-bar__bg ${hidden ? 'progress-bar__bg--hidden' : ''} ${className}`}>
-      <div className='progress-bar__indicator' style={{ width: `${progress}%` }} />
+      <div className='progress-bar__indicator' style={{ width: `${percentComplete}%` }} />
    </div>
  );
 }
@@ -1,37 +1,25 @@
@use '../../../theme/viewerDefs' as *;

 .title-card {
-  position: relative;
  display: flex;
  flex-direction: column;
-  gap: 0.25rem;
+  gap: 0.5rem;
 }

-.title-card__title,
-.title-card__secondary {
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
+.inline {
+  display: flex;
 }

 .title-card__title {
  font-weight: 600;
-  font-size: clamp(1.5rem, 3vw, 3rem);
+  font-size: clamp(32px, 3.5vw, 50px);
  color: var(--color-override, $viewer-color);
-  line-height: 1.2em;
-}
-
-.title-card__secondary {
-  font-size: clamp(1rem, 2vw, 2.25rem);
-  color: var(--secondary-color-override, $viewer-secondary-color);
-  line-height: 1.2em;
+  line-height: 1.1em;
 }

 .title-card__label {
-  position: absolute;
-  right: 1rem;
-  top: 0.5rem;
  font-size: clamp(1rem, 1.5vw, 1.5rem);
+  font-weight: 400;
  color: var(--secondary-color-override, $viewer-secondary-color);
  margin-left: auto;
  text-transform: uppercase;
@@ -40,3 +28,13 @@
    color: var(--accent-color-override, $accent-color);
  }
 }
+
+.title-card__secondary {
+  font-size: clamp(1.5rem, 2vw, 2.25rem);
+  color: var(--secondary-color-override, $viewer-secondary-color);
+  line-height: 1.1em;
+
+  &::after {
+    content: '\200b';
+  }
+}
@@ -1,32 +1,28 @@
-import { ForwardedRef, forwardRef } from 'react';
-
 import { useTranslation } from '../../../translation/TranslationProvider';

 import './TitleCard.scss';

 interface TitleCardProps {
+  label: 'now' | 'next';
  title: string;
-  label?: 'now' | 'next';
  secondary?: string;
-  className?: string;
 }

-const TitleCard = forwardRef((props: TitleCardProps, ref: ForwardedRef<HTMLDivElement>) => {
-  const { label, title, secondary, className = '' } = props;
+export default function TitleCard(props: TitleCardProps) {
+  const { label, title, secondary } = props;
  const { getLocalizedString } = useTranslation();

  const accent = label === 'now';

  return (
-    <div className={`title-card ${className}`} ref={ref}>
-      <span className='title-card__title'>{title}</span>
-      <span className={accent ? 'title-card__label title-card__label--accent' : 'title-card__label'}>
-        {label && getLocalizedString(`common.${label}`)}
-      </span>
+    <div className='title-card'>
+      <div className='inline'>
+        <span className='title-card__title'>{title}</span>
+        <span className={accent ? 'title-card__label title-card__label--accent' : 'title-card__label'}>
+          {getLocalizedString(`common.${label}`)}
+        </span>
+      </div>
      <div className='title-card__secondary'>{secondary}</div>
    </div>
  );
-});
-
-TitleCard.displayName = 'TitleCard';
-export default TitleCard;
+}
@@ -27,10 +27,6 @@ export default function ParamInput(props: EditFormInputProps) {
  const { paramField } = props;
  const { id, type, defaultValue } = paramField;

-  if (type === 'persist') {
-    return null;
-  }
-
  if (type === 'option') {
    const optionFromParams = searchParams.get(id);
    const defaultOptionValue = optionFromParams || defaultValue;
@@ -13,24 +13,14 @@
  color: $label-gray;
  display: flex;
  flex-direction: column;
-  gap: 0.25rem;
+  gap: 0.25rem
 }

-.section {
-  color: $ui-white;
-  font-size: 1rem;
-
-  &:not(:first-child) {
-    margin-top: 2rem;
-  }
-}
-
-.fieldSet {
+.columnSection {
  display: flex;
  padding: $section-spacing 0;
  flex-direction: column;
  gap: $element-spacing;
-  margin-left: 0.5rem;
 }

 .title {
@@ -13,7 +13,7 @@ import {
 } from '@chakra-ui/react';

 import ParamInput from './ParamInput';
-import { isSection, ViewOption } from './types';
+import { ParamField } from './types';

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

@@ -22,37 +22,26 @@ type ViewParamsObj = { [key: string]: string | FormDataEntryValue };
 /**
 * Makes a new URLSearchParams object from the given params object
 */
-const getURLSearchParamsFromObj = (paramsObj: ViewParamsObj, paramFields: ViewOption[]) => {
-  const newSearchParams = new URLSearchParams();
+const getURLSearchParamsFromObj = (paramsObj: ViewParamsObj, paramFields: ParamField[]) => {
+  const defaultValues = paramFields.reduce<Record<string, string>>((acc, { id, defaultValue }) => {
+    acc[id] = String(defaultValue);
+    return acc;
+  }, {});

-  // Convert paramFields to an object that contains default values
-  const defaultValues: Record<string, string> = {};
-  paramFields.forEach((option) => {
-    if (!isSection(option)) {
-      defaultValues[option.id] = String(option.defaultValue);
-    }
-
-    // extract persisted values
-    if ('type' in option && option.type === 'persist') {
-      newSearchParams.set(option.id, option.value);
-    }
-  });
-
-  // compare which values are different from the default values
-  Object.entries(paramsObj).forEach(([id, value]) => {
+  return Object.entries(paramsObj).reduce((newSearchParams, [id, value]) => {
    if (typeof value === 'string' && value.length && defaultValues[id] !== value) {
      newSearchParams.set(id, value);
    }
-  });
-  return newSearchParams;
+    return newSearchParams;
+  }, new URLSearchParams());
 };

 interface EditFormDrawerProps {
-  viewOptions: ViewOption[];
+  paramFields: ParamField[];
 }

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

@@ -80,7 +69,7 @@ export default function ViewParamsEditor({ viewOptions }: EditFormDrawerProps) {
    formEvent.preventDefault();

    const newParamsObject = Object.fromEntries(new FormData(formEvent.currentTarget));
-    const newSearchParams = getURLSearchParamsFromObj(newParamsObject, viewOptions);
+    const newSearchParams = getURLSearchParamsFromObj(newParamsObject, paramFields);
    setSearchParams(newSearchParams);

    onClose();
@@ -97,29 +86,15 @@ export default function ViewParamsEditor({ viewOptions }: EditFormDrawerProps) {

        <DrawerBody>
          <form id='edit-params-form' onSubmit={onParamsFormSubmit}>
-            {viewOptions.map((option) => {
-              if (isSection(option)) {
-                return (
-                  <div key={option.section} className={style.section}>
-                    {option.section}
-                  </div>
-                );
-              }
-
-              if (option.type === 'persist') {
-                return null;
-              }
-
-              return (
-                <div key={option.title} className={style.fieldSet}>
-                  <label className={style.label}>
-                    <span className={style.title}>{option.title}</span>
-                    <span className={style.description}>{option.description}</span>
-                    <ParamInput key={option.title} paramField={option} />
-                  </label>
-                </div>
-              );
-            })}
+            {paramFields.map((field) => (
+              <div key={field.title} className={style.columnSection}>
+                <label className={style.label}>
+                  <span className={style.title}>{field.title}</span>
+                  <span className={style.description}>{field.description}</span>
+                  <ParamInput key={field.title} paramField={field} />
+                </label>
+              </div>
+            ))}
          </form>
        </DrawerBody>

@@ -1,18 +1,15 @@
 import { CustomFields } from 'ontime-types';

-import type { ParamField } from './types';
+import { type ParamField } from './types';

-export const makeOptionsFromCustomFields = (
-  customFields: CustomFields,
-  additionalOptions: Record<string, string> = {},
-) => {
-  return Object.entries(customFields).reduce((options, [key, value]) => {
-    options[`custom-${key}`] = `Custom: ${value.label}`;
-    return options;
-  }, additionalOptions);
+const makeOptionsFromCustomFields = (customFields: CustomFields, additionalOptions?: Record<string, string>) => {
+  const customFieldOptions = Object.entries(customFields).reduce((acc, [key, value]) => {
+    return { ...acc, [`custom-${key}`]: `Custom: ${value.label}` };
+  }, additionalOptions ?? {});
+  return customFieldOptions;
 };

-export const getTimeOption = (timeFormat: string): ParamField => {
+const getTimeOption = (timeFormat: string): ParamField => {
  const placeholder = `${timeFormat} (default)`;
  return {
    id: 'timeformat',
@@ -23,7 +20,7 @@ export const getTimeOption = (timeFormat: string): ParamField => {
  };
 };

-export const hideTimerSeconds: ParamField = {
+const hideTimerSeconds: ParamField = {
  id: 'hideTimerSeconds',
  title: 'Hide seconds in timer',
  description: 'Whether to hide seconds in the running timer',
@@ -31,10 +28,488 @@ export const hideTimerSeconds: ParamField = {
  defaultValue: false,
 };

-export const showLeadingZeros: ParamField = {
+const showLeadingZeros: ParamField = {
  id: 'showLeadingZeros',
  title: 'Show leading zeros in timer',
  description: 'Whether to show leading zeros in the running timer',
  type: 'boolean',
  defaultValue: false,
 };
+
+export const getClockOptions = (timeFormat: string): ParamField[] => [
+  getTimeOption(timeFormat),
+  {
+    id: 'key',
+    title: 'Key Colour',
+    description: 'Background colour in hexadecimal',
+    prefix: '#',
+    type: 'string',
+    placeholder: '00000000 (default)',
+  },
+  {
+    id: 'text',
+    title: 'Text Colour',
+    description: 'Text colour in hexadecimal',
+    prefix: '#',
+    type: 'string',
+    placeholder: 'fffff (default)',
+  },
+  {
+    id: 'textbg',
+    title: 'Text Background',
+    description: 'Colour of text background in hexadecimal',
+    prefix: '#',
+    type: 'string',
+    placeholder: '00000000 (default)',
+  },
+  {
+    id: 'font',
+    title: 'Font',
+    description: 'Font family, will use the fonts available in the system',
+    type: 'string',
+    placeholder: 'Arial Black (default)',
+  },
+  {
+    id: 'size',
+    title: 'Text Size',
+    description: 'Scales the current style (0.5 = 50% 1 = 100% 2 = 200%)',
+    type: 'number',
+    placeholder: '1 (default)',
+  },
+  {
+    id: 'alignx',
+    title: 'Align Horizontal',
+    description: 'Moves the horizontally in page to start = left | center | end = right',
+    type: 'option',
+    values: { start: 'Start', center: 'Center', end: 'End' },
+    defaultValue: 'center',
+  },
+  {
+    id: 'offsetx',
+    title: 'Offset Horizontal',
+    description: 'Offsets the timer horizontal position by a given amount in pixels',
+    type: 'number',
+    placeholder: '0 (default)',
+  },
+  {
+    id: 'aligny',
+    title: 'Align Vertical',
+    description: 'Moves the vertically in page to start = left | center | end = right',
+    type: 'option',
+    values: { start: 'Start', center: 'Center', end: 'End' },
+    defaultValue: 'center',
+  },
+  {
+    id: 'offsety',
+    title: 'Offset Vertical',
+    description: 'Offsets the timer vertical position by a given amount in pixels',
+    type: 'number',
+    placeholder: '0 (default)',
+  },
+];
+
+export const getTimerOptions = (timeFormat: string, customFields: CustomFields): ParamField[] => {
+  const mainOptions = makeOptionsFromCustomFields(customFields, { title: 'Title' });
+  const secondaryOptions = makeOptionsFromCustomFields(customFields, { note: 'Note' });
+  return [
+    getTimeOption(timeFormat),
+    hideTimerSeconds,
+    showLeadingZeros,
+    {
+      id: 'hideClock',
+      title: 'Hide Time Now',
+      description: 'Hides the Time Now field',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'main',
+      title: 'Main text',
+      description: 'Select the data source for the main text',
+      type: 'option',
+      values: mainOptions,
+      defaultValue: 'Title',
+    },
+    {
+      id: 'secondary-src',
+      title: 'Secondary text',
+      description: 'Select the data source for the secondary text',
+      type: 'option',
+      values: secondaryOptions,
+      defaultValue: '',
+    },
+    {
+      id: 'hideCards',
+      title: 'Hide Cards',
+      description: 'Hides the Now and Next cards',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'hideProgress',
+      title: 'Hide progress bar',
+      description: 'Hides the progress bar',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'hideMessage',
+      title: 'Hide Presenter Message',
+      description: 'Prevents the screen from displaying messages from the presenter',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'hideExternal',
+      title: 'Hide External',
+      description: 'Prevents the screen from displaying the external field',
+      type: 'boolean',
+      defaultValue: false,
+    },
+  ];
+};
+
+export const MINIMAL_TIMER_OPTIONS: ParamField[] = [
+  hideTimerSeconds,
+  {
+    id: 'key',
+    title: 'Key Colour',
+    description: 'Background colour in hexadecimal',
+    prefix: '#',
+    type: 'string',
+    placeholder: '00000000 (default)',
+  },
+  {
+    id: 'text',
+    title: 'Text Colour',
+    description: 'Text colour in hexadecimal',
+    prefix: '#',
+    type: 'string',
+    placeholder: 'fffff (default)',
+  },
+  {
+    id: 'textbg',
+    title: 'Text Background',
+    description: 'Colour of text background in hexadecimal',
+    prefix: '#',
+    type: 'string',
+    placeholder: '00000000 (default)',
+  },
+  {
+    id: 'font',
+    title: 'Font',
+    description: 'Font family, will use the fonts available in the system',
+    type: 'string',
+    placeholder: 'Arial Black (default)',
+  },
+  {
+    id: 'size',
+    title: 'Text Size',
+    description: 'Scales the current style (0.5 = 50% 1 = 100% 2 = 200%)',
+    type: 'number',
+    placeholder: '1 (default)',
+  },
+  {
+    id: 'alignx',
+    title: 'Align Horizontal',
+    description: 'Moves the horizontally in page to start = left | center | end = right',
+    type: 'option',
+    values: { start: 'Start', center: 'Center', end: 'End' },
+    defaultValue: 'center',
+  },
+  {
+    id: 'offsetx',
+    title: 'Offset Horizontal',
+    description: 'Offsets the timer horizontal position by a given amount in pixels',
+    type: 'number',
+    placeholder: '0 (default)',
+  },
+  {
+    id: 'aligny',
+    title: 'Align Vertical',
+    description: 'Moves the vertically in page to start = left | center | end = right',
+    type: 'option',
+    values: { start: 'Start', center: 'Center', end: 'End' },
+    defaultValue: 'center',
+  },
+  {
+    id: 'offsety',
+    title: 'Offset Vertical',
+    description: 'Offsets the timer vertical position by a given amount in pixels',
+    type: 'number',
+    placeholder: '0 (default)',
+  },
+  {
+    id: 'hideovertime',
+    title: 'Hide Overtime',
+    description: 'Whether to suppress overtime styles (red borders and red text)',
+    type: 'boolean',
+    defaultValue: false,
+  },
+  {
+    id: 'hideendmessage',
+    title: 'Hide End Message',
+    description: 'Whether to hide end message and continue showing the clock if timer is in overtime',
+    type: 'boolean',
+    defaultValue: false,
+  },
+];
+
+export const getLowerThirdOptions = (customFields: CustomFields): ParamField[] => {
+  const topSourceOptions = makeOptionsFromCustomFields(customFields, {
+    title: 'Title',
+  });
+
+  const bottomSourceOptions = makeOptionsFromCustomFields(customFields, {
+    title: 'Title',
+    none: 'None',
+  });
+
+  return [
+    {
+      id: 'trigger',
+      title: 'Animation Trigger',
+      description: '',
+      type: 'option',
+      values: {
+        event: 'Event Load',
+        manual: 'Manual',
+      },
+      defaultValue: 'manual',
+    },
+    {
+      id: 'top-src',
+      title: 'Top Text',
+      description: '',
+      type: 'option',
+      values: topSourceOptions,
+      defaultValue: 'title',
+    },
+    {
+      id: 'bottom-src',
+      title: 'Bottom Text',
+      description: 'Select the data source for the bottom element',
+      type: 'option',
+      values: bottomSourceOptions,
+      defaultValue: 'none',
+    },
+    {
+      id: 'top-colour',
+      title: 'Top Text Colour',
+      description: 'Top text colour in hexadecimal',
+      prefix: '#',
+      type: 'string',
+      placeholder: '0000ff (default)',
+    },
+    {
+      id: 'bottom-colour',
+      title: 'Bottom Text Colour',
+      description: 'Bottom text colour in hexadecimal',
+      prefix: '#',
+      type: 'string',
+      placeholder: '0000ff (default)',
+    },
+    {
+      id: 'top-bg',
+      title: 'Top Background Colour',
+      description: 'Top text background colour in hexadecimal',
+      prefix: '#',
+      type: 'string',
+      placeholder: '00000000 (default)',
+    },
+    {
+      id: 'bottom-bg',
+      title: 'Bottom Background Colour',
+      description: 'Bottom text background colour in hexadecimal',
+      prefix: '#',
+      type: 'string',
+      placeholder: '00000000 (default)',
+    },
+    {
+      id: 'top-size',
+      title: 'Top Text Size',
+      description: 'Font size of the top text',
+      type: 'string',
+      placeholder: '65px',
+    },
+    {
+      id: 'bottom-size',
+      title: 'Bottom Text Size',
+      description: 'Font size of the bottom text',
+      type: 'string',
+      placeholder: '64px',
+    },
+    {
+      id: 'width',
+      title: 'Minimum Width',
+      description: 'Minimum Width of the element',
+      type: 'number',
+      prefix: '%',
+      placeholder: '45 (default)',
+    },
+    {
+      id: 'transition',
+      title: 'Transition',
+      description: 'Transition in time in seconds (default 3)',
+      type: 'number',
+      placeholder: '3 (default)',
+    },
+    {
+      id: 'delay',
+      title: 'Delay',
+      description: 'Delay between transition in and out in seconds (default 3)',
+      type: 'number',
+      placeholder: '3 (default)',
+    },
+    {
+      id: 'key',
+      title: 'Key Colour',
+      description: 'Colour of the background',
+      prefix: '#',
+      type: 'string',
+      placeholder: 'ffffffff (default)',
+    },
+    {
+      id: 'line-colour',
+      title: 'Line Colour',
+      description: 'Colour of the line',
+      prefix: '#',
+      type: 'string',
+      placeholder: 'ff0000ff (default)',
+    },
+  ];
+};
+
+export const getBackstageOptions = (timeFormat: string, customFields: CustomFields): ParamField[] => {
+  const secondaryOptions = makeOptionsFromCustomFields(customFields, { note: 'Note' });
+
+  return [
+    getTimeOption(timeFormat),
+    {
+      id: 'hidePast',
+      title: 'Hide past events',
+      description: 'Scheduler will only show upcoming events',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'stopCycle',
+      title: 'Stop cycling through event pages',
+      description: 'Schedule will not auto-cycle through events',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'eventsPerPage',
+      title: 'Events per page',
+      description: 'Sets the number of events on the page, can cause overflow',
+      type: 'number',
+      placeholder: '8 (default)',
+    },
+    {
+      id: 'secondary-src',
+      title: 'Event secondary text',
+      description: 'Select the data source for auxiliary text shown in now and next cards',
+      type: 'option',
+      values: secondaryOptions,
+      defaultValue: '',
+    },
+  ];
+};
+
+export const getPublicOptions = (timeFormat: string, customFields: CustomFields): ParamField[] => {
+  const secondaryOptions = makeOptionsFromCustomFields(customFields);
+
+  return [
+    getTimeOption(timeFormat),
+    {
+      id: 'hidePast',
+      title: 'Hide past events',
+      description: 'Scheduler will only show upcoming events',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'stopCycle',
+      title: 'Stop cycling through event pages',
+      description: 'Schedule will not auto-cycle through events',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'eventsPerPage',
+      title: 'Events per page',
+      description: 'Sets the number of events on the page, can cause overflow',
+      type: 'number',
+      placeholder: '8 (default)',
+    },
+    {
+      id: 'secondary-src',
+      title: 'Event secondary text',
+      description: 'Select the data source for auxiliary text shown in now and next cards',
+      type: 'option',
+      values: secondaryOptions,
+      defaultValue: '',
+    },
+  ];
+};
+
+export const getStudioClockOptions = (timeFormat: string): ParamField[] => [
+  getTimeOption(timeFormat),
+  hideTimerSeconds,
+];
+
+export const getOperatorOptions = (customFields: CustomFields, timeFormat: string): ParamField[] => {
+  const fieldOptions = makeOptionsFromCustomFields(customFields, { title: 'Title', note: 'Note' });
+
+  const customFieldSelect = Object.entries(customFields).reduce((acc, [key, field]) => {
+    return { ...acc, [key]: { value: key, label: field.label, colour: field.colour } };
+  }, {});
+
+  return [
+    getTimeOption(timeFormat),
+    {
+      id: 'hidepast',
+      title: 'Hide Past Events',
+      description: 'Whether to events that have passed',
+      type: 'boolean',
+      defaultValue: false,
+    },
+    {
+      id: 'main',
+      title: 'Main data field',
+      description: 'Field to be shown in the first line of text',
+      type: 'option',
+      values: fieldOptions,
+      defaultValue: 'title',
+    },
+    {
+      id: 'secondary',
+      title: 'Secondary data field',
+      description: 'Field to be shown in the second line of text',
+      type: 'option',
+      values: fieldOptions,
+      defaultValue: '',
+    },
+    {
+      id: 'subscribe',
+      title: 'Highlight Field',
+      description: 'Choose a custom field to highlight',
+      type: 'multi-option',
+      values: customFieldSelect,
+    },
+    {
+      id: 'shouldEdit',
+      title: 'Edit custom field',
+      description: 'Allows editing an events selected custom field by long pressing.',
+      type: 'boolean',
+      defaultValue: false,
+    },
+  ];
+};
+
+export const getCountdownOptions = (timeFormat: string): ParamField[] => [getTimeOption(timeFormat), hideTimerSeconds];
+
+export const getProgressOptions = (timeFormat: string): ParamField[] => {
+  return [getTimeOption(timeFormat)];
+};
@@ -1,7 +1,3 @@
-type ParamSection = {
-  section: string;
-};
-
 type BaseField = {
  id: string;
  title: string;
@@ -23,15 +19,5 @@ type MultiOptionsField = {
 type StringField = { type: 'string'; defaultValue?: string; prefix?: string; placeholder?: string };
 type NumberField = { type: 'number'; defaultValue?: number; prefix?: string; placeholder?: string };
 type BooleanField = { type: 'boolean'; defaultValue: boolean };
-type PersistedField = { type: 'persist'; defaultValue?: string; value: string };

-export type ParamField = BaseField &
-  (StringField | BooleanField | NumberField | OptionsField | MultiOptionsField | PersistedField);
-export type ViewOption = ParamSection | ParamField;
-
-/**
- * Type assertion utility checks whether an entry is a section separator
- */
-export function isSection(entry: ViewOption): entry is ParamSection {
-  return 'section' in entry;
-}
+export type ParamField = BaseField & (StringField | BooleanField | NumberField | OptionsField | MultiOptionsField);
@@ -1,7 +1,7 @@
 import { useQuery } from '@tanstack/react-query';
 import { CustomFields } from 'ontime-types';

-import { queryRefetchIntervalSlow } from '../../ontimeConfig';
+import { queryRefetchInterval } from '../../ontimeConfig';
 import { CUSTOM_FIELDS } from '../api/constants';
 import { getCustomFields } from '../api/customFields';

@@ -14,7 +14,7 @@ export default function useCustomFields() {
    placeholderData: (previousData, _previousQuery) => previousData,
    retry: 5,
    retryDelay: (attempt) => attempt * 2500,
-    refetchInterval: queryRefetchIntervalSlow,
+    refetchInterval: queryRefetchInterval,
    networkMode: 'always',
  });

@@ -2,7 +2,7 @@ import { useEffect, useState } from 'react';
 import { useQuery } from '@tanstack/react-query';
 import { NormalisedRundown, OntimeRundown, RundownCached } from 'ontime-types';

-import { queryRefetchIntervalSlow } from '../../ontimeConfig';
+import { queryRefetchInterval } from '../../ontimeConfig';
 import { RUNDOWN } from '../api/constants';
 import { fetchNormalisedRundown } from '../api/rundown';

@@ -16,7 +16,7 @@ export default function useRundown() {
    placeholderData: (previousData, _previousQuery) => previousData,
    retry: 5,
    retryDelay: (attempt) => attempt * 2500,
-    refetchInterval: queryRefetchIntervalSlow,
+    refetchInterval: queryRefetchInterval,
    networkMode: 'always',
  });
  return { data: data ?? cachedRundownPlaceholder, status, isError, refetch, isFetching };
@@ -12,7 +12,9 @@ export const useClientPath = () => {

  // notify of client path changes
  useEffect(() => {
-    socketSendJson('set-client-path', pathname + search);
+    //remove leading '/' from path
+    const fullPath = (pathname.startsWith('/') ? pathname.slice(1) : pathname) + search;
+    socketSendJson('set-client-path', fullPath);
  }, [pathname, search]);

  // navigate to new path when received from server
@@ -9,8 +9,6 @@ import {
  parseUserTime,
  reorderArray,
  swapEventData,
-  validateEndAction,
-  validateTimerType,
 } from 'ontime-utils';

 import { RUNDOWN } from '../api/constants';
@@ -34,15 +32,7 @@ import { useEditorSettings } from '../stores/editorSettings';
 */
 export const useEventAction = () => {
  const queryClient = useQueryClient();
-  const {
-    defaultPublic,
-    linkPrevious,
-    defaultDuration,
-    defaultWarnTime,
-    defaultDangerTime,
-    defaultTimerType,
-    defaultEndAction,
-  } = useEditorSettings();
+  const { defaultPublic, linkPrevious, defaultDuration, defaultWarnTime, defaultDangerTime } = useEditorSettings();

  /**
   * Calls mutation to add new event
@@ -56,17 +46,17 @@ export const useEventAction = () => {
    networkMode: 'always',
  });

-  // options to any new block (event / delay / block)
  type BaseOptions = {
    after?: string;
  };

-  // options to blocks of type OntimeEvent
  type EventOptions = BaseOptions &
    Partial<{
      defaultPublic: boolean;
      linkPrevious: boolean;
      lastEventId: string;
+      defaultWarnTime: number;
+      defaultDangerTime: number;
    }>;

  /**
@@ -78,12 +68,13 @@ export const useEventAction = () => {

      // ************* CHECK OPTIONS specific to events
      if (isOntimeEvent(newEvent)) {
-        // merge creation time options with event settings
        const applicationOptions = {
          after: options?.after,
          defaultPublic: options?.defaultPublic ?? defaultPublic,
          lastEventId: options?.lastEventId,
          linkPrevious: options?.linkPrevious ?? linkPrevious,
+          defaultWarnTime,
+          defaultDangerTime,
        };

        if (applicationOptions.linkPrevious && applicationOptions?.lastEventId) {
@@ -98,7 +89,6 @@ export const useEventAction = () => {
          }
        }

-        // Override event with options from editor settings
        if (applicationOptions.defaultPublic) {
          newEvent.isPublic = true;
        }
@@ -114,14 +104,6 @@ export const useEventAction = () => {
        if (newEvent.timeWarning === undefined) {
          newEvent.timeWarning = parseUserTime(defaultWarnTime);
        }
-
-        if (newEvent.timerType === undefined) {
-          newEvent.timerType = validateTimerType(defaultTimerType);
-        }
-
-        if (newEvent.endAction === undefined) {
-          newEvent.endAction = validateEndAction(defaultEndAction);
-        }
      }

      // handle adding options that concern all event type
@@ -135,17 +117,7 @@ export const useEventAction = () => {
        logAxiosError('Failed adding event', error);
      }
    },
-    [
-      _addEventMutation,
-      defaultDangerTime,
-      defaultDuration,
-      defaultEndAction,
-      defaultPublic,
-      defaultTimerType,
-      defaultWarnTime,
-      linkPrevious,
-      queryClient,
-    ],
+    [_addEventMutation, defaultDangerTime, defaultDuration, defaultPublic, defaultWarnTime, linkPrevious, queryClient],
  );

  /**
@@ -0,0 +1,159 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+
+export type TLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
+
+export type TOptions = {
+  logLevel?: TLogLevel;
+  maxFontSize?: number;
+  minFontSize?: number;
+  onFinish?: (fontSize: number) => void;
+  onStart?: () => void;
+  resolution?: number;
+};
+
+const LOG_LEVEL: Record<TLogLevel, number> = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  none: 100,
+};
+
+const useFitText = ({
+  logLevel: logLevelOption = 'info',
+  maxFontSize = 100,
+  minFontSize = 20,
+  onFinish,
+  onStart,
+  resolution = 5,
+}: TOptions = {}) => {
+  const logLevel = LOG_LEVEL[logLevelOption];
+
+  const initState = useCallback(() => {
+    return {
+      calcKey: 0,
+      fontSize: maxFontSize,
+      fontSizePrev: minFontSize,
+      fontSizeMax: maxFontSize,
+      fontSizeMin: minFontSize,
+    };
+  }, [maxFontSize, minFontSize]);
+
+  const ref = useRef<HTMLDivElement>(null);
+  const innerHtmlPrevRef = useRef<string | null>();
+  const isCalculatingRef = useRef(false);
+  const [state, setState] = useState(initState);
+  const { calcKey, fontSize, fontSizeMax, fontSizeMin, fontSizePrev } = state;
+
+  // Monitor div size changes and recalculate on resize
+  let animationFrameId: number | null = null;
+  const [ro] = useState(
+    () =>
+      new ResizeObserver(() => {
+        animationFrameId = window.requestAnimationFrame(() => {
+          if (isCalculatingRef.current) {
+            return;
+          }
+          onStart && onStart();
+          isCalculatingRef.current = true;
+          // `calcKey` is used in the dependencies array of
+          // `useIsoLayoutEffect` below. It is incremented so that the font size
+          // will be recalculated even if the previous state didn't change (e.g.
+          // when the text fit initially).
+          setState({
+            ...initState(),
+            calcKey: calcKey + 1,
+          });
+        });
+      }),
+  );
+
+  useEffect(() => {
+    if (ref.current) {
+      ro.observe(ref.current);
+    }
+    return () => {
+      animationFrameId && window.cancelAnimationFrame(animationFrameId);
+      ro.disconnect();
+    };
+  }, [animationFrameId, ro]);
+
+  // Recalculate when the div contents change
+  const innerHtml = ref.current && ref.current.innerHTML;
+  useEffect(() => {
+    if (calcKey === 0 || isCalculatingRef.current) {
+      return;
+    }
+    if (innerHtml !== innerHtmlPrevRef.current) {
+      onStart && onStart();
+      setState({
+        ...initState(),
+        calcKey: calcKey + 1,
+      });
+    }
+    innerHtmlPrevRef.current = innerHtml;
+  }, [calcKey, initState, innerHtml, onStart]);
+
+  // Check overflow and resize font
+  useLayoutEffect(() => {
+    // Don't start calculating font size until the `resizeKey` is incremented
+    // above in the `ResizeObserver` callback. This avoids an extra resize
+    // on initialization.
+    if (calcKey === 0) {
+      return;
+    }
+
+    const isWithinResolution = Math.abs(fontSize - fontSizePrev) <= resolution;
+    const isOverflow =
+      !!ref.current &&
+      (ref.current.scrollHeight > ref.current.offsetHeight || ref.current.scrollWidth > ref.current.offsetWidth);
+    const isFailed = isOverflow && fontSize === fontSizePrev;
+    const isAsc = fontSize > fontSizePrev;
+
+    // Return if the font size has been adjusted "enough" (change within `resolution`)
+    // reduce font size by one increment if it's overflowing.
+    if (isWithinResolution) {
+      if (isFailed) {
+        isCalculatingRef.current = false;
+        if (logLevel <= LOG_LEVEL.info) {
+          console.info(`[use-fit-text] reached \`minFontSize = ${minFontSize}\` without fitting text`);
+        }
+      } else if (isOverflow) {
+        setState({
+          fontSize: isAsc ? fontSizePrev : fontSizeMin,
+          fontSizeMax,
+          fontSizeMin,
+          fontSizePrev,
+          calcKey,
+        });
+      } else {
+        isCalculatingRef.current = false;
+        onFinish && onFinish(fontSize);
+      }
+      return;
+    }
+
+    // Binary search to adjust font size
+    let delta: number;
+    let newMax = fontSizeMax;
+    let newMin = fontSizeMin;
+    if (isOverflow) {
+      delta = isAsc ? fontSizePrev - fontSize : fontSizeMin - fontSize;
+      newMax = Math.min(fontSizeMax, fontSize);
+    } else {
+      delta = isAsc ? fontSizeMax - fontSize : fontSizePrev - fontSize;
+      newMin = Math.max(fontSizeMin, fontSize);
+    }
+    setState({
+      calcKey,
+      fontSize: fontSize + delta / 2,
+      fontSizeMax: newMax,
+      fontSizeMin: newMin,
+      fontSizePrev: fontSize,
+    });
+  }, [calcKey, fontSize, fontSizeMax, fontSizeMin, fontSizePrev, onFinish, ref, resolution]);
+
+  return { fontSize: `${fontSize}%`, ref };
+};
+
+export default useFitText;
@@ -19,7 +19,7 @@ export default function useLongPress(callback: () => void, options: LongPressOpt
  const { threshold = 400, onStart, onFinish, onCancel } = options;
  const isLongPressActive = useRef(false);
  const isPressed = useRef(false);
-  const timerId = useRef<NodeJS.Timeout>();
+  const timerId = useRef<NodeJS.Timer>();

  return useMemo(() => {
    const start = (event: SyntheticEvent) => {
@@ -1,4 +1,4 @@
-import { RuntimeStore, SimpleDirection, SimplePlayback, TimerMessage } from 'ontime-types';
+import { RuntimeStore, SimpleDirection, SimplePlayback } from 'ontime-types';

 import { useRuntimeStore } from '../stores/runtime';
 import { socketSendJson } from '../utils/socket';
@@ -28,43 +28,11 @@ export const useOperator = () => {
  return useRuntimeStore(featureSelector);
 };

-export const useTimerViewControl = () => {
+export const useMessageControl = () => {
  const featureSelector = (state: RuntimeStore) => ({
-    blackout: state.message.timer.blackout,
-    blink: state.message.timer.blink,
-    secondarySource: state.message.timer.secondarySource,
-  });
-
-  return useRuntimeStore(featureSelector);
-};
-
-export const useTimerMessageInput = () => {
-  const featureSelector = (state: RuntimeStore) => ({
-    text: state.message.timer.text,
-    visible: state.message.timer.visible,
-  });
-
-  return useRuntimeStore(featureSelector);
-};
-
-export const useExternalMessageInput = () => {
-  const featureSelector = (state: RuntimeStore) => ({
-    text: state.message.external,
-    visible: state.message.timer.secondarySource === 'external',
-  });
-
-  return useRuntimeStore(featureSelector);
-};
-
-export const useMessagePreview = () => {
-  const featureSelector = (state: RuntimeStore) => ({
-    blink: state.message.timer.blink,
-    blackout: state.message.timer.blackout,
-    phase: state.timer.phase,
-    showAuxTimer: state.message.timer.secondarySource === 'aux',
-    showExternalMessage: state.message.timer.secondarySource === 'external' && Boolean(state.message.external),
-    showTimerMessage: state.message.timer.visible && Boolean(state.message.timer.text),
-    timerType: state.eventNow?.timerType ?? null,
+    timer: state.message.timer,
+    external: state.message.external,
+    onAir: state.onAir,
  });

  return useRuntimeStore(featureSelector);
@@ -73,11 +41,8 @@ export const useMessagePreview = () => {
 export const setMessage = {
  timerText: (payload: string) => socketSendJson('message', { timer: { text: payload } }),
  timerVisible: (payload: boolean) => socketSendJson('message', { timer: { visible: payload } }),
-  externalText: (payload: string) => socketSendJson('message', { external: payload }),
  timerBlink: (payload: boolean) => socketSendJson('message', { timer: { blink: payload } }),
  timerBlackout: (payload: boolean) => socketSendJson('message', { timer: { blackout: payload } }),
-  timerSecondary: (payload: TimerMessage['secondarySource']) =>
-    socketSendJson('message', { timer: { secondarySource: payload } }),
 };

 export const usePlaybackControl = () => {
@@ -85,7 +50,6 @@ export const usePlaybackControl = () => {
    playback: state.timer.playback,
    selectedEventIndex: state.runtime.selectedEventIndex,
    numEvents: state.runtime.numEvents,
-    timerPhase: state.timer.phase,
  });

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

  return useRuntimeStore(featureSelector);
@@ -1,5 +1,3 @@
-import { EndAction, TimerType } from 'ontime-types';
-import { validateEndAction, validateTimerType } from 'ontime-utils';
 import { create } from 'zustand';

 import { booleanFromLocalStorage } from '../utils/localStorage';
@@ -10,15 +8,11 @@ type EditorSettingsStore = {
  defaultWarnTime: string;
  defaultDangerTime: string;
  defaultPublic: boolean;
-  defaultTimerType: TimerType;
-  defaultEndAction: EndAction;
  setDefaultDuration: (defaultDuration: string) => void;
  setLinkPrevious: (linkPrevious: boolean) => void;
  setWarnTime: (warnTime: string) => void;
  setDangerTime: (dangerTime: string) => void;
  setDefaultPublic: (defaultPublic: boolean) => void;
-  setDefaultTimerType: (defaultTimerType: TimerType) => void;
-  setDefaultEndAction: (defaultEndAction: EndAction) => void;
 };

 export const editorSettingsDefaults = {
@@ -27,8 +21,6 @@ export const editorSettingsDefaults = {
  warnTime: '00:02:00', // 120000 same as backend
  dangerTime: '00:01:00', // 60000 same as backend
  isPublic: true,
-  timerType: TimerType.CountDown,
-  endAction: EndAction.None,
 };

 enum EditorSettingsKeys {
@@ -37,8 +29,6 @@ enum EditorSettingsKeys {
  DefaultWarnTime = 'ontime-default-warn-time',
  DefaultDangerTime = 'ontime-default-danger-time',
  DefaultPublic = 'ontime-default-public',
-  DefaultTimerType = 'ontime-default-timer-type',
-  DefaultEndAction = 'ontime-default-end-action',
 }

 export const useEditorSettings = create<EditorSettingsStore>((set) => {
@@ -48,14 +38,6 @@ export const useEditorSettings = create<EditorSettingsStore>((set) => {
    defaultWarnTime: localStorage.getItem(EditorSettingsKeys.DefaultWarnTime) ?? editorSettingsDefaults.warnTime,
    defaultDangerTime: localStorage.getItem(EditorSettingsKeys.DefaultDangerTime) ?? editorSettingsDefaults.dangerTime,
    defaultPublic: booleanFromLocalStorage(EditorSettingsKeys.DefaultPublic, editorSettingsDefaults.isPublic),
-    defaultTimerType: validateTimerType(
-      localStorage.getItem(EditorSettingsKeys.DefaultTimerType),
-      editorSettingsDefaults.timerType,
-    ),
-    defaultEndAction: validateEndAction(
-      localStorage.getItem(EditorSettingsKeys.DefaultEndAction),
-      editorSettingsDefaults.endAction,
-    ),

    setDefaultDuration: (defaultDuration) =>
      set(() => {
@@ -83,15 +65,5 @@ export const useEditorSettings = create<EditorSettingsStore>((set) => {
        localStorage.setItem(EditorSettingsKeys.DefaultPublic, String(defaultPublic));
        return { defaultPublic };
      }),
-    setDefaultTimerType: (defaultTimerType) =>
-      set(() => {
-        localStorage.setItem(EditorSettingsKeys.DefaultTimerType, String(defaultTimerType));
-        return { defaultTimerType };
-      }),
-    setDefaultEndAction: (defaultEndAction) =>
-      set(() => {
-        localStorage.setItem(EditorSettingsKeys.DefaultEndAction, String(defaultEndAction));
-        return { defaultEndAction };
-      }),
  };
 });
@@ -23,9 +23,11 @@ export const runtimeStorePlaceholder: RuntimeStore = {
      visible: false,
      blink: false,
      blackout: false,
-      secondarySource: null,
    },
-    external: '',
+    external: {
+      text: '',
+      visible: false,
+    },
  },
  runtime: {
    selectedEventIndex: null,
@@ -36,10 +38,6 @@ export const runtimeStorePlaceholder: RuntimeStore = {
    actualStart: null,
    expectedEnd: null,
  },
-  currentBlock: {
-    block: null,
-    startedAt: null,
-  },
  eventNow: null,
  eventNext: null,
  publicEventNow: null,
@@ -50,7 +48,6 @@ export const runtimeStorePlaceholder: RuntimeStore = {
    duration: 0,
    playback: SimplePlayback.Stop,
  },
-  frozen: false,
 };

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

-import { CLIENT_LIST, CUSTOM_FIELDS, isProduction, RUNDOWN, RUNTIME, websocketUrl } from '../api/constants';
+import { CLIENT_LIST, isProduction, RUNTIME, websocketUrl } from '../api/constants';
 import { ontimeQueryClient } from '../queryClient';
 import {
  getClientId,
@@ -36,8 +36,7 @@ export const connectSocket = () => {
    }

    socketSendJson('set-client-type', 'ontime');
-
-    socketSendJson('set-client-path', location.pathname + location.search);
+    socketSendJson('set-client-path', location.pathname);
  };

  websocket.onclose = () => {
@@ -151,11 +150,6 @@ export const connectSocket = () => {
          updateDevTools({ eventNow: payload });
          break;
        }
-        case 'ontime-currentBlock': {
-          patchRuntime('currentBlock', payload);
-          updateDevTools({ currentBlock: payload });
-          break;
-        }
        case 'ontime-publicEventNow': {
          patchRuntime('publicEventNow', payload);
          updateDevTools({ publicEventNow: payload });
@@ -176,17 +170,6 @@ export const connectSocket = () => {
          updateDevTools({ auxtimer1: payload });
          break;
        }
-        case 'ontime-refetch': {
-          // the refetch message signals that the rundown has changed in the server side
-          const { revision } = payload;
-          const currentRevision = ontimeQueryClient.getQueryData<RundownCached>(RUNDOWN)?.revision ?? -1;
-
-          if (revision > currentRevision) {
-            ontimeQueryClient.invalidateQueries({ queryKey: RUNDOWN });
-            ontimeQueryClient.invalidateQueries({ queryKey: CUSTOM_FIELDS });
-          }
-          break;
-        }
      }
    } catch (_) {
      // ignore unhandled
@@ -34,16 +34,3 @@ export const enDash = '–';

 export const timerPlaceholder = '––:––:––';
 export const timerPlaceholderMin = '––:––';
-
-/**
- * Adds opacity to a given colour if possible
- */
-export function alpha(colour: string, amount: number): string {
-  try {
-    const withAlpha = Color(colour).alpha(amount).hexa();
-    return withAlpha;
-  } catch (_error) {
-    /* we do not handle errors here */
-  }
-  return colour;
-}
@@ -1,25 +1,25 @@
 import { MaybeNumber, Settings, TimeFormat } from 'ontime-types';
-import { formatFromMillis, MILLIS_PER_HOUR, MILLIS_PER_MINUTE, MILLIS_PER_SECOND } from 'ontime-utils';
+import { formatFromMillis } from 'ontime-utils';

 import { FORMAT_12, FORMAT_24 } from '../../viewerConfig';
 import { APP_SETTINGS } from '../api/constants';
 import { ontimeQueryClient } from '../queryClient';

 /**
- * Returns current time in milliseconds from midnight
+ * Returns current time in milliseconds
 * @returns {number}
 */
-export function nowInMillis(): number {
+export const nowInMillis = () => {
  const now = new Date();

  // extract milliseconds since midnight
-  let elapsed = now.getHours() * MILLIS_PER_HOUR;
-  elapsed += now.getMinutes() * MILLIS_PER_MINUTE;
-  elapsed += now.getSeconds() * MILLIS_PER_SECOND;
+  let elapsed = now.getHours() * 3600000;
+  elapsed += now.getMinutes() * 60000;
+  elapsed += now.getSeconds() * 1000;
  elapsed += now.getMilliseconds();

  return elapsed;
-}
+};

 /**
 * @description Resolves format from url and store
@@ -101,27 +101,19 @@ export const formatTime = (
 * @param duration
 * @returns
 */
-export function formatDuration(duration: number, hideSeconds = true): string {
-  // durations should never be negative, we handle it here to flag if there is an issue in future
-  if (duration <= 0) {
+export function formatDuration(duration: number): string {
+  if (duration === 0) {
    return '0h 0m';
  }

-  const hours = Math.floor(duration / MILLIS_PER_HOUR);
-  const minutes = Math.floor((duration % MILLIS_PER_HOUR) / MILLIS_PER_MINUTE);
+  const hours = Math.floor(duration / 3600000);
+  const minutes = Math.floor((duration % 3600000) / 60000);
  let result = '';
  if (hours > 0) {
-    result += `${hours}h`;
+    result += `${hours}h `;
  }
  if (minutes > 0) {
    result += `${minutes}m`;
  }
-
-  if (!hideSeconds) {
-    const seconds = Math.floor((duration % MILLIS_PER_MINUTE) / MILLIS_PER_SECOND);
-    if (seconds > 0) {
-      result += `${seconds}s`;
-    }
-  }
  return result;
 }
@@ -148,7 +148,6 @@ export default function GeneralPanelForm() {
                <option value='en'>English</option>
                <option value='fr'>French</option>
                <option value='de'>German</option>
-                <option value='hu'>Hungarian</option>
                <option value='it'>Italian</option>
                <option value='no'>Norwegian</option>
                <option value='pt'>Portuguese</option>
@@ -147,7 +147,7 @@ export default function ViewSettingsForm() {
                variant='ontime-filled'
                maxLength={150}
                width='275px'
-                placeholder='Shown when timer reaches end'
+                placeholder='Message shown when timer reaches end'
                {...register('endMessage')}
              />
            </Panel.ListItem>
@@ -7,26 +7,17 @@ import { editorSettingsDefaults, useEditorSettings } from '../../../../common/st
 import * as Panel from '../PanelUtils';

 export default function EditorSettingsForm() {
-  const {
-    defaultDuration,
-    linkPrevious,
-    defaultWarnTime,
-    defaultDangerTime,
-    defaultPublic,
-    defaultTimerType,
-    defaultEndAction,
-    setDefaultDuration,
-    setLinkPrevious,
-    setWarnTime,
-    setDangerTime,
-    setDefaultPublic,
-    setDefaultTimerType,
-    setDefaultEndAction,
-  } = useEditorSettings((state) => state);
+  const eventSettings = useEditorSettings((state) => state);

-  const durationInMs = parseUserTime(defaultDuration);
-  const warnTimeInMs = parseUserTime(defaultWarnTime);
-  const dangerTimeInMs = parseUserTime(defaultDangerTime);
+  const setDefaultDuration = eventSettings.setDefaultDuration;
+  const setLinkPrevious = eventSettings.setLinkPrevious;
+  const setWarnTime = eventSettings.setWarnTime;
+  const setDangerTime = eventSettings.setDangerTime;
+  const setDefaultPublic = eventSettings.setDefaultPublic;
+
+  const durationInMs = parseUserTime(eventSettings.defaultDuration);
+  const warnTimeInMs = parseUserTime(eventSettings.defaultWarnTime);
+  const dangerTimeInMs = parseUserTime(eventSettings.defaultDangerTime);

  return (
    <Panel.Section>
@@ -53,19 +44,13 @@ export default function EditorSettingsForm() {
              <Switch
                variant='ontime'
                size='lg'
-                defaultChecked={linkPrevious}
+                defaultChecked={eventSettings.linkPrevious}
                onChange={(event) => setLinkPrevious(event.target.checked)}
              />
            </Panel.ListItem>
            <Panel.ListItem>
              <Panel.Field title='Timer type' description='Default type of timer for new events' />
-              <Select
-                variant='ontime'
-                size='sm'
-                width='auto'
-                value={defaultTimerType}
-                onChange={(event) => setDefaultTimerType(event.target.value as TimerType)}
-              >
+              <Select variant='ontime' size='sm' width='auto' isDisabled>
                <option value={TimerType.CountDown}>Count down</option>
                <option value={TimerType.CountUp}>Count up</option>
                <option value={TimerType.TimeToEnd}>Time to end</option>
@@ -74,13 +59,7 @@ export default function EditorSettingsForm() {
            </Panel.ListItem>
            <Panel.ListItem>
              <Panel.Field title='End Action' description='Default end action for new events' />
-              <Select
-                variant='ontime'
-                size='sm'
-                width='auto'
-                value={defaultEndAction}
-                onChange={(event) => setDefaultEndAction(event.target.value as EndAction)}
-              >
+              <Select variant='ontime' size='sm' width='auto' isDisabled>
                <option value={EndAction.None}>None</option>
                <option value={EndAction.Stop}>Stop</option>
                <option value={EndAction.LoadNext}>Load next</option>
@@ -114,14 +93,14 @@ export default function EditorSettingsForm() {
              <Switch
                variant='ontime'
                size='lg'
-                defaultChecked={defaultPublic}
+                defaultChecked={eventSettings.defaultPublic}
                onChange={(event) => setDefaultPublic(event.target.checked)}
              />
            </Panel.ListItem>
          </Panel.ListGroup>
        </Panel.Section>
        <Panel.Section>
-          <Panel.Title>Run mode</Panel.Title>
+          <Panel.Title>Play mode</Panel.Title>
          <Panel.ListGroup>
            <Panel.ListItem>
              <Panel.Field
@@ -17,7 +17,7 @@ export default function LogExport() {
    <Panel.Section>
      <Panel.Card>
        <Panel.SubHeader>
-          Event log
+          Network log
          <Button
            variant='ontime-subtle'
            size='sm'
@@ -42,7 +42,7 @@ export default function ManageProjects() {
      const errorMessage = maybeAxiosError(error);
      setError(`Error uploading file: ${errorMessage}`);
    } finally {
-      await invalidateAllCaches();
+      invalidateAllCaches();
    }

    setLoading(null);
@@ -78,7 +78,7 @@ export default function ProjectCreateForm(props: ProjectCreateFromProps) {
        </div>
      </Panel.Title>
      {error && <Panel.Error>{error}</Panel.Error>}
-      <Panel.Section className={style.innerColumn}>
+      <div className={style.innerColumn}>
        <label>
          Project title
          <Input
@@ -145,7 +145,7 @@ export default function ProjectCreateForm(props: ProjectCreateFromProps) {
            {...register('backstageUrl')}
          />
        </label>
-      </Panel.Section>
+      </div>
    </Panel.Section>
  );
 }
@@ -2,6 +2,8 @@ import { useEffect } from 'react';
 import { useForm } from 'react-hook-form';
 import { Button, Input } from '@chakra-ui/react';

+import * as Panel from '../PanelUtils';
+
 import style from './ProjectPanel.module.scss';

 export type ProjectFormValues = {
@@ -9,13 +11,14 @@ export type ProjectFormValues = {
 };

 interface ProjectFormProps {
-  action: 'duplicate' | 'rename' | 'merge';
+  action: 'duplicate' | 'rename';
  filename: string;
  onCancel: () => void;
  onSubmit: (values: ProjectFormValues) => Promise<void>;
+  submitError: string | null;
 }

-export default function ProjectForm({ action, filename, onSubmit, onCancel }: ProjectFormProps) {
+export default function ProjectForm({ action, filename, onSubmit, onCancel, submitError }: ProjectFormProps) {
  const {
    handleSubmit,
    register,
@@ -34,31 +37,34 @@ export default function ProjectForm({ action, filename, onSubmit, onCancel }: Pr
  }, [setFocus]);

  return (
-    <form onSubmit={handleSubmit(onSubmit)} className={style.form}>
-      <Input
-        className={style.formInput}
-        id='filename'
-        size='sm'
-        type='text'
-        variant='ontime-filled'
-        placeholder='Enter new name'
-        autoComplete='off'
-        {...register('filename', { required: true })}
-      />
-      <div className={style.actionButtons}>
-        <Button onClick={onCancel} size='sm' variant='ontime-ghosted' disabled={isSubmitting}>
-          Cancel
-        </Button>
-        <Button
+    <>
+      <form onSubmit={handleSubmit(onSubmit)} className={style.form}>
+        <Input
+          className={style.formInput}
+          id='filename'
          size='sm'
+          type='text'
          variant='ontime-filled'
-          isDisabled={!isDirty || !isValid || isSubmitting}
-          type='submit'
-          className={style.saveButton}
-        >
-          {action}
-        </Button>
-      </div>
-    </form>
+          placeholder='Enter new name'
+          autoComplete='off'
+          {...register('filename')}
+        />
+        <div className={style.actionButtons}>
+          <Button onClick={onCancel} size='sm' variant='ontime-ghosted' disabled={isSubmitting}>
+            Cancel
+          </Button>
+          <Button
+            size='sm'
+            variant='ontime-filled'
+            isDisabled={!isDirty || !isValid || isSubmitting}
+            type='submit'
+            className={style.saveButton}
+          >
+            {action}
+          </Button>
+        </div>
+      </form>
+      {submitError && <Panel.Error>{submitError}</Panel.Error>}
+    </>
  );
 }
@@ -11,15 +11,12 @@ import {
  renameProject,
 } from '../../../../common/api/db';
 import { invalidateAllCaches, maybeAxiosError } from '../../../../common/api/utils';
-import { cx } from '../../../../common/utils/styleUtils';
-import * as Panel from '../PanelUtils';

 import ProjectForm, { ProjectFormValues } from './ProjectForm';
-import ProjectMergeForm from './ProjectMergeForm';

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

-export type EditMode = 'rename' | 'duplicate' | 'merge' | null;
+export type EditMode = 'rename' | 'duplicate' | null;

 interface ProjectListItemProps {
  current?: boolean;
@@ -43,53 +40,36 @@ export default function ProjectListItem({
  onToggleEditMode,
 }: ProjectListItemProps) {
  const [submitError, setSubmitError] = useState<string | null>(null);
-  const [loading, setLoading] = useState(false);

-  const handleSubmitAction = (actionType: 'rename' | 'duplicate') => {
-    return async (values: ProjectFormValues) => {
-      setLoading(true);
-      setSubmitError(null);
-      try {
-        if (!values.filename) {
-          setSubmitError('Filename cannot be blank');
-          return;
-        }
-        const action = actionType === 'rename' ? renameProject : duplicateProject;
-        await action(filename, values.filename);
-        await onRefetch();
-        onSubmit();
-      } catch (error) {
-        setSubmitError(maybeAxiosError(error));
-      } finally {
-        setLoading(false);
-      }
-    };
-  };
-
-  const handleLoad = async (filename: string) => {
-    setLoading(true);
-    setSubmitError(null);
+  const handleSubmitRename = async (values: ProjectFormValues) => {
    try {
-      await loadProject(filename);
+      setSubmitError(null);
+
+      if (!values.filename) {
+        setSubmitError('Filename cannot be blank');
+        return;
+      }
+      await renameProject(filename, values.filename);
      await onRefetch();
-      await invalidateAllCaches();
+      onSubmit();
    } catch (error) {
      setSubmitError(maybeAxiosError(error));
-    } finally {
-      setLoading(false);
    }
  };

-  const handleDelete = async (filename: string) => {
-    setLoading(true);
-    setSubmitError(null);
+  const handleSubmitDuplicate = async (values: ProjectFormValues) => {
    try {
-      await deleteProject(filename);
+      setSubmitError(null);
+
+      if (!values.filename) {
+        setSubmitError('Filename cannot be blank');
+        return;
+      }
+      await duplicateProject(filename, values.filename);
      await onRefetch();
+      onSubmit();
    } catch (error) {
      setSubmitError(maybeAxiosError(error));
-    } finally {
-      setLoading(false);
    }
  };

@@ -102,70 +82,54 @@ export default function ProjectListItem({
    handleToggleEditMode(null, null);
  };

-  const isCurrentlyBeingEdited = filename === editingFilename;
-  const showProjectForm = (editingMode === 'rename' || editingMode === 'duplicate') && filename === editingFilename;
-  const showMergeForm = editingMode === 'merge' && isCurrentlyBeingEdited;
-  const classes = cx([current && !isCurrentlyBeingEdited && style.current, isCurrentlyBeingEdited && style.isEditing]);
+  const isCurrentlyBeingEdited = editingMode && filename === editingFilename;
+  const classes = current && !isCurrentlyBeingEdited ? style.current : undefined;

  return (
-    <>
-      {submitError && (
-        <tr key='filename-error'>
-          <td colSpan={99}>
-            <Panel.Error>{submitError}</Panel.Error>
-          </td>
-        </tr>
-      )}
-      <tr key={filename} className={classes}>
-        {showProjectForm ? (
-          <td colSpan={99}>
-            <ProjectForm
-              action={editingMode}
+    <tr key={filename} className={classes}>
+      {isCurrentlyBeingEdited ? (
+        <td colSpan={99}>
+          <ProjectForm
+            action={editingMode}
+            filename={filename}
+            onSubmit={editingMode === 'duplicate' ? handleSubmitDuplicate : handleSubmitRename}
+            onCancel={handleCancel}
+            submitError={submitError}
+          />
+        </td>
+      ) : (
+        <>
+          <td className={style.containCell}>{filename}</td>
+          <td>{new Date(updatedAt).toLocaleString()}</td>
+          <td className={style.actionButton}>
+            <ActionMenu
+              current={current}
              filename={filename}
-              onSubmit={editingMode === 'duplicate' ? handleSubmitAction('duplicate') : handleSubmitAction('rename')}
-              onCancel={handleCancel}
+              onChangeEditMode={handleToggleEditMode}
+              onRefetch={onRefetch}
            />
          </td>
-        ) : (
-          <>
-            <td className={style.containCell}>{filename}</td>
-            <td>{current ? 'Currently loaded' : new Date(updatedAt).toLocaleString()}</td>
-            <td className={style.actionButton}>
-              <ActionMenu
-                current={current}
-                filename={filename}
-                onChangeEditMode={handleToggleEditMode}
-                onDelete={handleDelete}
-                onLoad={handleLoad}
-                isDisabled={loading || showMergeForm}
-                onMerge={(filename) => handleToggleEditMode('merge', filename)}
-              />
-            </td>
-          </>
-        )}
-      </tr>
-      {showMergeForm && (
-        <tr>
-          <td colSpan={99}>
-            <ProjectMergeForm onClose={handleCancel} fileName={filename} />
-          </td>
-        </tr>
+        </>
      )}
-    </>
+    </tr>
  );
 }

-interface ActionMenuProps {
+function ActionMenu({
+  current,
+  filename,
+  onChangeEditMode,
+  onRefetch,
+}: {
  current?: boolean;
  filename: string;
-  isDisabled: boolean;
  onChangeEditMode: (editMode: EditMode, filename: string) => void;
-  onDelete: (filename: string) => Promise<void>;
-  onLoad: (filename: string) => Promise<void>;
-  onMerge: (filename: string) => void;
-}
-function ActionMenu(props: ActionMenuProps) {
-  const { current, filename, isDisabled, onChangeEditMode, onDelete, onLoad, onMerge } = props;
+  onRefetch: () => Promise<void>;
+}) {
+  const handleLoad = async () => {
+    await loadProject(filename);
+    await invalidateAllCaches();
+  };

  const handleRename = () => {
    onChangeEditMode('rename', filename);
@@ -175,6 +139,11 @@ function ActionMenu(props: ActionMenuProps) {
    onChangeEditMode('duplicate', filename);
  };

+  const handleDelete = async () => {
+    await deleteProject(filename);
+    await onRefetch();
+  };
+
  const handleDownload = async () => {
    await downloadProject(filename);
  };
@@ -192,20 +161,16 @@ function ActionMenu(props: ActionMenuProps) {
        color='#e2e2e2' // $gray-200
        variant='ontime-ghosted'
        size='sm'
-        isDisabled={isDisabled}
      />
      <MenuList>
-        <MenuItem onClick={() => onLoad(filename)} isDisabled={current}>
+        <MenuItem onClick={handleLoad} isDisabled={current}>
          Load
        </MenuItem>
-        <MenuItem onClick={() => onMerge(filename)} isDisabled={current}>
-          Partial Load
-        </MenuItem>
        <MenuItem onClick={handleRename}>Rename</MenuItem>
        <MenuItem onClick={handleDuplicate}>Duplicate</MenuItem>
        <MenuItem onClick={handleDownload}>Download</MenuItem>
        <MenuItem onClick={handleExportCSV}>Export CSV Rundown</MenuItem>
-        <MenuItem isDisabled={current} onClick={() => onDelete(filename)}>
+        <MenuItem isDisabled={current} onClick={handleDelete}>
          Delete
        </MenuItem>
      </MenuList>
@@ -1,128 +0,0 @@
-import { useState } from 'react';
-import { useForm } from 'react-hook-form';
-import { Button, Switch } from '@chakra-ui/react';
-import { useQueryClient } from '@tanstack/react-query';
-
-import { PROJECT_DATA } from '../../../../common/api/constants';
-import { getDb, patchData } from '../../../../common/api/db';
-import { maybeAxiosError } from '../../../../common/api/utils';
-import { cx } from '../../../../common/utils/styleUtils';
-import * as Panel from '../PanelUtils';
-
-import { makeProjectPatch } from './project.utils';
-
-import style from './ProjectPanel.module.scss';
-
-interface ProjectMergeFromProps {
-  onClose: () => void;
-  fileName: string;
-}
-
-type ProjectMergeFormValues = {
-  project: boolean;
-  rundown: boolean;
-  viewSettings: boolean;
-  urlPresets: boolean;
-  osc: boolean;
-  http: boolean;
-};
-
-export default function ProjectMergeForm(props: ProjectMergeFromProps) {
-  const { onClose, fileName } = props;
-  const [error, setError] = useState<string | null>(null);
-  const queryClient = useQueryClient();
-
-  const {
-    handleSubmit,
-    register,
-    formState: { isSubmitting, isValid, isDirty },
-  } = useForm<ProjectMergeFormValues>({
-    defaultValues: {
-      project: false,
-      rundown: false,
-      viewSettings: false,
-      urlPresets: false,
-      osc: false,
-      http: false,
-    },
-    resetOptions: {
-      keepDirtyValues: true,
-    },
-  });
-
-  const handleSubmitCreate = async (values: ProjectMergeFormValues) => {
-    const allFalse = Object.values(values).every((value) => !value);
-    if (allFalse) {
-      setError('At least one option must be selected');
-      return;
-    }
-
-    try {
-      setError(null);
-
-      // make patch object
-      const { data } = await getDb(fileName);
-      const patch = await makeProjectPatch(data, values);
-
-      // request patch
-      await patchData(patch);
-      await queryClient.invalidateQueries({ queryKey: PROJECT_DATA });
-      onClose();
-    } catch (error) {
-      setError(maybeAxiosError(error));
-    }
-  };
-
-  return (
-    <Panel.Section as='form' onSubmit={handleSubmit(handleSubmitCreate)}>
-      <Panel.Title>
-        Merge {`"${fileName}"`}
-        <div className={style.createActionButtons}>
-          <Button onClick={onClose} variant='ontime-ghosted' size='sm' isDisabled={isSubmitting}>
-            Cancel
-          </Button>
-          <Button
-            isDisabled={!isValid || !isDirty}
-            type='submit'
-            isLoading={isSubmitting}
-            variant='ontime-filled'
-            size='sm'
-          >
-            Merge
-          </Button>
-        </div>
-      </Panel.Title>
-      {error && <Panel.Error>{error}</Panel.Error>}
-      <Panel.Section className={cx([style.innerColumn, style.inlineLabels])}>
-        <Panel.Description>
-          Select partial data from {`"${fileName}"`} to merge into the current project.
-          <br /> This process is irreversible.
-        </Panel.Description>
-        <label>
-          <Switch variant='ontime' {...register('project')} />
-          Project data
-        </label>
-        <label>
-          <Switch variant='ontime' {...register('rundown')} />
-          Rundown + Custom Fields
-        </label>
-        <label>
-          <Switch variant='ontime' {...register('viewSettings')} />
-          View Settings
-        </label>
-        <label>
-          <Switch variant='ontime' {...register('urlPresets')} />
-          URL Presets
-        </label>
-        <label>
-          <Switch variant='ontime' {...register('osc')} />
-          OSC Integration
-        </label>
-        <label>
-          <Switch variant='ontime' {...register('http')} />
-          HTTP Integration
-        </label>
-      </Panel.Section>
-    </Panel.Section>
-  );
-}
@@ -2,10 +2,6 @@
  background-color: $blue-1100;
 }

-.isEditing {
-  color: $blue-500;
-}
-
 .actionButton {
  flex: 1;
  text-align: right;
@@ -54,10 +50,3 @@
  flex-direction: column;
  gap: 1em;
 }
-
-.inlineLabels {
-  label {
-    display: flex;
-    gap: 1rem;
-  }
-}
@@ -1,17 +0,0 @@
-import { DatabaseModel, isKeyOfType } from 'ontime-types';
-
-export async function makeProjectPatch(data: DatabaseModel, mergeKeys: Record<string, boolean>) {
-  const patchObject: Partial<DatabaseModel> = {};
-
-  for (const key in mergeKeys) {
-    if (isKeyOfType(key, data) && mergeKeys[key]) {
-      // if the rundown is merged we also need the custom fields
-      if (key === 'rundown') {
-        patchObject.customFields = data['customFields'];
-      }
-      Object.assign(patchObject, { [key]: data[key] });
-    }
-  }
-
-  return patchObject;
-}
@@ -10,7 +10,6 @@ import {
  useDisclosure,
 } from '@chakra-ui/react';

-import { isLocalhost } from '../../../../common/api/constants';
 import useElectronEvent from '../../../../common/hooks/useElectronEvent';
 import * as Panel from '../PanelUtils';

@@ -32,10 +31,9 @@ export default function ShutdownPanel() {
          This will shutdown the Ontime server. <br />
          The runtime state will be lost, but your project is kept for next time.
        </Panel.Paragraph>
-        <Button colorScheme='red' onClick={onOpen} maxWidth='350px' isDisabled={!(isElectron || isLocalhost)}>
+        <Button colorScheme='red' onClick={onOpen} maxWidth='350px' isDisabled={!isElectron}>
          Shutdown ontime
        </Button>
-        <Panel.Description>Note: Ontime can only be shutdown from the machine it is running in.</Panel.Description>
        <AlertDialog variant='ontime' isOpen={isOpen} leastDestructiveRef={cancelRef} onClose={onClose}>
          <AlertDialogOverlay>
            <AlertDialogContent>
@@ -78,7 +78,7 @@ export default function ImportMapForm(props: ImportMapFormProps) {

  const isLoading = Boolean(loading);
  const canSubmitSpreadsheet = isSpreadsheet && !isLoading;
-  const canSubmitGSheet = !isLoading && !stepData.worksheet.error;
+  const canSubmitGSheet = !isLoading;
  const canSubmit = !hasErrors && isValid && (canSubmitSpreadsheet || canSubmitGSheet);

  return (
@@ -57,7 +57,7 @@ export const settingPanels: Readonly<SettingsOption[]> = [
    secondary: [
      {
        id: 'network__log',
-        label: 'Event log',
+        label: 'Application log',
      },
      {
        id: 'network__clients',
@@ -1,9 +1,10 @@
 import { useEffect, useRef } from 'react';
-import { Input } from '@chakra-ui/react';
+import { IconButton, Input } from '@chakra-ui/react';
 import { IoEye } from '@react-icons/all-files/io5/IoEye';
 import { IoEyeOffOutline } from '@react-icons/all-files/io5/IoEyeOffOutline';

 import TooltipActionBtn from '../../../common/components/buttons/TooltipActionBtn';
+import { cx } from '../../../common/utils/styleUtils';
 import { tooltipDelayMid } from '../../../ontimeConfig';

 import style from './InputRow.module.scss';
@@ -12,13 +13,15 @@ interface InputRowProps {
  label: string;
  placeholder: string;
  text: string;
-  visible: boolean;
-  actionHandler: () => void;
+  visible?: boolean;
+  readonly?: boolean;
+  actionHandler: (action: string, payload: object) => void;
  changeHandler: (newValue: string) => void;
+  className?: string;
 }

 export default function InputRow(props: InputRowProps) {
-  const { label, placeholder, text, visible, actionHandler, changeHandler } = props;
+  const { label, placeholder, text, visible, actionHandler, changeHandler, className, readonly } = props;

  const inputRef = useRef<HTMLInputElement>(null);
  const cursorPositionRef = useRef(0);
@@ -36,27 +39,41 @@ export default function InputRow(props: InputRowProps) {
    changeHandler(event.target.value);
  };

+  const classes = cx([style.inputRow, className]);
+
  return (
-    <div className={style.inputRow}>
+    <div className={classes}>
      <label className={`${style.label} ${visible ? style.active : ''}`}>{label}</label>
      <div className={style.inputItems}>
        <Input
          ref={inputRef}
          size='sm'
          variant='ontime-filled'
+          readOnly={readonly}
+          disabled={readonly}
          value={text}
          onChange={handleInputChange}
          placeholder={placeholder}
        />
-        <TooltipActionBtn
-          clickHandler={actionHandler}
-          tooltip={visible ? 'Make invisible' : 'Make visible'}
-          aria-label={`Toggle ${label}`}
-          openDelay={tooltipDelayMid}
-          icon={visible ? <IoEye size='18px' /> : <IoEyeOffOutline size='18px' />}
-          variant={visible ? 'ontime-filled' : 'ontime-subtle'}
-          size='sm'
-        />
+        {readonly ? (
+          <IconButton
+            size='sm'
+            isDisabled
+            icon={visible ? <IoEye size='18px' /> : <IoEyeOffOutline size='18px' />}
+            aria-label={`Toggle ${label}`}
+            variant={visible ? 'ontime-filled' : 'ontime-subtle'}
+          />
+        ) : (
+          <TooltipActionBtn
+            clickHandler={() => actionHandler('update', { field: 'isPublic', value: !visible })}
+            tooltip={visible ? 'Make invisible' : 'Make visible'}
+            aria-label={`Toggle ${label}`}
+            openDelay={tooltipDelayMid}
+            icon={visible ? <IoEye size='18px' /> : <IoEyeOffOutline size='18px' />}
+            variant={visible ? 'ontime-filled' : 'ontime-subtle'}
+            size='sm'
+          />
+        )}
      </div>
    </div>
  );
@@ -1,3 +1,23 @@
+.messageContainer {
+  display: flex;
+  flex-direction: column;
+  gap: $section-spacing;
+}
+
+.buttonSection {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: $element-spacing;
+  margin-top: -0.5rem;
+}
+
+.singleAction {
+  display: flex;
+  flex-direction: column;
+  gap: $element-spacing;
+  margin-top: $element-inner-spacing;
+}
+
 .label {
  font-size: $inner-section-text-size;
  color: $label-gray;
@@ -6,89 +26,3 @@
    color: $action-text-color;
  }
 }
-
-.previewContainer {
-  display: grid;
-  gap: $element-spacing;
-  grid-template-columns: 2fr 1fr;
-}
-
-.preview {
-  background-color: $ui-black;
-  display: grid;
-  place-content: center;
-  text-align: center;
-  position: relative;
-}
-
-.corner {
-  transform: rotate(45deg);
-
-  position: absolute;
-  top: 0.5rem;
-  right: 0.5rem;
-  cursor: pointer;
-  color: $ui-white;
-  transition-property: color;
-  transition-duration: $transition-time-action;
-
-  &:hover {
-    color: $ontime-color;
-  }
-}
-
-.options {
-  display: flex;
-  flex-direction: column;
-  gap: $element-spacing;
-}
-
-.eventStatus {
-  position: absolute;
-  left: 0;
-  margin: 0.5rem 0.25rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.25rem;
-}
-
-.mainContent {
-  font-size: 1rem;
-  font-weight: 600;
-  color: var(--override-colour, $ui-white);
-
-  &[data-phase='pending'] {
-    color: $ontime-roll;
-  }
-  &[data-phase='overtime'] {
-    color: $playback-negative;
-  }
-  &[data-phase='none'] {
-    opacity: $opacity-disabled;
-  }
-}
-
-.secondaryContent {
-  border-top: 1px solid $white-7;
-}
-
-.blackout {
-  display: none;
-}
-
-.timerIndicators {
-  display: flex;
-  flex-direction: column;
-}
-
-.statusIcon {
-  color: $gray-1000;
-
-  &[data-active='true'] {
-    color: $active-indicator;
-  }
-}
-
-.divider {
-  border-top: 1px solid $gray-1000;
-}
@@ -1,52 +1,64 @@
-import { setMessage, useExternalMessageInput, useTimerMessageInput } from '../../../common/hooks/useSocket';
+import { Button } from '@chakra-ui/react';
+import { IoEye } from '@react-icons/all-files/io5/IoEye';
+import { IoEyeOffOutline } from '@react-icons/all-files/io5/IoEyeOffOutline';
+import { IoSunny } from '@react-icons/all-files/io5/IoSunny';
+import { IoSunnyOutline } from '@react-icons/all-files/io5/IoSunnyOutline';
+
+import { setMessage, useMessageControl } from '../../../common/hooks/useSocket';
+import { enDash } from '../../../common/utils/styleUtils';

 import InputRow from './InputRow';
-import TimerControlsPreview from './TimerViewControl';
+
+import style from './MessageControl.module.scss';
+
+const noop = () => undefined;

 export default function MessageControl() {
-  return (
-    <>
-      <TimerControlsPreview />
-      <TimerMessageInput />
-      <ExternalInput />
-    </>
-  );
-}
-
-function TimerMessageInput() {
-  const { text, visible } = useTimerMessageInput();
+  const message = useMessageControl();
+  const blink = message.timer.blink;
+  const blackout = message.timer.blackout;

  return (
-    <InputRow
-      label='Timer Message'
-      placeholder='Message shown fullscreen in stage timer'
-      text={text}
-      visible={visible}
-      changeHandler={(newValue) => setMessage.timerText(newValue)}
-      actionHandler={() => setMessage.timerVisible(!visible)}
-    />
-  );
-}
-
-function ExternalInput() {
-  const { text, visible } = useExternalMessageInput();
-
-  const toggleExternal = () => {
-    if (visible) {
-      setMessage.timerSecondary(null);
-    } else {
-      setMessage.timerSecondary('external');
-    }
-  };
-
-  return (
-    <InputRow
-      label='External Message'
-      placeholder='Message shown as secondary text in stage timer'
-      text={text}
-      visible={visible}
-      changeHandler={(newValue) => setMessage.externalText(newValue)}
-      actionHandler={toggleExternal}
-    />
+    <div className={style.messageContainer}>
+      <InputRow
+        label='Timer'
+        placeholder='Message shown in stage timer'
+        text={message.timer.text}
+        visible={message.timer.visible}
+        changeHandler={(newValue) => setMessage.timerText(newValue)}
+        actionHandler={() => setMessage.timerVisible(!message.timer.visible)}
+      />
+      <div className={style.buttonSection}>
+        <Button
+          size='sm'
+          className={`${blink ? style.blink : ''}`}
+          variant={blink ? 'ontime-filled' : 'ontime-subtle'}
+          leftIcon={blink ? <IoSunny size='1rem' /> : <IoSunnyOutline size='1rem' />}
+          onClick={() => setMessage.timerBlink(!blink)}
+          data-testid='toggle timer blink'
+        >
+          Blink
+        </Button>
+        <Button
+          size='sm'
+          className={style.blackoutButton}
+          variant={blackout ? 'ontime-filled' : 'ontime-subtle'}
+          leftIcon={blackout ? <IoEye size='1rem' /> : <IoEyeOffOutline size='1rem' />}
+          onClick={() => setMessage.timerBlackout(!blackout)}
+          data-testid='toggle timer blackout'
+        >
+          Blackout screen
+        </Button>
+      </div>
+      <InputRow
+        label='External Message (read only)'
+        placeholder={enDash}
+        readonly
+        text={message.external.text}
+        visible={message.external.visible}
+        changeHandler={noop}
+        actionHandler={noop}
+      />
+    </div>
  );
 }
@@ -3,19 +3,16 @@ import { IoArrowUp } from '@react-icons/all-files/io5/IoArrowUp';

 import ErrorBoundary from '../../../common/components/error-boundary/ErrorBoundary';
 import { handleLinks } from '../../../common/utils/linkUtils';
-import { cx } from '../../../common/utils/styleUtils';

 import MessageControl from './MessageControl';

 import style from '../../editors/Editor.module.scss';

 const MessageControlExport = () => {
-  const classes = cx([style.content, style.contentColumnLayout]);
-
  return (
    <div className={style.messages} data-testid='panel-messages-control'>
      <IoArrowUp className={style.corner} onClick={(event) => handleLinks(event, 'messagecontrol')} />
-      <div className={classes}>
+      <div className={style.content}>
        <ErrorBoundary>
          <MessageControl />
        </ErrorBoundary>
@@ -1,78 +0,0 @@
-import { Tooltip } from '@chakra-ui/react';
-import { IoArrowDown } from '@react-icons/all-files/io5/IoArrowDown';
-import { IoArrowUp } from '@react-icons/all-files/io5/IoArrowUp';
-import { IoFlag } from '@react-icons/all-files/io5/IoFlag';
-import { IoTime } from '@react-icons/all-files/io5/IoTime';
-import { TimerPhase, TimerType } from 'ontime-types';
-
-import { useMessagePreview } from '../../../common/hooks/useSocket';
-import useViewSettings from '../../../common/hooks-query/useViewSettings';
-import { handleLinks } from '../../../common/utils/linkUtils';
-import { cx } from '../../../common/utils/styleUtils';
-import { tooltipDelayMid } from '../../../ontimeConfig';
-
-import style from './MessageControl.module.scss';
-
-export default function TimerPreview() {
-  const { blink, blackout, phase, showAuxTimer, showExternalMessage, showTimerMessage, timerType } =
-    useMessagePreview();
-  const { data } = useViewSettings();
-
-  const contentClasses = cx([style.previewContent, blink && style.blink, blackout && style.blackout]);
-
-  const main = (() => {
-    if (showTimerMessage) return 'Message';
-    if (phase === TimerPhase.Pending) return 'Standby to start';
-    if (phase === TimerPhase.Overtime && data.endMessage) return 'Custom end message';
-    return 'Timer';
-  })();
-
-  const secondary = (() => {
-    // message is a fullscreen overlay
-    if (showTimerMessage) return null;
-
-    // we need to check aux first since it takes priority
-    if (showAuxTimer) return 'Aux Timer';
-    if (showExternalMessage) return 'External message';
-    return null;
-  })();
-
-  const overrideColour = (() => {
-    // override fallback colours from starter project
-    if (phase === TimerPhase.Warning) return data.warningColor ?? '#FFAB33';
-    if (phase === TimerPhase.Danger) return data.dangerColor ?? '#ED3333';
-    return data.normalColor ?? '#FFFC';
-  })();
-
-  const showColourOverride = main == 'Timer';
-
-  return (
-    <div className={style.preview}>
-      <IoArrowUp className={style.corner} onClick={(event) => handleLinks(event, 'timer')} />
-      <div className={contentClasses}>
-        <div
-          className={style.mainContent}
-          data-phase={phase}
-          style={showColourOverride ? { '--override-colour': overrideColour } : {}}
-        >
-          {main}
-        </div>
-        {secondary !== null && <div className={style.secondaryContent}>{secondary}</div>}
-      </div>
-      <div className={style.eventStatus}>
-        <Tooltip label='Time type: Count down' openDelay={tooltipDelayMid} shouldWrapChildren>
-          <IoArrowDown className={style.statusIcon} data-active={timerType === TimerType.CountDown} />
-        </Tooltip>
-        <Tooltip label='Time type: Count up' openDelay={tooltipDelayMid} shouldWrapChildren>
-          <IoArrowUp className={style.statusIcon} data-active={timerType === TimerType.CountUp} />
-        </Tooltip>
-        <Tooltip label='Time type: Clock' openDelay={tooltipDelayMid} shouldWrapChildren>
-          <IoTime className={style.statusIcon} data-active={timerType === TimerType.Clock} />
-        </Tooltip>
-        <Tooltip label='Time type: Time to end' openDelay={tooltipDelayMid} shouldWrapChildren>
-          <IoFlag className={style.statusIcon} data-active={timerType === TimerType.TimeToEnd} />
-        </Tooltip>
-      </div>
-    </div>
-  );
-}
@@ -1,62 +0,0 @@
-import { Button } from '@chakra-ui/react';
-
-import { setMessage, useTimerViewControl } from '../../../common/hooks/useSocket';
-
-import TimerPreview from './TimerPreview';
-
-import style from './MessageControl.module.scss';
-
-export default function TimerControlsPreview() {
-  const { blackout, blink, secondarySource } = useTimerViewControl();
-
-  const toggleSecondary = (newValue: 'aux' | 'external' | null) => {
-    if (secondarySource === newValue) {
-      setMessage.timerSecondary(null);
-    } else {
-      setMessage.timerSecondary(newValue);
-    }
-  };
-
-  return (
-    <div className={style.previewContainer}>
-      <TimerPreview />
-
-      <div className={style.options}>
-        <Button
-          size='sm'
-          variant={secondarySource === 'aux' ? 'ontime-filled' : 'ontime-subtle'}
-          onClick={() => toggleSecondary('aux')}
-        >
-          Show Aux timer
-        </Button>
-        <Button
-          size='sm'
-          variant={secondarySource === 'external' ? 'ontime-filled' : 'ontime-subtle'}
-          onClick={() => toggleSecondary('external')}
-        >
-          Show external
-        </Button>
-
-        <hr className={style.divider} />
-
-        <Button
-          size='sm'
-          variant={blink ? 'ontime-filled' : 'ontime-subtle'}
-          onClick={() => setMessage.timerBlink(!blink)}
-          data-testid='toggle timer blink'
-        >
-          Blink
-        </Button>
-        <Button
-          size='sm'
-          className={style.blackoutButton}
-          variant={blackout ? 'ontime-filled' : 'ontime-subtle'}
-          onClick={() => setMessage.timerBlackout(!blackout)}
-          data-testid='toggle timer blackout'
-        >
-          Blackout screen
-        </Button>
-      </div>
-    </div>
-  );
-}
@@ -21,7 +21,6 @@ export default function PlaybackControl() {
        playback={data.playback}
        numEvents={data.numEvents}
        selectedEventIndex={data.selectedEventIndex}
-        timerPhase={data.timerPhase}
      />
      <AuxTimer />
    </div>
@@ -68,7 +68,7 @@ function AuxTimerInput() {

  const handleTimeUpdate = (_field: string, value: string) => {
    const newTime = parseUserTime(value);
-    setDuration(newTime / 1000); // frontend api is seconds based
+    setDuration(newTime / 1000); //frontend api is seconds based;
  };

  return (
@@ -6,7 +6,7 @@ import { IoPlaySkipForward } from '@react-icons/all-files/io5/IoPlaySkipForward'
 import { IoReload } from '@react-icons/all-files/io5/IoReload';
 import { IoStop } from '@react-icons/all-files/io5/IoStop';
 import { IoTime } from '@react-icons/all-files/io5/IoTime';
-import { Playback, TimerPhase } from 'ontime-types';
+import { Playback } from 'ontime-types';
 import { validatePlayback } from 'ontime-utils';

 import { setPlayback } from '../../../../common/hooks/useSocket';
@@ -19,11 +19,10 @@ interface PlaybackButtonsProps {
  playback: Playback;
  numEvents: number;
  selectedEventIndex: number | null;
-  timerPhase: TimerPhase;
 }

 export default function PlaybackButtons(props: PlaybackButtonsProps) {
-  const { playback, numEvents, selectedEventIndex, timerPhase } = props;
+  const { playback, numEvents, selectedEventIndex } = props;

  const isRolling = playback === Playback.Roll;
  const isPlaying = playback === Playback.Play;
@@ -38,7 +37,7 @@ export default function PlaybackButtons(props: PlaybackButtonsProps) {
  const disableNext = isRolling || noEvents || isLast;
  const disablePrev = isRolling || noEvents || isFirst;

-  const playbackCan = validatePlayback(playback, timerPhase);
+  const playbackCan = validatePlayback(playback);
  const disableStart = !playbackCan.start;
  const disablePause = !playbackCan.pause;
  const disableRoll = !playbackCan.roll || noEvents;
@@ -50,15 +50,9 @@ $table-header-font-size: calc(1rem - 3px);

  font-size: $table-header-font-size;
  color: $gray-700;
-}

-th {
-  background-color: $gray-1300;
-
-  &:hover {
-    .resizer {
-      width: 0.5rem;
-    }
+  th {
+      background-color: $gray-1300;
  }
 }

@@ -132,19 +126,30 @@ th {

 .resizer {
  cursor: col-resize;
-  opacity: $opacity-disabled;
+  opacity: 0;
  display: inline-block;
-  width: 0;
+  width: 3px;
  height: 100%;
  position: absolute;
  right: 0;
  top: 0;
+  transform: translateX(50%);
  background-color: $action-blue;

  user-select: none;
  touch-action: none;

+  transition-duration: $transition-time-action;
+  transition-property: width, background-color;
+
  &:hover {
+    opacity: $opacity-disabled;
+    width: 6px;
+  }
+
+  &.isResizing {
    opacity: 1;
+    width: 6px;
+    background-color: $action-blue;
  }
 }
@@ -21,11 +21,11 @@ interface CuesheetProps {
  columns: ColumnDef<OntimeRundownEntry>[];
  handleUpdate: (rowIndex: number, accessor: keyof OntimeRundownEntry, payload: unknown) => void;
  selectedId: string | null;
-  currentBlockId: string | null;
 }

-export default function Cuesheet({ data, columns, handleUpdate, selectedId, currentBlockId }: CuesheetProps) {
+export default function Cuesheet({ data, columns, handleUpdate, selectedId }: CuesheetProps) {
  const { followSelected, showSettings, showDelayBlock, showPrevious, showIndexColumn } = useCuesheetSettings();
+
  const {
    columnVisibility,
    columnOrder,
@@ -114,16 +114,11 @@ export default function Cuesheet({ data, columns, handleUpdate, selectedId, curr
              }

              if (isOntimeBlock(row.original)) {
-                if (isPast && !showPrevious && key !== currentBlockId) {
-                  return null;
-                }
                return <BlockRow key={key} title={row.original.title} />;
              }
              if (isOntimeDelay(row.original)) {
-                if (isPast && !showPrevious) {
-                  return null;
-                }
                const delayVal = row.original.duration;
+
                if (!showDelayBlock || delayVal === 0) {
                  return null;
                }
@@ -133,6 +128,9 @@ export default function Cuesheet({ data, columns, handleUpdate, selectedId, curr
              if (isOntimeEvent(row.original)) {
                eventIndex++;
                const isSelected = key === selectedId;
+                if (isSelected) {
+                  isPast = false;
+                }

                if (isPast && !showPrevious) {
                  return null;
@@ -107,7 +107,6 @@ export default function CuesheetWrapper() {
        columns={columns}
        handleUpdate={handleUpdate}
        selectedId={featureData.selectedEventId}
-        currentBlockId={featureData.currentBlockId}
      />
    </div>
  );
@@ -6,17 +6,18 @@ import styles from './CuesheetProgress.module.scss';

 export default function CuesheetProgress() {
  const { data } = useViewSettings();
-  const { current, duration, timeWarning, timeDanger } = useProgressData();
+  const { addedTime, current, duration, timeWarning, timeDanger } = useProgressData();
+  const totalTime = (duration ?? 0) + (addedTime ?? 0);

  return (
    <MultiPartProgressBar
      now={current}
-      complete={duration}
-      normalColor={data.normalColor}
+      complete={totalTime}
+      normalColor={data!.normalColor}
      warning={timeWarning}
-      warningColor={data.warningColor}
+      warningColor={data!.warningColor}
      danger={timeDanger}
-      dangerColor={data.dangerColor}
+      dangerColor={data!.dangerColor}
      className={styles.progressOverride}
      ignoreCssOverride
    />
@@ -4,6 +4,8 @@ import { CSS } from '@dnd-kit/utilities';
 import { Header } from '@tanstack/react-table';
 import { OntimeRundownEntry } from 'ontime-types';

+import { cx } from '../../../common/utils/styleUtils';
+
 import styles from '../Cuesheet.module.scss';

 interface SortableCellProps {
@@ -27,6 +29,8 @@ export function SortableCell({ header, style, children }: SortableCellProps) {
    transition,
  };

+  const resizerClasses = cx([styles.resizer, header.column.getIsResizing() ? styles.isResizing : null]);
+
  return (
    <th ref={setNodeRef} style={dragStyle} colSpan={colSpan}>
      <div {...attributes} {...listeners}>
@@ -37,7 +41,7 @@ export function SortableCell({ header, style, children }: SortableCellProps) {
          onMouseDown: header.getResizeHandler(),
          onTouchStart: header.getResizeHandler(),
        }}
-        className={styles.resizer}
+        className={resizerClasses}
      />
    </th>
  );
@@ -40,7 +40,7 @@ $panel-gap: 0.5rem;
  .playback,
  .messages {
    position: relative;
-    border-radius: var(--editor--panel__br);
+    border-radius: 8px;
    background-color: $bg-container-l2;
    padding: 1rem;
  }
@@ -62,10 +62,3 @@ $panel-gap: 0.5rem;
 .content {
  padding-top: 1.5rem;
 }
-
-.contentColumnLayout {
-  display: flex;
-  flex-direction: column;
-  gap: $section-spacing;
-  color: $ui-white;
-}
@@ -1,18 +1,10 @@
@use '../../theme/ontimeColours' as *;
@use '../../theme/ontimeStyles' as *;

-// declare editor specific styling constants
-:root {
-  --editor--panel__br: 8px;
-}
-
-@mixin corner() {
-  display: none;
-  transform: rotate(45deg);
-
+@mixin absolute-top-right($distance) {
  position: absolute;
-  top: 0.5rem;
-  right: 0.5rem;
+  top: $distance;
+  right: $distance;
  cursor: pointer;
  color: $ui-white;
  transition-property: color;
@@ -23,11 +15,17 @@
  }
 }

+@mixin corner() {
+  display: none;
+  @include absolute-top-right(0.5rem);
+  transform: rotate(45deg);
+}
+
@mixin panel() {
  display: flex;

  position: relative;
-  border-radius: var(--editor--panel__br);
+  border-radius: 8px;
  height: 100%;
  background-color: $bg-container-l2;
  padding: 1rem;
@@ -4,6 +4,7 @@ import { isOntimeEvent, OntimeEvent, SupportedEvent } from 'ontime-types';
 import { getFirstEventNormal, getLastEventNormal } from 'ontime-utils';

 import Empty from '../../common/components/state/Empty';
+import { getOperatorOptions } from '../../common/components/view-params-editor/constants';
 import ViewParamsEditor from '../../common/components/view-params-editor/ViewParamsEditor';
 import useFollowComponent from '../../common/hooks/useFollowComponent';
 import { useOperator } from '../../common/hooks/useSocket';
@@ -21,7 +22,6 @@ import FollowButton from './follow-button/FollowButton';
 import OperatorBlock from './operator-block/OperatorBlock';
 import OperatorEvent from './operator-event/OperatorEvent';
 import StatusBar from './status-bar/StatusBar';
-import { getOperatorOptions } from './operator.options';

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

@@ -134,7 +134,7 @@ export default function Operator() {

  return (
    <div className={style.operatorContainer}>
-      <ViewParamsEditor viewOptions={operatorOptions} />
+      <ViewParamsEditor paramFields={operatorOptions} />
      {editEvent && <EditModal event={editEvent} onClose={() => setEditEvent(null)} />}

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

@@ -65,15 +65,12 @@
  font-size: 1.5rem;
  letter-spacing: 0.5px;
  color: $ui-white;
-
-  @include ellipsis-text;
 }

 .secondaryField {
  grid-area: secondary;
  font-size: 1.25rem;
  letter-spacing: 0.5px;
-  @include ellipsis-text;
 }

 .schedule {
@@ -101,7 +98,8 @@

  .field {
    font-weight: 600;
-    padding-inline: 0.25rem;
+    padding: 0 0.25rem;
+    margin-right: 0.25rem;
  }

  .noColour {
@@ -112,8 +110,6 @@
  }

  .value {
-    padding-inline: 0.25rem;
-    background-color: $gray-1250;
    color: var(--operator-highlight-override, $ui-white);
    margin-right: 1rem;
  }
@@ -1,60 +0,0 @@
-import { CustomFields } from 'ontime-types';
-
-import { getTimeOption, makeOptionsFromCustomFields } from '../../common/components/view-params-editor/constants';
-import { ViewOption } from '../../common/components/view-params-editor/types';
-
-export const getOperatorOptions = (customFields: CustomFields, timeFormat: string): ViewOption[] => {
-  const fieldOptions = makeOptionsFromCustomFields(customFields, { title: 'Title', note: 'Note' });
-
-  const customFieldSelect = Object.entries(customFields).reduce<
-    Record<string, { value: string; label: string; colour: string }>
-  >((acc, [key, field]) => {
-    acc[key] = { value: key, label: field.label, colour: field.colour };
-    return acc;
-  }, {});
-
-  return [
-    { section: 'Clock Options' },
-    getTimeOption(timeFormat),
-    { section: 'Data sources' },
-
-    {
-      id: 'main',
-      title: 'Main data field',
-      description: 'Field to be shown in the first line of text',
-      type: 'option',
-      values: fieldOptions,
-      defaultValue: 'title',
-    },
-    {
-      id: 'secondary',
-      title: 'Secondary data field',
-      description: 'Field to be shown in the second line of text',
-      type: 'option',
-      values: fieldOptions,
-      defaultValue: '',
-    },
-    {
-      id: 'subscribe',
-      title: 'Highlight Field',
-      description: 'Choose a custom field to highlight',
-      type: 'multi-option',
-      values: customFieldSelect,
-    },
-    { section: 'Element visibility' },
-    {
-      id: 'hidepast',
-      title: 'Hide Past Events',
-      description: 'Whether to hide events that have passed',
-      type: 'boolean',
-      defaultValue: false,
-    },
-    {
-      id: 'shouldEdit',
-      title: 'Edit custom field',
-      description: 'Allows editing an events selected custom field by long pressing.',
-      type: 'boolean',
-      defaultValue: false,
-    },
-  ];
-};
@@ -11,12 +11,13 @@ interface StatusBarProgressProps {

 export default function StatusBarProgress(props: StatusBarProgressProps) {
  const { viewSettings } = props;
-  const { current, duration, timeWarning, timeDanger } = useProgressData();
+  const { addedTime, current, duration, timeWarning, timeDanger } = useProgressData();
+  const totalTime = (duration ?? 0) + (addedTime ?? 0);

  return (
    <MultiPartProgressBar
      now={current}
-      complete={duration}
+      complete={totalTime}
      normalColor={viewSettings.normalColor}
      warning={timeWarning}
      warningColor={viewSettings.warningColor}
@@ -33,7 +33,6 @@ function _EditorOverview({ children }: { children: React.ReactNode }) {
            <TimeRow label='Actual start' value={formatedTime(actualStart)} className={style.start} />
          </div>
          <ProgressOverview />
-          <CurrentBlockOverview />
          <RuntimeOverview />
          <div>
            <TimeRow label='Planned end' value={plannedEndText} className={style.end} daySpan={maybePlannedDaySpan} />
@@ -95,14 +94,6 @@ function TitlesOverview() {
  );
 }

-function CurrentBlockOverview() {
-  const { currentBlock, clock } = useRuntimePlaybackOverview();
-
-  const timeInBlock = formatedTime(currentBlock.startedAt === null ? null : clock - currentBlock.startedAt);
-
-  return <TimeColumn label='Time in block' value={timeInBlock} className={style.clock} />;
-}
-
 function TimerOverview() {
  const { current } = useTimer();

@@ -2,24 +2,8 @@ import { Fragment, lazy, useCallback, useEffect, useRef, useState } from 'react'
 import { closestCenter, DndContext, DragEndEvent, PointerSensor, useSensor, useSensors } from '@dnd-kit/core';
 import { arrayMove, SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable';
 import { useHotkeys } from '@mantine/hooks';
-import {
-  isOntimeBlock,
-  isOntimeEvent,
-  isPlayableEvent,
-  PlayableEvent,
-  Playback,
-  RundownCached,
-  SupportedEvent,
-} from 'ontime-types';
-import {
-  getFirstNormal,
-  getLastNormal,
-  getNextBlockNormal,
-  getNextNormal,
-  getPreviousBlockNormal,
-  getPreviousNormal,
-  isNewLatest,
-} from 'ontime-utils';
+import { isOntimeEvent, MaybeNumber, Playback, RundownCached, SupportedEvent } from 'ontime-types';
+import { getFirstNormal, getLastNormal, getNextNormal, getPreviousNormal } from 'ontime-utils';

 import { useEventAction } from '../../common/hooks/useEventAction';
 import useFollowComponent from '../../common/hooks/useFollowComponent';
@@ -114,61 +98,28 @@ export default function Rundown({ data }: RundownProps) {
    [rundown, order, addEvent],
  );

-  const selectBlock = useCallback(
-    (cursor: string | null, direction: 'up' | 'down') => {
-      if (order.length < 1) {
-        return;
-      }
-      let newCursor = cursor;
-      if (cursor === null) {
-        // there is no cursor, we select the first or last depending on direction
-        const selected = direction === 'up' ? getLastNormal(rundown, order) : getFirstNormal(rundown, order);
-
-        if (isOntimeBlock(selected)) {
-          setSelectedEvents({ id: selected.id, selectMode: 'click', index: direction === 'up' ? order.length : 0 });
-          return;
-        }
-        newCursor = selected?.id ?? null;
-      }
-
-      if (newCursor === null) {
-        return;
-      }
-
-      // otherwise we select the next or previous
-      const selected =
-        direction === 'up'
-          ? getPreviousBlockNormal(rundown, order, newCursor)
-          : getNextBlockNormal(rundown, order, newCursor);
-
-      if (selected.entry !== null && selected.index !== null) {
-        setSelectedEvents({ id: selected.entry.id, selectMode: 'click', index: selected.index });
-      }
-    },
-    [order, rundown, setSelectedEvents],
-  );
-
  const selectEntry = useCallback(
    (cursor: string | null, direction: 'up' | 'down') => {
      if (order.length < 1) {
        return;
      }
-
+      let newCursor: string | null;
+      let newIndex: number | null;
      if (cursor === null) {
        // there is no cursor, we select the first or last depending on direction if it exists
-        const selected = direction === 'up' ? getLastNormal(rundown, order) : getFirstNormal(rundown, order);
-        if (selected !== null) {
-          setSelectedEvents({ id: selected.id, selectMode: 'click', index: direction === 'up' ? order.length : 0 });
-        }
-        return;
+        newCursor =
+          (direction === 'up' ? getLastNormal(rundown, order)?.id : getFirstNormal(rundown, order)?.id) ?? null;
+        newIndex = direction === 'up' ? order.length : 0;
+      } else {
+        // otherwise we select the next or previous
+        const selected =
+          direction === 'up' ? getPreviousNormal(rundown, order, cursor) : getNextNormal(rundown, order, cursor);
+        newCursor = selected.entry?.id ?? null;
+        newIndex = selected.index;
      }

-      // otherwise we select the next or previous
-      const selected =
-        direction === 'up' ? getPreviousNormal(rundown, order, cursor) : getNextNormal(rundown, order, cursor);
-
-      if (selected.entry !== null && selected.index !== null) {
-        setSelectedEvents({ id: selected.entry.id, selectMode: 'click', index: selected.index });
+      if (newCursor && newIndex !== null) {
+        setSelectedEvents({ id: newCursor, selectMode: 'click', index: newIndex });
      }
    },
    [order, rundown, setSelectedEvents],
@@ -194,10 +145,6 @@ export default function Rundown({ data }: RundownProps) {
  useHotkeys([
    ['alt + ArrowDown', () => selectEntry(cursor, 'down'), { preventDefault: true }],
    ['alt + ArrowUp', () => selectEntry(cursor, 'up'), { preventDefault: true }],
-
-    ['alt + shift + ArrowDown', () => selectBlock(cursor, 'down'), { preventDefault: true }],
-    ['alt + shift + ArrowUp', () => selectBlock(cursor, 'up'), { preventDefault: true }],
-
    ['alt + mod + ArrowDown', () => moveEntry(cursor, 'down'), { preventDefault: true }],
    ['alt + mod + ArrowUp', () => moveEntry(cursor, 'up'), { preventDefault: true }],

@@ -256,9 +203,11 @@ export default function Rundown({ data }: RundownProps) {
    return <RundownEmpty handleAddNew={() => insertAtId(SupportedEvent.Event, cursor)} />;
  }

-  let lastEntry: PlayableEvent | undefined; // used by indicators
-  let thisEntry: PlayableEvent | undefined;
+  let previousStart: MaybeNumber = null;
+  let previousEnd: MaybeNumber = null;
  let previousEventId: string | undefined;
+  let thisStart: MaybeNumber = null;
+  let thisEnd: MaybeNumber = null;
  let thisId = previousEventId;

  let eventIndex = 0;
@@ -286,14 +235,13 @@ export default function Rundown({ data }: RundownProps) {
              if (isOntimeEvent(event)) {
                // event indexes are 1 based in frontend
                eventIndex++;
+                previousStart = thisStart;
+                previousEnd = thisEnd;
                previousEventId = thisId;
-                lastEntry = thisEntry;

-                if (isPlayableEvent(event)) {
-                  // populate previous entry
-                  if (isNewLatest(event.timeStart, event.timeEnd, lastEntry?.timeStart, lastEntry?.timeEnd)) {
-                    thisEntry = event;
-                  }
+                if (!event.skip) {
+                  thisStart = event.timeStart;
+                  thisEnd = event.timeEnd;
                  thisId = eventId;
                }
              }
@@ -320,8 +268,8 @@ export default function Rundown({ data }: RundownProps) {
                        loaded={isLoaded}
                        hasCursor={hasCursor}
                        isNext={isNext}
-                        previousStart={lastEntry?.timeStart}
-                        previousEnd={lastEntry?.timeEnd}
+                        previousStart={previousStart}
+                        previousEnd={previousEnd}
                        previousEventId={previousEventId}
                        playback={isLoaded ? featureData.playback : undefined}
                        isRolling={featureData.playback === Playback.Roll}
@@ -1,5 +1,5 @@
 import { useCallback } from 'react';
-import { OntimeEvent, OntimeRundownEntry, Playback, SupportedEvent } from 'ontime-types';
+import { MaybeNumber, OntimeEvent, OntimeRundownEntry, Playback, SupportedEvent } from 'ontime-types';

 import { useEventAction } from '../../common/hooks/useEventAction';
 import useMemoisedFn from '../../common/hooks/useMemoisedFn';
@@ -32,8 +32,8 @@ interface RundownEntryProps {
  eventIndex: number;
  hasCursor: boolean;
  isNext: boolean;
-  previousStart?: number;
-  previousEnd?: number;
+  previousStart: MaybeNumber;
+  previousEnd: MaybeNumber;
  previousEventId?: string;
  playback?: Playback; // we only care about this if this event is playing
  isRolling: boolean; // we need to know even if not related to this event
@@ -8,7 +8,7 @@ import { IoPeopleOutline } from '@react-icons/all-files/io5/IoPeopleOutline';
 import { IoReorderTwo } from '@react-icons/all-files/io5/IoReorderTwo';
 import { IoSwapVertical } from '@react-icons/all-files/io5/IoSwapVertical';
 import { IoTrash } from '@react-icons/all-files/io5/IoTrash';
-import { EndAction, MaybeString, OntimeEvent, Playback, TimerType, TimeStrategy } from 'ontime-types';
+import { EndAction, MaybeNumber, MaybeString, OntimeEvent, Playback, TimerType, TimeStrategy } from 'ontime-types';

 import { useContextMenu } from '../../../common/hooks/useContextMenu';
 import { cx, getAccessibleColour } from '../../../common/utils/styleUtils';
@@ -36,8 +36,8 @@ interface EventBlockProps {
  title: string;
  note: string;
  delay: number;
-  previousStart?: number;
-  previousEnd?: number;
+  previousStart: MaybeNumber;
+  previousEnd: MaybeNumber;
  colour: string;
  isPast: boolean;
  isNext: boolean;
@@ -1,13 +1,5 @@
-import {
-  calculateDuration,
-  checkIsNextDay,
-  dayInMs,
-  getTimeFromPrevious,
-  millisToString,
-  removeTrailingZero,
-} from 'ontime-utils';
-
-import { formatDuration } from '../../../common/utils/time';
+import { MaybeNumber } from 'ontime-types';
+import { checkIsNextDay, dayInMs, millisToString, removeLeadingZero, removeTrailingZero } from 'ontime-utils';

 export function formatDelay(timeStart: number, delay: number): string | undefined {
  if (!delay) return;
@@ -18,24 +10,31 @@ export function formatDelay(timeStart: number, delay: number): string | undefine
  return `New start ${timeTag}`;
 }

-export function formatOverlap(timeStart: number, previousStart?: number, previousEnd?: number): string | undefined {
-  const noPreviousElement = previousEnd === undefined || previousStart === undefined;
+export function formatOverlap(
+  previousStart: MaybeNumber,
+  previousEnd: MaybeNumber,
+  timeStart: number,
+): string | undefined {
+  const noPreviousElement = previousEnd === null || previousStart === null;
  if (noPreviousElement) return;

-  const normalisedDuration = calculateDuration(previousStart, previousEnd);
-  const timeFromPrevious = getTimeFromPrevious(timeStart, previousStart, previousEnd, normalisedDuration);
-  if (timeFromPrevious === 0) return;
+  const overlap = previousEnd - timeStart;
+  if (overlap === 0) return;

-  if (checkIsNextDay(previousStart, timeStart, normalisedDuration)) {
-    const previousCrossMidnight = previousStart > previousEnd;
-    const normalisedPreviousEnd = previousCrossMidnight ? previousEnd + dayInMs : previousEnd;
+  const previousCrossMidnight = previousStart > previousEnd;
+  const isNextDay = previousCrossMidnight
+    ? checkIsNextDay(previousEnd, timeStart) || previousEnd == 0 // exception for when previousEnd is precisely midnight
+    : checkIsNextDay(previousStart, timeStart);

-    const gap = dayInMs - normalisedPreviousEnd + timeStart;
+  const correctedPreviousEnd = previousCrossMidnight ? previousEnd + dayInMs : previousEnd;
+
+  if (isNextDay) {
+    const gap = dayInMs - correctedPreviousEnd + timeStart;
    if (gap === 0) return;
-    const gapString = formatDuration(Math.abs(gap), false);
+    const gapString = removeLeadingZero(millisToString(Math.abs(gap)));
    return `Gap ${gapString} (next day)`;
  }

-  const overlapString = formatDuration(Math.abs(timeFromPrevious), false);
-  return `${timeFromPrevious < 0 ? 'Overlap' : 'Gap'} ${overlapString}`;
+  const overlapString = removeLeadingZero(millisToString(Math.abs(overlap)));
+  return `${overlap > 0 ? 'Overlap' : 'Gap'} ${overlapString}`;
 }
@@ -21,6 +21,10 @@ import EventBlockProgressBar from './composite/EventBlockProgressBar';

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

+const tooltipProps = {
+  openDelay: tooltipDelayMid,
+};
+
 interface EventBlockInnerProps {
  timeStart: number;
  timeEnd: number;
@@ -94,7 +98,11 @@ const EventBlockInner = (props: EventBlockInnerProps) => {
      </div>
      <div className={style.titleSection}>
        <EditableBlockTitle title={title} eventId={eventId} placeholder='Event title' className={style.eventTitle} />
-        {isNext && <span className={style.nextTag}>UP NEXT</span>}
+        {isNext && (
+          <Tooltip label='Next event' {...tooltipProps}>
+            <span className={style.nextTag}>UP NEXT</span>
+          </Tooltip>
+        )}
      </div>
      <EventBlockPlayback
        eventId={eventId}
@@ -110,17 +118,17 @@ const EventBlockInner = (props: EventBlockInnerProps) => {
          {loaded && <EventBlockProgressBar />}
        </div>
        <div className={style.eventStatus} tabIndex={-1}>
-          <Tooltip label={`Time type: ${timerType}`} openDelay={tooltipDelayMid}>
+          <Tooltip label={`Time type: ${timerType}`} {...tooltipProps}>
            <span>
              <TimerIcon type={timerType} className={style.statusIcon} />
            </span>
          </Tooltip>
-          <Tooltip label={`End action: ${endAction}`} openDelay={tooltipDelayMid}>
+          <Tooltip label={`End action: ${endAction}`} {...tooltipProps}>
            <span>
              <EndActionIcon action={endAction} className={style.statusIcon} />
            </span>
          </Tooltip>
-          <Tooltip label={`${isPublic ? 'Event is public' : 'Event is private'}`} openDelay={tooltipDelayMid}>
+          <Tooltip label={`${isPublic ? 'Event is public' : 'Event is private'}`} {...tooltipProps}>
            <span>
              <IoPeople className={`${style.statusIcon} ${isPublic ? style.active : style.disabled}`} />
            </span>
@@ -1,18 +1,20 @@
+import { MaybeNumber } from 'ontime-types';
+
 import { formatDelay, formatOverlap } from './EventBlock.utils';

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

 interface RundownIndicatorProps {
  timeStart: number;
-  previousStart?: number;
-  previousEnd?: number;
+  previousStart: MaybeNumber;
+  previousEnd: MaybeNumber;
  delay: number;
 }

 export default function RundownIndicators(props: RundownIndicatorProps) {
  const { timeStart, previousStart, previousEnd, delay } = props;

-  const hasOverlap = formatOverlap(timeStart, previousStart, previousEnd);
+  const hasOverlap = formatOverlap(previousStart, previousEnd, timeStart);
  const hasDelay = formatDelay(timeStart, delay);

  return (
@@ -16,63 +16,47 @@ describe('formatOverlap()', () => {
    const previousStart = 0;
    const previousEnd = 60000; // 1 min
    const timeStart = 30000; // 30 sec
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toEqual('Overlap 30s');
+    const result = formatOverlap(previousStart, previousEnd, timeStart);
+    expect(result).toEqual('Overlap 0:30');
  });

  it('bug #949 recognises an overlap between two times', () => {
    const previousStart = 46800000; // 13:00:00
    const previousEnd = 48600000; // 13:30:00
    const timeStart = 48300000; // 13:25:00
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toEqual('Overlap 5m');
+    const result = formatOverlap(previousStart, previousEnd, timeStart);
+    expect(result).toEqual('Overlap 5:00');
  });

  it('handles events the day after, without overlap', () => {
    const previousStart = 11 * MILLIS_PER_HOUR;
    const previousEnd = 12 * MILLIS_PER_HOUR;
    const timeStart = 6 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Gap 18h (next day)');
+    const result = formatOverlap(previousStart, previousEnd, timeStart);
+    expect(result).toBe('Gap 18:00:00 (next day)');
  });

  it('handles events the day after, with gap', () => {
    const previousStart = 17 * MILLIS_PER_HOUR;
    const previousEnd = 23 * MILLIS_PER_HOUR;
    const timeStart = 9 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Gap 10h (next day)');
+    const result = formatOverlap(previousStart, previousEnd, timeStart);
+    expect(result).toBe('Gap 10:00:00 (next day)');
  });

  it('handles events the day after, with previous ending at midnight', () => {
    const previousStart = 23 * MILLIS_PER_HOUR; // 23:00:00
    const previousEnd = 0; // 00:00:00
    const timeStart = 1 * MILLIS_PER_HOUR; // 01:00:00
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Gap 1h (next day)');
+    const result = formatOverlap(previousStart, previousEnd, timeStart);
+    expect(result).toBe('Gap 01:00:00 (next day)');
  });

-  it('handles sequential events the day after, with previous ending over midnight', () => {
-    const previousStart = 23 * MILLIS_PER_HOUR;
-    const previousEnd = 1 * MILLIS_PER_HOUR;
-    const timeStart = 1 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBeUndefined();
-  });
-
-  it('handles events the day after, with previous ending over midnight with overlap', () => {
-    const previousStart = 23 * MILLIS_PER_HOUR;
-    const previousEnd = 2 * MILLIS_PER_HOUR;
-    const timeStart = 1 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Overlap 1h');
-  });
-
-  it('handles events the day after, with previous ending over midnight with gap', () => {
+  it('handles events the day after, with previous ending over midnight', () => {
    const previousStart = 23 * MILLIS_PER_HOUR;
    const previousEnd = 1 * MILLIS_PER_HOUR;
    const timeStart = 2 * MILLIS_PER_HOUR;
-    const result = formatOverlap(timeStart, previousStart, previousEnd);
-    expect(result).toBe('Gap 1h');
+    const result = formatOverlap(previousStart, previousEnd, timeStart);
+    expect(result).toBe('Gap 01:00:00');
  });
 });
@@ -1,12 +1,29 @@
+import { MaybeNumber } from 'ontime-types';
+
 import { useTimer } from '../../../../common/hooks/useSocket';
-import { getProgress } from '../../../../common/utils/getProgress';
+import { clamp } from '../../../../common/utils/math';

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

+export function getPercentComplete(remaining: MaybeNumber, total: MaybeNumber): number {
+  if (remaining === null || total === null) {
+    return 0;
+  }
+
+  if (remaining <= 0) {
+    return 100;
+  }
+
+  if (remaining === total) {
+    return 0;
+  }
+
+  return clamp(100 - (remaining * 100) / total, 0, 100);
+}
+
 export default function EventBlockProgressBar() {
  const timer = useTimer();

-  const progress = getProgress(timer.current, timer.duration);
-
-  return <div className={style.progressBar} style={{ width: `${progress}%` }} />;
+  const progress = `${getPercentComplete(timer.current, timer.duration)}%`;
+  return <div className={style.progressBar} style={{ width: progress }} />;
 }
@@ -0,0 +1,27 @@
+import { dayInMs } from 'ontime-utils';
+
+import { getPercentComplete } from '../EventBlockProgressBar';
+
+describe('getPercentComplete()', () => {
+  describe('calculates progress in normal cases', () => {
+    const testScenarios = [
+      { current: 0, duration: 0, expect: 100 },
+      { current: 0, duration: 100, expect: 100 },
+      { current: 0, duration: dayInMs, expect: 100 },
+      { current: 10, duration: 100, expect: 90 },
+      { current: 50, duration: 100, expect: 50 },
+      { current: 100, duration: 100, expect: 0 },
+    ];
+
+    testScenarios.forEach((testCase) => {
+      it(`handles ${testCase.current} / ${testCase.duration}`, () => {
+        const progress = getPercentComplete(testCase.current, testCase.duration);
+        expect(progress).toBe(testCase.expect);
+      });
+    });
+  });
+  it('is 0 if we dont have a current or duration', () => {
+    const progress = getPercentComplete(null, null);
+    expect(progress).toBe(0);
+  });
+});
@@ -28,7 +28,6 @@
    }
    td:nth-child(even) {
      text-align: right;
-      white-space: nowrap;
    }
  }
 }
@@ -24,18 +24,6 @@ function EventEditorEmpty() {
                <Kbd>↓</Kbd>
              </td>
            </tr>
-            <tr>
-              <td>Select block</td>
-              <td>
-                <Kbd>{deviceAlt}</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>Shift</Kbd>
-                <AuxKey>+</AuxKey>
-                <Kbd>↑</Kbd>
-                <AuxKey>/</AuxKey>
-                <Kbd>↓</Kbd>
-              </td>
-            </tr>
            <tr>
              <td>Deselect entry</td>
              <td>
@@ -6,14 +6,14 @@ import { EditorUpdateFields } from '../EventEditor';

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

-interface EventTextInputProps extends InputProps {
+interface CountedTextInputProps extends InputProps {
  field: EditorUpdateFields;
  label: string;
  initialValue: string;
  submitHandler: (field: EditorUpdateFields, value: string) => void;
 }

-export default function EventTextInput(props: EventTextInputProps) {
+export default function EventTextInput(props: CountedTextInputProps) {
  const { field, label, initialValue, submitHandler, maxLength } = props;
  const ref = useRef<HTMLInputElement | null>(null);
  const submitCallback = useCallback((newValue: string) => submitHandler(field, newValue), [field, submitHandler]);
@@ -34,7 +34,7 @@ export default function EventTextInput(props: EventTextInputProps) {
        variant='ontime-filled'
        data-testid='input-textfield'
        value={value}
-        maxLength={maxLength || 100}
+        maxLength={maxLength || 50}
        onChange={onChange}
        onBlur={onBlur}
        onKeyDown={onKeyDown}
@@ -0,0 +1,72 @@
+$timeline-entry-height: 20px;
+
+.timeline {
+  flex: 1;
+}
+
+.timelineEvents {
+  position: relative;
+}
+
+.entryIndicator {
+  position: absolute;
+  background-color: var(--color, $ui-white);
+  height: $timeline-entry-height;
+}
+
+.entryContent {
+  position: absolute;
+  margin-top: $timeline-entry-height;
+  padding-top: var(--top, 0);
+  border-left: 2px solid var(--color, $ui-white);
+
+  color: $ui-white;
+
+  white-space: nowrap;
+
+  > div {
+    min-width: 100%;
+    padding-inline: 0.5em;
+    width: fit-content;
+    background-color: $ui-black;
+  }
+
+  &.lastElement {
+    border-left: none;
+    border-right: 2px solid var(--color, $ui-black);
+    text-align: right;
+
+    transform: translateX(-100%);
+  }
+}
+
+.start,
+.title {
+  font-weight: 600;
+}
+
+// for elapsed events, we can hide some stuff
+[data-status='finished'] {
+  color: $gray-500;
+  .status {
+    display: none
+  }
+}
+
+[data-status='live'] {
+  font-weight: 600;
+  color: $ui-white;
+
+  .status {
+    color: $active-red;
+  }
+}
+
+[data-status='future'] {
+  font-weight: 600;
+  color: $gray-300;
+
+  .status {
+    color: $green-500;
+  }
+}
@@ -0,0 +1,121 @@
+import { memo } from 'react';
+import { useViewportSize } from '@mantine/hooks';
+import { isOntimeEvent, MaybeNumber } from 'ontime-types';
+import { dayInMs, getFirstEventNormal, getLastEventNormal, MILLIS_PER_HOUR } from 'ontime-utils';
+
+import useRundown from '../../../common/hooks-query/useRundown';
+
+import { type ProgressStatus, TimelineEntry } from './TimelineEntry';
+import { TimelineMarkers } from './TimelineMarkers';
+import { ProgressBar } from './TimelineProgressBar';
+import { getElementPosition, getEndHour, getEstimatedWidth, getLaneLevel, getStartHour } from './timelineUtils';
+
+import style from './Timeline.module.scss';
+
+export default memo(Timeline);
+
+function useTimeline() {
+  const { data } = useRundown();
+  if (data.revision === -1) {
+    return null;
+  }
+
+  const { firstEvent } = getFirstEventNormal(data.rundown, data.order);
+  const { lastEvent } = getLastEventNormal(data.rundown, data.order);
+  const firstStart = firstEvent?.timeStart ?? 0;
+  const lastEnd = lastEvent?.timeEnd ?? 0;
+  const normalisedLastEnd = lastEnd < firstStart ? lastEnd + dayInMs : lastEnd;
+
+  // timeline is padded to nearest hours (floor and ceil)
+  const startHour = getStartHour(firstStart) * MILLIS_PER_HOUR;
+  const endHour = getEndHour(normalisedLastEnd) * MILLIS_PER_HOUR;
+
+  return {
+    rundown: data.rundown,
+    order: data.order,
+    startHour,
+    endHour,
+  };
+}
+
+interface TimelineProps {
+  selectedEventId: string | null;
+}
+
+function Timeline(props: TimelineProps) {
+  const { selectedEventId } = props;
+  const { width: screenWidth } = useViewportSize();
+  const timelineData = useTimeline();
+
+  if (timelineData === null) {
+    return null;
+  }
+
+  const { rundown, order, startHour, endHour } = timelineData;
+
+  let hasTimelinePassedMidnight = false;
+  let previousEventStartTime: MaybeNumber = null;
+  let eventStatus: ProgressStatus = 'finished';
+  // a list of the right most element for each lane
+  const rightMostElements: Record<number, number> = {};
+
+  return (
+    <div className={style.timeline}>
+      <TimelineMarkers />
+      <div className={style.timelineEvents}>
+        {order.map((eventId) => {
+          // for now we dont render delays and blocks
+          const event = rundown[eventId];
+          if (!isOntimeEvent(event)) {
+            return null;
+          }
+
+          // keep track of progress of rundown
+          if (eventStatus === 'live') {
+            eventStatus = 'future';
+          }
+          if (eventId === selectedEventId) {
+            eventStatus = 'live';
+          }
+
+          // we need to offset the start to account for midnight
+          if (!hasTimelinePassedMidnight) {
+            hasTimelinePassedMidnight = previousEventStartTime !== null && event.timeStart < previousEventStartTime;
+          }
+          const normalisedStart = hasTimelinePassedMidnight ? event.timeStart + dayInMs : event.timeStart;
+          previousEventStartTime = normalisedStart;
+
+          const { left: elementLeftPosition, width: elementWidth } = getElementPosition(
+            startHour,
+            endHour,
+            normalisedStart,
+            event.duration,
+            screenWidth,
+          );
+          const estimatedRightPosition = elementLeftPosition + getEstimatedWidth(event.title);
+          const laneLevel = getLaneLevel(rightMostElements, elementLeftPosition);
+
+          if (rightMostElements[laneLevel] === undefined || rightMostElements[laneLevel] < estimatedRightPosition) {
+            rightMostElements[laneLevel] = estimatedRightPosition;
+          }
+
+          return (
+            <TimelineEntry
+              key={eventId}
+              colour={event.colour}
+              duration={event.duration}
+              isLast={eventId === order[order.length - 1]}
+              lane={laneLevel}
+              left={elementLeftPosition}
+              status={eventStatus}
+              start={event.timeStart}
+              title={event.title}
+              width={elementWidth}
+            />
+          );
+        })}
+      </div>
+      <ProgressBar startHour={startHour} endHour={endHour} />
+    </div>
+  );
+}
@@ -0,0 +1,78 @@
+import { useClock } from '../../../common/hooks/useSocket';
+import { cx } from '../../../common/utils/styleUtils';
+import { formatDuration, formatTime } from '../../../common/utils/time';
+
+import { getStatusLabel } from './timelineUtils';
+
+import style from './Timeline.module.scss';
+
+export type ProgressStatus = 'finished' | 'live' | 'future';
+
+interface TimelineEntry {
+  colour: string;
+  duration: number;
+  isLast: boolean;
+  lane: number;
+  left: number;
+  status: ProgressStatus;
+  start: number;
+  title: string;
+  width: number;
+}
+
+const laneHeight = 120;
+const formatOptions = {
+  format12: 'hh:mm a',
+  format24: 'HH:mm',
+};
+
+export function TimelineEntry(props: TimelineEntry) {
+  const { colour, duration, isLast, lane, left, status, start, title, width } = props;
+
+  const formattedStartTime = formatTime(start, formatOptions);
+  const formattedDuration = `Dur ${formatDuration(duration)}`;
+
+  const contentClasses = cx([style.entryContent, isLast && style.lastElement]);
+
+  return (
+    <>
+      <div
+        className={style.entryIndicator}
+        style={{
+          '--color': colour,
+          left: `${left}px`,
+          width: `${width}px`,
+        }}
+      />
+      <div
+        className={contentClasses}
+        data-status={status}
+        style={{
+          '--color': colour,
+          '--top': `${lane * laneHeight}px`,
+          zIndex: 5 - lane,
+          left: `${left}px`,
+        }}
+      >
+        <div className={style.start}>{formattedStartTime}</div>
+        <div className={style.title}>{title}</div>
+        <div className={style.duration}>{formattedDuration}</div>
+        <TimelineEntryStatus status={status} start={start} />
+      </div>
+    </>
+  );
+}
+
+interface TimelineEntryStatusProps {
+  status: ProgressStatus;
+  start: number;
+}
+// we isolate this component to avoid re-rendering too many elements
+function TimelineEntryStatus(props: TimelineEntryStatusProps) {
+  const { status, start } = props;
+  // TODO: account for offset instead of just using the clock
+  const { clock } = useClock();
+  const statusText = getStatusLabel(start - clock, status);
+
+  return <div className={style.status}>{statusText}</div>;
+}
@@ -1,16 +1,19 @@
 .markers {
  width: 100%;
  color: $ui-white;
+  background-color: $white-10;
  display: flex;
  height: 1rem;
  line-height: 1rem;
-  margin-bottom: 0.25rem;
  font-size: calc(1rem - 2px);
  justify-content: space-evenly;
+  text-align: center;

-  & > span {
+  & > * {
    flex-grow: 1;
-    border-left: 1px solid $white-7;
-    height: 100vh;
+  }
+
+  :nth-child(odd) {
+    background-color: $white-20;
  }
 }
@@ -0,0 +1,23 @@
+import useRundown from '../../../common/hooks-query/useRundown';
+
+import { getTimelineSections } from './timelineUtils';
+
+import style from './TimelineMarkers.module.scss';
+
+export function TimelineMarkers() {
+  const { data } = useRundown();
+
+  if (data.revision === -1) {
+    return null;
+  }
+
+  const elements = getTimelineSections(data.rundown, data.order);
+
+  return (
+    <div className={style.markers}>
+      {elements.map((tag, index) => {
+        return <span key={index}>{tag}</span>;
+      })}
+    </div>
+  );
+}
@@ -0,0 +1,8 @@
+.progressBar {
+  position: relative;
+  height: 100%;
+  border-right: 2px solid $active-red;
+
+  transition-duration: 0.3s;
+  transition-property: left;
+}
@@ -0,0 +1,19 @@
+import { useClock } from '../../../common/hooks/useSocket';
+
+import { getRelativePositionX } from './timelineUtils';
+
+import style from './TimelineProgressBar.module.scss';
+
+interface ProgressBarProps {
+  startHour: number;
+  endHour: number;
+}
+
+export function ProgressBar(props: ProgressBarProps) {
+  const { startHour, endHour } = props;
+  const { clock } = useClock();
+
+  const left = getRelativePositionX(startHour, endHour, clock);
+
+  return <div className={style.progressBar} style={{ width: `${left}%` }} />;
+}
@@ -1,6 +1,6 @@
 import { dayInMs } from 'ontime-utils';

-import { getElementPosition, makeTimelineSections } from '../timeline.utils';
+import { getElementPosition, getLaneLevel } from '../timelineUtils';

 describe('getCSSPosition()', () => {
  it('accounts for rundown with one event', () => {
@@ -53,14 +53,32 @@ describe('getCSSPosition()', () => {
  });
 });

-describe('makeTmelineSections', () => {
-  it('creates an array between the hours given, end excluded', () => {
-    const result = makeTimelineSections(11, 17);
-    expect(result).toEqual(['11:00', '12:00', '13:00', '14:00', '15:00', '16:00']);
+describe('getLaneLevel()', () => {
+  it('should place in lane 0 if there is no overlap', () => {
+    const rightMostElements = { 0: 50 };
+    const left = 60;
+    const result = getLaneLevel(rightMostElements, left);
+    expect(result).toBe(0);
  });

-  it('wraps around midnight', () => {
-    const result = makeTimelineSections(22, 26);
-    expect(result).toEqual(['22:00', '23:00', '00:00', '01:00']);
+  it('should place in next available lane if there is overlap', () => {
+    const rightMostElements = { 0: 150, 1: 100 };
+    const left = 120;
+    const result = getLaneLevel(rightMostElements, left);
+    expect(result).toBe(1);
+  });
+
+  it('should create a new lane if all existing lanes are overlapped', () => {
+    const rightMostElements = { 0: 200, 1: 250 };
+    const left = 150;
+    const result = getLaneLevel(rightMostElements, left);
+    expect(result).toBe(2);
+  });
+
+  it('should place in lane 0 if it is the first event', () => {
+    const rightMostElements = {};
+    const left = 0;
+    const result = getLaneLevel(rightMostElements, left);
+    expect(result).toBe(0);
  });
 });
@@ -0,0 +1,154 @@
+import { isOntimeEvent, MaybeString, NormalisedRundown, OntimeEvent } from 'ontime-types';
+import {
+  dayInMs,
+  getByEventId,
+  getFirstEvent,
+  getFirstEventNormal,
+  getLastEventNormal,
+  getNextEvent,
+  MILLIS_PER_HOUR,
+  millisToString,
+  removeSeconds,
+} from 'ontime-utils';
+
+import { clamp } from '../../../common/utils/math';
+import { formatDuration } from '../../../common/utils/time';
+
+import type { ProgressStatus } from './TimelineEntry';
+
+type CSSPosition = {
+  left: number;
+  width: number;
+};
+
+/**
+ * Calculates the position (in %) of an element relative to a schedule
+ */
+export function getRelativePositionX(scheduleStart: number, scheduleEnd: number, now: number): number {
+  return clamp(((now - scheduleStart) / (scheduleEnd - scheduleStart)) * 100, 0, 100);
+}
+
+/**
+ * Estimates the width of an element based on its content
+ */
+export function getEstimatedWidth(content: string): number {
+  // use 8 as minimum width to account for duration string
+  // 12 is a rough estimate of the width of a character at 15px font size
+  return Math.max(content.length, 8) * 12;
+}
+/**
+ * Calculates an absolute position of an element based on a schedule
+ */
+export function getElementPosition(
+  scheduleStart: number,
+  scheduleEnd: number,
+  eventStart: number,
+  eventDuration: number,
+  containerWidth: number,
+): CSSPosition {
+  // TODO: events that finish at midnight have lastEnd 0
+  const totalDuration = scheduleEnd - scheduleStart;
+  const width = (eventDuration * containerWidth) / totalDuration;
+  const left = ((eventStart - scheduleStart) * containerWidth) / totalDuration;
+
+  return { left, width };
+}
+
+export function getStartHour(startTime: number): number {
+  const hours = Math.floor(startTime / MILLIS_PER_HOUR);
+  return hours;
+}
+
+export function getEndHour(endTime: number): number {
+  const hours = Math.ceil(endTime / MILLIS_PER_HOUR);
+  return hours;
+}
+
+export function makeTimelineSections(firstHour: number, lastHour: number) {
+  const timelineSections = [];
+  for (let i = firstHour; i < lastHour; i++) {
+    timelineSections.push(removeSeconds(millisToString(i * MILLIS_PER_HOUR)));
+  }
+  return timelineSections;
+}
+
+// TODO: account for elapsed days
+export function getTimelineSections(rundown: NormalisedRundown, order: string[]): string[] {
+  if (order.length === 0) {
+    return [];
+  }
+  const { firstEvent } = getFirstEventNormal(rundown, order);
+  const { lastEvent } = getLastEventNormal(rundown, order);
+  const firstStart = firstEvent?.timeStart ?? 0;
+  const lastEnd = lastEvent?.timeEnd ?? 0;
+  const normalisedLastEnd = lastEnd < firstStart ? lastEnd + dayInMs : lastEnd;
+
+  const startHour = getStartHour(firstStart);
+  const endHour = getEndHour(normalisedLastEnd);
+
+  const elements = makeTimelineSections(startHour, endHour);
+  return elements;
+}
+
+const MAX_DEPTH = 5;
+
+/**
+ * Estimates the top offset for an element
+ */
+export function getLaneLevel(rightMostElements: Record<number, number>, left: number): number {
+  for (let checkLane = 0; checkLane < MAX_DEPTH; checkLane++) {
+    if (rightMostElements[checkLane] === undefined) {
+      return checkLane;
+    }
+    if (rightMostElements[checkLane] < left) {
+      return checkLane;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Returns a formatted label for a progress status
+ */
+export function getStatusLabel(timeToStart: number, status: ProgressStatus): string {
+  if (status === 'finished' || status === 'live') {
+    return status;
+  }
+
+  if (timeToStart < 0) {
+    return 'T - 0';
+  }
+
+  return `T - ${formatDuration(timeToStart)}`;
+}
+
+type UpcomingEvents = {
+  now: MaybeString;
+  next: MaybeString;
+  followedBy: MaybeString;
+};
+
+/**
+ * Returns upcoming events from current: now, next and followedBy
+ */
+export function getUpcomingEvents(events: OntimeEvent[], selectedId: MaybeString): UpcomingEvents {
+  if (events.length === 0) {
+    return { now: null, next: null, followedBy: null };
+  }
+
+  const nowEvent = selectedId ? getByEventId(events, selectedId) : getFirstEvent(events)?.firstEvent;
+
+  if (!isOntimeEvent(nowEvent)) {
+    return { now: null, next: null, followedBy: null };
+  }
+
+  const nextEvent = getNextEvent(events, nowEvent.id)?.nextEvent;
+  const followedByEvent = nextEvent ? getNextEvent(events, nextEvent.id)?.nextEvent : null;
+
+  // Return the titles, handling nulls appropriately
+  return {
+    now: nowEvent.title,
+    next: nextEvent ? nextEvent.title : null,
+    followedBy: followedByEvent ? followedByEvent.title : null,
+  };
+}
@@ -0,0 +1,51 @@
+.progress {
+  width: 100vw;
+  height: 100vh;
+
+  background-color: $ui-black;
+  color: $ui-white;
+  text-transform: uppercase;
+
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+}
+
+.title {
+  padding-inline: 2rem;
+  text-align: left;
+  font-size: 3.5rem;
+}
+
+.sections {
+  padding-inline: 2rem;
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  row-gap: 1rem;
+  column-gap: 3rem;
+}
+
+.sectionTitle {
+  line-height: 1.2em;
+  font-size: 1.5rem;
+  text-transform: uppercase;
+}
+
+.sectionContent {
+  line-height: 1em;
+  font-size: 3rem;
+  text-transform: uppercase;
+  font-weight: 600;
+
+  &.now {
+    color: $green-500;
+  }
+
+  &.next {
+    color: $red-500;
+  }
+
+  &.subdue {
+    opacity: $opacity-disabled;
+  }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Carlos Valente	815c285f87	bump version to alpha release	2024-06-22 20:17:37 +02:00
Carlos Valente	8aeb4c7a01	feat: progress view	2024-06-22 20:16:09 +02:00