refactor: use branded types in runtimestate

* 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

apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getontime/cli",
-  "version": "4.10.0",
+  "version": "4.11.0",
   "author": "Carlos Valente",
   "description": "Time keeping for live events",
   "repository": "https://github.com/cpvalente/ontime",

apps/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ontime-ui",
-  "version": "4.10.0",
+  "version": "4.11.0",
   "private": true,
   "type": "module",
   "dependencies": {

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

@@ -6,6 +6,7 @@ import {
   ProjectRundownsList,
   RenumberCues,
   Rundown,
+  RundownImportPayload,
   TransientEventPayload,
 } from 'ontime-types';
 
@@ -82,6 +83,15 @@ export async function deleteRundown(rundownId: RundownId): Promise<AxiosResponse
   return axios.delete(`${rundownPath}/${rundownId}`);
 }
 
+/**
+ * HTTP request to apply an imported rundown using a merge strategy or into a new rundown
+ */
+export async function importRundownWithOptions(
+  payload: RundownImportPayload,
+): Promise<AxiosResponse<ProjectRundownsList>> {
+  return axios.post(`${rundownPath}/import`, payload);
+}
+
 // #endregion operations on project rundowns ======================
 // #region operations on rundown entries ==========================
 

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

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

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

@@ -1,7 +1,6 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import {
   EntryId,
-  InsertOptions,
   MaybeString,
   OntimeDelay,
   OntimeEntry,
@@ -60,9 +59,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 +125,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 +154,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 +199,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 +211,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 +290,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) {
@@ -1057,7 +1063,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;

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

@@ -139,6 +139,17 @@ export const setEventPlayback = {
   pause: () => sendSocket('pause', undefined),
 };
 
+export const useTimerProgress = createSelector((state: RuntimeStore) => ({
+  playback: state.timer.playback,
+  phase: state.timer.phase,
+  addedTime: state.timer.addedTime,
+  secondaryTimer: state.timer.secondaryTimer,
+  current: state.timer.current,
+  expectedFinish: state.timer.expectedFinish,
+  startedAt: state.timer.startedAt,
+  isCountToEnd: state.eventNow?.countToEnd ?? false,
+}));
+
 export const useTimer = createSelector((state: RuntimeStore) => ({
   ...state.timer,
 }));

apps/client/src/common/utils/__tests__/uploadUtils.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { removeFileExtension } from '../uploadUtils';
+
+describe('removeFileExtension()', () => {
+  it('removes a trailing extension', () => {
+    expect(removeFileExtension('show.xlsx')).toBe('show');
+  });
+
+  it('only removes the last extension', () => {
+    expect(removeFileExtension('my.show.xlsx')).toBe('my.show');
+  });
+
+  it('returns the name unchanged when there is no extension', () => {
+    expect(removeFileExtension('rundown')).toBe('rundown');
+  });
+
+  it('does not treat a leading dot as an extension', () => {
+    expect(removeFileExtension('.gitignore')).toBe('.gitignore');
+  });
+
+  it('handles an empty string', () => {
+    expect(removeFileExtension('')).toBe('');
+  });
+});

apps/client/src/common/utils/time.ts

@@ -3,7 +3,9 @@ import {
   MILLIS_PER_HOUR,
   MILLIS_PER_MINUTE,
   MILLIS_PER_SECOND,
+  dayInMs,
   formatFromMillis,
+  getExpectedEnd,
   getExpectedStart,
 } from 'ontime-utils';
 
@@ -29,6 +31,11 @@ export function nowInMillis(): number {
   return elapsed;
 }
 
+export function normaliseWallClock(time: number): number {
+  const timeOfDay = time % dayInMs;
+  return timeOfDay < 0 ? timeOfDay + dayInMs : timeOfDay;
+}
+
 /**
  * @description Resolves format from url and store
  * @return {string|null} A format string like "hh:mm:ss a" or null
@@ -180,15 +187,13 @@ export function getExpectedTimesFromExtendedEvent(
       ...state,
     },
   );
-
+  const expectedEnd = getExpectedEnd(event, expectedStart, state.currentDay);
   const plannedEnd = event.timeStart + event.duration + event.delay;
 
   return {
     expectedStart,
     timeToStart: expectedStart - state.clock,
-    expectedEnd: event.countToEnd
+    expectedEnd,
-      ? Math.max(expectedStart + event.duration, plannedEnd)
-      : expectedStart + event.duration,
     plannedEnd,
   };
 }

apps/client/src/common/utils/uploadUtils.ts

@@ -38,6 +38,18 @@ export function validateProjectFile(file: File) {
   }
 }
 
+/**
+ * Removes a trailing file extension from a file name (e.g. "show.xlsx" -> "show")
+ * A leading dot (dotfiles like ".gitignore") is not treated as an extension
+ */
+export function removeFileExtension(fileName: string): string {
+  const lastDot = fileName.lastIndexOf('.');
+  if (lastDot <= 0) {
+    return fileName;
+  }
+  return fileName.slice(0, lastDot);
+}
+
 export function isExcelFile(file: File | null) {
   return file?.name.endsWith('.xlsx');
 }

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

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

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

@@ -1,4 +1,6 @@
 import type {
+  ImportedFields,
+  RundownImportMode,
   SpreadsheetPreviewResponse,
   SpreadsheetWorksheetMetadata,
   SpreadsheetWorksheetOptions,
@@ -6,6 +8,7 @@ import type {
 import { getErrorMessage, ImportMap } from 'ontime-utils';
 import { ChangeEvent, useCallback, useRef, useState } from 'react';
 import { IoCloudOutline, IoDownloadOutline } from 'react-icons/io5';
+import { useNavigate } from 'react-router';
 
 import {
   getWorksheetMetadata as getExcelWorksheetMetadata,
@@ -22,7 +25,7 @@ import Info from '../../../../../common/components/info/Info';
 import ExternalLink from '../../../../../common/components/link/external-link/ExternalLink';
 import Modal from '../../../../../common/components/modal/Modal';
 import useRundown from '../../../../../common/hooks-query/useRundown';
-import { validateExcelImport } from '../../../../../common/utils/uploadUtils';
+import { removeFileExtension, validateExcelImport } from '../../../../../common/utils/uploadUtils';
 import * as Panel from '../../../panel-utils/PanelUtils';
 import GSheetSetup from './GSheetSetup';
 import SheetImportEditor from './sheet-import/SheetImportEditor';
@@ -35,6 +38,7 @@ const googleSheetDocsUrl = 'https://docs.getontime.no/features/import-spreadshee
 type ActiveSource =
   | {
       kind: 'excel';
+      fileName: string;
       worksheetNames: string[];
       initialWorksheetMetadata: SpreadsheetWorksheetMetadata | null;
       closedByUser: boolean;
@@ -53,9 +57,11 @@ export default function SourcesPanel() {
   const [error, setError] = useState('');
   const [hasFile, setHasFile] = useState<'none' | 'loading' | 'done'>('none');
   const [activeSource, setActiveSource] = useState<ActiveSource | null>(null);
+  const [completedRundownTitle, setCompletedRundownTitle] = useState('');
 
   const { data: currentRundown } = useRundown();
-  const { importRundown } = useSpreadsheetImport();
+  const { applyImport } = useSpreadsheetImport();
+  const navigate = useNavigate();
 
   const fileInputRef = useRef<HTMLInputElement>(null);
 
@@ -74,6 +80,7 @@ export default function SourcesPanel() {
       const worksheetOptions = await uploadExcel(fileToUpload);
       setActiveSource({
         kind: 'excel',
+        fileName: fileToUpload.name,
         worksheetNames: worksheetOptions.worksheets,
         initialWorksheetMetadata: worksheetOptions.metadata,
         closedByUser: false,
@@ -97,6 +104,7 @@ export default function SourcesPanel() {
     setHasFile('none');
     setActiveSource(null);
     setError('');
+    setCompletedRundownTitle('');
   };
 
   const openGSheetFlow = () => {
@@ -119,29 +127,41 @@ export default function SourcesPanel() {
     }
   };
 
-  const handleFinished = () => {
+  const handleFinished = (rundownTitle: string) => {
     setImportFlow('finished');
     setHasFile('none');
     setActiveSource(null);
     setError('');
+    setCompletedRundownTitle(rundownTitle);
   };
 
-  const handleApplyImport = async (preview: SpreadsheetPreviewResponse) => {
+  const handleApplyImport = async (
+    preview: SpreadsheetPreviewResponse,
+    mode: RundownImportMode,
+    newRundownTitle: string,
+    providedFields: ImportedFields,
+  ) => {
+    if (mode === 'new') {
+      const title = newRundownTitle.trim() || preview.rundown.title;
+      await applyImport({ mode: 'new', rundown: { ...preview.rundown, title }, customFields: preview.customFields });
+      handleFinished(title);
+      return;
+    }
+
     if (!currentRundown) {
       throw new Error('No current rundown loaded');
     }
 
-    await importRundown(
+    // override or merge into the current rundown; merge uses providedFields to know which columns
-      {
+    // the sheet supplied so matched events keep the rest (e.g. automations)
-        [currentRundown.id]: {
+    await applyImport({
-          ...preview.rundown,
+      mode,
-          id: currentRundown.id,
+      targetRundownId: currentRundown.id,
-          title: currentRundown.title,
+      rundown: preview.rundown,
-        },
+      customFields: preview.customFields,
-      },
+      providedFields,
-      preview.customFields,
+    });
-    );
+    handleFinished(currentRundown.title);
-    handleFinished();
   };
 
   const loadWorksheetMetadata = useCallback(
@@ -208,6 +228,13 @@ export default function SourcesPanel() {
     if (activeSource.kind === 'excel') return 'excel';
     return `gsheet:${activeSource.sheetId}`;
   })();
+  // suggested name when importing into a new rundown: the spreadsheet file name (without extension)
+  // for Excel, or the document title for Google Sheets
+  const spreadsheetName = (() => {
+    if (!activeSource) return '';
+    if (activeSource.kind === 'excel') return removeFileExtension(activeSource.fileName);
+    return activeSource.title;
+  })();
 
   return (
     <Panel.Section>
@@ -267,11 +294,20 @@ export default function SourcesPanel() {
         {showCompleted && (
           <div className={style.finishSection}>
             <span className={style.finishBadge}>Import complete</span>
-            <div className={style.finishTitle}>Spreadsheet data applied.</div>
+            <div className={style.finishTitle}>
-            <div className={style.finishDescription}>You can close this flow or start another import.</div>
+              Spreadsheet data applied to {completedRundownTitle || 'your rundown'}.
-            <Button variant='subtle-white' onClick={resetFlow}>
+            </div>
-              Reset flow
+            <div className={style.finishDescription}>
-            </Button>
+              Review the imported rundown in the editor or start another import.
+            </div>
+            <div className={style.finishActions}>
+              <Button variant='primary' onClick={() => navigate('/editor')}>
+                Open editor
+              </Button>
+              <Button variant='subtle-white' onClick={resetFlow}>
+                Import another
+              </Button>
+            </div>
           </div>
         )}
         {isGSheetFlow && (
@@ -287,6 +323,7 @@ export default function SourcesPanel() {
           bodyElements={
             <SheetImportEditor
               sourceKey={sourceKey ?? 'spreadsheet'}
+              defaultRundownName={spreadsheetName}
               worksheetNames={activeSource?.worksheetNames ?? []}
               initialMetadata={activeSource?.initialWorksheetMetadata ?? null}
               loadMetadata={loadWorksheetMetadata}

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

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

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

@@ -33,6 +33,11 @@
   white-space: nowrap;
 }
 
+.importModeTrigger {
+  min-width: 12rem;
+  justify-content: space-between;
+}
+
 .addColumnTrigger {
   justify-content: center;
   white-space: nowrap;
@@ -87,6 +92,10 @@
   font-weight: 600;
 }
 
+.toolbarWarning {
+  color: $orange-400;
+}
+
 .mappingPaneTitle {
   align-self: center;
 }

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

@@ -1,10 +1,20 @@
-import type { SpreadsheetPreviewResponse, SpreadsheetWorksheetMetadata } from 'ontime-types';
+import type {
+  ImportedFields,
+  RundownImportMode,
+  SpreadsheetPreviewResponse,
+  SpreadsheetWorksheetMetadata,
+} from 'ontime-types';
 import type { ImportMap } from 'ontime-utils';
-import { IoArrowUpOutline, IoEye } from 'react-icons/io5';
+import { useMemo } from 'react';
+import { IoArrowUpOutline, IoCheckmark, IoChevronDown, IoEye, IoWarningOutline } from 'react-icons/io5';
 
 import Button from '../../../../../../common/components/buttons/Button';
+import { DropdownMenu, DropdownMenuOption } from '../../../../../../common/components/dropdown-menu/DropdownMenu';
+import Input from '../../../../../../common/components/input/input/Input';
 import Select from '../../../../../../common/components/select/Select';
 import * as Panel from '../../../../panel-utils/PanelUtils';
+import ApplyImportButton from './ApplyImportButton';
+import { isIdColumnMapped } from './importMapUtils';
 import PreviewTable from './preview/PreviewTable';
 import SheetImportMappingPane from './SheetImportMappingPane';
 import { useSheetImportForm } from './useSheetImportForm';
@@ -13,17 +23,46 @@ import style from './SheetImportEditor.module.scss';
 
 interface SheetImportEditorProps {
   sourceKey: string;
+  defaultRundownName: string;
   worksheetNames: string[];
   initialMetadata: SpreadsheetWorksheetMetadata | null;
   loadMetadata: (worksheet: string) => Promise<SpreadsheetWorksheetMetadata>;
   previewImport: (importMap: ImportMap) => Promise<SpreadsheetPreviewResponse>;
-  onApply: (preview: SpreadsheetPreviewResponse) => Promise<void>;
+  onApply: (
+    preview: SpreadsheetPreviewResponse,
+    mode: RundownImportMode,
+    newRundownTitle: string,
+    providedFields: ImportedFields,
+  ) => Promise<void>;
   onCancel: () => void;
   onExport?: (importMap: ImportMap) => Promise<void>;
 }
 
+const importModeOptions: Array<{
+  value: RundownImportMode;
+  label: string;
+  description: string;
+}> = [
+  {
+    value: 'override',
+    label: 'Replace current rundown',
+    description: 'Spreadsheet data completely replaces current rundown',
+  },
+  {
+    value: 'merge',
+    label: 'Merge with current rundown',
+    description: 'Merge entries referencing their IDs, entries not present in spreadsheet rundown are deleted',
+  },
+  {
+    value: 'new',
+    label: 'New rundown',
+    description: 'Create a new rundown to import the data into. Loads the new rundown',
+  },
+];
+
 export default function SheetImportEditor({
   sourceKey,
+  defaultRundownName,
   worksheetNames,
   initialMetadata,
   loadMetadata,
@@ -49,11 +88,16 @@ export default function SheetImportEditor({
     isBusy,
     canPreview,
     displayError,
+    importMode,
+    setImportMode,
+    newRundownTitle,
+    setNewRundownTitle,
     handlePreviewSubmit,
     handleExportSubmit,
     handleApply,
   } = useSheetImportForm({
     sourceKey,
+    defaultRundownName,
     worksheetNames,
     initialMetadata,
     loadMetadata,
@@ -62,6 +106,19 @@ export default function SheetImportEditor({
     onExport,
   });
 
+  const selectedImportMode = importModeOptions.find((option) => option.value === importMode) ?? importModeOptions[0];
+  const importModeItems = useMemo<DropdownMenuOption[]>(
+    () =>
+      importModeOptions.map((option) => ({
+        type: 'item',
+        label: option.label,
+        description: option.description,
+        icon: importMode === option.value ? IoCheckmark : undefined,
+        onClick: () => setImportMode(option.value),
+      })),
+    [importMode, setImportMode],
+  );
+
   return (
     <Panel.Section as='form' id='spreadsheet-import-workspace' className={style.editor} onSubmit={handlePreviewSubmit}>
       <Panel.InlineElements align='apart' wrap='wrap' className={style.editorToolbar}>
@@ -75,7 +132,16 @@ export default function SheetImportEditor({
             }
           />
         </label>
-        {toolbarStatus && <Panel.Description>{toolbarStatus}</Panel.Description>}
+        {toolbarStatus && (
+          <Panel.Description>
+            {toolbarStatus.entries === '–'
+              ? 'No import preview yet'
+              : `${toolbarStatus.entries} entries · ${toolbarStatus.groups} groups · ${toolbarStatus.milestones} milestones · ${toolbarStatus.start}–${toolbarStatus.end} · ${toolbarStatus.duration}`}
+            {toolbarStatus.warnings > 0 && (
+              <span className={style.toolbarWarning}> · {toolbarStatus.warnings} warnings</span>
+            )}
+          </Panel.Description>
+        )}
       </Panel.InlineElements>
 
       <div className={style.editorBody}>
@@ -93,13 +159,19 @@ export default function SheetImportEditor({
 
         <section className={style.previewPane}>
           <div className={style.previewPaneHeader}>
-            <span className={style.previewPaneTitle}>Import preview</span>
+            <div className={style.previewPaneHeading}>
+              <span className={style.previewPaneTitle}>Import preview</span>
+            </div>
           </div>
           <div className={style.tableShell}>
             <PreviewTable
               preview={state.preview}
               columnLabels={columnLabels}
+              canRefresh={canPreview}
               isLoadingMetadata={isLoadingMetadata}
+              isRefreshing={state.loading === 'preview'}
+              needsPreviewRefresh={state.needsPreviewRefresh}
+              onRefresh={handlePreviewSubmit}
               worksheetHeaders={worksheetHeaders}
             />
           </div>
@@ -107,33 +179,63 @@ export default function SheetImportEditor({
       </div>
 
       {displayError && <Panel.Error>{displayError}</Panel.Error>}
-      <Panel.InlineElements align='end' wrap='wrap' className={style.editorFooter}>
+      {importMode === 'merge' && !isIdColumnMapped(values) && (
-        <Button onClick={onCancel} disabled={isBusy}>
+        <Panel.Description tone='warning'>
-          Cancel
+          <IoWarningOutline /> No ID column mapped — merge matches entries by ID, so it will behave like Replace. Export
-        </Button>
+          your rundown to a spreadsheet first to keep its IDs.
-        {onExport && (
+        </Panel.Description>
-          <Button onClick={handleExportSubmit} disabled={!canPreview} loading={state.loading === 'export'}>
+      )}
-            <IoArrowUpOutline />
+      <Panel.InlineElements align='apart' wrap='wrap' className={style.editorFooter}>
-            Export
+        <Panel.InlineElements wrap='wrap'>
+          <label className={style.worksheetControl}>
+            <span className={style.worksheetLabel}>Import mode</span>
+            <DropdownMenu
+              render={<Button className={style.importModeTrigger} variant='subtle-white' />}
+              items={importModeItems}
+            >
+              {selectedImportMode.label}
+              <IoChevronDown />
+            </DropdownMenu>
+          </label>
+          {importMode === 'new' && (
+            <label className={style.worksheetControl}>
+              <span className={style.worksheetLabel}>New rundown name</span>
+              <Input
+                value={newRundownTitle}
+                onChange={(event) => setNewRundownTitle(event.target.value)}
+                placeholder={state.preview?.rundown.title || 'Imported rundown'}
+                aria-label='New rundown name'
+              />
+            </label>
+          )}
+        </Panel.InlineElements>
+        <Panel.InlineElements wrap='wrap'>
+          <Button onClick={onCancel} disabled={isBusy}>
+            Cancel
           </Button>
-        )}
+          {onExport && (
-        <Button
+            <Button onClick={handleExportSubmit} disabled={!canPreview} loading={state.loading === 'export'}>
-          variant={state.preview ? undefined : 'primary'}
+              <IoArrowUpOutline />
-          onClick={handlePreviewSubmit}
+              Export
-          disabled={!canPreview}
+            </Button>
-          loading={state.loading === 'preview'}
+          )}
-        >
+          <Button
-          <IoEye />
+            variant={state.preview ? undefined : 'primary'}
-          Preview import
+            onClick={handlePreviewSubmit}
-        </Button>
+            disabled={!canPreview}
-        <Button
+            loading={state.loading === 'preview'}
-          variant='primary'
+          >
-          onClick={handleApply}
+            <IoEye />
-          disabled={!state.preview || isBusy}
+            Preview import
-          loading={state.loading === 'apply'}
+          </Button>
-        >
+          <ApplyImportButton
-          Apply import
+            preview={state.preview}
-        </Button>
+            mode={importMode}
+            disabled={!state.preview || isBusy}
+            loading={state.loading === 'apply'}
+            onApply={handleApply}
+          />
+        </Panel.InlineElements>
       </Panel.InlineElements>
     </Panel.Section>
   );

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/sheet-import/__tests__/importMapUtils.test.ts

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

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

@@ -1,3 +1,4 @@
+import type { ImportedFields, RundownImportMode } from 'ontime-types';
 import type { ImportMap } from 'ontime-utils';
 
 import { makeStageKey } from '../../../../../../common/utils/localStorage';
@@ -49,6 +50,16 @@ export function createDefaultFormValues(): ImportFormValues {
   };
 }
 
+/**
+ * Whether the mapping supplies an ID column. Merge matches entries by ID, so without one every
+ * imported entry gets a fresh id and nothing can reconcile with the current rundown.
+ */
+export function isIdColumnMapped(values: ImportFormValues): boolean {
+  const idIndex = builtInFieldDefs.findIndex((def) => def.importKey === 'id');
+  const field = values.builtIn[idIndex];
+  return Boolean(field?.enabled && field.header.trim());
+}
+
 function sanitiseOntimeCustomFieldLabel(importName: string): string {
   // Replace punctuation with spaces, then collapse repeated whitespace into single spaces.
   const sanitised = importName
@@ -81,6 +92,24 @@ export function getResolvedCustomFields(customFields: ImportFormValues['custom']
   });
 }
 
+/**
+ * Returns the fields the import map supplies — the complete description of what the incoming data
+ * provides, for both built-in and custom fields. A merge uses this to patch exactly these fields
+ * onto a matched event and keep everything else (e.g. automations) untouched.
+ * Import-map keys are OntimeEvent field names; `worksheet`/`custom` are meta and `id` is only used
+ * for matching, not overwritten.
+ */
+export function getProvidedImportFields(importMap: ImportMap): ImportedFields {
+  const event: string[] = [];
+  for (const [key, value] of Object.entries(importMap)) {
+    if (key === 'worksheet' || key === 'custom' || key === 'id') continue;
+    if (typeof value === 'string' && value.trim() !== '') {
+      event.push(key);
+    }
+  }
+  return { event, custom: Object.keys(importMap.custom) };
+}
+
 export function convertToImportMap(values: ImportFormValues): ImportMap {
   const custom = getResolvedCustomFields(values.custom).reduce<Record<string, string>>(
     (accumulator, { ontimeName, importName }) => {
@@ -130,12 +159,12 @@ function isPersistedFormValues(obj: unknown): obj is ImportFormValues {
 export function getPersistedImportState(sourceKey: string): { values: ImportFormValues; isPersisted: boolean } {
   const storageKey = getImportMapKey(sourceKey);
   try {
-    const raw = localStorage.getItem(storageKey);
+    const persistedData = localStorage.getItem(storageKey);
-    if (!raw) {
+    if (!persistedData) {
       return { values: createDefaultFormValues(), isPersisted: false };
     }
 
-    const parsed: unknown = JSON.parse(raw);
+    const parsed: unknown = JSON.parse(persistedData);
     if (isPersistedFormValues(parsed)) {
       return { values: parsed, isPersisted: true };
     }
@@ -150,6 +179,32 @@ export function getPersistedImportState(sourceKey: string): { values: ImportForm
   }
 }
 
+/**
+ * The import mode (new / merge / override) is persisted separately from the field mapping
+ * so the mapping schema guard stays untouched.
+ */
+
+/** Default import mode: replace matched elements in the current rundown */
+export const defaultImportMode: RundownImportMode = 'override';
+
+function getImportModeKey(sourceKey: string) {
+  return makeStageKey(`import-mode:${sourceKey}`);
+}
+
+/** Persists the import mode for a given source */
+export function persistImportMode(sourceKey: string, mode: RundownImportMode) {
+  localStorage.setItem(getImportModeKey(sourceKey), mode);
+}
+
+/** Reads the persisted import mode for a source, falling back to the default when absent or invalid */
+export function getPersistedImportMode(sourceKey: string): RundownImportMode {
+  const persisted = localStorage.getItem(getImportModeKey(sourceKey));
+  if (persisted === 'new' || persisted === 'merge' || persisted === 'override') {
+    return persisted;
+  }
+  return defaultImportMode;
+}
+
 /**
  * Validates import mappings and generates warnings for duplicate or missing spreadsheet columns.
  */

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

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

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

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

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

@@ -1,7 +1,13 @@
 import { useQuery, useQueryClient } from '@tanstack/react-query';
-import type { SpreadsheetPreviewResponse, SpreadsheetWorksheetMetadata } from 'ontime-types';
+import type {
-import { millisToString } from 'ontime-utils';
+  ImportedFields,
-import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
+  RundownImportMode,
+  SpreadsheetPreviewResponse,
+  SpreadsheetWorksheetMetadata,
+} from 'ontime-types';
+import { isOntimeGroup, isOntimeMilestone } from 'ontime-types';
+import { millisToString, removeTrailingZero } from 'ontime-utils';
+import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react';
 import { useFieldArray, useForm } from 'react-hook-form';
 
 import { maybeAxiosError } from '../../../../../../common/api/utils';
@@ -11,8 +17,11 @@ import {
   builtInFieldDefs,
   convertToImportMap,
   getImportWarnings,
+  getPersistedImportMode,
   getPersistedImportState,
+  getProvidedImportFields,
   getResolvedCustomFields,
+  persistImportMode,
   persistImportState,
 } from './importMapUtils';
 import { deriveHeaderOptionsState } from './spreadsheetImportUtils';
@@ -24,7 +33,7 @@ type ImportAction =
   | { type: 'previewSuccess'; preview: SpreadsheetPreviewResponse }
   | { type: 'applySuccess' }
   | { type: 'exportSuccess' }
-  | { type: 'clearPreview'; error?: string }
+  | { type: 'clearPreview'; error?: string; needsRefresh?: boolean }
   | { type: 'failure'; error: string }
   | { type: 'reset' };
 
@@ -32,12 +41,14 @@ type ImportState = {
   loading: '' | 'preview' | 'apply' | 'export';
   error: string;
   preview: SpreadsheetPreviewResponse | null;
+  needsPreviewRefresh: boolean;
 };
 
 const initialImportState: ImportState = {
   loading: '',
   error: '',
   preview: null,
+  needsPreviewRefresh: false,
 };
 
 function importReducer(state: ImportState, action: ImportAction): ImportState {
@@ -49,15 +60,15 @@ function importReducer(state: ImportState, action: ImportAction): ImportState {
     case 'startExport':
       return { ...state, loading: 'export', error: '' };
     case 'previewSuccess':
-      return { loading: '', error: '', preview: action.preview };
+      return { loading: '', error: '', preview: action.preview, needsPreviewRefresh: false };
     case 'applySuccess':
     case 'exportSuccess':
       return { ...state, loading: '' };
     case 'clearPreview':
-      return { ...state, error: action.error ?? '', preview: null };
+      return { ...state, error: action.error ?? '', preview: null, needsPreviewRefresh: action.needsRefresh ?? false };
     case 'failure': {
       if (state.loading === 'preview') {
-        return { loading: '', error: action.error, preview: null };
+        return { loading: '', error: action.error, preview: null, needsPreviewRefresh: false };
       }
       return { ...state, loading: '', error: action.error };
     }
@@ -100,16 +111,23 @@ function buildColumnLabels(values: ImportFormValues): string[] {
 
 interface UseSheetImportFormProps {
   sourceKey: string;
+  defaultRundownName: string;
   worksheetNames: string[];
   initialMetadata: SpreadsheetWorksheetMetadata | null;
   loadMetadata: (worksheet: string) => Promise<SpreadsheetWorksheetMetadata>;
   previewImport: (importMap: ReturnType<typeof convertToImportMap>) => Promise<SpreadsheetPreviewResponse>;
-  onApply: (preview: SpreadsheetPreviewResponse) => Promise<void>;
+  onApply: (
+    preview: SpreadsheetPreviewResponse,
+    mode: RundownImportMode,
+    newRundownTitle: string,
+    providedFields: ImportedFields,
+  ) => Promise<void>;
   onExport?: (importMap: ReturnType<typeof convertToImportMap>) => Promise<void>;
 }
 
 export function useSheetImportForm({
   sourceKey,
+  defaultRundownName,
   worksheetNames,
   initialMetadata,
   loadMetadata,
@@ -170,6 +188,8 @@ export function useSheetImportForm({
   const columnLabels = buildColumnLabels(values);
 
   const [state, dispatch] = useReducer(importReducer, initialImportState);
+  const [importMode, setImportMode] = useState<RundownImportMode>(() => getPersistedImportMode(sourceKey));
+  const [newRundownTitle, setNewRundownTitle] = useState(defaultRundownName);
   const warnings = getImportWarnings(values, headers);
   const warningCount = Object.values(warnings).filter(Boolean).length;
   const previewRef = useRef<SpreadsheetPreviewResponse | null>(null);
@@ -182,6 +202,12 @@ export function useSheetImportForm({
     dispatch({ type: 'reset' });
   }, [initialFormValues, reset]);
 
+  // Update import mode and rundown name if the source changes
+  useEffect(() => {
+    setImportMode(getPersistedImportMode(sourceKey));
+    setNewRundownTitle(defaultRundownName);
+  }, [sourceKey, defaultRundownName]);
+
   // Keep the worksheet selection valid if the available worksheets change underneath the form.
   useEffect(() => {
     if (worksheetNames.length === 0) return;
@@ -198,7 +224,7 @@ export function useSheetImportForm({
     const sub = watch(() => {
       if (!previewRef.current) return;
       previewRef.current = null;
-      dispatch({ type: 'clearPreview' });
+      dispatch({ type: 'clearPreview', needsRefresh: true });
     });
     return () => sub.unsubscribe();
   }, [watch]);
@@ -241,13 +267,15 @@ export function useSheetImportForm({
 
     try {
       dispatch({ type: 'startApply' });
-      await onApply(state.preview);
+      const providedFields = getProvidedImportFields(convertToImportMap(getValues()));
+      await onApply(state.preview, importMode, newRundownTitle, providedFields);
       persistImportState(sourceKey, getValues());
+      persistImportMode(sourceKey, importMode);
       dispatch({ type: 'applySuccess' });
     } catch (error) {
       dispatch({ type: 'failure', error: maybeAxiosError(error) });
     }
-  }, [getValues, onApply, sourceKey, state.preview]);
+  }, [getValues, importMode, newRundownTitle, onApply, sourceKey, state.preview]);
 
   const handleExport = useCallback(
     async (formValues: ImportFormValues) => {
@@ -272,15 +300,37 @@ export function useSheetImportForm({
   }, [append]);
 
   const toolbarStatus = (() => {
-    const warningText = warningCount > 0 ? ` | warnings: ${warningCount}` : '';
-
     if (!state.preview) {
-      return `entries: – | start: – | end: – | duration: –${warningText}`;
+      return {
+        entries: '–',
+        groups: '–',
+        milestones: '–',
+        start: '–',
+        end: '–',
+        duration: '–',
+        warnings: warningCount,
+      };
     }
 
-    const { flatOrder } = state.preview.rundown;
+    const { entries, flatOrder } = state.preview.rundown;
     const { start, end, duration } = state.preview.summary;
-    return `entries: ${flatOrder.length} | start: ${millisToString(start)} | end: ${millisToString(end)} | duration: ${formatDuration(duration)}${warningText}`;
+    let groups = 0;
+    let milestones = 0;
+    for (const entryId of flatOrder) {
+      const entry = entries[entryId];
+      if (isOntimeGroup(entry)) groups++;
+      else if (isOntimeMilestone(entry)) milestones++;
+    }
+
+    return {
+      entries: flatOrder.length,
+      groups,
+      milestones,
+      start: removeTrailingZero(millisToString(start)),
+      end: removeTrailingZero(millisToString(end)),
+      duration: formatDuration(duration),
+      warnings: warningCount,
+    };
   })();
 
   return {
@@ -300,6 +350,10 @@ export function useSheetImportForm({
     isBusy,
     canPreview,
     displayError,
+    importMode,
+    setImportMode,
+    newRundownTitle,
+    setNewRundownTitle,
     handlePreviewSubmit: handleSubmit(handlePreview),
     handleExportSubmit: handleSubmit(handleExport),
     handleApply,

apps/client/src/features/app-settings/panel/manage-panel/sources-panel/useSpreadsheetImport.ts

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

apps/client/src/features/control/playback/playback-timer/PlaybackTimer.module.scss

@@ -73,6 +73,10 @@
   margin-right: 0.25rem;
 }
 
+.tagOvertime {
+  color: $playback-over;
+}
+
 .time {
   color: $section-white;
   font-size: $text-body-size;

apps/client/src/features/control/playback/playback-timer/PlaybackTimer.tsx

@@ -1,12 +1,13 @@
 import { MaybeNumber, Playback, TimerPhase } from 'ontime-types';
-import { dayInMs, millisToString } from 'ontime-utils';
+import { millisToString } from 'ontime-utils';
 import { PropsWithChildren } from 'react';
 
 import AppLink from '../../../../common/components/link/app-link/AppLink';
 import Tooltip from '../../../../common/components/tooltip/Tooltip';
 import useReport from '../../../../common/hooks-query/useReport';
-import { useTimer } from '../../../../common/hooks/useSocket';
+import { useTimerProgress } from '../../../../common/hooks/useSocket';
-import { formatDuration } from '../../../../common/utils/time';
+import { cx } from '../../../../common/utils/styleUtils';
+import { formatDuration, normaliseWallClock } from '../../../../common/utils/time';
 import TimerDisplay from '../timer-display/TimerDisplay';
 
 import style from './PlaybackTimer.module.scss';
@@ -24,15 +25,14 @@ function resolveAddedTimeLabel(addedTime: number) {
 }
 
 export default function PlaybackTimer({ children }: PropsWithChildren) {
-  const timer = useTimer();
+  'use memo';
+  const timer = useTimerProgress();
 
   const isRolling = timer.playback === Playback.Roll;
   const isWaiting = timer.phase === TimerPhase.Pending;
   const isOvertime = timer.phase === TimerPhase.Overtime;
   const hasAddedTime = Boolean(timer.addedTime);
-
   const rollLabel = isRolling ? 'Roll mode active' : '';
-
   const addedTimeLabel = resolveAddedTimeLabel(timer.addedTime);
 
   return (
@@ -51,7 +51,13 @@ export default function PlaybackTimer({ children }: PropsWithChildren) {
         {isWaiting ? (
           <span className={style.rolltag}>Roll: Countdown to start</span>
         ) : (
-          <RunningStatus startedAt={timer.startedAt} expectedFinish={timer.expectedFinish} playback={timer.playback} />
+          <RunningStatus
+            startedAt={timer.startedAt}
+            expectedFinish={timer.expectedFinish}
+            isStopped={timer.playback === Playback.Stop}
+            isCountToEnd={timer.isCountToEnd}
+            isOvertime={isOvertime}
+          />
         )}
       </div>
       {children}
@@ -62,16 +68,18 @@ export default function PlaybackTimer({ children }: PropsWithChildren) {
 interface RunningStatusProps {
   startedAt: MaybeNumber;
   expectedFinish: MaybeNumber;
-  playback: Playback;
+  isStopped: boolean;
+  isCountToEnd: boolean;
+  isOvertime: boolean;
 }
-function RunningStatus({ startedAt, expectedFinish, playback }: RunningStatusProps) {
+
-  if (playback === Playback.Stop) {
+function RunningStatus({ startedAt, expectedFinish, isStopped, isCountToEnd, isOvertime }: RunningStatusProps) {
+  if (isStopped) {
     return <StoppedStatus />;
   }
 
   const started = millisToString(startedAt);
-  const finishedMs = expectedFinish !== null ? expectedFinish % dayInMs : null;
+  const finish = millisToString(expectedFinish === null ? null : normaliseWallClock(expectedFinish));
-  const finish = millisToString(finishedMs);
 
   return (
     <>
@@ -80,7 +88,9 @@ function RunningStatus({ startedAt, expectedFinish, playback }: RunningStatusPro
         <span className={style.time}>{started}</span>
       </span>
       <span className={style.finish}>
-        <span className={style.tag}>Expect end</span>
+        <span className={cx([style.tag, isOvertime && style.tagOvertime])}>
+          {isCountToEnd ? 'Scheduled end' : 'Expected end'}
+        </span>
         <span className={style.time}>{finish}</span>
       </span>
     </>

apps/client/src/features/rundown/Rundown.tsx

@@ -105,12 +105,29 @@ export default function Rundown({ order, flatOrder, entries, id, rundownMetadata
     handleCollapseGroup,
   });
 
+  // Jump to the current element on demand: the running event in Run mode, the edit cursor otherwise.
+  // Scrolls only (no selection change) so jumping to the running event does not hijack the edit cursor.
+  const jumpToCurrent = useCallback(() => {
+    const targetId = editorMode === AppMode.Run ? featureData?.selectedEventId : cursor;
+    if (!targetId) {
+      return;
+    }
+
+    // Open parent group if the target is inside a collapsed group
+    const entry = entries[targetId];
+    if (entry && 'parent' in entry) {
+      expandGroup(entry.parent);
+    }
+    scrollToEntry(targetId);
+  }, [editorMode, featureData?.selectedEventId, cursor, entries, expandGroup, scrollToEntry]);
+
   // Keyboard shortcuts
   useRundownKeyboard({
     cursor,
     commands,
     clearSelectedEvents,
     setEntryCopyId,
+    jumpToCurrent,
   });
 
   // DND handlers
@@ -322,7 +339,9 @@ export default function Rundown({ order, flatOrder, entries, id, rundownMetadata
             increaseViewportBy={{ top: 200, bottom: 400 }}
             style={{ height: '100%' }}
             components={{
-              Header: isEditMode ? () => <QuickAddButtons previousEventId={null} parentGroup={null} /> : undefined,
+              Header: isEditMode
+                ? () => <QuickAddButtons previousEventId={null} nextEventId={order[0]} parentGroup={null} />
+                : undefined,
               Footer: () => (
                 <>
                   {isEditMode && (

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

@@ -44,6 +44,9 @@ function EventEditorEmpty() {
               <Separator />
               <Combo keys={['PgDn']} />
             </Shortcut>
+            <Shortcut label='Jump to current entry'>
+              <Combo keys={[deviceAlt, 'L']} />
+            </Shortcut>
             <Shortcut label='Deselect entry'>
               <Combo keys={['Esc']} />
             </Shortcut>

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

@@ -10,7 +10,7 @@ import Switch from '../../../../common/components/switch/Switch';
 import Tooltip from '../../../../common/components/tooltip/Tooltip';
 import { useEntryActionsContext } from '../../../../common/context/EntryActionsContext';
 import { millisToDelayString } from '../../../../common/utils/dateConfig';
-import { formatTime } from '../../../../common/utils/time';
+import { formatTime, normaliseWallClock } from '../../../../common/utils/time';
 import TimeInputFlow from '../../time-input-flow/TimeInputFlow';
 
 import style from '../EntryEditor.module.scss';
@@ -68,8 +68,10 @@ function EventEditorTimes({
   };
 
   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(timeStart + delay)} → ${formatTime(timeEnd + delay)}`
+    ? `Event is ${millisToDelayString(delay, 'expanded')}. New schedule ${formatTime(delayedStart)} → ${formatTime(delayedEnd)}`
     : '';
 
   return (
@@ -86,7 +88,6 @@ function EventEditorTimes({
               timeStrategy={timeStrategy}
               linkStart={linkStart}
               delay={delay}
-              countToEnd={countToEnd}
               showLabels
             />
           </div>

apps/client/src/features/rundown/entry-editor/quick-add-buttons/QuickAddButtons.tsx

@@ -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,
       },
-      {
+      insertionOptions,
-        after: previousEventId,
-        lastEventId: previousEventId,
-      },
     );
   };
 
   const addDelay = () => {
-    addEntry(
+    addEntry({ type: SupportedEntry.Delay, parent: parentGroup }, insertionOptions);
-      { type: SupportedEntry.Delay, parent: parentGroup },
-      {
-        lastEventId: previousEventId,
-        after: previousEventId,
-      },
-    );
   };
 
   const addMilestone = () => {
-    addEntry(
+    addEntry({ type: SupportedEntry.Milestone, parent: parentGroup }, insertionOptions);
-      { type: SupportedEntry.Milestone, parent: parentGroup },
-      {
-        lastEventId: previousEventId,
-        after: previousEventId,
-      },
-    );
   };
 
   const addGroup = () => {
     if (parentGroup !== null) {
       return;
     }
-    addEntry(
+    addEntry({ type: SupportedEntry.Group }, insertionOptions);
-      { type: SupportedEntry.Group },
-      {
-        lastEventId: previousEventId,
-        after: previousEventId,
-      },
-    );
   };
 
   /**

apps/client/src/features/rundown/hooks/useRundownCommands.ts

@@ -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],

apps/client/src/features/rundown/hooks/useRundownKeyboard.ts

@@ -19,6 +19,7 @@ interface UseRundownKeyboardOptions {
   };
   clearSelectedEvents: () => void;
   setEntryCopyId: (id: EntryId | null, mode?: 'copy' | 'cut') => void;
+  jumpToCurrent: () => void;
 }
 
 /**
@@ -40,6 +41,7 @@ export function useRundownKeyboard({
   commands,
   clearSelectedEvents,
   setEntryCopyId,
+  jumpToCurrent,
 }: UseRundownKeyboardOptions) {
   const scrollToEntry = useEventSelection((state) => state.scrollToEntry);
 
@@ -127,6 +129,8 @@ export function useRundownKeyboard({
       { preventDefault: true, usePhysicalKeys: true },
     ],
 
+    ['alt + L', () => jumpToCurrent(), { preventDefault: true, usePhysicalKeys: true }],
+
     [
       'alt + mod + ArrowDown',
       () => commands.moveEntry(cursor, 'down'),

apps/client/src/features/rundown/rundown-event/RundownEvent.module.scss

@@ -7,6 +7,7 @@ $skip-opacity: 0.2;
   background-color: $block-bg;
   margin-block: 0.25rem;
   overflow: initial;
+  position: relative;
 
   display: grid;
   grid-template-areas:
@@ -16,7 +17,7 @@ $skip-opacity: 0.2;
     'binder pb-actions estatus estatus'
     'binder ...        ...     ...';
 
-  grid-template-columns: $block-binder-width 3rem 1fr 3rem;
+  grid-template-columns: $block-binder-width 3rem minmax(0, 1fr) 3rem;
   grid-template-rows: 0.125rem 2rem 2rem auto 0.125rem;
   align-items: center;
   padding-right: $block-clearance;
@@ -136,6 +137,7 @@ $skip-opacity: 0.2;
   align-items: center;
   gap: $block-clearance;
   height: 100%;
+  min-width: 0;
 }
 
 .eventTimers.editMode:hover {
@@ -155,7 +157,7 @@ $skip-opacity: 0.2;
   align-items: center;
   justify-content: space-between;
 
-  .nextTag {
+  .warningMeta {
     font-size: 1rem;
     color: $orange-500;
     letter-spacing: 0.03px;
@@ -231,6 +233,10 @@ $skip-opacity: 0.2;
     color: var(--status-color-active-override, $active-indicator);
   }
 
+  .statusIcon.countToEndStatus {
+    color: $orange-400;
+  }
+
   .statusIcon.warning {
     color: $orange-500;
   }

apps/client/src/features/rundown/rundown-event/RundownEventInner.tsx

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

apps/client/src/features/rundown/rundown-event/__tests__/rundownEvent.utils.test.ts

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

apps/client/src/features/rundown/rundown-event/rundownEvent.utils.ts

@@ -1,15 +1,16 @@
 import { millisToString, removeTrailingZero } from 'ontime-utils';
 
-import { formatDuration } from '../../../common/utils/time';
+import { formatDuration, normaliseWallClock } from '../../../common/utils/time';
 
 export function formatDelay(timeStart: number, delay: number): string | undefined {
   if (!delay) return;
 
-  const delayedStart = Math.max(0, timeStart + delay);
+  const delayedStart = normaliseWallClock(timeStart + delay);
 
   const timeTag = removeTrailingZero(millisToString(delayedStart));
   return `New start ${timeTag}`;
 }
+
 export function formatGap(gap: number, isNextDay: boolean) {
   if (gap === 0) {
     if (isNextDay) {

apps/client/src/features/rundown/time-input-flow/TimeInputFlow.module.scss

@@ -4,10 +4,15 @@
 
 .timerNote {
   width: 1.25em;
+  flex: 0 0 1.25em;
   color: $blue-500;
   font-size: 1.5em;
 }
 
+.timerNotePlaceholder {
+  visibility: hidden;
+}
+
 .inactive {
   color: $muted-gray;
 }

apps/client/src/features/rundown/time-input-flow/TimeInputFlow.tsx

@@ -14,7 +14,6 @@ import style from './TimeInputFlow.module.scss';
 
 interface TimeInputFlowProps {
   eventId: string;
-  countToEnd: boolean;
   timeStart: number;
   timeEnd: number;
   duration: number;
@@ -22,12 +21,12 @@ interface TimeInputFlowProps {
   linkStart: boolean;
   delay: number;
   showLabels?: boolean;
+  showWarnings?: boolean;
 }
 
 export default memo(TimeInputFlow);
 function TimeInputFlow({
   eventId,
-  countToEnd,
   timeStart,
   timeEnd,
   duration,
@@ -35,6 +34,7 @@ function TimeInputFlow({
   linkStart,
   delay,
   showLabels,
+  showWarnings = true,
 }: TimeInputFlowProps) {
   const { updateEntry, updateTimer } = useEntryActionsContext();
 
@@ -56,10 +56,6 @@ function TimeInputFlow({
     warnings.push('Over midnight');
   }
 
-  if (countToEnd) {
-    warnings.push('Count to End');
-  }
-
   const hasDelay = delay !== 0;
   const isLockedEnd = timeStrategy === TimeStrategy.LockEnd;
   const isLockedDuration = timeStrategy === TimeStrategy.LockDuration;
@@ -136,11 +132,19 @@ function TimeInputFlow({
         </TimeInputGroup>
       </div>
 
-      {warnings.length > 0 && (
+      {showWarnings &&
-        <Tooltip text={warnings.join(' - ')} className={style.timerNote} data-testid='event-warning' render={<span />}>
+        (warnings.length > 0 ? (
-          <IoAlertCircleOutline />
+          <Tooltip
-        </Tooltip>
+            text={warnings.join(' - ')}
-      )}
+            className={style.timerNote}
+            data-testid='event-warning'
+            render={<span />}
+          >
+            <IoAlertCircleOutline />
+          </Tooltip>
+        ) : (
+          <span className={`${style.timerNote} ${style.timerNotePlaceholder}`} aria-hidden='true' />
+        ))}
     </>
   );
 }

apps/client/src/views/countdown/CountdownSubscriptions.tsx

@@ -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 (

apps/client/src/views/countdown/SingleEventCountdown.tsx

@@ -1,17 +1,15 @@
-import { MaybeNumber, OntimeEvent } from 'ontime-types';
+import { getExpectedEnd, getExpectedStart } from 'ontime-utils';
-import { 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) {

apps/client/src/views/countdown/countdown.utils.ts

@@ -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 };
 }

apps/client/src/views/editor/EditorLayoutOptions.tsx

@@ -15,7 +15,7 @@ function EditorLayoutOptions() {
       {
         type: 'item',
         label: 'Planning',
-        description: 'Edit-focused list with planning stats',
+        description: 'Edit focused list with planning stats',
         icon: layoutMode === EditorLayoutMode.PLANNING ? IoCheckmark : undefined,
         onClick: () => setLayoutMode(EditorLayoutMode.PLANNING),
       },

apps/client/src/views/editor/pip-timer/PipTimer.scss

@@ -28,9 +28,9 @@
 
   .timer-container {
     flex: 1;
-    align-content: center;
+    display: flex;
-    justify-self: center;
+    flex-direction: column;
-    align-self: center;
+    justify-content: center;
 
     width: 100%;
     overflow: hidden;

apps/client/src/views/timer/Timer.scss

@@ -82,9 +82,9 @@
 
   .timer-container {
     flex: 1;
-    align-content: center;
+    display: flex;
-    justify-self: center;
+    flex-direction: column;
-    align-self: center;
+    justify-content: center;
 
     width: 100%;
     overflow: hidden;

apps/electron/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ontime-electron",
-  "version": "4.10.0",
+  "version": "4.11.0",
   "author": "Carlos Valente",
   "description": "Time keeping for live events",
   "repository": "https://github.com/cpvalente/ontime",
@@ -125,6 +125,13 @@
           "**/*",
           "*{.ts}"
         ]
+      },
+      {
+        "from": "../server/src/html/",
+        "to": "extraResources/html/",
+        "filter": [
+          "**/*"
+        ]
       }
     ]
   }

apps/resolver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getontime/resolver",
-  "version": "4.10.0",
+  "version": "4.11.0",
   "type": "module",
   "repository": "https://github.com/cpvalente/ontime",
   "types": "./dist/main.d.ts",

apps/server/package.json

@@ -2,7 +2,7 @@
   "name": "ontime-server",
   "type": "module",
   "main": "src/index.ts",
-  "version": "4.10.0",
+  "version": "4.11.0",
   "exports": "./src/index.js",
   "dependencies": {
     "@googleapis/sheets": "^5.0.5",

apps/server/src/api-data/rundown/__tests__/rundown.dao.test.ts

@@ -432,6 +432,40 @@ describe('processRundown()', () => {
     expect(initResult.totalDuration).toBe(500 - 100);
   });
 
+  it('skipped events do not advance day offsets or affect gaps', () => {
+    const rundown = makeRundown({
+      order: ['1', 'skipped', '2'],
+      entries: {
+        '1': makeOntimeEvent({
+          id: '1',
+          timeStart: 22 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE, // 22:30:00
+          timeEnd: 30 * MILLIS_PER_MINUTE, // 00:30:00
+          duration: 2 * MILLIS_PER_HOUR, // 02:00:00
+        }),
+        skipped: makeOntimeEvent({
+          id: 'skipped',
+          skip: true,
+          timeStart: 22 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE, // 22:30:00
+          timeEnd: 30 * MILLIS_PER_MINUTE, // 00:30:00
+          duration: 2 * MILLIS_PER_HOUR, // 02:00:00
+        }),
+        '2': makeOntimeEvent({
+          id: '2',
+          timeStart: 30 * MILLIS_PER_MINUTE, // 00:30:00
+          timeEnd: 8 * MILLIS_PER_HOUR + 30 * MILLIS_PER_MINUTE, // 08:30:00
+          duration: 8 * MILLIS_PER_HOUR, // 08:00:00
+        }),
+      },
+    });
+
+    const initResult = processRundown(rundown, {});
+
+    expect((initResult.entries.skipped as OntimeEvent).dayOffset).toBe(0);
+    expect((initResult.entries.skipped as OntimeEvent).gap).toBe(0);
+    expect((initResult.entries['2'] as OntimeEvent).dayOffset).toBe(1);
+    expect((initResult.entries['2'] as OntimeEvent).gap).toBe(0);
+  });
+
   it('calculates total duration across days with gap', () => {
     const rundown = makeRundown({
       order: ['1', '2', '3'],
@@ -680,17 +714,17 @@ describe('processRundown()', () => {
 });
 
 describe('rundownMutation.add()', () => {
-  test('adds an event an empty rundown', () => {
+  test('adds an event to an empty rundown', () => {
     const mockEvent = makeOntimeEvent({ id: 'mock', cue: 'mock' });
     const rundown = makeRundown({});
 
-    rundownMutation.add(rundown, mockEvent, null, null);
+    rundownMutation.add(rundown, mockEvent, null, null, null);
 
     expect(rundown.order.length).toBe(1);
     expect(rundown.entries['mock']).toMatchObject(mockEvent);
   });
 
-  test('adds an event at the top if no afterId is given', () => {
+  test('adds an event at the end if no afterId is given', () => {
     const mockEvent = makeOntimeEvent({ id: 'mock', cue: 'mock' });
     const rundown = makeRundown({
       flatOrder: ['1'],
@@ -700,28 +734,28 @@ describe('rundownMutation.add()', () => {
       },
     });
 
-    rundownMutation.add(rundown, mockEvent, null, null);
+    rundownMutation.add(rundown, mockEvent, null, null, null);
 
-    expect(rundown.order).toStrictEqual(['mock', '1']);
+    expect(rundown.order).toStrictEqual(['1', 'mock']);
-    expect(rundown.flatOrder).toStrictEqual(['mock', '1']);
+    expect(rundown.flatOrder).toStrictEqual(['1', 'mock']);
     expect(rundown.entries['mock']).toMatchObject(mockEvent);
   });
 
-  test('adds an event at the top of the group if no after is given', () => {
+  test('adds an event at the end of the group if parent is provided but no after', () => {
     const mockEvent = makeOntimeEvent({ id: 'mock', cue: 'mock' });
     const rundown = makeRundown({
       flatOrder: ['1', '1a'],
       order: ['1'],
       entries: {
-        '1': makeOntimeGroup({ id: '1' }),
+        '1': makeOntimeGroup({ id: '1', entries: ['1a'] }),
         '1a': makeOntimeEvent({ id: '1a', parent: '1' }),
       },
     });
 
-    rundownMutation.add(rundown, mockEvent, null, rundown.entries['1'] as OntimeGroup);
+    rundownMutation.add(rundown, mockEvent, rundown.entries['1'] as OntimeGroup, null, null);
 
     expect(rundown.order).toStrictEqual(['1']);
-    expect(rundown.flatOrder).toStrictEqual(['1', 'mock', '1a']);
+    expect(rundown.flatOrder).toStrictEqual(['1', '1a', 'mock']);
     expect(rundown.entries['mock']).toMatchObject(mockEvent);
   });
 
@@ -731,12 +765,12 @@ describe('rundownMutation.add()', () => {
       flatOrder: ['1', '1a'],
       order: ['1'],
       entries: {
-        '1': makeOntimeGroup({ id: '1' }),
+        '1': makeOntimeGroup({ id: '1', entries: ['1a'] }),
         '1a': makeOntimeEvent({ id: '1a', parent: '1' }),
       },
     });
 
-    rundownMutation.add(rundown, mockEvent, '1a', rundown.entries['1'] as OntimeGroup);
+    rundownMutation.add(rundown, mockEvent, rundown.entries['1'] as OntimeGroup, '1a', null);
 
     expect(rundown.order).toStrictEqual(['1']);
     expect(rundown.flatOrder).toStrictEqual(['1', '1a', 'mock']);
@@ -1805,6 +1839,49 @@ describe('rundownMutation.clone()', () => {
       parent: null,
     });
   });
+
+  it('clones an event and appends it with after true', () => {
+    const testRundown = makeRundown({
+      order: ['1', '2'],
+      entries: {
+        '1': makeOntimeEvent({ id: '1', cue: 'event1', parent: null }),
+        '2': makeOntimeEvent({ id: '2', cue: 'event2', parent: null }),
+      },
+    });
+
+    const newEntry = rundownMutation.clone(testRundown, testRundown.entries['1'], { after: true });
+
+    expect(testRundown.order).toStrictEqual(['1', '2', newEntry.id]);
+  });
+
+  it('clones an event and prepends it with before true', () => {
+    const testRundown = makeRundown({
+      order: ['1', '2'],
+      entries: {
+        '1': makeOntimeEvent({ id: '1', cue: 'event1', parent: null }),
+        '2': makeOntimeEvent({ id: '2', cue: 'event2', parent: null }),
+      },
+    });
+
+    const newEntry = rundownMutation.clone(testRundown, testRundown.entries['2'], { before: true });
+
+    expect(testRundown.order).toStrictEqual([newEntry.id, '1', '2']);
+  });
+
+  it('clones a group and appends it with after true', () => {
+    const testRundown = makeRundown({
+      order: ['1', '2'],
+      entries: {
+        '1': makeOntimeGroup({ id: '1', title: 'top', entries: ['1a'] }),
+        '1a': makeOntimeEvent({ id: '1a', cue: 'nested', parent: '1' }),
+        '2': makeOntimeEvent({ id: '2', cue: 'event2', parent: null }),
+      },
+    });
+
+    const newEntry = rundownMutation.clone(testRundown, testRundown.entries['1'], { after: true });
+
+    expect(testRundown.order).toStrictEqual(['1', '2', newEntry.id]);
+  });
 });
 
 describe('rundownMutation.group()', () => {

apps/server/src/api-data/rundown/__tests__/rundown.utils.test.ts

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

apps/server/src/api-data/rundown/__tests__/rundown.validation.test.ts

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

apps/server/src/api-data/rundown/rundown.dao.ts

@@ -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
+    const position: { after: EntryId | null; before: EntryId | null } = (() => {
-    let atIndex = rundown.order.indexOf(entry.id) + 1;
+      if (options?.after === undefined && options?.before === undefined) {
-
+        return { after: entry.id, before: null };
-    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 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 maybeParent = rundown.entries[parentId];
-    const referenceId = options?.after ?? options?.before;
+      return isOntimeGroup(maybeParent) ? maybeParent : null;
+    })();
 
-    /**
+    const position = (() => {
-     * if we have a positioning reference, and that reference has a parent
+      // if no position is given, we add immediately after the element
-     * we need to maintain the same parent for the cloned entry
+      if (options?.after === undefined && options?.before === undefined) {
-     */
+        return { after: entry.id, before: null };
-    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;
-          }
-        }
       }
-    } 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
+      const after = getInsertAfterId(rundown, parent, options.after, options.before);
-    let after = getInsertAfterId(rundown, parent, options?.after, options?.before);
+      const before = options?.before === true ? after : (options.before ?? null);
-    if (!after) {
+      return { after, before };
-      after = entry.id;
+    })();
-    }
 
-    return addToRundown(rundown, clonedEntry, after, parent);
+    return addToRundown(rundown, clonedEntry, parent, position.after, position.before);
   }
 }
 

apps/server/src/api-data/rundown/rundown.parser.ts

@@ -279,14 +279,22 @@ function processEntry<T extends OntimeEntry>(
     // 2. handle custom fields - mutates entry
     sanitiseCustomFields(customFields, entry);
 
-    rundownMetadata.totalDays += calculateDayOffset(entry, rundownMetadata.previousEvent);
+    /*
-    entry.dayOffset = rundownMetadata.totalDays as Day;
+     * we initialise data so that is not calculated for skipped events
-    entry.delay = 0; // this means we dont calculate delays or gaps for skipped events
+     * consider especially the day offset, while skipped events have no
-    entry.gap = 0; // this means we dont calculate delays or gaps for skipped events
+     * day offset, we match it to the previous element to avoid
+     * pushing confusing data to the UI
+     */
+    entry.dayOffset = (rundownMetadata.previousEvent?.dayOffset ?? 0) as Day;
+    entry.delay = 0;
+    entry.gap = 0;
+
     entry.parent = childOfGroup;
 
     // update rundown metadata, it only concerns playable events
     if (isPlayableEvent(entry)) {
+      rundownMetadata.totalDays += calculateDayOffset(entry, rundownMetadata.previousEvent);
+      entry.dayOffset = rundownMetadata.totalDays as Day;
       rundownMetadata.playableEventOrder.push(entry.id);
 
       // first start is always the first event

apps/server/src/api-data/rundown/rundown.router.ts

@@ -1,7 +1,15 @@
 import type { Request, Response, Router } from 'express';
 import express from 'express';
 import { matchedData } from 'express-validator';
-import { ErrorResponse, OntimeEntry, ProjectRundownsList, RenumberCues, Rundown } from 'ontime-types';
+import {
+  ErrorResponse,
+  OntimeEntry,
+  ProjectRundowns,
+  ProjectRundownsList,
+  RenumberCues,
+  Rundown,
+  RundownImportPayload,
+} from 'ontime-types';
 import { getErrorMessage } from 'ontime-utils';
 
 import { getDataProvider } from '../../classes/data-provider/DataProvider.js';
@@ -12,7 +20,9 @@ import {
   applyDelay,
   batchEditEntries,
   cloneEntry,
+  applyImportToRundown,
   createNewRundown,
+  createRundownFromImport,
   deleteAllEntries,
   deleteEntries,
   deleteRundown,
@@ -36,6 +46,7 @@ import {
   entryReorderValidator,
   entrySwapValidator,
   rundownArrayOfIds,
+  rundownImportValidator,
   rundownPatchValidator,
   rundownPostValidator,
 } from './rundown.validation.js';
@@ -147,6 +158,39 @@ router.delete('/:id', paramsWithId, async (req: Request, res: Response<ProjectRu
   }
 });
 
+/**
+ * Applies an imported rundown: override or merge into an existing rundown, or create a new one.
+ */
+router.post(
+  '/import',
+  rundownImportValidator,
+  async (req: Request, res: Response<ProjectRundownsList | ErrorResponse>) => {
+    try {
+      const { mode, targetRundownId, rundown, customFields, providedFields } = matchedData<RundownImportPayload>(req);
+      let projectRundowns: ProjectRundowns;
+      if (mode === 'new') {
+        projectRundowns = await createRundownFromImport(rundown, customFields);
+      } else {
+        // the validator guarantees this for override/merge, the guard narrows the type and adds defence in depth
+        if (!targetRundownId) {
+          throw new Error('targetRundownId is required when mode is override or merge');
+        }
+        projectRundowns = await applyImportToRundown(
+          mode,
+          targetRundownId,
+          rundown,
+          customFields,
+          providedFields ?? { event: [], custom: [] },
+        );
+      }
+      res.status(200).json({ loaded: getCurrentRundown().id, rundowns: normalisedToRundownArray(projectRundowns) });
+    } catch (error) {
+      const message = getErrorMessage(error);
+      res.status(400).send({ message });
+    }
+  },
+);
+
 // #endregion operations on project rundowns ======================
 
 // #region operations on rundown entries ==========================

apps/server/src/api-data/rundown/rundown.service.ts

@@ -4,6 +4,7 @@ import {
   CustomFields,
   EntryId,
   EventPostPayload,
+  ImportedFields,
   InsertOptions,
   LogOrigin,
   OntimeEntry,
@@ -12,6 +13,7 @@ import {
   ProjectRundowns,
   RefetchKey,
   Rundown,
+  RundownImportMergeStrategy,
   isOntimeDelay,
   isOntimeEvent,
   isOntimeGroup,
@@ -25,6 +27,7 @@ import { makeNewRundown } from '../../models/dataModel.js';
 import { setLastLoadedRundown } from '../../services/app-state-service/AppStateService.js';
 import { runtimeService } from '../../services/runtime-service/runtime.service.js';
 import { updateRundownData } from '../../stores/runtimeState.js';
+import { parseCustomFields } from '../custom-fields/customFields.parser.js';
 import {
   createTransaction,
   customFieldMutation,
@@ -33,8 +36,19 @@ import {
   rundownMutation,
   updateBackgroundRundown,
 } from './rundown.dao.js';
+import { parseRundown } from './rundown.parser.js';
 import type { RundownMetadata } from './rundown.types.js';
-import { generateEvent, getIntegerAndFraction, hasChanges } from './rundown.utils.js';
+import {
+  generateEvent,
+  getFirstInsertId,
+  getIntegerAndFraction,
+  getLastInsertId,
+  getPreviousInsertId,
+  hasChanges,
+  mergeRundownPreservingFields,
+  isLoadedPlayable,
+} from './rundown.utils.js';
+import { assertInsertAnchorExists, assertInsertAnchorInOrder, assertSingleInsertAnchor } from './rundown.validation.js';
 
 /**
  * creates a new entry with given data
@@ -42,6 +56,8 @@ import { generateEvent, getIntegerAndFraction, hasChanges } from './rundown.util
 export async function addEntry(rundownId: string, eventData: EventPostPayload): Promise<OntimeEntry> {
   const { rundown, commit } = createTransaction({ rundownId, mutableRundown: true });
 
+  assertSingleInsertAnchor(eventData);
+
   // we allow the user to provide an ID, but make sure it is unique
   if (eventData?.id && Object.hasOwn(rundown.entries, eventData.id)) {
     throw new Error(`Event with ID ${eventData.id} already exists`);
@@ -58,14 +74,29 @@ export async function addEntry(rundownId: string, eventData: EventPostPayload):
     parent = maybeParent;
   }
 
+  assertInsertAnchorInOrder(rundown, parent, eventData);
+
   // normalise the position of the event in the rundown order
-  const afterId = getInsertAfterId(rundown, parent, eventData?.after, eventData?.before);
+  const insertPosition = (() => {
+    if (eventData.before !== undefined) {
+      const beforeId = getFirstInsertId(rundown, parent, eventData.before);
+      return { afterId: null, beforeId, cueAfterId: getPreviousInsertId(rundown, parent, beforeId) };
+    }
+
+    // if after is an ID, we will try and find the entry
+    if (eventData.after !== undefined && eventData.after !== true) {
+      const afterId = getInsertAfterId(rundown, parent, eventData.after);
+      return { afterId, beforeId: null, cueAfterId: afterId };
+    }
+
+    return { afterId: null, beforeId: null, cueAfterId: getLastInsertId(rundown, parent) };
+  })();
 
   // generate a fully formed entry from the patch
-  const newEntry = generateEvent(rundown, eventData, afterId, parent?.id);
+  const newEntry = generateEvent(rundown, eventData, insertPosition.cueAfterId, parent?.id);
 
   // make mutations to rundown
-  rundownMutation.add(rundown, newEntry, afterId, parent);
+  rundownMutation.add(rundown, newEntry, parent, insertPosition.afterId, insertPosition.beforeId);
 
   const { rundown: responseRundown, rundownMetadata, revision } = await commit();
 
@@ -385,7 +416,10 @@ export async function swapEvents(rundownId: string, fromId: EntryId, toId: Entry
  * @throws if the entry to clone does not exist
  */
 export async function cloneEntry(rundownId: string, entryId: EntryId, options: InsertOptions): Promise<Rundown> {
+  assertSingleInsertAnchor(options);
+
   const { rundown, commit } = createTransaction({ rundownId, mutableRundown: true });
+  assertInsertAnchorExists(rundown, options);
   const originalEntry = rundown.entries[entryId];
 
   if (!originalEntry) {
@@ -656,8 +690,8 @@ export async function loadRundown(id: string) {
 }
 
 /**
- * Sets a new rundown in the cache
+ * Sets a new rundown in the cache and marks it as the currently loaded one.
- * and marks it as the currently loaded one
+ * Switching to a rundown always stops playback.
  */
 export async function initRundown(
   rundown: Readonly<Rundown>,
@@ -679,6 +713,25 @@ export async function initRundown(
   });
 }
 
+/**
+ * Applies a rebuilt version of the currently loaded rundown in place.
+ * Unlike switching rundowns, this maintains playback when possible
+ */
+function applyChangeToCurrentRundown(rundown: Readonly<Rundown>, customFields: Readonly<CustomFields>) {
+  const loadedEvent = runtimeService.getLoadedEventId();
+  if (loadedEvent && !isLoadedPlayable(loadedEvent, rundown)) {
+    runtimeService.stop();
+  }
+  const { rundownMetadata, revision } = rundownCache.init(rundown, customFields);
+  updateRuntimeOnChange(rundownMetadata);
+
+  setImmediate(() => {
+    // notifying the timer hot-reloads the playing event and keeps playback
+    notifyChanges(rundown.id, rundownMetadata, revision, { timer: true, external: true, reload: true });
+    sendRefetch(RefetchKey.ProjectRundowns);
+  });
+}
+
 export async function createNewRundown(title: string) {
   const emptyRundown = makeNewRundown();
   emptyRundown.title = title;
@@ -743,6 +796,86 @@ export async function duplicateExistingRundown(id: string) {
   return dataProvider.getProjectRundowns();
 }
 
+/**
+ * Validates an imported rundown against the resulting custom fields, then commits those custom
+ * fields. The rundown is validated before the custom-field mutation, so a payload that fails
+ * validation cannot leave a partial custom-field write behind.
+ * @throws if the rundown or custom fields fail validation
+ */
+async function parseImportAndCommitCustomFields(
+  source: Readonly<Rundown>,
+  incomingCustomFields: CustomFields,
+): Promise<Rundown> {
+  const dataProvider = getDataProvider();
+  const parsedCustomFields = parseCustomFields({ customFields: incomingCustomFields });
+  const mergedCustomFields = { ...dataProvider.getCustomFields(), ...parsedCustomFields };
+  const parsed = parseRundown(source, mergedCustomFields);
+  await dataProvider.mergeIntoData({ customFields: parsedCustomFields });
+  return parsed;
+}
+
+/**
+ * Applies an imported rundown onto an existing rundown, keeping the existing identity while
+ * taking structure and order from the incoming data.
+ * - 'override' replaces all content with the incoming data
+ * - 'merge' updates matched entries with only the fields the spreadsheet provided, keeping the rest
+ *   (e.g. automations) from the existing entry
+ *
+ * When targeting the loaded rundown this is treated as a change, not a switch, so playback is
+ * maintained when the playing event survives.
+ * @throws if the target rundown does not exist
+ */
+export async function applyImportToRundown(
+  strategy: RundownImportMergeStrategy,
+  targetRundownId: string,
+  incomingRundown: Rundown,
+  incomingCustomFields: CustomFields,
+  providedFields: ImportedFields,
+): Promise<ProjectRundowns> {
+  const dataProvider = getDataProvider();
+  // throws if the rundown was deleted between preview and apply
+  const existing = dataProvider.getRundown(targetRundownId);
+
+  const source =
+    strategy === 'merge'
+      ? mergeRundownPreservingFields(incomingRundown, existing, providedFields)
+      : { ...incomingRundown, id: existing.id, title: existing.title, revision: existing.revision + 1 };
+  const parsed = await parseImportAndCommitCustomFields(source, incomingCustomFields);
+
+  if (isCurrentRundown(targetRundownId)) {
+    // applying to the loaded rundown is a change, not a switch: maintain playback when possible
+    applyChangeToCurrentRundown(parsed, dataProvider.getCustomFields());
+  } else {
+    await dataProvider.setRundown(parsed.id, parsed);
+    setImmediate(() => {
+      sendRefetch(RefetchKey.ProjectRundowns);
+    });
+  }
+
+  return dataProvider.getProjectRundowns();
+}
+
+/**
+ * Creates a new rundown from an imported rundown and loads it,
+ * so the user immediately sees the imported data.
+ * Loading a rundown stops playback (as with any rundown switch).
+ */
+export async function createRundownFromImport(
+  incomingRundown: Rundown,
+  incomingCustomFields: CustomFields,
+): Promise<ProjectRundowns> {
+  const dataProvider = getDataProvider();
+
+  // assign a fresh id so we never collide with an existing rundown
+  const parsed = await parseImportAndCommitCustomFields({ ...incomingRundown, id: generateId() }, incomingCustomFields);
+  parsed.revision = 0;
+
+  // initRundown persists the new rundown, makes it the loaded rundown and notifies clients
+  await initRundown(parsed, dataProvider.getCustomFields(), true);
+
+  return dataProvider.getProjectRundowns();
+}
+
 /**
  * Deletes a rundown
  * @throws if attempting to delete the loaded rundown or the last rundown in the project

apps/server/src/api-data/rundown/rundown.utils.ts

@@ -2,6 +2,7 @@ import {
   CustomFields,
   EntryCustomFields,
   EntryId,
+  ImportedFields,
   OntimeBaseEvent,
   OntimeDelay,
   OntimeEntry,
@@ -11,12 +12,14 @@ import {
   ProjectRundown,
   ProjectRundowns,
   Rundown,
+  RundownEntries,
   SupportedEntry,
   TimeStrategy,
   isOntimeDelay,
   isOntimeEvent,
   isOntimeGroup,
   isOntimeMilestone,
+  isPlayableEvent,
 } from 'ontime-types';
 import {
   createDelay,
@@ -67,6 +70,50 @@ export function generateEvent(
   throw new Error('Invalid event type');
 }
 
+/**
+ * Gets the last valid insertion reference for a top-level rundown or group order.
+ * Used when appending entries and when generating cues from the preceding entry.
+ */
+export function getLastInsertId(rundown: Rundown, parent: OntimeGroup | null): EntryId | null {
+  const insertionList = parent ? parent.entries : rundown.order;
+  return insertionList[insertionList.length - 1] ?? null;
+}
+
+/**
+ * Resolves a `before` insertion option to the first entry in the relevant order when `true` is provided.
+ * String values are already explicit anchors and are returned unchanged.
+ */
+export function getFirstInsertId(rundown: Rundown, parent: OntimeGroup | null, before: EntryId | true): EntryId | null {
+  if (before !== true) {
+    return before;
+  }
+
+  const insertionList = parent ? parent.entries : rundown.order;
+  return insertionList[0] ?? null;
+}
+
+/**
+ * Gets the sibling before a `before` insertion anchor in the top-level or group order.
+ * Returns `null` when the new entry will be inserted at the start.
+ */
+export function getPreviousInsertId(
+  rundown: Rundown,
+  parent: OntimeGroup | null,
+  beforeId: EntryId | null,
+): EntryId | null {
+  if (beforeId === null) {
+    return null;
+  }
+
+  const insertionList = parent ? parent.entries : rundown.order;
+  const beforeIndex = insertionList.indexOf(beforeId);
+  if (beforeIndex < 1) {
+    return null;
+  }
+
+  return insertionList[beforeIndex - 1] ?? null;
+}
+
 export function createEventPatch(originalEvent: OntimeEvent, patchEvent: Partial<OntimeEvent>): OntimeEvent {
   if (Object.keys(patchEvent).length === 0) {
     return originalEvent;
@@ -225,6 +272,83 @@ export function getUniqueId(rundown: Rundown): EntryId {
   return id;
 }
 
+/**
+ * Builds an entry patch containing exactly the fields the spreadsheet supplied, for both built-in
+ * and custom fields. Everything the sheet did not map is left out, so applying the patch keeps the
+ * existing value for those fields.
+ */
+function buildImportPatch(entry: OntimeEntry, providedFields: ImportedFields): Partial<OntimeEntry> {
+  const source = entry as Record<string, unknown>;
+  const patch: Record<string, unknown> = {};
+  for (const field of providedFields.event) {
+    patch[field] = source[field];
+  }
+  if (providedFields.custom.length > 0) {
+    const entryCustom = (source.custom ?? {}) as EntryCustomFields;
+    const custom: EntryCustomFields = {};
+    for (const key of providedFields.custom) {
+      custom[key] = entryCustom[key] ?? '';
+    }
+    patch.custom = custom;
+  }
+  return patch as Partial<OntimeEntry>;
+}
+
+/**
+ * Merges an imported rundown into an existing one
+ * - the incoming rundown is the source of truth for entry identity and structure (order + grouping)
+ * - a matched entry of the same type is merged field-by-field: a field the sheet provided overwrites
+ *   (even when empty), a field the sheet cannot express (an event's automations, a group's target
+ *   duration, an unmapped custom field) is kept from the existing entry
+ * - a new id, or an id whose type changed, takes the incoming entry wholesale
+ * - existing entries absent from the incoming rundown are dropped
+ */
+export function mergeRundownPreservingFields(
+  incoming: Readonly<Rundown>,
+  existing: Readonly<Rundown>,
+  providedFields: ImportedFields,
+): Rundown {
+  const entries: RundownEntries = {};
+
+  for (const [id, incomingEntry] of Object.entries(incoming.entries)) {
+    const existingEntry = existing.entries[id];
+
+    // a new id, or one whose type changed, is not compatible for a merge: take the incoming data
+    if (existingEntry === undefined || existingEntry.type !== incomingEntry.type) {
+      entries[id] = incomingEntry;
+      continue;
+    }
+
+    // merge the sheet's data onto the existing entry through the canonical patch function, which
+    // keeps every unmapped field and infers an event's time strategy from the provided times
+    const merged = applyPatchToEntry(existingEntry, buildImportPatch(incomingEntry, providedFields));
+    // grouping comes from the sheet structure, not a data column: a group owns its children, every
+    // other entry knows its parent
+    const structure = isOntimeGroup(incomingEntry)
+      ? { entries: incomingEntry.entries }
+      : { parent: incomingEntry.parent };
+    entries[id] = structuredClone({ ...merged, ...structure });
+  }
+
+  return {
+    id: existing.id,
+    title: existing.title,
+    order: [...incoming.order],
+    flatOrder: [...incoming.flatOrder],
+    revision: existing.revision + 1,
+    entries,
+  };
+}
+
+/**
+ * Whether the currently playing event survives a change to its rundown,
+ * i.e. it still exists and is playable in the new version.
+ */
+export function isLoadedPlayable(loadedEventId: EntryId, rundown: Readonly<Rundown>): boolean {
+  const entry = rundown.entries[loadedEventId];
+  return entry !== undefined && isOntimeEvent(entry) && isPlayableEvent(entry);
+}
+
 /** List of event properties which do not need the rundown to be regenerated */
 enum RegenerateWhitelist {
   'id', // adding it for completeness, users cannot change ID

apps/server/src/api-data/rundown/rundown.validation.ts

@@ -1,4 +1,5 @@
 import { body, param } from 'express-validator';
+import type { EntryId, InsertOptions, OntimeGroup, Rundown } from 'ontime-types';
 
 import { requestValidationFunction } from '../validation-utils/validationFunction.js';
 
@@ -11,20 +12,53 @@ export const rundownPatchValidator = [
   requestValidationFunction,
 ];
 
+export const rundownImportValidator = [
+  body('mode').isString().isIn(['override', 'merge', 'new']),
+  body('targetRundownId')
+    .if(body('mode').isIn(['override', 'merge']))
+    .isString()
+    .trim()
+    .notEmpty()
+    .withMessage('targetRundownId is required when mode is override or merge'),
+  body('rundown').isObject(),
+  body('rundown.entries').isObject(),
+  body('rundown.order').isArray(),
+  body('rundown.flatOrder').isArray(),
+  body('customFields').isObject(),
+  body('providedFields').optional().isObject(),
+  body('providedFields.event').optional().isArray(),
+  body('providedFields.event.*').isString(),
+  body('providedFields.custom').optional().isArray(),
+  body('providedFields.custom.*').isString(),
+  requestValidationFunction,
+];
+
 // #endregion operations on project rundowns ======================
 // #region operations on rundown entries ==========================
 
 export const entryPostValidator = [
   body('type').isString().isIn(['event', 'delay', 'group', 'milestone']),
-  body('after').optional().isString(),
+  body('after')
-  body('before').optional().isString(),
+    .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('after')
-  body('before').optional().isString(),
+    .optional()
+    .custom((value) => value === true || typeof value === 'string')
+    .withMessage('Allowed values for after are an ID or true.'),
+  body('before')
+    .optional()
+    .custom((value) => value === true || typeof value === 'string')
+    .withMessage('Allowed values for before are an ID or true.'),
 
   requestValidationFunction,
 ];
@@ -72,4 +106,44 @@ export const entryRenumberValidator = [
   requestValidationFunction,
 ];
 
+/**
+ * Ensures callers use a single insertion anchor so placement is unambiguous.
+ */
+export function assertSingleInsertAnchor(options: InsertOptions) {
+  if (options.after !== undefined && options.before !== undefined) {
+    throw new Error('Use only one insertion anchor: after or before');
+  }
+}
+
+/**
+ * Ensures an ID anchor exists and belongs to the order it is intended to position within.
+ */
+export function assertInsertAnchorInOrder(rundown: Rundown, parent: OntimeGroup | null, options: InsertOptions) {
+  const anchor = getStringInsertAnchor(options);
+  if (anchor === undefined) return;
+
+  if (!Object.hasOwn(rundown.entries, anchor)) {
+    throw new Error(`Insertion anchor with ID ${anchor} does not exist`);
+  }
+
+  const insertionList = parent ? parent.entries : rundown.order;
+  if (!insertionList.includes(anchor)) {
+    throw new Error(`Insertion anchor with ID ${anchor} is not in the target order`);
+  }
+}
+
+/** Ensures an ID anchor refers to an entry in the rundown. */
+export function assertInsertAnchorExists(rundown: Rundown, options: InsertOptions) {
+  const anchor = getStringInsertAnchor(options);
+  if (anchor !== undefined && !Object.hasOwn(rundown.entries, anchor)) {
+    throw new Error(`Insertion anchor with ID ${anchor} does not exist`);
+  }
+}
+
+function getStringInsertAnchor(options: InsertOptions): EntryId | undefined {
+  if (typeof options.after === 'string') return options.after;
+  if (typeof options.before === 'string') return options.before;
+  return undefined;
+}
+
 // #endregion operations on rundown entries =======================

apps/server/src/api-mcp/__tests__/mcp.service.test.ts

@@ -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({

apps/server/src/api-mcp/mcp.prompts.ts

@@ -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).

apps/server/src/api-mcp/mcp.service.ts

@@ -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;
+      const { type: _type, rundownId: _rundownId, after: _after, before: _before, ...eventFields } = args;
-      return { type: SupportedEntry.Event, ...eventFields };
+      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(
+export async function batchCreateEntriesForMcp(args: BatchCreateEntriesArgs) {
-  args: TargetRundownArgs & { entries: BatchCreateEntryArgs[]; after?: EntryId },
+  const { entries = [], after, before } = args;
-) {
-  const { entries = [], after } = 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 } : {}),
+    ...(previousId !== undefined ? { after: previousId } : {}),
-    ...(parentId ? { parent: parentId } : {}),
+    ...(parentId !== undefined ? { parent: parentId } : {}),
+    ...(previousId === undefined ? firstInsertOptions : {}),
   };
 
   const createdEntry = await addEntry(rundownId, { ...payload, ...insertOptions } as EventPostPayload);

apps/server/src/api-mcp/mcp.tools.ts

@@ -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' },
+        after: {
-        before: { type: 'string', description: 'Insert before this entry ID' },
+          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;
+        },
+      ),
     );
   },
 

apps/server/src/app.ts

@@ -117,8 +117,9 @@ app.use(`${prefix}/external`, (req, res) => {
 app.use(`${prefix}/user`, express.static(publicDir.userDir, { etag: false, lastModified: true }));
 
 // Serve legacy timer for old browsers that don't support modern JS
+// dotfiles must be allowed since the install path can contain dot directories (eg AppImage mounts in /tmp/.mount_*)
 app.get(`${prefix}/timer-legacy`, authenticateAndRedirect, (_req, res) => {
-  res.sendFile(srcFiles.timerLegacy);
+  res.sendFile(srcFiles.timerLegacy, { dotfiles: 'allow' });
 });
 
 // Base route for static files

apps/server/src/lib/time-core/timeCore.ts

@@ -1,5 +1,5 @@
 import { Day, Duration, Instant, TimeOfDay } from 'ontime-types';
-import { MILLIS_PER_MINUTE, dayInMs } from 'ontime-utils';
+import { MILLIS_PER_HOUR, MILLIS_PER_MINUTE, MILLIS_PER_SECOND, dayInMs } from 'ontime-utils';
 
 /** Returns the current instant */
 export function now(): Instant {
@@ -59,6 +59,10 @@ export function addDuration(instant: Instant, duration: Duration | Duration[]):
   return (instant + totalDuration) as Instant;
 }
 
+export function combineValues<T extends Duration | Day>(...duration: T[]): T {
+  return Array.isArray(duration) ? (duration.reduce<number>((total, current) => total + current, 0) as T) : duration;
+}
+
 /**
  * Calculates elapsed time on the clock from a starting time to the current time
  * Handles overnight crossing (when current < start, assumes we've crossed midnight)
@@ -80,3 +84,15 @@ export function daysSinceStart(startEpoch: Instant, currentEpoch: Instant): Day
 
   return (currentDaySerial - startDaySerial) as Day;
 }
+
+export const ZERO_DURATION = 0 as Duration;
+
+/**
+ * utility function to generate Instant times
+ */
+export function generateInstanceFromClock(hour: number, minutes: number, second: number, ms = 0) {
+  return toInstant(
+    (hour * MILLIS_PER_HOUR + minutes * MILLIS_PER_MINUTE + second * MILLIS_PER_SECOND + ms) as TimeOfDay,
+    now(),
+  );
+}

apps/server/src/services/__tests__/timerUtils.test.ts

@@ -1,7 +1,8 @@
-import { EndAction, Playback, TimeOfDay, TimeStrategy, TimerPhase, TimerType } from 'ontime-types';
+import { Duration, EndAction, Playback, TimeOfDay, TimeStrategy, TimerPhase, TimerType } from 'ontime-types';
 import { MILLIS_PER_HOUR, MILLIS_PER_MINUTE, MILLIS_PER_SECOND, dayInMs, millisToString } from 'ontime-utils';
 
-import type { RuntimeState } from '../../stores/runtimeState.js';
+import * as timeCore from '../../lib/time-core/timeCore.js';
+import type { InternalRuntimeState, RuntimeState } from '../../stores/runtimeState.js';
 import {
   findDayOffset,
   getCurrent,
@@ -19,48 +20,48 @@ const asTimeOfDay = (value: number): RuntimeState['clock'] => value as RuntimeSt
 describe('getElapsed()', () => {
   it('returns active elapsed time from startedAt without add-time adjustments', () => {
     const state = {
-      clock: 5 * MILLIS_PER_MINUTE,
+      _now: timeCore.generateInstanceFromClock(0, 5, 0),
       timer: {
         addedTime: -10 * MILLIS_PER_MINUTE,
         current: 15 * MILLIS_PER_MINUTE,
         duration: 20 * MILLIS_PER_MINUTE,
-        startedAt: 2 * MILLIS_PER_MINUTE,
+        startedAt: timeCore.generateInstanceFromClock(0, 2, 0),
       },
       _timer: {
         pausedAt: null,
         pausedDuration: 0,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     expect(getElapsed(state)).toBe(3 * MILLIS_PER_MINUTE);
   });
 
   it('subtracts accumulated pause time', () => {
     const state = {
-      clock: 10 * MILLIS_PER_MINUTE,
+      _now: timeCore.generateInstanceFromClock(0, 10, 0),
       timer: {
-        startedAt: 2 * MILLIS_PER_MINUTE,
+        startedAt: timeCore.generateInstanceFromClock(0, 2, 0),
       },
       _timer: {
         pausedAt: null,
         pausedDuration: 5 * MILLIS_PER_MINUTE,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     expect(getElapsed(state)).toBe(3 * MILLIS_PER_MINUTE);
   });
 
   it('uses the current pause start while paused', () => {
     const state = {
-      clock: 10 * MILLIS_PER_MINUTE,
+      _now: timeCore.generateInstanceFromClock(0, 10, 0),
       timer: {
-        startedAt: 2 * MILLIS_PER_MINUTE,
+        startedAt: timeCore.generateInstanceFromClock(0, 2, 0),
       },
       _timer: {
         pausedAt: 7 * MILLIS_PER_MINUTE,
         pausedDuration: 1 * MILLIS_PER_MINUTE,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     expect(getElapsed(state)).toBe(4 * MILLIS_PER_MINUTE);
   });
@@ -82,7 +83,7 @@ describe('getExpectedFinish()', () => {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
     const calculatedFinish = getExpectedFinish(state);
     expect(calculatedFinish).toBe(null);
   });
@@ -95,13 +96,13 @@ describe('getExpectedFinish()', () => {
       timer: {
         addedTime: 0,
         duration: 10,
-        startedAt: 10,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 10),
       },
       _timer: {
         pausedAt: null,
         hasFinished: true,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
     const calculatedFinish = getExpectedFinish(state);
     expect(calculatedFinish).toBe(20);
   });
@@ -114,13 +115,13 @@ describe('getExpectedFinish()', () => {
       timer: {
         addedTime: 0,
         duration: 10,
-        startedAt: 1,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 1),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
     const calculatedFinish = getExpectedFinish(state);
     expect(calculatedFinish).toBe(11);
   });
@@ -133,13 +134,13 @@ describe('getExpectedFinish()', () => {
       timer: {
         addedTime: 20,
         duration: 10,
-        startedAt: 1,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 1),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const calculatedFinish = getExpectedFinish(state);
     expect(calculatedFinish).toBe(31);
@@ -153,13 +154,13 @@ describe('getExpectedFinish()', () => {
       timer: {
         addedTime: -10,
         duration: 10,
-        startedAt: 1,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 1),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const calculatedFinish = getExpectedFinish(state);
     expect(calculatedFinish).toBe(1);
@@ -173,13 +174,13 @@ describe('getExpectedFinish()', () => {
       timer: {
         addedTime: -100,
         duration: 10,
-        startedAt: 1,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 1),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const calculatedFinish = getExpectedFinish(state);
     expect(calculatedFinish).toBe(1);
@@ -193,13 +194,13 @@ describe('getExpectedFinish()', () => {
       timer: {
         addedTime: 0,
         duration: 0,
-        startedAt: 1,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 1),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const calculatedFinish = getExpectedFinish(state);
     expect(calculatedFinish).toBe(1);
@@ -213,13 +214,13 @@ describe('getExpectedFinish()', () => {
       timer: {
         addedTime: 0,
         duration: dayInMs,
-        startedAt: 10,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 10),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const calculatedFinish = getExpectedFinish(state);
     expect(calculatedFinish).toBe(10);
@@ -234,13 +235,13 @@ describe('getExpectedFinish()', () => {
         timer: {
           addedTime: 10,
           duration: dayInMs,
-          startedAt: 10,
+          startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 10),
         },
         _timer: {
           pausedAt: null,
           hasFinished: false,
         },
-      } as RuntimeState;
+      } as InternalRuntimeState;
 
       const calculatedFinish = getExpectedFinish(state);
       expect(calculatedFinish).toBe(40);
@@ -253,7 +254,7 @@ describe('getExpectedFinish()', () => {
         },
         timer: {
           addedTime: 0,
-          startedAt: 79200000, // 22:00:00
+          startedAt: timeCore.generateInstanceFromClock(22, 0, 0),
         },
         _timer: {
           pausedAt: null,
@@ -263,7 +264,7 @@ describe('getExpectedFinish()', () => {
           actualStart: 79200000,
           plannedEnd: 600000,
         },
-      } as RuntimeState;
+      } as InternalRuntimeState;
 
       const calculatedFinish = getExpectedFinish(state);
       // expected finish is not a duration but a point in time
@@ -279,7 +280,7 @@ describe('getCurrent()', () => {
         timeEnd: 30,
         timerType: TimerType.CountDown,
       },
-      clock: 0,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0),
       timer: {
         addedTime: 10,
         duration: 111, // <-- we take the duration value
@@ -289,7 +290,7 @@ describe('getCurrent()', () => {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const current = getCurrent(state);
     expect(current).toBe(111);
@@ -300,17 +301,17 @@ describe('getCurrent()', () => {
         timeEnd: 10,
         timerType: TimerType.CountDown,
       },
-      clock: 1,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0, 1),
       timer: {
         addedTime: 0,
         duration: 10,
-        startedAt: 0,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const current = getCurrent(state);
     expect(current).toBe(9);
@@ -321,17 +322,17 @@ describe('getCurrent()', () => {
         timeEnd: 10,
         timerType: TimerType.CountDown,
       },
-      clock: 1,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0, 1),
       timer: {
         addedTime: 10,
         duration: 10,
-        startedAt: 0,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const current = getCurrent(state);
     expect(current).toBe(19);
@@ -342,17 +343,17 @@ describe('getCurrent()', () => {
         timeEnd: 20,
         timerType: TimerType.CountDown,
       },
-      clock: 10,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0, 10),
       timer: {
         addedTime: 0,
         duration: dayInMs + 10,
-        startedAt: 10,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 10),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const current = getCurrent(state);
     expect(current).toBe(dayInMs + 10);
@@ -363,17 +364,17 @@ describe('getCurrent()', () => {
         timeEnd: 20,
         timerType: TimerType.CountDown,
       },
-      clock: 5,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0, 5),
       timer: {
         addedTime: 0,
         duration: dayInMs + 10,
-        startedAt: 10,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 10),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const current = getCurrent(state);
     expect(current).toBe(15);
@@ -384,17 +385,17 @@ describe('getCurrent()', () => {
         timeEnd: 20,
         timerType: TimerType.CountDown,
       },
-      clock: 5,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0, 5),
       timer: {
         addedTime: 20,
         duration: dayInMs + 10,
-        startedAt: 10,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 10),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const current = getCurrent(state);
     expect(current).toBe(35);
@@ -407,7 +408,7 @@ describe('getCurrent()', () => {
           timeEnd: 100,
           countToEnd: true,
         },
-        clock: 30,
+        _now: timeCore.generateInstanceFromClock(0, 0, 0, 30),
         timer: {
           addedTime: 0,
           duration: 100,
@@ -420,7 +421,7 @@ describe('getCurrent()', () => {
           pausedAt: null,
           hasFinished: false,
         },
-      } as RuntimeState;
+      } as InternalRuntimeState;
 
       const current = getCurrent(state);
       expect(current).toBe(70);
@@ -432,11 +433,11 @@ describe('getCurrent()', () => {
           timeEnd: 100,
           countToEnd: true,
         },
-        clock: 30,
+        _now: timeCore.generateInstanceFromClock(0, 0, 0, 30),
         timer: {
           addedTime: 0,
           duration: 100,
-          startedAt: 10,
+          startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 10),
         },
         rundown: {
           plannedEnd: 100,
@@ -445,7 +446,7 @@ describe('getCurrent()', () => {
           pausedAt: null,
           hasFinished: false,
         },
-      } as RuntimeState;
+      } as InternalRuntimeState;
 
       const current = getCurrent(state);
       expect(current).toBe(70);
@@ -457,11 +458,11 @@ describe('getCurrent()', () => {
           timeEnd: 100,
           countToEnd: true,
         },
-        clock: 30,
+        _now: timeCore.generateInstanceFromClock(0, 0, 0, 30),
         timer: {
           addedTime: 7,
           duration: 100,
-          startedAt: 10,
+          startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 10),
         },
         rundown: {
           plannedEnd: 100,
@@ -470,7 +471,7 @@ describe('getCurrent()', () => {
           pausedAt: null,
           hasFinished: false,
         },
-      } as RuntimeState;
+      } as InternalRuntimeState;
 
       const current = getCurrent(state);
       expect(current).toBe(77);
@@ -483,11 +484,11 @@ describe('getCurrent()', () => {
           timeEnd: 600000, // 00:10:00
           countToEnd: true,
         },
-        clock: 79500000, // 22:05:00
+        _now: timeCore.generateInstanceFromClock(22, 5, 0),
         timer: {
           addedTime: 0,
           duration: Infinity, // not relevant,
-          startedAt: 79200000, // 22:00:00
+          startedAt: timeCore.generateInstanceFromClock(22, 0, 0),
         },
         rundown: {
           actualStart: 79200000,
@@ -497,7 +498,7 @@ describe('getCurrent()', () => {
           pausedAt: null,
           hasFinished: false,
         },
-      } as RuntimeState;
+      } as InternalRuntimeState;
 
       const current = getCurrent(state);
       expect(current).toBe(dayInMs - 79500000 + 600000);
@@ -505,7 +506,7 @@ describe('getCurrent()', () => {
 
     it('handles events that were started late', () => {
       const state = {
-        clock: 82000000, // 22:46:40 <--- starting 16 min after the scheduled end
+        _now: timeCore.generateInstanceFromClock(22, 46, 40), // 22:46:40 <--- starting 16 min after the scheduled end
         eventNow: {
           timeStart: 77400000, // 21:30:00
           timeEnd: 81000000, // 22:30:00
@@ -515,7 +516,7 @@ describe('getCurrent()', () => {
         timer: {
           addedTime: 0,
           duration: Infinity, // not relevant,
-          startedAt: 79200000, // 22:00:00
+          startedAt: timeCore.generateInstanceFromClock(22, 0, 0),
         },
         rundown: {
           actualStart: 82000000, // 22:46:40 <--- started now
@@ -525,7 +526,7 @@ describe('getCurrent()', () => {
           pausedAt: null,
           hasFinished: false,
         },
-      } as RuntimeState;
+      } as InternalRuntimeState;
 
       const current = getCurrent(state);
       expect(current).toBe(81000000 - 82000000); // <-- planned end - now
@@ -541,17 +542,17 @@ describe('getExpectedFinish() and getCurrentTime() combined', () => {
         timeEnd: 10,
         timerType: TimerType.CountDown,
       },
-      clock: 0,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0),
       timer: {
         addedTime: 0,
         duration,
-        startedAt: 0,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const expectedFinish = getExpectedFinish(state);
     const current = getCurrent(state);
@@ -569,25 +570,25 @@ describe('getExpectedFinish() and getCurrentTime() combined', () => {
         timeEnd: 10,
         timerType: TimerType.CountDown,
       },
-      clock: 5,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0, 5),
       timer: {
         addedTime: 3,
         duration,
-        startedAt: 0,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0),
       },
       _timer: {
         pausedAt: null,
         hasFinished: false,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const expectedFinish = getExpectedFinish(state);
     const current = getCurrent(state);
 
     const elapsed = duration - current;
     expect(expectedFinish).toBe(13);
-    expect(elapsed).toBe(2);
     expect(current).toBe(8);
+    expect(elapsed).toBe(2);
   });
 });
 
@@ -871,7 +872,7 @@ describe('getRuntimeOffset()', () => {
         dayOffset: 0,
       },
       timer: {
-        startedAt: 150,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 150),
         addedTime: 0,
         current: 0,
       },
@@ -883,9 +884,9 @@ describe('getRuntimeOffset()', () => {
         plannedStart: 100,
         currentDay: 0,
       },
-      clock: 150,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0, 150),
       _startDayOffset: 0,
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute } = getRuntimeOffset(state);
     expect(absolute).toBe(50);
@@ -899,7 +900,7 @@ describe('getRuntimeOffset()', () => {
         dayOffset: 0,
       },
       timer: {
-        startedAt: 150, // we started 50ms delayed
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 150), // we started 50ms delayed
         addedTime: 10, // we compensated with 10ms
         current: 10, // we are 10ms into the timer
       },
@@ -912,7 +913,7 @@ describe('getRuntimeOffset()', () => {
         currentDay: 0,
       },
       _startDayOffset: 0,
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute } = getRuntimeOffset(state);
     expect(absolute).toBe(60);
@@ -927,7 +928,7 @@ describe('getRuntimeOffset()', () => {
         dayOffset: 0,
       },
       timer: {
-        startedAt: 100, // we started ontime
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 100), // we started ontime
         current: -10, // we are 10 seconds over
         addedTime: 0, // we have not compensated with added time
       },
@@ -940,7 +941,7 @@ describe('getRuntimeOffset()', () => {
         currentDay: 0,
       },
       _startDayOffset: 0,
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute } = getRuntimeOffset(state);
     expect(absolute).toBe(10);
@@ -954,9 +955,9 @@ describe('getRuntimeOffset()', () => {
         timeEnd: 150,
         dayOffset: 0,
       },
-      clock: 150,
+      _now: timeCore.generateInstanceFromClock(0, 0, 0, 150),
       timer: {
-        startedAt: 100, // started on time
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 100), // started on time
         current: 25, // are 25ms into it
         addedTime: 0,
       },
@@ -969,7 +970,7 @@ describe('getRuntimeOffset()', () => {
         currentDay: 0,
       },
       _startDayOffset: 0,
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute } = getRuntimeOffset(state);
     expect(absolute).toBe(25);
@@ -977,7 +978,7 @@ describe('getRuntimeOffset()', () => {
 
   it('offset doesnt exist if we havent started', () => {
     const state = {
-      clock: 78480789,
+      _now: timeCore.generateInstanceFromClock(22, 48, 0), // 78480789
       eventNow: {
         id: 'd6a2ce',
         timeStart: 77400000,
@@ -1011,7 +1012,7 @@ describe('getRuntimeOffset()', () => {
       },
       _startDayOffset: 0,
       _timer: { pausedAt: null },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute } = getRuntimeOffset(state);
     expect(absolute).toBe(0);
@@ -1019,7 +1020,7 @@ describe('getRuntimeOffset()', () => {
 
   it('with time-to-end, offsets dont exist if we are not in overtime', () => {
     const state = {
-      clock: 80000000, // 22:13:20
+      _now: timeCore.generateInstanceFromClock(22, 13, 20),
       eventNow: {
         id: 'd6a2ce',
         type: 'event',
@@ -1063,11 +1064,11 @@ describe('getRuntimeOffset()', () => {
         expectedFinish: 81600000,
         playback: Playback.Play,
         secondaryTimer: null,
-        startedAt: 78000000,
+        startedAt: timeCore.generateInstanceFromClock(21, 40, 0),
       },
       _startDayOffset: 0,
       _timer: { pausedAt: null },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute } = getRuntimeOffset(state);
     expect(absolute).toBe(0);
@@ -1075,7 +1076,7 @@ describe('getRuntimeOffset()', () => {
 
   it('with time-to-end, offset is the overtime', () => {
     const state = {
-      clock: 82000000, // 22:46:40
+      _now: timeCore.generateInstanceFromClock(22, 46, 40),
       eventNow: {
         id: 'd6a2ce',
         type: 'event',
@@ -1119,19 +1120,19 @@ describe('getRuntimeOffset()', () => {
         expectedFinish: 81600000,
         playback: Playback.Play,
         secondaryTimer: null,
-        startedAt: 78000000,
+        startedAt: timeCore.generateInstanceFromClock(21, 40, 0),
       },
       _startDayOffset: 0,
       _timer: { pausedAt: null },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     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', () => {
     const state = {
-      clock: 82000000, // 22:46:40 <--- starting 16m 40s after the scheduled end
+      _now: timeCore.generateInstanceFromClock(22, 46, 40), // 22:46:40 <--- starting 16m 40s after the scheduled end
       eventNow: {
         id: 'd6a2ce',
         timeStart: 77400000, // 21:30:00
@@ -1164,14 +1165,14 @@ describe('getRuntimeOffset()', () => {
         expectedFinish: 82000000 + 3600000, // <--- now + duration
         playback: Playback.Play,
         secondaryTimer: null,
-        startedAt: 82000000, // <--- started now
+        startedAt: timeCore.generateInstanceFromClock(22, 46, 40),
       },
       _startDayOffset: 0,
       _timer: { pausedAt: null },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const updateCurrent = getCurrent(state);
-    state.timer.current = updateCurrent;
+    state.timer.current = updateCurrent as Duration;
     const { absolute } = getRuntimeOffset(state);
     expect(millisToString(absolute)).toBe('00:16:40');
     expect(absolute).toBe(82000000 - 81000000); // <-- now - planned end
@@ -1187,7 +1188,7 @@ describe('getRuntimeOffset() relative', () => {
         dayOffset: 0,
       },
       timer: {
-        startedAt: 150,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 150),
         addedTime: 0,
         current: 0,
       },
@@ -1200,7 +1201,7 @@ describe('getRuntimeOffset() relative', () => {
         currentDay: 0,
       },
       _startDayOffset: 0,
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute, relative } = getRuntimeOffset(state);
     expect(absolute).toBe(0);
@@ -1214,7 +1215,7 @@ describe('getRuntimeOffset() relative', () => {
         dayOffset: 0,
       },
       timer: {
-        startedAt: 150,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 150),
         addedTime: 0,
         current: 0,
       },
@@ -1227,7 +1228,7 @@ describe('getRuntimeOffset() relative', () => {
         currentDay: 0,
       },
       _startDayOffset: 0,
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute, relative } = getRuntimeOffset(state);
     expect(absolute).toBe(50);
@@ -1241,7 +1242,7 @@ describe('getRuntimeOffset() relative', () => {
         dayOffset: 0,
       },
       timer: {
-        startedAt: 100,
+        startedAt: timeCore.generateInstanceFromClock(0, 0, 0, 100),
         addedTime: 0,
         current: 0,
       },
@@ -1254,7 +1255,7 @@ describe('getRuntimeOffset() relative', () => {
         currentDay: 0,
       },
       _startDayOffset: 0,
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const { absolute, relative } = getRuntimeOffset(state);
     expect(absolute).toBe(-50);
@@ -1276,7 +1277,7 @@ describe('getTimerPhase()', () => {
         secondaryTimer: null,
         startedAt: null,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.None);
@@ -1294,7 +1295,7 @@ describe('getTimerPhase()', () => {
         timeDanger: 100,
         timeWarning: 200,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.Overtime);
@@ -1312,7 +1313,7 @@ describe('getTimerPhase()', () => {
         timeDanger: 100,
         timeWarning: 200,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.Danger);
@@ -1330,7 +1331,7 @@ describe('getTimerPhase()', () => {
         timeDanger: 100,
         timeWarning: 200,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.Warning);
@@ -1348,7 +1349,7 @@ describe('getTimerPhase()', () => {
         timeDanger: 100,
         timeWarning: 200,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.Default);
@@ -1356,7 +1357,7 @@ describe('getTimerPhase()', () => {
 
   it('#1042 identifies waiting to roll', () => {
     const state = {
-      clock: 55691050,
+      _now: timeCore.generateInstanceFromClock(16, 28, 11), //55691050
       eventNow: null,
       eventNext: null,
       rundown: {
@@ -1382,13 +1383,13 @@ describe('getTimerPhase()', () => {
         startedAt: null,
       },
       _timer: {
-        forceFinish: null,
+        forceFinish: false,
         pausedAt: null,
       },
       _rundown: {
         totalDelay: 0,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.Pending);
@@ -1396,7 +1397,7 @@ describe('getTimerPhase()', () => {
 
   it('#1042 identifies waiting to roll', () => {
     const state = {
-      clock: 55691050,
+      _now: timeCore.generateInstanceFromClock(16, 28, 11), //55691050
       eventNow: null,
       eventNext: null,
       rundown: {
@@ -1422,13 +1423,13 @@ describe('getTimerPhase()', () => {
         startedAt: null,
       },
       _timer: {
-        forceFinish: null,
+        forceFinish: false,
         pausedAt: null,
       },
       _rundown: {
         totalDelay: 0,
       },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.Pending);

apps/server/src/services/rollUtils.ts

@@ -5,6 +5,8 @@ import { RundownMetadata } from '../api-data/rundown/rundown.types.js';
 import { getTimedIndexFromPlayableIndex } from '../api-data/rundown/rundown.utils.js';
 import { normaliseEndTime } from './timerUtils.js';
 
+// import * as timeCore from '../lib/time-core/timeCore.js';
+
 /**
  * Finds current event in a rolling rundown
  */

apps/server/src/services/runtime-service/runtime.service.ts

@@ -165,6 +165,13 @@ class RuntimeService {
     }
   }
 
+  /**
+   * Returns the id of the currently loaded event, or null if none is loaded
+   */
+  public getLoadedEventId(): EntryId | null {
+    return runtimeState.getState().eventNow?.id ?? null;
+  }
+
   /**
    * Called when the underlying data has changed,
    * we check if the change affects the runtime
@@ -753,16 +760,17 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
 
     // save the restore state
     if (hasImmediateChanges) {
+      const internalState = runtimeState.getInternalState();
       restoreService
         .save({
           playback: state.timer.playback,
           selectedEventId: state.eventNow?.id ?? null,
           startedAt: state.timer.startedAt,
           addedTime: state.timer.addedTime,
-          pausedAt: state._timer.pausedAt,
+          pausedAt: internalState._timer.pausedAt,
-          pausedDuration: state._timer.pausedDuration,
+          pausedDuration: internalState._timer.pausedDuration,
           firstStart: state.rundown.actualStart,
-          startEpoch: state._startEpoch,
+          startEpoch: internalState._startEpoch,
           currentDay: state.rundown.currentDay,
         })
         .catch((_e) => {

apps/server/src/services/timerUtils.ts

@@ -1,7 +1,9 @@
-import { Day, MaybeNumber, TimeOfDay, TimerPhase } from 'ontime-types';
+import { Day, Duration, Maybe, TimeOfDay, TimerPhase } from 'ontime-types';
 import { MILLIS_PER_HOUR, checkIsNow, dayInMs, isPlaybackActive } from 'ontime-utils';
 
-import type { RuntimeState } from '../stores/runtimeState.js';
+import * as timeCore from '../lib/time-core/timeCore.js';
+import { ZERO_DURATION } from '../lib/time-core/timeCore.js';
+import type { InternalRuntimeState, RuntimeState } from '../stores/runtimeState.js';
 
 /**
  * handle events that span over midnight
@@ -20,48 +22,46 @@ export function hasCrossedMidnight(previous: TimeOfDay, current: TimeOfDay): boo
 
 /**
  * Calculates expected finish time of a running timer
- * @param {RuntimeState} state runtime state
+ * @param {InternalRuntimeState} state runtime state
  * @returns {number | null} new current time or null if nothing is running
  */
-export function getExpectedFinish(state: RuntimeState): MaybeNumber {
+export function getExpectedFinish(state: InternalRuntimeState): Maybe<TimeOfDay> {
   const { startedAt, duration, addedTime } = state.timer;
-
   if (state.eventNow === null) {
     return null;
   }
 
   const { countToEnd, timeEnd } = state.eventNow;
   const { pausedAt } = state._timer;
-  const { clock } = state;
+  const { _now } = state;
 
   if (startedAt === null) {
     return null;
   }
 
-  const pausedTime = pausedAt != null ? clock - pausedAt : 0;
+  const pausedTime = pausedAt !== null ? timeCore.toTimeOfDay(_now) - pausedAt : 0;
-
   if (countToEnd) {
-    return timeEnd + addedTime + pausedTime;
+    return (timeEnd + addedTime + pausedTime) as TimeOfDay;
   }
 
   // handle events that finish the day after
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- duration exists if ther eis a timer
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- duration exists if there is a timer
-  const expectedFinish = startedAt + duration! + addedTime + pausedTime;
+  const expectedFinish = timeCore.toTimeOfDay(startedAt) + duration! + addedTime + pausedTime;
+
   if (expectedFinish > dayInMs) {
-    return expectedFinish - dayInMs;
+    return (expectedFinish - dayInMs) as TimeOfDay;
   }
 
   // an event cannot finish before it started (user added too much negative time)
-  return Math.max(expectedFinish, startedAt);
+  return Math.max(expectedFinish, timeCore.toTimeOfDay(startedAt)) as TimeOfDay;
 }
 
 /**
  * Calculates running countdown
- * @param {RuntimeState} state runtime state
+ * @param {InternalRuntimeState} state runtime state
  * @returns {number} current time for timer
  */
-
+export function getCurrent(state: InternalRuntimeState): Duration {
-export function getCurrent(state: RuntimeState): number {
   // eslint-disable-next-line no-unused-labels -- dev code path
   DEV: {
     if (state.eventNow === null || state.timer.duration === null) {
@@ -71,12 +71,12 @@ export function getCurrent(state: RuntimeState): number {
   const { startedAt, duration, addedTime } = state.timer;
   const { countToEnd, timeStart, timeEnd } = state.eventNow;
   const { pausedAt } = state._timer;
-  const { clock } = state;
+  const { _now } = state;
 
   if (countToEnd) {
     const isEventOverMidnight = timeStart > timeEnd;
     const correctDay = isEventOverMidnight ? dayInMs : 0;
-    return correctDay - clock + timeEnd + addedTime;
+    return (correctDay - timeCore.toTimeOfDay(_now) + timeEnd + addedTime) as Duration;
   }
 
   if (startedAt === null) {
@@ -84,19 +84,19 @@ export function getCurrent(state: RuntimeState): number {
   }
 
   if (pausedAt != null) {
-    return startedAt + duration + addedTime - pausedAt;
+    return (timeCore.toTimeOfDay(startedAt) + duration + addedTime - pausedAt) as Duration;
   }
 
-  const hasPassedMidnight = startedAt > clock;
+  const hasPassedMidnight = timeCore.toTimeOfDay(startedAt) > timeCore.toTimeOfDay(_now);
   const correctDay = hasPassedMidnight ? dayInMs : 0;
-  return startedAt + duration + addedTime - clock - correctDay;
+  return (timeCore.toTimeOfDay(startedAt) + duration + addedTime - timeCore.toTimeOfDay(_now) - correctDay) as Duration;
 }
 
 /**
  * Calculates active time elapsed since the timer started.
  */
-export function getElapsed(state: RuntimeState): MaybeNumber {
+export function getElapsed(state: InternalRuntimeState): Maybe<Duration> {
-  const { clock } = state;
+  const { _now } = state;
   const { startedAt } = state.timer;
   const { pausedAt, pausedDuration } = state._timer;
 
@@ -104,11 +104,11 @@ export function getElapsed(state: RuntimeState): MaybeNumber {
     return null;
   }
 
-  const referenceClock = pausedAt ?? clock;
+  const referenceClock = pausedAt ?? timeCore.toTimeOfDay(_now);
-  const elapsedSinceStart = getTimeSinceStart(referenceClock, startedAt);
+  const elapsedSinceStart = getTimeSinceStart(referenceClock, timeCore.toTimeOfDay(startedAt));
   const activeElapsed = elapsedSinceStart - pausedDuration;
 
-  return Math.max(0, activeElapsed);
+  return Math.max(0, activeElapsed) as Duration;
 }
 
 function getTimeSinceStart(clock: TimeOfDay, startedAt: number): number {
@@ -127,7 +127,7 @@ function getTimeSinceStart(clock: TimeOfDay, startedAt: number): number {
  * @returns {boolean}
  */
 export function skippedOutOfEvent(state: RuntimeState, previousTime: number, skipLimit: number): boolean {
-  // we cant have skipped if we havent started
+  // we cant have skipped if we haven't started
   if (state.timer.expectedFinish === null || state.timer.startedAt === null) {
     return false;
   }
@@ -151,12 +151,12 @@ export function skippedOutOfEvent(state: RuntimeState, previousTime: number, ski
  * Positive offset is over time / behind schedule
  * Negative offset is under time / ahead of schedule
  */
-export function getRuntimeOffset(state: RuntimeState): { absolute: number; relative: number } {
+export function getRuntimeOffset(state: InternalRuntimeState): { absolute: Duration; relative: Duration } {
-  const { eventNow, clock, _startDayOffset } = state;
+  const { eventNow, _now, _startDayOffset } = state;
   const { addedTime, current, startedAt } = state.timer;
   // nothing to calculate if there are no loaded events or if we havent started
   if (eventNow === null || startedAt === null || _startDayOffset === null) {
-    return { absolute: 0, relative: 0 };
+    return { absolute: ZERO_DURATION, relative: ZERO_DURATION };
   }
 
   const { countToEnd, timeStart, dayOffset } = eventNow;
@@ -171,29 +171,32 @@ export function getRuntimeOffset(state: RuntimeState): { absolute: number; relat
   }
 
   // difference between planned event start and actual event start (will be positive if we started behind)
-  const eventStartOffset = startedAt + _startDayOffset * dayInMs - (timeStart + dayOffset * dayInMs);
+  const eventStartOffset =
+    timeCore.toTimeOfDay(startedAt) + _startDayOffset * dayInMs - (timeStart + dayOffset * dayInMs);
 
   // how long has the event been running over (is a negative number when in over timer so inverted before adding to offset)
   const overtime = Math.abs(Math.min(current, 0));
 
   // time the playback was paused, the different from now to when we paused is added to the offset TODO: brakes when crossing midnight
-  const pausedTime = state._timer.pausedAt === null ? 0 : clock - state._timer.pausedAt;
+  const pausedTime = state._timer.pausedAt === null ? 0 : timeCore.toTimeOfDay(_now) - 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
+  ) as Duration;
 
   // the relative offset is the same as the absolute but adjusted relative to the actual start time
-  const relative = absolute + plannedStart - actualStart - _startDayOffset * dayInMs;
+  const relative = (absolute + plannedStart - actualStart - _startDayOffset * dayInMs) as Duration;
 
-  // in case of count to end, the absolute offset is just the overtime
+  return { absolute, relative };
-  return countToEnd ? { absolute: overtime, relative } : { absolute, relative };
 }
 
 /**
  * Checks running timer to see which phase it currently is in
  * @param state
  */
-export function getTimerPhase(state: RuntimeState): TimerPhase {
+export function getTimerPhase(state: InternalRuntimeState): TimerPhase {
   if (!isPlaybackActive(state.timer.playback)) {
     return TimerPhase.None;
   }
@@ -223,7 +226,7 @@ export function getTimerPhase(state: RuntimeState): TimerPhase {
 
 /**
  * Finds the day offset relative to an event start
- * used byt the runtimeState on first start to get correct offsets
+ * used by the RuntimeState on first start to get correct offsets
  */
 export function findDayOffset(plannedStart: number, clock: number): Day {
   const distance = clock - plannedStart;

apps/server/src/stores/__mocks__/runtimeState.mocks.ts

@@ -1,33 +1,12 @@
-import { OffsetMode, Playback, type TimeOfDay, TimerPhase } from 'ontime-types';
+import { Day, type Duration, type Instant, OffsetMode, Playback, TimeOfDay, TimerPhase } from 'ontime-types';
 import { deepmerge } from 'ontime-utils';
 
-import type { RuntimeState } from '../runtimeState.js';
+import { ZERO_DURATION } from '../../lib/time-core/timeCore.js';
+import type { InternalRuntimeState, RuntimeState } from '../runtimeState.js';
 
-const baseState: RuntimeState = {
+export const runtimePlaceholder = {
-  clock: 0 as TimeOfDay,
-  eventNow: null,
-  eventNext: null,
-  eventFlag: null,
-  groupNow: null,
-  rundown: {
-    selectedEventIndex: null,
-    numEvents: 0,
-    plannedStart: 0,
-    plannedEnd: 0,
-    actualStart: null,
-    actualGroupStart: null,
-    currentDay: 0,
-  },
-  offset: {
-    absolute: 0,
-    relative: 0,
-    mode: OffsetMode.Absolute,
-    expectedRundownEnd: null,
-    expectedGroupEnd: null,
-    expectedFlagStart: null,
-  },
   timer: {
-    addedTime: 0,
+    addedTime: ZERO_DURATION,
     current: null,
     duration: null,
     elapsed: null,
@@ -37,10 +16,43 @@ const baseState: RuntimeState = {
     secondaryTimer: null,
     startedAt: null,
   },
+  offset: {
+    absolute: ZERO_DURATION,
+    relative: ZERO_DURATION,
+    mode: OffsetMode.Absolute,
+    expectedGroupEnd: null,
+    expectedRundownEnd: null,
+    expectedFlagStart: null,
+  },
+  rundown: {
+    selectedEventIndex: null,
+    numEvents: 0,
+    plannedStart: 0 as TimeOfDay,
+    plannedEnd: 0 as TimeOfDay,
+    actualStart: null,
+    actualGroupStart: null,
+
+    currentDay: 0 as Day,
+  },
+} as Readonly<InternalRuntimeState>;
+
+const baseState: InternalRuntimeState = {
+  _now: 0 as Instant,
+  eventNow: null,
+  eventNext: null,
+  eventFlag: null,
+  groupNow: null,
+  rundown: {
+    ...runtimePlaceholder.rundown,
+  },
+  offset: {
+    ...runtimePlaceholder.offset,
+  },
+  timer: { ...runtimePlaceholder.timer },
   _timer: {
-    forceFinish: null,
+    forceFinish: false,
     pausedAt: null,
-    pausedDuration: 0,
+    pausedDuration: 0 as Duration,
     secondaryTarget: null,
     hasFinished: false,
   },

apps/server/src/stores/__tests__/runtimeState.test.ts

@@ -6,9 +6,10 @@ import { rundownCache } from '../../api-data/rundown/rundown.dao.js';
 import { initRundown } from '../../api-data/rundown/rundown.service.js';
 import { RundownMetadata } from '../../api-data/rundown/rundown.types.js';
 import {
-  type RuntimeState,
+  type InternalRuntimeState,
   addTime,
   clearState,
+  getInternalState,
   getState,
   load,
   loadGroupFlagAndEnd,
@@ -32,7 +33,7 @@ const mockEvent = {
 } as PlayableEvent;
 
 const mockState = {
-  clock: 666,
+  _now: 666,
   eventNow: null,
   eventNext: null,
   rundown: {
@@ -53,7 +54,7 @@ const mockState = {
     pausedAt: null,
     hasFinished: false,
   },
-} as RuntimeState;
+} as InternalRuntimeState;
 
 vi.mock('../../classes/data-provider/DataProvider.js', () => {
   return {
@@ -108,34 +109,34 @@ describe('mutation on runtimeState', () => {
 
       const { metadata, rundown } = rundownCache.get();
       load(mockEvent, rundown, metadata);
-      let newState = getState();
+      let newState = getInternalState();
       expect(newState.eventNow?.id).toBe(mockEvent.id);
       expect(newState.eventNext?.id).toBe('event2');
       expect(newState.timer.playback).toBe(Playback.Armed);
-      expect(newState.clock).not.toBe(666);
+      expect(getState().clock).not.toBe(666);
       expect(newState.groupNow).toBeNull();
 
       // 2. Start event
       vi.setSystemTime('jan 1 00:02');
       let success = start();
-      newState = getState();
+      newState = getInternalState();
       expect(success).toBe(true);
       expect(newState.timer).toMatchObject({
         playback: Playback.Play,
       });
-      expect(newState.rundown.actualStart).toBe(newState.clock);
+      expect(newState.rundown.actualStart).toBe(getState().clock);
 
       // 3. Pause event
       vi.setSystemTime('jan 1 00:03');
       success = pause();
-      newState = getState();
+      newState = getInternalState();
       expect(success).toBe(true);
-      expect(newState.clock).not.toBe(666);
+      expect(getState().clock).not.toBe(666);
       expect(newState.timer).toMatchObject({
         playback: Playback.Pause,
         addedTime: 0,
       });
-      expect(newState._timer.pausedAt).toEqual(newState.clock);
+      expect(newState._timer.pausedAt).toEqual(getState().clock);
 
       success = pause();
       expect(success).toBe(false);
@@ -143,7 +144,7 @@ describe('mutation on runtimeState', () => {
       // 4. Restart event
       vi.setSystemTime('jan 1 00:04');
       success = start();
-      newState = getState();
+      newState = getInternalState();
       expect(success).toBe(true);
       expect(newState.timer).toMatchObject({
         playback: Playback.Play,
@@ -163,7 +164,7 @@ describe('mutation on runtimeState', () => {
       // 5. Stop event
       vi.setSystemTime('jan 1 00:05');
       success = stop();
-      newState = getState();
+      newState = getInternalState();
       expect(success).toBe(true);
       expect(newState.eventNow).toBe(null);
       expect(newState.timer).toMatchObject({
@@ -825,7 +826,7 @@ describe('roll mode', () => {
     test('pending event', () => {
       const { rundown, metadata } = rundownCache.get();
       const { eventId, didStart } = roll(rundown, metadata);
-      const state = getState();
+      const state = getInternalState();
 
       expect(eventId).toBe('1');
       expect(didStart).toBe(false);
@@ -944,7 +945,7 @@ describe('loadGroupFlagAndEnd()', () => {
       groupNow: null,
       eventNow: rundown.entries[11],
       rundown: { actualGroupStart: null },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const metadata = { playableEventOrder: ['0', '11', '3'], flags: ['1'] } as RundownMetadata;
 
@@ -972,7 +973,7 @@ describe('loadGroupFlagAndEnd()', () => {
       groupNow: rundown.entries[1],
       eventNow: rundown.entries[22],
       rundown: { actualGroupStart: null },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const metadata = { playableEventOrder: ['0', '11', '22'], flags: ['1'] } as RundownMetadata;
 
@@ -1000,7 +1001,7 @@ describe('loadGroupFlagAndEnd()', () => {
       groupNow: rundown.entries[1],
       eventNow: rundown.entries[0],
       rundown: { actualGroupStart: null },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const metadata = { playableEventOrder: ['0', '11', '22'], flags: ['1'] } as RundownMetadata;
 
@@ -1025,7 +1026,7 @@ describe('loadGroupFlagAndEnd()', () => {
       groupNow: null,
       eventNow: rundown.entries[0],
       rundown: { actualGroupStart: null },
-    } as RuntimeState;
+    } as InternalRuntimeState;
 
     const metadata = { playableEventOrder: ['0', '1'], flags: ['1'] } as RundownMetadata;
 
@@ -1036,4 +1037,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 InternalRuntimeState;
+
+    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 InternalRuntimeState;
+
+    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,
+    });
+  });
 });

apps/server/src/stores/runtimeState.ts

@@ -17,12 +17,12 @@ import {
   TimerPhase,
   TimerState,
   isOntimeEvent,
-  runtimeStorePlaceholder,
 } from 'ontime-types';
 import {
   calculateDuration,
   checkIsNow,
   dayInMs,
+  getExpectedEnd,
   getExpectedStart,
   getLastEventNormal,
   isPlaybackActive,
@@ -43,14 +43,18 @@ import {
   hasCrossedMidnight,
 } from '../services/timerUtils.js';
 import { timerConfig } from '../setup/config.js';
+import { runtimePlaceholder } from './__mocks__/runtimeState.mocks.js';
 
 type ExpectedMetadata = {
   event: OntimeEvent;
-  accumulatedGap: number;
+  accumulatedGap: Duration;
   isLinkedToLoaded: boolean;
 } | null;
 
 export type RuntimeState = {
+  /**
+   * @deprecated we want to phase out the 24h clock
+   */
   clock: TimeOfDay;
   groupNow: OntimeGroup | null;
   eventNow: PlayableEvent | null;
@@ -60,36 +64,72 @@ export type RuntimeState = {
   timer: TimerState;
   rundown: RundownState;
   // private properties of the timer calculations
+};
+
+export type InternalRuntimeState = Omit<RuntimeState, 'clock' | 'timer' | 'offset' | 'rundown'> & {
+  timer: {
+    addedTime: Duration;
+    current: Maybe<Duration>;
+    duration: Maybe<Duration>;
+    elapsed: Maybe<Duration>;
+    expectedFinish: Maybe<TimeOfDay>;
+    phase: TimerPhase;
+    playback: Playback;
+    secondaryTimer: Maybe<Duration>;
+    startedAt: Maybe<Instant>;
+  };
+  offset: {
+    absolute: Duration;
+    relative: Duration;
+    mode: OffsetMode;
+    expectedGroupEnd: Maybe<TimeOfDay>;
+    expectedRundownEnd: Maybe<TimeOfDay>;
+    expectedFlagStart: Maybe<TimeOfDay>;
+  };
+  rundown: {
+    selectedEventIndex: Maybe<number>;
+    numEvents: number;
+    plannedStart: Maybe<TimeOfDay>;
+    plannedEnd: Maybe<TimeOfDay>;
+    actualStart: Maybe<TimeOfDay>;
+    currentDay: Maybe<Day>;
+    actualGroupStart: Maybe<TimeOfDay>;
+  };
+  _now: Instant;
   _timer: {
-    forceFinish: Maybe<TimeOfDay>; // whether we should declare an event as finished, will contain the finish time
+    forceFinish: boolean; // whether we should declare an event as finished, will contain the finish time
     pausedAt: Maybe<TimeOfDay>;
-    pausedDuration: number;
+    pausedDuration: Duration;
     secondaryTarget: Maybe<TimeOfDay>;
     hasFinished: boolean;
   };
   _rundown: {
     totalDelay: number; // this value comes from rundown service
   };
+  _startDayOffset: Maybe<Day>;
+  _startEpoch: Maybe<Instant>;
   _group: ExpectedMetadata;
   _flag: ExpectedMetadata;
   _end: ExpectedMetadata;
-  _startEpoch: Maybe<Instant>;
-  _startDayOffset: Maybe<Day>;
 };
 
-const runtimeState: RuntimeState = {
+const runtimeState: InternalRuntimeState = {
-  clock: timeCore.timeOfDayNow(),
+  _now: timeCore.now(),
   groupNow: null,
   eventNow: null,
   eventNext: null,
   eventFlag: null,
-  offset: { ...runtimeStorePlaceholder.offset },
+  offset: { ...runtimePlaceholder.offset },
-  timer: { ...runtimeStorePlaceholder.timer },
+  timer: {
-  rundown: { ...runtimeStorePlaceholder.rundown },
+    ...runtimePlaceholder.timer,
+  },
+  rundown: {
+    ...runtimePlaceholder.rundown,
+  },
   _timer: {
-    forceFinish: null,
+    forceFinish: false,
     pausedAt: null,
-    pausedDuration: 0,
+    pausedDuration: 0 as Duration,
     secondaryTarget: null,
     hasFinished: false,
   },
@@ -103,19 +143,32 @@ const runtimeState: RuntimeState = {
   _startDayOffset: null,
 };
 
+export function getInternalState(): Readonly<InternalRuntimeState> {
+  return runtimeState;
+}
+
 export function getState(): Readonly<RuntimeState> {
   // create a shallow copy of the state
   return {
     ...runtimeState,
+    clock: timeCore.toTimeOfDay(runtimeState._now),
     eventNow: runtimeState.eventNow ? { ...runtimeState.eventNow } : null,
     eventNext: runtimeState.eventNext ? { ...runtimeState.eventNext } : null,
     eventFlag: runtimeState.eventFlag ? { ...runtimeState.eventFlag } : null,
     groupNow: runtimeState.groupNow ? { ...runtimeState.groupNow } : null,
     offset: { ...runtimeState.offset },
     rundown: { ...runtimeState.rundown },
-    timer: { ...runtimeState.timer },
+    timer: {
-    _timer: { ...runtimeState._timer },
+      addedTime: runtimeState.timer.addedTime,
-    _rundown: { ...runtimeState._rundown },
+      current: runtimeState.timer.current,
+      duration: runtimeState.timer.duration,
+      elapsed: runtimeState.timer.elapsed,
+      expectedFinish: runtimeState.timer.expectedFinish,
+      phase: runtimeState.timer.phase,
+      playback: runtimeState.timer.playback,
+      secondaryTimer: runtimeState.timer.secondaryTimer,
+      startedAt: runtimeState.timer.startedAt ? timeCore.toTimeOfDay(runtimeState.timer.startedAt) : null,
+    },
   };
 }
 
@@ -126,22 +179,18 @@ export function clearEventData() {
   runtimeState.eventNow = null;
   runtimeState.eventNext = null;
 
-  runtimeState.offset.absolute = 0;
+  runtimeState.offset = { ...runtimePlaceholder.offset };
-  runtimeState.offset.relative = 0;
-  runtimeState.offset.expectedFlagStart = null;
-  runtimeState.offset.expectedGroupEnd = null;
-  runtimeState.offset.expectedRundownEnd = null;
 
   runtimeState.rundown.selectedEventIndex = null;
 
   runtimeState.timer.playback = Playback.Stop;
-  runtimeState.clock = timeCore.timeOfDayNow();
+  runtimeState._now = timeCore.now();
-  runtimeState.timer = { ...runtimeStorePlaceholder.timer };
+  runtimeState.timer = { ...runtimePlaceholder.timer };
 
   // when clearing, we maintain the total delay from the rundown
-  runtimeState._timer.forceFinish = null;
+  runtimeState._timer.forceFinish = false;
   runtimeState._timer.pausedAt = null;
-  runtimeState._timer.pausedDuration = 0;
+  runtimeState._timer.pausedDuration = 0 as Duration;
   runtimeState._timer.secondaryTarget = null;
   runtimeState._timer.hasFinished = false;
 }
@@ -159,22 +208,18 @@ export function clearState() {
   runtimeState.rundown.actualStart = null;
   runtimeState.rundown.selectedEventIndex = null;
 
-  runtimeState.offset.absolute = 0;
+  runtimeState.offset = { ...runtimePlaceholder.offset };
-  runtimeState.offset.relative = 0;
-  runtimeState.offset.expectedRundownEnd = null;
-  runtimeState.offset.expectedGroupEnd = null;
-  runtimeState.offset.expectedFlagStart = null;
 
   runtimeState._end = null;
 
   runtimeState.timer.playback = Playback.Stop;
-  runtimeState.clock = timeCore.timeOfDayNow();
+  runtimeState._now = timeCore.now();
-  runtimeState.timer = { ...runtimeStorePlaceholder.timer };
+  runtimeState.timer = { ...runtimePlaceholder.timer };
 
   // when clearing, we maintain the total delay from the rundown
-  runtimeState._timer.forceFinish = null;
+  runtimeState._timer.forceFinish = false;
   runtimeState._timer.pausedAt = null;
-  runtimeState._timer.pausedDuration = 0;
+  runtimeState._timer.pausedDuration = 0 as Duration;
   runtimeState._timer.secondaryTarget = null;
   runtimeState._timer.hasFinished = false;
 
@@ -216,9 +261,9 @@ export function updateRundownData(rundownData: {
   runtimeState._rundown.totalDelay = rundownData.totalDelay;
 
   runtimeState.rundown.numEvents = rundownData.numEvents;
-  runtimeState.rundown.plannedStart = rundownData.firstStart;
+  runtimeState.rundown.plannedStart = rundownData.firstStart as TimeOfDay;
   runtimeState.rundown.plannedEnd =
-    rundownData.firstStart === null ? null : rundownData.firstStart + rundownData.totalDuration;
+    rundownData.firstStart === null ? null : ((rundownData.firstStart + rundownData.totalDuration) as TimeOfDay);
 
   if (isPlaybackActive(runtimeState.timer.playback)) getExpectedTimes();
 }
@@ -252,7 +297,7 @@ export function load(
 
   // update state
   runtimeState.timer.playback = Playback.Armed;
-  runtimeState.timer.duration = calculateDuration(event.timeStart, event.timeEnd);
+  runtimeState.timer.duration = event.duration as Duration;
   runtimeState.timer.current = getCurrent(runtimeState);
   runtimeState.rundown.numEvents = metadata.timedEventOrder.length;
 
@@ -266,13 +311,13 @@ export function load(
       (firstStart === null || typeof firstStart === 'number') &&
       (startEpoch === null || typeof startEpoch === 'number')
     ) {
-      runtimeState.rundown.actualStart = firstStart;
+      runtimeState.rundown.actualStart = firstStart as TimeOfDay;
       runtimeState._startEpoch = startEpoch;
       if (firstStart !== null && runtimeState.rundown.plannedStart !== null) {
         runtimeState._startDayOffset = findDayOffset(runtimeState.rundown.plannedStart, firstStart);
       }
       if (currentDay !== undefined) {
-        runtimeState.rundown.currentDay = currentDay;
+        runtimeState.rundown.currentDay = currentDay as Day;
       }
       const { absolute, relative } = getRuntimeOffset(runtimeState);
       runtimeState.offset.absolute = absolute;
@@ -364,16 +409,16 @@ export function updateLoaded(event?: PlayableEvent): string | undefined {
 
     // handle edge cases with roll
     if (runtimeState.timer.playback === Playback.Roll) {
-      const offsetClock = runtimeState.clock - runtimeState.offset.absolute;
+      const offsetClock = timeCore.toTimeOfDay(runtimeState._now) - runtimeState.offset.absolute;
       // if waiting to roll, we update the targets and potentially start the timer
       if (runtimeState._timer.secondaryTarget !== null) {
         if (runtimeState.eventNow.timeStart < offsetClock && offsetClock < runtimeState.eventNow.timeEnd) {
           // if the event is now, we queue a start
           runtimeState._timer.secondaryTarget = runtimeState.eventNow.timeStart as TimeOfDay;
-          runtimeState.timer.secondaryTimer = runtimeState._timer.secondaryTarget - offsetClock;
+          runtimeState.timer.secondaryTimer = (runtimeState._timer.secondaryTarget - offsetClock) as Duration;
         } else {
           runtimeState._timer.secondaryTarget = normaliseRollStart(
-            runtimeState.eventNow.timeStart,
+            runtimeState.eventNow.timeStart as TimeOfDay,
             offsetClock,
           ) as TimeOfDay;
         }
@@ -390,7 +435,7 @@ export function updateLoaded(event?: PlayableEvent): string | undefined {
 
   runtimeState.timer.startedAt = null;
   runtimeState._timer.hasFinished = false;
-  runtimeState.timer.addedTime = 0;
+  runtimeState.timer.addedTime = 0 as Duration;
   runtimeState._timer.pausedAt = null;
 
   // this could be looked after by the timer
@@ -413,7 +458,7 @@ export function updateAll(rundown: Rundown, metadata: RundownMetadata) {
   loadGroupFlagAndEnd(rundown, metadata, eventNowIndex);
 }
 
-export function start(state: RuntimeState = runtimeState): boolean {
+export function start(state: InternalRuntimeState = runtimeState): boolean {
   if (state.eventNow === null) {
     return false;
   }
@@ -421,22 +466,19 @@ export function start(state: RuntimeState = runtimeState): boolean {
     return false;
   }
 
-  const epoch = timeCore.now();
+  state._now = timeCore.now();
-  const now = timeCore.toTimeOfDay(epoch);
-
-  state.clock = now;
   state.timer.secondaryTimer = null;
 
   // add paused time if it exists
   if (state._timer.pausedAt) {
-    const timeToAdd = state.clock - state._timer.pausedAt;
+    const timeToAdd = (timeCore.toTimeOfDay(state._now) - state._timer.pausedAt) as Duration;
-    state.timer.addedTime += timeToAdd;
+    state.timer.addedTime = timeCore.combineValues(state.timer.addedTime, timeToAdd);
-    state._timer.pausedDuration += timeToAdd;
+    state._timer.pausedDuration = timeCore.combineValues(state._timer.pausedDuration, timeToAdd);
     state._timer.pausedAt = null;
   }
 
   if (state.timer.startedAt === null) {
-    state.timer.startedAt = state.clock;
+    state.timer.startedAt = state._now;
   }
 
   state.timer.playback = Playback.Play;
@@ -444,14 +486,15 @@ export function start(state: RuntimeState = runtimeState): boolean {
   state.timer.elapsed = getElapsed(state);
 
   if (state.rundown.actualStart === null) {
-    state._startDayOffset = (findDayOffset(state.eventNow.timeStart, state.clock) + state.eventNow.dayOffset) as Day;
+    state._startDayOffset = (findDayOffset(state.eventNow.timeStart, timeCore.toTimeOfDay(state._now)) +
+      state.eventNow.dayOffset) as Day;
     state.rundown.currentDay = state._startDayOffset;
-    state._startEpoch = epoch;
+    state._startEpoch = state._now;
-    state.rundown.actualStart = state.clock;
+    state.rundown.actualStart = timeCore.toTimeOfDay(state._now);
   }
 
   if (state.groupNow !== null && state.rundown.actualGroupStart === null) {
-    state.rundown.actualGroupStart = state.clock;
+    state.rundown.actualGroupStart = timeCore.toTimeOfDay(state._now);
   }
 
   // update timer phase
@@ -474,18 +517,18 @@ export function start(state: RuntimeState = runtimeState): boolean {
   return true;
 }
 
-export function pause(state: RuntimeState = runtimeState): boolean {
+export function pause(state: InternalRuntimeState = runtimeState): boolean {
   if (state.timer.playback !== Playback.Play) {
     return false;
   }
 
   state.timer.playback = Playback.Pause;
-  state.clock = timeCore.timeOfDayNow();
+  state._now = timeCore.now();
-  state._timer.pausedAt = state.clock;
+  state._timer.pausedAt = timeCore.toTimeOfDay(state._now);
   return true;
 }
 
-export function stop(state: RuntimeState = runtimeState): boolean {
+export function stop(state: InternalRuntimeState = runtimeState): boolean {
   if (state.timer.playback === Playback.Stop) {
     return false;
   }
@@ -515,7 +558,7 @@ export function addTime(amount: number) {
 
   if (willGoNegative && !runtimeState._timer.hasFinished) {
     // set finished time so side effects are triggered
-    runtimeState._timer.forceFinish = timeCore.timeOfDayNow();
+    runtimeState._timer.forceFinish = true;
   } else {
     const willGoPositive = runtimeState.timer.current < 0 && runtimeState.timer.current + amount > 0;
     if (willGoPositive) {
@@ -524,8 +567,8 @@ export function addTime(amount: number) {
   }
 
   // we can update the state after handling the side effects
-  runtimeState.timer.addedTime += amount;
+  runtimeState.timer.addedTime = timeCore.combineValues(runtimeState.timer.addedTime, amount as Duration);
-  runtimeState.timer.current += amount;
+  runtimeState.timer.current = timeCore.combineValues(runtimeState.timer.current, amount as Duration);
   runtimeState.timer.elapsed = getElapsed(runtimeState);
 
   // update runtime delays: over - under
@@ -545,10 +588,8 @@ export type UpdateResult = {
 
 export function update(): UpdateResult {
   // 0. there are some things we always do
-  const previousClock = runtimeState.clock;
+  const previousClock = timeCore.toTimeOfDay(runtimeState._now);
-  const epoch = timeCore.now();
+  runtimeState._now = timeCore.now(); // we update the clock on every update call
-  const now = timeCore.toTimeOfDay(epoch);
-  runtimeState.clock = now; // we update the clock on every update call
 
   // 1. is playback idle?
   if (!isPlaybackActive(runtimeState.timer.playback)) {
@@ -557,13 +598,13 @@ export function update(): UpdateResult {
 
   // calculate currentDay from epoch (days elapsed since playback was started)
   if (runtimeState._startEpoch !== null && runtimeState._startDayOffset !== null) {
-    const daysSinceStart = timeCore.daysSinceStart(runtimeState._startEpoch, epoch);
+    const daysSinceStart = timeCore.daysSinceStart(runtimeState._startEpoch, runtimeState._now);
-    runtimeState.rundown.currentDay = runtimeState._startDayOffset + daysSinceStart;
+    runtimeState.rundown.currentDay = timeCore.combineValues(runtimeState._startDayOffset, daysSinceStart);
   }
 
   // 2. are we waiting to roll?
   if (runtimeState.timer.playback === Playback.Roll && runtimeState.timer.secondaryTimer !== null) {
-    const clockHasCrossedMidnight = hasCrossedMidnight(previousClock, now);
+    const clockHasCrossedMidnight = hasCrossedMidnight(previousClock, timeCore.toTimeOfDay(runtimeState._now));
     return updateIfWaitingToRoll(clockHasCrossedMidnight);
   }
 
@@ -617,22 +658,24 @@ export function update(): UpdateResult {
     }
 
     // account for offset
-    const offsetClock = runtimeState.clock + runtimeState.offset.absolute;
+    const offsetClock = timeCore.toTimeOfDay(
+      timeCore.addDuration(runtimeState._now, runtimeState.offset.absolute as Duration),
+    );
     runtimeState.timer.phase = TimerPhase.Pending;
 
     if (hasCrossedMidnight) {
       // if we crossed midnight, we need to update the target
       // this is the same logic from the roll function
       runtimeState._timer.secondaryTarget = normaliseRollStart(
-        runtimeState.eventNow.timeStart,
+        runtimeState.eventNow.timeStart as TimeOfDay,
         offsetClock,
       ) as TimeOfDay;
     }
 
-    runtimeState.timer.secondaryTimer = runtimeState._timer.secondaryTarget! - offsetClock;
+    runtimeState.timer.secondaryTimer = (runtimeState._timer.secondaryTarget! - offsetClock) as Duration;
     return {
       hasTimerFinished: false,
-      hasSecondaryTimerFinished: runtimeState.timer.secondaryTimer <= 0,
+      hasSecondaryTimerFinished: runtimeState.timer.secondaryTimer! <= 0,
     };
   }
 }
@@ -649,9 +692,7 @@ export function roll(
   }
 
   // we will need to do some calculations, update the time first
-  const epoch = timeCore.now();
+  runtimeState._now = timeCore.now();
-  const now = timeCore.toTimeOfDay(epoch);
-  runtimeState.clock = now;
 
   // 2. if there is an event armed, we use it
   if (runtimeState.timer.playback === Playback.Armed || runtimeState.timer.phase === TimerPhase.Pending) {
@@ -663,7 +704,9 @@ export function roll(
     }
 
     if (offset) {
-      runtimeState.offset = { ...offset };
+      runtimeState.offset = {
+        ...offset,
+      } as InternalRuntimeState['offset'];
     }
     runtimeState.timer.playback = Playback.Roll;
 
@@ -672,15 +715,16 @@ export function roll(
       runtimeState.eventNow.timeEnd < runtimeState.eventNow.timeStart
         ? runtimeState.eventNow.timeEnd + dayInMs
         : runtimeState.eventNow.timeEnd;
-    runtimeState.timer.expectedFinish = normalisedEndTime;
+    runtimeState.timer.expectedFinish = normalisedEndTime as TimeOfDay;
 
     // account for offset
-    const offsetClock = runtimeState.clock - runtimeState.offset.absolute;
+    // const offsetClock = timeCore.addDuration(runtimeState._now, -runtimeState.offset.absolute as Duration);
+    const offsetClock = timeCore.toTimeOfDay(runtimeState._now) - runtimeState.offset.absolute;
 
     // state catch up
     runtimeState.timer.duration = calculateDuration(runtimeState.eventNow.timeStart, normalisedEndTime);
     runtimeState.timer.current = runtimeState.timer.duration;
-    runtimeState.timer.elapsed = 0;
+    runtimeState.timer.elapsed = 0 as Duration;
 
     // check if the event is ready to start or if needs to be pending
     const isNow = checkIsNow(runtimeState.eventNow.timeStart, runtimeState.eventNow.timeEnd, offsetClock);
@@ -689,8 +733,8 @@ export function roll(
        * If we are starting an event in roll mode
        * we backtrace all the start times to the supposed start time of the event
        */
-      const plannedStart = runtimeState.eventNow.timeStart;
+      const plannedStart = runtimeState.eventNow.timeStart as TimeOfDay;
-      runtimeState.timer.startedAt = plannedStart;
+      runtimeState.timer.startedAt = timeCore.toInstant(plannedStart, runtimeState._now);
       // reset the secondary timer to cancel any countdowns
       runtimeState.timer.secondaryTimer = null;
 
@@ -708,18 +752,20 @@ export function roll(
         runtimeState._startDayOffset = (findDayOffset(runtimeState.eventNow.timeStart, plannedStart) +
           runtimeState.eventNow.dayOffset) as Day;
         // backdate _startEpoch to when the event conceptually started
-        const timeElapsed = timeCore.elapsedTime(runtimeState.clock, plannedStart as TimeOfDay);
+        const timeElapsed = timeCore.elapsedTime(timeCore.toTimeOfDay(runtimeState._now), plannedStart as TimeOfDay);
-        runtimeState._startEpoch = timeCore.addDuration(epoch, -timeElapsed as Duration);
+        runtimeState._startEpoch = timeCore.addDuration(runtimeState._now, -timeElapsed as Duration);
         // calculate currentDay from the backdated epoch
-        runtimeState.rundown.currentDay =
+        runtimeState.rundown.currentDay = timeCore.combineValues(
-          runtimeState._startDayOffset + timeCore.daysSinceStart(runtimeState._startEpoch, epoch);
+          runtimeState._startDayOffset,
+          timeCore.daysSinceStart(runtimeState._startEpoch, runtimeState._now),
+        );
       }
     } else {
       runtimeState._timer.secondaryTarget = normaliseRollStart(
-        runtimeState.eventNow.timeStart,
+        runtimeState.eventNow.timeStart as TimeOfDay,
         offsetClock,
       ) as TimeOfDay;
-      runtimeState.timer.secondaryTimer = runtimeState._timer.secondaryTarget - offsetClock;
+      runtimeState.timer.secondaryTimer = (runtimeState._timer.secondaryTarget - offsetClock) as Duration;
       runtimeState.timer.phase = TimerPhase.Pending;
     }
 
@@ -736,9 +782,9 @@ export function roll(
 
   // account for offset but we only keep it if passed to us
   if (offset) {
-    runtimeState.offset = { ...offset };
+    runtimeState.offset = { ...offset } as InternalRuntimeState['offset'];
   }
-  const offsetClock = runtimeState.clock - runtimeState.offset.absolute;
+  const offsetClock = timeCore.toTimeOfDay(runtimeState._now) - runtimeState.offset.absolute;
 
   const { index, isPending } = loadRoll(rundown, metadata, offsetClock);
 
@@ -765,7 +811,7 @@ export function roll(
     runtimeState.timer.phase = TimerPhase.Pending;
     // we need to normalise start time in case it is the day after
     runtimeState._timer.secondaryTarget = normaliseRollStart(runtimeState.eventNow.timeStart, offsetClock) as TimeOfDay;
-    runtimeState.timer.secondaryTimer = runtimeState._timer.secondaryTarget - offsetClock;
+    runtimeState.timer.secondaryTimer = (runtimeState._timer.secondaryTarget - offsetClock) as Duration;
 
     // preload timer properties
     runtimeState.timer.duration = calculateDuration(runtimeState.eventNow.timeStart, runtimeState.eventNow.timeEnd);
@@ -788,18 +834,18 @@ export function roll(
    * when we start in roll mode
    * we need to backtrace all times to the supposed start time of the event
    */
-  const plannedStart = runtimeState.eventNow.timeStart;
+  const plannedStart = runtimeState.eventNow.timeStart as TimeOfDay;
   const endTime =
     runtimeState.eventNow.timeEnd < runtimeState.eventNow.timeStart
       ? runtimeState.eventNow.timeEnd + dayInMs
       : runtimeState.eventNow.timeEnd;
-  runtimeState.timer.startedAt = plannedStart;
+  runtimeState.timer.startedAt = timeCore.toInstant(plannedStart, runtimeState._now);
-  runtimeState.timer.expectedFinish = endTime;
+  runtimeState.timer.expectedFinish = endTime as TimeOfDay;
 
   // state catch up
   runtimeState.timer.duration = calculateDuration(runtimeState.eventNow.timeStart, endTime);
   runtimeState.timer.current = getCurrent(runtimeState);
-  runtimeState.timer.elapsed = 0;
+  runtimeState.timer.elapsed = 0 as Duration;
 
   // update runtime
   runtimeState.rundown.actualStart = plannedStart;
@@ -812,11 +858,11 @@ export function roll(
   runtimeState._startDayOffset = (findDayOffset(runtimeState.eventNow.timeStart, plannedStart) +
     runtimeState.eventNow.dayOffset) as Day;
   // backdate _startEpoch to when the event conceptually started
-  const timeElapsed = timeCore.elapsedTime(runtimeState.clock, plannedStart as TimeOfDay);
+  const timeElapsed = timeCore.elapsedTime(timeCore.toTimeOfDay(runtimeState._now), plannedStart as TimeOfDay);
-  runtimeState._startEpoch = timeCore.addDuration(epoch, -timeElapsed as Duration);
+  runtimeState._startEpoch = timeCore.addDuration(runtimeState._now, -timeElapsed as Duration);
   // calculate currentDay from the backdated epoch
   runtimeState.rundown.currentDay = (runtimeState._startDayOffset +
-    timeCore.daysSinceStart(runtimeState._startEpoch, epoch)) as Day;
+    timeCore.daysSinceStart(runtimeState._startEpoch, runtimeState._now)) as Day;
 
   return { eventId: runtimeState.eventNow.id, didStart: true };
 }
@@ -831,7 +877,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 +897,11 @@ function getExpectedTimes(state = runtimeState) {
         plannedStart,
         actualStart,
       });
-      state.offset.expectedGroupEnd = lastEventExpectedStart + lastEvent.duration;
+      state.offset.expectedGroupEnd = getExpectedEnd(
+        lastEvent,
+        lastEventExpectedStart,
+        state.rundown.currentDay!,
+      ) as TimeOfDay;
     }
   }
 
@@ -869,7 +918,7 @@ function getExpectedTimes(state = runtimeState) {
         plannedStart,
         actualStart,
       });
-      state.offset.expectedFlagStart = expectedStart;
+      state.offset.expectedFlagStart = expectedStart as TimeOfDay;
     }
   }
 
@@ -884,7 +933,7 @@ function getExpectedTimes(state = runtimeState) {
       plannedStart,
       actualStart,
     });
-    state.offset.expectedRundownEnd = expectedStart + event.duration;
+    state.offset.expectedRundownEnd = getExpectedEnd(event, expectedStart, state.rundown.currentDay!) as TimeOfDay;
   }
 }
 
@@ -927,6 +976,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,20 +984,35 @@ 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)) {
           foundFlag = true;
           state.eventFlag = entry as PlayableEvent; // we know it is playable as it is coming from the playableEventOrder list
-          state._flag = { event: entry, isLinkedToLoaded, accumulatedGap };
+          state._flag = { event: entry, isLinkedToLoaded, accumulatedGap: accumulatedGap as Duration };
         }
       }
 
       if (!foundGroupEnd && entry.id === lastEventInGroup?.id) {
         foundGroupEnd = true;
-        state._group = { event: lastEventInGroup, isLinkedToLoaded, accumulatedGap };
+        state._group = { event: lastEventInGroup, isLinkedToLoaded, accumulatedGap: accumulatedGap as Duration };
       }
     }
   }
@@ -955,7 +1020,7 @@ export function loadGroupFlagAndEnd(
   const lastID = playableEventOrder.at(-1);
   const lastEvent = lastID ? (entries[lastID] as OntimeEvent) : null;
   if (lastEvent) {
-    state._end = { event: lastEvent, isLinkedToLoaded, accumulatedGap };
+    state._end = { event: lastEvent, isLinkedToLoaded, accumulatedGap: accumulatedGap as Duration };
   }
 }
 

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

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ontime",
-  "version": "4.10.0",
+  "version": "4.11.0",
   "description": "Time keeping for live events",
   "keywords": [
     "ontime",

packages/types/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.10.0",
+  "version": "4.11.0",
   "name": "ontime-types",
   "type": "module",
   "main": "./src/index.ts",

packages/types/src/api/rundown-controller/BackendResponse.type.ts

@@ -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;
+  after?: EntryId | true;
-  before?: EntryId;
+  before?: EntryId | true;
 };
 
 export type EventPostPayload = Partial<OntimeEntry> & InsertOptions;

packages/types/src/api/spreadsheet/Spreadsheet.type.ts

@@ -18,3 +18,44 @@ export type SpreadsheetPreviewResponse = {
   customFields: CustomFields;
   summary: RundownSummary;
 };
+
+/**
+ * How elements matched by id should be reconciled when importing into an existing rundown
+ * - override: imported data replaces the whole matched element
+ * - merge: imported data updates only the fields the spreadsheet supplied, keeping the rest
+ */
+export type RundownImportMergeStrategy = 'override' | 'merge';
+
+/**
+ * What an import does with the data
+ * - override / merge apply the import onto an existing rundown (reconciling matched elements)
+ * - new creates a fresh rundown from the import
+ */
+export type RundownImportMode = RundownImportMergeStrategy | 'new';
+
+/**
+ * The fields an import supplies, i.e. the columns the spreadsheet maps.
+ * This is the complete description of what the incoming data provides, so a merge can apply exactly
+ * these fields onto a matched event and keep everything else (e.g. automations) untouched.
+ */
+export type ImportedFields = {
+  /** mapped OntimeEvent fields (the import-map keys are OntimeEvent field names) */
+  event: string[];
+  /** mapped custom field keys */
+  custom: string[];
+};
+
+/**
+ * Payload for the rundown import endpoint
+ * - override / merge apply the import onto the target rundown (targetRundownId required)
+ * - new creates a fresh rundown from the import
+ */
+export type RundownImportPayload = {
+  mode: RundownImportMode;
+  /** required when mode is 'override' or 'merge' */
+  targetRundownId?: string;
+  rundown: Rundown;
+  customFields: CustomFields;
+  /** the fields the spreadsheet supplies; used by 'merge' to patch only those on a matched event */
+  providedFields?: ImportedFields;
+};

packages/types/src/index.ts

@@ -97,6 +97,10 @@ export type {
   SpreadsheetWorksheetMetadata,
   SpreadsheetWorksheetOptions,
   SpreadsheetPreviewResponse,
+  RundownImportMergeStrategy,
+  RundownImportMode,
+  RundownImportPayload,
+  ImportedFields,
 } from './api/spreadsheet/Spreadsheet.type.js';
 
 // web socket

packages/utils/index.ts

@@ -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';

packages/utils/src/date-utils/getExpected.test.ts

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

packages/utils/src/date-utils/getExpected.ts

@@ -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;
+}

packages/utils/src/rundown-utils/rundownUtils.test.ts

@@ -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', () => {
+  it('returns null if after is true', () => {
-    expect(getInsertAfterId(rundown, null, undefined, 'z')).toBeNull();
+    expect(getInsertAfterId(rundown, null, true)).toBeNull();
-    expect(getInsertAfterId(rundown, null, undefined, '1')).toBeNull();
   });
 
-  it('returns the previous id of an entry in the rundown', () => {
+  it('returns the before id if provided', () => {
-    expect(getInsertAfterId(rundown, null, undefined, '2')).toBe('1');
+    expect(getInsertAfterId(rundown, null, undefined, '2')).toBe('2');
-    expect(getInsertAfterId(rundown, null, undefined, '4')).toBe('group');
+    expect(getInsertAfterId(rundown, null, undefined, '4')).toBe('4');
-    expect(getInsertAfterId(rundown, null, undefined, 'group')).toBe('2');
+    expect(getInsertAfterId(rundown, null, undefined, 'group')).toBe('group');
   });
 
-  it('returns the previous id of an event in a group', () => {
+  it('returns the first top-level id if before is true', () => {
-    expect(getInsertAfterId(rundown, rundown.entries.group as OntimeGroup, undefined, '31')).toBeNull();
+    expect(getInsertAfterId(rundown, null, undefined, true)).toBe('1');
-    expect(getInsertAfterId(rundown, rundown.entries.group as OntimeGroup, undefined, '32')).toBe('31');
+  });
+
+  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
+  // case 2c: insert at the end of the rundown
-  it('adds at the beginning of order and flatOrder when afterId is null', () => {
+  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.order).toEqual(['1', '2', 'group', 'new']);
-    expect(rundown.flatOrder).toEqual(['new', '1', '2', 'group', '31', '32']);
+    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('prepends to the rundown when before is true', () => {
-  it('inserts right after the group header in flatOrder and sets parent', () => {
+    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');

packages/utils/src/rundown-utils/rundownUtils.ts

@@ -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,
+  afterId?: EntryId | true,
-  beforeId?: EntryId,
+  beforeId?: EntryId | true,
 ): EntryId | null {
-  if (afterId) return afterId;
+  if (beforeId) {
-  if (!beforeId) return null;
+    const insertionList = parent ? parent.entries : rundown.order;
+    return beforeId === true ? (insertionList[0] ?? null) : beforeId;
+  }
 
-  const insertionList = parent ? parent.entries : rundown.order;
+  if (afterId) return afterId === true ? null : afterId;
-  if (!insertionList || insertionList.length === 0) return null;
 
-  const atIndex = insertionList.findIndex((id) => id === beforeId);
+  return null;
-  if (atIndex < 1) return null;
-  return insertionList[atIndex - 1];
 }
 
 type ResolveInsertParentOptions = {
   parent?: EntryId | null;
-  after?: EntryId;
+  after?: EntryId | true;
-  before?: EntryId;
+  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;
+  // 2. ... otherwise we look for a sibling and get their parent
-  if (!referenceId) return null;
+  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:
+ * if afterId and beforeId are not provided, we add at the end of the rundown
- * - 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
  */
 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
+    if (isOntimeGroup(entry)) {
-
+      throw new Error('Cannot add a group to another group');
-    // assign the parent reference on the entry
-    if ('parent' in entry) {
-      entry.parent = parent.id;
     }
 
-    if (afterId) {
+    entry.parent = parent.id;
-      // 1a. insert after a given entry within the group
+    parent.entries = insertAtIndex(insertionIndex, entry.id, parent.entries);
-      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);
-    }
   } else {
-    // 2. inserting an entry at top level
+    rundown.order = insertAtIndex(insertionIndex, entry.id, rundown.order);
-    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.flatOrder = insertAtIndex(flatIndex, entry.id, rundown.flatOrder);
 
   // either way, we register the entry in the entries map
   rundown.entries[entry.id] = entry;

packages/utils/src/validate-times/validateTimes.ts

@@ -1,4 +1,4 @@
-import type { OntimeEvent } from 'ontime-types';
+import type { Duration, OntimeEvent } from 'ontime-types';
 import { TimeStrategy } from 'ontime-types';
 
 import { dayInMs } from '../date-utils/conversionUtils.js';
@@ -103,16 +103,17 @@ export function validateTimes(
 
 /**
  * @description calculates event duration considering midnight
+ * @deprecated - duration is the more useful value from the event data, prefer using that directly
  * @param {number} timeStart
  * @param {number} timeEnd
  * @returns {number}
  */
-export function calculateDuration(timeStart: number, timeEnd: number): number {
+export function calculateDuration(timeStart: number, timeEnd: number): Duration {
   // Durations must be positive
   if (timeEnd < timeStart) {
-    return timeEnd + dayInMs - timeStart;
+    return (timeEnd + dayInMs - timeStart) as Duration;
   }
-  return timeEnd - timeStart;
+  return (timeEnd - timeStart) as Duration;
 }
 
 export function calculateEnd(timeStart: number, duration: number): number {