feat(rundown): clear a mixed field explicitly, cover both fixes with tests

Emptying a field which holds different values across the selection does not submit, otherwise focusing it and tabbing away would wipe every entry. That left no way to clear such a field, so text fields now offer an explicit Clear action, shown only while the entries disagree. Once they agree the field can be emptied by hand and the action is withdrawn. Both of the fixes which multi edit depends on were unguarded, so the logic moves into pure helpers alongside the existing hook helper convention: - shouldSubmitValue covers an unknown initial value being submitted as an empty string - applyPatchToEvents covers the optimistic batch update, whose signature now makes the original mistake of spreading the request body unrepresentable, and pins the custom field merge Both tests were confirmed to fail against the original behaviour. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PDETGBrhwgAqgTHjmrmJGJ
feat(rundown): batch edit event duration, model conflicts with a symbol
2026-08-16 12:53:32 +00:00 · 2026-07-25 12:49:47 +00:00 · 2026-07-25 12:39:17 +00:00 · 2026-07-25 12:29:30 +00:00 · 2026-07-25 11:22:24 +02:00 · 2026-07-22 07:17:39 +02:00
110 changed files with 3844 additions and 680 deletions
@@ -0,0 +1,5 @@
+# CodeGraph data files — local to each machine, not for committing.
+# Ignore everything in .codegraph/ except this file itself, so transient
+# files (the database, daemon.pid, sockets, logs) never show up in git.
+*
+!.gitignore
@@ -1,6 +1,6 @@
 {
  "name": "@getontime/cli",
-  "version": "4.10.0",
+  "version": "4.11.0",
  "author": "Carlos Valente",
  "description": "Time keeping for live events",
  "repository": "https://github.com/cpvalente/ontime",
@@ -1,6 +1,6 @@
 {
  "name": "ontime-ui",
-  "version": "4.10.0",
+  "version": "4.11.0",
  "private": true,
  "type": "module",
  "dependencies": {
@@ -6,6 +6,7 @@ import {
  ProjectRundownsList,
  RenumberCues,
  Rundown,
+  RundownImportPayload,
  TransientEventPayload,
 } from 'ontime-types';

@@ -82,6 +83,15 @@ export async function deleteRundown(rundownId: RundownId): Promise<AxiosResponse
  return axios.delete(`${rundownPath}/${rundownId}`);
 }

+/**
+ * HTTP request to apply an imported rundown using a merge strategy or into a new rundown
+ */
+export async function importRundownWithOptions(
+  payload: RundownImportPayload,
+): Promise<AxiosResponse<ProjectRundownsList>> {
+  return axios.post(`${rundownPath}/import`, payload);
+}
+
 // #endregion operations on project rundowns ======================
 // #region operations on rundown entries ==========================

@@ -6,7 +6,8 @@ import SwatchPicker from './SwatchPicker';
 import style from './SwatchSelect.module.scss';

 interface ColourInputProps {
-  value: string;
+  /** undefined represents values which do not agree, no swatch is highlighted */
+  value: string | undefined;
  name: 'colour';
  handleChange: (newValue: 'colour', name: string) => void;
 }
@@ -44,7 +45,11 @@ 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={!colours.includes(value)} />
+      <SwatchPicker
+        color={value ?? ''}
+        onChange={setColour}
+        isSelected={value !== undefined && !colours.includes(value)}
+      />
    </div>
  );
 }
@@ -0,0 +1,31 @@
+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);
+  });
+});
@@ -1,6 +1,23 @@
 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;
@@ -9,7 +26,8 @@ interface UseReactiveTextInputReturn {
 }

 export default function useReactiveTextInput(
-  initialText: string,
+  /** undefined represents an unknown value, the field is shown empty and blurring it submits nothing */
+  initialText: string | undefined,
  submitCallback: (newValue: string) => void,
  ref: RefObject<HTMLInputElement | HTMLTextAreaElement | null>,
  options?: {
@@ -22,7 +40,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
@@ -57,8 +75,7 @@ export default function useReactiveTextInput(
   */
  const handleSubmit = useCallback(
    (valueToSubmit: string) => {
-      // No need to update if it hasn't changed
-      if (valueToSubmit === initialText && !options?.allowSubmitSameValue) {
+      if (!shouldSubmitValue(valueToSubmit, initialText, options?.allowSubmitSameValue)) {
        options?.onCancelUpdate?.();
      } else {
        const cleanVal = valueToSubmit.trim();
@@ -86,10 +103,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
@@ -41,7 +41,10 @@ export default function TimeInput<T extends string>({
   * @description Resets input value to given
   */
  const resetValue = useCallback(() => {
-    if (typeof time !== 'number' || isNaN(time)) {
+    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)) {
      setValue('00:00:00');
    } else if (shouldFormat) {
      setValue(formatTime(time));
@@ -11,6 +11,7 @@ import {
 } from '../../../stores/savedViewParams';
 import { handleLinks } from '../../../utils/linkUtils';
 import IconButton from '../../buttons/IconButton';
+import Tooltip from '../../tooltip/Tooltip';
 import NavigationMenuItem from '../navigation-menu-item/NavigationMenuItem';

 import style from './ClientLink.module.scss';
@@ -105,16 +106,20 @@ function BrowserNavigationItem({ current, to, postAction, children }: PropsWithC
      {isCustomised && (
        <span className={style.trailing}>
          <span className={style.indicator} aria-hidden data-testid='client-link__saved-indicator' />
-          <IconButton
-            variant='ghosted-white'
-            size='small'
-            className={style.clear}
-            aria-label='Clear saved view settings'
-            title='Clear saved view settings'
-            onClick={clearViewSettings}
+          <Tooltip
+            text='Reset to default'
+            render={
+              <IconButton
+                variant='ghosted-white'
+                size='small'
+                className={style.clear}
+                aria-label='Reset to default'
+                onClick={clearViewSettings}
+              />
+            }
          >
            <IoCloseOutline />
-          </IconButton>
+          </Tooltip>
        </span>
      )}
    </NavigationMenuItem>
@@ -16,13 +16,21 @@ 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', ...selectRootProps }: SelectProps<T>) {
+export default function Select<T>({
+  options,
+  fluid,
+  size = 'medium',
+  placeholder,
+  ...selectRootProps
+}: SelectProps<T>) {
  return (
    <BaseSelect.Root items={options} {...selectRootProps}>
      <BaseSelect.Trigger className={cx([styles.select, styles[size], fluid && styles.fluid])}>
-        <BaseSelect.Value />
+        <BaseSelect.Value placeholder={placeholder} />
        <BaseSelect.Icon className={styles.selectIcon}>
          <LuChevronsUpDown />
        </BaseSelect.Icon>
@@ -29,6 +29,11 @@
  }
 }

+/* 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);
@@ -6,11 +6,13 @@ 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', ...switchProps }: SwitchProps) {
+export default function Switch({ size = 'medium', mixed, ...switchProps }: SwitchProps) {
  return (
-    <BaseSwitch.Root className={cx([style.switch, style[size]])} {...switchProps}>
+    <BaseSwitch.Root className={cx([style.switch, style[size], mixed && style.mixed])} {...switchProps}>
      <BaseSwitch.Thumb className={style.thumb} />
    </BaseSwitch.Root>
  );
@@ -6,6 +6,7 @@ import { useSearchParams } from 'react-router';

 import useViewSettings from '../../hooks-query/useViewSettings';
 import { useIsSmallScreen } from '../../hooks/useIsSmallScreen';
+import { useSavedViewParams } from '../../stores/savedViewParams';
 import Button from '../buttons/Button';
 import IconButton from '../buttons/IconButton';
 import Info from '../info/Info';
@@ -27,6 +28,7 @@ function ViewParamsEditor({ target, viewOptions }: EditFormDrawerProps) {
  const [searchParams, setSearchParams] = useSearchParams();
  const { data: viewSettings } = useViewSettings();
  const { isOpen, close } = useViewParamsEditorStore();
+  const clearSavedParams = useSavedViewParams((store) => store.clear);
  const isSmallScreen = useIsSmallScreen();

  const getPreservedParams = () => getPreservedSearchParams(searchParams, viewOptions);
@@ -36,6 +38,7 @@ function ViewParamsEditor({ target, viewOptions }: EditFormDrawerProps) {
  };

  const resetParams = () => {
+    clearSavedParams(target);
    setSearchParams(getPreservedParams());
  };

@@ -0,0 +1,76 @@
+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);
+  });
+});
@@ -0,0 +1,39 @@
+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);
+}
@@ -1,7 +1,6 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import {
  EntryId,
-  InsertOptions,
  MaybeString,
  OntimeDelay,
  OntimeEntry,
@@ -53,6 +52,7 @@ 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)
@@ -60,9 +60,15 @@ export type EventOptions = Partial<{
  before: MaybeString;
  // options of entries of type OntimeEvent
  linkPrevious: boolean;
+  /** the timing reference for the new entry, usually the same as after */
  lastEventId: MaybeString;
 }>;

+type ClientInsertOptions = {
+  after?: EntryId;
+  before?: EntryId;
+};
+
 /**
 * Gather utilities for actions on entries in the loaded rundown.
 */
@@ -120,7 +126,7 @@ function useEntryActionsForRundown(scopedRundownId: string | undefined) {
   * @private
   */
  const { mutateAsync: addEntryMutation } = useMutation({
-    mutationFn: ([rundownId, entry]: [string, PatchWithId & InsertOptions]) => postAddEntry(rundownId, entry),
+    mutationFn: ([rundownId, entry]: [string, PatchWithId & ClientInsertOptions]) => postAddEntry(rundownId, entry),
    onMutate: async ([_rundownId, entry]) => {
      const queryKey = resolveCurrentRundownQueryKey();
      await queryClient.cancelQueries({ queryKey });
@@ -149,8 +155,9 @@ function useEntryActionsForRundown(scopedRundownId: string | undefined) {
        addToRundown(
          newRundown,
          optimisticEntry,
-          afterId,
          parent ? (newRundown.entries[parent.id] as OntimeGroup) : null,
+          afterId,
+          entry.before ?? null,
        );

        queryClient.setQueryData<Rundown>(queryKey, newRundown);
@@ -193,7 +200,7 @@ function useEntryActionsForRundown(scopedRundownId: string | undefined) {
        throw new Error('Rundown not initialised');
      }

-      const newEntry: PatchWithId & InsertOptions = { ...entry, id: generateId() };
+      const newEntry: PatchWithId & ClientInsertOptions = { ...entry, id: generateId() };

      // handle adding options that concern all event types
      if (options?.after) {
@@ -205,8 +212,8 @@ function useEntryActionsForRundown(scopedRundownId: string | undefined) {

      // ************* CHECK OPTIONS specific to events
      if (isOntimeEvent(newEntry)) {
+        // last event id is the timing reference of the previous OntimeEvent in rundown
        if (options?.lastEventId) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- we know this is a value
          const previousEvent = rundownData.entries[options?.lastEventId];
          if (isOntimeEvent(previousEvent)) {
            newEntry.timeStart = previousEvent.timeEnd;
@@ -284,7 +291,7 @@ function useEntryActionsForRundown(scopedRundownId: string | undefined) {
   * Clone an entry
   */
  const clone = useCallback(
-    async (entryId: EntryId, options?: InsertOptions) => {
+    async (entryId: EntryId, options?: ClientInsertOptions) => {
      try {
        const rundownId = getCurrentRundownData()?.id;
        if (!rundownId) {
@@ -477,21 +484,9 @@ function useEntryActionsForRundown(scopedRundownId: string | undefined) {
      // Snapshot the previous value
      const previousRundown = queryClient.getQueryData<Rundown>(queryKey);

-      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,
-              };
-            }
-          }
-        });
+      // 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);

        queryClient.setQueryData<Rundown>(queryKey, {
          id: previousRundown.id,
@@ -1057,7 +1052,7 @@ function optimisticDeleteEntries(entryIds: EntryId[], rundown: Rundown) {
 /**
 * Utility to create an optimistic entry for immediate cache insertion
 */
-function createOptimisticEntry(payload: PatchWithId & InsertOptions): OntimeEntry {
+function createOptimisticEntry(payload: PatchWithId & ClientInsertOptions): OntimeEntry {
  const { after: _after, before: _before, ...entryData } = payload;
  const id = entryData.id;
  let parent: EntryId | null = null;
@@ -139,6 +139,17 @@ export const setEventPlayback = {
  pause: () => sendSocket('pause', undefined),
 };

+export const useTimerProgress = createSelector((state: RuntimeStore) => ({
+  playback: state.timer.playback,
+  phase: state.timer.phase,
+  addedTime: state.timer.addedTime,
+  secondaryTimer: state.timer.secondaryTimer,
+  current: state.timer.current,
+  expectedFinish: state.timer.expectedFinish,
+  startedAt: state.timer.startedAt,
+  isCountToEnd: state.eventNow?.countToEnd ?? false,
+}));
+
 export const useTimer = createSelector((state: RuntimeStore) => ({
  ...state.timer,
 }));
@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { removeFileExtension } from '../uploadUtils';
+
+describe('removeFileExtension()', () => {
+  it('removes a trailing extension', () => {
+    expect(removeFileExtension('show.xlsx')).toBe('show');
+  });
+
+  it('only removes the last extension', () => {
+    expect(removeFileExtension('my.show.xlsx')).toBe('my.show');
+  });
+
+  it('returns the name unchanged when there is no extension', () => {
+    expect(removeFileExtension('rundown')).toBe('rundown');
+  });
+
+  it('does not treat a leading dot as an extension', () => {
+    expect(removeFileExtension('.gitignore')).toBe('.gitignore');
+  });
+
+  it('handles an empty string', () => {
+    expect(removeFileExtension('')).toBe('');
+  });
+});
@@ -3,7 +3,9 @@ import {
  MILLIS_PER_HOUR,
  MILLIS_PER_MINUTE,
  MILLIS_PER_SECOND,
+  dayInMs,
  formatFromMillis,
+  getExpectedEnd,
  getExpectedStart,
 } from 'ontime-utils';

@@ -29,6 +31,11 @@ export function nowInMillis(): number {
  return elapsed;
 }

+export function normaliseWallClock(time: number): number {
+  const timeOfDay = time % dayInMs;
+  return timeOfDay < 0 ? timeOfDay + dayInMs : timeOfDay;
+}
+
 /**
 * @description Resolves format from url and store
 * @return {string|null} A format string like "hh:mm:ss a" or null
@@ -180,15 +187,13 @@ export function getExpectedTimesFromExtendedEvent(
      ...state,
    },
  );
-
+  const expectedEnd = getExpectedEnd(event, expectedStart, state.currentDay);
  const plannedEnd = event.timeStart + event.duration + event.delay;

  return {
    expectedStart,
    timeToStart: expectedStart - state.clock,
-    expectedEnd: event.countToEnd
-      ? Math.max(expectedStart + event.duration, plannedEnd)
-      : expectedStart + event.duration,
+    expectedEnd,
    plannedEnd,
  };
 }
@@ -38,6 +38,18 @@ export function validateProjectFile(file: File) {
  }
 }

+/**
+ * Removes a trailing file extension from a file name (e.g. "show.xlsx" -> "show")
+ * A leading dot (dotfiles like ".gitignore") is not treated as an extension
+ */
+export function removeFileExtension(fileName: string): string {
+  const lastDot = fileName.lastIndexOf('.');
+  if (lastDot <= 0) {
+    return fileName;
+  }
+  return fileName.slice(0, lastDot);
+}
+
 export function isExcelFile(file: File | null) {
  return file?.name.endsWith('.xlsx');
 }
@@ -293,8 +293,9 @@ export default function AutomationForm({ automation, onClose }: AutomationFormPr
        <h3>Outputs</h3>
        <Info>
          Automation outputs can be used to send data from Ontime to external software <br />
-          or to change properties of Ontime itself.
-          <ExternalLink href={integrationsDocsUrl}>See the documentation for templates</ExternalLink>
+          or to change properties of Ontime itself. <br /> <br />
+          Use Ontime runtime data in these fields with template strings. Type {'{{'} to see autocomplete, or{' '}
+          <ExternalLink href={integrationsDocsUrl}>read the docs</ExternalLink>
        </Info>

        {fieldOutputs.map((output, index) => {
@@ -341,12 +342,17 @@ export default function AutomationForm({ automation, onClose }: AutomationFormPr
                  </label>
                  <label>
                    Address
-                    <Input {...register(`outputs.${index}.address`)} fluid placeholder='/cue/start' />
+                    <TemplateInput
+                      {...register(`outputs.${index}.address`)}
+                      value={output.address}
+                      fluid
+                      placeholder='/cue/start'
+                    />
                    <Panel.Error>{rowErrors?.address?.message}</Panel.Error>
                  </label>
                  <label>
                    Arguments
-                    <TemplateInput {...register(`outputs.${index}.args`)} value={output.args} placeholder='1' />
+                    <TemplateInput {...register(`outputs.${index}.args`)} value={output.args} fluid placeholder='1' />
                    <Panel.Error>{rowErrors?.args?.message}</Panel.Error>
                  </label>
                  <div>
@@ -376,7 +382,7 @@ export default function AutomationForm({ automation, onClose }: AutomationFormPr
                <div className={style.httpSection}>
                  <label>
                    Target URL
-                    <Input
+                    <TemplateInput
                      {...register(`outputs.${index}.url`, {
                        required: { value: true, message: 'Required field' },
                        pattern: {
@@ -384,6 +390,7 @@ export default function AutomationForm({ automation, onClose }: AutomationFormPr
                          message: 'HTTP messages should target http:// or https://',
                        },
                      })}
+                      value={output.url}
                      fluid
                      placeholder='http://127.0.0.1/start/1'
                    />
@@ -5,6 +5,7 @@ import { UseFormRegister, UseFormSetValue, UseFormWatch } from 'react-hook-form'
 import Input from '../../../../common/components/input/input/Input';
 import Select from '../../../../common/components/select/Select';
 import * as Panel from '../../panel-utils/PanelUtils';
+import TemplateInput from './template-input/TemplateInput';

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

@@ -71,8 +72,8 @@ export default function OntimeActionForm({
            { value: 'playback-pause', label: 'Playback: pause' },
            { value: 'playback-roll', label: 'Playback: roll' },

-            { value: 'message-set', label: 'Primary Message: set' },
-            { value: 'message-secondary', label: 'Secondary Message: source' },
+            { value: 'message-set', label: 'Primary Message' },
+            { value: 'message-secondary', label: 'Secondary Message' },
          ]}
        />
        <Panel.Error>{rowErrors?.action?.message}</Panel.Error>
@@ -96,7 +97,12 @@ export default function OntimeActionForm({
        <>
          <label>
            Text (leave empty for no change)
-            <Input {...register(`outputs.${index}.text`)} fluid placeholder='eg: Timer is finished' />
+            <TemplateInput
+              {...register(`outputs.${index}.text`)}
+              value={watch(`outputs.${index}.text`) ?? ''}
+              fluid
+              placeholder='eg: Timer is finished'
+            />
            <Panel.Error>{rowErrors?.text?.message}</Panel.Error>
          </label>
          <label>
@@ -120,31 +126,48 @@ export default function OntimeActionForm({
      )}

      {selectedAction === 'message-secondary' && (
-        <label>
-          Timer secondary source
-          <Select<SecondarySource | 'null' | null>
-            onValueChange={(value) => {
-              // null -> no selection
-              if (value === null) return;
-              // 'null' -> clear the secondary source
-              if (value === 'null') {
-                setValue(`outputs.${index}.secondarySource`, null, { shouldDirty: true });
-                return;
-              }
-              setValue(`outputs.${index}.secondarySource`, value, { shouldDirty: true });
-            }}
-            value={watch(`outputs.${index}.secondarySource`)}
-            options={[
-              { value: null, label: 'Select secondary source' },
-              { value: 'aux1', label: 'Auxiliary timer 1' },
-              { value: 'aux2', label: 'Auxiliary timer 2' },
-              { value: 'aux3', label: 'Auxiliary timer 3' },
-              { value: 'secondary', label: 'Secondary' },
-              { value: 'null', label: 'None' }, // allow the user to clear the secondary source
-            ]}
-          />
-          <Panel.Error>{rowErrors?.secondarySource?.message}</Panel.Error>
-        </label>
+        <>
+          <label>
+            Text (leave empty for no change)
+            <TemplateInput
+              {...register(`outputs.${index}.text`)}
+              value={watch(`outputs.${index}.text`) ?? ''}
+              fluid
+              placeholder='eg: Next up: keynote'
+            />
+            <Panel.Error>{rowErrors?.text?.message}</Panel.Error>
+          </label>
+          <label>
+            Timer secondary source
+            <Select<SecondarySource | 'no-change' | 'null' | null>
+              onValueChange={(value) => {
+                // null -> no selection
+                if (value === null) return;
+                // no-change -> leave the current secondary source untouched
+                if (value === 'no-change') {
+                  setValue(`outputs.${index}.secondarySource`, undefined, { shouldDirty: true });
+                  return;
+                }
+                // 'null' -> clear the secondary source
+                if (value === 'null') {
+                  setValue(`outputs.${index}.secondarySource`, null, { shouldDirty: true });
+                  return;
+                }
+                setValue(`outputs.${index}.secondarySource`, value, { shouldDirty: true });
+              }}
+              value={watch(`outputs.${index}.secondarySource`) ?? 'no-change'}
+              options={[
+                { value: 'no-change', label: 'No change' },
+                { value: 'aux1', label: 'Auxiliary timer 1' },
+                { value: 'aux2', label: 'Auxiliary timer 2' },
+                { value: 'aux3', label: 'Auxiliary timer 3' },
+                { value: 'secondary', label: 'Secondary' },
+                { value: 'null', label: 'None' }, // allow the user to clear the secondary source
+              ]}
+            />
+            <Panel.Error>{rowErrors?.secondarySource?.message}</Panel.Error>
+          </label>
+        </>
      )}

      <div className={style.test}>{children}</div>
@@ -79,7 +79,7 @@ export default function TriggersList(props: TriggersListProps) {
          <tbody>
            {!showForm && triggers.length === 0 && (
              <Panel.TableEmpty
-                label='Create an automation to attach triggers to'
+                label='Create a trigger to run an automation'
                handleClick={canAdd ? () => setShowForm(true) : undefined}
              />
            )}
@@ -1,29 +1,67 @@
-.wrapper {
+.inputShell {
  position: relative;
 }

-.suggestions {
-  background: $gray-1250;
-  color: $ui-white;
-
-  position: absolute;
-  top: 100%;
-  left: 0;
+.fluid {
  width: 100%;
-  margin: 0;
-  z-index: $zindex-floating;
-  padding-block: 0.25rem;
+}

-  max-height: 200px;
-  overflow-y: auto;
+.input {
+  padding-right: 2rem;
+}
+
+.expandButton {
+  position: absolute;
+  top: 50%;
+  right: 0.25rem;
+  transform: translateY(-50%);
+}
+
+.positioner {
+  outline: 0;
+}
+
+.popup {
+  box-sizing: border-box;
+  min-width: var(--anchor-width);
+  max-width: var(--available-width);
+  border: 1px solid $gray-1000;
+  border-radius: $component-border-radius-md;
+  background: $gray-1250;
  color: $label-gray;
+}

-  li {
-    padding: 0.25rem;
-  }
+.list {
+  box-sizing: border-box;
+  max-height: min(20rem, var(--available-height));
+  overflow-y: auto;
+  overscroll-behavior: contain;
+  padding-block: 0.25rem;
+  outline: 0;
+}

-  li:hover {
+.item {
+  box-sizing: border-box;
+  padding: 0.25rem 0.5rem;
+  outline: 0;
+  cursor: default;
+  user-select: none;
+  overflow-wrap: anywhere;
+
+  &[data-highlighted] {
    color: $ui-white;
    background: $blue-700;
  }
 }
+
+.expandedEditor {
+  min-height: min(18rem, 45vh);
+  font-family: monospace;
+  line-height: 1.4;
+}
+
+.footerHint {
+  margin-right: auto;
+  color: $label-gray;
+  font-size: calc(1rem - 2px);
+}
@@ -1,69 +1,258 @@
-import { mergeRefs, useClickOutside } from '@mantine/hooks';
-import { forwardRef, useMemo, useState } from 'react';
+import { Autocomplete as BaseAutocomplete } from '@base-ui/react/autocomplete';
+import type { ChangeEvent, ReactNode, Ref } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { IoExpandOutline } from 'react-icons/io5';

-import Input, { type InputProps } from '../../../../../common/components/input/input/Input';
+import Button from '../../../../../common/components/buttons/Button';
+import IconButton from '../../../../../common/components/buttons/IconButton';
+import { type InputProps } from '../../../../../common/components/input/input/Input';
+import Textarea from '../../../../../common/components/input/textarea/Textarea';
+import Modal from '../../../../../common/components/modal/Modal';
 import useCustomFields from '../../../../../common/hooks-query/useCustomFields';
-import { makeAutoCompleteList, matchRemaining, selectFromLastTemplate } from './templateInput.utils';
+import { cx } from '../../../../../common/utils/styleUtils';
+import { makeAutoCompleteList } from './templateInput.utils';
+import { useTemplateAutocomplete } from './useTemplateAutocomplete';

+import inputStyle from '../../../../../common/components/input/input/Input.module.scss';
 import style from './TemplateInput.module.scss';

-interface TemplateInputProps extends InputProps {}
+interface TemplateInputProps extends Omit<InputProps, 'value'> {
+  ref?: Ref<HTMLInputElement>;
+  value?: string;
+}

-const TemplateInput = forwardRef(function TemplateInput(props: TemplateInputProps, ref) {
-  const { value, onChange, ...rest } = props;
+interface TemplateEditorModalProps {
+  autocompleteList: string[];
+  isOpen: boolean;
+  onClose: () => void;
+  onSave: (value: string) => void;
+  value: string;
+}
+
+type TemplateAutocompleteState = ReturnType<typeof useTemplateAutocomplete<HTMLInputElement>>;
+
+interface TemplateAutocompleteRootProps {
+  autocomplete: TemplateAutocompleteState;
+  children: ReactNode;
+  value: string;
+}
+
+function assignRef<T>(ref: Ref<T> | undefined, value: T | null) {
+  if (typeof ref === 'function') {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+}
+
+function emitInputChange(name: string | undefined, value: string, onChange: InputProps['onChange']) {
+  onChange?.({
+    target: { name, value },
+    currentTarget: { name, value },
+  } as ChangeEvent<HTMLInputElement>);
+}
+
+export default function TemplateInput({
+  className,
+  disabled,
+  fluid,
+  height = 'medium',
+  onChange,
+  readOnly,
+  ref,
+  value,
+  variant = 'subtle',
+  ...rest
+}: TemplateInputProps) {
  const { data } = useCustomFields();
-  const localRef = useClickOutside(() => setShowSuggestions(false));
+  const inputRef = useRef<HTMLInputElement | null>(null);
+  const [inputValue, setInputValue] = useState(value || '');
+  const [isExpanded, setIsExpanded] = useState(false);

  const autocompleteList = useMemo(() => {
    return makeAutoCompleteList(data);
  }, [data]);

-  const [inputValue, setInputValue] = useState(value || '');
-  const [suggestions, setSuggestions] = useState<string[]>([]);
-  const [showSuggestions, setShowSuggestions] = useState(false);
+  const updateInputValue = useCallback(
+    (nextValue: string) => {
+      setInputValue(nextValue);
+      emitInputChange(rest.name, nextValue, onChange);
+    },
+    [onChange, rest.name],
+  );

-  const updateSuggestions = (value: string) => {
-    const template = selectFromLastTemplate(value);
-    return autocompleteList.filter((suggestion) => suggestion.startsWith(template));
+  const autocomplete = useTemplateAutocomplete(inputValue, autocompleteList, inputRef, updateInputValue);
+  const { setCursorForValue } = autocomplete;
+
+  // Keep the local autocomplete input in sync when react-hook-form resets or swaps field-array values.
+  useEffect(() => {
+    const nextValue = value || '';
+    setInputValue(nextValue);
+    setCursorForValue(nextValue, nextValue.length);
+  }, [setCursorForValue, value]);
+
+  const setInputRef = useCallback(
+    (element: HTMLInputElement | null) => {
+      inputRef.current = element;
+      assignRef(ref, element);
+    },
+    [ref],
+  );
+
+  const openExpandedEditor = () => {
+    autocomplete.setShowSuggestions(false);
+    setIsExpanded(true);
  };

-  const handleInputChange = (event: React.ChangeEvent<HTMLInputElement>) => {
-    setInputValue(event.target.value);
-
-    if (event.target.value.endsWith('{')) {
-      setShowSuggestions(true);
-      setSuggestions(updateSuggestions(event.target.value));
-    } else if (event.target.value === '' || event.target.value.endsWith('}}')) {
-      setShowSuggestions(false);
-    } else if (showSuggestions) {
-      setSuggestions(updateSuggestions(event.target.value));
-    }
-
-    onChange?.(event);
+  const closeExpandedEditor = () => {
+    setIsExpanded(false);
  };

-  const handleSuggestion = (value: string) => {
-    setInputValue((prev) => {
-      const remaining = matchRemaining(prev as string, value);
-      return prev + remaining;
-    });
-    setShowSuggestions(false);
+  const saveExpandedEditor = (nextValue: string) => {
+    updateInputValue(nextValue);
+    autocomplete.setCursorForValue(nextValue, nextValue.length);
+    setIsExpanded(false);
  };

  return (
-    <div className={style.wrapper} ref={mergeRefs(localRef, ref)}>
-      <Input value={inputValue} {...rest} onChange={handleInputChange} fluid />
-      {showSuggestions && suggestions.length > 0 && (
-        <ul className={style.suggestions}>
-          {suggestions.map((suggestion) => (
-            <li key={suggestion} onClick={() => handleSuggestion(suggestion)}>
-              {suggestion}
-            </li>
-          ))}
-        </ul>
-      )}
-    </div>
+    <>
+      <TemplateAutocompleteRoot autocomplete={autocomplete} value={inputValue}>
+        <div className={cx([style.inputShell, fluid && style.fluid])}>
+          <BaseAutocomplete.Input
+            ref={setInputRef}
+            className={cx([
+              inputStyle.input,
+              inputStyle[variant],
+              inputStyle[height],
+              fluid && inputStyle.fluid,
+              style.input,
+              className,
+            ])}
+            {...rest}
+            disabled={disabled}
+            onClick={autocomplete.updateCursor}
+            onFocus={autocomplete.updateCursor}
+            onKeyUp={autocomplete.updateCursor}
+            onSelect={autocomplete.updateCursor}
+            readOnly={readOnly}
+          />
+          <IconButton
+            aria-label='Expand template editor'
+            className={style.expandButton}
+            disabled={disabled || readOnly}
+            onClick={openExpandedEditor}
+            size='small'
+            title='Expand template editor'
+            variant='ghosted-white'
+          >
+            <IoExpandOutline />
+          </IconButton>
+        </div>
+      </TemplateAutocompleteRoot>
+      <TemplateEditorModal
+        autocompleteList={autocompleteList}
+        isOpen={isExpanded}
+        onClose={closeExpandedEditor}
+        onSave={saveExpandedEditor}
+        value={inputValue}
+      />
+    </>
  );
-});
+}

-export default TemplateInput;
+function TemplateAutocompleteRoot({ autocomplete, children, value }: TemplateAutocompleteRootProps) {
+  return (
+    <BaseAutocomplete.Root
+      items={autocomplete.suggestions}
+      autoHighlight
+      highlightItemOnHover
+      mode='none'
+      open={autocomplete.open}
+      value={value}
+      onOpenChange={autocomplete.setShowSuggestions}
+      onValueChange={autocomplete.handleValueChange}
+    >
+      {children}
+      <TemplateSuggestionPopup />
+    </BaseAutocomplete.Root>
+  );
+}
+
+function TemplateEditorModal({ autocompleteList, isOpen, onClose, onSave, value }: TemplateEditorModalProps) {
+  const expandedInputRef = useRef<HTMLTextAreaElement | null>(null);
+  const [draftValue, setDraftValue] = useState(value);
+  const autocomplete = useTemplateAutocomplete(draftValue, autocompleteList, expandedInputRef, setDraftValue);
+  const { setShowSuggestions } = autocomplete;
+
+  // Reset the draft whenever the modal opens so cancel never leaks unsaved changes.
+  useEffect(() => {
+    if (!isOpen) {
+      return;
+    }
+
+    setDraftValue(value);
+    setShowSuggestions(false);
+  }, [isOpen, setShowSuggestions, value]);
+
+  const handleClose = () => {
+    setShowSuggestions(false);
+    onClose();
+  };
+
+  const handleSave = () => {
+    setShowSuggestions(false);
+    onSave(draftValue);
+  };
+
+  return (
+    <Modal
+      isOpen={isOpen}
+      onClose={handleClose}
+      showBackdrop
+      showCloseButton
+      title='Edit template'
+      bodyElements={
+        <TemplateAutocompleteRoot autocomplete={autocomplete} value={draftValue}>
+          <BaseAutocomplete.Input
+            autoFocus
+            className={style.expandedEditor}
+            onClick={autocomplete.updateCursor}
+            onFocus={autocomplete.updateCursor}
+            onKeyUp={autocomplete.updateCursor}
+            onSelect={autocomplete.updateCursor}
+            render={<Textarea ref={expandedInputRef} fluid resize='none' rows={8} />}
+          />
+        </TemplateAutocompleteRoot>
+      }
+      footerElements={
+        <>
+          <span className={style.footerHint}>Start a template with {'{{'} to see autocomplete.</span>
+          <Button onClick={handleClose}>Cancel</Button>
+          <Button onClick={handleSave} variant='primary'>
+            Save
+          </Button>
+        </>
+      }
+    />
+  );
+}
+
+function TemplateSuggestionPopup() {
+  return (
+    <BaseAutocomplete.Portal>
+      <BaseAutocomplete.Positioner side='bottom' align='start' className={style.positioner}>
+        <BaseAutocomplete.Popup className={style.popup}>
+          <BaseAutocomplete.List className={style.list}>
+            <BaseAutocomplete.Collection>
+              {(suggestion: string) => (
+                <BaseAutocomplete.Item key={suggestion} value={suggestion} className={style.item}>
+                  {suggestion}
+                </BaseAutocomplete.Item>
+              )}
+            </BaseAutocomplete.Collection>
+          </BaseAutocomplete.List>
+        </BaseAutocomplete.Popup>
+      </BaseAutocomplete.Positioner>
+    </BaseAutocomplete.Portal>
+  );
+}
@@ -1,4 +1,4 @@
-import { matchRemaining } from '../templateInput.utils';
+import { completeTemplateAtCursor, matchRemaining, selectActiveTemplate } from '../templateInput.utils';

 describe('matchRemaining()', () => {
  it('should return a partial string needed for autocomplete', () => {
@@ -15,3 +15,54 @@ describe('matchRemaining()', () => {
    expect(matchRemaining('test', 'test')).toBe('');
  });
 });
+
+describe('selectActiveTemplate()', () => {
+  it('returns the last unclosed template fragment', () => {
+    expect(selectActiveTemplate('send {{event')).toBe('{{event');
+    expect(selectActiveTemplate('send {{eventNow.title}} and {{event')).toBe('{{event');
+  });
+
+  it('ignores single braces and closed templates', () => {
+    expect(selectActiveTemplate('send {')).toBe('');
+    expect(selectActiveTemplate('send {{eventNow.title}}')).toBe('');
+  });
+
+  it('only considers templates before the cursor', () => {
+    expect(selectActiveTemplate('send {{event}} then {{timer', 14)).toBe('');
+    expect(selectActiveTemplate('send {{event}} then {{timer', 27)).toBe('{{timer');
+  });
+
+  it('selects a partial template when the cursor is inside a completed template', () => {
+    expect(selectActiveTemplate('send {{timer.current}} after', 12)).toBe('{{timer');
+  });
+});
+
+describe('completeTemplateAtCursor()', () => {
+  it('completes the active template before the cursor', () => {
+    expect(completeTemplateAtCursor('send {{timer after', '{{timer.current}}', 12)).toEqual({
+      value: 'send {{timer.current}} after',
+      cursorIndex: 22,
+    });
+  });
+
+  it('preserves text before and after the cursor', () => {
+    expect(completeTemplateAtCursor('before {{event after', '{{eventNow.title}}', 14)).toEqual({
+      value: 'before {{eventNow.title}} after',
+      cursorIndex: 25,
+    });
+  });
+
+  it('preserves a following template when completing between templates', () => {
+    expect(completeTemplateAtCursor('{{clock}} and {{timer then {{eventNow.title}}', '{{timer.current}}', 21)).toEqual({
+      value: '{{clock}} and {{timer.current}} then {{eventNow.title}}',
+      cursorIndex: 31,
+    });
+  });
+
+  it('replaces the whole template when the cursor is inside a completed template', () => {
+    expect(completeTemplateAtCursor('before {{timer.current}} after', '{{timer.duration}}', 15)).toEqual({
+      value: 'before {{timer.duration}} after',
+      cursorIndex: 25,
+    });
+  });
+});
@@ -54,6 +54,16 @@ const eventStaticPropertiesNext = [
  '{{eventNext.delay}}',
 ];

+const groupStaticPropertiesNow = [
+  '{{groupNow.id}}',
+  '{{groupNow.title}}',
+  '{{groupNow.note}}',
+  '{{groupNow.colour}}',
+  '{{groupNow.timeStart}}',
+  '{{groupNow.timeEnd}}',
+  '{{groupNow.duration}}',
+];
+
 const staticAuxProperties = (index: 1 | 2 | 3) => [
  `{{auxtimer${index}.current}}`,
  `{{auxtimer${index}.duration}}`,
@@ -75,12 +85,19 @@ export function makeAutoCompleteList(customFields: CustomFields): string[] {
    ...Object.entries(customFields).map(([key]) => `{{eventNow.custom.${key}}}`),
    ...eventStaticPropertiesNext,
    ...Object.entries(customFields).map(([key]) => `{{eventNext.custom.${key}}}`),
+    ...groupStaticPropertiesNow,
+    ...Object.entries(customFields).map(([key]) => `{{groupNow.custom.${key}}}`),
    ...staticAuxProperties(1),
    ...staticAuxProperties(2),
    ...staticAuxProperties(3),
  ];
 }

+interface TemplateCompletion {
+  cursorIndex: number;
+  value: string;
+}
+
 /**
 * Returns the partial string b needed to autocomplete string a
 * @example matchRemaining('te', 'test') -> 'st'
@@ -111,13 +128,54 @@ export function matchRemaining(a: string, b: string) {
  return '';
 }

-/**
- * Selects the last starting template in a string
- */
-export function selectFromLastTemplate(text: string) {
-  const lastBraceIndex = text.lastIndexOf('{{');
-  if (lastBraceIndex !== -1) {
-    return text.slice(lastBraceIndex);
+function getActiveTemplateRange(text: string, cursorIndex = text.length) {
+  const textBeforeCursor = text.slice(0, cursorIndex);
+  const start = textBeforeCursor.lastIndexOf('{{');
+  if (start === -1) {
+    return null;
  }
-  return '';
+
+  const closeBeforeCursor = textBeforeCursor.lastIndexOf('}}');
+  if (closeBeforeCursor > start) {
+    return null;
+  }
+
+  const closeAfterStart = text.indexOf('}}', start);
+  const nextStartAfterCursor = text.indexOf('{{', cursorIndex);
+  const closesBeforeNextTemplate = nextStartAfterCursor === -1 || closeAfterStart < nextStartAfterCursor;
+  const end = closeAfterStart !== -1 && closesBeforeNextTemplate ? closeAfterStart + 2 : cursorIndex;
+
+  return {
+    end,
+    start,
+    template: text.slice(start, cursorIndex),
+  };
+}
+
+/**
+ * Selects the last unclosed starting template before the cursor.
+ */
+export function selectActiveTemplate(text: string, cursorIndex = text.length) {
+  return getActiveTemplateRange(text, cursorIndex)?.template ?? '';
+}
+
+/**
+ * Replaces the active template fragment before the cursor with the selected suggestion.
+ */
+export function completeTemplateAtCursor(
+  text: string,
+  suggestion: string,
+  cursorIndex = text.length,
+): TemplateCompletion {
+  const activeTemplateRange = getActiveTemplateRange(text, cursorIndex);
+  if (!activeTemplateRange) {
+    const value = text + matchRemaining(text, suggestion);
+    return { value, cursorIndex: value.length };
+  }
+
+  const value = `${text.slice(0, activeTemplateRange.start)}${suggestion}${text.slice(activeTemplateRange.end)}`;
+  return {
+    value,
+    cursorIndex: activeTemplateRange.start + suggestion.length,
+  };
 }
@@ -0,0 +1,72 @@
+import { Autocomplete as BaseAutocomplete } from '@base-ui/react/autocomplete';
+import { useCallback, useMemo, useState, type RefObject } from 'react';
+
+import { completeTemplateAtCursor, selectActiveTemplate } from './templateInput.utils';
+
+type TemplateElement = HTMLInputElement | HTMLTextAreaElement;
+
+function getCursorIndex(element: TemplateElement | null, fallback: string) {
+  return element?.selectionStart ?? fallback.length;
+}
+
+function focusCursor(element: TemplateElement | null, cursorIndex: number) {
+  requestAnimationFrame(() => {
+    element?.focus();
+    element?.setSelectionRange(cursorIndex, cursorIndex);
+  });
+}
+
+export function useTemplateAutocomplete<T extends TemplateElement>(
+  value: string,
+  autocompleteList: string[],
+  elementRef: RefObject<T | null>,
+  onValueChange: (value: string) => void,
+) {
+  const [showSuggestions, setShowSuggestions] = useState(false);
+  const [cursor, setCursor] = useState(value.length);
+
+  const activeTemplate = selectActiveTemplate(value, cursor);
+  const suggestions = useMemo(() => {
+    if (!activeTemplate) {
+      return [];
+    }
+    return autocompleteList.filter((suggestion) => suggestion.startsWith(activeTemplate));
+  }, [activeTemplate, autocompleteList]);
+
+  const setCursorForValue = useCallback((nextValue: string, cursorIndex: number) => {
+    setCursor(cursorIndex);
+    setShowSuggestions(Boolean(selectActiveTemplate(nextValue, cursorIndex)));
+  }, []);
+
+  const updateCursor = useCallback(() => {
+    const cursorIndex = getCursorIndex(elementRef.current, value);
+    setCursorForValue(value, cursorIndex);
+  }, [elementRef, setCursorForValue, value]);
+
+  const handleValueChange = useCallback(
+    (nextValue: string, eventDetails: BaseAutocomplete.Root.ChangeEventDetails) => {
+      if (eventDetails.reason === 'item-press') {
+        eventDetails.cancel();
+        const completed = completeTemplateAtCursor(value, nextValue, cursor);
+        setCursorForValue(completed.value, completed.cursorIndex);
+        onValueChange(completed.value);
+        focusCursor(elementRef.current, completed.cursorIndex);
+        return;
+      }
+
+      const cursorIndex = getCursorIndex(elementRef.current, nextValue);
+      setCursorForValue(nextValue, cursorIndex);
+      onValueChange(nextValue);
+    },
+    [cursor, elementRef, onValueChange, setCursorForValue, value],
+  );
+
+  return {
+    handleValueChange,
+    open: showSuggestions && suggestions.length > 0,
+    setCursorForValue,
+    setShowSuggestions,
+    suggestions,
+    updateCursor,
+  };
+}
@@ -1,4 +1,6 @@
 import type {
+  ImportedFields,
+  RundownImportMode,
  SpreadsheetPreviewResponse,
  SpreadsheetWorksheetMetadata,
  SpreadsheetWorksheetOptions,
@@ -22,7 +24,7 @@ import Info from '../../../../../common/components/info/Info';
 import ExternalLink from '../../../../../common/components/link/external-link/ExternalLink';
 import Modal from '../../../../../common/components/modal/Modal';
 import useRundown from '../../../../../common/hooks-query/useRundown';
-import { validateExcelImport } from '../../../../../common/utils/uploadUtils';
+import { removeFileExtension, validateExcelImport } from '../../../../../common/utils/uploadUtils';
 import * as Panel from '../../../panel-utils/PanelUtils';
 import GSheetSetup from './GSheetSetup';
 import SheetImportEditor from './sheet-import/SheetImportEditor';
@@ -35,6 +37,7 @@ const googleSheetDocsUrl = 'https://docs.getontime.no/features/import-spreadshee
 type ActiveSource =
  | {
      kind: 'excel';
+      fileName: string;
      worksheetNames: string[];
      initialWorksheetMetadata: SpreadsheetWorksheetMetadata | null;
      closedByUser: boolean;
@@ -55,7 +58,7 @@ export default function SourcesPanel() {
  const [activeSource, setActiveSource] = useState<ActiveSource | null>(null);

  const { data: currentRundown } = useRundown();
-  const { importRundown } = useSpreadsheetImport();
+  const { applyImport } = useSpreadsheetImport();

  const fileInputRef = useRef<HTMLInputElement>(null);

@@ -74,6 +77,7 @@ export default function SourcesPanel() {
      const worksheetOptions = await uploadExcel(fileToUpload);
      setActiveSource({
        kind: 'excel',
+        fileName: fileToUpload.name,
        worksheetNames: worksheetOptions.worksheets,
        initialWorksheetMetadata: worksheetOptions.metadata,
        closedByUser: false,
@@ -126,21 +130,32 @@ export default function SourcesPanel() {
    setError('');
  };

-  const handleApplyImport = async (preview: SpreadsheetPreviewResponse) => {
+  const handleApplyImport = async (
+    preview: SpreadsheetPreviewResponse,
+    mode: RundownImportMode,
+    newRundownTitle: string,
+    providedFields: ImportedFields,
+  ) => {
+    if (mode === 'new') {
+      const title = newRundownTitle.trim() || preview.rundown.title;
+      await applyImport({ mode: 'new', rundown: { ...preview.rundown, title }, customFields: preview.customFields });
+      handleFinished();
+      return;
+    }
+
    if (!currentRundown) {
      throw new Error('No current rundown loaded');
    }

-    await importRundown(
-      {
-        [currentRundown.id]: {
-          ...preview.rundown,
-          id: currentRundown.id,
-          title: currentRundown.title,
-        },
-      },
-      preview.customFields,
-    );
+    // override or merge into the current rundown; merge uses providedFields to know which columns
+    // the sheet supplied so matched events keep the rest (e.g. automations)
+    await applyImport({
+      mode,
+      targetRundownId: currentRundown.id,
+      rundown: preview.rundown,
+      customFields: preview.customFields,
+      providedFields,
+    });
    handleFinished();
  };

@@ -208,6 +223,13 @@ export default function SourcesPanel() {
    if (activeSource.kind === 'excel') return 'excel';
    return `gsheet:${activeSource.sheetId}`;
  })();
+  // suggested name when importing into a new rundown: the spreadsheet file name (without extension)
+  // for Excel, or the document title for Google Sheets
+  const spreadsheetName = (() => {
+    if (!activeSource) return '';
+    if (activeSource.kind === 'excel') return removeFileExtension(activeSource.fileName);
+    return activeSource.title;
+  })();

  return (
    <Panel.Section>
@@ -287,6 +309,7 @@ export default function SourcesPanel() {
          bodyElements={
            <SheetImportEditor
              sourceKey={sourceKey ?? 'spreadsheet'}
+              defaultRundownName={spreadsheetName}
              worksheetNames={activeSource?.worksheetNames ?? []}
              initialMetadata={activeSource?.initialWorksheetMetadata ?? null}
              loadMetadata={loadWorksheetMetadata}
@@ -0,0 +1,55 @@
+import type { RundownImportMode, SpreadsheetPreviewResponse } from 'ontime-types';
+import { isOntimeEvent, isPlayableEvent, Playback } from 'ontime-types';
+import { useEffect, useState } from 'react';
+
+import Button from '../../../../../../common/components/buttons/Button';
+import { usePlayback, useSelectedEventId } from '../../../../../../common/hooks/useSocket';
+
+interface ApplyImportButtonProps {
+  preview: SpreadsheetPreviewResponse | null;
+  mode: RundownImportMode;
+  disabled: boolean;
+  loading: boolean;
+  onApply: () => void;
+}
+
+/**
+ * Apply action for the spreadsheet import.
+ * Subscribes to playback state on its own so playback updates do not re-render the whole editor.
+ * Requires a second click to confirm when applying would stop a running playback.
+ */
+export default function ApplyImportButton({ preview, mode, disabled, loading, onApply }: ApplyImportButtonProps) {
+  const playback = usePlayback();
+  const loadedEventId = useSelectedEventId();
+
+  // the loaded (playing) event loses its playback unless it still exists as a playable event after the import
+  const loadedEntry = loadedEventId ? preview?.rundown.entries[loadedEventId] : undefined;
+  const willLoadedEventBeOverriden = !(
+    loadedEntry !== undefined &&
+    isOntimeEvent(loadedEntry) &&
+    isPlayableEvent(loadedEntry)
+  );
+
+  // applying stops playback when creating a new rundown, or when the playing event does not survive
+  const willStopPlayback = playback !== Playback.Stop && (mode === 'new' || willLoadedEventBeOverriden);
+
+  // two-step confirmation before applying an import that stops playback
+  const [confirmStop, setConfirmStop] = useState(false);
+  useEffect(() => {
+    setConfirmStop(false);
+  }, [mode, preview]);
+
+  const handleClick = () => {
+    if (willStopPlayback && !confirmStop) {
+      setConfirmStop(true);
+      return;
+    }
+    onApply();
+  };
+
+  return (
+    <Button variant='primary' onClick={handleClick} disabled={disabled} loading={loading}>
+      {willStopPlayback && confirmStop ? 'Confirm — stop playback & apply import' : 'Apply import'}
+    </Button>
+  );
+}
@@ -33,6 +33,11 @@
  white-space: nowrap;
 }

+.importModeTrigger {
+  min-width: 12rem;
+  justify-content: space-between;
+}
+
 .addColumnTrigger {
  justify-content: center;
  white-space: nowrap;
@@ -1,10 +1,20 @@
-import type { SpreadsheetPreviewResponse, SpreadsheetWorksheetMetadata } from 'ontime-types';
+import type {
+  ImportedFields,
+  RundownImportMode,
+  SpreadsheetPreviewResponse,
+  SpreadsheetWorksheetMetadata,
+} from 'ontime-types';
 import type { ImportMap } from 'ontime-utils';
-import { IoArrowUpOutline, IoEye } from 'react-icons/io5';
+import { useMemo } from 'react';
+import { IoArrowUpOutline, IoCheckmark, IoChevronDown, IoEye, IoWarningOutline } from 'react-icons/io5';

 import Button from '../../../../../../common/components/buttons/Button';
+import { DropdownMenu, DropdownMenuOption } from '../../../../../../common/components/dropdown-menu/DropdownMenu';
+import Input from '../../../../../../common/components/input/input/Input';
 import Select from '../../../../../../common/components/select/Select';
 import * as Panel from '../../../../panel-utils/PanelUtils';
+import ApplyImportButton from './ApplyImportButton';
+import { isIdColumnMapped } from './importMapUtils';
 import PreviewTable from './preview/PreviewTable';
 import SheetImportMappingPane from './SheetImportMappingPane';
 import { useSheetImportForm } from './useSheetImportForm';
@@ -13,17 +23,46 @@ import style from './SheetImportEditor.module.scss';

 interface SheetImportEditorProps {
  sourceKey: string;
+  defaultRundownName: string;
  worksheetNames: string[];
  initialMetadata: SpreadsheetWorksheetMetadata | null;
  loadMetadata: (worksheet: string) => Promise<SpreadsheetWorksheetMetadata>;
  previewImport: (importMap: ImportMap) => Promise<SpreadsheetPreviewResponse>;
-  onApply: (preview: SpreadsheetPreviewResponse) => Promise<void>;
+  onApply: (
+    preview: SpreadsheetPreviewResponse,
+    mode: RundownImportMode,
+    newRundownTitle: string,
+    providedFields: ImportedFields,
+  ) => Promise<void>;
  onCancel: () => void;
  onExport?: (importMap: ImportMap) => Promise<void>;
 }

+const importModeOptions: Array<{
+  value: RundownImportMode;
+  label: string;
+  description: string;
+}> = [
+  {
+    value: 'override',
+    label: 'Replace current rundown',
+    description: 'Spreadsheet data completely replaces current rundown',
+  },
+  {
+    value: 'merge',
+    label: 'Merge with current rundown',
+    description: 'Merge entries referencing their IDs, entries not present in spreadsheet rundown are deleted',
+  },
+  {
+    value: 'new',
+    label: 'New rundown',
+    description: 'Create a new rundown to import the data into. Loads the new rundown',
+  },
+];
+
 export default function SheetImportEditor({
  sourceKey,
+  defaultRundownName,
  worksheetNames,
  initialMetadata,
  loadMetadata,
@@ -49,11 +88,16 @@ export default function SheetImportEditor({
    isBusy,
    canPreview,
    displayError,
+    importMode,
+    setImportMode,
+    newRundownTitle,
+    setNewRundownTitle,
    handlePreviewSubmit,
    handleExportSubmit,
    handleApply,
  } = useSheetImportForm({
    sourceKey,
+    defaultRundownName,
    worksheetNames,
    initialMetadata,
    loadMetadata,
@@ -62,6 +106,19 @@ export default function SheetImportEditor({
    onExport,
  });

+  const selectedImportMode = importModeOptions.find((option) => option.value === importMode) ?? importModeOptions[0];
+  const importModeItems = useMemo<DropdownMenuOption[]>(
+    () =>
+      importModeOptions.map((option) => ({
+        type: 'item',
+        label: option.label,
+        description: option.description,
+        icon: importMode === option.value ? IoCheckmark : undefined,
+        onClick: () => setImportMode(option.value),
+      })),
+    [importMode, setImportMode],
+  );
+
  return (
    <Panel.Section as='form' id='spreadsheet-import-workspace' className={style.editor} onSubmit={handlePreviewSubmit}>
      <Panel.InlineElements align='apart' wrap='wrap' className={style.editorToolbar}>
@@ -107,33 +164,63 @@ export default function SheetImportEditor({
      </div>

      {displayError && <Panel.Error>{displayError}</Panel.Error>}
-      <Panel.InlineElements align='end' wrap='wrap' className={style.editorFooter}>
-        <Button onClick={onCancel} disabled={isBusy}>
-          Cancel
-        </Button>
-        {onExport && (
-          <Button onClick={handleExportSubmit} disabled={!canPreview} loading={state.loading === 'export'}>
-            <IoArrowUpOutline />
-            Export
+      {importMode === 'merge' && !isIdColumnMapped(values) && (
+        <Panel.Description tone='warning'>
+          <IoWarningOutline /> No ID column mapped — merge matches entries by ID, so it will behave like Replace. Export
+          your rundown to a spreadsheet first to keep its IDs.
+        </Panel.Description>
+      )}
+      <Panel.InlineElements align='apart' wrap='wrap' className={style.editorFooter}>
+        <Panel.InlineElements wrap='wrap'>
+          <label className={style.worksheetControl}>
+            <span className={style.worksheetLabel}>Import mode</span>
+            <DropdownMenu
+              render={<Button className={style.importModeTrigger} variant='subtle-white' />}
+              items={importModeItems}
+            >
+              {selectedImportMode.label}
+              <IoChevronDown />
+            </DropdownMenu>
+          </label>
+          {importMode === 'new' && (
+            <label className={style.worksheetControl}>
+              <span className={style.worksheetLabel}>New rundown name</span>
+              <Input
+                value={newRundownTitle}
+                onChange={(event) => setNewRundownTitle(event.target.value)}
+                placeholder={state.preview?.rundown.title || 'Imported rundown'}
+                aria-label='New rundown name'
+              />
+            </label>
+          )}
+        </Panel.InlineElements>
+        <Panel.InlineElements wrap='wrap'>
+          <Button onClick={onCancel} disabled={isBusy}>
+            Cancel
          </Button>
-        )}
-        <Button
-          variant={state.preview ? undefined : 'primary'}
-          onClick={handlePreviewSubmit}
-          disabled={!canPreview}
-          loading={state.loading === 'preview'}
-        >
-          <IoEye />
-          Preview import
-        </Button>
-        <Button
-          variant='primary'
-          onClick={handleApply}
-          disabled={!state.preview || isBusy}
-          loading={state.loading === 'apply'}
-        >
-          Apply import
-        </Button>
+          {onExport && (
+            <Button onClick={handleExportSubmit} disabled={!canPreview} loading={state.loading === 'export'}>
+              <IoArrowUpOutline />
+              Export
+            </Button>
+          )}
+          <Button
+            variant={state.preview ? undefined : 'primary'}
+            onClick={handlePreviewSubmit}
+            disabled={!canPreview}
+            loading={state.loading === 'preview'}
+          >
+            <IoEye />
+            Preview import
+          </Button>
+          <ApplyImportButton
+            preview={state.preview}
+            mode={importMode}
+            disabled={!state.preview || isBusy}
+            loading={state.loading === 'apply'}
+            onApply={handleApply}
+          />
+        </Panel.InlineElements>
      </Panel.InlineElements>
    </Panel.Section>
  );
@@ -1,15 +1,21 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';

 import {
  builtInFieldDefs,
  convertToImportMap,
  createDefaultFormValues,
+  defaultImportMode,
  getImportWarnings,
+  getPersistedImportMode,
+  getProvidedImportFields,
  getResolvedCustomFields,
+  isIdColumnMapped,
+  persistImportMode,
 } from '../importMapUtils';

 const cueIndex = builtInFieldDefs.findIndex((field) => field.label === 'Cue');
 const titleIndex = builtInFieldDefs.findIndex((field) => field.label === 'Title');
+const idIndex = builtInFieldDefs.findIndex((field) => field.importKey === 'id');

 describe('getImportWarnings()', () => {
  it('warns when two mappings target the same spreadsheet column', () => {
@@ -128,3 +134,64 @@ describe('convertToImportMap()', () => {
    });
  });
 });
+
+describe('getProvidedImportFields()', () => {
+  it('reports the mapped built-in and custom fields the sheet supplies', () => {
+    const values = createDefaultFormValues();
+    values.builtIn[titleIndex] = { header: 'title', enabled: true };
+    values.builtIn[cueIndex] = { header: '', enabled: false };
+    values.custom = [{ ontimeName: 'ignored', importName: 'FOH/Monitor' }];
+
+    const provided = getProvidedImportFields(convertToImportMap(values));
+
+    // enabled built-in mappings are reported as event fields, disabled ones are not
+    expect(provided.event).toContain('title');
+    expect(provided.event).not.toContain('cue');
+    // the id column is only used for matching, never overwritten
+    expect(provided.event).not.toContain('id');
+    // custom fields are reported symmetrically by their resolved Ontime name
+    expect(provided.custom).toStrictEqual(['FOH Monitor']);
+  });
+});
+
+describe('isIdColumnMapped()', () => {
+  it('is true when the ID field is enabled with a header', () => {
+    // the default form maps the ID column
+    expect(isIdColumnMapped(createDefaultFormValues())).toBe(true);
+  });
+
+  it('is false when the ID field is disabled', () => {
+    const values = createDefaultFormValues();
+    values.builtIn[idIndex] = { header: 'id', enabled: false };
+    expect(isIdColumnMapped(values)).toBe(false);
+  });
+
+  it('is false when the ID field header is blank', () => {
+    const values = createDefaultFormValues();
+    values.builtIn[idIndex] = { header: '   ', enabled: true };
+    expect(isIdColumnMapped(values)).toBe(false);
+  });
+});
+
+describe('import mode persistence', () => {
+  const sourceKey = 'excel-test';
+
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('defaults to override when nothing is persisted', () => {
+    expect(getPersistedImportMode(sourceKey)).toBe('override');
+    expect(defaultImportMode).toBe('override');
+  });
+
+  it('round-trips a persisted value', () => {
+    persistImportMode(sourceKey, 'merge');
+    expect(getPersistedImportMode(sourceKey)).toBe('merge');
+  });
+
+  it('falls back to the default when the persisted value is invalid', () => {
+    persistImportMode(sourceKey, 'nonsense' as never);
+    expect(getPersistedImportMode(sourceKey)).toBe('override');
+  });
+});
@@ -1,3 +1,4 @@
+import type { ImportedFields, RundownImportMode } from 'ontime-types';
 import type { ImportMap } from 'ontime-utils';

 import { makeStageKey } from '../../../../../../common/utils/localStorage';
@@ -49,6 +50,16 @@ export function createDefaultFormValues(): ImportFormValues {
  };
 }

+/**
+ * Whether the mapping supplies an ID column. Merge matches entries by ID, so without one every
+ * imported entry gets a fresh id and nothing can reconcile with the current rundown.
+ */
+export function isIdColumnMapped(values: ImportFormValues): boolean {
+  const idIndex = builtInFieldDefs.findIndex((def) => def.importKey === 'id');
+  const field = values.builtIn[idIndex];
+  return Boolean(field?.enabled && field.header.trim());
+}
+
 function sanitiseOntimeCustomFieldLabel(importName: string): string {
  // Replace punctuation with spaces, then collapse repeated whitespace into single spaces.
  const sanitised = importName
@@ -81,6 +92,24 @@ export function getResolvedCustomFields(customFields: ImportFormValues['custom']
  });
 }

+/**
+ * Returns the fields the import map supplies — the complete description of what the incoming data
+ * provides, for both built-in and custom fields. A merge uses this to patch exactly these fields
+ * onto a matched event and keep everything else (e.g. automations) untouched.
+ * Import-map keys are OntimeEvent field names; `worksheet`/`custom` are meta and `id` is only used
+ * for matching, not overwritten.
+ */
+export function getProvidedImportFields(importMap: ImportMap): ImportedFields {
+  const event: string[] = [];
+  for (const [key, value] of Object.entries(importMap)) {
+    if (key === 'worksheet' || key === 'custom' || key === 'id') continue;
+    if (typeof value === 'string' && value.trim() !== '') {
+      event.push(key);
+    }
+  }
+  return { event, custom: Object.keys(importMap.custom) };
+}
+
 export function convertToImportMap(values: ImportFormValues): ImportMap {
  const custom = getResolvedCustomFields(values.custom).reduce<Record<string, string>>(
    (accumulator, { ontimeName, importName }) => {
@@ -130,12 +159,12 @@ function isPersistedFormValues(obj: unknown): obj is ImportFormValues {
 export function getPersistedImportState(sourceKey: string): { values: ImportFormValues; isPersisted: boolean } {
  const storageKey = getImportMapKey(sourceKey);
  try {
-    const raw = localStorage.getItem(storageKey);
-    if (!raw) {
+    const persistedData = localStorage.getItem(storageKey);
+    if (!persistedData) {
      return { values: createDefaultFormValues(), isPersisted: false };
    }

-    const parsed: unknown = JSON.parse(raw);
+    const parsed: unknown = JSON.parse(persistedData);
    if (isPersistedFormValues(parsed)) {
      return { values: parsed, isPersisted: true };
    }
@@ -150,6 +179,32 @@ export function getPersistedImportState(sourceKey: string): { values: ImportForm
  }
 }

+/**
+ * The import mode (new / merge / override) is persisted separately from the field mapping
+ * so the mapping schema guard stays untouched.
+ */
+
+/** Default import mode: replace matched elements in the current rundown */
+export const defaultImportMode: RundownImportMode = 'override';
+
+function getImportModeKey(sourceKey: string) {
+  return makeStageKey(`import-mode:${sourceKey}`);
+}
+
+/** Persists the import mode for a given source */
+export function persistImportMode(sourceKey: string, mode: RundownImportMode) {
+  localStorage.setItem(getImportModeKey(sourceKey), mode);
+}
+
+/** Reads the persisted import mode for a source, falling back to the default when absent or invalid */
+export function getPersistedImportMode(sourceKey: string): RundownImportMode {
+  const persisted = localStorage.getItem(getImportModeKey(sourceKey));
+  if (persisted === 'new' || persisted === 'merge' || persisted === 'override') {
+    return persisted;
+  }
+  return defaultImportMode;
+}
+
 /**
 * Validates import mappings and generates warnings for duplicate or missing spreadsheet columns.
 */
@@ -1,7 +1,12 @@
 import { useQuery, useQueryClient } from '@tanstack/react-query';
-import type { SpreadsheetPreviewResponse, SpreadsheetWorksheetMetadata } from 'ontime-types';
+import type {
+  ImportedFields,
+  RundownImportMode,
+  SpreadsheetPreviewResponse,
+  SpreadsheetWorksheetMetadata,
+} from 'ontime-types';
 import { millisToString } from 'ontime-utils';
-import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react';
 import { useFieldArray, useForm } from 'react-hook-form';

 import { maybeAxiosError } from '../../../../../../common/api/utils';
@@ -11,8 +16,11 @@ import {
  builtInFieldDefs,
  convertToImportMap,
  getImportWarnings,
+  getPersistedImportMode,
  getPersistedImportState,
+  getProvidedImportFields,
  getResolvedCustomFields,
+  persistImportMode,
  persistImportState,
 } from './importMapUtils';
 import { deriveHeaderOptionsState } from './spreadsheetImportUtils';
@@ -100,16 +108,23 @@ function buildColumnLabels(values: ImportFormValues): string[] {

 interface UseSheetImportFormProps {
  sourceKey: string;
+  defaultRundownName: string;
  worksheetNames: string[];
  initialMetadata: SpreadsheetWorksheetMetadata | null;
  loadMetadata: (worksheet: string) => Promise<SpreadsheetWorksheetMetadata>;
  previewImport: (importMap: ReturnType<typeof convertToImportMap>) => Promise<SpreadsheetPreviewResponse>;
-  onApply: (preview: SpreadsheetPreviewResponse) => Promise<void>;
+  onApply: (
+    preview: SpreadsheetPreviewResponse,
+    mode: RundownImportMode,
+    newRundownTitle: string,
+    providedFields: ImportedFields,
+  ) => Promise<void>;
  onExport?: (importMap: ReturnType<typeof convertToImportMap>) => Promise<void>;
 }

 export function useSheetImportForm({
  sourceKey,
+  defaultRundownName,
  worksheetNames,
  initialMetadata,
  loadMetadata,
@@ -170,6 +185,8 @@ export function useSheetImportForm({
  const columnLabels = buildColumnLabels(values);

  const [state, dispatch] = useReducer(importReducer, initialImportState);
+  const [importMode, setImportMode] = useState<RundownImportMode>(() => getPersistedImportMode(sourceKey));
+  const [newRundownTitle, setNewRundownTitle] = useState(defaultRundownName);
  const warnings = getImportWarnings(values, headers);
  const warningCount = Object.values(warnings).filter(Boolean).length;
  const previewRef = useRef<SpreadsheetPreviewResponse | null>(null);
@@ -182,6 +199,12 @@ export function useSheetImportForm({
    dispatch({ type: 'reset' });
  }, [initialFormValues, reset]);

+  // Update import mode and rundown name if the source changes
+  useEffect(() => {
+    setImportMode(getPersistedImportMode(sourceKey));
+    setNewRundownTitle(defaultRundownName);
+  }, [sourceKey, defaultRundownName]);
+
  // Keep the worksheet selection valid if the available worksheets change underneath the form.
  useEffect(() => {
    if (worksheetNames.length === 0) return;
@@ -241,13 +264,15 @@ export function useSheetImportForm({

    try {
      dispatch({ type: 'startApply' });
-      await onApply(state.preview);
+      const providedFields = getProvidedImportFields(convertToImportMap(getValues()));
+      await onApply(state.preview, importMode, newRundownTitle, providedFields);
      persistImportState(sourceKey, getValues());
+      persistImportMode(sourceKey, importMode);
      dispatch({ type: 'applySuccess' });
    } catch (error) {
      dispatch({ type: 'failure', error: maybeAxiosError(error) });
    }
-  }, [getValues, onApply, sourceKey, state.preview]);
+  }, [getValues, importMode, newRundownTitle, onApply, sourceKey, state.preview]);

  const handleExport = useCallback(
    async (formValues: ImportFormValues) => {
@@ -300,6 +325,10 @@ export function useSheetImportForm({
    isBusy,
    canPreview,
    displayError,
+    importMode,
+    setImportMode,
+    newRundownTitle,
+    setNewRundownTitle,
    handlePreviewSubmit: handleSubmit(handlePreview),
    handleExportSubmit: handleSubmit(handleExport),
    handleApply,
@@ -1,30 +1,17 @@
-import { useQueryClient } from '@tanstack/react-query';
-import { CustomFields, ProjectRundowns } from 'ontime-types';
+import { RundownImportPayload } from 'ontime-types';
 import { useCallback } from 'react';

-import { CUSTOM_FIELDS, RUNDOWN } from '../../../../../common/api/constants';
-import { patchData } from '../../../../../common/api/db';
+import { importRundownWithOptions } from '../../../../../common/api/rundown';

 export default function useSpreadsheetImport() {
-  const queryClient = useQueryClient();
-
-  /** applies rundown and customFields to current project */
-  const importRundown = useCallback(
-    async (rundowns: ProjectRundowns, customFields: CustomFields) => {
-      await patchData({ rundowns, customFields });
-      // we are unable to optimistically set the rundown since we need
-      // it to be normalised
-      await queryClient.invalidateQueries({
-        queryKey: RUNDOWN,
-      });
-      await queryClient.invalidateQueries({
-        queryKey: CUSTOM_FIELDS,
-      });
-    },
-    [queryClient],
-  );
+  /** applies a spreadsheet import: override or merge into the current rundown, or create a new one */
+  const applyImport = useCallback(async (payload: RundownImportPayload) => {
+    // the backend broadcasts a refetch once the rundown is parsed and applied, so the caches update
+    // through that single path rather than racing it with an optimistic write from here
+    await importRundownWithOptions(payload);
+  }, []);

  return {
-    importRundown,
+    applyImport,
  };
 }
@@ -73,6 +73,10 @@
  margin-right: 0.25rem;
 }

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

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

 import style from './PlaybackTimer.module.scss';
@@ -24,15 +25,14 @@ function resolveAddedTimeLabel(addedTime: number) {
 }

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

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

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

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

  return (
    <>
@@ -80,7 +88,9 @@ function RunningStatus({ startedAt, expectedFinish, playback }: RunningStatusPro
        <span className={style.time}>{started}</span>
      </span>
      <span className={style.finish}>
-        <span className={style.tag}>Expect end</span>
+        <span className={cx([style.tag, isOvertime && style.tagOvertime])}>
+          {isCountToEnd ? 'Scheduled end' : 'Expected end'}
+        </span>
        <span className={style.time}>{finish}</span>
      </span>
    </>
@@ -105,12 +105,29 @@ export default function Rundown({ order, flatOrder, entries, id, rundownMetadata
    handleCollapseGroup,
  });

+  // Jump to the current element on demand: the running event in Run mode, the edit cursor otherwise.
+  // Scrolls only (no selection change) so jumping to the running event does not hijack the edit cursor.
+  const jumpToCurrent = useCallback(() => {
+    const targetId = editorMode === AppMode.Run ? featureData?.selectedEventId : cursor;
+    if (!targetId) {
+      return;
+    }
+
+    // Open parent group if the target is inside a collapsed group
+    const entry = entries[targetId];
+    if (entry && 'parent' in entry) {
+      expandGroup(entry.parent);
+    }
+    scrollToEntry(targetId);
+  }, [editorMode, featureData?.selectedEventId, cursor, entries, expandGroup, scrollToEntry]);
+
  // Keyboard shortcuts
  useRundownKeyboard({
    cursor,
    commands,
    clearSelectedEvents,
    setEntryCopyId,
+    jumpToCurrent,
  });

  // DND handlers
@@ -322,7 +339,9 @@ export default function Rundown({ order, flatOrder, entries, id, rundownMetadata
            increaseViewportBy={{ top: 200, bottom: 400 }}
            style={{ height: '100%' }}
            components={{
-              Header: isEditMode ? () => <QuickAddButtons previousEventId={null} parentGroup={null} /> : undefined,
+              Header: isEditMode
+                ? () => <QuickAddButtons previousEventId={null} nextEventId={order[0]} parentGroup={null} />
+                : undefined,
              Footer: () => (
                <>
                  {isEditMode && (
@@ -22,10 +22,13 @@ export default function CuesheetEntryEditor({ entryId, rundown }: CuesheetEntryE
    return event ?? null;
  }, [entryId, rundown.entries, rundown.order.length]);

-  if (isOntimeEvent(entry)) {
+  // the cuesheet always edits a single entry
+  const events = useMemo(() => (isOntimeEvent(entry) ? [entry] : null), [entry]);
+
+  if (events) {
    return (
      <div className={style.entryEditor} data-testid='editor-container'>
-        <EventEditor event={entry} />
+        <EventEditor events={events} />
      </div>
    );
  }
@@ -75,6 +75,26 @@
  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;
@@ -1,14 +1,19 @@
 import { OntimeEvent } from 'ontime-types';
-import { useCallback } from 'react';
+import { useCallback, useMemo } 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';

@@ -16,66 +21,115 @@ import style from './EntryEditor.module.scss';
 export type EventEditorUpdateFields = 'cue' | 'title' | 'note' | 'colour' | string;

 interface EventEditorProps {
-  event: OntimeEvent;
+  /** events being edited, editing several events at once shows a merged view of their values */
+  events: OntimeEvent[];
 }

-export default function EventEditor({ event }: EventEditorProps) {
+export default function EventEditor({ events }: EventEditorProps) {
  const { data: customFields } = useCustomFields();
-  const { updateEntry } = useEntryActionsContext();
+  const { updateEntry, batchUpdateEvents } = 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];
-        updateEntry({ id: event.id, custom: { [fieldLabel]: value } });
+        submit({ custom: { [fieldLabel]: value } });
      } else {
-        updateEntry({ id: event.id, [field]: value });
+        submit({ [field]: value });
      }
    },
-    [event.id, updateEntry],
+    [submit],
  );

+  // 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={`${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}
+        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}
      />
      <EventEditorTitles
-        key={`${event.id}-titles`}
-        eventId={event.id}
-        cue={event.cue}
-        flag={event.flag}
-        title={event.title}
-        note={event.note}
-        colour={event.colour}
+        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}
      />
      <div className={style.column}>
        <Editor.Title>
          Custom Fields
          {isEditor && <AppLink search='settings=manage__custom'>Manage Custom Fields</AppLink>}
        </Editor.Title>
-        <EntryEditorCustomFields fields={customFields} handleSubmit={handleSubmit} entry={event} />
+        <EntryEditorCustomFields
+          key={`${editorKey}-custom`}
+          fields={customFields}
+          custom={merged.custom}
+          idKey={editorKey}
+          mixedPlaceholder={mixedPlaceholder}
+          handleSubmit={handleSubmit}
+        />
      </div>
      <div className={style.column}>
        <Editor.Title>
          Automations
-          {isEditor && <AppLink search='settings=automation'>Manage Automations</AppLink>}
+          {isEditor && singleEvent && <AppLink search='settings=automation'>Manage Automations</AppLink>}
        </Editor.Title>
-        <EventEditorTriggers triggers={event.triggers} eventId={event.id} />
+        {singleEvent ? (
+          <EventEditorTriggers triggers={singleEvent.triggers} eventId={singleEvent.id} />
+        ) : (
+          <Info>Automations are not available when editing multiple events</Info>
+        )}
      </div>
    </div>
  );
@@ -44,6 +44,9 @@ function EventEditorEmpty() {
              <Separator />
              <Combo keys={['PgDn']} />
            </Shortcut>
+            <Shortcut label='Jump to current entry'>
+              <Combo keys={[deviceAlt, 'L']} />
+            </Shortcut>
            <Shortcut label='Deselect entry'>
              <Combo keys={['Esc']} />
            </Shortcut>
@@ -112,7 +112,12 @@ 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} entry={group} />
+        <EntryEditorCustomFields
+          fields={customFields}
+          handleSubmit={handleSubmit}
+          custom={group.custom}
+          idKey={group.id}
+        />
      </div>
    </div>
  );
@@ -69,7 +69,12 @@ 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} entry={milestone} />
+        <EntryEditorCustomFields
+          fields={customFields}
+          handleSubmit={handleSubmit}
+          custom={milestone.custom}
+          idKey={milestone.id}
+        />
      </div>
    </div>
  );
@@ -1,4 +1,4 @@
-import { OntimeEntry, isOntimeEvent, isOntimeGroup, isOntimeMilestone } from 'ontime-types';
+import { OntimeEntry, OntimeEvent, isOntimeEvent, isOntimeGroup, isOntimeMilestone } from 'ontime-types';
 import { useMemo } from 'react';

 import useRundown from '../../../common/hooks-query/useRundown';
@@ -15,6 +15,25 @@ 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;
@@ -29,19 +48,20 @@ export default function RundownEntryEditor() {
    return event ?? null;
  }, [data.order.length, data.entries, selectedEvents]);

-  if (!entry) {
-    return <EventEditorEmpty />;
-  }
-
-  if (isOntimeEvent(entry)) {
+  if (events.length > 0) {
+    const singleEvent = events.length === 1 ? events[0] : null;
    return (
      <div className={style.rundownEditor} data-testid='editor-container'>
-        <EventEditor event={entry} />
-        <EventEditorFooter id={entry.id} cue={entry.cue} />
+        <EventEditor events={events} />
+        {singleEvent && <EventEditorFooter id={singleEvent.id} cue={singleEvent.cue} />}
      </div>
    );
  }

+  if (!entry) {
+    return <EventEditorEmpty />;
+  }
+
  if (isOntimeMilestone(entry)) {
    return (
      <div className={style.rundownEditor} data-testid='editor-container'>
@@ -0,0 +1,122 @@
+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();
+  });
+});
@@ -0,0 +1,48 @@
+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>
+  );
+}
@@ -1,8 +1,9 @@
-import { CustomFields, OntimeEvent, OntimeGroup, OntimeMilestone } from 'ontime-types';
+import { CustomFields, EntryCustomFields } 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';
@@ -11,21 +12,29 @@ import style from '../EntryEditor.module.scss';

 interface EntryEditorCustomFieldsProps {
  fields: CustomFields;
-  entry: OntimeEvent | OntimeGroup | OntimeMilestone;
+  /** 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;
  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 = `${entry.id}-${fieldKey}`;
+        const key = `${idKey}-${fieldKey}`;
        const fieldName = `custom-${fieldKey}`;
-        const initialValue = entry.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 { backgroundColor, color } = getAccessibleColour(customFields[fieldKey].colour);
        const labelText = customFields[fieldKey].label;

@@ -36,6 +45,7 @@ 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}
@@ -51,13 +61,13 @@ export default function EntryEditorCustomFields({
                field={fieldName}
                label={labelText}
                initialValue={initialValue}
-                placeholder='Paste image URL'
+                placeholder={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>
          );
        }
@@ -0,0 +1,62 @@
+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>
+  );
+}
@@ -1,4 +1,4 @@
-import { EndAction, TimeStrategy, TimerType } from 'ontime-types';
+import { EndAction, OntimeEvent, TimerType } from 'ontime-types';
 import { parseUserTime } from 'ontime-utils';
 import { memo } from 'react';
 import { IoInformationCircle } from 'react-icons/io5';
@@ -8,102 +8,47 @@ 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 { useEntryActionsContext } from '../../../../common/context/EntryActionsContext';
-import { millisToDelayString } from '../../../../common/utils/dateConfig';
-import { formatTime } from '../../../../common/utils/time';
-import TimeInputFlow from '../../time-input-flow/TimeInputFlow';
+import { mixedPlaceholder, switchLabel } from '../entryEditor.utils';

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

 interface EventEditorTimesProps {
-  eventId: string;
-  timeStart: number;
-  timeEnd: number;
-  duration: number;
-  timeStrategy: TimeStrategy;
-  linkStart: boolean;
-  countToEnd: boolean;
-  delay: number;
-  endAction: EndAction;
-  timerType: TimerType;
-  timeWarning: number;
-  timeDanger: number;
+  countToEnd: boolean | undefined;
+  endAction: EndAction | undefined;
+  timerType: TimerType | undefined;
+  timeWarning: number | undefined;
+  timeDanger: number | undefined;
+  submit: (patch: Partial<OntimeEvent>) => void;
 }

-type HandledActions = 'countToEnd' | 'timerType' | 'endAction' | 'timeWarning' | 'timeDanger';
+type TimeFields = 'timeWarning' | 'timeDanger';

 export default memo(EventEditorTimes);
 function EventEditorTimes({
-  eventId,
-  timeStart,
-  timeEnd,
-  duration,
-  timeStrategy,
-  linkStart,
  countToEnd,
-  delay,
  endAction,
  timerType,
  timeWarning,
  timeDanger,
+  submit,
 }: EventEditorTimesProps) {
-  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 handleTimeSubmit = (field: TimeFields, value: string) => {
+    submit({ [field]: parseUserTime(value) });
  };

-  const hasDelay = delay !== 0;
-  const delayLabel = hasDelay
-    ? `Event is ${millisToDelayString(delay, 'expanded')}. New schedule ${formatTime(timeStart + delay)} → ${formatTime(timeEnd + delay)}`
-    : '';
-
  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}
-              countToEnd={countToEnd}
-              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}
+              value={endAction ?? null}
+              placeholder={mixedPlaceholder}
              onValueChange={(value: EndAction | null) => {
                if (value === null) return;
-                handleSubmit('endAction', value);
+                submit({ endAction: value });
              }}
              options={[
                { value: EndAction.None, label: 'None' },
@@ -117,10 +62,11 @@ function EventEditorTimes({
            <Editor.Label className={style.switchLabel}>
              <Switch
                id='countToEnd'
-                checked={countToEnd}
-                onCheckedChange={(value) => handleSubmit('countToEnd', value)}
+                checked={countToEnd ?? false}
+                mixed={countToEnd === undefined}
+                onCheckedChange={(value) => submit({ countToEnd: value })}
              />
-              {countToEnd ? 'On' : 'Off'}
+              {switchLabel(countToEnd)}
            </Editor.Label>
          </div>
        </div>
@@ -140,10 +86,11 @@ function EventEditorTimes({
          <div>
            <Editor.Label htmlFor='timerType'>Timer Type</Editor.Label>
            <Select
-              value={timerType}
+              value={timerType ?? null}
+              placeholder={mixedPlaceholder}
              onValueChange={(value: TimerType | null) => {
                if (value === null) return;
-                handleSubmit('timerType', value);
+                submit({ timerType: value });
              }}
              options={[
                { value: TimerType.CountDown, label: 'Count down' },
@@ -160,9 +107,9 @@ function EventEditorTimes({
              <TimeInput
                id='timeWarning'
                name='timeWarning'
-                submitHandler={handleSubmit}
+                submitHandler={handleTimeSubmit}
                time={timeWarning}
-                placeholder='Duration'
+                placeholder={timeWarning === undefined ? mixedPlaceholder : 'Duration'}
              />
            </div>
            <div>
@@ -170,9 +117,9 @@ function EventEditorTimes({
              <TimeInput
                id='timeDanger'
                name='timeDanger'
-                submitHandler={handleSubmit}
+                submitHandler={handleTimeSubmit}
                time={timeDanger}
-                placeholder='Duration'
+                placeholder={timeDanger === undefined ? mixedPlaceholder : 'Duration'}
              />
            </div>
          </div>
@@ -1,34 +1,36 @@
+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 { useEntryActionsContext } from '../../../../common/context/EntryActionsContext';
+import { enDash } from '../../../../common/utils/styleUtils';
+import { mixedPlaceholder, switchLabel } from '../entryEditor.utils';
 import EventTextArea from './EventTextArea';
 import EntryEditorTextInput from './EventTextInput';

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

 interface EventEditorTitlesProps {
-  eventId: string;
+  /** id of the event being edited, null when editing several events */
+  eventId: string | null;
+  /** amount of events being edited */
+  eventCount: number;
  cue: string;
-  flag: boolean;
-  title: string;
-  note: string;
-  colour: string;
+  flag: boolean | undefined;
+  title: string | undefined;
+  note: string | undefined;
+  colour: string | undefined;
+  submit: (patch: Partial<OntimeEvent>) => void;
 }

 export default memo(EventEditorTitles);
-function EventEditorTitles({ eventId, cue, flag, title, note, colour }: EventEditorTitlesProps) {
-  const { updateEntry } = useEntryActionsContext();
-
-  const flagSubmitHandler = (newValue: boolean) => {
-    updateEntry({ id: eventId, flag: newValue });
-  };
+function EventEditorTitles({ eventId, eventCount, cue, flag, title, note, colour, submit }: EventEditorTitlesProps) {
+  const isMulti = eventId === null;

  const textSubmitHandler = (field: string, newValue: string) => {
-    updateEntry({ id: eventId, [field]: newValue });
+    submit({ [field]: newValue });
  };

  return (
@@ -36,21 +38,39 @@ function EventEditorTitles({ eventId, cue, flag, title, note, colour }: EventEdi
      <Editor.Title>Event Data</Editor.Title>
      <div className={style.splitThree}>
        <div>
-          <Editor.Label htmlFor='eventId'>Event ID (read only)</Editor.Label>
-          <Input id='eventId' data-testid='input-textfield' value={eventId} readOnly fluid />
+          <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
+          />
        </div>
-        <EntryEditorTextInput
-          field='cue'
-          label='Cue'
-          initialValue={cue}
-          submitHandler={textSubmitHandler}
-          maxLength={10}
-        />
+        {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}
+          />
+        )}
        <div>
          <Editor.Label htmlFor='flag'>Flag</Editor.Label>
          <Editor.Label className={style.switchLabel}>
-            <Switch id='flag' checked={flag} onCheckedChange={flagSubmitHandler} />
-            {flag ? 'On' : 'Off'}
+            <Switch
+              id='flag'
+              checked={flag ?? false}
+              mixed={flag === undefined}
+              onCheckedChange={(newValue) => submit({ flag: newValue })}
+            />
+            {switchLabel(flag)}
          </Editor.Label>
        </div>
      </div>
@@ -58,8 +78,20 @@ function EventEditorTitles({ eventId, cue, flag, title, note, colour }: EventEdi
        <Editor.Label>Colour</Editor.Label>
        <SwatchSelect name='colour' value={colour} handleChange={textSubmitHandler} />
      </div>
-      <EntryEditorTextInput field='title' label='Title' initialValue={title} submitHandler={textSubmitHandler} />
-      <EventTextArea field='note' label='Note' initialValue={note} submitHandler={textSubmitHandler} />
+      <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}
+      />
    </div>
  );
 }
@@ -5,11 +5,15 @@ 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;
-  initialValue: string;
+  /** undefined represents values which do not agree across the edited entries */
+  initialValue: string | undefined;
+  placeholder?: string;
  style?: CSSProperties;
  submitHandler: (field: EventEditorUpdateFields, value: string) => void;
 }
@@ -19,6 +23,7 @@ export default function EventTextArea({
  field,
  label,
  initialValue,
+  placeholder,
  style: givenStyles,
  submitHandler,
 }: CountedTextAreaProps) {
@@ -29,16 +34,27 @@ 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>
-      <Editor.Label className={className} htmlFor={field} style={givenStyles}>
-        {label}
-      </Editor.Label>
+      <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>
      <AutoTextarea
        id={field}
        inputref={ref}
        rows={1}
        data-testid='input-textarea'
+        placeholder={placeholder}
        fluid
        value={value}
        onChange={onChange}
@@ -6,10 +6,13 @@ 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;
-  initialValue: string;
+  /** undefined represents values which do not agree across the edited entries */
+  initialValue: string | undefined;
  placeholder?: string;
  submitHandler: (field: EventEditorUpdateFields, value: string) => void;
 }
@@ -31,11 +34,21 @@ 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>
-      <Editor.Label className={className} htmlFor={field} style={givenStyles}>
-        {label}
-      </Editor.Label>
+      <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>
      <Input
        id={field}
        ref={ref}
@@ -0,0 +1,10 @@
+/** 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';
+}
@@ -0,0 +1,108 @@
+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;
+}
@@ -11,13 +11,17 @@ import style from './QuickAddButtons.module.scss';

 interface QuickAddButtonsProps {
  previousEventId: MaybeString;
+  nextEventId?: MaybeString;
  parentGroup: MaybeString;
  backgroundColor?: string;
 }

 export default memo(QuickAddButtons);
-function QuickAddButtons({ previousEventId, parentGroup, backgroundColor }: QuickAddButtonsProps) {
+function QuickAddButtons({ previousEventId, nextEventId, parentGroup, backgroundColor }: QuickAddButtonsProps) {
  const { addEntry } = useEntryActionsContext();
+  const appendOptions = previousEventId ? { after: previousEventId, lastEventId: previousEventId } : undefined;
+  const prependOptions = nextEventId ? { before: nextEventId } : undefined;
+  const insertionOptions = appendOptions ?? prependOptions;

  const addEvent = () => {
    addEntry(
@@ -25,44 +29,23 @@ function QuickAddButtons({ previousEventId, parentGroup, backgroundColor }: Quic
        type: SupportedEntry.Event,
        parent: parentGroup,
      },
-      {
-        after: previousEventId,
-        lastEventId: previousEventId,
-      },
+      insertionOptions,
    );
  };

  const addDelay = () => {
-    addEntry(
-      { type: SupportedEntry.Delay, parent: parentGroup },
-      {
-        lastEventId: previousEventId,
-        after: previousEventId,
-      },
-    );
+    addEntry({ type: SupportedEntry.Delay, parent: parentGroup }, insertionOptions);
  };

  const addMilestone = () => {
-    addEntry(
-      { type: SupportedEntry.Milestone, parent: parentGroup },
-      {
-        lastEventId: previousEventId,
-        after: previousEventId,
-      },
-    );
+    addEntry({ type: SupportedEntry.Milestone, parent: parentGroup }, insertionOptions);
  };

  const addGroup = () => {
    if (parentGroup !== null) {
      return;
    }
-    addEntry(
-      { type: SupportedEntry.Group },
-      {
-        lastEventId: previousEventId,
-        after: previousEventId,
-      },
-    );
+    addEntry({ type: SupportedEntry.Group }, insertionOptions);
  };

  /**
@@ -96,7 +96,7 @@ export function useRundownCommands({
      addEntry(patch, {
        after: id && !above ? id : undefined,
        before: id && above ? id : undefined,
-        lastEventId: !above && id ? id : undefined,
+        lastEventId: id && !above ? id : undefined,
      });
    },
    [addEntry],
@@ -19,6 +19,7 @@ interface UseRundownKeyboardOptions {
  };
  clearSelectedEvents: () => void;
  setEntryCopyId: (id: EntryId | null, mode?: 'copy' | 'cut') => void;
+  jumpToCurrent: () => void;
 }

 /**
@@ -40,6 +41,7 @@ export function useRundownKeyboard({
  commands,
  clearSelectedEvents,
  setEntryCopyId,
+  jumpToCurrent,
 }: UseRundownKeyboardOptions) {
  const scrollToEntry = useEventSelection((state) => state.scrollToEntry);

@@ -127,6 +129,8 @@ export function useRundownKeyboard({
      { preventDefault: true, usePhysicalKeys: true },
    ],

+    ['alt + L', () => jumpToCurrent(), { preventDefault: true, usePhysicalKeys: true }],
+
    [
      'alt + mod + ArrowDown',
      () => commands.moveEntry(cursor, 'down'),
@@ -7,6 +7,7 @@ $skip-opacity: 0.2;
  background-color: $block-bg;
  margin-block: 0.25rem;
  overflow: initial;
+  position: relative;

  display: grid;
  grid-template-areas:
@@ -16,7 +17,7 @@ $skip-opacity: 0.2;
    'binder pb-actions estatus estatus'
    'binder ...        ...     ...';

-  grid-template-columns: $block-binder-width 3rem 1fr 3rem;
+  grid-template-columns: $block-binder-width 3rem minmax(0, 1fr) 3rem;
  grid-template-rows: 0.125rem 2rem 2rem auto 0.125rem;
  align-items: center;
  padding-right: $block-clearance;
@@ -136,6 +137,7 @@ $skip-opacity: 0.2;
  align-items: center;
  gap: $block-clearance;
  height: 100%;
+  min-width: 0;
 }

 .eventTimers.editMode:hover {
@@ -155,7 +157,7 @@ $skip-opacity: 0.2;
  align-items: center;
  justify-content: space-between;

-  .nextTag {
+  .warningMeta {
    font-size: 1rem;
    color: $orange-500;
    letter-spacing: 0.03px;
@@ -231,6 +233,10 @@ $skip-opacity: 0.2;
    color: var(--status-color-active-override, $active-indicator);
  }

+  .statusIcon.countToEndStatus {
+    color: $orange-400;
+  }
+
  .statusIcon.warning {
    color: $orange-500;
  }
@@ -115,12 +115,12 @@ function RundownEventInner({
          delay={delay}
          timeStrategy={timeStrategy}
          linkStart={linkStart}
-          countToEnd={countToEnd}
        />
      </div>
      <div className={style.titleSection}>
        <TitleEditor title={title} entryId={eventId} placeholder='Event title' className={style.eventTitle} />
-        {isNext && <span className={style.nextTag}>UP NEXT</span>}
+        {isNext && <span className={style.warningMeta}>UP NEXT</span>}
+        {!isNext && countToEnd && <span className={style.warningMeta}>COUNT TO END</span>}
      </div>
      <EventBlockPlayback
        eventId={eventId}
@@ -157,7 +157,13 @@ function RundownEventInner({
            <EndActionIcon action={endAction} className={style.statusIcon} />
          </Tooltip>
          <Tooltip text={`${countToEnd ? 'Count to End' : 'Count duration'}`} render={<span />}>
-            <LuArrowDownToLine className={`${style.statusIcon} ${countToEnd ? style.active : style.disabled}`} />
+            <LuArrowDownToLine
+              className={cx([
+                style.statusIcon,
+                countToEnd ? style.active : style.disabled,
+                countToEnd && style.countToEndStatus,
+              ])}
+            />
          </Tooltip>
          <Tooltip text={automationTooltip} render={<span />}>
            <IoFlash className={automationIconClasses} />
@@ -1,10 +1,33 @@
+import { MILLIS_PER_HOUR, MILLIS_PER_MINUTE } from 'ontime-utils';
+
 import { formatDelay } from '../rundownEvent.utils';

 describe('formatDelay()', () => {
  it('adds a given delay to the start time', () => {
-    const timeStart = 60000; // 1 min
-    const delay = 60000; // 1 min
+    const timeStart = 1 * MILLIS_PER_MINUTE; // 00:01
+    const delay = 1 * MILLIS_PER_MINUTE; // 00:01
    const result = formatDelay(timeStart, delay);
    expect(result).toEqual('New start 00:02');
  });
+
+  it('wraps negative delayed starts under midnight', () => {
+    const timeStart = 1 * MILLIS_PER_MINUTE; // 00:01
+    const delay = -2 * MILLIS_PER_MINUTE; // -00:02
+    const result = formatDelay(timeStart, delay);
+    expect(result).toEqual('New start 23:59');
+  });
+
+  it('wraps later-day negative delays using delay as the source of truth', () => {
+    const timeStart = 1 * MILLIS_PER_HOUR; // 01:00
+    const delay = -(1 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE); // -01:30
+    const result = formatDelay(timeStart, delay);
+    expect(result).toEqual('New start 23:30');
+  });
+
+  it('displays positive delays as wall-clock time', () => {
+    const timeStart = 1 * MILLIS_PER_HOUR; // 01:00
+    const delay = 1 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE; // 01:30
+    const result = formatDelay(timeStart, delay);
+    expect(result).toEqual('New start 02:30');
+  });
 });
@@ -1,15 +1,16 @@
 import { millisToString, removeTrailingZero } from 'ontime-utils';

-import { formatDuration } from '../../../common/utils/time';
+import { formatDuration, normaliseWallClock } from '../../../common/utils/time';

 export function formatDelay(timeStart: number, delay: number): string | undefined {
  if (!delay) return;

-  const delayedStart = Math.max(0, timeStart + delay);
+  const delayedStart = normaliseWallClock(timeStart + delay);

  const timeTag = removeTrailingZero(millisToString(delayedStart));
  return `New start ${timeTag}`;
 }
+
 export function formatGap(gap: number, isNextDay: boolean) {
  if (gap === 0) {
    if (isNextDay) {
@@ -4,10 +4,15 @@

 .timerNote {
  width: 1.25em;
+  flex: 0 0 1.25em;
  color: $blue-500;
  font-size: 1.5em;
 }

+.timerNotePlaceholder {
+  visibility: hidden;
+}
+
 .inactive {
  color: $muted-gray;
 }
@@ -14,7 +14,6 @@ import style from './TimeInputFlow.module.scss';

 interface TimeInputFlowProps {
  eventId: string;
-  countToEnd: boolean;
  timeStart: number;
  timeEnd: number;
  duration: number;
@@ -22,12 +21,12 @@ interface TimeInputFlowProps {
  linkStart: boolean;
  delay: number;
  showLabels?: boolean;
+  showWarnings?: boolean;
 }

 export default memo(TimeInputFlow);
 function TimeInputFlow({
  eventId,
-  countToEnd,
  timeStart,
  timeEnd,
  duration,
@@ -35,6 +34,7 @@ function TimeInputFlow({
  linkStart,
  delay,
  showLabels,
+  showWarnings = true,
 }: TimeInputFlowProps) {
  const { updateEntry, updateTimer } = useEntryActionsContext();

@@ -56,10 +56,6 @@ function TimeInputFlow({
    warnings.push('Over midnight');
  }

-  if (countToEnd) {
-    warnings.push('Count to End');
-  }
-
  const hasDelay = delay !== 0;
  const isLockedEnd = timeStrategy === TimeStrategy.LockEnd;
  const isLockedDuration = timeStrategy === TimeStrategy.LockDuration;
@@ -136,11 +132,19 @@ function TimeInputFlow({
        </TimeInputGroup>
      </div>

-      {warnings.length > 0 && (
-        <Tooltip text={warnings.join(' - ')} className={style.timerNote} data-testid='event-warning' render={<span />}>
-          <IoAlertCircleOutline />
-        </Tooltip>
-      )}
+      {showWarnings &&
+        (warnings.length > 0 ? (
+          <Tooltip
+            text={warnings.join(' - ')}
+            className={style.timerNote}
+            data-testid='event-warning'
+            render={<span />}
+          >
+            <IoAlertCircleOutline />
+          </Tooltip>
+        ) : (
+          <span className={`${style.timerNote} ${style.timerNotePlaceholder}`} aria-hidden='true' />
+        ))}
    </>
  );
 }
@@ -153,7 +153,7 @@ type ScheduleTimeProps = {
 //TODO: consider relative mode
 export function ScheduleTime(props: ScheduleTimeProps) {
  const { event, showExpected } = props;
-  const { timeStart, duration, delay, expectedStart, countToEnd } = event;
+  const { timeStart, duration, delay, expectedStart, expectedEnd } = event;

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

@@ -164,7 +164,6 @@ export function ScheduleTime(props: ScheduleTimeProps) {

  const expectedStateClass = `sub__schedule--${getOffsetState(expectedStart - plannedStart)}`;
  const plannedEnd = plannedStart + duration + delay;
-  const expectedEnd = countToEnd ? Math.max(expectedStart + duration, plannedEnd) : expectedStart + duration;
  const expectedEndClass = `sub__schedule--${getOffsetState(expectedEnd - plannedEnd)}`;

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

 import Button from '../../common/components/buttons/Button';
 import useReport from '../../common/hooks-query/useReport';
 import { useFadeOutOnInactivity } from '../../common/hooks/useFadeOutOnInactivity';
 import { useExpectedStartData } from '../../common/hooks/useSocket';
-import { ExtendedEntry } from '../../common/utils/rundownMetadata';
 import { cx } from '../../common/utils/styleUtils';
 import SuperscriptTime from '../common/superscript-time/SuperscriptTime';
 import { getPropertyValue } from '../common/viewUtils';
 import { useCountdownOptions } from './countdown.options';
-import { CountdownTarget, useSubscriptionDisplayData } from './countdown.utils';
+import { CountdownEvent, CountdownTarget, useSubscriptionDisplayData } from './countdown.utils';
 import { ScheduleTime } from './CountdownSubscriptions';

 import './SingleEventCountdown.scss';
@@ -38,8 +36,10 @@ export default function SingleEventCountdown({ subscribedEvent, goToEditMode }:
    mode,
  });

+  const expectedEnd = getExpectedEnd(subscribedEvent, expectedStart, currentDay);
+
  const { endedAt } = reportData[subscribedEvent.reportId ?? subscribedEvent.id] ?? { endedAt: null };
-  const countdownEvent = { ...subscribedEvent, expectedStart, endedAt };
+  const countdownEvent = { ...subscribedEvent, expectedStart, endedAt, expectedEnd };
  const titleTmp = getPropertyValue(subscribedEvent, mainSource ?? 'title');
  const title = titleTmp?.length ? titleTmp : ' '; // insert utf-8 empty space to avoid the line collapsing;
  // while a group is live, surface the running event's title as the secondary line
@@ -64,7 +64,7 @@ export default function SingleEventCountdown({ subscribedEvent, goToEditMode }:
 }

 interface SubscriptionStatusProps {
-  event: ExtendedEntry<OntimeEvent> & { endedAt: MaybeNumber; expectedStart: number };
+  event: CountdownEvent;
 }

 function SubscriptionStatus({ event }: SubscriptionStatusProps) {
@@ -12,7 +12,7 @@ import {
  isOntimeGroup,
  isPlayableEvent,
 } from 'ontime-types';
-import { MILLIS_PER_MINUTE, getExpectedStart, millisToString, removeLeadingZero } from 'ontime-utils';
+import { MILLIS_PER_MINUTE, getExpectedEnd, getExpectedStart, millisToString, removeLeadingZero } from 'ontime-utils';

 import { useCountdownSocket } from '../../common/hooks/useSocket';
 import { ExtendedEntry } from '../../common/utils/rundownMetadata';
@@ -197,7 +197,7 @@ export type CountdownTarget = ExtendedEntry<OntimeEvent> & {
  liveEntry?: ExtendedEntry<OntimeEvent> | null; // the running child while a group is live
 };

-export type CountdownEvent = CountdownTarget & { expectedStart: number; endedAt: MaybeNumber };
+export type CountdownEvent = CountdownTarget & { expectedStart: number; endedAt: MaybeNumber; expectedEnd: number };

 /**
 * Resolves a subscription (event or group) into an event-shaped countdown target.
@@ -271,6 +271,7 @@ export function extendEventData(
    offset,
    mode,
  });
+  const expectedEnd = getExpectedEnd(event, expectedStart, currentDay);
  const { endedAt } = reportData[event.reportId ?? event.id] ?? { endedAt: null };
-  return { ...event, expectedStart, endedAt };
+  return { ...event, expectedStart, endedAt, expectedEnd };
 }
@@ -15,7 +15,7 @@ function EditorLayoutOptions() {
      {
        type: 'item',
        label: 'Planning',
-        description: 'Edit-focused list with planning stats',
+        description: 'Edit focused list with planning stats',
        icon: layoutMode === EditorLayoutMode.PLANNING ? IoCheckmark : undefined,
        onClick: () => setLayoutMode(EditorLayoutMode.PLANNING),
      },
@@ -28,9 +28,9 @@

  .timer-container {
    flex: 1;
-    align-content: center;
-    justify-self: center;
-    align-self: center;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;

    width: 100%;
    overflow: hidden;
@@ -82,9 +82,9 @@

  .timer-container {
    flex: 1;
-    align-content: center;
-    justify-self: center;
-    align-self: center;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;

    width: 100%;
    overflow: hidden;
@@ -1,6 +1,6 @@
 {
  "name": "ontime-electron",
-  "version": "4.10.0",
+  "version": "4.11.0",
  "author": "Carlos Valente",
  "description": "Time keeping for live events",
  "repository": "https://github.com/cpvalente/ontime",
@@ -125,6 +125,13 @@
          "**/*",
          "*{.ts}"
        ]
+      },
+      {
+        "from": "../server/src/html/",
+        "to": "extraResources/html/",
+        "filter": [
+          "**/*"
+        ]
      }
    ]
  }
@@ -1,6 +1,6 @@
 {
  "name": "@getontime/resolver",
-  "version": "4.10.0",
+  "version": "4.11.0",
  "type": "module",
  "repository": "https://github.com/cpvalente/ontime",
  "types": "./dist/main.d.ts",
@@ -2,7 +2,7 @@
  "name": "ontime-server",
  "type": "module",
  "main": "src/index.ts",
-  "version": "4.10.0",
+  "version": "4.11.0",
  "exports": "./src/index.js",
  "dependencies": {
    "@googleapis/sheets": "^5.0.5",
@@ -163,5 +163,70 @@ describe('parseOutput', () => {
        secondarySource: 'secondary',
      });
    });
+
+    it('parses message-secondary with a text value', () => {
+      expect(
+        parseOutput({
+          type: 'ontime',
+          action: 'message-secondary',
+          text: 'hello',
+        }),
+      ).toMatchObject({
+        text: 'hello',
+      });
+      expect(
+        parseOutput({
+          type: 'ontime',
+          action: 'message-secondary',
+          secondarySource: undefined,
+          text: 'hello',
+        }),
+      ).toMatchObject({
+        text: 'hello',
+      });
+      expect(
+        parseOutput({
+          type: 'ontime',
+          action: 'message-secondary',
+          secondarySource: 'secondary',
+          text: 'hello',
+        }),
+      ).toMatchObject({
+        secondarySource: 'secondary',
+        text: 'hello',
+      });
+      // an empty text is treated as no change
+      expect(
+        parseOutput({
+          type: 'ontime',
+          action: 'message-secondary',
+          secondarySource: 'secondary',
+          text: '',
+        }),
+      ).toMatchObject({
+        secondarySource: 'secondary',
+        text: undefined,
+      });
+      // text can be set while clearing the secondary source
+      expect(
+        parseOutput({
+          type: 'ontime',
+          action: 'message-secondary',
+          secondarySource: null,
+          text: 'hello',
+        }),
+      ).toMatchObject({
+        secondarySource: null,
+        text: 'hello',
+      });
+      expect(() =>
+        parseOutput({
+          type: 'ontime',
+          action: 'message-secondary',
+          secondarySource: 'secondary',
+          text: 123,
+        }),
+      ).toThrow('Unexpected payload type:');
+    });
  });
 });
@@ -0,0 +1,113 @@
+import { runtimeStorePlaceholder } from 'ontime-types';
+
+import * as messageService from '../../../services/message-service/message.service.js';
+import { toOntimeAction } from '../clients/ontime.client.js';
+
+vi.mock('../../../services/message-service/message.service.js', () => ({
+  patch: vi.fn(),
+}));
+
+describe('toOntimeAction()', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('parses templates in primary message text', () => {
+    toOntimeAction(
+      {
+        type: 'ontime',
+        action: 'message-set',
+        text: 'Current: {{timer.current}}',
+        visible: true,
+      },
+      {
+        ...runtimeStorePlaceholder,
+        timer: {
+          ...runtimeStorePlaceholder.timer,
+          current: 42,
+        },
+      },
+    );
+
+    expect(messageService.patch).toHaveBeenCalledWith({
+      timer: {
+        text: 'Current: 42',
+        visible: true,
+      },
+    });
+  });
+
+  it('parses templates in secondary message text', () => {
+    toOntimeAction(
+      {
+        type: 'ontime',
+        action: 'message-secondary',
+        secondarySource: 'secondary',
+        text: 'Next: {{eventNext.title}}',
+      },
+      {
+        ...runtimeStorePlaceholder,
+        eventNext: {
+          id: 'next-event',
+          type: 'event',
+          cue: '2',
+          title: 'Keynote',
+          note: '',
+          timeStart: 0,
+          timeEnd: 0,
+          duration: 0,
+          timerType: 'count-down',
+          colour: '',
+          delay: 0,
+          isPublic: true,
+          skip: false,
+          endAction: 'none',
+          revision: 0,
+          custom: {},
+        },
+      },
+    );
+
+    expect(messageService.patch).toHaveBeenCalledWith({
+      timer: {
+        secondarySource: 'secondary',
+      },
+      secondary: 'Next: Keynote',
+    });
+  });
+
+  it('can set secondary message text without changing the secondary source', () => {
+    toOntimeAction(
+      {
+        type: 'ontime',
+        action: 'message-secondary',
+        text: 'Next: {{eventNext.title}}',
+      },
+      {
+        ...runtimeStorePlaceholder,
+        eventNext: {
+          id: 'next-event',
+          type: 'event',
+          cue: '2',
+          title: 'Keynote',
+          note: '',
+          timeStart: 0,
+          timeEnd: 0,
+          duration: 0,
+          timerType: 'count-down',
+          colour: '',
+          delay: 0,
+          isPublic: true,
+          skip: false,
+          endAction: 'none',
+          revision: 0,
+          custom: {},
+        },
+      },
+    );
+
+    expect(messageService.patch).toHaveBeenCalledWith({
+      secondary: 'Next: Keynote',
+    });
+  });
+});
@@ -132,7 +132,7 @@ function send(output: AutomationOutput[], store: RuntimeStore) {
    } else if (isHTTPOutput(payload)) {
      emitHTTP(payload, store);
    } else if (isOntimeAction(payload)) {
-      toOntimeAction(payload);
+      toOntimeAction(payload, store);
    } else {
      logger.warning(LogOrigin.Tx, `Unknown output type: ${payload}`);
    }
@@ -225,13 +225,28 @@ function parseOntimeAction(maybeOntimeAction: object): OntimeAction {
  }

  if (maybeOntimeAction.action === 'message-secondary') {
-    assert.hasKeys(maybeOntimeAction, ['secondarySource']);
+    // the secondary text is optional, an empty string is treated as no change
+    let text: string | undefined = undefined;
+    if ('text' in maybeOntimeAction) {
+      assert.isString(maybeOntimeAction.text);
+      text = indeterminateText(maybeOntimeAction.text);
+    }
+
+    if (!('secondarySource' in maybeOntimeAction) || maybeOntimeAction.secondarySource === undefined) {
+      return {
+        type: 'ontime',
+        action: 'message-secondary',
+        text,
+      };
+    }
+
    // null is used to clear the secondary source
    if (maybeOntimeAction.secondarySource === null) {
      return {
        type: 'ontime',
        action: 'message-secondary',
        secondarySource: null,
+        text,
      };
    }

@@ -240,6 +255,7 @@ function parseOntimeAction(maybeOntimeAction: object): OntimeAction {
      type: 'ontime',
      action: 'message-secondary',
      secondarySource: chooseSecondarySource(maybeOntimeAction.secondarySource),
+      text,
    };
  }

@@ -1,12 +1,14 @@
-import { LogOrigin, OntimeAction } from 'ontime-types';
+import { LogOrigin, OntimeAction, RuntimeStore } from 'ontime-types';
 import { parseUserTime } from 'ontime-utils';
+import { DeepReadonly } from 'ts-essentials';

 import { logger } from '../../../classes/Logger.js';
 import { auxTimerService } from '../../../services/aux-timer-service/AuxTimerService.js';
 import * as messageService from '../../../services/message-service/message.service.js';
 import { runtimeService } from '../../../services/runtime-service/runtime.service.js';
+import { parseTemplateNested } from '../automation.utils.js';

-export function toOntimeAction(action: OntimeAction) {
+export function toOntimeAction(action: OntimeAction, store: DeepReadonly<RuntimeStore>) {
  const actionType = action.action;
  switch (actionType) {
    // Aux timer actions
@@ -55,18 +57,25 @@ export function toOntimeAction(action: OntimeAction) {
    case 'message-set': {
      messageService.patch({
        timer: {
-          text: action.text,
+          text: action.text ? parseTemplateNested(action.text, store) : action.text,
          visible: action.visible,
        },
      });
      break;
    }
    case 'message-secondary': {
-      messageService.patch({
-        timer: {
-          secondarySource: action.secondarySource,
-        },
-      });
+      const secondary = action.text ? parseTemplateNested(action.text, store) : action.text;
+      const patch =
+        action.secondarySource === undefined
+          ? { secondary }
+          : {
+              timer: {
+                secondarySource: action.secondarySource,
+              },
+              secondary,
+            };
+
+      messageService.patch(patch);
      break;
    }

@@ -432,6 +432,40 @@ describe('processRundown()', () => {
    expect(initResult.totalDuration).toBe(500 - 100);
  });

+  it('skipped events do not advance day offsets or affect gaps', () => {
+    const rundown = makeRundown({
+      order: ['1', 'skipped', '2'],
+      entries: {
+        '1': makeOntimeEvent({
+          id: '1',
+          timeStart: 22 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE, // 22:30:00
+          timeEnd: 30 * MILLIS_PER_MINUTE, // 00:30:00
+          duration: 2 * MILLIS_PER_HOUR, // 02:00:00
+        }),
+        skipped: makeOntimeEvent({
+          id: 'skipped',
+          skip: true,
+          timeStart: 22 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE, // 22:30:00
+          timeEnd: 30 * MILLIS_PER_MINUTE, // 00:30:00
+          duration: 2 * MILLIS_PER_HOUR, // 02:00:00
+        }),
+        '2': makeOntimeEvent({
+          id: '2',
+          timeStart: 30 * MILLIS_PER_MINUTE, // 00:30:00
+          timeEnd: 8 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE, // 08:30:00
+          duration: 8 * MILLIS_PER_HOUR, // 08:00:00
+        }),
+      },
+    });
+
+    const initResult = processRundown(rundown, {});
+
+    expect((initResult.entries.skipped as OntimeEvent).dayOffset).toBe(0);
+    expect((initResult.entries.skipped as OntimeEvent).gap).toBe(0);
+    expect((initResult.entries['2'] as OntimeEvent).dayOffset).toBe(1);
+    expect((initResult.entries['2'] as OntimeEvent).gap).toBe(0);
+  });
+
  it('calculates total duration across days with gap', () => {
    const rundown = makeRundown({
      order: ['1', '2', '3'],
@@ -680,17 +714,17 @@ describe('processRundown()', () => {
 });

 describe('rundownMutation.add()', () => {
-  test('adds an event an empty rundown', () => {
+  test('adds an event to an empty rundown', () => {
    const mockEvent = makeOntimeEvent({ id: 'mock', cue: 'mock' });
    const rundown = makeRundown({});

-    rundownMutation.add(rundown, mockEvent, null, null);
+    rundownMutation.add(rundown, mockEvent, null, null, null);

    expect(rundown.order.length).toBe(1);
    expect(rundown.entries['mock']).toMatchObject(mockEvent);
  });

-  test('adds an event at the top if no afterId is given', () => {
+  test('adds an event at the end if no afterId is given', () => {
    const mockEvent = makeOntimeEvent({ id: 'mock', cue: 'mock' });
    const rundown = makeRundown({
      flatOrder: ['1'],
@@ -700,28 +734,28 @@ describe('rundownMutation.add()', () => {
      },
    });

-    rundownMutation.add(rundown, mockEvent, null, null);
+    rundownMutation.add(rundown, mockEvent, null, null, null);

-    expect(rundown.order).toStrictEqual(['mock', '1']);
-    expect(rundown.flatOrder).toStrictEqual(['mock', '1']);
+    expect(rundown.order).toStrictEqual(['1', 'mock']);
+    expect(rundown.flatOrder).toStrictEqual(['1', 'mock']);
    expect(rundown.entries['mock']).toMatchObject(mockEvent);
  });

-  test('adds an event at the top of the group if no after is given', () => {
+  test('adds an event at the end of the group if parent is provided but no after', () => {
    const mockEvent = makeOntimeEvent({ id: 'mock', cue: 'mock' });
    const rundown = makeRundown({
      flatOrder: ['1', '1a'],
      order: ['1'],
      entries: {
-        '1': makeOntimeGroup({ id: '1' }),
+        '1': makeOntimeGroup({ id: '1', entries: ['1a'] }),
        '1a': makeOntimeEvent({ id: '1a', parent: '1' }),
      },
    });

-    rundownMutation.add(rundown, mockEvent, null, rundown.entries['1'] as OntimeGroup);
+    rundownMutation.add(rundown, mockEvent, rundown.entries['1'] as OntimeGroup, null, null);

    expect(rundown.order).toStrictEqual(['1']);
-    expect(rundown.flatOrder).toStrictEqual(['1', 'mock', '1a']);
+    expect(rundown.flatOrder).toStrictEqual(['1', '1a', 'mock']);
    expect(rundown.entries['mock']).toMatchObject(mockEvent);
  });

@@ -731,12 +765,12 @@ describe('rundownMutation.add()', () => {
      flatOrder: ['1', '1a'],
      order: ['1'],
      entries: {
-        '1': makeOntimeGroup({ id: '1' }),
+        '1': makeOntimeGroup({ id: '1', entries: ['1a'] }),
        '1a': makeOntimeEvent({ id: '1a', parent: '1' }),
      },
    });

-    rundownMutation.add(rundown, mockEvent, '1a', rundown.entries['1'] as OntimeGroup);
+    rundownMutation.add(rundown, mockEvent, rundown.entries['1'] as OntimeGroup, '1a', null);

    expect(rundown.order).toStrictEqual(['1']);
    expect(rundown.flatOrder).toStrictEqual(['1', '1a', 'mock']);
@@ -1805,6 +1839,49 @@ describe('rundownMutation.clone()', () => {
      parent: null,
    });
  });
+
+  it('clones an event and appends it with after true', () => {
+    const testRundown = makeRundown({
+      order: ['1', '2'],
+      entries: {
+        '1': makeOntimeEvent({ id: '1', cue: 'event1', parent: null }),
+        '2': makeOntimeEvent({ id: '2', cue: 'event2', parent: null }),
+      },
+    });
+
+    const newEntry = rundownMutation.clone(testRundown, testRundown.entries['1'], { after: true });
+
+    expect(testRundown.order).toStrictEqual(['1', '2', newEntry.id]);
+  });
+
+  it('clones an event and prepends it with before true', () => {
+    const testRundown = makeRundown({
+      order: ['1', '2'],
+      entries: {
+        '1': makeOntimeEvent({ id: '1', cue: 'event1', parent: null }),
+        '2': makeOntimeEvent({ id: '2', cue: 'event2', parent: null }),
+      },
+    });
+
+    const newEntry = rundownMutation.clone(testRundown, testRundown.entries['2'], { before: true });
+
+    expect(testRundown.order).toStrictEqual([newEntry.id, '1', '2']);
+  });
+
+  it('clones a group and appends it with after true', () => {
+    const testRundown = makeRundown({
+      order: ['1', '2'],
+      entries: {
+        '1': makeOntimeGroup({ id: '1', title: 'top', entries: ['1a'] }),
+        '1a': makeOntimeEvent({ id: '1a', cue: 'nested', parent: '1' }),
+        '2': makeOntimeEvent({ id: '2', cue: 'event2', parent: null }),
+      },
+    });
+
+    const newEntry = rundownMutation.clone(testRundown, testRundown.entries['1'], { after: true });
+
+    expect(testRundown.order).toStrictEqual(['1', '2', newEntry.id]);
+  });
 });

 describe('rundownMutation.group()', () => {
@@ -1,8 +1,18 @@
-import { EndAction, OntimeEvent, TimeStrategy, TimerType } from 'ontime-types';
+import {
+  EndAction,
+  OntimeEvent,
+  OntimeGroup,
+  OntimeMilestone,
+  TimeStrategy,
+  TimerLifeCycle,
+  TimerType,
+  Trigger,
+} from 'ontime-types';
 import { MILLIS_PER_HOUR, createEvent } from 'ontime-utils';
 import { assertType } from 'vitest';

-import { makeOntimeEvent, makeOntimeGroup, makeRundown } from '../__mocks__/rundown.mocks.js';
+import { makeOntimeEvent, makeOntimeGroup, makeOntimeMilestone, makeRundown } from '../__mocks__/rundown.mocks.js';
+import { parseRundown } from '../rundown.parser.js';
 import {
  calculateDayOffset,
  deleteById,
@@ -10,6 +20,8 @@ import {
  getIntegerAndFraction,
  hasChanges,
  makeDeepClone,
+  mergeRundownPreservingFields,
+  isLoadedPlayable,
 } from '../rundown.utils.js';

 describe('test event validator', () => {
@@ -287,3 +299,314 @@ describe('getIntegerAndFraction()', () => {
    expect(getIntegerAndFraction('123.')).toStrictEqual({ integer: 123, faction: 0, precision: 0 });
  });
 });
+
+/**
+ * The merge strategy takes the incoming (spreadsheet) rundown as the source of truth for structure
+ * and order. For a matched event it only applies the fields the spreadsheet mapped (providedFields);
+ * any field it does not provide (e.g. automations) is kept from the existing event.
+ */
+describe('mergeRundownPreservingFields()', () => {
+  const automation: Trigger = {
+    id: 'trigger-onair',
+    title: 'Go on air',
+    trigger: TimerLifeCycle.onStart,
+    automationId: 'automation-onair',
+  };
+
+  it('keeps the current rundown identity but takes structure and order from the incoming rundown', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      title: 'Main show',
+      revision: 3,
+      order: ['welcome', 'keynote'],
+      entries: {
+        welcome: makeOntimeEvent({ id: 'welcome', title: 'Welcome' }),
+        keynote: makeOntimeEvent({ id: 'keynote', title: 'Keynote' }),
+      },
+    });
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      title: 'From spreadsheet',
+      revision: 0,
+      order: ['welcome', 'lunch'],
+      entries: {
+        welcome: makeOntimeEvent({ id: 'welcome', title: 'Welcome' }),
+        lunch: makeOntimeEvent({ id: 'lunch', title: 'Lunch' }),
+      },
+    });
+
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: [] });
+
+    // identity and revision come from the current rundown
+    expect(merged.id).toBe('show-rundown');
+    expect(merged.title).toBe('Main show');
+    expect(merged.revision).toBe(4);
+    // structure and order come from the incoming rundown
+    expect(merged.order).toEqual(['welcome', 'lunch']);
+    expect(merged.flatOrder).toEqual(incoming.flatOrder);
+  });
+
+  it('deletes current entries that are absent from the incoming rundown', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['welcome', 'keynote'],
+      entries: {
+        welcome: makeOntimeEvent({ id: 'welcome' }),
+        keynote: makeOntimeEvent({ id: 'keynote' }),
+      },
+    });
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['welcome'],
+      entries: { welcome: makeOntimeEvent({ id: 'welcome' }) },
+    });
+
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: [] });
+
+    expect(merged.entries.welcome).toBeDefined();
+    expect(merged.entries.keynote).toBeUndefined();
+  });
+
+  it('replaces an entry entirely with the incoming data when the id is kept but the type changes', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', title: 'Keynote', triggers: [automation] }) },
+    });
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeGroup({ id: 'keynote', title: 'Keynote group' }) },
+    });
+
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: [] });
+
+    // the incoming group fully replaces the previous event, no old data is carried over
+    expect(merged.entries.keynote).toEqual(incoming.entries.keynote);
+  });
+
+  it('applies the provided fields to a matched event, including when the incoming value is empty', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', title: 'Keynote', note: 'in the green room' }) },
+    });
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', title: 'Opening keynote', note: '' }) },
+    });
+
+    // the sheet mapped title and note
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title', 'note'], custom: [] });
+    const keynote = merged.entries.keynote as OntimeEvent;
+
+    expect(keynote.title).toBe('Opening keynote');
+    // an empty provided value replaces the current one
+    expect(keynote.note).toBe('');
+  });
+
+  it('keeps fields the sheet did not map on a matched event, regardless of the incoming values', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['keynote'],
+      entries: {
+        keynote: makeOntimeEvent({ id: 'keynote', title: 'Keynote', note: 'green room', triggers: [automation] }),
+      },
+    });
+    // the preview always fully populates an entry, so the incoming carries a note and triggers; what
+    // the sheet actually supplied is providedFields, not the values that happen to be on the entry
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['keynote'],
+      entries: {
+        keynote: makeOntimeEvent({
+          id: 'keynote',
+          title: 'Opening keynote',
+          note: 'from a stale column',
+          triggers: [],
+        }),
+      },
+    });
+
+    // only title is mapped, so note and automations keep the existing values, not the incoming ones
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: [] });
+    const keynote = merged.entries.keynote as OntimeEvent;
+
+    expect(keynote.title).toBe('Opening keynote');
+    expect(keynote.note).toBe('green room');
+    expect(keynote.triggers).toEqual([automation]);
+  });
+
+  it('patches the provided custom fields on a matched event and keeps the unmapped ones', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['keynote'],
+      entries: {
+        keynote: makeOntimeEvent({
+          id: 'keynote',
+          title: 'Keynote',
+          custom: { lighting: 'warm', song: 'intro theme' },
+        }),
+      },
+    });
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['keynote'],
+      entries: {
+        keynote: makeOntimeEvent({ id: 'keynote', title: 'Opening keynote', custom: { lighting: 'cold' } }),
+      },
+    });
+
+    // the sheet mapped the title and the lighting custom field, but not song
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: ['lighting'] });
+    const keynote = merged.entries.keynote as OntimeEvent;
+
+    expect(keynote.title).toBe('Opening keynote');
+    expect(keynote.custom.lighting).toBe('cold');
+    // an unmapped custom field is kept from the existing event
+    expect(keynote.custom.song).toBe('intro theme');
+  });
+
+  it('infers the time strategy from the provided times when the sheet is unambiguous', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', timeStrategy: TimeStrategy.LockEnd }) },
+    });
+    // the sheet provides only a duration, so the strategy is unambiguously LockDuration
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', duration: 60000 }) },
+    });
+
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['duration'], custom: [] });
+
+    expect((merged.entries.keynote as OntimeEvent).timeStrategy).toBe(TimeStrategy.LockDuration);
+  });
+
+  it('keeps the existing time strategy when the provided times are ambiguous', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', timeStrategy: TimeStrategy.LockEnd }) },
+    });
+    // the sheet provides both an end and a duration, so the strategy cannot be inferred from them
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', timeEnd: 60000, duration: 60000 }) },
+    });
+
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['timeEnd', 'duration'], custom: [] });
+
+    expect((merged.entries.keynote as OntimeEvent).timeStrategy).toBe(TimeStrategy.LockEnd);
+  });
+
+  it('merges a matched group, keeping the fields the sheet cannot express', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['session'],
+      entries: { session: makeOntimeGroup({ id: 'session', title: 'Old session', targetDuration: 3_600_000 }) },
+    });
+    // the sheet cannot express a group's target duration, so the incoming group does not carry one
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['session'],
+      entries: { session: makeOntimeGroup({ id: 'session', title: 'New session', targetDuration: null }) },
+    });
+
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: [] });
+    const session = merged.entries.session as OntimeGroup;
+
+    expect(session.title).toBe('New session');
+    expect(session.targetDuration).toBe(3_600_000);
+  });
+
+  it('merges a matched milestone, keeping the fields the sheet did not map', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['reminder'],
+      entries: { reminder: makeOntimeMilestone({ id: 'reminder', title: 'Reminder', note: 'call talent' }) },
+    });
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['reminder'],
+      entries: { reminder: makeOntimeMilestone({ id: 'reminder', title: 'Green room reminder', note: 'ignored' }) },
+    });
+
+    // only title is mapped, so the milestone's note keeps the existing value
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: [] });
+    const reminder = merged.entries.reminder as OntimeMilestone;
+
+    expect(reminder.title).toBe('Green room reminder');
+    expect(reminder.note).toBe('call talent');
+  });
+
+  it('does not mutate the current rundown and deep-clones the kept automations', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', triggers: [automation] }) },
+    });
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', triggers: [] }) },
+    });
+
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: [] });
+
+    // kept automations are a copy, not a shared reference to the current rundown
+    (merged.entries.keynote as OntimeEvent).triggers.push({ ...automation, id: 'trigger-extra' });
+    expect((current.entries.keynote as OntimeEvent).triggers).toEqual([automation]);
+  });
+
+  it('keeps the not-provided fields through a parseRundown round-trip', () => {
+    const current = makeRundown({
+      id: 'show-rundown',
+      order: ['keynote'],
+      entries: {
+        keynote: makeOntimeEvent({ id: 'keynote', triggers: [automation], timeStrategy: TimeStrategy.LockEnd }),
+      },
+    });
+    const incoming = makeRundown({
+      id: 'spreadsheet-rundown',
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', title: 'Keynote', triggers: [] }) },
+    });
+
+    const merged = mergeRundownPreservingFields(incoming, current, { event: ['title'], custom: [] });
+    const parsed = parseRundown(merged, {});
+    const keynote = parsed.entries.keynote as OntimeEvent;
+
+    expect(keynote.triggers).toEqual([automation]);
+    expect(keynote.timeStrategy).toBe(TimeStrategy.LockEnd);
+  });
+});
+
+describe('isLoadedPlayable()', () => {
+  it('returns true when the loaded event still exists and is playable', () => {
+    const rundown = makeRundown({ order: ['keynote'], entries: { keynote: makeOntimeEvent({ id: 'keynote' }) } });
+    expect(isLoadedPlayable('keynote', rundown)).toBe(true);
+  });
+
+  it('returns false when the loaded event was removed', () => {
+    const rundown = makeRundown({ order: ['welcome'], entries: { welcome: makeOntimeEvent({ id: 'welcome' }) } });
+    expect(isLoadedPlayable('keynote', rundown)).toBe(false);
+  });
+
+  it('returns false when the loaded event is now skipped', () => {
+    const rundown = makeRundown({
+      order: ['keynote'],
+      entries: { keynote: makeOntimeEvent({ id: 'keynote', skip: true }) },
+    });
+    expect(isLoadedPlayable('keynote', rundown)).toBe(false);
+  });
+
+  it('returns false when the matched entry is no longer an event', () => {
+    const rundown = makeRundown({ order: ['keynote'], entries: { keynote: makeOntimeGroup({ id: 'keynote' }) } });
+    expect(isLoadedPlayable('keynote', rundown)).toBe(false);
+  });
+});
@@ -0,0 +1,40 @@
+import type { OntimeGroup } from 'ontime-types';
+import { describe, expect, test } from 'vitest';
+
+import { makeOntimeEvent, makeOntimeGroup, makeRundown } from '../__mocks__/rundown.mocks.js';
+import { assertInsertAnchorExists, assertInsertAnchorInOrder } from '../rundown.validation.js';
+
+const rundown = makeRundown({
+  order: ['top', 'group'],
+  entries: {
+    top: makeOntimeEvent({ id: 'top', parent: null }),
+    group: makeOntimeGroup({ id: 'group', entries: ['nested'] }),
+    nested: makeOntimeEvent({ id: 'nested', parent: 'group' }),
+  },
+});
+
+describe('insertion anchor validation', () => {
+  test('rejects a missing anchor', () => {
+    expect(() => assertInsertAnchorInOrder(rundown, null, { before: 'missing' })).toThrow(
+      'Insertion anchor with ID missing does not exist',
+    );
+  });
+
+  test('rejects an anchor from a different order', () => {
+    expect(() => assertInsertAnchorInOrder(rundown, null, { after: 'nested' })).toThrow(
+      'Insertion anchor with ID nested is not in the target order',
+    );
+  });
+
+  test('accepts a group-local anchor', () => {
+    const group = rundown.entries.group as OntimeGroup;
+
+    expect(() => assertInsertAnchorInOrder(rundown, group, { before: 'nested' })).not.toThrow();
+  });
+
+  test('checks clone anchors exist', () => {
+    expect(() => assertInsertAnchorExists(rundown, { after: 'missing' })).toThrow(
+      'Insertion anchor with ID missing does not exist',
+    );
+  });
+});
@@ -439,21 +439,27 @@ function clone(rundown: Rundown, entry: OntimeEntry, options?: InsertOptions): O
      rundown.entries[nestedEntry.id] = nestedEntry;
    }

-    // by default we insert after the cloned element
-    let atIndex = rundown.order.indexOf(entry.id) + 1;
-
-    const referenceId = options?.after ?? options?.before;
-    if (referenceId) {
-      // trying to insert relatively to another entry
-      const referenceEntry = rundown.entries[referenceId];
-      if (referenceEntry) {
-        if (options?.after) {
-          atIndex = rundown.order.indexOf(referenceId) + 1;
-        } else if (options?.before) {
-          atIndex = rundown.order.indexOf(referenceId);
-        }
+    const position: { after: EntryId | null; before: EntryId | null } = (() => {
+      if (options?.after === undefined && options?.before === undefined) {
+        return { after: entry.id, before: null };
      }
-    }
+
+      const after = getInsertAfterId(rundown, null, options.after, options.before);
+      const before = options.before === true ? (after ?? null) : (options.before ?? null);
+      return { after, before };
+    })();
+
+    const atIndex = (() => {
+      if (position.before !== null) {
+        return rundown.order.indexOf(position.before);
+      }
+
+      if (position.after !== null) {
+        return rundown.order.indexOf(position.after) + 1;
+      }
+
+      return rundown.order.length;
+    })();

    // we only need to insert the group, the nested entries will be resolved by the rundown engine
    rundown.order = insertAtIndex(atIndex, newGroup.id, rundown.order);
@@ -461,41 +467,33 @@ function clone(rundown: Rundown, entry: OntimeEntry, options?: InsertOptions): O
    return newGroup;
  } else {
    const clonedEntry = cloneSimpleRundownEntry(entry, getUniqueId(rundown));
+    const parent = (() => {
+      const referenceId = (() => {
+        if (typeof options?.after === 'string') return options.after;
+        if (typeof options?.before === 'string') return options.before;
+        return undefined;
+      })();

-    let parent: OntimeGroup | null = null;
+      const referenceEntry = referenceId ? rundown.entries[referenceId] : entry;
+      const parentId = referenceEntry && !isOntimeGroup(referenceEntry) ? referenceEntry.parent : null;
+      if (parentId === null) return null;

-    // trying to insert relatively to another entry, check that entries parent
-    const referenceId = options?.after ?? options?.before;
+      const maybeParent = rundown.entries[parentId];
+      return isOntimeGroup(maybeParent) ? maybeParent : null;
+    })();

-    /**
-     * if we have a positioning reference, and that reference has a parent
-     * we need to maintain the same parent for the cloned entry
-     */
-    if (referenceId) {
-      const referenceEntry = rundown.entries[referenceId];
-
-      if (referenceEntry && !isOntimeGroup(referenceEntry)) {
-        if (referenceEntry.parent) {
-          const maybeParent = rundown.entries[referenceEntry.parent];
-          if (maybeParent && isOntimeGroup(maybeParent)) {
-            parent = maybeParent;
-          }
-        }
+    const position = (() => {
+      // if no position is given, we add immediately after the element
+      if (options?.after === undefined && options?.before === undefined) {
+        return { after: entry.id, before: null };
      }
-    } else if (entry.parent) {
-      const maybeParent = rundown.entries[entry.parent];
-      if (maybeParent && isOntimeGroup(maybeParent)) {
-        parent = maybeParent;
-      }
-    }

-    // if we have resolved a parent, we add it to the cloned entry
-    let after = getInsertAfterId(rundown, parent, options?.after, options?.before);
-    if (!after) {
-      after = entry.id;
-    }
+      const after = getInsertAfterId(rundown, parent, options.after, options.before);
+      const before = options?.before === true ? after : (options.before ?? null);
+      return { after, before };
+    })();

-    return addToRundown(rundown, clonedEntry, after, parent);
+    return addToRundown(rundown, clonedEntry, parent, position.after, position.before);
  }
 }

@@ -279,14 +279,22 @@ function processEntry<T extends OntimeEntry>(
    // 2. handle custom fields - mutates entry
    sanitiseCustomFields(customFields, entry);

-    rundownMetadata.totalDays += calculateDayOffset(entry, rundownMetadata.previousEvent);
-    entry.dayOffset = rundownMetadata.totalDays as Day;
-    entry.delay = 0; // this means we dont calculate delays or gaps for skipped events
-    entry.gap = 0; // this means we dont calculate delays or gaps for skipped events
+    /*
+     * we initialise data so that is not calculated for skipped events
+     * consider especially the day offset, while skipped events have no
+     * day offset, we match it to the previous element to avoid
+     * pushing confusing data to the UI
+     */
+    entry.dayOffset = (rundownMetadata.previousEvent?.dayOffset ?? 0) as Day;
+    entry.delay = 0;
+    entry.gap = 0;
+
    entry.parent = childOfGroup;

    // update rundown metadata, it only concerns playable events
    if (isPlayableEvent(entry)) {
+      rundownMetadata.totalDays += calculateDayOffset(entry, rundownMetadata.previousEvent);
+      entry.dayOffset = rundownMetadata.totalDays as Day;
      rundownMetadata.playableEventOrder.push(entry.id);

      // first start is always the first event
@@ -1,7 +1,15 @@
 import type { Request, Response, Router } from 'express';
 import express from 'express';
 import { matchedData } from 'express-validator';
-import { ErrorResponse, OntimeEntry, ProjectRundownsList, RenumberCues, Rundown } from 'ontime-types';
+import {
+  ErrorResponse,
+  OntimeEntry,
+  ProjectRundowns,
+  ProjectRundownsList,
+  RenumberCues,
+  Rundown,
+  RundownImportPayload,
+} from 'ontime-types';
 import { getErrorMessage } from 'ontime-utils';

 import { getDataProvider } from '../../classes/data-provider/DataProvider.js';
@@ -12,7 +20,9 @@ import {
  applyDelay,
  batchEditEntries,
  cloneEntry,
+  applyImportToRundown,
  createNewRundown,
+  createRundownFromImport,
  deleteAllEntries,
  deleteEntries,
  deleteRundown,
@@ -36,6 +46,7 @@ import {
  entryReorderValidator,
  entrySwapValidator,
  rundownArrayOfIds,
+  rundownImportValidator,
  rundownPatchValidator,
  rundownPostValidator,
 } from './rundown.validation.js';
@@ -147,6 +158,39 @@ router.delete('/:id', paramsWithId, async (req: Request, res: Response<ProjectRu
  }
 });

+/**
+ * Applies an imported rundown: override or merge into an existing rundown, or create a new one.
+ */
+router.post(
+  '/import',
+  rundownImportValidator,
+  async (req: Request, res: Response<ProjectRundownsList | ErrorResponse>) => {
+    try {
+      const { mode, targetRundownId, rundown, customFields, providedFields } = matchedData<RundownImportPayload>(req);
+      let projectRundowns: ProjectRundowns;
+      if (mode === 'new') {
+        projectRundowns = await createRundownFromImport(rundown, customFields);
+      } else {
+        // the validator guarantees this for override/merge, the guard narrows the type and adds defence in depth
+        if (!targetRundownId) {
+          throw new Error('targetRundownId is required when mode is override or merge');
+        }
+        projectRundowns = await applyImportToRundown(
+          mode,
+          targetRundownId,
+          rundown,
+          customFields,
+          providedFields ?? { event: [], custom: [] },
+        );
+      }
+      res.status(200).json({ loaded: getCurrentRundown().id, rundowns: normalisedToRundownArray(projectRundowns) });
+    } catch (error) {
+      const message = getErrorMessage(error);
+      res.status(400).send({ message });
+    }
+  },
+);
+
 // #endregion operations on project rundowns ======================

 // #region operations on rundown entries ==========================
@@ -4,6 +4,7 @@ import {
  CustomFields,
  EntryId,
  EventPostPayload,
+  ImportedFields,
  InsertOptions,
  LogOrigin,
  OntimeEntry,
@@ -12,6 +13,7 @@ import {
  ProjectRundowns,
  RefetchKey,
  Rundown,
+  RundownImportMergeStrategy,
  isOntimeDelay,
  isOntimeEvent,
  isOntimeGroup,
@@ -25,6 +27,7 @@ import { makeNewRundown } from '../../models/dataModel.js';
 import { setLastLoadedRundown } from '../../services/app-state-service/AppStateService.js';
 import { runtimeService } from '../../services/runtime-service/runtime.service.js';
 import { updateRundownData } from '../../stores/runtimeState.js';
+import { parseCustomFields } from '../custom-fields/customFields.parser.js';
 import {
  createTransaction,
  customFieldMutation,
@@ -33,8 +36,19 @@ import {
  rundownMutation,
  updateBackgroundRundown,
 } from './rundown.dao.js';
+import { parseRundown } from './rundown.parser.js';
 import type { RundownMetadata } from './rundown.types.js';
-import { generateEvent, getIntegerAndFraction, hasChanges } from './rundown.utils.js';
+import {
+  generateEvent,
+  getFirstInsertId,
+  getIntegerAndFraction,
+  getLastInsertId,
+  getPreviousInsertId,
+  hasChanges,
+  mergeRundownPreservingFields,
+  isLoadedPlayable,
+} from './rundown.utils.js';
+import { assertInsertAnchorExists, assertInsertAnchorInOrder, assertSingleInsertAnchor } from './rundown.validation.js';

 /**
 * creates a new entry with given data
@@ -42,6 +56,8 @@ import { generateEvent, getIntegerAndFraction, hasChanges } from './rundown.util
 export async function addEntry(rundownId: string, eventData: EventPostPayload): Promise<OntimeEntry> {
  const { rundown, commit } = createTransaction({ rundownId, mutableRundown: true });

+  assertSingleInsertAnchor(eventData);
+
  // we allow the user to provide an ID, but make sure it is unique
  if (eventData?.id && Object.hasOwn(rundown.entries, eventData.id)) {
    throw new Error(`Event with ID ${eventData.id} already exists`);
@@ -58,14 +74,29 @@ export async function addEntry(rundownId: string, eventData: EventPostPayload):
    parent = maybeParent;
  }

+  assertInsertAnchorInOrder(rundown, parent, eventData);
+
  // normalise the position of the event in the rundown order
-  const afterId = getInsertAfterId(rundown, parent, eventData?.after, eventData?.before);
+  const insertPosition = (() => {
+    if (eventData.before !== undefined) {
+      const beforeId = getFirstInsertId(rundown, parent, eventData.before);
+      return { afterId: null, beforeId, cueAfterId: getPreviousInsertId(rundown, parent, beforeId) };
+    }
+
+    // if after is an ID, we will try and find the entry
+    if (eventData.after !== undefined && eventData.after !== true) {
+      const afterId = getInsertAfterId(rundown, parent, eventData.after);
+      return { afterId, beforeId: null, cueAfterId: afterId };
+    }
+
+    return { afterId: null, beforeId: null, cueAfterId: getLastInsertId(rundown, parent) };
+  })();

  // generate a fully formed entry from the patch
-  const newEntry = generateEvent(rundown, eventData, afterId, parent?.id);
+  const newEntry = generateEvent(rundown, eventData, insertPosition.cueAfterId, parent?.id);

  // make mutations to rundown
-  rundownMutation.add(rundown, newEntry, afterId, parent);
+  rundownMutation.add(rundown, newEntry, parent, insertPosition.afterId, insertPosition.beforeId);

  const { rundown: responseRundown, rundownMetadata, revision } = await commit();

@@ -385,7 +416,10 @@ export async function swapEvents(rundownId: string, fromId: EntryId, toId: Entry
 * @throws if the entry to clone does not exist
 */
 export async function cloneEntry(rundownId: string, entryId: EntryId, options: InsertOptions): Promise<Rundown> {
+  assertSingleInsertAnchor(options);
+
  const { rundown, commit } = createTransaction({ rundownId, mutableRundown: true });
+  assertInsertAnchorExists(rundown, options);
  const originalEntry = rundown.entries[entryId];

  if (!originalEntry) {
@@ -656,8 +690,8 @@ export async function loadRundown(id: string) {
 }

 /**
- * Sets a new rundown in the cache
- * and marks it as the currently loaded one
+ * Sets a new rundown in the cache and marks it as the currently loaded one.
+ * Switching to a rundown always stops playback.
 */
 export async function initRundown(
  rundown: Readonly<Rundown>,
@@ -679,6 +713,25 @@ export async function initRundown(
  });
 }

+/**
+ * Applies a rebuilt version of the currently loaded rundown in place.
+ * Unlike switching rundowns, this maintains playback when possible
+ */
+function applyChangeToCurrentRundown(rundown: Readonly<Rundown>, customFields: Readonly<CustomFields>) {
+  const loadedEvent = runtimeService.getLoadedEventId();
+  if (loadedEvent && !isLoadedPlayable(loadedEvent, rundown)) {
+    runtimeService.stop();
+  }
+  const { rundownMetadata, revision } = rundownCache.init(rundown, customFields);
+  updateRuntimeOnChange(rundownMetadata);
+
+  setImmediate(() => {
+    // notifying the timer hot-reloads the playing event and keeps playback
+    notifyChanges(rundown.id, rundownMetadata, revision, { timer: true, external: true, reload: true });
+    sendRefetch(RefetchKey.ProjectRundowns);
+  });
+}
+
 export async function createNewRundown(title: string) {
  const emptyRundown = makeNewRundown();
  emptyRundown.title = title;
@@ -743,6 +796,86 @@ export async function duplicateExistingRundown(id: string) {
  return dataProvider.getProjectRundowns();
 }

+/**
+ * Validates an imported rundown against the resulting custom fields, then commits those custom
+ * fields. The rundown is validated before the custom-field mutation, so a payload that fails
+ * validation cannot leave a partial custom-field write behind.
+ * @throws if the rundown or custom fields fail validation
+ */
+async function parseImportAndCommitCustomFields(
+  source: Readonly<Rundown>,
+  incomingCustomFields: CustomFields,
+): Promise<Rundown> {
+  const dataProvider = getDataProvider();
+  const parsedCustomFields = parseCustomFields({ customFields: incomingCustomFields });
+  const mergedCustomFields = { ...dataProvider.getCustomFields(), ...parsedCustomFields };
+  const parsed = parseRundown(source, mergedCustomFields);
+  await dataProvider.mergeIntoData({ customFields: parsedCustomFields });
+  return parsed;
+}
+
+/**
+ * Applies an imported rundown onto an existing rundown, keeping the existing identity while
+ * taking structure and order from the incoming data.
+ * - 'override' replaces all content with the incoming data
+ * - 'merge' updates matched entries with only the fields the spreadsheet provided, keeping the rest
+ *   (e.g. automations) from the existing entry
+ *
+ * When targeting the loaded rundown this is treated as a change, not a switch, so playback is
+ * maintained when the playing event survives.
+ * @throws if the target rundown does not exist
+ */
+export async function applyImportToRundown(
+  strategy: RundownImportMergeStrategy,
+  targetRundownId: string,
+  incomingRundown: Rundown,
+  incomingCustomFields: CustomFields,
+  providedFields: ImportedFields,
+): Promise<ProjectRundowns> {
+  const dataProvider = getDataProvider();
+  // throws if the rundown was deleted between preview and apply
+  const existing = dataProvider.getRundown(targetRundownId);
+
+  const source =
+    strategy === 'merge'
+      ? mergeRundownPreservingFields(incomingRundown, existing, providedFields)
+      : { ...incomingRundown, id: existing.id, title: existing.title, revision: existing.revision + 1 };
+  const parsed = await parseImportAndCommitCustomFields(source, incomingCustomFields);
+
+  if (isCurrentRundown(targetRundownId)) {
+    // applying to the loaded rundown is a change, not a switch: maintain playback when possible
+    applyChangeToCurrentRundown(parsed, dataProvider.getCustomFields());
+  } else {
+    await dataProvider.setRundown(parsed.id, parsed);
+    setImmediate(() => {
+      sendRefetch(RefetchKey.ProjectRundowns);
+    });
+  }
+
+  return dataProvider.getProjectRundowns();
+}
+
+/**
+ * Creates a new rundown from an imported rundown and loads it,
+ * so the user immediately sees the imported data.
+ * Loading a rundown stops playback (as with any rundown switch).
+ */
+export async function createRundownFromImport(
+  incomingRundown: Rundown,
+  incomingCustomFields: CustomFields,
+): Promise<ProjectRundowns> {
+  const dataProvider = getDataProvider();
+
+  // assign a fresh id so we never collide with an existing rundown
+  const parsed = await parseImportAndCommitCustomFields({ ...incomingRundown, id: generateId() }, incomingCustomFields);
+  parsed.revision = 0;
+
+  // initRundown persists the new rundown, makes it the loaded rundown and notifies clients
+  await initRundown(parsed, dataProvider.getCustomFields(), true);
+
+  return dataProvider.getProjectRundowns();
+}
+
 /**
 * Deletes a rundown
 * @throws if attempting to delete the loaded rundown or the last rundown in the project
@@ -2,6 +2,7 @@ import {
  CustomFields,
  EntryCustomFields,
  EntryId,
+  ImportedFields,
  OntimeBaseEvent,
  OntimeDelay,
  OntimeEntry,
@@ -11,12 +12,14 @@ import {
  ProjectRundown,
  ProjectRundowns,
  Rundown,
+  RundownEntries,
  SupportedEntry,
  TimeStrategy,
  isOntimeDelay,
  isOntimeEvent,
  isOntimeGroup,
  isOntimeMilestone,
+  isPlayableEvent,
 } from 'ontime-types';
 import {
  createDelay,
@@ -67,6 +70,50 @@ export function generateEvent(
  throw new Error('Invalid event type');
 }

+/**
+ * Gets the last valid insertion reference for a top-level rundown or group order.
+ * Used when appending entries and when generating cues from the preceding entry.
+ */
+export function getLastInsertId(rundown: Rundown, parent: OntimeGroup | null): EntryId | null {
+  const insertionList = parent ? parent.entries : rundown.order;
+  return insertionList[insertionList.length - 1] ?? null;
+}
+
+/**
+ * Resolves a `before` insertion option to the first entry in the relevant order when `true` is provided.
+ * String values are already explicit anchors and are returned unchanged.
+ */
+export function getFirstInsertId(rundown: Rundown, parent: OntimeGroup | null, before: EntryId | true): EntryId | null {
+  if (before !== true) {
+    return before;
+  }
+
+  const insertionList = parent ? parent.entries : rundown.order;
+  return insertionList[0] ?? null;
+}
+
+/**
+ * Gets the sibling before a `before` insertion anchor in the top-level or group order.
+ * Returns `null` when the new entry will be inserted at the start.
+ */
+export function getPreviousInsertId(
+  rundown: Rundown,
+  parent: OntimeGroup | null,
+  beforeId: EntryId | null,
+): EntryId | null {
+  if (beforeId === null) {
+    return null;
+  }
+
+  const insertionList = parent ? parent.entries : rundown.order;
+  const beforeIndex = insertionList.indexOf(beforeId);
+  if (beforeIndex < 1) {
+    return null;
+  }
+
+  return insertionList[beforeIndex - 1] ?? null;
+}
+
 export function createEventPatch(originalEvent: OntimeEvent, patchEvent: Partial<OntimeEvent>): OntimeEvent {
  if (Object.keys(patchEvent).length === 0) {
    return originalEvent;
@@ -225,6 +272,83 @@ export function getUniqueId(rundown: Rundown): EntryId {
  return id;
 }

+/**
+ * Builds an entry patch containing exactly the fields the spreadsheet supplied, for both built-in
+ * and custom fields. Everything the sheet did not map is left out, so applying the patch keeps the
+ * existing value for those fields.
+ */
+function buildImportPatch(entry: OntimeEntry, providedFields: ImportedFields): Partial<OntimeEntry> {
+  const source = entry as Record<string, unknown>;
+  const patch: Record<string, unknown> = {};
+  for (const field of providedFields.event) {
+    patch[field] = source[field];
+  }
+  if (providedFields.custom.length > 0) {
+    const entryCustom = (source.custom ?? {}) as EntryCustomFields;
+    const custom: EntryCustomFields = {};
+    for (const key of providedFields.custom) {
+      custom[key] = entryCustom[key] ?? '';
+    }
+    patch.custom = custom;
+  }
+  return patch as Partial<OntimeEntry>;
+}
+
+/**
+ * Merges an imported rundown into an existing one
+ * - the incoming rundown is the source of truth for entry identity and structure (order + grouping)
+ * - a matched entry of the same type is merged field-by-field: a field the sheet provided overwrites
+ *   (even when empty), a field the sheet cannot express (an event's automations, a group's target
+ *   duration, an unmapped custom field) is kept from the existing entry
+ * - a new id, or an id whose type changed, takes the incoming entry wholesale
+ * - existing entries absent from the incoming rundown are dropped
+ */
+export function mergeRundownPreservingFields(
+  incoming: Readonly<Rundown>,
+  existing: Readonly<Rundown>,
+  providedFields: ImportedFields,
+): Rundown {
+  const entries: RundownEntries = {};
+
+  for (const [id, incomingEntry] of Object.entries(incoming.entries)) {
+    const existingEntry = existing.entries[id];
+
+    // a new id, or one whose type changed, is not compatible for a merge: take the incoming data
+    if (existingEntry === undefined || existingEntry.type !== incomingEntry.type) {
+      entries[id] = incomingEntry;
+      continue;
+    }
+
+    // merge the sheet's data onto the existing entry through the canonical patch function, which
+    // keeps every unmapped field and infers an event's time strategy from the provided times
+    const merged = applyPatchToEntry(existingEntry, buildImportPatch(incomingEntry, providedFields));
+    // grouping comes from the sheet structure, not a data column: a group owns its children, every
+    // other entry knows its parent
+    const structure = isOntimeGroup(incomingEntry)
+      ? { entries: incomingEntry.entries }
+      : { parent: incomingEntry.parent };
+    entries[id] = structuredClone({ ...merged, ...structure });
+  }
+
+  return {
+    id: existing.id,
+    title: existing.title,
+    order: [...incoming.order],
+    flatOrder: [...incoming.flatOrder],
+    revision: existing.revision + 1,
+    entries,
+  };
+}
+
+/**
+ * Whether the currently playing event survives a change to its rundown,
+ * i.e. it still exists and is playable in the new version.
+ */
+export function isLoadedPlayable(loadedEventId: EntryId, rundown: Readonly<Rundown>): boolean {
+  const entry = rundown.entries[loadedEventId];
+  return entry !== undefined && isOntimeEvent(entry) && isPlayableEvent(entry);
+}
+
 /** List of event properties which do not need the rundown to be regenerated */
 enum RegenerateWhitelist {
  'id', // adding it for completeness, users cannot change ID
@@ -1,4 +1,5 @@
 import { body, param } from 'express-validator';
+import type { EntryId, InsertOptions, OntimeGroup, Rundown } from 'ontime-types';

 import { requestValidationFunction } from '../validation-utils/validationFunction.js';

@@ -11,20 +12,53 @@ export const rundownPatchValidator = [
  requestValidationFunction,
 ];

+export const rundownImportValidator = [
+  body('mode').isString().isIn(['override', 'merge', 'new']),
+  body('targetRundownId')
+    .if(body('mode').isIn(['override', 'merge']))
+    .isString()
+    .trim()
+    .notEmpty()
+    .withMessage('targetRundownId is required when mode is override or merge'),
+  body('rundown').isObject(),
+  body('rundown.entries').isObject(),
+  body('rundown.order').isArray(),
+  body('rundown.flatOrder').isArray(),
+  body('customFields').isObject(),
+  body('providedFields').optional().isObject(),
+  body('providedFields.event').optional().isArray(),
+  body('providedFields.event.*').isString(),
+  body('providedFields.custom').optional().isArray(),
+  body('providedFields.custom.*').isString(),
+  requestValidationFunction,
+];
+
 // #endregion operations on project rundowns ======================
 // #region operations on rundown entries ==========================

 export const entryPostValidator = [
  body('type').isString().isIn(['event', 'delay', 'group', 'milestone']),
-  body('after').optional().isString(),
-  body('before').optional().isString(),
+  body('after')
+    .optional()
+    .custom((value) => value === true || typeof value === 'string')
+    .withMessage('Allowed values for after are an ID or true.'),
+  body('before')
+    .optional()
+    .custom((value) => value === true || typeof value === 'string')
+    .withMessage('Allowed values for before are an ID or true.'),

  requestValidationFunction,
 ];

 export const clonePostValidator = [
-  body('after').optional().isString(),
-  body('before').optional().isString(),
+  body('after')
+    .optional()
+    .custom((value) => value === true || typeof value === 'string')
+    .withMessage('Allowed values for after are an ID or true.'),
+  body('before')
+    .optional()
+    .custom((value) => value === true || typeof value === 'string')
+    .withMessage('Allowed values for before are an ID or true.'),

  requestValidationFunction,
 ];
@@ -72,4 +106,44 @@ export const entryRenumberValidator = [
  requestValidationFunction,
 ];

+/**
+ * Ensures callers use a single insertion anchor so placement is unambiguous.
+ */
+export function assertSingleInsertAnchor(options: InsertOptions) {
+  if (options.after !== undefined && options.before !== undefined) {
+    throw new Error('Use only one insertion anchor: after or before');
+  }
+}
+
+/**
+ * Ensures an ID anchor exists and belongs to the order it is intended to position within.
+ */
+export function assertInsertAnchorInOrder(rundown: Rundown, parent: OntimeGroup | null, options: InsertOptions) {
+  const anchor = getStringInsertAnchor(options);
+  if (anchor === undefined) return;
+
+  if (!Object.hasOwn(rundown.entries, anchor)) {
+    throw new Error(`Insertion anchor with ID ${anchor} does not exist`);
+  }
+
+  const insertionList = parent ? parent.entries : rundown.order;
+  if (!insertionList.includes(anchor)) {
+    throw new Error(`Insertion anchor with ID ${anchor} is not in the target order`);
+  }
+}
+
+/** Ensures an ID anchor refers to an entry in the rundown. */
+export function assertInsertAnchorExists(rundown: Rundown, options: InsertOptions) {
+  const anchor = getStringInsertAnchor(options);
+  if (anchor !== undefined && !Object.hasOwn(rundown.entries, anchor)) {
+    throw new Error(`Insertion anchor with ID ${anchor} does not exist`);
+  }
+}
+
+function getStringInsertAnchor(options: InsertOptions): EntryId | undefined {
+  if (typeof options.after === 'string') return options.after;
+  if (typeof options.before === 'string') return options.before;
+  return undefined;
+}
+
 // #endregion operations on rundown entries =======================
@@ -153,6 +153,41 @@ describe('mcp.service', () => {
    expect(result.created.map((entry) => entry.id)).toEqual(['entry-1', 'entry-2', 'entry-3', 'entry-4']);
  });

+  it('omits insert anchors when creating an entry without a position', async () => {
+    await createEntryForMcp({
+      type: SupportedEntry.Milestone,
+      title: 'End marker',
+    });
+
+    expect(addEntryMock).toHaveBeenCalledWith(
+      'loaded-rundown',
+      expect.objectContaining({ type: SupportedEntry.Milestone, title: 'End marker' }),
+    );
+    expect(addEntryMock.mock.calls[0][1]).not.toHaveProperty('after');
+    expect(addEntryMock.mock.calls[0][1]).not.toHaveProperty('before');
+  });
+
+  it('uses before true for the first batch entry and chains the rest', async () => {
+    await batchCreateEntriesForMcp({
+      before: true,
+      entries: [
+        { type: SupportedEntry.Event, title: 'First' },
+        { type: SupportedEntry.Event, title: 'Second' },
+      ],
+    });
+
+    expect(addEntryMock).toHaveBeenNthCalledWith(
+      1,
+      'loaded-rundown',
+      expect.objectContaining({ type: SupportedEntry.Event, title: 'First', before: true }),
+    );
+    expect(addEntryMock).toHaveBeenNthCalledWith(
+      2,
+      'loaded-rundown',
+      expect.objectContaining({ type: SupportedEntry.Event, title: 'Second', after: 'entry-1' }),
+    );
+  });
+
  it('rejects nested groups before creating entries', async () => {
    await expect(
      batchCreateEntriesForMcp({
@@ -71,10 +71,10 @@ Read the ontime://schema resource if you need a data model reference.

 Steps:
 1. Call ontime_list_rundowns and identify the target rundown. If the user wants a background rundown, pass its \`rundownId\` in all entry read/write calls instead of loading it.
-2. Call ontime_get_rundown with the chosen \`rundownId\` to see current state and identify an \`after\` anchor if appending.
+2. Call ontime_get_rundown with the chosen \`rundownId\` to see current state and avoid duplicating existing entries.
 3. Call ontime_get_timer_state. If playback is not \`stop\` and the target is the loaded rundown, explain that MCP edits affect the live rundown and ask the user to confirm before changing it. If the target is a background rundown, it can be edited without interrupting playback.
 4. Build an array of entries in order and call ontime_batch_create_entries ONCE with all of them. This is much faster than calling ontime_create_entry per item.
-5. If the rundown already has events, pass \`after: <last event id>\` on the batch call so new events chain from the end.
+5. Omit \`after\` and \`before\` on the batch call to append the new entries to the end of the rundown. Use \`after: true\` for an explicit append request, or \`before: true\` for an explicit prepend request.

 Entry type guidance:
 - Use \`event\` for anything with a scheduled time and duration (talks, panels, breaks, meals).
@@ -63,6 +63,11 @@ export type BatchCreateEntryArgs = CreateEntryArgs & { children?: BatchCreateEnt
 export type UpdateEntryArgs = EntryFieldArgs & TargetRundownArgs & { id: EntryId };
 export type GroupEntriesArgs = GroupFieldArgs & TargetRundownArgs & { ids: EntryId[] };
 export type UngroupEntryArgs = TargetRundownArgs & { id: EntryId };
+type BatchCreateEntriesArgs = TargetRundownArgs & {
+  entries: BatchCreateEntryArgs[];
+  after?: EntryId | true;
+  before?: EntryId | true;
+};

 export function resolveTargetRundownId(args: TargetRundownArgs): string {
  return args.rundownId ?? getCurrentRundownId();
@@ -133,20 +138,24 @@ export function assertKnownCustomFields(...customValues: Array<EntryFieldArgs['c
 /** Translates tool arguments into the payload consumed by rundown.service addEntry */
 export function toEntryPayload(args: CreateEntryArgs): EventPostPayload {
  const { type = SupportedEntry.Event, after, before } = args;
+  const insertOptions = {
+    ...(after !== undefined ? { after } : {}),
+    ...(before !== undefined ? { before } : {}),
+  };

  switch (type) {
    case SupportedEntry.Delay:
-      return { type: SupportedEntry.Delay, duration: args.duration, after, before };
+      return { type: SupportedEntry.Delay, duration: args.duration, ...insertOptions };
    case SupportedEntry.Milestone: {
      const { cue, title, note, colour, custom } = args;
-      return { type: SupportedEntry.Milestone, cue, title, note, colour, custom, after, before };
+      return { type: SupportedEntry.Milestone, cue, title, note, colour, custom, ...insertOptions };
    }
    case SupportedEntry.Group:
      // group creation currently only accepts a title, see generateEvent in rundown.utils.ts
-      return { type: SupportedEntry.Group, title: args.title, after, before };
+      return { type: SupportedEntry.Group, title: args.title, ...insertOptions };
    case SupportedEntry.Event: {
-      const { type: _type, rundownId: _rundownId, ...eventFields } = args;
-      return { type: SupportedEntry.Event, ...eventFields };
+      const { type: _type, rundownId: _rundownId, after: _after, before: _before, ...eventFields } = args;
+      return { type: SupportedEntry.Event, ...eventFields, ...insertOptions };
    }
    default:
      throw new Error(`Invalid entry type: ${String(type)}`);
@@ -259,20 +268,25 @@ export async function ungroupEntryForMcp(args: UngroupEntryArgs) {
  return { target: getTargetMeta(rundownId), ungrouped: args.id, order: updatedRundown.order };
 }

-export async function batchCreateEntriesForMcp(
-  args: TargetRundownArgs & { entries: BatchCreateEntryArgs[]; after?: EntryId },
-) {
-  const { entries = [], after } = args;
+export async function batchCreateEntriesForMcp(args: BatchCreateEntriesArgs) {
+  const { entries = [], after, before } = args;
  validateBatchCreateEntries(entries);
  const allEntries = flattenBatchCreateEntries(entries);
  assertKnownCustomFields(...allEntries.map((entry) => entry.custom));
  const rundownId = resolveTargetRundownId(args);
-  let previousId = after;
+  let previousId: EntryId | undefined;
  const created: OntimeEntry[] = [];

  for (const entryArgs of entries) {
+    const firstInsertOptions =
+      created.length === 0
+        ? {
+            ...(after !== undefined ? { after } : {}),
+            ...(before !== undefined ? { before } : {}),
+          }
+        : undefined;
    // eslint-disable-next-line no-await-in-loop -- top-level entries chain after the previously created one
-    const entry = await createBatchEntry(rundownId, entryArgs, previousId);
+    const entry = await createBatchEntry(rundownId, entryArgs, previousId, undefined, firstInsertOptions);
    created.push(...entry.created);
    previousId = entry.entry.id;
  }
@@ -303,6 +317,7 @@ async function createBatchEntry(
  entryArgs: BatchCreateEntryArgs,
  previousId?: EntryId,
  parentId?: EntryId,
+  firstInsertOptions?: InsertOptions,
 ): Promise<{ entry: OntimeEntry; created: OntimeEntry[] }> {
  if (parentId && entryArgs.type === SupportedEntry.Group) {
    throw new Error('Cannot create a group inside another group.');
@@ -311,8 +326,9 @@ async function createBatchEntry(
  const { children: _children, ...createArgs } = entryArgs;
  const payload = toEntryPayload(createArgs);
  const insertOptions = {
-    ...(previousId ? { after: previousId } : {}),
-    ...(parentId ? { parent: parentId } : {}),
+    ...(previousId !== undefined ? { after: previousId } : {}),
+    ...(parentId !== undefined ? { parent: parentId } : {}),
+    ...(previousId === undefined ? firstInsertOptions : {}),
  };

  const createdEntry = await addEntry(rundownId, { ...payload, ...insertOptions } as EventPostPayload);
@@ -96,7 +96,7 @@ export const TOOL_DEFINITIONS = [
  {
    name: 'ontime_create_entry',
    description:
-      'Create a new entry. Omit rundownId for the currently loaded live rundown, or provide a rundownId from ontime_list_rundowns to edit a background rundown without loading it. If playback is running and rundownId is omitted or matches the loaded rundown, confirm the user intends to change the live rundown before calling. Omit after/before to append at the end. For type "event" provide title plus enough timing data for Ontime to infer a strategy: timeStart+duration calculates timeEnd, timeStart+timeEnd calculates duration and locks end, timeEnd+duration calculates timeStart, and all three prioritise duration. For "milestone" provide cue/title/note/colour and optional custom values using existing project custom field keys. For "delay" provide duration. For "group" provide title plus optional note/colour/custom/targetDuration.',
+      'Create a new entry. Omit after/before to append at the end, use after: true to explicitly append, use before: true to prepend, or use before/after with an entry ID to position the entry. Omit rundownId for the currently loaded live rundown, or provide a rundownId from ontime_list_rundowns to edit a background rundown without loading it. If playback is running and rundownId is omitted or matches the loaded rundown, confirm the user intends to change the live rundown before calling. For type "event" provide title plus enough timing data for Ontime to infer a strategy: timeStart+duration calculates timeEnd, timeStart+timeEnd calculates duration and locks end, timeEnd+duration calculates timeStart, and all three prioritise duration. For "milestone" provide cue/title/note/colour and optional custom values using existing project custom field keys. For "delay" provide duration. For "group" provide title plus optional note/colour/custom/targetDuration.',
    inputSchema: {
      type: 'object',
      properties: {
@@ -114,8 +114,14 @@ export const TOOL_DEFINITIONS = [
          description: 'Duration in ms (events: should equal timeEnd - timeStart; delays: the schedule shift)',
        },
        targetDuration: { type: 'number', description: 'Groups only: planned length of the group in ms' },
-        after: { type: 'string', description: 'Insert after this entry ID' },
-        before: { type: 'string', description: 'Insert before this entry ID' },
+        after: {
+          type: ['string', 'boolean'],
+          description: 'Insert after this entry ID, or true to append',
+        },
+        before: {
+          type: ['string', 'boolean'],
+          description: 'Insert before this entry ID, or true to prepend',
+        },
        ...EVENT_WRITABLE_FIELDS,
      },
    },
@@ -218,13 +224,20 @@ export const TOOL_DEFINITIONS = [
  {
    name: 'ontime_batch_create_entries',
    description:
-      'Create multiple entries, including groups with nested children. Omit rundownId for the currently loaded live rundown, or provide a rundownId from ontime_list_rundowns to edit a background rundown without loading it. If playback is running and rundownId is omitted or matches the loaded rundown, confirm the user intends to change the live rundown before calling. Use this for "build from agenda" flows to avoid many round trips. Entries are inserted in array order; if `after` is provided it positions the first top-level entry, subsequent top-level entries chain from the previous. A group entry may include `children`; those entries are created inside the group in array order. Groups cannot be nested. For events, provide title plus enough timing data for Ontime to infer a strategy: timeStart+duration calculates timeEnd, timeStart+timeEnd calculates duration and locks end, timeEnd+duration calculates timeStart, and all three prioritise duration.',
+      'Create multiple entries, including groups with nested children. Omit rundownId for the currently loaded live rundown, or provide a rundownId from ontime_list_rundowns to edit a background rundown without loading it. If playback is running and rundownId is omitted or matches the loaded rundown, confirm the user intends to change the live rundown before calling. Use this for "build from agenda" flows to avoid many round trips. Entries are inserted in array order; omit after/before to append the first entry at the end, use after: true to explicitly append, use before: true to prepend, or use after/before with an entry ID to position the first top-level entry. Subsequent top-level entries chain from the previous. A group entry may include `children`; those entries are created inside the group in array order. Groups cannot be nested. For events, provide title plus enough timing data for Ontime to infer a strategy: timeStart+duration calculates timeEnd, timeStart+timeEnd calculates duration and locks end, timeEnd+duration calculates timeStart, and all three prioritise duration.',
    inputSchema: {
      type: 'object',
      required: ['entries'],
      properties: {
        ...RUNDOWN_TARGET_FIELD,
-        after: { type: 'string', description: 'Insert the first entry after this entry ID' },
+        after: {
+          type: ['string', 'boolean'],
+          description: 'Insert the first entry after this entry ID, or true to append',
+        },
+        before: {
+          type: ['string', 'boolean'],
+          description: 'Insert the first entry before this entry ID, or true to prepend',
+        },
        entries: {
          type: 'array',
          description: 'Array of entries to create, in desired order',
@@ -588,7 +601,13 @@ const TOOL_HANDLERS: Record<ToolName, (args: Record<string, unknown>) => Promise

  ontime_batch_create_entries: async (args) => {
    return ok(
-      await batchCreateEntriesForMcp(args as TargetRundownArgs & { entries: BatchCreateEntryArgs[]; after?: EntryId }),
+      await batchCreateEntriesForMcp(
+        args as TargetRundownArgs & {
+          entries: BatchCreateEntryArgs[];
+          after?: EntryId | true;
+          before?: EntryId | true;
+        },
+      ),
    );
  },

@@ -117,8 +117,9 @@ app.use(`${prefix}/external`, (req, res) => {
 app.use(`${prefix}/user`, express.static(publicDir.userDir, { etag: false, lastModified: true }));

 // Serve legacy timer for old browsers that don't support modern JS
+// dotfiles must be allowed since the install path can contain dot directories (eg AppImage mounts in /tmp/.mount_*)
 app.get(`${prefix}/timer-legacy`, authenticateAndRedirect, (_req, res) => {
-  res.sendFile(srcFiles.timerLegacy);
+  res.sendFile(srcFiles.timerLegacy, { dotfiles: 'allow' });
 });

 // Base route for static files
@@ -1126,7 +1126,7 @@ describe('getRuntimeOffset()', () => {
    } as RuntimeState;

    const { absolute } = getRuntimeOffset(state);
-    expect(absolute).toBe(400000); // <--- offset is always the overtime
+    expect(absolute).toBe(400000 - 200000); // <--- offset is always the overtime + added time
  });

  it('handles time-to-end started after the end time', () => {
@@ -165,6 +165,13 @@ class RuntimeService {
    }
  }

+  /**
+   * Returns the id of the currently loaded event, or null if none is loaded
+   */
+  public getLoadedEventId(): EntryId | null {
+    return runtimeState.getState().eventNow?.id ?? null;
+  }
+
  /**
   * Called when the underlying data has changed,
   * we check if the change affects the runtime
@@ -180,13 +180,13 @@ export function getRuntimeOffset(state: RuntimeState): { absolute: number; relat
  const pausedTime = state._timer.pausedAt === null ? 0 : clock - state._timer.pausedAt;

  // absolute offset is difference between schedule and playback time
-  const absolute = eventStartOffset + overtime + pausedTime + addedTime;
+  // in case of count to end, the absolute offset is overtime and added time
+  const absolute = countToEnd ? overtime + addedTime : eventStartOffset + overtime + pausedTime + addedTime;

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

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

 /**
@@ -1036,4 +1036,167 @@ describe('loadGroupFlagAndEnd()', () => {
      eventNow: rundown.entries[0],
    });
  });
+
+  test('countToEnd entries decouple the link chain for subsequent events', () => {
+    // Event 0 (loaded): no countToEnd, linkStart=true
+    // Event 1: countToEnd=true           → breaks the link chain
+    // Event 2: linkStart=true           → unlinked (chain broken by event 1)
+    // Event 3: flag event               → also unlinked
+    const rundown = makeRundown({
+      entries: {
+        group: makeOntimeGroup({ id: 'group', entries: ['0', '1', '2'] }),
+        0: makeOntimeEvent({
+          id: '0',
+          parent: 'group',
+          timeStart: 0,
+          duration: 3600000,
+          countToEnd: false,
+          linkStart: true,
+          gap: 0,
+        } as any),
+        1: makeOntimeEvent({
+          id: '1',
+          parent: 'group',
+          timeStart: 3600000,
+          duration: 3600000,
+          countToEnd: true,
+          linkStart: true,
+          gap: 0,
+        } as any),
+        2: makeOntimeEvent({
+          id: '2',
+          parent: 'group',
+          timeStart: 7200000,
+          duration: 3600000,
+          linkStart: true,
+          gap: 0,
+        } as any),
+        3: makeOntimeEvent({
+          id: '3',
+          parent: null,
+          timeStart: 10800000,
+          duration: 3600000,
+          linkStart: true,
+          gap: 0,
+        } as any),
+      },
+      order: ['group', '0', '1', '2', '3'],
+    });
+
+    const state = {
+      groupNow: null,
+      eventNow: rundown.entries[0],
+      rundown: { actualGroupStart: null },
+    } as RuntimeState;
+
+    const metadata = { playableEventOrder: ['0', '1', '2', '3'], flags: ['3'] } as RundownMetadata;
+
+    loadGroupFlagAndEnd(rundown, metadata, 0, state);
+
+    // _group is the last event in the group (event 2)
+    // isLinkedToLoaded is false because event 1 (between loaded and group end) has countToEnd=true
+    // accumulatedGap includes event 1's duration carried forward to event 2
+    // (the countToEnd duration is applied to the next event, not the countToEnd event itself)
+    expect(state._group).toMatchObject({
+      event: rundown.entries[2],
+      isLinkedToLoaded: false,
+      accumulatedGap: 3600000,
+    });
+
+    // _flag (event 3): isLinkedToLoaded is false because chain was broken by event 1
+    // accumulatedGap is still 3600000 because event 2 is not countToEnd,
+    // so previousWasCountToEnd is null and no further duration is carried forward
+    expect(state._flag).toMatchObject({
+      event: rundown.entries[3],
+      isLinkedToLoaded: false,
+      accumulatedGap: 3600000,
+    });
+
+    // _end (event 3): also unlinked because the chain was broken at event 1
+    expect(state._end).toMatchObject({
+      event: rundown.entries[3],
+      isLinkedToLoaded: false,
+    });
+  });
+
+  test('countToEnd in the middle of the chain breaks links for downstream events', () => {
+    // Event 0 (loaded): no countToEnd, linkStart=true
+    // Event 1: linkStart=true           → linked to loaded
+    // Event 2: countToEnd=true          → breaks the chain (also last in group)
+    // Event 3: linkStart=true           → unlinked (chain broken by event 2)
+    const rundown = makeRundown({
+      entries: {
+        group: makeOntimeGroup({ id: 'group', entries: ['0', '1', '2'] }),
+        0: makeOntimeEvent({
+          id: '0',
+          parent: 'group',
+          timeStart: 0,
+          duration: 3600000,
+          countToEnd: false,
+          linkStart: true,
+          gap: 0,
+        } as any),
+        1: makeOntimeEvent({
+          id: '1',
+          parent: 'group',
+          timeStart: 3600000,
+          duration: 3600000,
+          linkStart: true,
+          gap: 0,
+        } as any),
+        2: makeOntimeEvent({
+          id: '2',
+          parent: 'group',
+          timeStart: 7200000,
+          duration: 3600000,
+          countToEnd: true,
+          linkStart: true,
+          gap: 0,
+        } as any),
+        3: makeOntimeEvent({
+          id: '3',
+          parent: null,
+          timeStart: 10800000,
+          duration: 3600000,
+          linkStart: true,
+          gap: 0,
+        } as any),
+      },
+      order: ['group', '0', '1', '2', '3'],
+    });
+
+    const state = {
+      groupNow: null,
+      eventNow: rundown.entries[0],
+      rundown: { actualGroupStart: null },
+    } as RuntimeState;
+
+    const metadata = { playableEventOrder: ['0', '1', '2', '3'], flags: ['3'] } as RundownMetadata;
+
+    loadGroupFlagAndEnd(rundown, metadata, 0, state);
+
+    // _group is the last event in the group (event 2)
+    // isLinkedToLoaded is true because no preceding event had countToEnd
+    // accumulatedGap is 0 because no preceding event was countToEnd
+    // (the countToEnd duration is carried forward to the next event, not added to the countToEnd event itself)
+    expect(state._group).toMatchObject({
+      event: rundown.entries[2],
+      isLinkedToLoaded: true,
+      accumulatedGap: 0,
+    });
+
+    // _flag (event 3): isLinkedToLoaded is false because chain was broken by count-to-end event 2
+    // accumulatedGap includes event 2's duration carried forward
+    expect(state._flag).toMatchObject({
+      event: rundown.entries[3],
+      isLinkedToLoaded: false,
+      accumulatedGap: 3600000,
+    });
+
+    // _end (event 3): unlinked because event 2 has countToEnd=true
+    expect(state._end).toMatchObject({
+      event: rundown.entries[3],
+      isLinkedToLoaded: false,
+    });
+  });
 });
@@ -23,6 +23,7 @@ import {
  calculateDuration,
  checkIsNow,
  dayInMs,
+  getExpectedEnd,
  getExpectedStart,
  getLastEventNormal,
  isPlaybackActive,
@@ -831,7 +832,6 @@ function getExpectedTimes(state = runtimeState) {
  state.offset.expectedRundownEnd = null;
  state.offset.expectedGroupEnd = null;
  state.offset.expectedFlagStart = null;
-  state.offset.expectedRundownEnd = null;

  const { offset } = state;
  const { plannedStart, actualStart } = state.rundown;
@@ -852,7 +852,7 @@ function getExpectedTimes(state = runtimeState) {
        plannedStart,
        actualStart,
      });
-      state.offset.expectedGroupEnd = lastEventExpectedStart + lastEvent.duration;
+      state.offset.expectedGroupEnd = getExpectedEnd(lastEvent, lastEventExpectedStart, state.rundown.currentDay!);
    }
  }

@@ -884,7 +884,7 @@ function getExpectedTimes(state = runtimeState) {
      plannedStart,
      actualStart,
    });
-    state.offset.expectedRundownEnd = expectedStart + event.duration;
+    state.offset.expectedRundownEnd = getExpectedEnd(event, expectedStart, state.rundown.currentDay!);
  }
 }

@@ -927,6 +927,7 @@ export function loadGroupFlagAndEnd(

  let accumulatedGap = 0;
  let isLinkedToLoaded = true;
+  let previousWasCountToEnd: Maybe<number> = null;

  for (let idx = currentIndex; idx < playableEventOrder.length; idx++) {
    const entry = entries[playableEventOrder[idx]];
@@ -934,8 +935,23 @@ export function loadGroupFlagAndEnd(
    if (isOntimeEvent(entry)) {
      if (idx !== currentIndex) {
        // we only accumulate data after the loaded event
-        accumulatedGap += entry.gap;
-        isLinkedToLoaded = isLinkedToLoaded && entry.linkStart;
+
+        if (previousWasCountToEnd !== null) {
+          /** previous event was countToEnd: add its duration as a positive gap (it "gives back" time downstream)
+           *   and break the link to the loaded event since countToEnd events reset the schedule
+           */
+          accumulatedGap += entry.gap + previousWasCountToEnd;
+          isLinkedToLoaded = false;
+        } else {
+          accumulatedGap += entry.gap;
+          isLinkedToLoaded = isLinkedToLoaded && entry.linkStart;
+        }
+
+        if (entry.countToEnd) {
+          previousWasCountToEnd = entry.duration;
+        } else {
+          previousWasCountToEnd = null;
+        }

        // and the loaded event is not allowed to be the next flag
        if (!foundFlag && metadata.flags.includes(entry.id)) {
@@ -0,0 +1,87 @@
+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');
+});
@@ -1,6 +1,6 @@
 {
  "name": "ontime",
-  "version": "4.10.0",
+  "version": "4.11.0",
  "description": "Time keeping for live events",
  "keywords": [
    "ontime",
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Claude	69aeb4aabb	feat(rundown): clear a mixed field explicitly, cover both fixes with tests Emptying a field which holds different values across the selection does not submit, otherwise focusing it and tabbing away would wipe every entry. That left no way to clear such a field, so text fields now offer an explicit Clear action, shown only while the entries disagree. Once they agree the field can be emptied by hand and the action is withdrawn. Both of the fixes which multi edit depends on were unguarded, so the logic moves into pure helpers alongside the existing hook helper convention: - shouldSubmitValue covers an unknown initial value being submitted as an empty string - applyPatchToEvents covers the optimistic batch update, whose signature now makes the original mistake of spreading the request body unrepresentable, and pins the custom field merge Both tests were confirmed to fail against the original behaviour. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PDETGBrhwgAqgTHjmrmJGJ	2026-07-25 12:49:47 +00:00
Claude	34ca715fb7	feat(rundown): batch edit event duration, model conflicts with a symbol Two follow ups on multi event editing. Duration is now editable across a selection. The batch endpoint already applies every mutation to a cloned rundown and calls processRundown once on commit, so a batched duration cascades correctly through linked events with a single recalculation, and the server infers the duration lock for entries which were locked to their end. Start and end times remain excluded: they are absolute points in time, so giving several events the same value collapses every linked event to a zero duration. Only the duration is offered in a multi selection. The optimistic update is skipped when the patch carries a duration, since the resulting schedule cannot be resolved on the client. Conflicting values are now marked with a dedicated symbol rather than undefined, which was doing double duty for "the entries disagree" and "the field is absent". The distinction was already leaking into the custom field merge, which needed a key lookup to tell the two apart. The symbol also makes it a type error to assign a merged value into an entry patch, where it would previously have been dropped silently on serialisation. Components keep taking plain optional values: the conflict is resolved once at the editor boundary, so no indeterminate handling spreads into the tree. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PDETGBrhwgAqgTHjmrmJGJ	2026-07-25 12:39:17 +00:00
Claude	b981bae63f	feat(rundown): edit multiple events at once in the entry editor Selecting several events in the editor now turns the entry editor into a multi editor: fields shared by every selected event show their value, fields which differ show as mixed, and editing a field applies it to the whole selection through the existing batch endpoint. Rather than branching between a single and a multi editor, the editor now always renders a merged view of N events (N >= 1) where a field is undefined when the events disagree. For a single event nothing is ever undefined, so single event editing is unchanged by construction and the composites carry no multi edit branching. - add mergeEvents() to build the merged view over a selection - EventEditor takes an events array and resolves the write path itself, replacing the eventId threaded into the composites with a submit callback - extract EventEditorSchedule, which is only rendered for a single event since schedule values cascade through the rundown - support indeterminate values in Switch, Select, SwatchSelect and TimeInput - cue, event id, schedule and automations are not available in multi edit Two related fixes which multi edit depends on: - useReactiveTextInput submitted an empty string when the initial value was undefined, so leaving a mixed field without editing it would have wiped the value on every selected event - the batch optimistic update spread the request body onto the entry instead of the patch, and replaced custom fields rather than merging them Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PDETGBrhwgAqgTHjmrmJGJ	2026-07-25 12:29:30 +00:00
Alex Christoffer Rasmussen	2a890cf2b3	fix: issue where a countToEnd would lead to incorrect expected times (#2149 ) * fix: issue where a count-to-end would lead to incorrect expected times * fix: include add time in overtime when countToEnd * fix: ui and server use same calculation for expected end	2026-07-25 11:22:24 +02:00
Carlos Valente	a8c611911d	refactor(rundown): new entries are appended to rundown	2026-07-22 07:17:39 +02:00
Carlos Valente	8363f06a5c	chore(rundown): improve documentation of insert logic	2026-07-22 07:17:39 +02:00
will@t1d.dev	5f040092cb	fix: timer-legacy view not served in desktop distributions The server serves html/timer-legacy.html and html/login.html from disk at runtime, relative to the bundled server. The Docker image copies these files but the electron packaging did not, so the view 404ed in all desktop distributions. Additionally, AppImages mount at /tmp/.mount_*, a hidden directory. Express sendFile refuses paths containing dot-segments by default (returns 404 without touching disk), so the view failed on Linux even with the file packaged. Allow dotfiles for this route; the request path is fixed so no user input is affected.	2026-07-19 10:02:45 +02:00
Carlos Valente	347c748dd9	feat(rundown): add shortcut to jump to current element	2026-07-18 17:03:02 +02:00
Carlos Valente	f234a1f892	fix(rundown): prevent skipped events from influencing day calculations	2026-07-18 16:52:36 +02:00
Carlos Valente	0c5e87b7e7	fix(ui): prevent warning indicator from overflowing container	2026-07-18 16:52:36 +02:00
Carlos Valente	64082ceac0	refactor(rundown): improve visibility of count to end	2026-07-18 16:45:55 +02:00
Carlos Valente	f598e8dab1	refactor(time control): improve handling of overtime and count to end	2026-07-18 16:45:55 +02:00
Carlos Valente	0c84a3ff9e	fix: delays account for midnight	2026-07-18 16:45:55 +02:00
Carlos Valente	c8760b5e9c	bump version to 4.11.0	2026-07-18 15:24:25 +02:00
Claude	34360a5b8f	feat(import): add merge strategy and new-rundown destination to spreadsheet import Co-authored-by: Carlos Valente <34649812+cpvalente@users.noreply.github.com>	2026-07-17 22:26:19 +02:00
Claude	5e6debcce0	fix(views): center timer digits with flexbox for embedded browser compatibility The Stage Timer and PiP Timer views relied on `align-content: center` to vertically center the timer digits inside `.timer-container`, which is a plain block element. Aligning children of a block container via `align-content` only works in Chromium 123+ (Firefox 125+, Safari 17.4+). Embedded browsers such as vMix Browser Input (CEF V115) and other older CEF/Chromium-based production tools ignore the property, so the digits fall back to the top of the container while every other element renders correctly. Make `.timer-container` a real flex column and center with `justify-content: center`, which is universally supported and matches the centering approach used elsewhere in the codebase. The removed `justify-self`/`align-self` were no-ops on a full-width flex item. Fixes #2126 Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_014T6ENZ3r6JXZb1fpYw2oNY	2026-07-17 20:59:49 +02:00
Carlos Valente	c191786e50	refactor(navigation): clear params from editor drawer	2026-07-17 15:50:42 +02:00
Carlos Valente	6911e37c18	refactor(automation): improve automation UX	2026-07-17 10:53:45 +02:00
Claude	86b2132cdc	feat(automation): expose group title and allow setting secondary text Surface {{groupNow.*}} template variables (title, note, colour, times, custom fields) in the automation template autocomplete so events inside a group can reference their group. The runtime store already carries groupNow, so substitution and filters worked already; this makes it discoverable. Extend the message-secondary action with an optional text field so an automation can set the secondary message content, not just its source. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LZYPZVdZLWowU7DyzGkWyy	2026-07-17 10:53:45 +02:00
Carlos Valente	25f0dba83a	chore: add codegraph to gitignore	2026-07-16 10:46:10 +02:00