@growth-labs/cms 0.8.1 → 0.8.3

package/src/engine/foundry-dispatch.ts

@@ -10,7 +10,7 @@
 // on `processing_trigger_token` and deduplicated on `event_id`.
 
 import type { FoundryDispatch } from '../providers/types.js'
-import type { D1Database } from './d1.js'
+import type { D1Database, D1Result } from './d1.js'
 import { validPodcastSourceUrl } from './podcast-source.js'
 
 interface PodcastDispatchSnapshot {
@@ -35,8 +35,10 @@ export type ProcessingState =
 const TERMINAL_STATES: ProcessingState[] = ['ready', 'failed']
 
 export interface DispatchResult {
-	correlationId: string
+	/** Podcast capture reuse has no persisted correlation to return. */
+	correlationId: string | null
 	triggerToken: string
+	skipped?: boolean
 }
 
 export class FoundryDispatchPrerequisiteError extends Error {
@@ -99,9 +101,23 @@ function inferVideoSourceKind(sourceUrl: string): string {
 	return 'http_url'
 }
 
+/**
+ * Mint a fresh source identity for the caller's source-snapshot CAS. Capture
+ * time records initiation, not worker admission; this helper does not dispatch
+ * work or change readiness. The raw token stays in the private capture record.
+ */
+export function createFoundrySourceCaptureToken(
+	capturedAtSeconds = Math.floor(Date.now() / 1000),
+): string {
+	if (!Number.isSafeInteger(capturedAtSeconds) || capturedAtSeconds <= 0) {
+		throw new RangeError('Capture time must be positive safe integer Unix seconds')
+	}
+	return `fronts-source-v2:${capturedAtSeconds}:${crypto.randomUUID()}`
+}
+
 /**
  * Dispatch a video or podcast content item to Foundry via the injected hook.
- * Mints a fresh `processing_trigger_token` (UUID), calls
+ * Mints a fresh versioned `processing_trigger_token` (capture time + UUID), calls
  * `hook.dispatchVideo({ contentId, sourceUrl, kind, durationSeconds })`, and writes
  * `processing_correlation_id` + advances to `'queued'` in either
  * `video_content` or `podcast_content`.
@@ -112,6 +128,7 @@ export async function dispatchToFoundry(
 	db: D1Database,
 	contentId: string,
 	hook: Pick<FoundryDispatch, 'dispatchVideo'>,
+	options: { ifUncaptured?: boolean } = {},
 ): Promise<DispatchResult> {
 	const content = await db
 		.prepare(
@@ -135,7 +152,7 @@ export async function dispatchToFoundry(
 	// Determine which media table owns this content id.
 	const videoRow = await db
 		.prepare(
-			'SELECT content_id, video_id, duration_seconds, processing_source_url, processing_source_kind FROM video_content WHERE content_id = ?',
+			'SELECT content_id, video_id, duration_seconds, processing_source_url, processing_source_kind, processing_trigger_token, processing_correlation_id FROM video_content WHERE content_id = ?',
 		)
 		.bind(contentId)
 		.first<{
@@ -144,6 +161,8 @@ export async function dispatchToFoundry(
 			duration_seconds: number | null
 			processing_source_url: string | null
 			processing_source_kind: string | null
+			processing_trigger_token: string | null
+			processing_correlation_id: string | null
 		}>()
 
 	let table: 'video_content' | 'podcast_content'
@@ -155,6 +174,20 @@ export async function dispatchToFoundry(
 	let podcastSnapshot: PodcastDispatchSnapshot | null = null
 
 	if (videoRow) {
+		if (content.type !== 'video' || content.deleted_at != null || content.status === 'archived') {
+			throw new Error(`dispatchToFoundry: video ${contentId} is inactive`)
+		}
+		if (
+			options.ifUncaptured &&
+			videoRow.processing_trigger_token &&
+			videoRow.processing_correlation_id
+		) {
+			return {
+				correlationId: videoRow.processing_correlation_id,
+				triggerToken: videoRow.processing_trigger_token,
+				skipped: true,
+			}
+		}
 		table = 'video_content'
 		sourceUrl = videoRow.processing_source_url?.trim() ?? ''
 		if (!sourceUrl) {
@@ -199,8 +232,22 @@ export async function dispatchToFoundry(
 	) {
 		throw new FoundryDispatchPrerequisiteError(contentId)
 	}
+	if (
+		options.ifUncaptured &&
+		podcastSnapshot?.processing_trigger_token?.trim() &&
+		podcastSnapshot.processing_source_kind === 'https' &&
+		validPodcastSourceUrl(podcastSnapshot.processing_source_url)
+	) {
+		// Source edits clear the token. This source/token pair is the CMS's
+		// committed capture evidence; a metadata save need not call the host again.
+		return {
+			correlationId: null,
+			triggerToken: podcastSnapshot.processing_trigger_token,
+			skipped: true,
+		}
+	}
 
-	const triggerToken = crypto.randomUUID()
+	const triggerToken = createFoundrySourceCaptureToken()
 	const processingTriggerTokenHash = `sha256:${await sha256Hex(triggerToken)}`
 	const { correlationId, podcastSource } = await hook.dispatchVideo({
 		contentId,
@@ -217,7 +264,8 @@ export async function dispatchToFoundry(
 	const now = Math.floor(Date.now() / 1000)
 
 	if (table === 'video_content') {
-		await db
+		if (!videoRow) throw new Error('Video dispatch snapshot is missing')
+		const written = await db
 			.prepare(
 				`UPDATE video_content
          SET processing_state = 'queued',
@@ -235,10 +283,33 @@ export async function dispatchToFoundry(
              transcript_url = NULL,
              hls_manifest_url = NULL,
              hls_poster_url = NULL
-         WHERE content_id = ?`,
+         WHERE content_id = ? AND video_id IS ? AND duration_seconds IS ?
+         AND processing_source_url IS ? AND processing_source_kind IS ?
+         AND processing_trigger_token IS ? AND processing_correlation_id IS ?
+         AND EXISTS (SELECT 1 FROM content_items ci WHERE ci.id = video_content.content_id
+         AND ci.type = 'video' AND ci.slug = ? AND ci.canonical_version = ?
+         AND ci.status = ? AND ci.deleted_at IS NULL)`,
+			)
+			.bind(
+				videoId,
+				sourceKind,
+				correlationId,
+				triggerToken,
+				now,
+				contentId,
+				videoRow.video_id,
+				videoRow.duration_seconds,
+				videoRow.processing_source_url,
+				videoRow.processing_source_kind,
+				videoRow.processing_trigger_token,
+				videoRow.processing_correlation_id,
+				content.slug,
+				content.canonical_version,
+				content.status,
 			)
-			.bind(videoId, sourceKind, correlationId, triggerToken, now, contentId)
 			.run()
+		if (written.meta?.changes !== 1)
+			throw new Error('Video source changed before dispatch acknowledgement')
 	} else {
 		if (!podcastSnapshot) throw new Error('Podcast dispatch snapshot is missing')
 		if (
@@ -259,7 +330,7 @@ export async function dispatchToFoundry(
 		// source/audio/editor snapshot is still current. No stale acknowledgement
 		// can restore a replaced source or overwrite a newer processing token.
 		const written = await db
-			.prepare(`UPDATE podcast_content SET processing_source_url = ?, processing_source_kind = ?, processing_trigger_token = ?
+			.prepare(`UPDATE podcast_content SET processing_source_url = ?, processing_source_kind = ?, processing_trigger_token = ?, transcript = ''
 			WHERE content_id = ? AND audio_r2_key IS ? AND duration_seconds IS ? AND transcript IS ?
 			AND processing_source_url IS ? AND processing_source_kind IS ? AND processing_trigger_token IS ?
 			AND EXISTS (SELECT 1 FROM content_items ci WHERE ci.id = podcast_content.content_id
@@ -372,12 +443,12 @@ export async function applyFoundryCallback(db: D1Database, input: CallbackInput)
 				? Math.max(0, Math.floor(durationSeconds))
 				: null
 		if (nextTranscript !== null || nextDurationSeconds !== null) {
-			await db
+			const updated = await db
 				.prepare(
 					`UPDATE podcast_content
 					SET transcript = CASE WHEN ? THEN ? ELSE transcript END,
 						duration_seconds = CASE WHEN ? THEN ? ELSE duration_seconds END
-					WHERE content_id = ?`,
+					WHERE content_id = ? AND processing_trigger_token = ?`,
 				)
 				.bind(
 					nextTranscript !== null ? 1 : 0,
@@ -385,21 +456,26 @@ export async function applyFoundryCallback(db: D1Database, input: CallbackInput)
 					nextDurationSeconds !== null ? 1 : 0,
 					nextDurationSeconds,
 					podcastRow.content_id,
+					triggerToken,
 				)
 				.run()
+			if (updated.meta?.changes !== 1) return false
 		}
 
 		const nextDescription =
 			typeof description === 'string' && description.trim() ? description.trim() : null
 		const nextExcerpt = typeof excerpt === 'string' && excerpt.trim() ? excerpt.trim() : null
 		if (nextDescription !== null || nextExcerpt !== null) {
-			await db
+			const updated = await db
 				.prepare(
 					`UPDATE content_items
 					SET description = CASE WHEN ? THEN ? ELSE description END,
 						excerpt = CASE WHEN ? THEN ? ELSE excerpt END,
 						updated_at = unixepoch()
-					WHERE id = ?`,
+					WHERE id = ? AND EXISTS (
+						SELECT 1 FROM podcast_content p WHERE p.content_id = content_items.id
+						AND p.processing_trigger_token = ?
+					)`,
 				)
 				.bind(
 					nextDescription !== null ? 1 : 0,
@@ -407,50 +483,60 @@ export async function applyFoundryCallback(db: D1Database, input: CallbackInput)
 					nextExcerpt !== null ? 1 : 0,
 					nextExcerpt,
 					podcastRow.content_id,
+					triggerToken,
 				)
 				.run()
+			if (updated.meta?.changes !== 1) return false
 		}
 
-		return true
+		return Boolean(
+			await db
+				.prepare(
+					'SELECT content_id FROM podcast_content WHERE content_id = ? AND processing_trigger_token = ?',
+				)
+				.bind(podcastRow.content_id, triggerToken)
+				.first(),
+		)
 	}
 
 	if (!videoRow) return false
 	const row = videoRow
+	let updated: D1Result
 
 	if (nextState === 'failed') {
-		await db
+		updated = await db
 			.prepare(
 				`UPDATE video_content
          SET processing_state = ?,
              processing_last_event_at = ?,
              processing_completed_at = ?,
              processing_error = ?
-         WHERE content_id = ?`,
+         WHERE content_id = ? AND processing_trigger_token = ?`,
 			)
-			.bind(nextState, now, now, error ?? null, row.content_id)
+			.bind(nextState, now, now, error ?? null, row.content_id, triggerToken)
 			.run()
 	} else if (isTerminal) {
 		// 'ready'
-		await db
+		updated = await db
 			.prepare(
 				`UPDATE video_content
          SET processing_state = ?,
              processing_last_event_at = ?,
              processing_completed_at = ?
-         WHERE content_id = ?`,
+         WHERE content_id = ? AND processing_trigger_token = ?`,
 			)
-			.bind(nextState, now, now, row.content_id)
+			.bind(nextState, now, now, row.content_id, triggerToken)
 			.run()
 	} else {
-		await db
+		updated = await db
 			.prepare(
-				'UPDATE video_content SET processing_state = ?, processing_last_event_at = ? WHERE content_id = ?',
+				'UPDATE video_content SET processing_state = ?, processing_last_event_at = ? WHERE content_id = ? AND processing_trigger_token = ?',
 			)
-			.bind(nextState, now, row.content_id)
+			.bind(nextState, now, row.content_id, triggerToken)
 			.run()
 	}
 
-	return true
+	return updated.meta?.changes === 1
 }
 
 /**

package/src/engine/fronts-publish-intent.ts

@@ -304,15 +304,53 @@ export function parseFrontsChannelTargets(
 	return normalizeChannelTargets(parsed)
 }
 
+/** Host defaults are opt-in; an invalid configured list must fail before a save. */
+export function parseFrontsDefaultChannelTargets(
+	value: unknown,
+):
+	| { targets: string[] }
+	| { error: 'missing_fronts_default_channel_targets' | 'invalid_fronts_default_channel_targets' } {
+	if (value === undefined) return { error: 'missing_fronts_default_channel_targets' }
+	if (!Array.isArray(value)) return { error: 'invalid_fronts_default_channel_targets' }
+	const parsed = normalizeChannelTargets(value)
+	return 'code' in parsed ? { error: 'invalid_fronts_default_channel_targets' } : parsed
+}
+
+interface ScheduledTargetsSnapshot {
+	id: string
+	canonical_version: number | null
+	publish_at: number
+	updated_at: number | null
+	fronts_publish_trigger_token: string | null
+	fronts_publish_status: string | null
+}
+
+interface ChannelTargetsWriteOptions {
+	onlyIfNull?: boolean
+	expectedScheduled?: ScheduledTargetsSnapshot
+}
+
 /**
  * Arm an item's publish targets. Rejects an empty or non-string list loudly
  * instead of storing something that would later hydrate as "complete".
  */
+export function setFrontsChannelTargets(
+	db: D1Database,
+	contentId: string,
+	targets: readonly string[],
+): Promise<void>
+export function setFrontsChannelTargets(
+	db: D1Database,
+	contentId: string,
+	targets: readonly string[],
+	options: ChannelTargetsWriteOptions,
+): Promise<boolean>
 export async function setFrontsChannelTargets(
 	db: D1Database,
 	contentId: string,
 	targets: readonly string[],
-): Promise<void> {
+	options?: ChannelTargetsWriteOptions,
+): Promise<void | boolean> {
 	const normalized = normalizeChannelTargets(targets)
 	if ('code' in normalized) {
 		throw new FrontsPublishIntentError(
@@ -321,10 +359,83 @@ export async function setFrontsChannelTargets(
 			'targets must be a non-empty list of non-empty strings',
 		)
 	}
-	await db
-		.prepare('UPDATE content_items SET fronts_channel_targets = ? WHERE id = ?')
-		.bind(JSON.stringify(normalized.targets), contentId)
+	const predicates = ['id = ?']
+	const values: unknown[] = [JSON.stringify(normalized.targets), contentId]
+	if (options?.onlyIfNull || options?.expectedScheduled) {
+		predicates.push('fronts_channel_targets IS NULL', 'deleted_at IS NULL')
+	}
+	if (options?.expectedScheduled) {
+		const expected = options.expectedScheduled
+		if (expected.id !== contentId)
+			throw new Error('Channel target snapshot belongs to different content')
+		predicates.push(
+			"status = 'scheduled'",
+			'canonical_version IS ?',
+			'publish_at IS ?',
+			'updated_at IS ?',
+			'fronts_publish_trigger_token IS ?',
+			'fronts_publish_status IS ?',
+		)
+		values.push(
+			expected.canonical_version,
+			expected.publish_at,
+			expected.updated_at,
+			expected.fronts_publish_trigger_token,
+			expected.fronts_publish_status,
+		)
+	}
+	const result = await db
+		.prepare(
+			`UPDATE content_items SET fronts_channel_targets = ? WHERE ${predicates.join(' AND ')}`,
+		)
+		.bind(...values)
 		.run()
+	// Preserve the original explicit setter contract. CAS callers need a proved
+	// change count, including an honest false when another writer won.
+	if (!options) return
+	const changes = result.meta?.changes
+	if (
+		result.success === false ||
+		typeof changes !== 'number' ||
+		!Number.isInteger(changes) ||
+		changes < 0 ||
+		changes > 1
+	) {
+		throw new Error('Fronts channel target write did not report a valid change count')
+	}
+	return changes === 1
+}
+
+/** A bounded repair requested by Go; all rows keep their current publish/media identity. */
+export async function backfillFrontsChannelTargets(
+	db: D1Database,
+	targets: readonly string[],
+	limit: number,
+): Promise<{ examined: number; armed: number; skipped: number; contentIds: string[] }> {
+	if (!Number.isInteger(limit) || limit < 1 || limit > 50)
+		throw new Error('Invalid channel target backfill limit')
+	const selected = await db
+		.prepare(`SELECT id, canonical_version, publish_at, updated_at,
+			fronts_publish_trigger_token, fronts_publish_status
+			FROM content_items
+			WHERE status = 'scheduled' AND deleted_at IS NULL
+				AND publish_at IS NOT NULL AND fronts_channel_targets IS NULL
+			ORDER BY publish_at ASC, id ASC LIMIT ?`)
+		.bind(limit)
+		.all<ScheduledTargetsSnapshot>()
+	if (selected.success === false || !Array.isArray(selected.results))
+		throw new Error('Fronts channel target selection failed')
+	const contentIds: string[] = []
+	for (const row of selected.results) {
+		if (await setFrontsChannelTargets(db, row.id, targets, { expectedScheduled: row }))
+			contentIds.push(row.id)
+	}
+	return {
+		examined: selected.results.length,
+		armed: contentIds.length,
+		skipped: selected.results.length - contentIds.length,
+		contentIds,
+	}
 }
 
 // --- hydration -------------------------------------------------------------
@@ -617,6 +728,176 @@ async function loadContentRefSources(
 	return { articles, videos, podcasts, media }
 }
 
+/** Preparation and publication projections share the same source validation. */
+async function videoSourceRef(
+	row: IntentCandidateRow,
+	found: VideoRefRow | undefined,
+): Promise<FrontsPublishVideoSourceRef | null> {
+	const correlation = found?.processing_correlation_id?.trim()
+	if (
+		!found ||
+		!validPodcastSourceUrl(found.processing_source_url) ||
+		!videoSourceIngestableOverHttps(found.processing_source_kind) ||
+		!correlation ||
+		!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(correlation)
+	)
+		return null
+	if (
+		typeof found.duration_seconds !== 'number' ||
+		!Number.isFinite(found.duration_seconds) ||
+		found.duration_seconds <= 0
+	) {
+		throw new FrontsPublishIntentError(
+			'video_source_duration_unavailable',
+			row.id,
+			'Video source duration is not verified.',
+		)
+	}
+	return {
+		kind: 'https',
+		url: found.processing_source_url,
+		duration_seconds: found.duration_seconds,
+		generation: await frontsVideoSourceGeneration({
+			content_id: row.id,
+			slug: row.slug,
+			canonical_version: row.canonical_version as number,
+			processing_source_url: found.processing_source_url,
+			processing_source_kind: found.processing_source_kind,
+			processing_trigger_token: found.processing_trigger_token,
+		}),
+		correlation_id: correlation,
+		visibility: row.visibility === 'premium' ? 'premium' : 'free',
+	}
+}
+
+async function podcastSourceRef(
+	row: IntentCandidateRow,
+	found: PodcastRefRow | undefined,
+): Promise<FrontsPublishPodcastSourceRef | null> {
+	if (
+		!found ||
+		!validPodcastSourceUrl(found.processing_source_url) ||
+		found.processing_source_kind !== 'https'
+	)
+		return null
+	if (
+		typeof found.duration_seconds !== 'number' ||
+		!Number.isFinite(found.duration_seconds) ||
+		found.duration_seconds <= 0
+	) {
+		throw new FrontsPublishIntentError(
+			'podcast_source_duration_unavailable',
+			row.id,
+			'Podcast source duration is not verified.',
+		)
+	}
+	return {
+		kind: 'https',
+		url: found.processing_source_url,
+		duration_seconds: found.duration_seconds,
+		generation: await frontsPodcastSourceGeneration({
+			content_id: row.id,
+			slug: row.slug,
+			canonical_version: row.canonical_version as number,
+			processing_source_url: found.processing_source_url,
+			processing_source_kind: found.processing_source_kind,
+			processing_trigger_token: found.processing_trigger_token,
+		}),
+	}
+}
+
+/** A captured source is preparation authority, never publication authority. */
+export interface FrontsMediaPreparation {
+	content_id: string
+	type: 'video' | 'podcast'
+	slug: string
+	channel: string | null
+	canonical_version: number
+	/** The actual slot, if any; never invented for a draft. */
+	publish_at: number | null
+	/** Actual capture time; unknown for a legacy token. */
+	captured_at: number | null
+	video_source: FrontsPublishVideoSourceRef | null
+	podcast_source: FrontsPublishPodcastSourceRef | null
+}
+
+export interface FrontsMediaPreparations {
+	version: 1
+	items: FrontsMediaPreparation[]
+	incomplete: Array<{ content_id: string; code: string; message: string }>
+}
+
+/**
+ * Extend the existing authenticated poll with captured media, independently of
+ * publish_at/status=scheduled. No publish token, fake deadline or new queue is
+ * minted by this read. A finite complete response fails loudly on overflow.
+ */
+export async function hydrateFrontsMediaPreparations(
+	db: D1Database,
+	options: Pick<
+		HydrateFrontsPublishIntentsOptions,
+		'limit' | 'videoSourceProductionEnabled' | 'podcastSourceProductionEnabled'
+	> = {},
+): Promise<FrontsMediaPreparations> {
+	const limit = Math.min(Math.max(1, Math.floor(options.limit ?? 200)), 1000)
+	const result: FrontsMediaPreparations = { version: 1, items: [], incomplete: [] }
+	const candidates = await db
+		.prepare(`SELECT ${CANDIDATE_COLUMNS} FROM content_items
+		WHERE deleted_at IS NULL AND status IN ('draft', 'review', 'scheduled', 'published')
+		AND ((type = 'video' AND ? = 1 AND EXISTS (
+			SELECT 1 FROM video_content v WHERE v.content_id = content_items.id
+			AND v.processing_trigger_token IS NOT NULL
+			AND (v.hls_ready <> 1 OR v.hls_manifest_url IS NULL OR v.transcript_ready <> 1)))
+		OR (type = 'podcast' AND ? = 1 AND EXISTS (
+			SELECT 1 FROM podcast_content p WHERE p.content_id = content_items.id
+			AND p.processing_trigger_token IS NOT NULL
+			AND (trim(COALESCE(p.audio_r2_key, '')) = '' OR trim(COALESCE(p.transcript, '')) = ''))))
+		ORDER BY created_at ASC, id ASC LIMIT ?`)
+		.bind(
+			options.videoSourceProductionEnabled === false ? 0 : 1,
+			options.podcastSourceProductionEnabled === false ? 0 : 1,
+			limit + 1,
+		)
+		.all<IntentCandidateRow>()
+	const rows = candidates.results ?? []
+	if (rows.length > limit) throw new FrontsScheduleOverflowError(limit)
+	const refs = await loadContentRefSources(db, rows)
+	for (const row of rows) {
+		try {
+			if (!Number.isInteger(row.canonical_version) || (row.canonical_version ?? 0) <= 0) {
+				throw new FrontsPublishIntentError('invalid_canonical_version', row.id)
+			}
+			const video = row.type === 'video' ? await videoSourceRef(row, refs.videos.get(row.id)) : null
+			const podcast =
+				row.type === 'podcast' ? await podcastSourceRef(row, refs.podcasts.get(row.id)) : null
+			if (!video && !podcast)
+				throw new FrontsPublishIntentError(
+					row.type === 'video' ? 'video_media_not_ready' : 'missing_podcast_audio',
+					row.id,
+					'Captured source is incomplete or not ingestable.',
+				)
+			const token = (row.type === 'video' ? refs.videos.get(row.id) : refs.podcasts.get(row.id))
+				?.processing_trigger_token
+			const capturedAt = /^fronts-source-v2:([1-9][0-9]*):[0-9a-f-]{36}$/.exec(token ?? '')?.[1]
+			result.items.push({
+				content_id: row.id,
+				type: row.type as 'video' | 'podcast',
+				slug: row.slug,
+				channel: row.channel,
+				canonical_version: row.canonical_version as number,
+				publish_at: row.publish_at,
+				captured_at: capturedAt ? Number(capturedAt) : null,
+				video_source: video,
+				podcast_source: podcast,
+			})
+		} catch (error) {
+			if (!(error instanceof FrontsPublishIntentError)) throw error
+			result.incomplete.push({ content_id: row.id, code: error.code, message: error.message })
+		}
+	}
+	return result
+}
+
 /** Build one intent, throwing FrontsPublishIntentError on any missing required value. */
 async function buildIntent(
 	row: IntentCandidateRow,
@@ -739,41 +1020,8 @@ async function buildContentRefs(
 				message:
 					'a video intent requires video_content.hls_ready = 1 and a non-empty hls_manifest_url',
 			}
-			const sourceUrl = found?.processing_source_url
-			const correlationId = found?.processing_correlation_id?.trim()
-			if (
-				found &&
-				validPodcastSourceUrl(sourceUrl) &&
-				videoSourceIngestableOverHttps(found.processing_source_kind) &&
-				correlationId &&
-				/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(correlationId)
-			) {
-				if (
-					typeof found.duration_seconds !== 'number' ||
-					!Number.isFinite(found.duration_seconds) ||
-					found.duration_seconds <= 0
-				) {
-					throw new FrontsPublishIntentError(
-						'video_source_duration_unavailable',
-						row.id,
-						'Video source duration is not verified.',
-					)
-				}
-				videoSource = {
-					kind: 'https',
-					url: sourceUrl,
-					duration_seconds: found.duration_seconds,
-					generation: await frontsVideoSourceGeneration({
-						content_id: row.id,
-						slug: row.slug,
-						canonical_version: row.canonical_version as number,
-						processing_source_url: found.processing_source_url,
-						processing_source_kind: found.processing_source_kind,
-						processing_trigger_token: found.processing_trigger_token,
-					}),
-					correlation_id: correlationId,
-					visibility: row.visibility === 'premium' ? 'premium' : 'free',
-				}
+			videoSource = await videoSourceRef(row, found)
+			if (videoSource) {
 				incomplete = {
 					content_id: row.id,
 					code: failure.code,
@@ -824,32 +1072,8 @@ async function buildContentRefs(
 				code: 'missing_podcast_audio' as const,
 				message: 'Podcast audio is not ready.',
 			}
-			const sourceUrl = found?.processing_source_url
-			if (found && validPodcastSourceUrl(sourceUrl) && found.processing_source_kind === 'https') {
-				if (
-					typeof found.duration_seconds !== 'number' ||
-					!Number.isFinite(found.duration_seconds) ||
-					found.duration_seconds <= 0
-				) {
-					throw new FrontsPublishIntentError(
-						'podcast_source_duration_unavailable',
-						row.id,
-						'Podcast source duration is not verified.',
-					)
-				}
-				podcastSource = {
-					kind: 'https',
-					url: sourceUrl,
-					duration_seconds: found.duration_seconds,
-					generation: await frontsPodcastSourceGeneration({
-						content_id: row.id,
-						slug: row.slug,
-						canonical_version: row.canonical_version as number,
-						processing_source_url: found.processing_source_url,
-						processing_source_kind: found.processing_source_kind,
-						processing_trigger_token: found.processing_trigger_token,
-					}),
-				}
+			podcastSource = await podcastSourceRef(row, found)
+			if (podcastSource) {
 				incomplete = {
 					content_id: row.id,
 					code: failure.code,