@growth-labs/cms 0.8.2 → 0.8.3

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,

package/src/engine/fronts-publish.ts

@@ -24,7 +24,14 @@
 // additive and gated by FRONTS_PUBLISH_ENABLED (default ON — a rollback lever,
 // not a dark-staging gate).
 
+import type { LlmDispatch } from '../providers/types.js'
 import type { ContentType, FrontsPublishStatus } from '../schema/types.js'
+import {
+	applyGeneratedContentDek,
+	generateContentDekSuggestion,
+	loadDekGenerationContextFromSnapshot,
+} from './ai-dek.js'
+import { parseLockedFields } from './ai-writeback.js'
 import type { D1Database } from './d1.js'
 import { FrontsScheduleOverflowError } from './fronts-publish-intent.js'
 import { podcastPublishBlocker } from './podcast-source.js'
@@ -35,6 +42,7 @@ import {
 	snapshotRecord,
 } from './publication-current-guard.js'
 import { getContentSnapshot } from './publisher.js'
+import { getRevision } from './revisions.js'
 
 /** The five lifecycle states foundryd reports for a Fronts publish intent. */
 export const FRONTS_PUBLISH_STATUSES: readonly FrontsPublishStatus[] = [
@@ -161,6 +169,8 @@ export interface FrontsPublishCallbackInput {
 	now?: number
 	/** Optional occurrence evidence carried by current publish workers. */
 	publishAt?: number | null
+	/** Optional existing CMS LLM hook for best-effort missing-dek generation. */
+	llm?: LlmDispatch
 	/** The route supplies the same host hook used by the editorial publish action. */
 	checkReadiness?: (item: {
 		id: string
@@ -183,6 +193,10 @@ export interface FrontsPublishCallbackResult {
 	ledgerError: string | null
 	/** A retryable hold or stale/cancelled snapshot; never consumes event_id. */
 	rejection?: { code: string; status: 404 | 409 | 503; blockers?: string[]; message: string }
+	/** Safe post-commit reason for a missing-dek editor notification. */
+	dekFailureReason?: 'ai_generation_unavailable' | 'ai_generation_timeout' | null
+	/** Existing lifecycle payload fields, present only for this call's committed publication. */
+	publishedItem?: { id: string; type: ContentType; title: string } | null
 }
 
 function hasReceipt(receipt: FrontsPublishReceipt | null | undefined): boolean {
@@ -210,6 +224,8 @@ function resolveOccurredAtSeconds(
 	return Math.min(seconds, now)
 }
 
+class DekGenerationTimeoutError extends Error {}
+
 /**
  * Apply one foundryd publish-callback. Idempotent by `event_id`: a repeat
  * delivery returns the stored outcome without re-applying. See the module
@@ -250,6 +266,8 @@ export async function applyFrontsPublishCallback(
 	let published = item.status === 'published'
 	let attemptId: string | null = null
 	let ledgerError: string | null = null
+	let committedDekFailureReason: FrontsPublishCallbackResult['dekFailureReason'] = null
+	let committedPublishedItem: FrontsPublishCallbackResult['publishedItem'] = null
 	const shouldPublish = input.status === 'live' && hasReceipt(input.receipt)
 	if (shouldPublish && item.status === 'published') {
 		const current = await getContentSnapshot(db, input.contentId)
@@ -326,9 +344,88 @@ export async function applyFrontsPublishCallback(
 				['publish_not_due'],
 			)
 		}
+		let dekFailureReason: FrontsPublishCallbackResult['dekFailureReason'] = null
+		const initialExcerpt =
+			typeof expectedItem.excerpt === 'string' ? expectedItem.excerpt.trim() : ''
+		const initialLocks = parseLockedFields(
+			typeof expectedItem.ai_locked_fields === 'string' ? expectedItem.ai_locked_fields : null,
+		)
+		if (!initialExcerpt && !initialLocks.includes('excerpt')) {
+			if (!input.llm) {
+				dekFailureReason = 'ai_generation_unavailable'
+			} else {
+				const deadlineAt = performance.now() + 8_000
+				let timeout: ReturnType<typeof setTimeout> | undefined
+				try {
+					const generated = await Promise.race([
+						(async () => {
+							const context = await loadDekGenerationContextFromSnapshot(db, expectedSnapshot)
+							if (!context) {
+								return {
+									context: null,
+									suggestion: {
+										status: 'unavailable' as const,
+										dek: null,
+										reason: 'unavailable',
+									},
+								}
+							}
+							return {
+								context,
+								suggestion: await generateContentDekSuggestion({
+									context,
+									llm: input.llm!,
+								}),
+							}
+						})(),
+						new Promise<never>((_resolve, rejectTimeout) => {
+							timeout = setTimeout(() => rejectTimeout(new DekGenerationTimeoutError()), 8_000)
+						}),
+					])
+					if (generated.suggestion.status !== 'generated') {
+						dekFailureReason = 'ai_generation_unavailable'
+					} else if (!generated.context || performance.now() >= deadlineAt) {
+						dekFailureReason = 'ai_generation_timeout'
+					} else {
+						const applied = await applyGeneratedContentDek({
+							db,
+							contentId: input.contentId,
+							dek: generated.suggestion.dek,
+							context: generated.context,
+							expectedPublicationSnapshot: expectedSnapshot,
+						})
+						if (applied.status === 'unavailable') dekFailureReason = 'ai_generation_unavailable'
+					}
+				} catch (error) {
+					dekFailureReason =
+						error instanceof DekGenerationTimeoutError
+							? 'ai_generation_timeout'
+							: 'ai_generation_unavailable'
+				} finally {
+					if (timeout !== undefined) clearTimeout(timeout)
+				}
+			}
+		}
+
+		const currentSnapshot = await getContentSnapshot(db, input.contentId)
+		try {
+			assertCurrentPublicationSnapshot(currentSnapshot ?? {}, expectedSnapshot)
+		} catch {
+			return reject(
+				'publish_snapshot_changed',
+				409,
+				'Scheduled content or media changed before publication.',
+			)
+		}
+		const currentItem = snapshotRecord(currentSnapshot?.item)
+		const currentExcerpt = typeof currentItem.excerpt === 'string' ? currentItem.excerpt.trim() : ''
+		const currentLocks = parseLockedFields(
+			typeof currentItem.ai_locked_fields === 'string' ? currentItem.ai_locked_fields : null,
+		)
+		if (currentExcerpt || currentLocks.includes('excerpt')) dekFailureReason = null
 		const blocker =
-			expectedItem.type === 'podcast'
-				? podcastPublishBlocker(snapshotRecord(expectedSnapshot.content))
+			currentItem.type === 'podcast'
+				? podcastPublishBlocker(snapshotRecord(currentSnapshot?.content))
 				: null
 		if (blocker) return reject('publish_not_ready', 503, blocker.message, [blocker.code])
 		if (input.checkReadiness) {
@@ -337,7 +434,7 @@ export async function applyFrontsPublishCallback(
 				const readiness = await Promise.race([
 					input.checkReadiness({
 						id: input.contentId,
-						type: expectedItem.type as ContentType,
+						type: currentItem.type as ContentType,
 						status: 'scheduled',
 					}),
 					new Promise<never>((_resolve, rejectTimeout) => {
@@ -378,11 +475,29 @@ export async function applyFrontsPublishCallback(
 				...(publishedAt !== null ? { publishedAt } : {}),
 				createdBy: 'foundry.fronts-publish',
 				surfaces: [surface],
-				expectedCurrentSnapshot: expectedSnapshot,
+				expectedCurrentSnapshot: currentSnapshot!,
 				expectedReceiptIdentity: receiptIdentity,
 			})
 			attemptId = receipt.attemptId
 			published = true
+			const committedRevision = await getRevision(db, input.contentId, receipt.revisionId)
+			if (attemptId && committedRevision) {
+				const committedItem = snapshotRecord(committedRevision.payload.item)
+				const committedExcerpt =
+					typeof committedItem.excerpt === 'string' ? committedItem.excerpt.trim() : ''
+				const committedLocks = parseLockedFields(
+					typeof committedItem.ai_locked_fields === 'string'
+						? committedItem.ai_locked_fields
+						: null,
+				)
+				committedDekFailureReason =
+					committedExcerpt || committedLocks.includes('excerpt') ? null : dekFailureReason
+				committedPublishedItem = {
+					id: String(committedItem.id ?? input.contentId),
+					type: committedItem.type as ContentType,
+					title: String(committedItem.title ?? ''),
+				}
+			}
 		} catch (error) {
 			// A concurrently published row may belong to a newer editor/source
 			// revision. Only a matching committed snapshot and full receipt prove
@@ -496,6 +611,8 @@ export async function applyFrontsPublishCallback(
 		attemptId,
 		contentFound: true,
 		ledgerError,
+		dekFailureReason: committedDekFailureReason,
+		publishedItem: committedPublishedItem,
 	}
 }
 

package/src/engine/index.ts

@@ -78,6 +78,7 @@ export type { D1Database, D1DatabaseSession, D1PreparedStatement, D1Result } fro
 export {
 	applyFoundryCallback,
 	type CallbackInput,
+	createFoundrySourceCaptureToken,
 	type DispatchResult,
 	dispatchToFoundry,
 	type ProcessingState,

package/src/engine/podcast-source.ts

@@ -9,19 +9,21 @@ export interface FrontsPodcastSourceSnapshot {
 }
 
 /**
- * Stable over polling, machine media callbacks and rescheduling. Canonical
- * editor/source changes invalidate the old production. Neither the raw source
+ * V1 captures keep their canonical-version binding. New v2 captures remain
+ * stable over editorial metadata edits, polling, callbacks and rescheduling;
+ * source/slug/token changes invalidate production. Neither the raw source
  * token nor URL needs to appear in callback/notification identities.
  */
 export async function frontsPodcastSourceGeneration(
 	input: FrontsPodcastSourceSnapshot,
 ): Promise<string> {
+	const version = input.processing_trigger_token?.startsWith('fronts-source-v2:') ? 2 : 1
 	const bytes = new TextEncoder().encode(
 		JSON.stringify([
-			'fronts-podcast-source.v1',
+			`fronts-podcast-source.v${version}`,
 			input.content_id,
 			input.slug,
-			input.canonical_version,
+			...(version === 1 ? [input.canonical_version] : []),
 			input.processing_source_url,
 			input.processing_source_kind,
 			input.processing_trigger_token,