chore: improve convention entry <> event

2026-08-06 07:53:54 +00:00 · 2025-04-13 20:46:47 +02:00
parent d2c7b34142
commit 82dc1bc56b
23 changed files with 211 additions and 210 deletions
@@ -1,5 +1,6 @@
 import axios, { AxiosResponse } from 'axios';
 import {
+  EntryId,
  MessageResponse,
  OntimeEntry,
  OntimeEvent,
@@ -29,16 +30,16 @@ export async function fetchCurrentRundown(): Promise<Rundown> {
 }

 /**
- * HTTP request to post new event
+ * HTTP request to post new entry
 */
-export async function requestPostEvent(data: TransientEventPayload): Promise<AxiosResponse<OntimeEntry>> {
+export async function postAddEntry(data: TransientEventPayload): Promise<AxiosResponse<OntimeEntry>> {
  return axios.post(rundownPath, data);
 }

 /**
- * HTTP request to put new event
+ * HTTP request to edit an entry
 */
-export async function requestPutEvent(data: Partial<OntimeEntry>): Promise<AxiosResponse<OntimeEntry>> {
+export async function putEditEntry(data: Partial<OntimeEntry>): Promise<AxiosResponse<OntimeEntry>> {
  return axios.put(rundownPath, data);
 }

@@ -48,9 +49,9 @@ type BatchEditEntry = {
 };

 /**
- * HTTP request to put multiple events
+ * HTTP request to edit multiple events
 */
-export async function requestBatchPutEvents(data: BatchEditEntry): Promise<AxiosResponse<MessageResponse>> {
+export async function putBatchEditEvents(data: BatchEditEntry): Promise<AxiosResponse<MessageResponse>> {
  return axios.put(`${rundownPath}/batch`, data);
 }

@@ -61,9 +62,9 @@ export type ReorderEntry = {
 };

 /**
- * HTTP request to reorder events
+ * HTTP request to reorder an entry
 */
-export async function requestReorderEvent(data: ReorderEntry): Promise<AxiosResponse<OntimeEntry>> {
+export async function patchReorderEntry(data: ReorderEntry): Promise<AxiosResponse<OntimeEntry>> {
  return axios.patch(`${rundownPath}/reorder`, data);
 }

@@ -82,15 +83,15 @@ export async function requestEventSwap(data: SwapEntry): Promise<AxiosResponse<M
 /**
 * HTTP request to request application of delay
 */
-export async function requestApplyDelay(eventId: string): Promise<AxiosResponse<MessageResponse>> {
-  return axios.patch(`${rundownPath}/applydelay/${eventId}`);
+export async function requestApplyDelay(delayId: string): Promise<AxiosResponse<MessageResponse>> {
+  return axios.patch(`${rundownPath}/applydelay/${delayId}`);
 }

 /**
- * HTTP request to delete given event
+ * HTTP request to delete entries
 */
-export async function requestDelete(eventIds: string[]): Promise<AxiosResponse<MessageResponse>> {
-  return axios.delete(rundownPath, { data: { ids: eventIds } });
+export async function deleteEntries(entryIds: EntryId[]): Promise<AxiosResponse<MessageResponse>> {
+  return axios.delete(rundownPath, { data: { ids: entryIds } });
 }

 /**
@@ -7,7 +7,7 @@ import { addLog } from '../stores/logger';
 import { nowInMillis } from '../utils/time';

 /**
- * Utility unrwap a potential axios error
+ * Utility unwrap a potential axios error
 * @param error
 * @returns
 */
@@ -34,7 +34,7 @@ export function maybeAxiosError(error: unknown) {
 }

 /**
- * Utility unrwaps a potential axios error and sends to logger
+ * Utility unwraps a potential axios error and sends to logger
 * @param prepend
 * @param error
 */
@@ -2,7 +2,7 @@ import { KeyboardEvent, useEffect, useRef, useState } from 'react';
 import { Input, Radio, RadioGroup } from '@chakra-ui/react';
 import { millisToString, parseUserTime } from 'ontime-utils';

-import { useEventAction } from '../../../hooks/useEventAction';
+import { useEntryActions } from '../../../hooks/useEntryAction';

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

@@ -13,7 +13,7 @@ interface DelayInputProps {

 export default function DelayInput(props: DelayInputProps) {
  const { eventId, duration } = props;
-  const { updateEvent } = useEventAction();
+  const { updateEntry } = useEntryActions();

  const [value, setValue] = useState<string>('');
  const inputRef = useRef<HTMLInputElement | null>(null);
@@ -54,7 +54,7 @@ export default function DelayInput(props: DelayInputProps) {
  };

  const submitChange = (value: number) => {
-    updateEvent({
+    updateEntry({
      id: eventId,
      duration: value,
    });
@@ -1,10 +1,9 @@
 import { useCallback } from 'react';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import {
+  EntryId,
  isOntimeEvent,
  MaybeString,
-  OntimeBlock,
-  OntimeDelay,
  OntimeEntry,
  OntimeEvent,
  Rundown,
@@ -16,15 +15,15 @@ import { dayInMs, MILLIS_PER_SECOND, parseUserTime, reorderArray, swapEventData

 import { RUNDOWN } from '../api/constants';
 import {
+  deleteEntries,
+  patchReorderEntry,
+  postAddEntry,
+  putBatchEditEvents,
+  putEditEntry,
  ReorderEntry,
  requestApplyDelay,
-  requestBatchPutEvents,
-  requestDelete,
  requestDeleteAll,
  requestEventSwap,
-  requestPostEvent,
-  requestPutEvent,
-  requestReorderEvent,
  SwapEntry,
 } from '../api/rundown';
 import { logAxiosError } from '../api/utils';
@@ -41,9 +40,9 @@ export type EventOptions = Partial<{
 }>;

 /**
- * @description Set of utilities for events //TODO: should this be called useEntryAction and so on
+ * Gather utilities for actions on entries
 */
-export const useEventAction = () => {
+export const useEntryActions = () => {
  const queryClient = useQueryClient();
  const {
    defaultPublic,
@@ -56,8 +55,8 @@ export const useEventAction = () => {
    defaultEndAction,
  } = useEditorSettings();

-  const getEventById = useCallback(
-    (eventId: string) => {
+  const getEntryById = useCallback(
+    (eventId: string): OntimeEntry | undefined => {
      const cachedRundown = queryClient.getQueryData<Rundown>(RUNDOWN);
      if (!cachedRundown?.entries) {
        return;
@@ -68,11 +67,11 @@ export const useEventAction = () => {
  );

  /**
-   * Calls mutation to add new event
+   * Calls mutation to add new entry
   * @private
   */
-  const _addEventMutation = useMutation({
-    mutationFn: requestPostEvent,
+  const _addEntryMutation = useMutation({
+    mutationFn: postAddEntry,
    onSettled: () => {
      queryClient.invalidateQueries({ queryKey: RUNDOWN });
    },
@@ -80,14 +79,14 @@ export const useEventAction = () => {
  });

  /**
-   * Adds an event to rundown
+   * Adds an entry to rundown
   */
-  const addEvent = useCallback(
-    async (event: Partial<OntimeEvent | OntimeDelay | OntimeBlock>, options?: EventOptions) => {
-      const newEvent: TransientEventPayload = { ...event };
+  const addEntry = useCallback(
+    async (entry: Partial<OntimeEntry>, options?: EventOptions) => {
+      const newEntry: TransientEventPayload = { ...entry };

      // ************* CHECK OPTIONS specific to events
-      if (isOntimeEvent(newEvent)) {
+      if (isOntimeEvent(newEntry)) {
        // merge creation time options with event settings
        const applicationOptions = {
          after: options?.after,
@@ -102,57 +101,57 @@ export const useEventAction = () => {
          const rundownData = queryClient.getQueryData<Rundown>(RUNDOWN)!;
          const previousEvent = rundownData.entries[applicationOptions.lastEventId];
          if (isOntimeEvent(previousEvent)) {
-            newEvent.timeStart = previousEvent.timeEnd;
+            newEntry.timeStart = previousEvent.timeEnd;
          }
        }

        // Override event with options from editor settings
-        newEvent.linkStart = applicationOptions.linkPrevious;
-        newEvent.isPublic = applicationOptions.defaultPublic;
+        newEntry.linkStart = applicationOptions.linkPrevious;
+        newEntry.isPublic = applicationOptions.defaultPublic;

-        if (newEvent.duration === undefined && newEvent.timeEnd === undefined) {
-          newEvent.duration = parseUserTime(defaultDuration);
+        if (newEntry.duration === undefined && newEntry.timeEnd === undefined) {
+          newEntry.duration = parseUserTime(defaultDuration);
        }

-        if (newEvent.timeDanger === undefined) {
-          newEvent.timeDanger = parseUserTime(defaultDangerTime);
+        if (newEntry.timeDanger === undefined) {
+          newEntry.timeDanger = parseUserTime(defaultDangerTime);
        }

-        if (newEvent.timeWarning === undefined) {
-          newEvent.timeWarning = parseUserTime(defaultWarnTime);
+        if (newEntry.timeWarning === undefined) {
+          newEntry.timeWarning = parseUserTime(defaultWarnTime);
        }

-        if (newEvent.timerType === undefined) {
-          newEvent.timerType = defaultTimerType;
+        if (newEntry.timerType === undefined) {
+          newEntry.timerType = defaultTimerType;
        }

-        if (newEvent.endAction === undefined) {
-          newEvent.endAction = defaultEndAction;
+        if (newEntry.endAction === undefined) {
+          newEntry.endAction = defaultEndAction;
        }

-        if (newEvent.timeStrategy === undefined) {
-          newEvent.timeStrategy = defaultTimeStrategy;
+        if (newEntry.timeStrategy === undefined) {
+          newEntry.timeStrategy = defaultTimeStrategy;
        }
      }

      // handle adding options that concern all event type
      if (options?.after) {
        // @ts-expect-error -- not sure how to type this, <after> is a transient property
-        newEvent.after = options.after;
+        newEntry.after = options.after;
      }
      if (options?.before) {
        // @ts-expect-error -- not sure how to type this, <before> is a transient property
-        newEvent.before = options.before;
+        newEntry.before = options.before;
      }

      try {
-        await _addEventMutation.mutateAsync(newEvent as TransientEventPayload);
+        await _addEntryMutation.mutateAsync(newEntry as TransientEventPayload);
      } catch (error) {
        logAxiosError('Failed adding event', error);
      }
    },
    [
-      _addEventMutation,
+      _addEntryMutation,
      defaultDangerTime,
      defaultDuration,
      defaultEndAction,
@@ -166,11 +165,11 @@ export const useEventAction = () => {
  );

  /**
-   * Calls mutation to update existing event
+   * Calls mutation to update existing entry
   * @private
   */
-  const _updateEventMutation = useMutation({
-    mutationFn: requestPutEvent,
+  const _updateEntryMutation = useMutation({
+    mutationFn: putEditEntry,
    // we optimistically update here
    onMutate: async (newEvent) => {
      // cancel ongoing queries
@@ -210,35 +209,35 @@ export const useEventAction = () => {
  });

  /**
-   * Updates existing event
+   * Updates existing entry
   */
-  const updateEvent = useCallback(
+  const updateEntry = useCallback(
    async (event: Partial<OntimeEntry>) => {
      try {
-        await _updateEventMutation.mutateAsync(event);
+        await _updateEntryMutation.mutateAsync(event);
      } catch (error) {
        logAxiosError('Error updating event', error);
      }
    },
-    [_updateEventMutation],
+    [_updateEntryMutation],
  );

  const updateCustomField = useCallback(
-    async (eventId: string, field: string, value: string) => {
-      updateEvent({ id: eventId, custom: { [field]: value } });
+    async (entryId: EntryId, field: string, value: string) => {
+      updateEntry({ id: entryId, custom: { [field]: value } });
    },
-    [updateEvent],
+    [updateEntry],
  );

  /**
   * Updates time of existing event
-   * @param eventId {string} - id of the event
+   * @param eventId {EntryId} - id of the event
   * @param field {TimeField} - field to update
   * @param value {string} - new value string to be parsed
   * @param lockOnUpdate {boolean} - whether we will apply the lock / release on update
   */
  const updateTimer = useCallback(
-    async (eventId: string, field: TimeField, value: string, lockOnUpdate?: boolean) => {
+    async (eventId: EntryId, field: TimeField, value: string, lockOnUpdate?: boolean) => {
      // an empty value with no lock has no domain validity
      if (!lockOnUpdate && value === '') {
        return;
@@ -268,7 +267,7 @@ export const useEventAction = () => {
      }

      try {
-        await _updateEventMutation.mutateAsync(newEvent);
+        await _updateEntryMutation.mutateAsync(newEvent);
      } catch (error) {
        logAxiosError('Error updating event', error);
      }
@@ -320,7 +319,7 @@ export const useEventAction = () => {
        return previousEnd;
      }
    },
-    [_updateEventMutation, queryClient],
+    [_updateEntryMutation, queryClient],
  );

  /**
@@ -328,7 +327,7 @@ export const useEventAction = () => {
   * @private
   */
  const _batchUpdateEventsMutation = useMutation({
-    mutationFn: requestBatchPutEvents,
+    mutationFn: putBatchEditEvents,
    onMutate: async ({ ids, data }) => {
      // cancel ongoing queries
      await queryClient.cancelQueries({ queryKey: RUNDOWN });
@@ -360,6 +359,7 @@ export const useEventAction = () => {
          revision: -1,
        });
      }
+
      // Return a context with the previous rundown
      return { previousRundown };
    },
@@ -384,13 +384,13 @@ export const useEventAction = () => {
  );

  /**
-   * Calls mutation to delete an event
+   * Calls mutation to delete an entry
   * @private
   */
-  const _deleteEventMutation = useMutation({
-    mutationFn: requestDelete,
+  const _deleteEntryMutation = useMutation({
+    mutationFn: deleteEntries,
    // we optimistically update here
-    onMutate: async (eventIds: string[]) => {
+    onMutate: async (entryIds: EntryId[]) => {
      // cancel ongoing queries
      await queryClient.cancelQueries({ queryKey: RUNDOWN });

@@ -399,9 +399,9 @@ export const useEventAction = () => {

      if (previousData) {
        // optimistically update object
-        const newOrder = previousData.order.filter((id) => !eventIds.includes(id));
+        const newOrder = previousData.order.filter((id) => !entryIds.includes(id));
        const newRundown = { ...previousData.entries };
-        for (const eventId of eventIds) {
+        for (const eventId of entryIds) {
          delete newRundown[eventId];
        }

@@ -419,7 +419,7 @@ export const useEventAction = () => {
    },

    // Mutation fails, rollback undoes optimist update
-    onError: (_error, _eventId, context) => {
+    onError: (_error, _entryIds, context) => {
      queryClient.setQueryData<Rundown>(RUNDOWN, context?.previousData);
    },
    // Mutation finished, failed or successful
@@ -431,24 +431,24 @@ export const useEventAction = () => {
  });

  /**
-   * Deletes an event form the list
+   * Deletes an event entry from the rundown
   */
-  const deleteEvent = useCallback(
-    async (eventIds: string[]) => {
+  const deleteEntry = useCallback(
+    async (entryIds: EntryId[]) => {
      try {
-        await _deleteEventMutation.mutateAsync(eventIds);
+        await _deleteEntryMutation.mutateAsync(entryIds);
      } catch (error) {
        logAxiosError('Error deleting event', error);
      }
    },
-    [_deleteEventMutation],
+    [_deleteEntryMutation],
  );

  /**
   * Calls mutation to delete all events
   * @private
   */
-  const _deleteAllEventsMutation = useMutation({
+  const _deleteAllEntriesMutation = useMutation({
    mutationFn: requestDeleteAll,
    // we optimistically update here
    onMutate: async () => {
@@ -471,8 +471,8 @@ export const useEventAction = () => {
      return { previousData };
    },

-    // Mutation fails, rollback undos optimist update
-    onError: (_error, _eventId, context) => {
+    // Mutation fails, rollback optimist update
+    onError: (_error, _, context) => {
      queryClient.setQueryData<Rundown>(RUNDOWN, context?.previousData);
    },
    // Mutation finished, failed or successful
@@ -484,15 +484,15 @@ export const useEventAction = () => {
  });

  /**
-   * Deletes all events from list
+   * Deletes all entries in the rundown
   */
-  const deleteAllEvents = useCallback(async () => {
+  const deleteAllEntries = useCallback(async () => {
    try {
-      await _deleteAllEventsMutation.mutateAsync();
+      await _deleteAllEntriesMutation.mutateAsync();
    } catch (error) {
      logAxiosError('Error deleting events', error);
    }
-  }, [_deleteAllEventsMutation]);
+  }, [_deleteAllEntriesMutation]);

  /**
   * Calls mutation to apply a delay
@@ -508,7 +508,7 @@ export const useEventAction = () => {
  });

  /**
-   * Applies a given delay block
+   * Applies a given delay
   */
  const applyDelay = useCallback(
    async (delayEventId: string) => {
@@ -522,11 +522,11 @@ export const useEventAction = () => {
  );

  /**
-   * Calls mutation to reorder an event
+   * Calls mutation to reorder an entry
   * @private
   */
-  const _reorderEventMutation = useMutation({
-    mutationFn: requestReorderEvent,
+  const _reorderEntryMutation = useMutation({
+    mutationFn: patchReorderEntry,
    // we optimistically update here
    onMutate: async (data) => {
      // cancel ongoing queries
@@ -552,7 +552,7 @@ export const useEventAction = () => {
    },

    // Mutation fails, rollback undoes optimist update
-    onError: (_error, _eventId, context) => {
+    onError: (_error, _data, context) => {
      queryClient.setQueryData<Rundown>(RUNDOWN, context?.previousData);
    },
    // Mutation finished, failed or successful
@@ -564,22 +564,22 @@ export const useEventAction = () => {
  });

  /**
-   * Reorders a given event
+   * Reorders a given entry
   */
-  const reorderEvent = useCallback(
-    async (eventId: string, from: number, to: number) => {
+  const reorderEntry = useCallback(
+    async (entryId: string, from: number, to: number) => {
      try {
        const reorderObject: ReorderEntry = {
-          eventId,
+          eventId: entryId,
          from,
          to,
        };
-        await _reorderEventMutation.mutateAsync(reorderObject);
+        await _reorderEntryMutation.mutateAsync(reorderObject);
      } catch (error) {
        logAxiosError('Error re-ordering event', error);
      }
    },
-    [_reorderEventMutation],
+    [_reorderEntryMutation],
  );

  /**
@@ -649,15 +649,15 @@ export const useEventAction = () => {
  );

  return {
-    addEvent,
+    addEntry,
    applyDelay,
    batchUpdateEvents,
-    deleteEvent,
-    deleteAllEvents,
-    getEventById,
-    reorderEvent,
+    deleteEntry,
+    deleteAllEntries,
+    getEntryById,
+    reorderEntry,
    swapEvents,
-    updateEvent,
+    updateEntry,
    updateTimer,
    updateCustomField,
  };
@@ -2,7 +2,7 @@ import { useRef, useState } from 'react';
 import { Button, Textarea } from '@chakra-ui/react';
 import { OntimeEvent } from 'ontime-types';

-import { useEventAction } from '../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../common/hooks/useEntryAction';
 import type { EditEvent } from '../Operator';

 import style from './EditModal.module.scss';
@@ -15,7 +15,7 @@ interface EditModalProps {
 export default function EditModal(props: EditModalProps) {
  const { event, onClose } = props;

-  const { updateEvent } = useEventAction();
+  const { updateEntry } = useEntryActions();
  const [loading, setLoading] = useState(false);
  const inputRef = useRef<HTMLTextAreaElement[]>(new Array<HTMLTextAreaElement>());

@@ -36,7 +36,7 @@ export default function EditModal(props: EditModalProps) {
    });

    if (patchObject.custom) {
-      await updateEvent(patchObject);
+      await updateEntry(patchObject);
    }

    setLoading(false);
@@ -21,7 +21,7 @@ import {
  reorderArray,
 } from 'ontime-utils';

-import { type EventOptions, useEventAction } from '../../common/hooks/useEventAction';
+import { type EventOptions, useEntryActions } from '../../common/hooks/useEntryAction';
 import useFollowComponent from '../../common/hooks/useFollowComponent';
 import { useRundownEditor } from '../../common/hooks/useSocket';
 import { AppMode, useAppMode } from '../../common/stores/appModeStore';
@@ -48,7 +48,7 @@ export default function Rundown({ data }: RundownProps) {
  const [statefulEntries, setStatefulEntries] = useState<EntryId[]>(order);

  const featureData = useRundownEditor();
-  const { addEvent, reorderEvent, deleteEvent } = useEventAction();
+  const { addEntry, reorderEntry, deleteEntry } = useEntryActions();

  const { entryCopyId, setEntryCopyId } = useEntryCopy();

@@ -67,12 +67,12 @@ export default function Rundown({ data }: RundownProps) {
    (cursor: string | null) => {
      if (!cursor) return;
      const { entry, index } = getPreviousNormal(entries, order, cursor);
-      deleteEvent([cursor]);
+      deleteEntry([cursor]);
      if (entry && index !== null) {
        setSelectedEvents({ id: entry.id, selectMode: 'click', index });
      }
    },
-    [entries, order, deleteEvent, setSelectedEvents],
+    [entries, order, deleteEntry, setSelectedEvents],
  );

  const insertCopyAtId = useCallback(
@@ -86,10 +86,10 @@ export default function Rundown({ data }: RundownProps) {
      if (cloneEntry?.type === SupportedEvent.Event) {
        //if we don't have a cursor add the new event on top
        const newEvent = cloneEvent(cloneEntry);
-        addEvent(newEvent, { after: adjustedCursor ?? undefined });
+        addEntry(newEvent, { after: adjustedCursor ?? undefined });
      }
    },
-    [addEvent, order, entries],
+    [addEntry, order, entries],
  );

  const insertAtId = useCallback(
@@ -109,12 +109,12 @@ export default function Rundown({ data }: RundownProps) {
        if (!above && id) {
          options.lastEventId = id;
        }
-        addEvent(newEvent, options);
+        addEntry(newEvent, options);
      } else {
-        addEvent({ type }, options);
+        addEntry({ type }, options);
      }
    },
-    [addEvent],
+    [addEntry],
  );

  const selectBlock = useCallback(
@@ -187,10 +187,10 @@ export default function Rundown({ data }: RundownProps) {

      if (index !== null) {
        const offsetIndex = direction === 'up' ? index + 1 : index - 1;
-        reorderEvent(cursor, offsetIndex, index);
+        reorderEntry(cursor, offsetIndex, index);
      }
    },
-    [order, reorderEvent, entries],
+    [order, reorderEntry, entries],
  );

  // shortcuts
@@ -254,7 +254,7 @@ export default function Rundown({ data }: RundownProps) {
        setStatefulEntries((currentEntries) => {
          return reorderArray(currentEntries, fromIndex, toIndex);
        });
-        reorderEvent(String(active.id), fromIndex, toIndex);
+        reorderEntry(String(active.id), fromIndex, toIndex);
      }
    }
  };
@@ -9,7 +9,7 @@ import {
  SupportedEvent,
 } from 'ontime-types';

-import { useEventAction } from '../../common/hooks/useEventAction';
+import { useEntryActions } from '../../common/hooks/useEntryAction';
 import useMemoisedFn from '../../common/hooks/useMemoisedFn';
 import { useEmitLog } from '../../common/stores/logger';
 import { cloneEvent } from '../../common/utils/eventsManager';
@@ -66,7 +66,7 @@ export default function RundownEntry(props: RundownEntryProps) {
    isLinkedToLoaded,
  } = props;
  const { emitError } = useEmitLog();
-  const { addEvent, updateEvent, batchUpdateEvents, deleteEvent, swapEvents } = useEventAction();
+  const { addEntry, updateEntry, batchUpdateEvents, deleteEntry, swapEvents } = useEntryActions();
  const { selectedEvents, unselect, clearSelectedEvents } = useEventSelection();

  const removeOpenEvent = useCallback(() => {
@@ -91,26 +91,26 @@ export default function RundownEntry(props: RundownEntryProps) {
          after: data.id,
          lastEventId: previousEventId,
        };
-        return addEvent(newEvent, options);
+        return addEntry(newEvent, options);
      }
      case 'event-before': {
        const newEvent = { type: SupportedEvent.Event };
        const options = {
          after: previousEntryId,
        };
-        return addEvent(newEvent, options);
+        return addEntry(newEvent, options);
      }
      case 'delay': {
-        return addEvent({ type: SupportedEvent.Delay }, { after: data.id });
+        return addEntry({ type: SupportedEvent.Delay }, { after: data.id });
      }
      case 'delay-before': {
-        return addEvent({ type: SupportedEvent.Delay }, { after: previousEntryId });
+        return addEntry({ type: SupportedEvent.Delay }, { after: previousEntryId });
      }
      case 'block': {
-        return addEvent({ type: SupportedEvent.Block }, { after: data.id });
+        return addEntry({ type: SupportedEvent.Block }, { after: data.id });
      }
      case 'block-before': {
-        return addEvent({ type: SupportedEvent.Block }, { after: previousEntryId });
+        return addEntry({ type: SupportedEvent.Block }, { after: previousEntryId });
      }
      case 'swap': {
        const { value } = payload as FieldValue;
@@ -119,14 +119,14 @@ export default function RundownEntry(props: RundownEntryProps) {
      case 'delete': {
        if (selectedEvents.size > 1) {
          clearMultiSelection();
-          return deleteEvent(Array.from(selectedEvents));
+          return deleteEntry(Array.from(selectedEvents));
        }
        removeOpenEvent();
-        return deleteEvent([data.id]);
+        return deleteEntry([data.id]);
      }
      case 'clone': {
        const newEvent = cloneEvent(data as OntimeEvent);
-        addEvent(newEvent, { after: data.id });
+        addEntry(newEvent, { after: data.id });
        break;
      }
      case 'update': {
@@ -147,7 +147,7 @@ export default function RundownEntry(props: RundownEntryProps) {
        if (field in data) {
          // @ts-expect-error -- not sure how to type this
          newData[field] = value;
-          return updateEvent(newData);
+          return updateEntry(newData);
        }

        return emitError(`Unknown field: ${field}`);
@@ -2,7 +2,7 @@ import { useCallback, useRef } from 'react';
 import { Input } from '@chakra-ui/react';

 import useReactiveTextInput from '../../../common/components/input/text-input/useReactiveTextInput';
-import { useEventAction } from '../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../common/hooks/useEntryAction';
 import { cx } from '../../../common/utils/styleUtils';

 import style from './TitleEditor.module.scss';
@@ -16,7 +16,7 @@ interface TitleEditorProps {

 export default function EditableBlockTitle(props: TitleEditorProps) {
  const { title, eventId, placeholder, className } = props;
-  const { updateEvent } = useEventAction();
+  const { updateEntry } = useEntryActions();
  const ref = useRef<HTMLInputElement | null>(null);
  const submitCallback = useCallback(
    (text: string) => {
@@ -25,9 +25,9 @@ export default function EditableBlockTitle(props: TitleEditorProps) {
      }

      const cleanVal = text.trim();
-      updateEvent({ id: eventId, title: cleanVal });
+      updateEntry({ id: eventId, title: cleanVal });
    },
-    [title, updateEvent, eventId],
+    [title, updateEntry, eventId],
  );

  const { value, onChange, onBlur, onKeyDown } = useReactiveTextInput(title, submitCallback, ref, {
@@ -6,7 +6,7 @@ import { CSS } from '@dnd-kit/utilities';
 import { OntimeDelay } from 'ontime-types';

 import DelayInput from '../../../common/components/input/delay-input/DelayInput';
-import { useEventAction } from '../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../common/hooks/useEntryAction';
 import { cx } from '../../../common/utils/styleUtils';

 import style from './DelayBlock.module.scss';
@@ -18,7 +18,7 @@ interface DelayBlockProps {

 export default function DelayBlock(props: DelayBlockProps) {
  const { data, hasCursor } = props;
-  const { applyDelay, deleteEvent } = useEventAction();
+  const { applyDelay, deleteEntry } = useEntryActions();
  const handleRef = useRef<null | HTMLSpanElement>(null);

  const {
@@ -48,7 +48,7 @@ export default function DelayBlock(props: DelayBlockProps) {
  };

  const cancelDelayHandler = () => {
-    deleteEvent([data.id]);
+    deleteEntry([data.id]);
  };

  const blockClasses = cx([style.delay, hasCursor ? style.hasCursor : null]);
@@ -2,7 +2,7 @@ import { memo, MouseEvent } from 'react';
 import { IoPause, IoPlay, IoReload, IoRemoveCircle, IoRemoveCircleOutline } from 'react-icons/io5';

 import TooltipActionBtn from '../../../../common/components/buttons/TooltipActionBtn';
-import { useEventAction } from '../../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../../common/hooks/useEntryAction';
 import { setEventPlayback } from '../../../../common/hooks/useSocket';
 import { tooltipDelayMid } from '../../../../ontimeConfig';

@@ -34,11 +34,11 @@ interface EventBlockPlaybackProps {

 const EventBlockPlayback = (props: EventBlockPlaybackProps) => {
  const { eventId, skip, isPlaying, isPaused, loaded, disablePlayback } = props;
-  const { updateEvent } = useEventAction();
+  const { updateEntry } = useEntryActions();

  const toggleSkip = (event: MouseEvent) => {
    event.stopPropagation();
-    updateEvent({ id: eventId, skip: !skip });
+    updateEntry({ id: eventId, skip: !skip });
  };

  const actionHandler = (event: MouseEvent) => {
@@ -2,7 +2,7 @@ import { useCallback } from 'react';
 import { CustomFieldLabel, OntimeEvent } from 'ontime-types';

 import AppLink from '../../../common/components/link/app-link/AppLink';
-import { useEventAction } from '../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../common/hooks/useEntryAction';
 import useCustomFields from '../../../common/hooks-query/useCustomFields';
 import * as Editor from '../../editors/editor-utils/EditorUtils';

@@ -23,7 +23,7 @@ interface EventEditorProps {
 export default function EventEditor(props: EventEditorProps) {
  const { event } = props;
  const { data: customFields } = useCustomFields();
-  const { updateEvent } = useEventAction();
+  const { updateEntry } = useEntryActions();

  const isEditor = window.location.pathname.includes('editor');

@@ -31,12 +31,12 @@ export default function EventEditor(props: EventEditorProps) {
    (field: EditorUpdateFields, value: string) => {
      if (field.startsWith('custom-')) {
        const fieldLabel = field.split('custom-')[1];
-        updateEvent({ id: event?.id, custom: { [fieldLabel]: value } });
+        updateEntry({ id: event?.id, custom: { [fieldLabel]: value } });
      } else {
-        updateEvent({ id: event?.id, [field]: value });
+        updateEntry({ id: event?.id, [field]: value });
      }
    },
-    [event?.id, updateEvent],
+    [event?.id, updateEntry],
  );

  if (!event) {
@@ -5,7 +5,7 @@ import { EndAction, TimerType, TimeStrategy } from 'ontime-types';
 import { millisToString, parseUserTime } from 'ontime-utils';

 import TimeInput from '../../../../common/components/input/time-input/TimeInput';
-import { useEventAction } from '../../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../../common/hooks/useEntryAction';
 import { millisToDelayString } from '../../../../common/utils/dateConfig';
 import * as Editor from '../../../editors/editor-utils/EditorUtils';
 import TimeInputFlow from '../../time-input-flow/TimeInputFlow';
@@ -46,27 +46,27 @@ function EventEditorTimes(props: EventEditorTimesProps) {
    timeWarning,
    timeDanger,
  } = props;
-  const { updateEvent } = useEventAction();
+  const { updateEntry } = useEntryActions();

  const handleSubmit = (field: HandledActions, value: string | boolean) => {
    if (field === 'isPublic') {
-      updateEvent({ id: eventId, isPublic: !(value as boolean) });
+      updateEntry({ id: eventId, isPublic: !(value as boolean) });
      return;
    }

    if (field === 'countToEnd') {
-      updateEvent({ id: eventId, countToEnd: !(value as boolean) });
+      updateEntry({ id: eventId, countToEnd: !(value as boolean) });
      return;
    }

    if (field === 'timeWarning' || field === 'timeDanger') {
      const newTime = parseUserTime(value as string);
-      updateEvent({ id: eventId, [field]: newTime });
+      updateEntry({ id: eventId, [field]: newTime });
      return;
    }

    if (field === 'timerType' || field === 'endAction') {
-      updateEvent({ id: eventId, [field]: value });
+      updateEntry({ id: eventId, [field]: value });
      return;
    }
  };
@@ -3,7 +3,7 @@ import { IoAdd } from 'react-icons/io5';
 import { Button } from '@chakra-ui/react';
 import { MaybeString, SupportedEvent } from 'ontime-types';

-import { useEventAction } from '../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../common/hooks/useEntryAction';
 import { useEmitLog } from '../../../common/stores/logger';

 import style from './QuickAddBlock.module.scss';
@@ -17,7 +17,7 @@ export default memo(QuickAddBlock);

 function QuickAddBlock(props: QuickAddBlockProps) {
  const { previousEventId, showBlocks } = props;
-  const { addEvent } = useEventAction();
+  const { addEntry } = useEntryActions();
  const { emitError } = useEmitLog();

  const doLinkPrevious = useRef<HTMLInputElement | null>(null);
@@ -37,7 +37,7 @@ function QuickAddBlock(props: QuickAddBlockProps) {
            lastEventId: previousEventId,
            linkPrevious,
          };
-          addEvent(newEvent, options);
+          addEntry(newEvent, options);
          break;
        }
        case 'delay': {
@@ -45,7 +45,7 @@ function QuickAddBlock(props: QuickAddBlockProps) {
            lastEventId: previousEventId,
            after: previousEventId,
          };
-          addEvent({ type: SupportedEvent.Delay }, options);
+          addEntry({ type: SupportedEvent.Delay }, options);
          break;
        }
        case 'block': {
@@ -53,7 +53,7 @@ function QuickAddBlock(props: QuickAddBlockProps) {
            lastEventId: previousEventId,
            after: previousEventId,
          };
-          addEvent({ type: SupportedEvent.Block }, options);
+          addEntry({ type: SupportedEvent.Block }, options);
          break;
        }
        default: {
@@ -62,7 +62,7 @@ function QuickAddBlock(props: QuickAddBlockProps) {
        }
      }
    },
-    [previousEventId, addEvent, emitError],
+    [previousEventId, addEntry, emitError],
  );

  return (
@@ -11,23 +11,23 @@ import {
  useDisclosure,
 } from '@chakra-ui/react';

-import { useEventAction } from '../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../common/hooks/useEntryAction';
 import { useAppMode } from '../../../common/stores/appModeStore';
 import { useEventSelection } from '../useEventSelection';

 export default function RundownMenu() {
  const clearSelectedEvents = useEventSelection((state) => state.clearSelectedEvents);
  const appMode = useAppMode((state) => state.mode);
-  const { deleteAllEvents } = useEventAction();
+  const { deleteAllEntries } = useEntryActions();

  const { isOpen, onOpen, onClose } = useDisclosure();
  const cancelRef = useRef<HTMLButtonElement | null>(null);

  const deleteAll = useCallback(() => {
-    deleteAllEvents();
+    deleteAllEntries();
    clearSelectedEvents();
    onClose();
-  }, [clearSelectedEvents, deleteAllEvents, onClose]);
+  }, [clearSelectedEvents, deleteAllEntries, onClose]);

  return (
    <>
@@ -5,7 +5,7 @@ import { TimeField, TimeStrategy } from 'ontime-types';
 import { dayInMs } from 'ontime-utils';

 import TimeInputWithButton from '../../../common/components/input/time-input/TimeInputWithButton';
-import { useEventAction } from '../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../common/hooks/useEntryAction';
 import { cx } from '../../../common/utils/styleUtils';
 import { tooltipDelayFast, tooltipDelayMid } from '../../../ontimeConfig';
 import * as Editor from '../../editors/editor-utils/EditorUtils';
@@ -26,7 +26,7 @@ interface EventBlockTimerProps {

 function TimeInputFlow(props: EventBlockTimerProps) {
  const { eventId, countToEnd, timeStart, timeEnd, duration, timeStrategy, linkStart, delay, showLabels } = props;
-  const { updateEvent, updateTimer } = useEventAction();
+  const { updateEntry, updateTimer } = useEntryActions();

  // In sync with EventEditorTimes
  const handleSubmit = (field: TimeField, value: string) => {
@@ -34,11 +34,11 @@ function TimeInputFlow(props: EventBlockTimerProps) {
  };

  const handleChangeStrategy = (timeStrategy: TimeStrategy) => {
-    updateEvent({ id: eventId, timeStrategy });
+    updateEntry({ id: eventId, timeStrategy });
  };

  const handleLink = (doLink: boolean) => {
-    updateEvent({ id: eventId, linkStart: doLink });
+    updateEntry({ id: eventId, linkStart: doLink });
  };

  const warnings = [];
@@ -1,5 +1,5 @@
 import { MouseEvent } from 'react';
-import { isOntimeEvent, MaybeNumber, MaybeString, OntimeEvent, Rundown } from 'ontime-types';
+import { EntryId, isOntimeEvent, MaybeNumber, MaybeString, Rundown } from 'ontime-types';
 import { create } from 'zustand';

 import { RUNDOWN } from '../../common/api/constants';
@@ -66,11 +66,11 @@ export const useEventSelection = create<EventSelectionStore>()((set, get) => ({
      if (!rundownData) return;

      // get list of rundown with only ontime events
-      const events: OntimeEvent[] = [];
-      rundownData.order.forEach((eventId) => {
+      const eventIds: EntryId[] = [];
+      rundownData.flatOrder.forEach((eventId) => {
        const event = rundownData.entries[eventId];
        if (isOntimeEvent(event)) {
-          events.push(event);
+          eventIds.push(event.id);
        }
      });

@@ -78,7 +78,7 @@ export const useEventSelection = create<EventSelectionStore>()((set, get) => ({
      const end = anchoredIndex === null ? index : Math.max(anchoredIndex, index + 1);

      // create new set with range of ids from start to end
-      const selectedEventIds = events.slice(start, end).map((event) => event.id);
+      const selectedEventIds = eventIds.slice(start, end);

      return set({
        selectedEvents: new Set([...selectedEvents, ...selectedEventIds]),
@@ -3,7 +3,7 @@ import { useTableNav } from '@table-nav/react';
 import { ColumnDef, getCoreRowModel, useReactTable } from '@tanstack/react-table';
 import { isOntimeEvent, MaybeString, OntimeEntry, OntimeEvent, TimeField } from 'ontime-types';

-import { useEventAction } from '../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../common/hooks/useEntryAction';
 import useFollowComponent from '../../../common/hooks/useFollowComponent';
 import { useCuesheetOptions } from '../cuesheet.options';

@@ -24,7 +24,7 @@ interface CuesheetTableProps {
 export default function CuesheetTable(props: CuesheetTableProps) {
  const { data, columns, showModal } = props;

-  const { updateEvent, updateTimer } = useEventAction();
+  const { updateEntry, updateTimer } = useEntryActions();
  const { followSelected, showDelayedTimes, hideTableSeconds } = useCuesheetOptions();
  const { columnVisibility, columnOrder, columnSizing, resetColumnOrder, setColumnVisibility, setColumnSizing } =
    useColumnManager(columns);
@@ -64,11 +64,11 @@ export default function CuesheetTable(props: CuesheetTableProps) {
        }

        if (isCustom) {
-          updateEvent({ id: event.id, custom: { [accessor]: payload } });
+          updateEntry({ id: event.id, custom: { [accessor]: payload } });
          return;
        }

-        updateEvent({ id: event.id, [accessor]: payload });
+        updateEntry({ id: event.id, [accessor]: payload });
      },
      handleUpdateTimer: (eventId: string, field: TimeField, payload) => {
        // the timer element already contains logic to avoid submitting a unchanged value
@@ -2,7 +2,7 @@ import { IoAdd, IoArrowDown, IoArrowUp, IoDuplicateOutline, IoOptions, IoTrash }
 import { MenuDivider, MenuItem, MenuList } from '@chakra-ui/react';
 import { isOntimeEvent, SupportedEvent } from 'ontime-types';

-import { useEventAction } from '../../../../common/hooks/useEventAction';
+import { useEntryActions } from '../../../../common/hooks/useEntryAction';
 import { cloneEvent } from '../../../../common/utils/eventsManager';

 interface CuesheetTableMenuActionsProps {
@@ -13,17 +13,17 @@ interface CuesheetTableMenuActionsProps {

 export default function CuesheetTableMenuActions(props: CuesheetTableMenuActionsProps) {
  const { eventId, entryIndex, showModal } = props;
-  const { addEvent, getEventById, reorderEvent, deleteEvent } = useEventAction();
+  const { addEntry, getEntryById, reorderEntry, deleteEntry } = useEntryActions();

  const handleCloneEvent = () => {
-    const currentEvent = getEventById(eventId);
+    const currentEvent = getEntryById(eventId);
    if (!currentEvent || !isOntimeEvent(currentEvent)) {
      return;
    }

    const newEvent = cloneEvent(currentEvent);
    try {
-      addEvent(newEvent, { after: eventId });
+      addEntry(newEvent, { after: eventId });
    } catch (_error) {
      // we do not handle errors here
    }
@@ -35,10 +35,10 @@ export default function CuesheetTableMenuActions(props: CuesheetTableMenuActions
        Edit ...
      </MenuItem>
      <MenuDivider />
-      <MenuItem icon={<IoAdd />} onClick={() => addEvent({ type: SupportedEvent.Event }, { before: eventId })}>
+      <MenuItem icon={<IoAdd />} onClick={() => addEntry({ type: SupportedEvent.Event }, { before: eventId })}>
        Add event above
      </MenuItem>
-      <MenuItem icon={<IoAdd />} onClick={() => addEvent({ type: SupportedEvent.Event }, { after: eventId })}>
+      <MenuItem icon={<IoAdd />} onClick={() => addEntry({ type: SupportedEvent.Event }, { after: eventId })}>
        Add event below
      </MenuItem>
      <MenuItem icon={<IoDuplicateOutline />} onClick={handleCloneEvent}>
@@ -48,14 +48,14 @@ export default function CuesheetTableMenuActions(props: CuesheetTableMenuActions
      <MenuItem
        isDisabled={entryIndex < 1}
        icon={<IoArrowUp />}
-        onClick={() => reorderEvent(eventId, entryIndex, entryIndex - 1)}
+        onClick={() => reorderEntry(eventId, entryIndex, entryIndex - 1)}
      >
        Move up
      </MenuItem>
-      <MenuItem icon={<IoArrowDown />} onClick={() => reorderEvent(eventId, entryIndex, entryIndex + 1)}>
+      <MenuItem icon={<IoArrowDown />} onClick={() => reorderEntry(eventId, entryIndex, entryIndex + 1)}>
        Move down
      </MenuItem>
-      <MenuItem icon={<IoTrash />} onClick={() => deleteEvent([eventId])}>
+      <MenuItem icon={<IoTrash />} onClick={() => deleteEntry([eventId])}>
        Delete
      </MenuItem>
    </MenuList>
@@ -8,13 +8,13 @@ import {
  addEvent,
  applyDelay,
  batchEditEvents,
-  deleteAllEvents,
+  deleteAllEntries,
  deleteEvent,
  editEvent,
-  reorderEvent,
+  reorderEntry,
  swapEvents,
 } from '../../services/rundown-service/RundownService.js';
-import { getEventWithId, getCurrentRundown } from '../../services/rundown-service/rundownUtils.js';
+import { getEntryWithId, getCurrentRundown } from '../../services/rundown-service/rundownUtils.js';

 export async function rundownGetAll(_req: Request, res: Response<ProjectRundownsList>) {
  const rundown = getCurrentRundown();
@@ -30,7 +30,7 @@ export async function rundownGetById(req: Request, res: Response<OntimeEntry | E
  const { eventId } = req.params;

  try {
-    const event = getEventWithId(eventId);
+    const event = getEntryWithId(eventId);

    if (!event) {
      res.status(404).send({ message: 'Event not found' });
@@ -93,7 +93,7 @@ export async function rundownReorder(req: Request, res: Response<OntimeEntry | E

  try {
    const { eventId, from, to } = req.body;
-    const event = await reorderEvent(eventId, from, to);
+    const event = await reorderEntry(eventId, from, to);
    res.status(200).send(event.newEvent);
  } catch (error) {
    const message = getErrorMessage(error);
@@ -128,7 +128,7 @@ export async function rundownApplyDelay(req: Request, res: Response<MessageRespo

 export async function rundownDelete(_req: Request, res: Response<MessageResponse | ErrorResponse>) {
  try {
-    await deleteAllEvents();
+    await deleteAllEntries();
    res.status(204).send({ message: 'All events deleted' });
  } catch (error) {
    const message = getErrorMessage(error);
@@ -2,7 +2,7 @@ import { EndAction, OntimeEvent, TimerType, isKeyOfType, isOntimeEvent } from 'o
 import { MILLIS_PER_SECOND, maxDuration } from 'ontime-utils';

 import { editEvent } from '../services/rundown-service/RundownService.js';
-import { getEventWithId } from '../services/rundown-service/rundownUtils.js';
+import { getEntryWithId } from '../services/rundown-service/rundownUtils.js';
 import { coerceBoolean, coerceColour, coerceEnum, coerceNumber, coerceString } from '../utils/coerceType.js';
 import { getDataProvider } from '../classes/data-provider/DataProvider.js';

@@ -64,7 +64,7 @@ export function parseProperty(property: string, value: unknown) {
 * @param {Partial<OntimeEvent>} patchEvent
 */
 export function updateEvent(patchEvent: Partial<OntimeEvent> & { id: string }) {
-  const event = getEventWithId(patchEvent?.id ?? '');
+  const event = getEntryWithId(patchEvent?.id ?? '');
  if (!event) {
    throw new Error(`Event with ID ${patchEvent?.id} not found`);
  }
@@ -126,9 +126,9 @@ export async function deleteEvent(eventIds: string[]) {
 }

 /**
- * deletes all events in database
+ * deletes all entries in database
 */
-export async function deleteAllEvents() {
+export async function deleteAllEntries() {
  const scopedMutation = cache.mutateCache(cache.removeAll);
  await scopedMutation({});

@@ -182,12 +182,12 @@ export async function batchEditEvents(ids: string[], data: Partial<OntimeEvent>)
 }

 /**
- * reorders a given event
+ * reorders a given entry
 * @param {string} eventId - ID of event from, for sanity check
 * @param {number} from - index of event from
 * @param {number} to - index of event to
 */
-export async function reorderEvent(eventId: string, from: number, to: number) {
+export async function reorderEntry(eventId: EntryId, from: number, to: number) {
  const scopedMutation = cache.mutateCache(cache.reorder);
  const reorderedItem = await scopedMutation({ eventId, from, to });

@@ -60,9 +60,9 @@ export function getEventAtIndex(eventIndex: number): OntimeEvent | undefined {
 /**
 * returns first event that matches a given ID
 */
-export function getEventWithId(eventId: string): OntimeEntry | undefined {
+export function getEntryWithId(entryId: EntryId): OntimeEntry | undefined {
  const { entries } = getCurrentRundown();
-  return entries[eventId];
+  return entries[entryId];
 }

 /**
@@ -71,7 +71,7 @@ export function getEventWithId(eventId: string): OntimeEntry | undefined {
 export function getFirstPlayable(playableOrder: EntryId[]): PlayableEvent | undefined {
  const firstEventId = playableOrder.at(0);
  if (!firstEventId) return;
-  return getEventWithId(firstEventId) as PlayableEvent | undefined;
+  return getEntryWithId(firstEventId) as PlayableEvent | undefined;
 }

 /**
@@ -84,7 +84,7 @@ export function getNextEventWithCue(targetCue: string, currentEventIndex = 0): O

  for (let i = currentEventIndex; i < playableEventsOrder.length; i++) {
    const eventId = playableEventsOrder[i];
-    const event = getEventWithId(eventId) as PlayableEvent | undefined;
+    const event = getEntryWithId(eventId) as PlayableEvent | undefined;
    if (event?.cue.toLowerCase() === lowerCaseCue) {
      return event;
    }
@@ -114,7 +114,7 @@ export function findPrevious(currentEventId?: string): OntimeEvent | undefined {
    return getFirstPlayable(playableEventsOrder);
  }

-  return getEventWithId(previousEventId) as PlayableEvent | undefined;
+  return getEntryWithId(previousEventId) as PlayableEvent | undefined;
 }

 /**
@@ -140,7 +140,7 @@ export function findNext(currentEventId?: string): PlayableEvent | undefined {
    return getFirstPlayable(playableEventsOrder);
  }

-  return getEventWithId(nextEventId) as PlayableEvent | undefined;
+  return getEntryWithId(nextEventId) as PlayableEvent | undefined;
 }

 export function filterTimedEvents(rundown: Rundown, timedEventOrder: EntryId[]): OntimeEvent[] {
@@ -30,7 +30,7 @@ import {
  findPrevious,
  getEventAtIndex,
  getNextEventWithCue,
-  getEventWithId,
+  getEntryWithId,
  getCurrentRundown,
  getTimedEvents,
  getRundownData,
@@ -258,7 +258,7 @@ class RuntimeService {
    if (safeOption || eventInMemory) {
      if (state.eventNow !== null) {
        // load stuff again, but keep running if our events still exist
-        const eventNow = getEventWithId(state.eventNow.id);
+        const eventNow = getEntryWithId(state.eventNow.id);
        if (!isOntimeEvent(eventNow) || !isPlayableEvent(eventNow)) {
          // maybe the event was deleted or the skip state was changed
          runtimeState.stop();
@@ -323,7 +323,7 @@ class RuntimeService {
   */
  @broadcastResult
  public startById(eventId: string): boolean {
-    const event = getEventWithId(eventId);
+    const event = getEntryWithId(eventId);
    if (!event || !isOntimeEvent(event)) {
      return false;
    }
@@ -377,7 +377,7 @@ class RuntimeService {
   */
  @broadcastResult
  public loadById(eventId: string): boolean {
-    const event = getEventWithId(eventId);
+    const event = getEntryWithId(eventId);
    if (!event || !isOntimeEvent(event)) {
      return false;
    }
@@ -654,7 +654,7 @@ class RuntimeService {

    // the db would have to change for the event not to exist
    // we do not know the reason for the crash, so we check anyway
-    const event = getEventWithId(selectedEventId);
+    const event = getEntryWithId(selectedEventId);
    if (!isOntimeEvent(event) || !isPlayableEvent(event)) {
      return;
    }