@growth-labs/cms 0.8.2 → 0.8.4

package/src/engine/foundry-dispatch.ts

@@ -10,8 +10,9 @@
 // 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, D1PreparedStatement, D1Result } from './d1.js'
 import { validPodcastSourceUrl } from './podcast-source.js'
+import { mediaPublicationCaptureGuard } from './publication-current-guard.js'
 
 interface PodcastDispatchSnapshot {
 	content_id: string
@@ -35,8 +36,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 +102,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,10 +129,13 @@ export async function dispatchToFoundry(
 	db: D1Database,
 	contentId: string,
 	hook: Pick<FoundryDispatch, 'dispatchVideo'>,
+	options: { ifUncaptured?: boolean } = {},
 ): Promise<DispatchResult> {
 	const content = await db
 		.prepare(
-			'SELECT id, type, slug, title, description, canonical_version, status, deleted_at FROM content_items WHERE id = ? LIMIT 1',
+			`SELECT id, type, slug, title, description, canonical_version, status, deleted_at,
+			visibility, published_revision_id, published_at, publish_at, publish_tz,
+			fronts_publish_status, fronts_publish_trigger_token FROM content_items WHERE id = ? LIMIT 1`,
 		)
 		.bind(contentId)
 		.first<{
@@ -127,6 +147,13 @@ export async function dispatchToFoundry(
 			canonical_version: number
 			status: string
 			deleted_at: number | null
+			visibility: string
+			published_revision_id: string | null
+			published_at: number | null
+			publish_at: number | null
+			publish_tz: string | null
+			fronts_publish_status: string | null
+			fronts_publish_trigger_token: string | null
 		}>()
 	if (!content) {
 		throw new Error(`dispatchToFoundry: content ${contentId} not found`)
@@ -135,7 +162,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 +171,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 +184,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) {
@@ -182,12 +225,21 @@ export async function dispatchToFoundry(
 			throw new Error(`dispatchToFoundry: podcast ${contentId} is inactive`)
 		}
 		podcastSnapshot = podcastRow
-		sourceUrl = podcastRow.audio_r2_key?.trim() ?? ''
+		const selectedSource = podcastRow.processing_source_url?.trim()
+		if (
+			selectedSource &&
+			(podcastRow.processing_source_kind !== 'https' || !validPodcastSourceUrl(selectedSource))
+		) {
+			throw new Error(`dispatchToFoundry: content ${contentId} has an invalid podcast source URL`)
+		}
+		sourceUrl = selectedSource || podcastRow.audio_r2_key?.trim() || ''
 		if (!sourceUrl) {
-			throw new Error(`dispatchToFoundry: content ${contentId} has no podcast audio R2 key`)
+			throw new Error(
+				`dispatchToFoundry: content ${contentId} has no podcast source or audio R2 key`,
+			)
 		}
 		kind = 'podcast'
-		sourceKind = 'r2_key'
+		sourceKind = selectedSource ? 'https' : 'r2_key'
 		videoId = normalizeVideoId(content.slug, content.slug)
 		durationSeconds = podcastRow.duration_seconds
 	}
@@ -199,9 +251,24 @@ 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 publicationGuard = mediaPublicationCaptureGuard(content, processingTriggerTokenHash)
 	const { correlationId, podcastSource } = await hook.dispatchVideo({
 		contentId,
 		sourceUrl,
@@ -217,7 +284,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',
@@ -225,6 +293,7 @@ export async function dispatchToFoundry(
              processing_source_kind = ?,
              processing_correlation_id = ?,
              processing_trigger_token = ?,
+             processing_publication_guard = ?,
              processing_started_at = ?,
              processing_completed_at = NULL,
              processing_last_event_at = NULL,
@@ -235,10 +304,44 @@ 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
+         AND ci.visibility IS ? AND ci.published_revision_id IS ? AND ci.published_at IS ?
+         AND ci.publish_at IS ? AND ci.publish_tz IS ?
+         AND ci.fronts_publish_status IS ? AND ci.fronts_publish_trigger_token IS ?)`,
+			)
+			.bind(
+				videoId,
+				sourceKind,
+				correlationId,
+				triggerToken,
+				publicationGuard,
+				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,
+				content.visibility,
+				content.published_revision_id,
+				content.published_at,
+				content.publish_at,
+				content.publish_tz,
+				content.fronts_publish_status,
+				content.fronts_publish_trigger_token,
 			)
-			.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,16 +362,20 @@ 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 = ?, processing_publication_guard = ?, processing_state = 'queued', 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
 			AND ci.type = 'podcast' AND ci.slug = ? AND ci.canonical_version = ?
-			AND ci.status = ? AND ci.deleted_at IS NULL)`)
+			AND ci.status = ? AND ci.deleted_at IS NULL
+			AND ci.visibility IS ? AND ci.published_revision_id IS ? AND ci.published_at IS ?
+			AND ci.publish_at IS ? AND ci.publish_tz IS ?
+			AND ci.fronts_publish_status IS ? AND ci.fronts_publish_trigger_token IS ?)`)
 			.bind(
 				capturedUrl,
 				capturedKind,
 				triggerToken,
+				publicationGuard,
 				contentId,
 				podcastSnapshot.audio_r2_key,
 				podcastSnapshot.duration_seconds,
@@ -279,6 +386,13 @@ export async function dispatchToFoundry(
 				content.slug,
 				content.canonical_version,
 				content.status,
+				content.visibility,
+				content.published_revision_id,
+				content.published_at,
+				content.publish_at,
+				content.publish_tz,
+				content.fronts_publish_status,
+				content.fronts_publish_trigger_token,
 			)
 			.run()
 		if (written.meta?.changes !== 1)
@@ -352,14 +466,19 @@ export async function applyFoundryCallback(db: D1Database, input: CallbackInput)
 		return false // no matching job for this trigger token
 	}
 
-	// Insert the event row.
+	// A failed event is consumed atomically with terminal state and guard revocation.
+	// Otherwise a transient media write failure would make its retry a no-op.
 	const now = Math.floor(Date.now() / 1000)
-	await db
+	const eventStatement = db
 		.prepare(
 			'INSERT INTO foundry_callback_events (event_id, event_kind, correlation_id, received_at) VALUES (?, ?, ?, ?)',
 		)
 		.bind(eventId, eventKind, correlationId, now)
-		.run()
+	if (nextState !== 'failed') await eventStatement.run()
+	const applyMediaUpdate = async (statement: D1PreparedStatement): Promise<D1Result> =>
+		nextState === 'failed'
+			? (await db.batch([statement, eventStatement]))[0]!
+			: await statement.run()
 
 	// Advance the state machine.
 	const isTerminal = (TERMINAL_STATES as string[]).includes(nextState)
@@ -371,35 +490,44 @@ export async function applyFoundryCallback(db: D1Database, input: CallbackInput)
 			typeof durationSeconds === 'number' && Number.isFinite(durationSeconds)
 				? Math.max(0, Math.floor(durationSeconds))
 				: null
-		if (nextTranscript !== null || nextDurationSeconds !== null) {
-			await db
-				.prepare(
-					`UPDATE podcast_content
-					SET transcript = CASE WHEN ? THEN ? ELSE transcript END,
+		{
+			const updated = await applyMediaUpdate(
+				db
+					.prepare(
+						`UPDATE podcast_content
+					SET processing_state = ?, processing_publication_guard = CASE WHEN ? = 'failed' THEN NULL ELSE processing_publication_guard END,
+                        transcript = CASE WHEN ? THEN ? ELSE transcript END,
 						duration_seconds = CASE WHEN ? THEN ? ELSE duration_seconds END
-					WHERE content_id = ?`,
-				)
-				.bind(
-					nextTranscript !== null ? 1 : 0,
-					nextTranscript,
-					nextDurationSeconds !== null ? 1 : 0,
-					nextDurationSeconds,
-					podcastRow.content_id,
-				)
-				.run()
+					WHERE content_id = ? AND processing_trigger_token = ?`,
+					)
+					.bind(
+						nextState,
+						nextState,
+						nextTranscript !== null ? 1 : 0,
+						nextTranscript,
+						nextDurationSeconds !== null ? 1 : 0,
+						nextDurationSeconds,
+						podcastRow.content_id,
+						triggerToken,
+					),
+			)
+			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 +535,62 @@ 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
-			.prepare(
-				`UPDATE video_content
+		updated = await applyMediaUpdate(
+			db
+				.prepare(
+					`UPDATE video_content
          SET processing_state = ?,
+             processing_publication_guard = NULL,
              processing_last_event_at = ?,
              processing_completed_at = ?,
              processing_error = ?
-         WHERE content_id = ?`,
-			)
-			.bind(nextState, now, now, error ?? null, row.content_id)
-			.run()
+         WHERE content_id = ? AND processing_trigger_token = ?`,
+				)
+				.bind(nextState, now, now, error ?? null, row.content_id, triggerToken),
+		)
 	} 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
 }
 
 /**