@growth-labs/cms 0.8.2 → 0.8.3

package/src/engine/ai-dek.ts

@@ -2,6 +2,11 @@ import type { LlmDispatch } from '../providers/types.js'
 import { dekPrompt } from './ai-prompts.js'
 import { applyAiWrite, parseLockedFields } from './ai-writeback.js'
 import type { D1Database } from './d1.js'
+import {
+	CURRENT_PUBLICATION_GUARD,
+	currentPublicationSqlGuard,
+	snapshotRecord,
+} from './publication-current-guard.js'
 import { type ContentItemRecord, getContentItem } from './publisher.js'
 
 export const DEK_EXEMPLAR_LIMIT = 6
@@ -18,6 +23,10 @@ export type GenerateContentDekResult =
 	| { status: 'unavailable'; dek: null; written: false; reason: string }
 	| { status: 'not_found'; dek: null; written: false; reason: 'not_found' }
 
+export type GenerateContentDekSuggestionResult =
+	| { status: 'generated'; dek: string }
+	| { status: 'unavailable'; dek: null; reason: string }
+
 async function loadTypeSource(db: D1Database, item: ContentItemRecord): Promise<string> {
 	if (item.type === 'video') {
 		const row = await db
@@ -47,16 +56,7 @@ async function loadTypeSource(db: D1Database, item: ContentItemRecord): Promise<
 	return (row?.body_markdown || row?.body_html || row?.subtitle || '').trim()
 }
 
-export async function loadDekGenerationContext(
-	db: D1Database,
-	contentId: string,
-): Promise<DekGenerationContext | null> {
-	const item = await getContentItem(db, contentId)
-	if (!item) return null
-
-	const typeSource = await loadTypeSource(db, item)
-	const description = item.description?.trim() ?? ''
-	const source = [description, typeSource].filter(Boolean).join('\n\n')
+async function loadExemplars(db: D1Database, item: ContentItemRecord): Promise<string[]> {
 	const rows = await db
 		.prepare(
 			`SELECT title, excerpt
@@ -71,13 +71,44 @@ export async function loadDekGenerationContext(
 			          id ASC
 			 LIMIT ?`,
 		)
-		.bind(contentId, item.type, DEK_EXEMPLAR_LIMIT)
+		.bind(item.id, item.type, DEK_EXEMPLAR_LIMIT)
 		.all<{ title: string; excerpt: string }>()
-	const exemplars = (rows.results ?? []).map(
-		(row) => `Headline: ${row.title}\nDek: ${row.excerpt.trim()}`,
-	)
+	return (rows.results ?? []).map((row) => `Headline: ${row.title}\nDek: ${row.excerpt.trim()}`)
+}
 
-	return { item, source, exemplars }
+export async function loadDekGenerationContext(
+	db: D1Database,
+	contentId: string,
+): Promise<DekGenerationContext | null> {
+	const item = await getContentItem(db, contentId)
+	if (!item) return null
+
+	const typeSource = await loadTypeSource(db, item)
+	const description = item.description?.trim() ?? ''
+	const source = [description, typeSource].filter(Boolean).join('\n\n')
+	return { item, source, exemplars: await loadExemplars(db, item) }
+}
+
+/** Build the prompt context from an already-authorized publication snapshot. */
+export async function loadDekGenerationContextFromSnapshot(
+	db: D1Database,
+	snapshot: Record<string, unknown>,
+): Promise<DekGenerationContext | null> {
+	const item = snapshotRecord(snapshot.item) as unknown as ContentItemRecord
+	if (!item.id || !item.type || !item.title) return null
+	const content = snapshotRecord(snapshot.content)
+	const typeSource =
+		item.type === 'video'
+			? String(content.script ?? '').trim()
+			: item.type === 'podcast'
+				? String(content.transcript ?? '').trim()
+				: String(content.body_markdown || content.body_html || content.subtitle || '').trim()
+	const description = item.description?.trim() ?? ''
+	return {
+		item,
+		source: [description, typeSource].filter(Boolean).join('\n\n'),
+		exemplars: await loadExemplars(db, item),
+	}
 }
 
 function normalizeDek(text: string): string {
@@ -88,51 +119,111 @@ function normalizeDek(text: string): string {
 		.trim()
 }
 
-export async function generateContentDek(input: {
-	db: D1Database
-	contentId: string
+/** Dispatch and normalize a dek suggestion without creating any D1 write continuation. */
+export async function generateContentDekSuggestion(input: {
+	context: DekGenerationContext
 	llm: LlmDispatch
-}): Promise<GenerateContentDekResult> {
-	const context = await loadDekGenerationContext(input.db, input.contentId)
-	if (!context) {
-		return { status: 'not_found', dek: null, written: false, reason: 'not_found' }
-	}
-
+}): Promise<GenerateContentDekSuggestionResult> {
 	const result = await input.llm.dispatch({
 		...dekPrompt({
-			title: context.item.title,
-			source: context.source,
-			exemplars: context.exemplars,
+			title: input.context.item.title,
+			source: input.context.source,
+			exemplars: input.context.exemplars,
 		}),
 		stream: false,
 	})
 	if (result instanceof ReadableStream) {
-		return { status: 'unavailable', dek: null, written: false, reason: 'stream_result' }
+		return { status: 'unavailable', dek: null, reason: 'stream_result' }
 	}
 	if (result.status === 'unavailable') {
 		return {
 			status: 'unavailable',
 			dek: null,
-			written: false,
 			reason: result.reason ?? 'unavailable',
 		}
 	}
 
 	const dek = normalizeDek(result.text)
-	if (!dek) {
-		return { status: 'unavailable', dek: null, written: false, reason: 'empty_result' }
-	}
+	if (!dek) return { status: 'unavailable', dek: null, reason: 'empty_result' }
+	return { status: 'generated', dek }
+}
 
+/** Apply a generated suggestion only while its captured editor/publication state is current. */
+export async function applyGeneratedContentDek(input: {
+	db: D1Database
+	contentId: string
+	dek: string
+	context: DekGenerationContext
+	expectedPublicationSnapshot?: Record<string, unknown>
+}): Promise<GenerateContentDekResult> {
 	const write = applyAiWrite({
-		locked: parseLockedFields(context.item.ai_locked_fields),
+		locked: parseLockedFields(input.context.item.ai_locked_fields),
 		field: 'excerpt',
-		value: dek,
+		value: input.dek,
 	})
-	if (!write.written) return { status: 'locked', dek, written: false }
+	if (!write.written) return { status: 'locked', dek: input.dek, written: false }
+
+	const capturedItem = input.context.item as ContentItemRecord & { canonical_version: number }
+	const guardPayload = input.expectedPublicationSnapshot
+		? JSON.stringify({
+				...input.expectedPublicationSnapshot,
+				publication_guard: CURRENT_PUBLICATION_GUARD,
+			})
+		: null
+	const publicationPredicate = guardPayload
+		? `AND EXISTS (
+			 SELECT 1 FROM (SELECT ? AS payload_json) dek_expected
+			 WHERE ${currentPublicationSqlGuard('dek_expected')}
+		   )`
+		: ''
+	const statement = input.db
+		.prepare(
+			`UPDATE content_items
+			 SET excerpt = ?, updated_at = unixepoch()
+			 WHERE id = ?
+			   AND canonical_version IS ?
+			   AND excerpt IS ?
+			   AND ai_locked_fields IS ?
+			   ${publicationPredicate}`,
+		)
+		.bind(
+			input.dek,
+			input.contentId,
+			capturedItem.canonical_version,
+			capturedItem.excerpt,
+			capturedItem.ai_locked_fields,
+			...(guardPayload ? [guardPayload] : []),
+		)
+	const result = await statement.run()
+	if (result.meta?.changes !== 1) {
+		return { status: 'unavailable', dek: null, written: false, reason: 'content_changed' }
+	}
+	return { status: 'generated', dek: input.dek, written: true }
+}
 
-	await input.db
-		.prepare('UPDATE content_items SET excerpt = ?, updated_at = unixepoch() WHERE id = ?')
-		.bind(dek, input.contentId)
-		.run()
-	return { status: 'generated', dek, written: true }
+export async function generateContentDek(input: {
+	db: D1Database
+	contentId: string
+	llm: LlmDispatch
+}): Promise<GenerateContentDekResult> {
+	const context = await loadDekGenerationContext(input.db, input.contentId)
+	if (!context) {
+		return { status: 'not_found', dek: null, written: false, reason: 'not_found' }
+	}
+
+	const suggestion = await generateContentDekSuggestion({ context, llm: input.llm })
+	if (suggestion.status === 'unavailable') {
+		return {
+			status: 'unavailable',
+			dek: null,
+			written: false,
+			reason: suggestion.reason,
+		}
+	}
+	return applyGeneratedContentDek({
+		db: input.db,
+		contentId: input.contentId,
+		dek: suggestion.dek,
+		context,
+	})
 }

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
 }
 
 /**