eprec 1.10.2 → 1.12.0

package/process-course/edits/combined-video-editor.ts

@@ -14,6 +14,7 @@ import {
 	findSpeechStartWithRmsFallback,
 } from '../utils/audio-analysis'
 import { allocateJoinPadding } from '../utils/video-editing'
+import type { StepProgressReporter } from '../../progress-reporter'
 
 export interface CombineVideosOptions {
 	video1Path: string
@@ -26,6 +27,8 @@ export interface CombineVideosOptions {
 	video2Duration?: number
 	outputPath: string
 	overlapPaddingMs?: number
+	progress?: StepProgressReporter
+	editProgressFactory?: (detail: string) => StepProgressReporter | undefined
 }
 
 export interface CombineVideosResult {
@@ -39,12 +42,17 @@ export interface CombineVideosResult {
 export async function combineVideos(
 	options: CombineVideosOptions,
 ): Promise<CombineVideosResult> {
+	const progress = options.progress
+	const totalSteps = 5
+	progress?.start({ stepCount: totalSteps, label: 'Preparing edits' })
+
 	const tempDir = await mkdtemp(path.join(os.tmpdir(), 'video-combine-'))
 	try {
 		const { video1Path, video2Path } = await applyOptionalEdits(
 			options,
 			tempDir,
 		)
+		progress?.step('Measuring durations')
 		const editsApplied =
 			options.video1EditedTextPath || options.video2EditedTextPath
 		const video1Duration = editsApplied
@@ -54,6 +62,8 @@ export async function combineVideos(
 			? await getMediaDurationSeconds(video2Path)
 			: (options.video2Duration ?? (await getMediaDurationSeconds(video2Path)))
 
+		progress?.step('Detecting speech')
+		progress?.setLabel('Checking first video')
 		const video1HasSpeech = await checkSegmentHasSpeech(
 			video1Path,
 			video1Duration,
@@ -67,6 +77,7 @@ export async function combineVideos(
 			}
 		}
 
+		progress?.setLabel('Finding first video speech end')
 		const paddingSeconds =
 			(options.overlapPaddingMs ?? EDIT_CONFIG.speechBoundaryPaddingMs) / 1000
 
@@ -74,6 +85,7 @@ export async function combineVideos(
 			inputPath: video1Path,
 			duration: video1Duration,
 		})
+		progress?.setLabel('Finding second video speech bounds')
 		const { speechStart: video2SpeechStart, speechEnd: video2SpeechEnd } =
 			await findVideo2SpeechBounds({
 				inputPath: video2Path,
@@ -103,8 +115,10 @@ export async function combineVideos(
 			video2Duration,
 		)
 
+		progress?.step('Trimming segments')
 		const segment1Path = path.join(tempDir, 'segment-1.mp4')
 		const segment2Path = path.join(tempDir, 'segment-2.mp4')
+		progress?.setLabel('Extracting segment 1/2')
 		await extractChapterSegmentAccurate({
 			inputPath: video1Path,
 			outputPath: segment1Path,
@@ -119,6 +133,7 @@ export async function combineVideos(
 				video2TrimStart,
 			}
 		}
+		progress?.setLabel('Extracting segment 2/2')
 		await extractChapterSegmentAccurate({
 			inputPath: video2Path,
 			outputPath: segment2Path,
@@ -126,6 +141,7 @@ export async function combineVideos(
 			end: video2TrimEnd,
 		})
 
+		progress?.setLabel('Validating trimmed speech')
 		const segment2HasSpeech = await checkSegmentHasSpeech(
 			segment2Path,
 			video2TrimEnd - video2TrimStart,
@@ -139,6 +155,7 @@ export async function combineVideos(
 			}
 		}
 
+		progress?.step('Combining output')
 		const resolvedOutputPath = await resolveOutputPath(
 			options.outputPath,
 			video1Path,
@@ -151,6 +168,7 @@ export async function combineVideos(
 			outputPath: resolvedOutputPath,
 		})
 		await finalizeOutput(resolvedOutputPath, options.outputPath)
+		progress?.finish('Complete')
 
 		return {
 			success: true,
@@ -176,18 +194,21 @@ async function applyOptionalEdits(
 ): Promise<{ video1Path: string; video2Path: string }> {
 	let video1Path = options.video1Path
 	let video2Path = options.video2Path
+	const editProgressFactory = options.editProgressFactory
 
 	if (options.video1EditedTextPath) {
 		if (!options.video1TranscriptJsonPath) {
 			throw new Error('Missing transcript JSON for first video edits.')
 		}
 		const editedPath = path.join(tempDir, 'video1-edited.mp4')
+		const progress = editProgressFactory?.('Edit first video')
 		const result = await editVideo({
 			inputPath: options.video1Path,
 			transcriptJsonPath: options.video1TranscriptJsonPath,
 			editedTextPath: options.video1EditedTextPath,
 			outputPath: editedPath,
 			paddingMs: options.overlapPaddingMs,
+			progress,
 		})
 		if (!result.success) {
 			throw new Error(result.error ?? 'Failed to edit first video.')
@@ -200,12 +221,14 @@ async function applyOptionalEdits(
 			throw new Error('Missing transcript JSON for second video edits.')
 		}
 		const editedPath = path.join(tempDir, 'video2-edited.mp4')
+		const progress = editProgressFactory?.('Edit second video')
 		const result = await editVideo({
 			inputPath: options.video2Path,
 			transcriptJsonPath: options.video2TranscriptJsonPath,
 			editedTextPath: options.video2EditedTextPath,
 			outputPath: editedPath,
 			paddingMs: options.overlapPaddingMs,
+			progress,
 		})
 		if (!result.success) {
 			throw new Error(result.error ?? 'Failed to edit second video.')

package/process-course/edits/video-editor.ts

@@ -11,6 +11,7 @@ import {
 } from './timestamp-refinement'
 import type { TimeRange } from '../types'
 import type { TranscriptJson, TranscriptWordWithIndex } from './types'
+import type { StepProgressReporter } from '../../progress-reporter'
 
 export interface EditVideoOptions {
 	inputPath: string
@@ -18,6 +19,7 @@ export interface EditVideoOptions {
 	editedTextPath: string
 	outputPath: string
 	paddingMs?: number
+	progress?: StepProgressReporter
 }
 
 export interface EditVideoResult {
@@ -37,8 +39,13 @@ export async function editVideo(
 	options: EditVideoOptions,
 ): Promise<EditVideoResult> {
 	try {
+		const progress = options.progress
+		const totalSteps = 5
+		progress?.start({ stepCount: totalSteps, label: 'Loading transcript' })
+
 		const transcript = await readTranscriptJson(options.transcriptJsonPath)
 		const editedText = await Bun.file(options.editedTextPath).text()
+		progress?.step('Validating edits')
 		const validation = validateEditedTranscript({
 			originalWords: transcript.words,
 			editedText,
@@ -51,6 +58,7 @@ export async function editVideo(
 				removedRanges: [],
 			}
 		}
+		progress?.step('Diffing transcript')
 		const diffResult = diffTranscripts({
 			originalWords: transcript.words,
 			editedText,
@@ -64,9 +72,12 @@ export async function editVideo(
 			}
 		}
 
+		progress?.step('Planning edits')
 		const removedWords = diffResult.removedWords
 		if (removedWords.length === 0) {
+			progress?.step('Rendering output')
 			await ensureOutputCopy(options.inputPath, options.outputPath)
+			progress?.finish('No edits')
 			return {
 				success: true,
 				outputPath: options.outputPath,
@@ -77,7 +88,9 @@ export async function editVideo(
 
 		const removalRanges = wordsToTimeRanges(removedWords)
 		if (removalRanges.length === 0) {
+			progress?.step('Rendering output')
 			await ensureOutputCopy(options.inputPath, options.outputPath)
+			progress?.finish('No ranges')
 			return {
 				success: true,
 				outputPath: options.outputPath,
@@ -86,6 +99,7 @@ export async function editVideo(
 			}
 		}
 
+		progress?.setLabel('Refining ranges')
 		const refinedRanges = await refineAllRemovalRanges({
 			inputPath: options.inputPath,
 			duration: transcript.source_duration,
@@ -111,6 +125,7 @@ export async function editVideo(
 			}
 		}
 
+		progress?.step('Rendering output')
 		await mkdir(path.dirname(options.outputPath), { recursive: true })
 
 		const isFullRange =
@@ -120,6 +135,7 @@ export async function editVideo(
 			keepRanges[0].end >= transcript.source_duration - 0.001
 		if (isFullRange) {
 			await ensureOutputCopy(options.inputPath, options.outputPath)
+			progress?.finish('Complete')
 			return {
 				success: true,
 				outputPath: options.outputPath,
@@ -129,12 +145,14 @@ export async function editVideo(
 		}
 
 		if (keepRanges.length === 1 && keepRanges[0]) {
+			progress?.setLabel('Extracting segment')
 			await extractChapterSegmentAccurate({
 				inputPath: options.inputPath,
 				outputPath: options.outputPath,
 				start: keepRanges[0].start,
 				end: keepRanges[0].end,
 			})
+			progress?.finish('Complete')
 			return {
 				success: true,
 				outputPath: options.outputPath,
@@ -147,6 +165,9 @@ export async function editVideo(
 		try {
 			const segmentPaths: string[] = []
 			for (const [index, range] of keepRanges.entries()) {
+				progress?.setLabel(
+					`Extracting segment ${index + 1}/${keepRanges.length}`,
+				)
 				const segmentPath = path.join(tempDir, `segment-${index + 1}.mp4`)
 				await extractChapterSegmentAccurate({
 					inputPath: options.inputPath,
@@ -156,10 +177,12 @@ export async function editVideo(
 				})
 				segmentPaths.push(segmentPath)
 			}
+			progress?.setLabel('Concatenating segments')
 			await concatSegments({
 				segmentPaths,
 				outputPath: options.outputPath,
 			})
+			progress?.finish('Complete')
 			return {
 				success: true,
 				outputPath: options.outputPath,

package/server/processing-queue.ts

@@ -0,0 +1,441 @@
+type ProcessingCategory = 'chapter' | 'transcript' | 'export'
+type ProcessingStatus = 'queued' | 'running' | 'done' | 'error'
+type ProcessingAction =
+	| 'edit-chapter'
+	| 'combine-chapters'
+	| 'regenerate-transcript'
+	| 'detect-command-windows'
+	| 'render-preview'
+	| 'export-final'
+
+type ProcessingProgress = {
+	step: number
+	totalSteps: number
+	label: string
+	percent: number
+}
+
+export type ProcessingTask = {
+	id: string
+	title: string
+	detail: string
+	status: ProcessingStatus
+	category: ProcessingCategory
+	action: ProcessingAction
+	progress?: ProcessingProgress
+	errorMessage?: string
+	updatedAt: number
+	createdAt: number
+	simulateError?: boolean
+}
+
+type ProcessingQueueSnapshot = {
+	tasks: ProcessingTask[]
+	activeTaskId: string | null
+}
+
+type QueueListener = (snapshot: ProcessingQueueSnapshot) => void
+
+const QUEUE_HEADERS = {
+	'Access-Control-Allow-Origin': '*',
+	'Access-Control-Allow-Methods': 'GET, POST, DELETE, OPTIONS',
+	'Access-Control-Allow-Headers': 'Accept, Content-Type',
+} as const
+
+const TASK_STEPS: Record<ProcessingAction, string[]> = {
+	'edit-chapter': [
+		'Collecting edit ranges',
+		'Updating cut list',
+		'Preparing edit workspace',
+	],
+	'combine-chapters': [
+		'Loading chapter outputs',
+		'Aligning audio padding',
+		'Rendering combined preview',
+	],
+	'regenerate-transcript': [
+		'Extracting audio',
+		'Running Whisper alignment',
+		'Refreshing transcript cues',
+	],
+	'detect-command-windows': [
+		'Scanning transcript markers',
+		'Refining command windows',
+		'Updating cut ranges',
+	],
+	'render-preview': ['Rendering preview clip', 'Optimizing output', 'Verifying'],
+	'export-final': [
+		'Rendering chapters',
+		'Packaging exports',
+		'Verifying outputs',
+	],
+}
+
+const STEP_DELAY_MS = 850
+const STEP_JITTER_MS = 350
+
+let tasks: ProcessingTask[] = []
+let activeTaskId: string | null = null
+let nextTaskId = 1
+let runController: AbortController | null = null
+const listeners = new Set<QueueListener>()
+
+function buildSnapshot(): ProcessingQueueSnapshot {
+	return {
+		tasks,
+		activeTaskId,
+	}
+}
+
+function emitSnapshot() {
+	const snapshot = buildSnapshot()
+	for (const listener of listeners) {
+		listener(snapshot)
+	}
+}
+
+function updateQueueState(mutate: () => void) {
+	mutate()
+	emitSnapshot()
+}
+
+function updateTask(taskId: string, patch: Partial<ProcessingTask>) {
+	updateQueueState(() => {
+		tasks = tasks.map((task) =>
+			task.id === taskId
+				? { ...task, ...patch, updatedAt: Date.now() }
+				: task,
+		)
+	})
+}
+
+function enqueueTask(options: {
+	title: string
+	detail: string
+	category: ProcessingCategory
+	action: ProcessingAction
+	simulateError?: boolean
+}) {
+	const task: ProcessingTask = {
+		id: `task-${nextTaskId++}`,
+		title: options.title,
+		detail: options.detail,
+		status: 'queued',
+		category: options.category,
+		action: options.action,
+		createdAt: Date.now(),
+		updatedAt: Date.now(),
+		simulateError: options.simulateError,
+	}
+	updateQueueState(() => {
+		tasks = [...tasks, task]
+	})
+	return task
+}
+
+function removeTask(taskId: string) {
+	updateQueueState(() => {
+		tasks = tasks.filter((task) => task.id !== taskId)
+		if (activeTaskId === taskId) {
+			activeTaskId = null
+			runController?.abort()
+			runController = null
+		}
+	})
+}
+
+function clearCompleted() {
+	updateQueueState(() => {
+		tasks = tasks.filter((task) => task.status !== 'done')
+	})
+}
+
+function markActiveDone() {
+	if (!activeTaskId) return
+	updateQueueState(() => {
+		tasks = tasks.map((task) =>
+			task.id === activeTaskId
+				? {
+						...task,
+						status: 'done',
+						progress: task.progress
+							? { ...task.progress, percent: 100, label: 'Complete' }
+							: undefined,
+						updatedAt: Date.now(),
+					}
+				: task,
+		)
+		activeTaskId = null
+		runController?.abort()
+		runController = null
+	})
+}
+
+function buildProgress(step: number, totalSteps: number, label: string) {
+	const percent =
+		totalSteps > 0 ? Math.round((step / totalSteps) * 100) : 0
+	return { step, totalSteps, label, percent }
+}
+
+function sleep(duration: number, signal?: AbortSignal) {
+	return new Promise<void>((resolve, reject) => {
+		const timeout = setTimeout(resolve, duration)
+		const onAbort = () => {
+			clearTimeout(timeout)
+			reject(new Error('aborted'))
+		}
+		if (signal) {
+			if (signal.aborted) {
+				onAbort()
+				return
+			}
+			signal.addEventListener('abort', onAbort, { once: true })
+		}
+	})
+}
+
+async function runTask(task: ProcessingTask) {
+	const steps = TASK_STEPS[task.action] ?? ['Starting', 'Working', 'Complete']
+	const controller = new AbortController()
+	runController = controller
+	updateQueueState(() => {
+		activeTaskId = task.id
+		tasks = tasks.map((entry) =>
+			entry.id === task.id
+				? {
+						...entry,
+						status: 'running',
+						progress: buildProgress(0, steps.length, 'Starting'),
+						errorMessage: undefined,
+						updatedAt: Date.now(),
+					}
+				: entry,
+		)
+	})
+
+	const failAtStep = task.simulateError
+		? Math.max(1, Math.ceil(steps.length * 0.6))
+		: null
+
+	try {
+		for (let index = 0; index < steps.length; index++) {
+			if (controller.signal.aborted) return
+			const label = steps[index]
+			updateTask(task.id, {
+				progress: buildProgress(index + 1, steps.length, label),
+			})
+			if (failAtStep && index + 1 === failAtStep) {
+				throw new Error('Processing failed during render.')
+			}
+			const delay =
+				STEP_DELAY_MS + Math.round(Math.random() * STEP_JITTER_MS)
+			await sleep(delay, controller.signal)
+		}
+		updateTask(task.id, {
+			status: 'done',
+			progress: buildProgress(steps.length, steps.length, 'Complete'),
+		})
+	} catch (error) {
+		if (controller.signal.aborted) return
+		updateTask(task.id, {
+			status: 'error',
+			errorMessage:
+				error instanceof Error ? error.message : 'Processing failed.',
+		})
+	} finally {
+		runController = null
+		updateQueueState(() => {
+			if (activeTaskId === task.id) {
+				activeTaskId = null
+			}
+		})
+	}
+}
+
+function runNextTask() {
+	if (activeTaskId) return
+	const nextTask = tasks.find((task) => task.status === 'queued')
+	if (!nextTask) return
+	void runTask(nextTask)
+}
+
+function jsonResponse(payload: unknown, status = 200) {
+	return new Response(JSON.stringify(payload), {
+		status,
+		headers: {
+			'Content-Type': 'application/json',
+			...QUEUE_HEADERS,
+		},
+	})
+}
+
+function createEventStream(request: Request) {
+	const encoder = new TextEncoder()
+	return new Response(
+		new ReadableStream({
+			start(controller) {
+				let isClosed = false
+				const send = (event: string, data: unknown) => {
+					if (isClosed) return
+					controller.enqueue(
+						encoder.encode(
+							`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`,
+						),
+					)
+				}
+				const listener = (snapshot: ProcessingQueueSnapshot) => {
+					send('snapshot', snapshot)
+				}
+				listeners.add(listener)
+				send('snapshot', buildSnapshot())
+				const ping = setInterval(() => {
+					send('ping', { time: Date.now() })
+				}, 15000)
+				const close = () => {
+					if (isClosed) return
+					isClosed = true
+					clearInterval(ping)
+					listeners.delete(listener)
+					controller.close()
+				}
+				request.signal.addEventListener('abort', close)
+			},
+			cancel() {
+				// handled via abort
+			},
+		}),
+		{
+			headers: {
+				'Content-Type': 'text/event-stream',
+				'Cache-Control': 'no-cache, no-transform',
+				Connection: 'keep-alive',
+				...QUEUE_HEADERS,
+			},
+		},
+	)
+}
+
+function isProcessingCategory(value: unknown): value is ProcessingCategory {
+	return value === 'chapter' || value === 'transcript' || value === 'export'
+}
+
+function isProcessingAction(value: unknown): value is ProcessingAction {
+	return (
+		value === 'edit-chapter' ||
+		value === 'combine-chapters' ||
+		value === 'regenerate-transcript' ||
+		value === 'detect-command-windows' ||
+		value === 'render-preview' ||
+		value === 'export-final'
+	)
+}
+
+export async function handleProcessingQueueRequest(request: Request) {
+	if (request.method === 'OPTIONS') {
+		return new Response(null, { status: 204, headers: QUEUE_HEADERS })
+	}
+
+	const url = new URL(request.url)
+	const pathname = url.pathname
+
+	if (pathname === '/api/processing-queue/stream') {
+		if (request.method !== 'GET') {
+			return jsonResponse({ error: 'Method not allowed' }, 405)
+		}
+		return createEventStream(request)
+	}
+
+	if (pathname === '/api/processing-queue') {
+		if (request.method !== 'GET') {
+			return jsonResponse({ error: 'Method not allowed' }, 405)
+		}
+		return jsonResponse(buildSnapshot())
+	}
+
+	if (pathname === '/api/processing-queue/enqueue') {
+		if (request.method !== 'POST') {
+			return jsonResponse({ error: 'Method not allowed' }, 405)
+		}
+		let payload: unknown = null
+		try {
+			payload = await request.json()
+		} catch (error) {
+			return jsonResponse({ error: 'Invalid JSON payload.' }, 400)
+		}
+		if (
+			!payload ||
+			typeof payload !== 'object' ||
+			!('title' in payload) ||
+			!('detail' in payload) ||
+			!('category' in payload) ||
+			!('action' in payload)
+		) {
+			return jsonResponse({ error: 'Missing task fields.' }, 400)
+		}
+		const data = payload as {
+			title?: unknown
+			detail?: unknown
+			category?: unknown
+			action?: unknown
+			simulateError?: unknown
+		}
+		if (typeof data.title !== 'string' || data.title.trim().length === 0) {
+			return jsonResponse({ error: 'Task title is required.' }, 400)
+		}
+		if (typeof data.detail !== 'string') {
+			return jsonResponse({ error: 'Task detail is required.' }, 400)
+		}
+		if (!isProcessingCategory(data.category)) {
+			return jsonResponse({ error: 'Invalid task category.' }, 400)
+		}
+		if (!isProcessingAction(data.action)) {
+			return jsonResponse({ error: 'Invalid task action.' }, 400)
+		}
+		enqueueTask({
+			title: data.title,
+			detail: data.detail,
+			category: data.category,
+			action: data.action,
+			simulateError: data.simulateError === true,
+		})
+		return jsonResponse(buildSnapshot())
+	}
+
+	if (pathname === '/api/processing-queue/run-next') {
+		if (request.method !== 'POST') {
+			return jsonResponse({ error: 'Method not allowed' }, 405)
+		}
+		runNextTask()
+		return jsonResponse(buildSnapshot())
+	}
+
+	if (pathname === '/api/processing-queue/mark-done') {
+		if (request.method !== 'POST') {
+			return jsonResponse({ error: 'Method not allowed' }, 405)
+		}
+		markActiveDone()
+		return jsonResponse(buildSnapshot())
+	}
+
+	if (pathname === '/api/processing-queue/clear-completed') {
+		if (request.method !== 'POST') {
+			return jsonResponse({ error: 'Method not allowed' }, 405)
+		}
+		clearCompleted()
+		return jsonResponse(buildSnapshot())
+	}
+
+	if (pathname.startsWith('/api/processing-queue/task/')) {
+		if (request.method !== 'DELETE') {
+			return jsonResponse({ error: 'Method not allowed' }, 405)
+		}
+		const taskId = pathname.replace('/api/processing-queue/task/', '')
+		if (!taskId) {
+			return jsonResponse({ error: 'Task id is required.' }, 400)
+		}
+		removeTask(taskId)
+		return jsonResponse(buildSnapshot())
+	}
+
+	return jsonResponse({ error: 'Not found' }, 404)
+}

package/src/app-server.ts

@@ -6,6 +6,7 @@ import { getEnv } from '../app/config/env.ts'
 import { createAppRouter } from '../app/router.tsx'
 import { handleVideoRequest } from '../app/video-api.ts'
 import { createBundlingRoutes } from '../server/bundling.ts'
+import { handleProcessingQueueRequest } from '../server/processing-queue.ts'
 
 type AppServerOptions = {
 	host?: string
@@ -196,6 +197,9 @@ function startServer(port: number, hostname: string) {
 				if (url.pathname === '/api/video') {
 					return await handleVideoRequest(request)
 				}
+				if (url.pathname.startsWith('/api/processing-queue')) {
+					return await handleProcessingQueueRequest(request)
+				}
 				return await router.fetch(request)
 			} catch (error) {
 				console.error(error)