Add persistent live controls and interaction notes

src/lib/server/live.ts

@@ -11,6 +11,7 @@ import {
 	movePieceUsage,
 	type MovePieceUsageInput,
 	type PieceUsage,
+	type ShowStatus,
 	type ShowSection
 } from './shows.js';
 
@@ -41,6 +42,7 @@ export type LiveUsage = PieceUsage & {
 	introHtml: string;
 	researchHtml: string;
 	moderationHtml: string;
+	interactionHtml: string;
 	transitionHtml: string;
 };
 
@@ -55,7 +57,10 @@ export type LiveView = {
 		totalDurationSeconds: number;
 	};
 	liveRevision: number;
+	calculatedAtUtc: string;
 	startedAtUtc: string | null;
+	endedAtUtc: string | null;
+	isPaused: boolean;
 	updatedAtUtc: string;
 	presentationUsageId: string | null;
 	presentationRevision: number;
@@ -72,6 +77,15 @@ export type LiveView = {
 		elapsedSeconds: number;
 		runningSinceUtc: string | null;
 	};
+	totalTimer: {
+		elapsedSeconds: number;
+		runningSinceUtc: string | null;
+	};
+	remainingEstimate: {
+		seconds: number;
+		activeCountdownSeconds: number;
+		unplannedSectionCount: number;
+	};
 };
 
 export type PresentationView = {
@@ -152,6 +166,55 @@ function closeActiveRun(database: Database.Database, showId: string, now: string
 		.run(now, showId);
 }
 
+function closeShowTimerRun(database: Database.Database, showId: string, now: string) {
+	database
+		.prepare(
+			`UPDATE live_show_timer_runs SET ended_at_utc = ?
+			 WHERE show_id = ? AND ended_at_utc IS NULL`
+		)
+		.run(now, showId);
+}
+
+function openShowTimerRun(database: Database.Database, showId: string, now: string) {
+	const active = database
+		.prepare('SELECT 1 FROM live_show_timer_runs WHERE show_id = ? AND ended_at_utc IS NULL')
+		.get(showId);
+	if (!active) {
+		database
+			.prepare(
+				`INSERT INTO live_show_timer_runs (id, show_id, started_at_utc)
+				 VALUES (?, ?, ?)`
+			)
+			.run(randomUUID(), showId, now);
+	}
+}
+
+function showTimerRunning(database: Database.Database, showId: string) {
+	return Boolean(
+		database
+			.prepare('SELECT 1 FROM live_show_timer_runs WHERE show_id = ? AND ended_at_utc IS NULL')
+			.get(showId)
+	);
+}
+
+function elapsedRuns(
+	runs: { started_at_utc: string; ended_at_utc: string | null }[],
+	now: string
+) {
+	return runs.reduce(
+		(total, run) =>
+			total +
+			Math.max(
+				0,
+				Math.floor(
+					(new Date(run.ended_at_utc ?? now).getTime() - new Date(run.started_at_utc).getTime()) /
+						1_000
+				)
+			),
+		0
+	);
+}
+
 function closeSectionTimer(database: Database.Database, showId: string, now: string) {
 	const timer = database
 		.prepare('SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL')
@@ -167,6 +230,26 @@ function closeSectionTimer(database: Database.Database, showId: string, now: str
 		.run(now, timer.id);
 }
 
+function resumeSectionTimerRun(database: Database.Database, showId: string, now: string) {
+	const timer = database
+		.prepare('SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL')
+		.get(showId) as { id: string } | undefined;
+	if (!timer) return;
+	const running = database
+		.prepare(
+			'SELECT 1 FROM live_section_timer_runs WHERE timer_id = ? AND ended_at_utc IS NULL'
+		)
+		.get(timer.id);
+	if (!running) {
+		database
+			.prepare(
+				`INSERT INTO live_section_timer_runs (id, timer_id, started_at_utc)
+				 VALUES (?, ?, ?)`
+			)
+			.run(randomUUID(), timer.id, now);
+	}
+}
+
 function syncSectionTimer(
 	database: Database.Database,
 	showId: string,
@@ -237,7 +320,8 @@ function executeCommand(
 	expectedRevision: number,
 	action: string,
 	operation: (database: Database.Database, state: LiveStateRow, now: string) => void,
-	nowValue?: Date
+	nowValue?: Date,
+	allowCompleted = false
 ) {
 	requireCommandId(commandId);
 	const database = getDatabase();
@@ -251,7 +335,7 @@ function executeCommand(
 		const show = database.prepare('SELECT status FROM shows WHERE id = ?').get(showId) as {
 			status: string;
 		};
-		if (show.status === 'completed') throw new Error('SHOW_COMPLETED');
+		if (show.status === 'completed' && !allowCompleted) throw new Error('SHOW_COMPLETED');
 		if (state.revision !== expectedRevision) throw new Error('CONFLICT');
 		operation(database, state, now);
 		const updated = database
@@ -307,6 +391,7 @@ function liveUsage(
 		introHtml: renderMarkdown(usage.intro),
 		researchHtml: renderMarkdown(usage.research),
 		moderationHtml: renderMarkdown(usage.moderation),
+		interactionHtml: renderMarkdown(usage.interaction),
 		transitionHtml: renderMarkdown(usage.transition)
 	};
 }
@@ -351,18 +436,7 @@ export function getLiveView(showId: string, nowValue?: Date): LiveView {
 			)
 			.all(timer.id) as { started_at_utc: string; ended_at_utc: string | null }[];
 		const running = runs.find((run) => run.ended_at_utc === null) ?? null;
-		const elapsedSeconds = runs.reduce(
-			(total, run) =>
-				total +
-				Math.max(
-					0,
-					Math.floor(
-						(new Date(run.ended_at_utc ?? now).getTime() - new Date(run.started_at_utc).getTime()) /
-							1_000
-					)
-				),
-			0
-		);
+		const elapsedSeconds = elapsedRuns(runs, now);
 		sectionTimer = {
 			sectionId: timer.section_id,
 			sectionName: timer.section_name,
@@ -371,6 +445,50 @@ export function getLiveView(showId: string, nowValue?: Date): LiveView {
 			runningSinceUtc: running?.started_at_utc ?? null
 		};
 	}
+	const totalTimerRuns = database
+		.prepare(
+			`SELECT started_at_utc, ended_at_utc FROM live_show_timer_runs
+			 WHERE show_id = ? ORDER BY started_at_utc`
+		)
+		.all(showId) as { started_at_utc: string; ended_at_utc: string | null }[];
+	const runningTotalTimer = totalTimerRuns.find((run) => run.ended_at_utc === null) ?? null;
+	const totalElapsedSeconds = elapsedRuns(totalTimerRuns, now);
+	const remainingAnchor = current ?? next;
+	let reachedRemaining = !remainingAnchor;
+	let remainingSeconds = 0;
+	let activeCountdownSeconds = 0;
+	let unplannedSectionCount = 0;
+	for (const section of sections) {
+		if (section.id === remainingAnchor?.sectionId) reachedRemaining = true;
+		if (!reachedRemaining) continue;
+		const remainingUsages = section.usages.filter(
+			(usage) => usage.status === 'open' || usage.status === 'current'
+		);
+		if (remainingUsages.length === 0) continue;
+
+		if (section.id === current?.sectionId) {
+			if (section.durationSeconds > 0 && sectionTimer?.sectionId === section.id) {
+				activeCountdownSeconds = Math.max(0, section.durationSeconds - sectionTimer.elapsedSeconds);
+				remainingSeconds += activeCountdownSeconds;
+			} else {
+				remainingSeconds += remainingUsages.reduce((total, usage) => {
+					const elapsed = usage.id === current?.id ? usage.actualDurationSeconds : 0;
+					const remainder = Math.max(0, usage.durationSeconds - elapsed);
+					if (usage.id === current?.id) activeCountdownSeconds = remainder;
+					return total + remainder;
+				}, 0);
+				if (section.durationSeconds <= 0) unplannedSectionCount += 1;
+			}
+		} else if (section.durationSeconds > 0) {
+			remainingSeconds += section.durationSeconds;
+		} else {
+			remainingSeconds += remainingUsages.reduce(
+				(total, usage) => total + usage.durationSeconds,
+				0
+			);
+			unplannedSectionCount += 1;
+		}
+	}
 	return {
 		show: {
 			id: show.id,
@@ -380,7 +498,10 @@ export function getLiveView(showId: string, nowValue?: Date): LiveView {
 			totalDurationSeconds: show.totalDurationSeconds
 		},
 		liveRevision: state.revision,
+		calculatedAtUtc: now,
 		startedAtUtc: state.started_at_utc,
+		endedAtUtc: state.ended_at_utc,
+		isPaused: Boolean(state.started_at_utc && !state.ended_at_utc && !runningTotalTimer),
 		updatedAtUtc: state.updated_at_utc,
 		presentationUsageId: state.presentation_usage_id,
 		presentationRevision: state.presentation_revision,
@@ -391,7 +512,16 @@ export function getLiveView(showId: string, nowValue?: Date): LiveView {
 		completedCount: usages.filter((usage) => usage.status === 'done' || usage.status === 'skipped')
 			.length,
 		totalCount: usages.length,
-		sectionTimer
+		sectionTimer,
+		totalTimer: {
+			elapsedSeconds: totalElapsedSeconds,
+			runningSinceUtc: runningTotalTimer?.started_at_utc ?? null
+		},
+		remainingEstimate: {
+			seconds: remainingSeconds,
+			activeCountdownSeconds,
+			unplannedSectionCount
+		}
 	};
 }
 
@@ -409,7 +539,7 @@ export function startOrResumeLive(
 		(database, state, now) => {
 			database
 				.prepare(
-					`UPDATE shows SET status = 'live', updated_at_utc = ?
+					`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ?
 					 WHERE id = ? AND status != 'completed'`
 				)
 				.run(now, showId);
@@ -419,10 +549,14 @@ export function startOrResumeLive(
 					 WHERE show_id = ?`
 				)
 				.run(now, showId);
+			openShowTimerRun(database, showId, now);
 			const activeRun = database
 				.prepare('SELECT 1 FROM live_usage_runs WHERE show_id = ? AND ended_at_utc IS NULL')
 				.get(showId);
-			if (state.current_usage_id && activeRun) return;
+			if (state.current_usage_id && activeRun) {
+				resumeSectionTimerRun(database, showId, now);
+				return;
+			}
 			const current = state.current_usage_id
 				? orderedUsages(database, showId).find((usage) => usage.id === state.current_usage_id)
 				: undefined;
@@ -434,6 +568,263 @@ export function startOrResumeLive(
 	);
 }
 
+export function pauseLive(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'pause',
+		(database, state, now) => {
+			if (!state.started_at_utc || state.ended_at_utc) throw new Error('NOT_LIVE');
+			if (!showTimerRunning(database, showId)) throw new Error('ALREADY_PAUSED');
+			closeShowTimerRun(database, showId, now);
+			closeActiveRun(database, showId, now);
+			database
+				.prepare(
+					`UPDATE live_section_timer_runs SET ended_at_utc = ?
+					 WHERE timer_id IN (
+						SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL
+					 ) AND ended_at_utc IS NULL`
+				)
+				.run(now, showId);
+		},
+		nowValue
+	);
+}
+
+export function resumeLive(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'resume',
+		(database, state, now) => {
+			if (!state.started_at_utc || state.ended_at_utc) throw new Error('NOT_LIVE');
+			if (showTimerRunning(database, showId)) throw new Error('ALREADY_RUNNING');
+			openShowTimerRun(database, showId, now);
+			if (state.current_usage_id) {
+				database
+					.prepare(
+						`INSERT INTO live_usage_runs (id, show_id, usage_id, started_at_utc)
+						 VALUES (?, ?, ?, ?)`
+					)
+					.run(randomUUID(), showId, state.current_usage_id, now);
+			}
+			resumeSectionTimerRun(database, showId, now);
+		},
+		nowValue
+	);
+}
+
+export function resetSectionTimer(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'reset-section-timer',
+		(database, _state, now) => {
+			const timer = database
+				.prepare(
+					`SELECT section_id, planned_duration_seconds
+					 FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL`
+				)
+				.get(showId) as
+				| { section_id: string; planned_duration_seconds: number }
+				| undefined;
+			if (!timer) throw new Error('NO_SECTION_TIMER');
+			const running = showTimerRunning(database, showId);
+			closeSectionTimer(database, showId, now);
+			const timerId = randomUUID();
+			database
+				.prepare(
+					`INSERT INTO live_section_timers
+					 (id, show_id, section_id, planned_duration_seconds, started_at_utc)
+					 VALUES (?, ?, ?, ?, ?)`
+				)
+				.run(timerId, showId, timer.section_id, timer.planned_duration_seconds, now);
+			if (running) {
+				database
+					.prepare(
+						`INSERT INTO live_section_timer_runs (id, timer_id, started_at_utc)
+						 VALUES (?, ?, ?)`
+					)
+					.run(randomUUID(), timerId, now);
+			}
+		},
+		nowValue
+	);
+}
+
+export function resetTotalTimer(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'reset-total-timer',
+		(database, state, now) => {
+			if (!state.started_at_utc || state.ended_at_utc) throw new Error('NOT_LIVE');
+			const running = showTimerRunning(database, showId);
+			database.prepare('DELETE FROM live_show_timer_runs WHERE show_id = ?').run(showId);
+			if (running) openShowTimerRun(database, showId, now);
+		},
+		nowValue
+	);
+}
+
+export function setShowStatus(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	expectedShowRevision: number,
+	status: Extract<ShowStatus, 'draft' | 'ready'>,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		`status-${status}`,
+		(database, state, now) => {
+			if (state.started_at_utc) throw new Error('ALREADY_STARTED');
+			const result = database
+				.prepare(
+					'UPDATE shows SET status = ?, revision = revision + 1, updated_at_utc = ? WHERE id = ? AND revision = ?'
+				)
+				.run(status, now, showId, expectedShowRevision);
+			if (result.changes !== 1) throw new Error('CONFLICT');
+		},
+		nowValue
+	);
+}
+
+export function endLive(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'end',
+		(database, state, now) => {
+			if (!state.started_at_utc || state.ended_at_utc) throw new Error('NOT_LIVE');
+			closeShowTimerRun(database, showId, now);
+			closeActiveRun(database, showId, now);
+			database
+				.prepare(
+					`UPDATE live_section_timer_runs SET ended_at_utc = ?
+					 WHERE timer_id IN (
+						SELECT id FROM live_section_timers WHERE show_id = ? AND ended_at_utc IS NULL
+					 ) AND ended_at_utc IS NULL`
+				)
+				.run(now, showId);
+			database
+				.prepare(
+					`UPDATE show_live_states SET ended_at_utc = ? WHERE show_id = ?`
+				)
+				.run(now, showId);
+			database
+				.prepare(`UPDATE shows SET status = 'completed', revision = revision + 1, updated_at_utc = ? WHERE id = ?`)
+				.run(now, showId);
+		},
+		nowValue
+	);
+}
+
+export function resumeEndedLive(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'resume-ended',
+		(database, state, now) => {
+			if (!state.ended_at_utc) throw new Error('NOT_ENDED');
+			database.prepare(`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ? WHERE id = ?`).run(now, showId);
+			database
+				.prepare('UPDATE show_live_states SET ended_at_utc = NULL WHERE show_id = ?')
+				.run(showId);
+			openShowTimerRun(database, showId, now);
+			if (state.current_usage_id) {
+				database
+					.prepare(
+						`INSERT INTO live_usage_runs (id, show_id, usage_id, started_at_utc)
+						 VALUES (?, ?, ?, ?)`
+					)
+					.run(randomUUID(), showId, state.current_usage_id, now);
+				resumeSectionTimerRun(database, showId, now);
+			}
+		},
+		nowValue,
+		true
+	);
+}
+
+export function startNewLiveRun(
+	showId: string,
+	commandId: string,
+	expectedRevision: number,
+	nowValue?: Date
+) {
+	return executeCommand(
+		showId,
+		commandId,
+		expectedRevision,
+		'start-new-run',
+		(database, state, now) => {
+			if (!state.ended_at_utc) throw new Error('NOT_ENDED');
+			database.prepare('DELETE FROM live_usage_runs WHERE show_id = ?').run(showId);
+			database.prepare('DELETE FROM live_show_timer_runs WHERE show_id = ?').run(showId);
+			database.prepare('DELETE FROM live_section_timers WHERE show_id = ?').run(showId);
+			database
+				.prepare(
+					`UPDATE piece_usages SET status = 'open'
+					 WHERE show_section_id IN (SELECT id FROM show_sections WHERE show_id = ?)`
+				)
+				.run(showId);
+			database
+				.prepare(
+					`UPDATE show_live_states
+					 SET current_usage_id = NULL, started_at_utc = ?, ended_at_utc = NULL
+					 WHERE show_id = ?`
+				)
+				.run(now, showId);
+			database.prepare(`UPDATE shows SET status = 'live', revision = revision + 1, updated_at_utc = ? WHERE id = ?`).run(now, showId);
+			openShowTimerRun(database, showId, now);
+			const target = orderedUsages(database, showId).find((usage) => usage.status === 'open');
+			if (target) activateUsage(database, showId, target.id, now);
+		},
+		nowValue,
+		true
+	);
+}
+
 function advanceCurrent(
 	showId: string,
 	commandId: string,
@@ -447,6 +838,7 @@ function advanceCurrent(
 		expectedRevision,
 		status,
 		(database, state, now) => {
+			if (!showTimerRunning(database, showId)) throw new Error('TIMER_PAUSED');
 			if (!state.current_usage_id) throw new Error('NO_CURRENT');
 			const ordered = orderedUsages(database, showId);
 			const currentIndex = ordered.findIndex((usage) => usage.id === state.current_usage_id);
@@ -498,6 +890,7 @@ export function goBack(
 		expectedRevision,
 		'back',
 		(database, state, now) => {
+			if (!showTimerRunning(database, showId)) throw new Error('TIMER_PAUSED');
 			const ordered = orderedUsages(database, showId);
 			const currentIndex = state.current_usage_id
 				? ordered.findIndex((usage) => usage.id === state.current_usage_id)
@@ -533,6 +926,7 @@ export function selectUsage(
 		'select',
 		(database, state, now) => {
 			if (!state.started_at_utc) throw new Error('NOT_STARTED');
+			if (!showTimerRunning(database, showId)) throw new Error('TIMER_PAUSED');
 			usageBelongsToShow(database, showId, usageId);
 			if (state.current_usage_id === usageId) return;
 			if (state.current_usage_id) {