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-20 14:39:06 +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
54 changed files with 1798 additions and 423 deletions
@@ -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));
@@ -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>
  );
@@ -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;
@@ -5,6 +5,7 @@ import {
  MILLIS_PER_SECOND,
  dayInMs,
  formatFromMillis,
+  getExpectedEnd,
  getExpectedStart,
 } from 'ontime-utils';

@@ -186,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,
  };
 }
@@ -339,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>
  );
@@ -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,103 +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, normaliseWallClock } 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 delayedStart = normaliseWallClock(timeStart + delay);
-  const delayedEnd = normaliseWallClock(timeEnd + delay);
-  const delayLabel = hasDelay
-    ? `Event is ${millisToDelayString(delay, 'expanded')}. New schedule ${formatTime(delayedStart)} → ${formatTime(delayedEnd)}`
-    : '';
-
  return (
    <>
-      <div className={style.column}>
-        <Editor.Title>Event schedule</Editor.Title>
-        <div>
-          <div className={style.inline}>
-            <TimeInputFlow
-              eventId={eventId}
-              timeStart={timeStart}
-              timeEnd={timeEnd}
-              duration={duration}
-              timeStrategy={timeStrategy}
-              linkStart={linkStart}
-              delay={delay}
-              showLabels
-            />
-          </div>
-          <div className={style.delayLabel}>{delayLabel}</div>
-        </div>
-      </div>
-
      <div className={style.column}>
        <Editor.Title>Event Behaviour</Editor.Title>
        <div className={style.splitTwo}>
          <div>
            <Editor.Label htmlFor='endAction'>End Action</Editor.Label>
            <Select
-              value={endAction}
+              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' },
@@ -118,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>
@@ -141,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' },
@@ -161,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>
@@ -171,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],
@@ -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 };
 }
@@ -714,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'],
@@ -734,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);
  });

@@ -765,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']);
@@ -1839,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()', () => {
@@ -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);
  }
 }

@@ -40,11 +40,15 @@ import { parseRundown } from './rundown.parser.js';
 import type { RundownMetadata } from './rundown.types.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
@@ -52,6 +56,8 @@ import {
 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`);
@@ -68,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();

@@ -395,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) {
@@ -70,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;
@@ -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';

@@ -37,15 +38,27 @@ export const rundownImportValidator = [

 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,
 ];
@@ -93,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;
+        },
+      ),
    );
  },

@@ -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', () => {
@@ -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');
+});
@@ -4,8 +4,8 @@ import type { MaybeNumber } from '../../utils/utils.type.js';
 export type PatchWithId<T extends OntimeEntry = OntimeEntry> = Partial<T> & { id: EntryId };

 export type InsertOptions = {
-  after?: EntryId;
-  before?: EntryId;
+  after?: EntryId | true;
+  before?: EntryId | true;
 };

 export type EventPostPayload = Partial<OntimeEntry> & InsertOptions;
@@ -80,7 +80,7 @@ export { validateEndAction, validateTimerType } from './src/validate-events/vali

 // feature business logic

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

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

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

 describe('getExpectedStart()', () => {
  describe('Absolute offset mode', () => {
@@ -315,3 +315,144 @@ describe('getExpectedStart()', () => {
    expect(getExpectedStart(testEvent, { ...testState, currentDay: 0 })).toBe(23 * MILLIS_PER_HOUR + 5);
  });
 });
+
+describe('getExpectedEnd()', () => {
+  const baseState = {
+    currentDay: 0,
+    totalGap: 0,
+    mode: OffsetMode.Absolute,
+    actualStart: null,
+    plannedStart: null,
+    isLinkedToLoaded: true,
+  };
+
+  test('a regular event ends at its expected start plus duration', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 0,
+      dayOffset: 0 as Day,
+      countToEnd: false,
+    };
+
+    // on schedule
+    const expectedStart0 = getExpectedStart(testEvent, { ...baseState, offset: 0 });
+    expect(getExpectedEnd(testEvent, expectedStart0, baseState.currentDay)).toBe(150);
+
+    // running 20 behind pushes the end out
+    const expectedStart20 = getExpectedStart(testEvent, { ...baseState, offset: 20 });
+    expect(getExpectedEnd(testEvent, expectedStart20, baseState.currentDay)).toBe(170);
+  });
+
+  test('a countToEnd event pins to the planned end while in overtime', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 0,
+      dayOffset: 0 as Day,
+      countToEnd: true,
+    };
+
+    // overtime would otherwise push the end to 170, but countToEnd absorbs it and pins to 150
+    const expectedStart = getExpectedStart(testEvent, { ...baseState, offset: 20 });
+    expect(getExpectedEnd(testEvent, expectedStart, baseState.currentDay)).toBe(150);
+  });
+
+  test('an overnight countToEnd event returns a normalised end', () => {
+    // event starts at 23:00 and counts to 01:00 the next day -> duration spans midnight
+    const timeStart = 23 * MILLIS_PER_HOUR;
+    const duration = 2 * MILLIS_PER_HOUR;
+    const testEvent = {
+      timeStart,
+      duration,
+      delay: 0,
+      dayOffset: 0 as Day,
+      countToEnd: true,
+    };
+
+    const expectedStart = getExpectedStart(testEvent, { ...baseState, offset: 0 });
+    expect(getExpectedEnd(testEvent, expectedStart, baseState.currentDay)).toBe(timeStart + duration);
+  });
+
+  test('a countToEnd event ignores upstream delays and stays pinned to its fixed end', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 20,
+      dayOffset: 0 as Day,
+    };
+
+    // events shift their schedule based on delay...
+    const expectedStart = getExpectedStart({ ...testEvent }, { ...baseState, offset: 0 });
+    expect(getExpectedEnd({ ...testEvent, countToEnd: false }, expectedStart, baseState.currentDay)).toBe(170);
+
+    // ... but count to end events stay pinned to the scheduled end
+    const expectedStartCountToEnd = getExpectedStart({ ...testEvent }, { ...baseState, offset: 0 });
+    expect(getExpectedEnd({ ...testEvent, countToEnd: true }, expectedStartCountToEnd, baseState.currentDay)).toBe(150);
+  });
+
+  test('a countToEnd event drifts when a delay pushes its start past the fixed end', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 60,
+      dayOffset: 0 as Day,
+      countToEnd: true,
+    };
+
+    // the delayed start (160) is past the fixed end (150), so the event can no longer
+    // finish on time and the end follows the compromised start
+    const expectedStart = getExpectedStart(testEvent, { ...baseState, offset: 0 });
+    expect(getExpectedEnd(testEvent, expectedStart, baseState.currentDay)).toBe(160);
+  });
+
+  test('a countToEnd event on a later day keeps the day offset on the end', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 0,
+      dayOffset: 1 as Day,
+      countToEnd: true,
+    };
+
+    // the scheduled end must include the day offset (timeStart + dayInMs + duration),
+    // not collapse to the day-shifted start
+    const expectedStart = getExpectedStart(testEvent, { ...baseState, currentDay: 0, offset: 0 });
+    expect(getExpectedEnd(testEvent, expectedStart, baseState.currentDay)).toBe(150 + dayInMs);
+
+    // when the running event is already on the same day, no extra day is added
+    const expectedStartSameDay = getExpectedStart(
+      { ...testEvent, dayOffset: 0 as Day },
+      { ...baseState, currentDay: 0, offset: 0 },
+    );
+    expect(getExpectedEnd({ ...testEvent, dayOffset: 0 as Day }, expectedStartSameDay, baseState.currentDay)).toBe(150);
+  });
+
+  test('a countToEnd event is anchored to its wall-clock end in relative mode', () => {
+    const testEvent = {
+      timeStart: 100,
+      duration: 50,
+      delay: 0,
+      dayOffset: 0 as Day,
+      countToEnd: true,
+    };
+
+    const relativeState = {
+      ...baseState,
+      mode: OffsetMode.Relative,
+      actualStart: 30,
+      plannedStart: 0,
+      offset: 0,
+    };
+
+    // a regular event in the same state is shifted by the relative-start offset to 180
+    const expectedStartRegular = getExpectedStart({ ...testEvent }, relativeState);
+    expect(getExpectedEnd({ ...testEvent, countToEnd: false }, expectedStartRegular, relativeState.currentDay)).toBe(
+      180,
+    );
+
+    // the countToEnd event stays pinned to its wall-clock end (150), not shifted
+    const expectedStartCountToEnd = getExpectedStart(testEvent, relativeState);
+    expect(getExpectedEnd(testEvent, expectedStartCountToEnd, relativeState.currentDay)).toBe(150);
+  });
+});
@@ -3,15 +3,6 @@ import { OffsetMode } from 'ontime-types';

 import { dayInMs } from './conversionUtils.js';

-/**
- * @param event the event that we are counting to
- * @param currentDay the day offset of the currently running event
- * @param totalGap accumulated gap from the current event
- * @param isLinkedToLoaded is this event part of a chain linking back to the current loaded event
- * @param clock
- * @param offset
- * @returns
- */
 export function getExpectedStart(
  event: Pick<OntimeEvent, 'timeStart' | 'dayOffset' | 'delay'>,
  state: {
@@ -60,3 +51,25 @@ export function getExpectedStart(
  const offsetStartTimeBufferedByGaps = offsetStartTime - totalGap;
  return offsetStartTimeBufferedByGaps;
 }
+
+export function getExpectedEnd(
+  event: Pick<OntimeEvent, 'timeStart' | 'dayOffset' | 'duration' | 'countToEnd'>,
+  expectedStart: number,
+  currentRuntimeDay: number,
+): number {
+  /**
+   * Count to end events are a special case
+   * - the end time is always the wall clock
+   */
+  if (event.countToEnd) {
+    // account for day offset
+    const relativeDayOffset = event.dayOffset - currentRuntimeDay;
+    const plannedEnd = event.timeStart + event.duration + relativeDayOffset * dayInMs;
+
+    // count to end should finish on the planned time or on start
+    return Math.max(expectedStart, plannedEnd);
+  }
+
+  // for normal events, the expected end is when we would start + its duration
+  return expectedStart + event.duration;
+}
@@ -248,28 +248,30 @@ describe('getInsertAfterId()', () => {
    revision: 1,
  } as Rundown;

-  it('returns afterId if provided', () => {
+  it('returns the provided after id', () => {
    expect(getInsertAfterId(rundown, null, 'b')).toBe('b');
  });

-  it('returns null if neither afterId nor beforeId is provided', () => {
+  it('returns null if no anchors are provided', () => {
    expect(getInsertAfterId(rundown, null)).toBeNull();
  });

-  it('returns null if beforeId is not found', () => {
-    expect(getInsertAfterId(rundown, null, undefined, 'z')).toBeNull();
-    expect(getInsertAfterId(rundown, null, undefined, '1')).toBeNull();
+  it('returns null if after is true', () => {
+    expect(getInsertAfterId(rundown, null, true)).toBeNull();
  });

-  it('returns the previous id of an entry in the rundown', () => {
-    expect(getInsertAfterId(rundown, null, undefined, '2')).toBe('1');
-    expect(getInsertAfterId(rundown, null, undefined, '4')).toBe('group');
-    expect(getInsertAfterId(rundown, null, undefined, 'group')).toBe('2');
+  it('returns the before id if provided', () => {
+    expect(getInsertAfterId(rundown, null, undefined, '2')).toBe('2');
+    expect(getInsertAfterId(rundown, null, undefined, '4')).toBe('4');
+    expect(getInsertAfterId(rundown, null, undefined, 'group')).toBe('group');
  });

-  it('returns the previous id of an event in a group', () => {
-    expect(getInsertAfterId(rundown, rundown.entries.group as OntimeGroup, undefined, '31')).toBeNull();
-    expect(getInsertAfterId(rundown, rundown.entries.group as OntimeGroup, undefined, '32')).toBe('31');
+  it('returns the first top-level id if before is true', () => {
+    expect(getInsertAfterId(rundown, null, undefined, true)).toBe('1');
+  });
+
+  it('returns the first group entry if before is true inside a group', () => {
+    expect(getInsertAfterId(rundown, rundown.entries.group as OntimeGroup, undefined, true)).toBe('31');
  });
 });

@@ -331,22 +333,22 @@ describe('addToRundown()', () => {
    const rundown = { id: 'test', title: '', entries: {}, order: [], flatOrder: [], revision: 0 } as Rundown;
    const newEntry = { id: 'new', type: SupportedEntry.Event } as OntimeEvent;

-    addToRundown(rundown, newEntry, null, null);
+    addToRundown(rundown, newEntry, null, null, null);

    expect(rundown.order).toEqual(['new']);
    expect(rundown.flatOrder).toEqual(['new']);
    expect(rundown.entries['new']).toBe(newEntry);
  });

-  // case 2b: insert at the beginning of the rundown
-  it('adds at the beginning of order and flatOrder when afterId is null', () => {
+  // case 2c: insert at the end of the rundown
+  it('adds at the end of order and flatOrder when afterId is null', () => {
    const rundown = makeTestRundown();
    const newEntry = { id: 'new', type: SupportedEntry.Event } as OntimeEvent;

-    addToRundown(rundown, newEntry, null, null);
+    addToRundown(rundown, newEntry, null, null, null);

-    expect(rundown.order).toEqual(['new', '1', '2', 'group']);
-    expect(rundown.flatOrder).toEqual(['new', '1', '2', 'group', '31', '32']);
+    expect(rundown.order).toEqual(['1', '2', 'group', 'new']);
+    expect(rundown.flatOrder).toEqual(['1', '2', 'group', '31', '32', 'new']);
  });

  // case 2a: insert after a given entry at top level
@@ -354,19 +356,55 @@ describe('addToRundown()', () => {
    const rundown = makeTestRundown();
    const newEntry = { id: 'new', type: SupportedEntry.Event } as OntimeEvent;

-    addToRundown(rundown, newEntry, '1', null);
+    addToRundown(rundown, newEntry, null, '1', null);

    expect(rundown.order).toEqual(['1', 'new', '2', 'group']);
    expect(rundown.flatOrder).toEqual(['1', 'new', '2', 'group', '31', '32']);
  });

-  // case 1b: insert at the beginning of a group
-  it('inserts right after the group header in flatOrder and sets parent', () => {
+  it('prepends to the rundown when before is true', () => {
+    const rundown = makeTestRundown();
+    const newEntry = { id: 'new', type: SupportedEntry.Event } as OntimeEvent;
+    const afterId = getInsertAfterId(rundown, null, undefined, true);
+
+    addToRundown(rundown, newEntry, null, afterId, afterId);
+
+    expect(rundown.order).toEqual(['new', '1', '2', 'group']);
+    expect(rundown.flatOrder).toEqual(['new', '1', '2', 'group', '31', '32']);
+  });
+
+  it('inserts after a top-level group and its children in flatOrder', () => {
+    const rundown = makeTestRundown();
+    const newEntry = { id: 'new', type: SupportedEntry.Event } as OntimeEvent;
+
+    addToRundown(rundown, newEntry, null, 'group', null);
+
+    expect(rundown.order).toEqual(['1', '2', 'group', 'new']);
+    expect(rundown.flatOrder).toEqual(['1', '2', 'group', '31', '32', 'new']);
+  });
+
+  // case 1c: insert at the end of a group
+  it('inserts at the end of a group and sets parent', () => {
    const rundown = makeTestRundown();
    const parent = rundown.entries['group'] as OntimeGroup;
    const newEntry = { id: 'new', type: SupportedEntry.Event, parent: null } as OntimeEvent;

-    addToRundown(rundown, newEntry, null, parent);
+    addToRundown(rundown, newEntry, parent, null, null);
+
+    expect(parent.entries).toEqual(['31', '32', 'new']);
+    expect(newEntry.parent).toBe('group');
+    expect(rundown.flatOrder).toEqual(['1', '2', 'group', '31', '32', 'new']);
+    // top-level order must not change when inserting into a group
+    expect(rundown.order).toEqual(['1', '2', 'group']);
+  });
+
+  it('prepends to a group when before is true', () => {
+    const rundown = makeTestRundown();
+    const parent = rundown.entries['group'] as OntimeGroup;
+    const newEntry = { id: 'new', type: SupportedEntry.Event, parent: null } as OntimeEvent;
+    const afterId = getInsertAfterId(rundown, parent, undefined, true);
+
+    addToRundown(rundown, newEntry, parent, afterId, afterId);

    expect(parent.entries).toEqual(['new', '31', '32']);
    expect(newEntry.parent).toBe('group');
@@ -381,7 +419,7 @@ describe('addToRundown()', () => {
    const parent = rundown.entries['group'] as OntimeGroup;
    const newEntry = { id: 'new', type: SupportedEntry.Event, parent: null } as OntimeEvent;

-    addToRundown(rundown, newEntry, '31', parent);
+    addToRundown(rundown, newEntry, parent, '31', null);

    expect(parent.entries).toEqual(['31', 'new', '32']);
    expect(newEntry.parent).toBe('group');
@@ -361,31 +361,26 @@ export function getNextGroupNormal(
  return { entry: null, index: null };
 }

-/**
- * Receives an insertion order and returns the reference to an entry ID
- * after which we will insert the new entry
- */
 export function getInsertAfterId(
  rundown: Rundown,
  parent: OntimeGroup | null,
-  afterId?: EntryId,
-  beforeId?: EntryId,
+  afterId?: EntryId | true,
+  beforeId?: EntryId | true,
 ): EntryId | null {
-  if (afterId) return afterId;
-  if (!beforeId) return null;
+  if (beforeId) {
+    const insertionList = parent ? parent.entries : rundown.order;
+    return beforeId === true ? (insertionList[0] ?? null) : beforeId;
+  }

-  const insertionList = parent ? parent.entries : rundown.order;
-  if (!insertionList || insertionList.length === 0) return null;
+  if (afterId) return afterId === true ? null : afterId;

-  const atIndex = insertionList.findIndex((id) => id === beforeId);
-  if (atIndex < 1) return null;
-  return insertionList[atIndex - 1];
+  return null;
 }

 type ResolveInsertParentOptions = {
  parent?: EntryId | null;
-  after?: EntryId;
-  before?: EntryId;
+  after?: EntryId | true;
+  before?: EntryId | true;
 };

 /**
@@ -393,15 +388,21 @@ type ResolveInsertParentOptions = {
 * Uses explicit parent first, then infers from sibling references.
 */
 export function resolveInsertParent(rundown: Rundown, options: ResolveInsertParentOptions): EntryId | null {
-  if (options.parent) {
+  // 1. if we have a parent reference we return that
+  if (options.parent !== undefined && options.parent !== null) {
    return options.parent;
  }

-  const referenceId = options.after ?? options.before;
-  if (!referenceId) return null;
+  // 2. ... otherwise we look for a sibling and get their parent
+  const referenceId = (() => {
+    if (typeof options.after === 'string') return options.after;
+    if (typeof options.before === 'string') return options.before;
+    return undefined;
+  })();
+  if (referenceId === undefined) return null;

  const maybeSibling = rundown.entries[referenceId];
-  if (maybeSibling && 'parent' in maybeSibling && maybeSibling.parent) {
+  if (maybeSibling !== undefined && 'parent' in maybeSibling && maybeSibling.parent !== null) {
    return maybeSibling.parent;
  }

@@ -410,52 +411,57 @@ export function resolveInsertParent(rundown: Rundown, options: ResolveInsertPare

 /**
 * Add entry to rundown, mutates the rundown in place.
- * Handles the following cases:
- * - 1a. add entry in group, after a given entry
- * - 1b. add entry in group, at the beginning (right after the group header)
- * - 2a. add entry to the rundown, after a given entry
- * - 2b. add entry to the rundown, at the beginning
+ * if afterId and beforeId are not provided, we add at the end of the rundown
 */
 export function addToRundown(
  rundown: Rundown,
  entry: OntimeEntry,
-  afterId: EntryId | null,
  parent: OntimeGroup | null,
+  afterId: EntryId | null,
+  beforeId: EntryId | null,
 ): OntimeEntry {
+  // which list to use, the top level or a group order
+  const insertionList = parent ? parent.entries : rundown.order;
+
+  // the index inside the list
+  const insertionIndex = (() => {
+    if (beforeId) return insertionList.indexOf(beforeId);
+    if (afterId) return insertionList.indexOf(afterId) + 1;
+    return insertionList.length;
+  })();
+
+  // the index inside the flat order
+  const flatIndex = (() => {
+    if (beforeId) return rundown.flatOrder.indexOf(beforeId);
+
+    if (afterId) {
+      const afterEntry = rundown.entries[afterId];
+      const flatReferenceId =
+        !parent && isOntimeGroup(afterEntry) && afterEntry.entries?.length > 0
+          ? afterEntry.entries[afterEntry.entries.length - 1]
+          : afterId;
+      return rundown.flatOrder.indexOf(flatReferenceId) + 1;
+    }
+
+    if (parent) {
+      const previousId = insertionList[insertionIndex - 1] ?? parent.id;
+      return rundown.flatOrder.indexOf(previousId) + 1;
+    }
+
+    return rundown.flatOrder.length;
+  })();
+
  if (parent) {
-    // 1. inserting an entry inside a group
-
-    // assign the parent reference on the entry
-    if ('parent' in entry) {
-      entry.parent = parent.id;
+    if (isOntimeGroup(entry)) {
+      throw new Error('Cannot add a group to another group');
    }

-    if (afterId) {
-      // 1a. insert after a given entry within the group
-      const atEventsIndex = parent.entries.indexOf(afterId) + 1;
-      const atFlatIndex = rundown.flatOrder.indexOf(afterId) + 1;
-      parent.entries = insertAtIndex(atEventsIndex, entry.id, parent.entries);
-      rundown.flatOrder = insertAtIndex(atFlatIndex, entry.id, rundown.flatOrder);
-    } else {
-      // 1b. insert at the beginning of the group (right after the group header in flatOrder)
-      parent.entries = insertAtIndex(0, entry.id, parent.entries);
-      const atFlatIndex = rundown.flatOrder.indexOf(parent.id) + 1;
-      rundown.flatOrder = insertAtIndex(atFlatIndex, entry.id, rundown.flatOrder);
-    }
+    entry.parent = parent.id;
+    parent.entries = insertAtIndex(insertionIndex, entry.id, parent.entries);
  } else {
-    // 2. inserting an entry at top level
-    if (afterId) {
-      // 2a. insert after a given entry
-      const atOrderIndex = rundown.order.indexOf(afterId) + 1;
-      const atFlatIndex = rundown.flatOrder.indexOf(afterId) + 1;
-      rundown.order = insertAtIndex(atOrderIndex, entry.id, rundown.order);
-      rundown.flatOrder = insertAtIndex(atFlatIndex, entry.id, rundown.flatOrder);
-    } else {
-      // 2b. insert at the beginning
-      rundown.order = insertAtIndex(0, entry.id, rundown.order);
-      rundown.flatOrder = insertAtIndex(0, entry.id, rundown.flatOrder);
-    }
+    rundown.order = insertAtIndex(insertionIndex, entry.id, rundown.order);
  }
+  rundown.flatOrder = insertAtIndex(flatIndex, entry.id, rundown.flatOrder);

  // either way, we register the entry in the entries map
  rundown.entries[entry.id] = entry;
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