feat(network): add session status card

Display server health metrics from the unused /session endpoint:
- Connected clients count (live from useClientStore)
- Server uptime since last restart
- Last client connection time (relative)
- Last integration request time (relative)
- Server timezone
- Cloud latency (Docker only) with warning threshold

Adds useSessionStats hook with 60s refetch interval, new NetworkStatus
component as first card in Network panel, and navigation menu entries
for Server status and Network interfaces sections.

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NrhcEgY8mqaxZi8veMPrrx

apps/client/src/common/api/constants.ts

@@ -15,6 +15,7 @@ export const RUNDOWN = ['rundown'];
 export const CURRENT_RUNDOWN_QUERY_KEY = ['rundown', 'current'];
 export const getRundownQueryKey = (rundownId: string) => ['rundown', rundownId];
 export const RUNTIME = ['runtimeStore'];
+export const SESSION_STATS = ['sessionStats'];
 export const URL_PRESETS = ['urlpresets'];
 export const VIEW_SETTINGS = ['viewSettings'];
 export const CSS_OVERRIDE = ['cssOverride'];

apps/client/src/common/api/session.ts

@@ -1,11 +1,19 @@
 import axios from 'axios';
-import { GetInfo, LinkOptions } from 'ontime-types';
+import { GetInfo, LinkOptions, SessionStats } from 'ontime-types';
 
 import { apiEntryUrl } from './constants';
 import type { RequestOptions } from './requestOptions';
 
 const sessionPath = `${apiEntryUrl}/session`;
 
+/**
+ * HTTP request to retrieve statistics of the running session
+ */
+export async function getSessionStats(options?: RequestOptions): Promise<SessionStats> {
+  const res = await axios.get(sessionPath, { signal: options?.signal });
+  return res.data;
+}
+
 /**
  * HTTP request to retrieve application info
  */

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

@@ -13,6 +13,9 @@ import Select from '../select/Select';
 
 import style from './RedirectClientModal.module.scss';
 
+/** the first navigator view, used as the initial value of the view select */
+const defaultView = `/${navigatorConstants[0].url}`;
+
 interface RedirectClientModalProps {
   id: string;
   name: string;
@@ -25,7 +28,7 @@ interface RedirectClientModalProps {
 export function RedirectClientModal({ id, isOpen, name, currentPath, origin, onClose }: RedirectClientModalProps) {
   const { data } = useUrlPresets();
   const [path, setPath] = useState(currentPath);
-  const [selected, setSelected] = useState('/');
+  const [selected, setSelected] = useState(defaultView);
 
   const { setRedirect } = setClientRemote;
 
@@ -97,19 +100,18 @@ export function RedirectClientModal({ id, isOpen, name, currentPath, origin, onC
                 <Select
                   fluid
                   options={viewOptions}
-                  defaultValue={viewOptions[0].value}
+                  defaultValue={defaultView}
                   onValueChange={(value) => {
                     if (value === null) return;
                     setSelected(value);
                   }}
-                  disabled={enabledPresets.length === 0}
                 />
               </label>
               <Button
                 variant='primary'
                 aria-label='Redirect to preset'
                 className={style.redirect}
-                disabled={enabledPresets.length === 0 || selected === '/'}
+                disabled={selected === currentPath}
                 onClick={() => handleRedirect(selected)}
               >
                 Redirect <IoArrowForward />

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

@@ -2,6 +2,7 @@ import { useState } from 'react';
 
 import Button from '../../../common/components/buttons/Button';
 import { setClientRemote } from '../../hooks/useSocket';
+import { isKeyEnter } from '../../utils/keyEvent';
 import Dialog from '../dialog/Dialog';
 import Input from '../input/input/Input';
 
@@ -33,7 +34,18 @@ export function RenameClientModal({ id, name: currentName = '', isOpen, onClose
       showCloseButton
       onClose={onClose}
       bodyElements={
-        <Input height='large' placeholder='New name' value={name} onChange={(event) => setName(event.target.value)} />
+        <Input
+          height='large'
+          placeholder='New name'
+          autoFocus
+          value={name}
+          onChange={(event) => setName(event.target.value)}
+          onKeyDown={(event) => {
+            if (isKeyEnter(event) && canSubmit) {
+              handleRename();
+            }
+          }}
+        />
       }
       footerElements={
         <>

apps/client/src/common/components/input/colour-input/SwatchSelect.tsx

@@ -6,8 +6,7 @@ import SwatchPicker from './SwatchPicker';
 import style from './SwatchSelect.module.scss';
 
 interface ColourInputProps {
-  /** undefined represents values which do not agree, no swatch is highlighted */
-  value: string | undefined;
+  value: string;
   name: 'colour';
   handleChange: (newValue: 'colour', name: string) => void;
 }
@@ -45,11 +44,7 @@ export default function SwatchSelect(props: ColourInputProps) {
       {colours.map((colour) => (
         <Swatch key={colour} color={colour} onClick={setColour} isSelected={value === colour} />
       ))}
-      <SwatchPicker
-        color={value ?? ''}
-        onChange={setColour}
-        isSelected={value !== undefined && !colours.includes(value)}
-      />
+      <SwatchPicker color={value} onChange={setColour} isSelected={!colours.includes(value)} />
     </div>
   );
 }

apps/client/src/common/components/input/text-input/__tests__/useReactiveTextInput.test.ts

@@ -1,31 +0,0 @@
-import { shouldSubmitValue } from '../useReactiveTextInput';
-
-describe('shouldSubmitValue()', () => {
-  it('submits a value which differs from the initial value', () => {
-    expect(shouldSubmitValue('new', 'old')).toBe(true);
-  });
-
-  it('does not submit a value which has not changed', () => {
-    expect(shouldSubmitValue('same', 'same')).toBe(false);
-  });
-
-  it('submits an empty value when the initial value is known', () => {
-    // clearing a field which has a value is a valid edit
-    expect(shouldSubmitValue('', 'old')).toBe(true);
-  });
-
-  it('does not submit an empty value when the initial value is unknown', () => {
-    // an unknown value renders as an empty field, submitting it on blur
-    // would overwrite every entry being edited with an empty value
-    expect(shouldSubmitValue('', undefined)).toBe(false);
-  });
-
-  it('submits a typed value when the initial value is unknown', () => {
-    expect(shouldSubmitValue('typed', undefined)).toBe(true);
-  });
-
-  it('submits an unchanged value when the caller opts in', () => {
-    expect(shouldSubmitValue('same', 'same', true)).toBe(true);
-    expect(shouldSubmitValue('', undefined, true)).toBe(true);
-  });
-});

apps/client/src/common/components/input/text-input/useReactiveTextInput.tsx

@@ -1,23 +1,6 @@
 import { HotkeyItem, getHotkeyHandler } from '@mantine/hooks';
 import { ChangeEvent, KeyboardEvent, RefObject, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-/**
- * Whether a value should be sent to the server
- * An undefined initial value means that the value is unknown, for example when several
- * entries are being edited and they do not agree on a value
- * It is shown as an empty field, so submitting it would overwrite data the user has not edited
- */
-export function shouldSubmitValue(
-  valueToSubmit: string,
-  initialText: string | undefined,
-  allowSubmitSameValue?: boolean,
-): boolean {
-  if (allowSubmitSameValue) {
-    return true;
-  }
-  return valueToSubmit !== (initialText ?? '');
-}
-
 interface UseReactiveTextInputReturn {
   value: string;
   onChange: (event: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
@@ -26,8 +9,7 @@ interface UseReactiveTextInputReturn {
 }
 
 export default function useReactiveTextInput(
-  /** undefined represents an unknown value, the field is shown empty and blurring it submits nothing */
-  initialText: string | undefined,
+  initialText: string,
   submitCallback: (newValue: string) => void,
   ref: RefObject<HTMLInputElement | HTMLTextAreaElement | null>,
   options?: {
@@ -40,7 +22,7 @@ export default function useReactiveTextInput(
     allowKeyboardNavigation?: boolean;
   },
 ): UseReactiveTextInputReturn {
-  const [text, setText] = useState<string>(initialText ?? '');
+  const [text, setText] = useState<string>(initialText);
   // track whether we are submitting via a submit key (eg enter) and avoid submitting again on blur
   const isKeyboardSubmitting = useRef(false);
   // track escape to prevent the subsequent blur from submitting
@@ -75,7 +57,8 @@ export default function useReactiveTextInput(
    */
   const handleSubmit = useCallback(
     (valueToSubmit: string) => {
-      if (!shouldSubmitValue(valueToSubmit, initialText, options?.allowSubmitSameValue)) {
+      // No need to update if it hasn't changed
+      if (valueToSubmit === initialText && !options?.allowSubmitSameValue) {
         options?.onCancelUpdate?.();
       } else {
         const cleanVal = valueToSubmit.trim();
@@ -103,10 +86,10 @@ export default function useReactiveTextInput(
   const handleEscape = useCallback(() => {
     isEscaping.current = true;
     // No need to update if it hasn't changed
-    setText(initialText ?? '');
+    setText(initialText);
     // force the text to be the initial value
     if (ref.current) {
-      ref.current.value = initialText ?? '';
+      ref.current.value = initialText;
     }
     options?.onCancelUpdate?.();
     setTimeout(() => ref.current?.blur()); // Immediate timeout to ensure text is set before blurring

apps/client/src/common/components/input/time-input/TimeInput.tsx

@@ -41,10 +41,7 @@ export default function TimeInput<T extends string>({
    * @description Resets input value to given
    */
   const resetValue = useCallback(() => {
-    if (time === undefined) {
-      // there is no value to show, we leave the field empty so that the placeholder is visible
-      setValue('');
-    } else if (typeof time !== 'number' || isNaN(time)) {
+    if (typeof time !== 'number' || isNaN(time)) {
       setValue('00:00:00');
     } else if (shouldFormat) {
       setValue(formatTime(time));

apps/client/src/common/components/modal/Modal.module.scss

@@ -20,7 +20,7 @@
 .wide {
   top: 4vh;
   min-width: min(1280px, 96vw);
-  max-width: min(1600px, 96vw);
+  max-width: min(1800px, 98vw);
   height: 88vh;
   max-height: 88vh;
   display: flex;

apps/client/src/common/components/select/Select.tsx

@@ -16,21 +16,13 @@ interface SelectProps<T> extends Omit<BaseSelect.Root.Props<T>, 'items'> {
   options: SelectOption<T>[];
   fluid?: boolean;
   size?: 'medium' | 'large';
-  /** shown when the value is null, used to represent values which do not agree */
-  placeholder?: string;
 }
 
-export default function Select<T>({
-  options,
-  fluid,
-  size = 'medium',
-  placeholder,
-  ...selectRootProps
-}: SelectProps<T>) {
+export default function Select<T>({ options, fluid, size = 'medium', ...selectRootProps }: SelectProps<T>) {
   return (
     <BaseSelect.Root items={options} {...selectRootProps}>
       <BaseSelect.Trigger className={cx([styles.select, styles[size], fluid && styles.fluid])}>
-        <BaseSelect.Value placeholder={placeholder} />
+        <BaseSelect.Value />
         <BaseSelect.Icon className={styles.selectIcon}>
           <LuChevronsUpDown />
         </BaseSelect.Icon>

apps/client/src/common/components/switch/Switch.module.scss

@@ -29,11 +29,6 @@
   }
 }
 
-/* values do not agree, we show an empty track instead of a thumb position */
-.mixed .thumb {
-  visibility: hidden;
-}
-
 .medium {
   padding: 2px;
   --width: calc(2.5rem + 4px);

apps/client/src/common/components/switch/Switch.tsx

@@ -6,13 +6,11 @@ import style from './Switch.module.scss';
 
 interface SwitchProps extends BaseSwitch.Root.Props {
   size?: 'medium' | 'large';
-  /** the switch represents several values which do not agree, we hide the thumb */
-  mixed?: boolean;
 }
 
-export default function Switch({ size = 'medium', mixed, ...switchProps }: SwitchProps) {
+export default function Switch({ size = 'medium', ...switchProps }: SwitchProps) {
   return (
-    <BaseSwitch.Root className={cx([style.switch, style[size], mixed && style.mixed])} {...switchProps}>
+    <BaseSwitch.Root className={cx([style.switch, style[size]])} {...switchProps}>
       <BaseSwitch.Thumb className={style.thumb} />
     </BaseSwitch.Root>
   );

apps/client/src/common/hooks-query/useSessionStats.ts

@@ -0,0 +1,17 @@
+import { useQuery } from '@tanstack/react-query';
+import { SessionStats } from 'ontime-types';
+
+import { queryRefetchInterval } from '../../ontimeConfig';
+import { SESSION_STATS } from '../api/constants';
+import { getSessionStats } from '../api/session';
+
+export default function useSessionStats() {
+  const { data, status, isError, refetch } = useQuery<SessionStats>({
+    queryKey: SESSION_STATS,
+    queryFn: ({ signal }) => getSessionStats({ signal }),
+    placeholderData: (previousData, _previousQuery) => previousData,
+    refetchInterval: queryRefetchInterval,
+  });
+
+  return { data, status, isError, refetch };
+}

apps/client/src/common/hooks/__tests__/entryAction.utils.test.ts

@@ -1,76 +0,0 @@
-import { OntimeEvent, OntimeGroup, RundownEntries, SupportedEntry } from 'ontime-types';
-
-import { applyPatchToEvents, canPredictBatchResult } from '../entryAction.utils';
-
-function makeEntries(): RundownEntries {
-  return {
-    '1': { type: SupportedEntry.Event, id: '1', title: 'one', custom: { lx: 'a', sound: 'x' } } as OntimeEvent,
-    '2': { type: SupportedEntry.Event, id: '2', title: 'two', custom: { lx: 'b' } } as OntimeEvent,
-    '3': { type: SupportedEntry.Event, id: '3', title: 'three', custom: {} } as OntimeEvent,
-    group: { type: SupportedEntry.Group, id: 'group', title: 'a group', custom: {} } as OntimeGroup,
-  };
-}
-
-describe('applyPatchToEvents()', () => {
-  it('applies the patch to the given events only', () => {
-    const patched = applyPatchToEvents(makeEntries(), ['1', '2'], { title: 'patched' });
-
-    expect((patched['1'] as OntimeEvent).title).toBe('patched');
-    expect((patched['2'] as OntimeEvent).title).toBe('patched');
-    expect((patched['3'] as OntimeEvent).title).toBe('three');
-  });
-
-  it('patches custom fields instead of replacing them', () => {
-    const patched = applyPatchToEvents(makeEntries(), ['1', '2'], { custom: { lx: 'new' } });
-
-    // the field which was not part of the patch must survive
-    expect((patched['1'] as OntimeEvent).custom).toStrictEqual({ lx: 'new', sound: 'x' });
-    expect((patched['2'] as OntimeEvent).custom).toStrictEqual({ lx: 'new' });
-  });
-
-  it('keeps the existing custom fields when the patch has none', () => {
-    const patched = applyPatchToEvents(makeEntries(), ['1'], { title: 'patched' });
-
-    expect((patched['1'] as OntimeEvent).custom).toStrictEqual({ lx: 'a', sound: 'x' });
-  });
-
-  it('ignores ids which are not in the rundown', () => {
-    const patched = applyPatchToEvents(makeEntries(), ['1', 'does-not-exist'], { title: 'patched' });
-
-    expect(Object.keys(patched)).toStrictEqual(['1', '2', '3', 'group']);
-    expect((patched['1'] as OntimeEvent).title).toBe('patched');
-  });
-
-  it('ignores entries which are not events', () => {
-    const patched = applyPatchToEvents(makeEntries(), ['group'], { title: 'patched' });
-
-    expect((patched.group as OntimeGroup).title).toBe('a group');
-  });
-
-  it('does not mutate the given entries', () => {
-    const entries = makeEntries();
-    applyPatchToEvents(entries, ['1'], { title: 'patched', custom: { lx: 'new' } });
-
-    expect((entries['1'] as OntimeEvent).title).toBe('one');
-    expect((entries['1'] as OntimeEvent).custom).toStrictEqual({ lx: 'a', sound: 'x' });
-  });
-
-  it('handles repeated ids', () => {
-    const patched = applyPatchToEvents(makeEntries(), ['1', '1'], { title: 'patched' });
-
-    expect((patched['1'] as OntimeEvent).title).toBe('patched');
-  });
-});
-
-describe('canPredictBatchResult()', () => {
-  it('allows resolving patches which do not affect the schedule', () => {
-    expect(canPredictBatchResult({ title: 'a title' })).toBe(true);
-    expect(canPredictBatchResult({ colour: 'red', flag: true })).toBe(true);
-  });
-
-  it('defers to the server when the duration changes', () => {
-    // a duration cascades into the start and end of every linked event
-    expect(canPredictBatchResult({ duration: 1000 })).toBe(false);
-    expect(canPredictBatchResult({ title: 'a title', duration: 1000 })).toBe(false);
-  });
-});

apps/client/src/common/hooks/entryAction.utils.ts

@@ -1,39 +0,0 @@
-import { EntryId, OntimeEvent, RundownEntries, isOntimeEvent } from 'ontime-types';
-
-/**
- * Applies a patch to a set of events, used to optimistically resolve a batch edit
- * Entries which are missing or are not events are left untouched, mirroring the server
- * @returns a new entries object, the given entries are not mutated
- */
-export function applyPatchToEvents(
-  entries: RundownEntries,
-  ids: EntryId[],
-  patch: Partial<OntimeEvent>,
-): RundownEntries {
-  const patchedEntries = { ...entries };
-
-  for (const id of new Set(ids)) {
-    const entry = patchedEntries[id];
-    if (!isOntimeEvent(entry)) {
-      continue;
-    }
-
-    patchedEntries[id] = {
-      ...entry,
-      ...patch,
-      // custom fields are patched, not replaced
-      custom: patch.custom ? { ...entry.custom, ...patch.custom } : entry.custom,
-    };
-  }
-
-  return patchedEntries;
-}
-
-/**
- * Whether the result of a batch edit can be resolved without the server
- * Changing the duration cascades through the rundown, so the resulting
- * schedule is only known once the server has recalculated it
- */
-export function canPredictBatchResult(patch: Partial<OntimeEvent>): boolean {
-  return !('duration' in patch);
-}

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

@@ -52,7 +52,6 @@ import {
 } from '../api/rundown';
 import { logAxiosError } from '../api/utils';
 import { useEditorSettings } from '../stores/editorSettings';
-import { applyPatchToEvents, canPredictBatchResult } from './entryAction.utils';
 
 export type EventOptions = Partial<{
   // options of any new entries (event / delay / group)
@@ -484,9 +483,21 @@ function useEntryActionsForRundown(scopedRundownId: string | undefined) {
       // Snapshot the previous value
       const previousRundown = queryClient.getQueryData<Rundown>(queryKey);
 
-      // when the result cannot be resolved here we wait for the recalculated rundown from the server
-      if (previousRundown && canPredictBatchResult(data.data)) {
-        const newRundown = applyPatchToEvents(previousRundown.entries, data.ids, data.data);
+      if (previousRundown) {
+        const eventIds = new Set(data.ids);
+        const newRundown = { ...previousRundown.entries };
+
+        eventIds.forEach((eventId) => {
+          if (Object.hasOwn(newRundown, eventId)) {
+            const event = newRundown[eventId];
+            if (isOntimeEvent(event)) {
+              newRundown[eventId] = {
+                ...event,
+                ...data,
+              };
+            }
+          }
+        });
 
         queryClient.setQueryData<Rundown>(queryKey, {
           id: previousRundown.id,

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

@@ -15,11 +15,14 @@ const logger = createStore<LogStore>(() => ({
   logs: [],
 }));
 
+/** the log is kept in memory, we cap it to avoid it growing through a long show */
+const maxLogEntries = 500;
+
 export const useLogData = () => useStore(logger);
 
 export const addLog = (log: Log) =>
   logger.setState((state) => ({
-    logs: [log, ...state.logs],
+    logs: [log, ...state.logs].slice(0, maxLogEntries),
   }));
 
 export const clearLogs = () => logger.setState({ logs: [] });

apps/client/src/features/app-settings/panel-utils/PanelUtils.module.scss

@@ -117,6 +117,10 @@ $inner-padding: 1rem;
   td[data-warn='true'] {
     background-color: $orange-1300;
   }
+
+  tr[data-highlight='true'] {
+    background-color: $blue-1100;
+  }
 }
 
 .listGroup {

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/SourcesPanel.module.scss

@@ -25,6 +25,13 @@
   margin-top: 1rem;
 }
 
+.finishActions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 0.5rem;
+}
+
 .sourceGrid {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/SourcesPanel.tsx

@@ -8,6 +8,7 @@ import type {
 import { getErrorMessage, ImportMap } from 'ontime-utils';
 import { ChangeEvent, useCallback, useRef, useState } from 'react';
 import { IoCloudOutline, IoDownloadOutline } from 'react-icons/io5';
+import { useNavigate } from 'react-router';
 
 import {
   getWorksheetMetadata as getExcelWorksheetMetadata,
@@ -56,9 +57,11 @@ export default function SourcesPanel() {
   const [error, setError] = useState('');
   const [hasFile, setHasFile] = useState<'none' | 'loading' | 'done'>('none');
   const [activeSource, setActiveSource] = useState<ActiveSource | null>(null);
+  const [completedRundownTitle, setCompletedRundownTitle] = useState('');
 
   const { data: currentRundown } = useRundown();
   const { applyImport } = useSpreadsheetImport();
+  const navigate = useNavigate();
 
   const fileInputRef = useRef<HTMLInputElement>(null);
 
@@ -101,6 +104,7 @@ export default function SourcesPanel() {
     setHasFile('none');
     setActiveSource(null);
     setError('');
+    setCompletedRundownTitle('');
   };
 
   const openGSheetFlow = () => {
@@ -123,11 +127,12 @@ export default function SourcesPanel() {
     }
   };
 
-  const handleFinished = () => {
+  const handleFinished = (rundownTitle: string) => {
     setImportFlow('finished');
     setHasFile('none');
     setActiveSource(null);
     setError('');
+    setCompletedRundownTitle(rundownTitle);
   };
 
   const handleApplyImport = async (
@@ -139,7 +144,7 @@ export default function SourcesPanel() {
     if (mode === 'new') {
       const title = newRundownTitle.trim() || preview.rundown.title;
       await applyImport({ mode: 'new', rundown: { ...preview.rundown, title }, customFields: preview.customFields });
-      handleFinished();
+      handleFinished(title);
       return;
     }
 
@@ -156,7 +161,7 @@ export default function SourcesPanel() {
       customFields: preview.customFields,
       providedFields,
     });
-    handleFinished();
+    handleFinished(currentRundown.title);
   };
 
   const loadWorksheetMetadata = useCallback(
@@ -289,11 +294,20 @@ export default function SourcesPanel() {
         {showCompleted && (
           <div className={style.finishSection}>
             <span className={style.finishBadge}>Import complete</span>
-            <div className={style.finishTitle}>Spreadsheet data applied.</div>
-            <div className={style.finishDescription}>You can close this flow or start another import.</div>
-            <Button variant='subtle-white' onClick={resetFlow}>
-              Reset flow
-            </Button>
+            <div className={style.finishTitle}>
+              Spreadsheet data applied to {completedRundownTitle || 'your rundown'}.
+            </div>
+            <div className={style.finishDescription}>
+              Review the imported rundown in the editor or start another import.
+            </div>
+            <div className={style.finishActions}>
+              <Button variant='primary' onClick={() => navigate('/editor')}>
+                Open editor
+              </Button>
+              <Button variant='subtle-white' onClick={resetFlow}>
+                Import another
+              </Button>
+            </div>
           </div>
         )}
         {isGSheetFlow && (

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/sheet-import/SheetImportEditor.module.scss

@@ -92,6 +92,10 @@
   font-weight: 600;
 }
 
+.toolbarWarning {
+  color: $orange-400;
+}
+
 .mappingPaneTitle {
   align-self: center;
 }

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/sheet-import/SheetImportEditor.tsx

@@ -132,7 +132,16 @@ export default function SheetImportEditor({
             }
           />
         </label>
-        {toolbarStatus && <Panel.Description>{toolbarStatus}</Panel.Description>}
+        {toolbarStatus && (
+          <Panel.Description>
+            {toolbarStatus.entries === '–'
+              ? 'No import preview yet'
+              : `${toolbarStatus.entries} entries · ${toolbarStatus.groups} groups · ${toolbarStatus.milestones} milestones · ${toolbarStatus.start}–${toolbarStatus.end} · ${toolbarStatus.duration}`}
+            {toolbarStatus.warnings > 0 && (
+              <span className={style.toolbarWarning}> · {toolbarStatus.warnings} warnings</span>
+            )}
+          </Panel.Description>
+        )}
       </Panel.InlineElements>
 
       <div className={style.editorBody}>
@@ -150,13 +159,19 @@ export default function SheetImportEditor({
 
         <section className={style.previewPane}>
           <div className={style.previewPaneHeader}>
-            <span className={style.previewPaneTitle}>Import preview</span>
+            <div className={style.previewPaneHeading}>
+              <span className={style.previewPaneTitle}>Import preview</span>
+            </div>
           </div>
           <div className={style.tableShell}>
             <PreviewTable
               preview={state.preview}
               columnLabels={columnLabels}
+              canRefresh={canPreview}
               isLoadingMetadata={isLoadingMetadata}
+              isRefreshing={state.loading === 'preview'}
+              needsPreviewRefresh={state.needsPreviewRefresh}
+              onRefresh={handlePreviewSubmit}
               worksheetHeaders={worksheetHeaders}
             />
           </div>

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/sheet-import/preview/PreviewTable.module.scss

@@ -1,27 +1,35 @@
 .emptyState {
-  height: 100%;
-  min-height: 16rem;
-  display: grid;
-  place-content: center;
-  gap: 0.35rem;
-  padding: 1.5rem;
+  padding: 3rem 1.5rem;
   text-align: center;
 }
 
+.emptyMessage {
+  width: min(30rem, 100%);
+  margin-inline: auto;
+}
+
 .emptyTitle {
-  color: $ui-white;
-  font-size: 1rem;
-  font-weight: 600;
+  margin-bottom: 0.25rem;
+  color: rgba($gray-200, 0.72);
+  font-size: calc(1rem + 2px);
+  font-weight: 400;
 }
 
 .emptyBody {
-  color: $gray-400;
-  font-size: 0.95rem;
+  color: rgba($gray-200, 0.55);
+  font-size: calc(1rem - 3px);
+  line-height: 1.5;
+}
+
+.emptyAction {
+  margin: 1rem auto 0;
 }
 
 .table {
   width: 100%;
-  border-collapse: collapse;
+  border-collapse: separate;
+  border-spacing: 0;
+  color: $ui-white;
   font-size: calc(1rem - 2px);
   text-align: left;
   table-layout: auto;
@@ -34,31 +42,101 @@
   }
 
   th {
-    font-weight: 400;
-    color: $gray-400;
-    text-transform: capitalize;
-    vertical-align: top;
+    color: $gray-300;
+    font-size: 0.8rem;
+    font-weight: 600;
+    letter-spacing: 0.02em;
+    text-transform: uppercase;
+    vertical-align: bottom;
     white-space: normal;
   }
 
   th,
   td {
-    padding: 0.5rem;
+    box-sizing: border-box;
     min-width: 8rem;
-    vertical-align: top;
+    max-width: 20rem;
+    padding: 0.55rem 0.65rem;
+    border-bottom: 1px solid $white-10;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    vertical-align: middle;
+    white-space: nowrap;
   }
 
-  tr:nth-child(even) {
-    background-color: $white-1;
+  tbody tr {
+    --entry-colour: transparent;
+    background-color: color-mix(in srgb, $gray-1300 96%, var(--entry-colour) 4%);
+    box-shadow: inset 3px 0 var(--entry-colour);
   }
+
+  td[data-empty='true'] {
+    color: $gray-600;
+  }
+}
+
+.rowNumber,
+.rowType {
+  position: sticky;
+  z-index: 1;
+  background-color: inherit;
 }
 
 .rowNumber {
-  width: 4.5rem;
-  min-width: 4.5rem;
+  left: 0;
+  width: 3.25rem;
+  min-width: 3.25rem !important;
+  color: $gray-400;
+  text-align: right;
 }
 
 .rowType {
-  width: 7rem;
-  min-width: 7rem;
+  left: 3.25rem;
+  width: 6.25rem;
+  min-width: 6.25rem !important;
+  color: $gray-400;
+  font-size: 0.8rem;
+  box-shadow: 1px 0 $white-10;
+}
+
+thead .rowNumber,
+thead .rowType {
+  z-index: 2;
+  background-color: $gray-1350;
+}
+
+.numericCell {
+  font-variant-numeric: tabular-nums;
+  text-align: right;
+}
+
+.multilineCell {
+  max-width: 30rem !important;
+  overflow-wrap: anywhere;
+  text-overflow: clip !important;
+  white-space: pre-wrap !important;
+}
+
+.eventRow {
+  .rowNumber {
+    font-variant-numeric: tabular-nums;
+  }
+}
+
+.groupRow {
+  background-color: color-mix(in srgb, $gray-1300 88%, var(--entry-colour) 12%) !important;
+  box-shadow: inset 4px 0 var(--entry-colour) !important;
+  font-weight: 600;
+
+  td {
+    min-height: 3.25rem;
+    border-top: 0.75rem solid $gray-1350;
+  }
+}
+
+.milestoneRow {
+  background-color: color-mix(in srgb, $gray-1300 93%, var(--entry-colour) 7%) !important;
+  box-shadow: inset 3px 0 var(--entry-colour) !important;
+  color: $gray-300;
+  font-style: italic;
 }

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/sheet-import/preview/PreviewTable.tsx

@@ -1,7 +1,11 @@
 import type { CustomField, CustomFieldKey, SpreadsheetPreviewResponse } from 'ontime-types';
-import { isOntimeEvent, isOntimeGroup, isOntimeMilestone } from 'ontime-types';
+import { isOntimeDelay, isOntimeEvent, isOntimeGroup, isOntimeMilestone } from 'ontime-types';
+import type { CSSProperties } from 'react';
 import { useMemo } from 'react';
 
+import Button from '../../../../../../../common/components/buttons/Button';
+import Tag from '../../../../../../../common/components/tag/Tag';
+import { getRundownMetadata } from '../../../../../../../common/utils/rundownMetadata';
 import { getCellValue } from './previewTableUtils';
 
 import style from './PreviewTable.module.scss';
@@ -9,14 +13,85 @@ import style from './PreviewTable.module.scss';
 interface PreviewTableProps {
   preview: SpreadsheetPreviewResponse | null;
   columnLabels: string[];
+  canRefresh: boolean;
   isLoadingMetadata: boolean;
+  isRefreshing: boolean;
+  needsPreviewRefresh: boolean;
+  onRefresh: () => void;
   worksheetHeaders: string[];
 }
 
+const priorityColumns = ['Title', 'Cue', 'Start', 'End', 'Duration'];
+const numericColumns = new Set(['Start', 'End', 'Duration', 'Time warning', 'Time danger']);
+const transparentColour = 'transparent';
+
+type PreviewEntry = SpreadsheetPreviewResponse['rundown']['entries'][string];
+
+function getEntryDisplay(entry: PreviewEntry, groupColour?: string) {
+  if (isOntimeGroup(entry)) {
+    return {
+      rowClassName: style.groupRow,
+      entryColour: entry.colour,
+      entryType: 'Group',
+    };
+  }
+
+  const entryColour = groupColour ?? transparentColour;
+
+  if (isOntimeMilestone(entry)) {
+    return {
+      rowClassName: style.milestoneRow,
+      entryColour,
+      entryType: 'Milestone',
+    };
+  }
+
+  if (isOntimeDelay(entry)) {
+    return {
+      rowClassName: style.eventRow,
+      entryColour,
+      entryType: 'Delay',
+    };
+  }
+
+  return {
+    rowClassName: style.eventRow,
+    entryColour,
+    entryType: 'Event',
+  };
+}
+
+function getCellClassName(label: string, value: string) {
+  if (value.includes('\n')) {
+    return style.multilineCell;
+  }
+
+  if (numericColumns.has(label)) {
+    return style.numericCell;
+  }
+
+  return undefined;
+}
+
+function getDisplayColumns(columnLabels: string[]) {
+  return [...columnLabels].sort((left, right) => {
+    const leftPriority = priorityColumns.indexOf(left);
+    const rightPriority = priorityColumns.indexOf(right);
+    return (
+      (leftPriority === -1 ? priorityColumns.length : leftPriority) -
+      (rightPriority === -1 ? priorityColumns.length : rightPriority)
+    );
+  });
+}
+
 export default function PreviewTable({
   preview,
   columnLabels,
+  canRefresh,
   isLoadingMetadata,
+  isRefreshing,
+  needsPreviewRefresh,
+  onRefresh,
   worksheetHeaders,
 }: PreviewTableProps) {
   const customFieldKeyByLabel = useMemo(() => {
@@ -24,33 +99,57 @@ export default function PreviewTable({
     return new Map(Object.entries(preview.customFields).map(([fieldId, field]) => [field.label, fieldId]));
   }, [preview]);
 
+  const displayColumns = useMemo(() => getDisplayColumns(columnLabels), [columnLabels]);
+
+  const previewMetadata = useMemo(() => {
+    if (!preview) return null;
+    return getRundownMetadata(preview.rundown, null);
+  }, [preview]);
+
   if (!preview) {
+    let emptyTitle = 'Preview not generated';
     let emptyContent = 'Select the fields you want to import, then click Preview import.';
 
     if (isLoadingMetadata) {
+      emptyTitle = 'Loading worksheet';
       emptyContent = 'Loading worksheet metadata...';
     } else if (worksheetHeaders.length === 0) {
+      emptyTitle = 'No headers found';
       emptyContent =
         'No column headers detected in this worksheet. Try a different worksheet or ensure the first row contains column headers.';
+    } else if (needsPreviewRefresh) {
+      emptyTitle = 'Preview needs updating';
+      emptyContent = 'Your column mapping changed. Preview the import again to update this table.';
     }
 
     return (
       <div className={style.emptyState}>
-        <div className={style.emptyTitle}>Preview not generated</div>
-        <div className={style.emptyBody}>{emptyContent}</div>
+        <div className={style.emptyMessage}>
+          <div className={style.emptyTitle}>{emptyTitle}</div>
+          <div className={style.emptyBody}>{emptyContent}</div>
+          {needsPreviewRefresh && (
+            <Button
+              className={style.emptyAction}
+              variant='primary'
+              onClick={onRefresh}
+              disabled={!canRefresh}
+              loading={isRefreshing}
+            >
+              Refresh preview
+            </Button>
+          )}
+        </div>
       </div>
     );
   }
 
-  let eventIndex = 0;
-
   return (
     <table className={style.table}>
       <thead>
         <tr>
           <th className={style.rowNumber}>#</th>
           <th className={style.rowType}>Type</th>
-          {columnLabels.map((label, index) => (
+          {displayColumns.map((label, index) => (
             <th key={`${label}-${index}`}>{label}</th>
           ))}
         </tr>
@@ -59,16 +158,29 @@ export default function PreviewTable({
         {preview.rundown.flatOrder.map((entryId) => {
           const entry = preview.rundown.entries[entryId];
           const isEvent = isOntimeEvent(entry);
-          if (isEvent) eventIndex++;
-          const hasType = isEvent || isOntimeGroup(entry) || isOntimeMilestone(entry);
+          const entryMetadata = previewMetadata?.[entryId];
+          const { rowClassName, entryColour, entryType } = getEntryDisplay(entry, entryMetadata?.groupColour);
 
           return (
-            <tr key={entryId}>
-              <td className={style.rowNumber}>{isEvent ? eventIndex : ''}</td>
-              <td className={style.rowType}>{hasType ? entry.type : ''}</td>
-              {columnLabels.map((label, colIndex) => (
-                <td key={`${entryId}-${colIndex}`}>{getCellValue(label, entry, customFieldKeyByLabel)}</td>
-              ))}
+            <tr key={entryId} className={rowClassName} style={{ '--entry-colour': entryColour } as CSSProperties}>
+              <td className={style.rowNumber}>{isEvent ? entryMetadata?.eventIndex : ''}</td>
+              <td className={style.rowType}>
+                <Tag>{entryType}</Tag>
+              </td>
+              {displayColumns.map((label, colIndex) => {
+                const value = getCellValue(label, entry, customFieldKeyByLabel);
+                const cellClassName = getCellClassName(label, value);
+                return (
+                  <td
+                    key={`${entryId}-${colIndex}`}
+                    className={cellClassName}
+                    data-empty={value === ''}
+                    title={value || undefined}
+                  >
+                    {value}
+                  </td>
+                );
+              })}
             </tr>
           );
         })}

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/sheet-import/useSheetImportForm.ts

@@ -5,7 +5,8 @@ import type {
   SpreadsheetPreviewResponse,
   SpreadsheetWorksheetMetadata,
 } from 'ontime-types';
-import { millisToString } from 'ontime-utils';
+import { isOntimeGroup, isOntimeMilestone } from 'ontime-types';
+import { millisToString, removeTrailingZero } from 'ontime-utils';
 import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react';
 import { useFieldArray, useForm } from 'react-hook-form';
 
@@ -32,7 +33,7 @@ type ImportAction =
   | { type: 'previewSuccess'; preview: SpreadsheetPreviewResponse }
   | { type: 'applySuccess' }
   | { type: 'exportSuccess' }
-  | { type: 'clearPreview'; error?: string }
+  | { type: 'clearPreview'; error?: string; needsRefresh?: boolean }
   | { type: 'failure'; error: string }
   | { type: 'reset' };
 
@@ -40,12 +41,14 @@ type ImportState = {
   loading: '' | 'preview' | 'apply' | 'export';
   error: string;
   preview: SpreadsheetPreviewResponse | null;
+  needsPreviewRefresh: boolean;
 };
 
 const initialImportState: ImportState = {
   loading: '',
   error: '',
   preview: null,
+  needsPreviewRefresh: false,
 };
 
 function importReducer(state: ImportState, action: ImportAction): ImportState {
@@ -57,15 +60,15 @@ function importReducer(state: ImportState, action: ImportAction): ImportState {
     case 'startExport':
       return { ...state, loading: 'export', error: '' };
     case 'previewSuccess':
-      return { loading: '', error: '', preview: action.preview };
+      return { loading: '', error: '', preview: action.preview, needsPreviewRefresh: false };
     case 'applySuccess':
     case 'exportSuccess':
       return { ...state, loading: '' };
     case 'clearPreview':
-      return { ...state, error: action.error ?? '', preview: null };
+      return { ...state, error: action.error ?? '', preview: null, needsPreviewRefresh: action.needsRefresh ?? false };
     case 'failure': {
       if (state.loading === 'preview') {
-        return { loading: '', error: action.error, preview: null };
+        return { loading: '', error: action.error, preview: null, needsPreviewRefresh: false };
       }
       return { ...state, loading: '', error: action.error };
     }
@@ -221,7 +224,7 @@ export function useSheetImportForm({
     const sub = watch(() => {
       if (!previewRef.current) return;
       previewRef.current = null;
-      dispatch({ type: 'clearPreview' });
+      dispatch({ type: 'clearPreview', needsRefresh: true });
     });
     return () => sub.unsubscribe();
   }, [watch]);
@@ -297,15 +300,37 @@ export function useSheetImportForm({
   }, [append]);
 
   const toolbarStatus = (() => {
-    const warningText = warningCount > 0 ? ` | warnings: ${warningCount}` : '';
-
     if (!state.preview) {
-      return `entries: – | start: – | end: – | duration: –${warningText}`;
+      return {
+        entries: '–',
+        groups: '–',
+        milestones: '–',
+        start: '–',
+        end: '–',
+        duration: '–',
+        warnings: warningCount,
+      };
     }
 
-    const { flatOrder } = state.preview.rundown;
+    const { entries, flatOrder } = state.preview.rundown;
     const { start, end, duration } = state.preview.summary;
-    return `entries: ${flatOrder.length} | start: ${millisToString(start)} | end: ${millisToString(end)} | duration: ${formatDuration(duration)}${warningText}`;
+    let groups = 0;
+    let milestones = 0;
+    for (const entryId of flatOrder) {
+      const entry = entries[entryId];
+      if (isOntimeGroup(entry)) groups++;
+      else if (isOntimeMilestone(entry)) milestones++;
+    }
+
+    return {
+      entries: flatOrder.length,
+      groups,
+      milestones,
+      start: removeTrailingZero(millisToString(start)),
+      end: removeTrailingZero(millisToString(end)),
+      duration: formatDuration(duration),
+      warnings: warningCount,
+    };
   })();
 
   return {

apps/client/src/features/app-settings/panel/network-panel/NetworkInterfaces.tsx

@@ -19,10 +19,12 @@ export default function InfoNif() {
         // interfaces outside localhost wont have access
         if (nif.name === 'localhost' && !isLocalhost) return null;
         const address = linkToOtherHost(nif.address);
+        // we show the address as it would be typed in a browser, including the port
+        const label = new URL(address).host;
 
         return (
-          <CopyTag key={nif.name} copyValue={address} onClick={() => handleClick(address)}>
-            {`${nif.name} - ${nif.address}`} <IoArrowUp className={style.goIcon} />
+          <CopyTag key={`${nif.name}-${nif.address}`} copyValue={address} onClick={() => handleClick(address)}>
+            {`${nif.name} - ${label}`} <IoArrowUp className={style.goIcon} />
           </CopyTag>
         );
       })}

apps/client/src/features/app-settings/panel/network-panel/NetworkLogExport.tsx

@@ -19,10 +19,13 @@ export default function LogExport() {
         <Panel.SubHeader>
           Event log
           <Button onClick={extract}>
-            Extract <IoArrowUp className={style.iconRotate} />
+            Open in new window <IoArrowUp className={style.iconRotate} />
           </Button>
         </Panel.SubHeader>
         <Panel.Divider />
+        <Panel.Paragraph>
+          Activity in this session. The log is not saved with the project and is cleared when Ontime restarts.
+        </Panel.Paragraph>
         <Log />
       </Panel.Card>
     </Panel.Section>

apps/client/src/features/app-settings/panel/network-panel/NetworkLogPanel.tsx

@@ -1,26 +1,38 @@
-import { MessageTag } from 'ontime-types';
-import { useEffect } from 'react';
-
 import useScrollIntoView from '../../../../common/hooks/useScrollIntoView';
-import { usePing } from '../../../../common/hooks/useSocket';
-import { sendSocket } from '../../../../common/utils/socket';
-import { isDocker } from '../../../../externals';
+import { isOntimeCloud } from '../../../../externals';
 import type { PanelBaseProps } from '../../panel-list/PanelList';
 import * as Panel from '../../panel-utils/PanelUtils';
 import ClientControlPanel from './client-control/ClientControlPanel';
+import InfoNif from './NetworkInterfaces';
 import LogExport from './NetworkLogExport';
+import NetworkStatus from './NetworkStatus';
 
 export default function NetworkLogPanel({ location }: PanelBaseProps) {
+  const statusRef = useScrollIntoView<HTMLDivElement>('status', location);
+  const interfacesRef = useScrollIntoView<HTMLDivElement>('interfaces', location);
   const clientsRef = useScrollIntoView<HTMLDivElement>('clients', location);
   const logRef = useScrollIntoView<HTMLDivElement>('log', location);
 
   return (
     <>
       <Panel.Header>Network</Panel.Header>
-      {isDocker && (
-        <Panel.Section>
-          <OntimeCloudStats />
-        </Panel.Section>
+      <div ref={statusRef}>
+        <NetworkStatus />
+      </div>
+      {!isOntimeCloud && (
+        <div ref={interfacesRef}>
+          <Panel.Section>
+            <Panel.Card>
+              <Panel.SubHeader>Network interfaces</Panel.SubHeader>
+              <Panel.Divider />
+              <Panel.Paragraph>
+                Addresses which can be used to reach Ontime from other devices in the network. <br />
+                Click an address to open it in a new window, or use the icon to copy it to the clipboard.
+              </Panel.Paragraph>
+              <InfoNif />
+            </Panel.Card>
+          </Panel.Section>
+        </div>
       )}
       <div ref={logRef}>
         <LogExport />
@@ -31,29 +43,3 @@ export default function NetworkLogPanel({ location }: PanelBaseProps) {
     </>
   );
 }
-
-function OntimeCloudStats() {
-  const ping = usePing();
-
-  /**
-   * Send immediate ping request, and keep sending on an interval
-   */
-  useEffect(() => {
-    sendSocket(MessageTag.Ping, new Date());
-
-    const doPing = setInterval(() => {
-      sendSocket(MessageTag.Ping, new Date());
-    }, 5000);
-
-    return () => {
-      clearInterval(doPing);
-    };
-  }, []);
-
-  return (
-    <Panel.SubHeader>
-      Ontime cloud
-      <Panel.Description>Current ping: {ping}ms</Panel.Description>
-    </Panel.SubHeader>
-  );
-}

apps/client/src/features/app-settings/panel/network-panel/NetworkStatus.tsx

@@ -0,0 +1,109 @@
+import { MaybeString, MessageTag } from 'ontime-types';
+import { MILLIS_PER_MINUTE } from 'ontime-utils';
+import { useEffect } from 'react';
+
+import Tag from '../../../../common/components/tag/Tag';
+import useSessionStats from '../../../../common/hooks-query/useSessionStats';
+import { usePing } from '../../../../common/hooks/useSocket';
+import { useClientStore } from '../../../../common/stores/clientStore';
+import { formatDuration } from '../../../../common/utils/time';
+import { sendSocket } from '../../../../common/utils/socket';
+import { isDocker } from '../../../../externals';
+import * as Panel from '../../panel-utils/PanelUtils';
+
+/** ping values above this are flagged to the user (ms) */
+const slowPingThreshold = 100;
+
+/** how often we ask the server for a ping (ms) */
+const pingInterval = 5000;
+
+/**
+ * Presents a date as the time elapsed since it happened
+ */
+function timeSince(date: MaybeString): string {
+  if (date === null) {
+    return 'Never';
+  }
+
+  const elapsed = Date.now() - new Date(date).getTime();
+  if (elapsed < MILLIS_PER_MINUTE) {
+    return 'Just now';
+  }
+  return `${formatDuration(elapsed)} ago`;
+}
+
+export default function NetworkStatus() {
+  const { data, status, isError } = useSessionStats();
+  // the client list is kept up to date over websocket, unlike the polled session stats
+  const clients = useClientStore((store) => store.clients);
+
+  return (
+    <Panel.Section>
+      <Panel.Card>
+        <Panel.SubHeader>Server status</Panel.SubHeader>
+        <Panel.Loader isLoading={status === 'pending'} />
+        {isError && <Panel.Error>Failed to load session data</Panel.Error>}
+        <Panel.Divider />
+        <Panel.ListGroup>
+          <Panel.ListItem>
+            <Panel.Field title='Connected clients' description='Clients currently connected to this server' />
+            <Tag>{Object.keys(clients).length}</Tag>
+          </Panel.ListItem>
+          <Panel.ListItem>
+            <Panel.Field title='Server running for' description='Time since the Ontime server was started' />
+            <Tag>{data ? formatDuration(Date.now() - new Date(data.startedAt).getTime()) : '...'}</Tag>
+          </Panel.ListItem>
+          <Panel.ListItem>
+            <Panel.Field title='Last client connection' description='When a client last connected to the server' />
+            <Tag>{data ? timeSince(data.lastConnection) : '...'}</Tag>
+          </Panel.ListItem>
+          <Panel.ListItem>
+            <Panel.Field
+              title='Last integration request'
+              description='When the server last received a request from an integration'
+            />
+            <Tag>{data ? timeSince(data.lastRequest) : '...'}</Tag>
+          </Panel.ListItem>
+          <Panel.ListItem>
+            <Panel.Field title='Server time zone' description='Time zone used by the machine running Ontime' />
+            <Tag>{data ? data.timezone : '...'}</Tag>
+          </Panel.ListItem>
+          {isDocker && <CloudPing />}
+        </Panel.ListGroup>
+      </Panel.Card>
+    </Panel.Section>
+  );
+}
+
+/**
+ * Ontime cloud users are not in the same network as the server
+ * we show the round trip time to help them qualify the connection
+ */
+function CloudPing() {
+  const ping = usePing();
+
+  /**
+   * Send immediate ping request, and keep sending on an interval
+   */
+  useEffect(() => {
+    sendSocket(MessageTag.Ping, new Date());
+
+    const doPing = setInterval(() => {
+      sendSocket(MessageTag.Ping, new Date());
+    }, pingInterval);
+
+    return () => {
+      clearInterval(doPing);
+    };
+  }, []);
+
+  return (
+    <Panel.ListItem>
+      <Panel.Field
+        title='Ontime cloud latency'
+        description='Time for a message to travel to the server and back. Lower is better'
+      />
+      <Tag variant={ping > slowPingThreshold ? 'warning' : 'default'}>{ping}ms</Tag>
+    </Panel.ListItem>
+  );
+}

apps/client/src/features/app-settings/panel/network-panel/client-control/ClientControlPanel.module.scss

@@ -1,11 +1,3 @@
-.fullWidth {
-  width: 100%;
-}
-
-.halfWidth {
-  width: 50%;
-}
-
 .halfWidthNoWrap {
   width: 50%;
   white-space: nowrap;
@@ -16,6 +8,11 @@
   user-select: text;
 }
 
-.self {
-  background-color: $blue-1100;
+.muted {
+  color: $label-gray;
+}
+
+// align section notes with the table contents
+.note {
+  padding: 0 2rem;
 }

apps/client/src/features/app-settings/panel/network-panel/client-control/ClientList.tsx

@@ -5,14 +5,42 @@ import { useState } from 'react';
 import Button from '../../../../../common/components/buttons/Button';
 import { RedirectClientModal } from '../../../../../common/components/client-modal/RedirectClientModal';
 import { RenameClientModal } from '../../../../../common/components/client-modal/RenameClientModal';
+import CopyTag from '../../../../../common/components/copy-tag/CopyTag';
 import Tag from '../../../../../common/components/tag/Tag';
+import Tooltip from '../../../../../common/components/tooltip/Tooltip';
 import { setClientRemote } from '../../../../../common/hooks/useSocket';
 import { useClientStore } from '../../../../../common/stores/clientStore';
-import { cx } from '../../../../../common/utils/styleUtils';
+import { openLink } from '../../../../../common/utils/linkUtils';
 import * as Panel from '../../../panel-utils/PanelUtils';
 
 import style from './ClientControlPanel.module.scss';
 
+/**
+ * Shows the path a client is showing
+ * The full URL is available for copying or opening in a new window
+ */
+function ClientPath({ origin, path }: { origin: string; path: string }) {
+  // clients report their path on connection, we may not have it yet
+  if (!path) {
+    return <span className={style.muted}>unknown</span>;
+  }
+
+  // origin is empty for clients which have not reported their location
+  if (!origin) {
+    return <span className={style.copiable}>{path}</span>;
+  }
+
+  const fullUrl = `${origin}${path}`;
+
+  return (
+    <Tooltip text={fullUrl} render={<span />}>
+      <CopyTag copyValue={fullUrl} size='small' onClick={() => openLink(fullUrl)}>
+        {path}
+      </CopyTag>
+    </Tooltip>
+  );
+}
+
 export default function ClientList() {
   const id = useClientStore((store) => store.id);
   const clients = useClientStore((store) => store.clients);
@@ -32,8 +60,19 @@ export default function ClientList() {
     redirectHandler.open();
   };
 
-  const ontimeClients = Object.entries(clients).filter(([_, { type }]) => type === 'ontime');
-  const otherClients = Object.entries(clients).filter(([_, { type }]) => type !== 'ontime');
+  /**
+   * Clients are given by the server in connection order, which means rows move
+   * as clients come and go. We keep a stable order: self first, then by name
+   */
+  const sortClients = (clientEntries: [string, Client][]) =>
+    clientEntries.sort(([keyA, clientA], [keyB, clientB]) => {
+      if (keyA === id) return -1;
+      if (keyB === id) return 1;
+      return clientA.name.localeCompare(clientB.name);
+    });
+
+  const ontimeClients = sortClients(Object.entries(clients).filter(([_, { type }]) => type === 'ontime'));
+  const otherClients = sortClients(Object.entries(clients).filter(([_, { type }]) => type !== 'ontime'));
 
   const targetClient: Client | undefined = clients[targetId];
 
@@ -59,29 +98,37 @@ export default function ClientList() {
       )}
       <Panel.Section>
         <Panel.Title>Ontime Clients ({ontimeClients.length})</Panel.Title>
+        <div className={style.note}>
+          <Panel.Description>
+            Ontime views connected to this server. Identify shows a marker in the client screen until you turn it off,
+            redirect sends the client to a different view.
+          </Panel.Description>
+        </div>
         <Panel.Table>
           <thead>
             <tr>
-              <td style={{ width: '20%' }}>Client Name</td>
-              <td>Path</td>
-              <td />
+              <th style={{ width: '20%' }}>Client Name</th>
+              <th>Path</th>
+              <th />
             </tr>
           </thead>
           <tbody>
+            {ontimeClients.length === 0 && <Panel.TableEmpty label='No Ontime clients connected' />}
             {ontimeClients.map(([key, client]) => {
               const { identify, name, path } = client;
               const isCurrent = id === key;
               return (
-                <tr key={key} className={cx([isCurrent && style.self])}>
+                <tr key={key} data-highlight={isCurrent}>
                   <Panel.InlineElements relation='inner' as='td'>
                     {isCurrent && <Tag>SELF</Tag>}
                     {name}
                   </Panel.InlineElements>
-                  <td className={style.copiable}>{path}</td>
+                  <td>
+                    <ClientPath origin={client.origin} path={path} />
+                  </td>
                   <Panel.InlineElements relation='inner' as='td'>
                     <Button
                       size='small'
-                      className={`${identify ? style.blink : ''}`}
                       disabled={isCurrent}
                       variant={identify ? 'primary' : 'subtle'}
                       data-testid={isCurrent ? '' : 'not-self-identify'}
@@ -117,14 +164,21 @@ export default function ClientList() {
       <Panel.Divider />
       <Panel.Section>
         <Panel.Title>Other Clients ({otherClients.length})</Panel.Title>
+        <div className={style.note}>
+          <Panel.Description>
+            Connections which are not Ontime views, such as integrations and custom clients. These cannot be controlled
+            from Ontime.
+          </Panel.Description>
+        </div>
         <Panel.Table>
           <thead>
             <tr>
-              <td className={style.halfWidthNoWrap}>Client Name</td>
-              <td className={style.halfWidthNoWrap}>Client type</td>
+              <th className={style.halfWidthNoWrap}>Client Name</th>
+              <th className={style.halfWidthNoWrap}>Client type</th>
             </tr>
           </thead>
           <tbody>
+            {otherClients.length === 0 && <Panel.TableEmpty label='No other clients connected' />}
             {otherClients.map(([key, client]) => {
               const { name, type } = client;
 

apps/client/src/features/app-settings/useAppSettingsMenu.tsx

@@ -67,6 +67,14 @@ const staticOptions = [
     id: 'network',
     label: 'Network',
     secondary: [
+      {
+        id: 'network__status',
+        label: 'Server status',
+      },
+      {
+        id: 'network__interfaces',
+        label: 'Network interfaces',
+      },
       {
         id: 'network__log',
         label: 'Event log',

apps/client/src/features/log/Log.module.scss

@@ -51,3 +51,13 @@ $info-hover: $section-white;
   flex-wrap: wrap;
   padding-bottom: 0.5rem;
 }
+
+.count {
+  color: $info-gray;
+  white-space: nowrap;
+}
+
+.empty {
+  color: $info-gray;
+  padding: 0.5rem 0;
+}

apps/client/src/features/log/Log.tsx

@@ -1,115 +1,90 @@
-import { LogOrigin } from 'ontime-types';
+import { LogLevel, LogOrigin } from 'ontime-types';
 import { useCallback, useState } from 'react';
 import { IoClose } from 'react-icons/io5';
 
 import Button from '../../common/components/buttons/Button';
+import Input from '../../common/components/input/input/Input';
 import { clearLogs, useLogData } from '../../common/stores/logger';
 import * as Panel from '../app-settings/panel-utils/PanelUtils';
 
 import style from './Log.module.scss';
 
+const allOrigins = [
+  LogOrigin.User,
+  LogOrigin.Client,
+  LogOrigin.Server,
+  LogOrigin.Playback,
+  LogOrigin.Rx,
+  LogOrigin.Tx,
+];
+
 export default function Log() {
   const { logs: logData } = useLogData();
 
-  const [showClient, setShowClient] = useState(true);
-  const [showServer, setShowServer] = useState(true);
-  const [showRx, setShowRx] = useState(true);
-  const [showTx, setShowTx] = useState(true);
-  const [showPlayback, setShowPlayback] = useState(true);
-  const [showUser, setShowUser] = useState(true);
+  // log entries are not guaranteed to have an origin from the enum
+  const [origins, setOrigins] = useState<Set<string>>(() => new Set<string>(allOrigins));
+  const [onlyProblems, setOnlyProblems] = useState(false);
+  const [search, setSearch] = useState('');
 
-  const matchers: LogOrigin[] = [];
-  if (showUser) {
-    matchers.push(LogOrigin.User);
-  }
-  if (showClient) {
-    matchers.push(LogOrigin.Client);
-  }
-  if (showServer) {
-    matchers.push(LogOrigin.Server);
-  }
-  if (showRx) {
-    matchers.push(LogOrigin.Rx);
-  }
-  if (showTx) {
-    matchers.push(LogOrigin.Tx);
-  }
-  if (showPlayback) {
-    matchers.push(LogOrigin.Playback);
-  }
-
-  const filteredData = logData.filter((entry) => matchers.some((match) => entry.origin === match));
-
-  const disableOthers = useCallback((toEnable: LogOrigin) => {
-    setShowUser(toEnable === LogOrigin.User);
-    setShowClient(toEnable === LogOrigin.Client);
-    setShowServer(toEnable === LogOrigin.Server);
-    setShowRx(toEnable === LogOrigin.Rx);
-    setShowTx(toEnable === LogOrigin.Tx);
-    setShowPlayback(toEnable === LogOrigin.Playback);
+  const toggleOrigin = useCallback((origin: LogOrigin) => {
+    setOrigins((previous) => {
+      const newOrigins = new Set(previous);
+      if (newOrigins.has(origin)) {
+        newOrigins.delete(origin);
+      } else {
+        newOrigins.add(origin);
+      }
+      return newOrigins;
+    });
   }, []);
 
+  /** middle click on an origin shows only that origin */
+  const showOnlyOrigin = useCallback((origin: LogOrigin) => {
+    setOrigins(new Set([origin]));
+  }, []);
+
+  const searchTerm = search.toLowerCase();
+  const filteredData = logData.filter((entry) => {
+    if (!origins.has(entry.origin)) return false;
+    if (onlyProblems && entry.level === LogLevel.Info) return false;
+    if (searchTerm && !entry.text.toLowerCase().includes(searchTerm)) return false;
+    return true;
+  });
+
+  const isFiltered = filteredData.length !== logData.length;
+
   return (
     <>
       <Panel.InlineElements className={style.buttonBar}>
+        {allOrigins.map((origin) => (
+          <Button
+            key={origin}
+            variant={origins.has(origin) ? 'primary' : 'subtle'}
+            size='small'
+            onClick={() => toggleOrigin(origin)}
+            onAuxClick={() => showOnlyOrigin(origin)}
+            onContextMenu={(event) => event.preventDefault()}
+          >
+            {origin}
+          </Button>
+        ))}
         <Button
-          variant={showUser ? 'primary' : 'subtle'}
+          variant={onlyProblems ? 'primary' : 'subtle'}
           size='small'
-          onClick={() => setShowUser((s) => !s)}
-          onAuxClick={() => disableOthers(LogOrigin.User)}
-          onContextMenu={(e) => e.preventDefault()}
+          onClick={() => setOnlyProblems((previous) => !previous)}
         >
-          {LogOrigin.User}
-        </Button>
-        <Button
-          variant={showClient ? 'primary' : 'subtle'}
-          size='small'
-          onClick={() => setShowClient((s) => !s)}
-          onAuxClick={() => disableOthers(LogOrigin.Client)}
-          onContextMenu={(e) => e.preventDefault()}
-        >
-          {LogOrigin.Client}
-        </Button>
-        <Button
-          variant={showServer ? 'primary' : 'subtle'}
-          size='small'
-          onClick={() => setShowServer((s) => !s)}
-          onAuxClick={() => disableOthers(LogOrigin.Server)}
-          onContextMenu={(e) => e.preventDefault()}
-        >
-          {LogOrigin.Server}
-        </Button>
-        <Button
-          variant={showPlayback ? 'primary' : 'subtle'}
-          size='small'
-          onClick={() => setShowPlayback((s) => !s)}
-          onAuxClick={() => disableOthers(LogOrigin.Playback)}
-          onContextMenu={(e) => e.preventDefault()}
-        >
-          {LogOrigin.Playback}
-        </Button>
-        <Button
-          variant={showRx ? 'primary' : 'subtle'}
-          size='small'
-          onClick={() => setShowRx((s) => !s)}
-          onAuxClick={() => disableOthers(LogOrigin.Rx)}
-          onContextMenu={(e) => e.preventDefault()}
-        >
-          {LogOrigin.Rx}
-        </Button>
-        <Button
-          variant={showTx ? 'primary' : 'subtle'}
-          size='small'
-          onClick={() => setShowTx((s) => !s)}
-          onAuxClick={() => disableOthers(LogOrigin.Tx)}
-          onContextMenu={(e) => e.preventDefault()}
-        >
-          {LogOrigin.Tx}
+          Issues only
         </Button>
         <Button variant='subtle-destructive' size='small' onClick={clearLogs} className={style.apart}>
           <IoClose /> Clear
         </Button>
       </Panel.InlineElements>
+      <Panel.InlineElements className={style.buttonBar}>
+        <Input fluid placeholder='Filter messages' value={search} onChange={(event) => setSearch(event.target.value)} />
+        <span className={style.count}>
+          {isFiltered ? `${filteredData.length} of ${logData.length}` : logData.length} entries
+        </span>
+      </Panel.InlineElements>
       <ul className={style.log}>
         {filteredData.map((logEntry) => (
           <li key={logEntry.id} className={`${style.logEntry} ${style[logEntry.level]} `}>
@@ -118,6 +93,9 @@ export default function Log() {
             <span className={style.msg}>{logEntry.text}</span>
           </li>
         ))}
+        {filteredData.length === 0 && (
+          <li className={style.empty}>{logData.length === 0 ? 'No activity yet' : 'No entries match the filters'}</li>
+        )}
       </ul>
     </>
   );

apps/client/src/features/rundown/entry-editor/CuesheetEventEditor.tsx

@@ -22,13 +22,10 @@ export default function CuesheetEntryEditor({ entryId, rundown }: CuesheetEntryE
     return event ?? null;
   }, [entryId, rundown.entries, rundown.order.length]);
 
-  // the cuesheet always edits a single entry
-  const events = useMemo(() => (isOntimeEvent(entry) ? [entry] : null), [entry]);
-
-  if (events) {
+  if (isOntimeEvent(entry)) {
     return (
       <div className={style.entryEditor} data-testid='editor-container'>
-        <EventEditor events={events} />
+        <EventEditor event={entry} />
       </div>
     );
   }

apps/client/src/features/rundown/entry-editor/EntryEditor.module.scss

@@ -75,26 +75,6 @@
   gap: 1rem;
 }
 
-// a label with an action aligned to the end of the row
-.labelRow {
-  display: flex;
-  align-items: baseline;
-  justify-content: space-between;
-  gap: 0.5rem;
-}
-
-.clearAction {
-  font-size: $aux-text-size;
-  color: $blue-400;
-  margin-bottom: $element-inner-spacing; // match the label
-  text-decoration: underline;
-  text-underline-offset: 2px;
-
-  &:hover {
-    color: $blue-500;
-  }
-}
-
 .splitTwo {
   display: grid;
   grid-template-columns: 1fr 1fr;

apps/client/src/features/rundown/entry-editor/EventEditor.tsx

@@ -1,19 +1,14 @@
 import { OntimeEvent } from 'ontime-types';
-import { useCallback, useMemo } from 'react';
+import { useCallback } from 'react';
 
 import * as Editor from '../../../common/components/editor-utils/EditorUtils';
-import Info from '../../../common/components/info/Info';
 import AppLink from '../../../common/components/link/app-link/AppLink';
 import { useEntryActionsContext } from '../../../common/context/EntryActionsContext';
 import useCustomFields from '../../../common/hooks-query/useCustomFields';
-import EventEditorBatchSchedule from './composite/EventEditorBatchSchedule';
 import EntryEditorCustomFields from './composite/EventEditorCustomFields';
-import EventEditorSchedule from './composite/EventEditorSchedule';
 import EventEditorTimes from './composite/EventEditorTimes';
 import EventEditorTitles from './composite/EventEditorTitles';
 import EventEditorTriggers from './composite/EventEditorTriggers';
-import { mixedPlaceholder } from './entryEditor.utils';
-import { mergeEvents, resolveConflict } from './mergeEvents';
 
 import style from './EntryEditor.module.scss';
 
@@ -21,115 +16,66 @@ import style from './EntryEditor.module.scss';
 export type EventEditorUpdateFields = 'cue' | 'title' | 'note' | 'colour' | string;
 
 interface EventEditorProps {
-  /** events being edited, editing several events at once shows a merged view of their values */
-  events: OntimeEvent[];
+  event: OntimeEvent;
 }
 
-export default function EventEditor({ events }: EventEditorProps) {
+export default function EventEditor({ event }: EventEditorProps) {
   const { data: customFields } = useCustomFields();
-  const { updateEntry, batchUpdateEvents } = useEntryActionsContext();
+  const { updateEntry } = useEntryActionsContext();
 
   const isEditor = window.location.pathname.includes('editor');
 
-  const ids = useMemo(() => events.map((event) => event.id), [events]);
-  const merged = useMemo(() => mergeEvents(events), [events]);
-
-  // when editing a single event, we can show the values which are unique to it
-  const singleEvent = events.length === 1 ? events[0] : null;
-
-  /**
-   * Applies a patch to every event being edited
-   */
-  const submit = useCallback(
-    (patch: Partial<OntimeEvent>) => {
-      if (ids.length === 1) {
-        updateEntry({ id: ids[0], ...patch });
-        return;
-      }
-      batchUpdateEvents(patch, ids);
-    },
-    [batchUpdateEvents, ids, updateEntry],
-  );
-
   const handleSubmit = useCallback(
     (field: EventEditorUpdateFields, value: string) => {
       if (field.startsWith('custom-')) {
         const fieldLabel = field.split('custom-')[1];
-        submit({ custom: { [fieldLabel]: value } });
+        updateEntry({ id: event.id, custom: { [fieldLabel]: value } });
       } else {
-        submit({ [field]: value });
+        updateEntry({ id: event.id, [field]: value });
       }
     },
-    [submit],
+    [event.id, updateEntry],
   );
 
-  // inputs keep local state, we remount them when the edited entries change
-  const editorKey = ids.join();
-
   return (
     <div className={style.content}>
-      {singleEvent ? (
-        <EventEditorSchedule
-          key={`${editorKey}-schedule`}
-          eventId={singleEvent.id}
-          timeStart={singleEvent.timeStart}
-          timeEnd={singleEvent.timeEnd}
-          duration={singleEvent.duration}
-          timeStrategy={singleEvent.timeStrategy}
-          linkStart={singleEvent.linkStart}
-          delay={singleEvent.delay}
-        />
-      ) : (
-        <EventEditorBatchSchedule
-          key={`${editorKey}-schedule`}
-          duration={resolveConflict(merged.duration)}
-          submit={submit}
-        />
-      )}
       <EventEditorTimes
-        key={`${editorKey}-times`}
-        countToEnd={resolveConflict(merged.countToEnd)}
-        endAction={resolveConflict(merged.endAction)}
-        timerType={resolveConflict(merged.timerType)}
-        timeWarning={resolveConflict(merged.timeWarning)}
-        timeDanger={resolveConflict(merged.timeDanger)}
-        submit={submit}
+        key={`${event.id}-times`}
+        eventId={event.id}
+        timeStart={event.timeStart}
+        timeEnd={event.timeEnd}
+        duration={event.duration}
+        timeStrategy={event.timeStrategy}
+        linkStart={event.linkStart}
+        countToEnd={event.countToEnd}
+        delay={event.delay}
+        endAction={event.endAction}
+        timerType={event.timerType}
+        timeWarning={event.timeWarning}
+        timeDanger={event.timeDanger}
       />
       <EventEditorTitles
-        key={`${editorKey}-titles`}
-        eventId={singleEvent?.id ?? null}
-        eventCount={events.length}
-        cue={singleEvent?.cue ?? ''}
-        flag={resolveConflict(merged.flag)}
-        title={resolveConflict(merged.title)}
-        note={resolveConflict(merged.note)}
-        colour={resolveConflict(merged.colour)}
-        submit={submit}
+        key={`${event.id}-titles`}
+        eventId={event.id}
+        cue={event.cue}
+        flag={event.flag}
+        title={event.title}
+        note={event.note}
+        colour={event.colour}
       />
       <div className={style.column}>
         <Editor.Title>
           Custom Fields
           {isEditor && <AppLink search='settings=manage__custom'>Manage Custom Fields</AppLink>}
         </Editor.Title>
-        <EntryEditorCustomFields
-          key={`${editorKey}-custom`}
-          fields={customFields}
-          custom={merged.custom}
-          idKey={editorKey}
-          mixedPlaceholder={mixedPlaceholder}
-          handleSubmit={handleSubmit}
-        />
+        <EntryEditorCustomFields fields={customFields} handleSubmit={handleSubmit} entry={event} />
       </div>
       <div className={style.column}>
         <Editor.Title>
           Automations
-          {isEditor && singleEvent && <AppLink search='settings=automation'>Manage Automations</AppLink>}
+          {isEditor && <AppLink search='settings=automation'>Manage Automations</AppLink>}
         </Editor.Title>
-        {singleEvent ? (
-          <EventEditorTriggers triggers={singleEvent.triggers} eventId={singleEvent.id} />
-        ) : (
-          <Info>Automations are not available when editing multiple events</Info>
-        )}
+        <EventEditorTriggers triggers={event.triggers} eventId={event.id} />
       </div>
     </div>
   );

apps/client/src/features/rundown/entry-editor/GroupEditor.tsx

@@ -112,12 +112,7 @@ export default function GroupEditor({ group }: GroupEditorProps) {
           Custom Fields
           {isEditor && <AppLink search='settings=manage__custom'>Manage Custom Fields</AppLink>}
         </Editor.Title>
-        <EntryEditorCustomFields
-          fields={customFields}
-          handleSubmit={handleSubmit}
-          custom={group.custom}
-          idKey={group.id}
-        />
+        <EntryEditorCustomFields fields={customFields} handleSubmit={handleSubmit} entry={group} />
       </div>
     </div>
   );

apps/client/src/features/rundown/entry-editor/MilestoneEditor.tsx

@@ -69,12 +69,7 @@ export default function MilestoneEditor({ milestone }: MilestoneEditorProps) {
           Custom Fields
           {isEditor && <AppLink search='settings=manage__custom'>Manage Custom Fields</AppLink>}
         </Editor.Title>
-        <EntryEditorCustomFields
-          fields={customFields}
-          handleSubmit={handleSubmit}
-          custom={milestone.custom}
-          idKey={milestone.id}
-        />
+        <EntryEditorCustomFields fields={customFields} handleSubmit={handleSubmit} entry={milestone} />
       </div>
     </div>
   );

apps/client/src/features/rundown/entry-editor/RundownEntryEditor.tsx

@@ -1,4 +1,4 @@
-import { OntimeEntry, OntimeEvent, isOntimeEvent, isOntimeGroup, isOntimeMilestone } from 'ontime-types';
+import { OntimeEntry, isOntimeEvent, isOntimeGroup, isOntimeMilestone } from 'ontime-types';
 import { useMemo } from 'react';
 
 import useRundown from '../../../common/hooks-query/useRundown';
@@ -15,25 +15,6 @@ export default function RundownEntryEditor() {
   const selectedEvents = useEventSelection((state) => state.selectedEvents);
   const { data } = useRundown();
 
-  /**
-   * Events in the current selection
-   * Only events can be multi selected, groups and milestones are always selected on their own
-   */
-  const events = useMemo<OntimeEvent[]>(() => {
-    if (data.order.length === 0) {
-      return [];
-    }
-
-    const selection: OntimeEvent[] = [];
-    selectedEvents.forEach((entryId) => {
-      const entry = data.entries[entryId];
-      if (isOntimeEvent(entry)) {
-        selection.push(entry);
-      }
-    });
-    return selection;
-  }, [data.order.length, data.entries, selectedEvents]);
-
   const entry = useMemo<OntimeEntry | null>(() => {
     if (data.order.length === 0) {
       return null;
@@ -48,20 +29,19 @@ export default function RundownEntryEditor() {
     return event ?? null;
   }, [data.order.length, data.entries, selectedEvents]);
 
-  if (events.length > 0) {
-    const singleEvent = events.length === 1 ? events[0] : null;
-    return (
-      <div className={style.rundownEditor} data-testid='editor-container'>
-        <EventEditor events={events} />
-        {singleEvent && <EventEditorFooter id={singleEvent.id} cue={singleEvent.cue} />}
-      </div>
-    );
-  }
-
   if (!entry) {
     return <EventEditorEmpty />;
   }
 
+  if (isOntimeEvent(entry)) {
+    return (
+      <div className={style.rundownEditor} data-testid='editor-container'>
+        <EventEditor event={entry} />
+        <EventEditorFooter id={entry.id} cue={entry.cue} />
+      </div>
+    );
+  }
+
   if (isOntimeMilestone(entry)) {
     return (
       <div className={style.rundownEditor} data-testid='editor-container'>

apps/client/src/features/rundown/entry-editor/__tests__/mergeEvents.test.ts

@@ -1,122 +0,0 @@
-import { EndAction, OntimeEvent, SupportedEntry, TimerType } from 'ontime-types';
-
-import { conflict, isConflict, mergeEvents, resolveConflict } from '../mergeEvents';
-
-function makeEvent(patch: Partial<OntimeEvent>): OntimeEvent {
-  return {
-    type: SupportedEntry.Event,
-    id: 'event',
-    title: 'title',
-    note: 'note',
-    colour: '#FFCC78',
-    flag: false,
-    duration: 600000,
-    endAction: EndAction.None,
-    countToEnd: false,
-    timerType: TimerType.CountDown,
-    timeWarning: 120000,
-    timeDanger: 60000,
-    linkStart: true,
-    custom: {},
-    ...patch,
-  } as OntimeEvent;
-}
-
-describe('mergeEvents()', () => {
-  it('returns the values of a single event', () => {
-    const event = makeEvent({ id: '1', title: 'only event' });
-
-    expect(mergeEvents([event])).toStrictEqual({
-      title: 'only event',
-      note: 'note',
-      colour: '#FFCC78',
-      flag: false,
-      duration: 600000,
-      endAction: EndAction.None,
-      countToEnd: false,
-      timerType: TimerType.CountDown,
-      timeWarning: 120000,
-      timeDanger: 60000,
-      linkStart: true,
-      custom: {},
-    });
-  });
-
-  it('keeps values which are shared by all events', () => {
-    const merged = mergeEvents([makeEvent({ id: '1' }), makeEvent({ id: '2' }), makeEvent({ id: '3' })]);
-
-    expect(merged.title).toBe('title');
-    expect(merged.colour).toBe('#FFCC78');
-    expect(merged.timerType).toBe(TimerType.CountDown);
-    expect(merged.duration).toBe(600000);
-  });
-
-  it('marks only the fields which differ as conflicting', () => {
-    const merged = mergeEvents([makeEvent({ id: '1', title: 'first' }), makeEvent({ id: '2', title: 'second' })]);
-
-    expect(merged.title).toBe(conflict);
-    expect(merged.note).toBe('note');
-    expect(merged.colour).toBe('#FFCC78');
-    expect(merged.flag).toBe(false);
-  });
-
-  it('handles boolean and numeric fields', () => {
-    const merged = mergeEvents([
-      makeEvent({ id: '1', flag: true, timeWarning: 1000, duration: 1000 }),
-      makeEvent({ id: '2', flag: false, timeWarning: 1000, duration: 2000 }),
-    ]);
-
-    expect(merged.flag).toBe(conflict);
-    expect(merged.timeWarning).toBe(1000);
-    expect(merged.duration).toBe(conflict);
-  });
-
-  describe('custom fields', () => {
-    it('merges values under the same key', () => {
-      const merged = mergeEvents([
-        makeEvent({ id: '1', custom: { lx: 'same', sound: 'a' } }),
-        makeEvent({ id: '2', custom: { lx: 'same', sound: 'b' } }),
-      ]);
-
-      expect(merged.custom).toStrictEqual({ lx: 'same', sound: conflict });
-    });
-
-    it('treats a missing key as empty', () => {
-      const merged = mergeEvents([makeEvent({ id: '1', custom: { lx: 'value' } }), makeEvent({ id: '2', custom: {} })]);
-
-      expect(merged.custom).toStrictEqual({ lx: conflict });
-    });
-
-    it('collects keys from all events', () => {
-      const merged = mergeEvents([
-        makeEvent({ id: '1', custom: { lx: '' } }),
-        makeEvent({ id: '2', custom: { sound: 'value' } }),
-      ]);
-
-      // lx is empty in both events, sound is only filled in one of them
-      expect(merged.custom).toStrictEqual({ lx: '', sound: conflict });
-    });
-
-    it('does not report a key which is absent from every event', () => {
-      const merged = mergeEvents([makeEvent({ id: '1', custom: {} }), makeEvent({ id: '2', custom: {} })]);
-
-      expect(merged.custom).toStrictEqual({});
-      // an absent key is distinguishable from a conflicting one
-      expect(merged.custom.lx).toBeUndefined();
-      expect(isConflict(merged.custom.lx)).toBe(false);
-    });
-  });
-});
-
-describe('resolveConflict()', () => {
-  it('passes known values through', () => {
-    expect(resolveConflict('value')).toBe('value');
-    expect(resolveConflict(0)).toBe(0);
-    expect(resolveConflict(false)).toBe(false);
-    expect(resolveConflict('')).toBe('');
-  });
-
-  it('resolves a conflict to undefined', () => {
-    expect(resolveConflict(conflict)).toBeUndefined();
-  });
-});

apps/client/src/features/rundown/entry-editor/composite/EventEditorBatchSchedule.tsx

@@ -1,48 +0,0 @@
-import { OntimeEvent } from 'ontime-types';
-import { MILLIS_PER_SECOND, dayInMs, parseUserTime } from 'ontime-utils';
-import { memo } from 'react';
-
-import * as Editor from '../../../../common/components/editor-utils/EditorUtils';
-import TimeInput from '../../../../common/components/input/time-input/TimeInput';
-import { mixedPlaceholder } from '../entryEditor.utils';
-
-import style from '../EntryEditor.module.scss';
-
-interface EventEditorBatchScheduleProps {
-  /** undefined when the events do not share a duration */
-  duration: number | undefined;
-  submit: (patch: Partial<OntimeEvent>) => void;
-}
-
-/**
- * Schedule fields which can be applied to several events at once
- * Start and end times are absolute points in time: giving several events the same
- * value would collapse their durations, so only the duration is offered here
- * The server infers the duration lock and recalculates the rundown once for the whole batch
- */
-export default memo(EventEditorBatchSchedule);
-function EventEditorBatchSchedule({ duration, submit }: EventEditorBatchScheduleProps) {
-  const handleSubmit = (_field: 'duration', value: string) => {
-    // durations cannot exceed a day
-    submit({ duration: Math.min(parseUserTime(value), dayInMs - MILLIS_PER_SECOND) });
-  };
-
-  return (
-    <div className={style.column}>
-      <Editor.Title>Event schedule</Editor.Title>
-      <div className={style.splitTwo}>
-        <div>
-          <Editor.Label htmlFor='duration'>Duration</Editor.Label>
-          <TimeInput
-            id='duration'
-            name='duration'
-            submitHandler={handleSubmit}
-            time={duration}
-            placeholder={duration === undefined ? mixedPlaceholder : 'Duration'}
-            align='left'
-          />
-        </div>
-      </div>
-    </div>
-  );
-}

apps/client/src/features/rundown/entry-editor/composite/EventEditorCustomFields.tsx

@@ -1,9 +1,8 @@
-import { CustomFields, EntryCustomFields } from 'ontime-types';
+import { CustomFields, OntimeEvent, OntimeGroup, OntimeMilestone } from 'ontime-types';
 import { CSSProperties, Fragment } from 'react';
 
 import { getAccessibleColour } from '../../../../common/utils/styleUtils';
 import { EventEditorUpdateFields } from '../EventEditor';
-import { MergedCustomFields, resolveConflict } from '../mergeEvents';
 import EventEditorImage from './EventEditorImage';
 import EventTextArea from './EventTextArea';
 import EntryEditorTextInput from './EventTextInput';
@@ -12,29 +11,21 @@ import style from '../EntryEditor.module.scss';
 
 interface EntryEditorCustomFieldsProps {
   fields: CustomFields;
-  /** values of the entries being edited, undefined when the entries do not agree */
-  custom: EntryCustomFields | MergedCustomFields;
-  /** used to generate stable keys for the fields */
-  idKey: string;
-  mixedPlaceholder?: string;
+  entry: OntimeEvent | OntimeGroup | OntimeMilestone;
   handleSubmit: (field: EventEditorUpdateFields, value: string) => void;
 }
 
 export default function EntryEditorCustomFields({
   fields: customFields,
-  custom,
-  idKey,
-  mixedPlaceholder,
   handleSubmit,
+  entry,
 }: EntryEditorCustomFieldsProps) {
   return (
     <Fragment>
       {Object.keys(customFields).map((fieldKey) => {
-        const key = `${idKey}-${fieldKey}`;
+        const key = `${entry.id}-${fieldKey}`;
         const fieldName = `custom-${fieldKey}`;
-        // a key which is absent from the merged view is not present in any of the entries
-        const initialValue = resolveConflict(custom[fieldKey] ?? '');
-        const placeholder = initialValue === undefined ? mixedPlaceholder : undefined;
+        const initialValue = entry.custom[fieldKey] ?? '';
         const { backgroundColor, color } = getAccessibleColour(customFields[fieldKey].colour);
         const labelText = customFields[fieldKey].label;
 
@@ -45,7 +36,6 @@ export default function EntryEditorCustomFields({
               field={fieldName}
               label={labelText}
               initialValue={initialValue}
-              placeholder={placeholder}
               submitHandler={handleSubmit}
               className={style.decorated}
               style={{ '--decorator-bg': backgroundColor, '--decorator-color': color } as CSSProperties}
@@ -61,13 +51,13 @@ export default function EntryEditorCustomFields({
                 field={fieldName}
                 label={labelText}
                 initialValue={initialValue}
-                placeholder={placeholder ?? 'Paste image URL'}
+                placeholder='Paste image URL'
                 submitHandler={handleSubmit}
                 className={style.decorated}
                 maxLength={255}
                 style={{ '--decorator-bg': backgroundColor, '--decorator-color': color } as CSSProperties}
               />
-              <EventEditorImage src={initialValue ?? ''} />
+              <EventEditorImage src={initialValue} />
             </div>
           );
         }

apps/client/src/features/rundown/entry-editor/composite/EventEditorSchedule.tsx

@@ -1,62 +0,0 @@
-import { TimeStrategy } from 'ontime-types';
-import { memo } from 'react';
-
-import * as Editor from '../../../../common/components/editor-utils/EditorUtils';
-import { millisToDelayString } from '../../../../common/utils/dateConfig';
-import { formatTime, normaliseWallClock } from '../../../../common/utils/time';
-import TimeInputFlow from '../../time-input-flow/TimeInputFlow';
-
-import style from '../EntryEditor.module.scss';
-
-interface EventEditorScheduleProps {
-  eventId: string;
-  timeStart: number;
-  timeEnd: number;
-  duration: number;
-  timeStrategy: TimeStrategy;
-  linkStart: boolean;
-  delay: number;
-}
-
-/**
- * Schedule of a single event
- * Schedule values cascade through the rundown, so they are not editable across a selection
- */
-export default memo(EventEditorSchedule);
-function EventEditorSchedule({
-  eventId,
-  timeStart,
-  timeEnd,
-  duration,
-  timeStrategy,
-  linkStart,
-  delay,
-}: EventEditorScheduleProps) {
-  const hasDelay = delay !== 0;
-  const delayedStart = normaliseWallClock(timeStart + delay);
-  const delayedEnd = normaliseWallClock(timeEnd + delay);
-  const delayLabel = hasDelay
-    ? `Event is ${millisToDelayString(delay, 'expanded')}. New schedule ${formatTime(delayedStart)} → ${formatTime(delayedEnd)}`
-    : '';
-
-  return (
-    <div className={style.column}>
-      <Editor.Title>Event schedule</Editor.Title>
-      <div>
-        <div className={style.inline}>
-          <TimeInputFlow
-            eventId={eventId}
-            timeStart={timeStart}
-            timeEnd={timeEnd}
-            duration={duration}
-            timeStrategy={timeStrategy}
-            linkStart={linkStart}
-            delay={delay}
-            showLabels
-          />
-        </div>
-        <div className={style.delayLabel}>{delayLabel}</div>
-      </div>
-    </div>
-  );
-}

apps/client/src/features/rundown/entry-editor/composite/EventEditorTimes.tsx

@@ -1,4 +1,4 @@
-import { EndAction, OntimeEvent, TimerType } from 'ontime-types';
+import { EndAction, TimeStrategy, TimerType } from 'ontime-types';
 import { parseUserTime } from 'ontime-utils';
 import { memo } from 'react';
 import { IoInformationCircle } from 'react-icons/io5';
@@ -8,47 +8,103 @@ import TimeInput from '../../../../common/components/input/time-input/TimeInput'
 import Select from '../../../../common/components/select/Select';
 import Switch from '../../../../common/components/switch/Switch';
 import Tooltip from '../../../../common/components/tooltip/Tooltip';
-import { mixedPlaceholder, switchLabel } from '../entryEditor.utils';
+import { useEntryActionsContext } from '../../../../common/context/EntryActionsContext';
+import { millisToDelayString } from '../../../../common/utils/dateConfig';
+import { formatTime, normaliseWallClock } from '../../../../common/utils/time';
+import TimeInputFlow from '../../time-input-flow/TimeInputFlow';
 
 import style from '../EntryEditor.module.scss';
 
 interface EventEditorTimesProps {
-  countToEnd: boolean | undefined;
-  endAction: EndAction | undefined;
-  timerType: TimerType | undefined;
-  timeWarning: number | undefined;
-  timeDanger: number | undefined;
-  submit: (patch: Partial<OntimeEvent>) => void;
+  eventId: string;
+  timeStart: number;
+  timeEnd: number;
+  duration: number;
+  timeStrategy: TimeStrategy;
+  linkStart: boolean;
+  countToEnd: boolean;
+  delay: number;
+  endAction: EndAction;
+  timerType: TimerType;
+  timeWarning: number;
+  timeDanger: number;
 }
 
-type TimeFields = 'timeWarning' | 'timeDanger';
+type HandledActions = 'countToEnd' | 'timerType' | 'endAction' | 'timeWarning' | 'timeDanger';
 
 export default memo(EventEditorTimes);
 function EventEditorTimes({
+  eventId,
+  timeStart,
+  timeEnd,
+  duration,
+  timeStrategy,
+  linkStart,
   countToEnd,
+  delay,
   endAction,
   timerType,
   timeWarning,
   timeDanger,
-  submit,
 }: EventEditorTimesProps) {
-  const handleTimeSubmit = (field: TimeFields, value: string) => {
-    submit({ [field]: parseUserTime(value) });
+  const { updateEntry } = useEntryActionsContext();
+
+  const handleSubmit = (field: HandledActions, value: string | boolean) => {
+    if (field === 'countToEnd') {
+      updateEntry({ id: eventId, countToEnd: value as boolean });
+      return;
+    }
+
+    if (field === 'timeWarning' || field === 'timeDanger') {
+      const newTime = parseUserTime(value as string);
+      updateEntry({ id: eventId, [field]: newTime });
+      return;
+    }
+
+    if (field === 'timerType' || field === 'endAction') {
+      updateEntry({ id: eventId, [field]: value });
+      return;
+    }
   };
 
+  const hasDelay = delay !== 0;
+  const delayedStart = normaliseWallClock(timeStart + delay);
+  const delayedEnd = normaliseWallClock(timeEnd + delay);
+  const delayLabel = hasDelay
+    ? `Event is ${millisToDelayString(delay, 'expanded')}. New schedule ${formatTime(delayedStart)} → ${formatTime(delayedEnd)}`
+    : '';
+
   return (
     <>
+      <div className={style.column}>
+        <Editor.Title>Event schedule</Editor.Title>
+        <div>
+          <div className={style.inline}>
+            <TimeInputFlow
+              eventId={eventId}
+              timeStart={timeStart}
+              timeEnd={timeEnd}
+              duration={duration}
+              timeStrategy={timeStrategy}
+              linkStart={linkStart}
+              delay={delay}
+              showLabels
+            />
+          </div>
+          <div className={style.delayLabel}>{delayLabel}</div>
+        </div>
+      </div>
+
       <div className={style.column}>
         <Editor.Title>Event Behaviour</Editor.Title>
         <div className={style.splitTwo}>
           <div>
             <Editor.Label htmlFor='endAction'>End Action</Editor.Label>
             <Select
-              value={endAction ?? null}
-              placeholder={mixedPlaceholder}
+              value={endAction}
               onValueChange={(value: EndAction | null) => {
                 if (value === null) return;
-                submit({ endAction: value });
+                handleSubmit('endAction', value);
               }}
               options={[
                 { value: EndAction.None, label: 'None' },
@@ -62,11 +118,10 @@ function EventEditorTimes({
             <Editor.Label className={style.switchLabel}>
               <Switch
                 id='countToEnd'
-                checked={countToEnd ?? false}
-                mixed={countToEnd === undefined}
-                onCheckedChange={(value) => submit({ countToEnd: value })}
+                checked={countToEnd}
+                onCheckedChange={(value) => handleSubmit('countToEnd', value)}
               />
-              {switchLabel(countToEnd)}
+              {countToEnd ? 'On' : 'Off'}
             </Editor.Label>
           </div>
         </div>
@@ -86,11 +141,10 @@ function EventEditorTimes({
           <div>
             <Editor.Label htmlFor='timerType'>Timer Type</Editor.Label>
             <Select
-              value={timerType ?? null}
-              placeholder={mixedPlaceholder}
+              value={timerType}
               onValueChange={(value: TimerType | null) => {
                 if (value === null) return;
-                submit({ timerType: value });
+                handleSubmit('timerType', value);
               }}
               options={[
                 { value: TimerType.CountDown, label: 'Count down' },
@@ -107,9 +161,9 @@ function EventEditorTimes({
               <TimeInput
                 id='timeWarning'
                 name='timeWarning'
-                submitHandler={handleTimeSubmit}
+                submitHandler={handleSubmit}
                 time={timeWarning}
-                placeholder={timeWarning === undefined ? mixedPlaceholder : 'Duration'}
+                placeholder='Duration'
               />
             </div>
             <div>
@@ -117,9 +171,9 @@ function EventEditorTimes({
               <TimeInput
                 id='timeDanger'
                 name='timeDanger'
-                submitHandler={handleTimeSubmit}
+                submitHandler={handleSubmit}
                 time={timeDanger}
-                placeholder={timeDanger === undefined ? mixedPlaceholder : 'Duration'}
+                placeholder='Duration'
               />
             </div>
           </div>

apps/client/src/features/rundown/entry-editor/composite/EventEditorTitles.tsx

@@ -1,36 +1,34 @@
-import { OntimeEvent } from 'ontime-types';
 import { memo } from 'react';
 
 import * as Editor from '../../../../common/components/editor-utils/EditorUtils';
 import SwatchSelect from '../../../../common/components/input/colour-input/SwatchSelect';
 import Input from '../../../../common/components/input/input/Input';
 import Switch from '../../../../common/components/switch/Switch';
-import { enDash } from '../../../../common/utils/styleUtils';
-import { mixedPlaceholder, switchLabel } from '../entryEditor.utils';
+import { useEntryActionsContext } from '../../../../common/context/EntryActionsContext';
 import EventTextArea from './EventTextArea';
 import EntryEditorTextInput from './EventTextInput';
 
 import style from '../EntryEditor.module.scss';
 
 interface EventEditorTitlesProps {
-  /** id of the event being edited, null when editing several events */
-  eventId: string | null;
-  /** amount of events being edited */
-  eventCount: number;
+  eventId: string;
   cue: string;
-  flag: boolean | undefined;
-  title: string | undefined;
-  note: string | undefined;
-  colour: string | undefined;
-  submit: (patch: Partial<OntimeEvent>) => void;
+  flag: boolean;
+  title: string;
+  note: string;
+  colour: string;
 }
 
 export default memo(EventEditorTitles);
-function EventEditorTitles({ eventId, eventCount, cue, flag, title, note, colour, submit }: EventEditorTitlesProps) {
-  const isMulti = eventId === null;
+function EventEditorTitles({ eventId, cue, flag, title, note, colour }: EventEditorTitlesProps) {
+  const { updateEntry } = useEntryActionsContext();
+
+  const flagSubmitHandler = (newValue: boolean) => {
+    updateEntry({ id: eventId, flag: newValue });
+  };
 
   const textSubmitHandler = (field: string, newValue: string) => {
-    submit({ [field]: newValue });
+    updateEntry({ id: eventId, [field]: newValue });
   };
 
   return (
@@ -38,39 +36,21 @@ function EventEditorTitles({ eventId, eventCount, cue, flag, title, note, colour
       <Editor.Title>Event Data</Editor.Title>
       <div className={style.splitThree}>
         <div>
-          <Editor.Label htmlFor='eventId'>{isMulti ? 'Selection (read only)' : 'Event ID (read only)'}</Editor.Label>
-          <Input
-            id='eventId'
-            data-testid='input-textfield'
-            value={isMulti ? `${eventCount} events selected` : eventId}
-            readOnly
-            fluid
-          />
+          <Editor.Label htmlFor='eventId'>Event ID (read only)</Editor.Label>
+          <Input id='eventId' data-testid='input-textfield' value={eventId} readOnly fluid />
         </div>
-        {isMulti ? (
-          <div>
-            <Editor.Label htmlFor='cue'>Cue (not available)</Editor.Label>
-            <Input id='cue' value={enDash} readOnly fluid />
-          </div>
-        ) : (
-          <EntryEditorTextInput
-            field='cue'
-            label='Cue'
-            initialValue={cue}
-            submitHandler={textSubmitHandler}
-            maxLength={10}
-          />
-        )}
+        <EntryEditorTextInput
+          field='cue'
+          label='Cue'
+          initialValue={cue}
+          submitHandler={textSubmitHandler}
+          maxLength={10}
+        />
         <div>
           <Editor.Label htmlFor='flag'>Flag</Editor.Label>
           <Editor.Label className={style.switchLabel}>
-            <Switch
-              id='flag'
-              checked={flag ?? false}
-              mixed={flag === undefined}
-              onCheckedChange={(newValue) => submit({ flag: newValue })}
-            />
-            {switchLabel(flag)}
+            <Switch id='flag' checked={flag} onCheckedChange={flagSubmitHandler} />
+            {flag ? 'On' : 'Off'}
           </Editor.Label>
         </div>
       </div>
@@ -78,20 +58,8 @@ function EventEditorTitles({ eventId, eventCount, cue, flag, title, note, colour
         <Editor.Label>Colour</Editor.Label>
         <SwatchSelect name='colour' value={colour} handleChange={textSubmitHandler} />
       </div>
-      <EntryEditorTextInput
-        field='title'
-        label='Title'
-        initialValue={title}
-        placeholder={title === undefined ? mixedPlaceholder : undefined}
-        submitHandler={textSubmitHandler}
-      />
-      <EventTextArea
-        field='note'
-        label='Note'
-        initialValue={note}
-        placeholder={note === undefined ? mixedPlaceholder : undefined}
-        submitHandler={textSubmitHandler}
-      />
+      <EntryEditorTextInput field='title' label='Title' initialValue={title} submitHandler={textSubmitHandler} />
+      <EventTextArea field='note' label='Note' initialValue={note} submitHandler={textSubmitHandler} />
     </div>
   );
 }

apps/client/src/features/rundown/entry-editor/composite/EventTextArea.tsx

@@ -5,15 +5,11 @@ import { AutoTextarea } from '../../../../common/components/input/auto-textarea/
 import useReactiveTextInput from '../../../../common/components/input/text-input/useReactiveTextInput';
 import { EventEditorUpdateFields } from '../EventEditor';
 
-import style from '../EntryEditor.module.scss';
-
 interface CountedTextAreaProps {
   className?: string;
   field: EventEditorUpdateFields;
   label: string;
-  /** undefined represents values which do not agree across the edited entries */
-  initialValue: string | undefined;
-  placeholder?: string;
+  initialValue: string;
   style?: CSSProperties;
   submitHandler: (field: EventEditorUpdateFields, value: string) => void;
 }
@@ -23,7 +19,6 @@ export default function EventTextArea({
   field,
   label,
   initialValue,
-  placeholder,
   style: givenStyles,
   submitHandler,
 }: CountedTextAreaProps) {
@@ -34,27 +29,16 @@ export default function EventTextArea({
     submitOnCtrlEnter: true,
   });
 
-  // an unknown value cannot be cleared by emptying the field, we offer an explicit action
-  const canClear = initialValue === undefined;
-
   return (
     <div>
-      <div className={style.labelRow}>
-        <Editor.Label className={className} htmlFor={field} style={givenStyles}>
-          {label}
-        </Editor.Label>
-        {canClear && (
-          <button type='button' className={style.clearAction} onClick={() => submitCallback('')}>
-            Clear
-          </button>
-        )}
-      </div>
+      <Editor.Label className={className} htmlFor={field} style={givenStyles}>
+        {label}
+      </Editor.Label>
       <AutoTextarea
         id={field}
         inputref={ref}
         rows={1}
         data-testid='input-textarea'
-        placeholder={placeholder}
         fluid
         value={value}
         onChange={onChange}

apps/client/src/features/rundown/entry-editor/composite/EventTextInput.tsx

@@ -6,13 +6,10 @@ import useReactiveTextInput from '../../../../common/components/input/text-input
 import { EventEditorUpdateFields } from '../EventEditor';
 import { GroupEditorUpdateTextFields } from '../GroupEditor';
 
-import style from '../EntryEditor.module.scss';
-
 interface EntryEditorTextInputProps extends InputProps {
   field: EventEditorUpdateFields | GroupEditorUpdateTextFields;
   label: string;
-  /** undefined represents values which do not agree across the edited entries */
-  initialValue: string | undefined;
+  initialValue: string;
   placeholder?: string;
   submitHandler: (field: EventEditorUpdateFields, value: string) => void;
 }
@@ -34,21 +31,11 @@ export default function EntryEditorTextInput({
     submitOnEnter: true,
   });
 
-  // an unknown value cannot be cleared by emptying the field, we offer an explicit action
-  const canClear = initialValue === undefined;
-
   return (
     <div>
-      <div className={style.labelRow}>
-        <Editor.Label className={className} htmlFor={field} style={givenStyles}>
-          {label}
-        </Editor.Label>
-        {canClear && (
-          <button type='button' className={style.clearAction} onClick={() => submitCallback('')}>
-            Clear
-          </button>
-        )}
-      </div>
+      <Editor.Label className={className} htmlFor={field} style={givenStyles}>
+        {label}
+      </Editor.Label>
       <Input
         id={field}
         ref={ref}

apps/client/src/features/rundown/entry-editor/entryEditor.utils.ts

@@ -1,10 +0,0 @@
-/** Shown in place of a value when the entries being edited do not agree */
-export const mixedPlaceholder = 'Mixed';
-
-/** Returns the label of a switch which may represent values that do not agree */
-export function switchLabel(value: boolean | undefined): string {
-  if (value === undefined) {
-    return mixedPlaceholder;
-  }
-  return value ? 'On' : 'Off';
-}

apps/client/src/features/rundown/entry-editor/mergeEvents.ts

@@ -1,108 +0,0 @@
-import { CustomFieldKey, OntimeEvent } from 'ontime-types';
-
-/**
- * Marks a value which is not the same across the entries being edited
- * This is a distinct value from undefined, which means that the field is absent
- * Being a symbol, it also cannot be assigned to a patch by accident
- */
-export const conflict: unique symbol = Symbol('conflict');
-export type Conflict = typeof conflict;
-
-/** A value which may not be the same across the entries being edited */
-export type MergedValue<T> = T | Conflict;
-
-export function isConflict<T>(value: MergedValue<T>): value is Conflict {
-  return value === conflict;
-}
-
-/** Resolves a merged value for the UI, where an unknown value is represented by undefined */
-export function resolveConflict<T>(value: MergedValue<T>): T | undefined {
-  return isConflict(value) ? undefined : value;
-}
-
-/**
- * Fields which can be edited across a selection of events
- * timeStart and timeEnd are absolute points in time and are excluded:
- * giving several events the same start or end collapses their durations
- */
-export const batchEditableFields = [
-  'title',
-  'note',
-  'colour',
-  'flag',
-  'duration',
-  'endAction',
-  'countToEnd',
-  'timerType',
-  'timeWarning',
-  'timeDanger',
-  'linkStart',
-] as const;
-
-type BatchEditableField = (typeof batchEditableFields)[number];
-
-/**
- * Custom fields of the entries being edited
- * A missing key means that none of the entries have a value for that field
- */
-export type MergedCustomFields = Record<CustomFieldKey, MergedValue<string>>;
-
-/**
- * A merged view over a set of events
- * A field holds the conflict symbol when the events do not agree on its value
- */
-export type MergedEvent = {
-  [K in BatchEditableField]: MergedValue<OntimeEvent[K]>;
-} & {
-  custom: MergedCustomFields;
-};
-
-/**
- * Merges a list of events into a single view
- * For a single event, no field is in conflict and every value matches the event
- * @param events - events to merge, must contain at least one element
- */
-export function mergeEvents(events: OntimeEvent[]): MergedEvent {
-  return {
-    title: mergeField(events, 'title'),
-    note: mergeField(events, 'note'),
-    colour: mergeField(events, 'colour'),
-    flag: mergeField(events, 'flag'),
-    duration: mergeField(events, 'duration'),
-    endAction: mergeField(events, 'endAction'),
-    countToEnd: mergeField(events, 'countToEnd'),
-    timerType: mergeField(events, 'timerType'),
-    timeWarning: mergeField(events, 'timeWarning'),
-    timeDanger: mergeField(events, 'timeDanger'),
-    linkStart: mergeField(events, 'linkStart'),
-    custom: mergeCustomFields(events),
-  };
-}
-
-/**
- * Returns the shared value of a field, or the conflict symbol if the events disagree
- */
-function mergeField<K extends BatchEditableField>(events: OntimeEvent[], field: K): MergedValue<OntimeEvent[K]> {
-  const value = events[0][field];
-  return events.some((event) => event[field] !== value) ? conflict : value;
-}
-
-/**
- * Merges the custom fields of a list of events
- * Fields missing from an entry are considered empty
- */
-function mergeCustomFields(events: OntimeEvent[]): MergedCustomFields {
-  const merged: MergedCustomFields = {};
-
-  for (const event of events) {
-    for (const key of Object.keys(event.custom)) {
-      if (key in merged) {
-        continue;
-      }
-      const value = event.custom[key] ?? '';
-      merged[key] = events.some((other) => (other.custom[key] ?? '') !== value) ? conflict : value;
-    }
-  }
-
-  return merged;
-}

e2e/tests/features/215-multi-edit.spec.ts

@@ -1,87 +0,0 @@
-import { expect, test } from '@playwright/test';
-
-test('Editing multiple events', async ({ page }) => {
-  await page.goto('/editor');
-  await page.getByRole('button', { name: 'Edit' }).click();
-
-  // clear rundown
-  await page.getByRole('button', { name: 'Rundown menu' }).click();
-  await page.getByRole('menuitem', { name: 'Clear all' }).click();
-  await page.getByRole('button', { name: 'Delete all' }).click();
-
-  // create two events with distinct titles
-  await page.getByRole('button', { name: 'Create Event' }).click();
-  await page.getByRole('button', { name: 'Event', exact: true }).nth(1).click();
-  await expect(page.getByTestId('rundown-event')).toHaveCount(2);
-
-  await page.getByTestId('entry-1').getByTestId('entry__title').fill('first');
-  await page.getByTestId('entry-1').getByTestId('entry__title').press('Enter');
-  await page.getByTestId('entry-2').getByTestId('entry__title').fill('second');
-  await page.getByTestId('entry-2').getByTestId('entry__title').press('Enter');
-
-  const editor = page.getByTestId('editor-container');
-
-  // a single selection shows the full schedule and the event id
-  await page.getByTestId('entry-1').getByTestId('rundown-event').click();
-  await expect(editor.getByTestId('time-input-timeStart')).toBeVisible();
-  await expect(editor.getByLabel('Title', { exact: true })).toHaveValue('first');
-
-  // selecting both events shows a merged view
-  await page
-    .getByTestId('entry-2')
-    .getByTestId('rundown-event')
-    .click({ modifiers: ['Shift'] });
-  await expect(editor.locator('#eventId')).toHaveValue('2 events selected');
-  await expect(editor.getByText('Automations are not available when editing multiple events')).toBeVisible();
-
-  // start and end times are unique to an event, only the duration can be batched
-  await expect(editor.getByTestId('time-input-timeStart')).toBeHidden();
-  await expect(editor.getByTestId('time-input-timeEnd')).toBeHidden();
-  await expect(editor.getByTestId('time-input-duration')).toBeVisible();
-
-  // fields which do not agree are shown as mixed
-  const title = editor.getByLabel('Title', { exact: true });
-  await expect(title).toHaveValue('');
-  await expect(title).toHaveAttribute('placeholder', 'Mixed');
-
-  // leaving a mixed field without editing it does not overwrite the events
-  await title.click();
-  await page.keyboard.press('Tab');
-  await expect(page.getByTestId('entry-1').getByTestId('entry__title')).toHaveValue('first');
-  await expect(page.getByTestId('entry-2').getByTestId('entry__title')).toHaveValue('second');
-
-  // a mixed field cannot be cleared by emptying it, so an explicit action is offered
-  const clearTitle = editor.getByRole('button', { name: 'Clear', exact: true }).first();
-  await expect(clearTitle).toBeVisible();
-  await clearTitle.click();
-  await expect(page.getByTestId('entry-1').getByTestId('entry__title')).toHaveValue('');
-  await expect(page.getByTestId('entry-2').getByTestId('entry__title')).toHaveValue('');
-
-  // the events now agree, so the field can be cleared by hand and the action is withdrawn
-  await expect(editor.getByLabel('Title', { exact: true })).not.toHaveAttribute('placeholder', 'Mixed');
-
-  // editing a field applies it to the whole selection
-  await title.fill('shared title');
-  await title.press('Enter');
-  await expect(page.getByTestId('entry-1').getByTestId('entry__title')).toHaveValue('shared title');
-  await expect(page.getByTestId('entry-2').getByTestId('entry__title')).toHaveValue('shared title');
-
-  // the value is no longer mixed
-  await expect(editor.getByLabel('Title', { exact: true })).toHaveValue('shared title');
-
-  // a batched duration is applied to every event and the rundown is recalculated once
-  const duration = editor.getByTestId('time-input-duration');
-  await duration.click();
-  await duration.fill('5m');
-  await duration.press('Enter');
-  await expect(page.getByTestId('entry-1').getByTestId('time-input-duration')).toHaveValue('00:05:00');
-  await expect(page.getByTestId('entry-2').getByTestId('time-input-duration')).toHaveValue('00:05:00');
-  // the second event is linked, so its start follows the new end of the first
-  await expect(page.getByTestId('entry-2').getByTestId('time-input-timeStart')).toHaveValue('00:05:00');
-  await expect(page.getByTestId('entry-2').getByTestId('time-input-timeEnd')).toHaveValue('00:10:00');
-
-  // going back to a single selection restores the full editor
-  await page.getByTestId('entry-1').getByTestId('rundown-event').click();
-  await expect(editor.getByTestId('time-input-timeStart')).toBeVisible();
-  await expect(editor.locator('#eventId')).not.toHaveValue('2 events selected');
-});

e2e/tests/features/301-spreadsheet-import.spec.ts

@@ -33,8 +33,8 @@ test('imports spreadsheet and applies imported rundown to editor', async ({ page
   await page.getByRole('button', { name: 'Preview import' }).click();
   await page.getByRole('button', { name: 'Apply import' }).click();
   await expect(page.getByText('Import complete')).toBeVisible();
-  await expect(page.getByText('Spreadsheet data applied.')).toBeVisible();
-  await page.getByRole('button', { name: 'Reset flow' }).click();
+  await expect(page.getByRole('button', { name: 'Open editor' })).toBeVisible();
+  await page.getByRole('button', { name: 'Import another' }).click();
 
   // verify the data in the rundown
   await page.getByRole('button', { name: 'Close settings' }).scrollIntoViewIfNeeded();