@growth-labs/cms 0.6.3 → 0.6.5

package/src/engine/publisher.ts

@@ -343,12 +343,19 @@ export interface UpdateContentInput extends Partial<BaseContentInput> {
 export interface UpdateContentOptions {
 	/** Atomically apply the update only while the content row has this status. */
 	requiredStatus?: ContentStatus
+	/** Apply a resolved media source only while this exact source identity is still stored. */
+	expectedMediaSource?: {
+		sourceUrl: string | null
+		sourceKind: string | null
+	}
 }
 
 export interface UpdateContentResult {
 	slug: string
 	/** Present when requiredStatus lost a race before the mutation transaction. */
 	statusConflict?: string
+	/** Present when a newer media-source update won while this request was resolving. */
+	mediaSourceConflict?: boolean
 }
 
 interface VideoUpdatePlan {
@@ -1113,9 +1120,10 @@ export async function updateContentItem(
 		return { slug }
 	}
 
-	await db
-		.prepare(
-			`
+	const updateBaseContent = async () => {
+		await db
+			.prepare(
+				`
       UPDATE content_items SET
         slug = ?,
         title = ?,
@@ -1145,38 +1153,40 @@ export async function updateContentItem(
         canonical_version = canonical_version + 1
       WHERE id = ?
       `,
-		)
-		.bind(
-			slug,
-			title,
-			seoTitle,
-			description,
-			excerpt,
-			byline,
-			primaryCategory,
-			primaryTopic,
-			featured,
-			visibility,
-			authorId,
-			heroImageId,
-			heroImageAlt,
-			heroImageCaption,
-			socialImageId,
-			canonicalUrl,
-			aiLockedFields,
-			seoFocusKeyword,
-			metadataJson,
-			id,
-		)
-		.run()
+			)
+			.bind(
+				slug,
+				title,
+				seoTitle,
+				description,
+				excerpt,
+				byline,
+				primaryCategory,
+				primaryTopic,
+				featured,
+				visibility,
+				authorId,
+				heroImageId,
+				heroImageAlt,
+				heroImageCaption,
+				socialImageId,
+				canonicalUrl,
+				aiLockedFields,
+				seoFocusKeyword,
+				metadataJson,
+				id,
+			)
+			.run()
 
-	if (input.tags !== undefined) {
-		await setContentTagPairs(db, id, tagPairs ?? [])
-	}
+		if (input.tags !== undefined) {
+			await setContentTagPairs(db, id, tagPairs ?? [])
+		}
 
-	if (input.relations !== undefined) {
-		await setContentRelations(db, id, input.relations)
+		if (input.relations !== undefined) {
+			await setContentRelations(db, id, input.relations)
+		}
 	}
+	if (!options.expectedMediaSource) await updateBaseContent()
 
 	if (input.content) {
 		if (isBodyBackedContentType(existing.type)) {
@@ -1276,7 +1286,7 @@ export async function updateContentItem(
 
 		if (existing.type === 'video') {
 			if (!videoUpdatePlan) return { slug }
-			await db
+			const result = await db
 				.prepare(
 					`
           UPDATE video_content SET
@@ -1299,7 +1309,8 @@ export async function updateContentItem(
             transcript_url = CASE WHEN ? THEN NULL ELSE transcript_url END,
             hls_manifest_url = CASE WHEN ? THEN NULL ELSE hls_manifest_url END,
             hls_poster_url = CASE WHEN ? THEN NULL ELSE hls_poster_url END
-          WHERE content_id = ?
+		  WHERE content_id = ?
+		    AND (? = 0 OR (processing_source_url IS ? AND processing_source_kind IS ?))
 		  `,
 				)
 				.bind(
@@ -1323,13 +1334,19 @@ export async function updateContentItem(
 					videoUpdatePlan.sourceChanged ? 1 : 0,
 					videoUpdatePlan.sourceChanged ? 1 : 0,
 					id,
+					options.expectedMediaSource ? 1 : 0,
+					options.expectedMediaSource?.sourceUrl ?? null,
+					options.expectedMediaSource?.sourceKind ?? null,
 				)
 				.run()
+			if (options.expectedMediaSource && (result.meta?.changes ?? 0) !== 1) {
+				return { slug, mediaSourceConflict: true }
+			}
 		}
 
 		if (existing.type === 'podcast') {
 			if (!podcastUpdatePlan) return { slug }
-			await db
+			const result = await db
 				.prepare(
 					`
 		  UPDATE podcast_content SET
@@ -1340,6 +1357,7 @@ export async function updateContentItem(
 		    processing_source_url = ?,
 		    processing_source_kind = ?
 		  WHERE content_id = ?
+		    AND (? = 0 OR (processing_source_url IS ? AND processing_source_kind IS ?))
 		  `,
 				)
 				.bind(
@@ -1350,10 +1368,17 @@ export async function updateContentItem(
 					podcastUpdatePlan.sourceUrl,
 					podcastUpdatePlan.sourceKind,
 					id,
+					options.expectedMediaSource ? 1 : 0,
+					options.expectedMediaSource?.sourceUrl ?? null,
+					options.expectedMediaSource?.sourceKind ?? null,
 				)
 				.run()
+			if (options.expectedMediaSource && (result.meta?.changes ?? 0) !== 1) {
+				return { slug, mediaSourceConflict: true }
+			}
 		}
 	}
+	if (options.expectedMediaSource) await updateBaseContent()
 
 	return { slug }
 }

package/src/providers/types.ts

@@ -402,6 +402,42 @@ export interface FoundryDispatch {
 	getJob(correlationId: string): Promise<{ state: string } | null>
 }
 
+export type MediaSourceKind = 'video' | 'podcast'
+
+export interface MediaSourceResolveInput {
+	kind: MediaSourceKind
+	sourceUrl: string
+	/** A client-side measurement may be reused only when the host can prove its source identity. */
+	knownDurationSeconds?: number | null
+}
+
+export interface MediaSourceResolution {
+	/** Echo of the exact source this result measured. Routes reject mismatched/stale results. */
+	requestedUrl: string
+	/** Stable source URL to persist and later dispatch. */
+	resolvedUrl: string
+	sourceKind: string
+	durationSeconds: number | null
+	/** Explicit reasons the source is not dispatch-ready. Empty when duration is authoritative. */
+	blockers: string[]
+}
+
+export interface MediaSourceProvider {
+	resolve(input: MediaSourceResolveInput, ctx?: unknown): Promise<MediaSourceResolution>
+}
+
+export class MediaSourceProviderError extends Error {
+	readonly status: number
+	readonly code: string
+
+	constructor(status: number, code: string, message: string) {
+		super(message)
+		this.name = 'MediaSourceProviderError'
+		this.status = status
+		this.code = code
+	}
+}
+
 export interface SeoProvider {
 	scoreDraft(input: SeoScoreInput): Promise<SeoScoreResult>
 }
@@ -442,4 +478,6 @@ export interface CmsProviders {
 	search: SearchProvider
 	settings: SettingsProvider
 	surveys?: SurveyProvider
+	/** Optional host-owned source normalizer and duration probe. */
+	mediaSource?: MediaSourceProvider
 }

package/src/routes/content.ts

@@ -59,6 +59,7 @@ import { softDeleteContent } from '../engine/soft-delete.js'
 import { normalizeSourceSections } from '../engine/source-sections.js'
 import { TagInputError } from '../engine/taxonomy.js'
 import type { ValidationError } from '../engine/validator/index.js'
+import type { MediaSourceResolution } from '../providers/types.js'
 import { parseLayoutEnvelope } from '../schema/layout.js'
 import { parsePortableTextEnvelope } from '../schema/portable-text.js'
 import type { ContentStatus, FrontsPublishStatus } from '../schema/types.js'
@@ -77,6 +78,62 @@ interface PodcastFoundryAttempt {
 	reason: PodcastFoundryReason
 }
 
+export interface MediaSourceReadiness {
+	requestedUrl: string
+	resolvedUrl: string
+	sourceKind: string
+	durationSeconds: number | null
+	ready: boolean
+	blockers: string[]
+}
+
+interface StoredMediaSource {
+	sourceUrl: string | null
+	sourceKind: string | null
+	durationSeconds: number | null
+}
+
+interface MutableMediaSourceContent {
+	processingSourceUrl?: string | null
+	processingSourceKind?: string | null
+	durationSeconds?: number | null
+}
+
+function positiveIntegerDuration(value: unknown): number | null {
+	if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) return null
+	return Math.ceil(value)
+}
+
+interface MediaSourceProviderFailure {
+	name: 'MediaSourceProviderError'
+	message: string
+	status: number
+	code: string
+}
+
+function asMediaSourceProviderFailure(error: unknown): MediaSourceProviderFailure | null {
+	if (!error || typeof error !== 'object') return null
+	const candidate = error as Partial<MediaSourceProviderFailure>
+	if (
+		candidate.name !== 'MediaSourceProviderError' ||
+		typeof candidate.message !== 'string' ||
+		typeof candidate.code !== 'string' ||
+		typeof candidate.status !== 'number' ||
+		!Number.isInteger(candidate.status) ||
+		candidate.status < 400 ||
+		candidate.status > 599
+	) {
+		return null
+	}
+	return candidate as MediaSourceProviderFailure
+}
+
+function mediaSourceProviderErrorResponse(error: unknown): Response | null {
+	const failure = asMediaSourceProviderFailure(error)
+	if (!failure) return null
+	return json({ error: failure.message, reason: failure.code }, failure.status)
+}
+
 function verifiedMediaDurationConflictResponse(error: unknown): Response | null {
 	if (!(error instanceof VerifiedMediaDurationConflictError)) return null
 	return json(
@@ -771,6 +828,159 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 	const publishReadiness = config.publishReadiness
 	const activeWorkspaceId = config.activeWorkspaceId ?? 'default'
 
+	async function loadStoredMediaSource(
+		db: D1Database,
+		contentId: string,
+		type: ContentType,
+	): Promise<StoredMediaSource | null> {
+		if (type !== 'video' && type !== 'podcast') return null
+		const table = type === 'video' ? 'video_content' : 'podcast_content'
+		const row = await db
+			.prepare(
+				`SELECT processing_source_url, processing_source_kind, duration_seconds
+				 FROM ${table}
+				 WHERE content_id = ?
+				 LIMIT 1`,
+			)
+			.bind(contentId)
+			.first<{
+				processing_source_url: string | null
+				processing_source_kind: string | null
+				duration_seconds: number | null
+			}>()
+		return row
+			? {
+					sourceUrl: row.processing_source_url,
+					sourceKind: row.processing_source_kind,
+					durationSeconds: positiveIntegerDuration(row.duration_seconds),
+				}
+			: null
+	}
+
+	async function resolveMediaSourceForSave(
+		ctx: RouteContext,
+		type: ContentType,
+		content: MutableMediaSourceContent,
+		stored: StoredMediaSource | null,
+	): Promise<MediaSourceReadiness | null> {
+		const provider = resolved.providers.mediaSource
+		if (!provider || (type !== 'video' && type !== 'podcast')) return null
+		if (!Object.hasOwn(content, 'processingSourceUrl')) return null
+
+		const requestedUrl = content.processingSourceUrl?.trim() ?? ''
+		if (!requestedUrl) {
+			content.processingSourceUrl = null
+			content.processingSourceKind = null
+			content.durationSeconds = null
+			return null
+		}
+		const storedDuration = positiveIntegerDuration(stored?.durationSeconds)
+		if (stored?.sourceUrl === requestedUrl && storedDuration !== null) {
+			content.processingSourceUrl = stored.sourceUrl
+			content.processingSourceKind = stored.sourceKind
+			content.durationSeconds = storedDuration
+			return {
+				requestedUrl,
+				resolvedUrl: requestedUrl,
+				sourceKind: stored.sourceKind ?? content.processingSourceKind ?? 'http_url',
+				durationSeconds: storedDuration,
+				ready: true,
+				blockers: [],
+			}
+		}
+
+		let resolution: MediaSourceResolution
+		try {
+			resolution = await provider.resolve(
+				{
+					kind: type,
+					sourceUrl: requestedUrl,
+					knownDurationSeconds:
+						stored?.sourceUrl === requestedUrl
+							? positiveIntegerDuration(content.durationSeconds)
+							: null,
+				},
+				ctx,
+			)
+		} catch (error) {
+			if (asMediaSourceProviderFailure(error)) throw error
+			content.processingSourceUrl = requestedUrl
+			content.durationSeconds = null
+			return {
+				requestedUrl,
+				resolvedUrl: requestedUrl,
+				sourceKind: content.processingSourceKind ?? 'http_url',
+				durationSeconds: null,
+				ready: false,
+				blockers: ['duration_probe_failed'],
+			}
+		}
+
+		if (resolution.requestedUrl !== requestedUrl) {
+			content.processingSourceUrl = requestedUrl
+			content.durationSeconds = null
+			return {
+				requestedUrl,
+				resolvedUrl: requestedUrl,
+				sourceKind: content.processingSourceKind ?? 'http_url',
+				durationSeconds: null,
+				ready: false,
+				blockers: ['stale_source_measurement'],
+			}
+		}
+
+		let resolvedUrl: string
+		try {
+			resolvedUrl = new URL(resolution.resolvedUrl).toString()
+		} catch {
+			content.processingSourceUrl = requestedUrl
+			content.durationSeconds = null
+			return {
+				requestedUrl,
+				resolvedUrl: requestedUrl,
+				sourceKind: content.processingSourceKind ?? 'http_url',
+				durationSeconds: null,
+				ready: false,
+				blockers: ['source_resolution_invalid'],
+			}
+		}
+
+		const durationSeconds = positiveIntegerDuration(resolution.durationSeconds)
+		const blockers =
+			durationSeconds === null
+				? resolution.blockers.filter((blocker) => blocker.trim().length > 0)
+				: []
+		content.processingSourceUrl = resolvedUrl
+		content.processingSourceKind = resolution.sourceKind
+		content.durationSeconds = durationSeconds
+		return {
+			requestedUrl,
+			resolvedUrl,
+			sourceKind: resolution.sourceKind,
+			durationSeconds,
+			ready: durationSeconds !== null,
+			blockers:
+				durationSeconds === null && blockers.length === 0 ? ['duration_probe_failed'] : blockers,
+		}
+	}
+
+	function mediaSourceReadinessFromStored(
+		stored: StoredMediaSource | null,
+	): MediaSourceReadiness | null {
+		if (!stored) return null
+		const sourceUrl = stored.sourceUrl?.trim()
+		if (!sourceUrl) return null
+		const durationSeconds = positiveIntegerDuration(stored.durationSeconds)
+		return {
+			requestedUrl: sourceUrl,
+			resolvedUrl: sourceUrl,
+			sourceKind: stored.sourceKind ?? 'http_url',
+			durationSeconds,
+			ready: durationSeconds !== null,
+			blockers: durationSeconds === null ? ['duration_unavailable'] : [],
+		}
+	}
+
 	async function maybeDispatchPodcastToFoundry(
 		ctx: RouteContext,
 		contentId: string,
@@ -1116,6 +1326,22 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				return json({ error: 'Invalid request', details: parsed.error.flatten() }, 400)
 			}
 
+			let mediaSourceReadiness: MediaSourceReadiness | null = null
+			if (parsed.data.type === 'video' || parsed.data.type === 'podcast') {
+				try {
+					mediaSourceReadiness = await resolveMediaSourceForSave(
+						ctx,
+						parsed.data.type,
+						parsed.data.content,
+						null,
+					)
+				} catch (error) {
+					const providerError = mediaSourceProviderErrorResponse(error)
+					if (providerError) return providerError
+					throw error
+				}
+			}
+
 			let created: Awaited<ReturnType<typeof createContent>>
 			try {
 				created = await createContent(ctx.db, parsed.data)
@@ -1144,6 +1370,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 					podcastFoundryQueued: Boolean(podcastAttempt.result),
 					podcastFoundryCorrelationId: podcastAttempt.result?.correlationId ?? null,
 					podcastFoundryReason: podcastAttempt.reason,
+					...(mediaSourceReadiness ? { mediaSourceReadiness } : {}),
 				},
 				201,
 			)
@@ -1207,6 +1434,10 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 						...(thumbnailImageId ? { thumbnail_image_url: thumbnailImageUrl } : {}),
 					}
 				: content
+			const mediaSourceReadiness =
+				item.type === 'video' || item.type === 'podcast'
+					? mediaSourceReadinessFromStored(await loadStoredMediaSource(ctx.db, id, item.type))
+					: null
 
 			const aiLockedFields: string[] = (() => {
 				try {
@@ -1222,6 +1453,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				tags,
 				relations,
 				aiLockedFields,
+				...(mediaSourceReadiness ? { mediaSourceReadiness } : {}),
 			})
 		},
 
@@ -1254,6 +1486,8 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			// never told is how a malformed Sources section reached a published page
 			// (packages#329).
 			let bodyWarnings: ValidationError[] = []
+			let mediaSourceReadiness: MediaSourceReadiness | null = null
+			let expectedMediaSource: StoredMediaSource | undefined
 
 			if (parsed.data.content !== undefined) {
 				const contentSchema = getContentUpdateSchema(existing.type)
@@ -1265,6 +1499,28 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				}
 				parsed.data.content = contentParsed.data
 
+				if (existing.type === 'video' || existing.type === 'podcast') {
+					try {
+						const storedMediaSource = await loadStoredMediaSource(ctx.db, id, existing.type)
+						if (
+							resolved.providers.mediaSource &&
+							Object.hasOwn(contentParsed.data, 'processingSourceUrl')
+						) {
+							expectedMediaSource = storedMediaSource ?? undefined
+						}
+						mediaSourceReadiness = await resolveMediaSourceForSave(
+							ctx,
+							existing.type,
+							contentParsed.data as MutableMediaSourceContent,
+							storedMediaSource,
+						)
+					} catch (error) {
+						const providerError = mediaSourceProviderErrorResponse(error)
+						if (providerError) return providerError
+						throw error
+					}
+				}
+
 				// Pre-publish content lint: refuse to overwrite an article body with
 				// content that contains known formatting artifacts. Draft saves run
 				// the same check but allow empty bodies (the auto-save path needs to
@@ -1327,6 +1583,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			try {
 				updated = await updateContentItem(ctx.db, id, parsed.data, {
 					requiredStatus: config.updateStatusConstraint,
+					...(expectedMediaSource ? { expectedMediaSource } : {}),
 				})
 			} catch (error) {
 				if (error instanceof TagInputError) return tagInputErrorResponse(error)
@@ -1338,6 +1595,9 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			if (updated.statusConflict) {
 				return json({ error: 'update_status_conflict', state: updated.statusConflict }, 409)
 			}
+			if (updated.mediaSourceConflict) {
+				return json({ error: 'media_source_conflict' }, 409)
+			}
 			const podcastAttempt: PodcastFoundryAttempt =
 				existing.type === 'podcast'
 					? await dispatchPodcastAfterSave(ctx, id)
@@ -1356,6 +1616,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				podcastFoundryQueued: Boolean(podcastAttempt.result),
 				podcastFoundryCorrelationId: podcastAttempt.result?.correlationId ?? null,
 				podcastFoundryReason: podcastAttempt.reason,
+				...(mediaSourceReadiness ? { mediaSourceReadiness } : {}),
 				// Present and empty when the body linted clean, so a client can
 				// distinguish "no warnings" from "this build does not report them".
 				bodyWarnings,

package/src/routes/index.ts

@@ -71,6 +71,7 @@ export {
 	createContentRoutes,
 	type DispatchFaqHook,
 	type DispatchTakeawaysHook,
+	type MediaSourceReadiness,
 	type PublishReadinessHook,
 } from './content.js'
 // Content Insights surface — read/dismiss/undismiss + the HMAC insights-ingest route.

package/src/ui/editor/ContentForm.tsx

@@ -29,12 +29,14 @@ import { AiAssistPanel } from './AiAssistPanel.js'
 import { AUTOSAVE_DEBOUNCE_MS, shouldSnapshot } from './autosave.js'
 import { type BodyWarning, describeBodyWarnings, sortBodyWarnings } from './body-warnings.js'
 import {
+	applyMediaSourceReadiness,
 	buildContentCreatePayload,
 	buildContentUpdatePayload,
 	type ContentDraftFields,
 	canCreateContentDraft,
 	foundryDispatchSourceForDraft,
 	initialContentMetadata,
+	type MediaSourceReadinessPayload,
 	normalizeMediaDurationSeconds,
 	slugifyTitle,
 	updateContentMetadataSelection,
@@ -431,16 +433,29 @@ export function ContentForm({
 						}))
 						return
 					}
-					const created = (await res.json()) as { id: string }
+					const created = (await res.json()) as {
+						id: string
+						mediaSourceReadiness?: MediaSourceReadinessPayload
+					}
+					const latest = latestForm.current
+					const resolvedDraft = created.mediaSourceReadiness
+						? applyMediaSourceReadiness(contentType, latest, created.mediaSourceReadiness)
+						: latest
+					const sourceResultIsCurrent = !created.mediaSourceReadiness || resolvedDraft !== latest
+					const dispatchDraft = created.mediaSourceReadiness ? resolvedDraft : draft
 					setForm((prev) => ({
-						...prev,
+						...(created.mediaSourceReadiness
+							? applyMediaSourceReadiness(contentType, prev, created.mediaSourceReadiness)
+							: prev),
 						saving: false,
 						savedId: created.id,
 						lastSavedAt: Date.now(),
 						saveError: null,
 					}))
 					onDocCreated?.(created.id)
-					void queueFoundryProcessing(created.id, draft)
+					if (sourceResultIsCurrent) {
+						void queueFoundryProcessing(created.id, dispatchDraft)
+					}
 				} catch (err) {
 					setForm((prev) => ({
 						...prev,
@@ -474,9 +489,18 @@ export function ContentForm({
 					// left them invisible.
 					const saved = (await res.json().catch(() => ({}))) as {
 						bodyWarnings?: BodyWarning[]
+						mediaSourceReadiness?: MediaSourceReadinessPayload
 					}
+					const latest = latestForm.current
+					const resolvedDraft = saved.mediaSourceReadiness
+						? applyMediaSourceReadiness(contentType, latest, saved.mediaSourceReadiness)
+						: latest
+					const sourceResultIsCurrent = !saved.mediaSourceReadiness || resolvedDraft !== latest
+					const dispatchDraft = saved.mediaSourceReadiness ? resolvedDraft : draft
 					setForm((prev) => ({
-						...prev,
+						...(saved.mediaSourceReadiness
+							? applyMediaSourceReadiness(contentType, prev, saved.mediaSourceReadiness)
+							: prev),
 						bodyWarnings: Array.isArray(saved.bodyWarnings) ? saved.bodyWarnings : [],
 					}))
 
@@ -501,7 +525,9 @@ export function ContentForm({
 						lastSavedAt: now,
 						saveError: null,
 					}))
-					void queueFoundryProcessing(id, draft)
+					if (sourceResultIsCurrent) {
+						void queueFoundryProcessing(id, dispatchDraft)
+					}
 				} catch (err) {
 					setForm((prev) => ({
 						...prev,
@@ -656,6 +682,7 @@ export function ContentForm({
 			...latestForm.current,
 			podcastSourceUrl: value,
 			podcastSourceKind: value.trim() ? 'https' : null,
+			durationSeconds: null,
 		}
 		setForm(next)
 		publishDraft(next)