@growth-labs/cms 0.8.18 → 0.8.20

package/src/routes/content-insights.ts

@@ -1,7 +1,9 @@
 import { z } from 'zod'
 import {
 	dismissInsight,
+	InsightPublicationError,
 	isMissingInsightDismissalSchema,
+	isMissingInsightPublicationSchema,
 	isMissingInsightsTable,
 	listInsightBoard,
 	replaceInsightsBoard,
@@ -203,9 +205,12 @@ export function createContentInsightsRoutes(
 					ok: true,
 					outcome: result.outcome,
 					landedRunAttempt: result.landedRunAttempt,
+					publication: result.publication,
 				})
 			} catch (error) {
-				if (isMissingInsightsTable(error)) return json({ error: 'schema_not_ready' }, 409)
+				if (isMissingInsightPublicationSchema(error))
+					return json({ error: 'schema_not_ready' }, 409)
+				if (error instanceof InsightPublicationError) return json({ error: error.code }, 409)
 				throw error
 			}
 		},

package/src/routes/content.ts

@@ -66,6 +66,11 @@ import { invalidateMediaCaptureStatements, softDeleteContent } from '../engine/s
 import { normalizeSourceSections } from '../engine/source-sections.js'
 import { TagInputError } from '../engine/taxonomy.js'
 import type { ValidationError } from '../engine/validator/index.js'
+import {
+	isValidTimeZone,
+	PUBLISH_TIMEZONE_FALLBACK,
+	parseLocalDateTimeInZoneToUnixSeconds,
+} from '../lib/publish-timezone.js'
 import type { MediaSourceResolution } from '../providers/types.js'
 import { parseLayoutEnvelope } from '../schema/layout.js'
 import { parsePortableTextEnvelope } from '../schema/portable-text.js'
@@ -242,9 +247,6 @@ export interface ContentRouteConfig extends CmsRouteConfig {
 	activeWorkspaceId?: string
 }
 
-const PUBLISH_TIMEZONE_FALLBACK = 'Europe/Paris'
-const LOCAL_DATE_TIME_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/
-
 type ContentType = 'article' | 'video' | 'podcast' | 'newsletter' | 'page'
 
 /**
@@ -677,119 +679,6 @@ const ContributorsReplaceSchema = z.object({
 
 // --- timezone-aware local-datetime parsing (ported verbatim) --------------
 
-type LocalDateTimeParts = { year: number; month: number; day: number; hour: number; minute: number }
-
-function parseLocalDateTime(value: string): LocalDateTimeParts | null {
-	const match = LOCAL_DATE_TIME_RE.exec(value)
-	if (!match) return null
-	const [, y, m, d, h, min] = match
-	const parts: LocalDateTimeParts = {
-		year: Number.parseInt(y, 10),
-		month: Number.parseInt(m, 10),
-		day: Number.parseInt(d, 10),
-		hour: Number.parseInt(h, 10),
-		minute: Number.parseInt(min, 10),
-	}
-	if (
-		!Number.isInteger(parts.year) ||
-		parts.month < 1 ||
-		parts.month > 12 ||
-		parts.day < 1 ||
-		parts.day > 31 ||
-		parts.hour < 0 ||
-		parts.hour > 23 ||
-		parts.minute < 0 ||
-		parts.minute > 59
-	) {
-		return null
-	}
-	const dateCheck = new Date(Date.UTC(parts.year, parts.month - 1, parts.day))
-	if (
-		dateCheck.getUTCFullYear() !== parts.year ||
-		dateCheck.getUTCMonth() + 1 !== parts.month ||
-		dateCheck.getUTCDate() !== parts.day
-	) {
-		return null
-	}
-	return parts
-}
-
-function getZonedParts(instantMs: number, timeZone: string): LocalDateTimeParts | null {
-	const formatter = new Intl.DateTimeFormat('en-US', {
-		timeZone,
-		hour12: false,
-		year: 'numeric',
-		month: '2-digit',
-		day: '2-digit',
-		hour: '2-digit',
-		minute: '2-digit',
-		second: '2-digit',
-	})
-	const values = { year: '', month: '', day: '', hour: '', minute: '', second: '' }
-	for (const part of formatter.formatToParts(new Date(instantMs))) {
-		if (part.type in values) values[part.type as keyof typeof values] = part.value
-	}
-	const year = Number.parseInt(values.year, 10)
-	const month = Number.parseInt(values.month, 10)
-	const day = Number.parseInt(values.day, 10)
-	const hour = Number.parseInt(values.hour, 10)
-	const minute = Number.parseInt(values.minute, 10)
-	if (![year, month, day, hour, minute].every(Number.isFinite)) return null
-	return { year, month, day, hour, minute }
-}
-
-function isValidTimeZone(timeZone: string): boolean {
-	try {
-		new Intl.DateTimeFormat('en-US', { timeZone }).format(new Date())
-		return true
-	} catch {
-		return false
-	}
-}
-
-function getTimeZoneOffsetMs(instantMs: number, timeZone: string): number | null {
-	const zoned = getZonedParts(instantMs, timeZone)
-	if (!zoned) return null
-	const asUtc = Date.UTC(zoned.year, zoned.month - 1, zoned.day, zoned.hour, zoned.minute, 0)
-	return asUtc - instantMs
-}
-
-function parseLocalDateTimeInZoneToUnixSeconds(value: string, timeZone: string): number | null {
-	const target = parseLocalDateTime(value)
-	if (!target) return null
-	const targetUtcMs = Date.UTC(
-		target.year,
-		target.month - 1,
-		target.day,
-		target.hour,
-		target.minute,
-		0,
-	)
-	let candidateMs = targetUtcMs
-	for (let i = 0; i < 5; i += 1) {
-		const offsetMs = getTimeZoneOffsetMs(candidateMs, timeZone)
-		if (offsetMs === null) return null
-		const next = targetUtcMs - offsetMs
-		if (Math.abs(next - candidateMs) < 1000) {
-			candidateMs = next
-			break
-		}
-		candidateMs = next
-	}
-	const resolved = getZonedParts(candidateMs, timeZone)
-	if (
-		!resolved ||
-		resolved.year !== target.year ||
-		resolved.month !== target.month ||
-		resolved.day !== target.day ||
-		resolved.hour !== target.hour ||
-		resolved.minute !== target.minute
-	) {
-		return null
-	}
-	return Math.floor(candidateMs / 1000)
-}
-
 // --- read-side payload helpers (ported verbatim) --------------------------
 
 async function getContentPayload(ctx: RouteContext, type: string, id: string) {

package/src/schema/migrations.ts

@@ -914,6 +914,13 @@ ALTER TABLE podcast_content ADD COLUMN processing_state TEXT CHECK (processing_s
 		id: '0031_podcast_processing_error',
 		sql: `ALTER TABLE podcast_content ADD COLUMN processing_error TEXT;`,
 	},
+	{
+		id: '0032_content_insight_publication_identity',
+		sql: `
+ALTER TABLE content_insight_runs ADD COLUMN publication_run_id TEXT;
+ALTER TABLE content_insight_runs ADD COLUMN payload_sha256 TEXT;
+	`,
+	},
 ]
 
 /**

package/src/schema/types.ts

@@ -677,7 +677,7 @@ export interface ContentInsightRunRow {
 	site_id: string
 	run_date: string
 	status: InsightRunStatus
-	/** Dedupe key (mirrors foundry_callback_events.event_id). */
+	/** Immutable event identity while this publication remains current. */
 	event_id: string
 	/** Monotonic; the stale-replay guard rejects equal-or-lower. */
 	run_attempt: number
@@ -685,6 +685,9 @@ export interface ContentInsightRunRow {
 	generated_at: number
 	/** Content hash of the board for change detection. */
 	content_hash: string
+	/** Sender run identity and receiver-computed RFC 8785 payload digest; null on legacy rows. */
+	publication_run_id: string | null
+	payload_sha256: string | null
 	demand_count: number
 	opportunity_count: number
 	started_at: number | null

package/src/ui/inspector/PublishTab.tsx

@@ -10,7 +10,8 @@
 // Compile-gated (tsc, jsx: react-jsx). No vitest — pure shapers are in
 // inspector-data.ts and tested there.
 
-import { useCallback, useEffect, useState } from 'react'
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { formatInstantInZone, PUBLISH_TIMEZONE_FALLBACK } from '../../lib/publish-timezone.js'
 import type { ContentStatus } from '../../schema/types.js'
 import { apiErrorMessage } from '../api-error.js'
 import { Icon } from '../icons.js'
@@ -40,6 +41,12 @@ export interface PublishTabProps {
 	authorId: string | null
 	/** Current scheduled publish time (ISO string, null if not scheduled). */
 	publishAt: string | null
+	/**
+	 * Timezone the editor schedules in. The same zone is used to DISPLAY the
+	 * stored instant and to SAVE what is typed, so a resave of untouched fields
+	 * is a true no-op. Defaults to the publication timezone.
+	 */
+	publishTimezone?: string
 	/** Called after a status/field change so the parent can refresh. */
 	onChanged?: () => void
 }
@@ -85,6 +92,7 @@ export function PublishTab({
 	visibility,
 	authorId,
 	publishAt,
+	publishTimezone = PUBLISH_TIMEZONE_FALLBACK,
 	onChanged,
 }: PublishTabProps): React.ReactElement {
 	const [saving, setSaving] = useState(false)
@@ -92,16 +100,20 @@ export function PublishTab({
 	const [actionError, setActionError] = useState<string | null>(null)
 
 	// Local schedule date/time inputs.
-	const [schedDate, setSchedDate] = useState(() => {
-		if (!publishAt) return ''
-		// publishAt is an ISO string; extract the date part.
-		return publishAt.slice(0, 10)
-	})
-	const [schedTime, setSchedTime] = useState(() => {
-		if (!publishAt) return '12:00'
-		// Extract HH:MM from ISO.
-		return publishAt.slice(11, 16) || '12:00'
-	})
+	// The editor thinks in publication-local wall clock, so that is what these
+	// inputs show. Falling back to the raw UTC slice keeps an unusable zone
+	// readable rather than blank.
+	const scheduled = useMemo(() => {
+		if (!publishAt) return null
+		const ms = Date.parse(publishAt)
+		if (!Number.isFinite(ms)) return null
+		return formatInstantInZone(ms, publishTimezone)
+	}, [publishAt, publishTimezone])
+
+	const [schedDate, setSchedDate] = useState(() => scheduled?.date ?? publishAt?.slice(0, 10) ?? '')
+	const [schedTime, setSchedTime] = useState(
+		() => scheduled?.time ?? publishAt?.slice(11, 16) ?? '12:00',
+	)
 
 	// Author list (fetched once on mount).
 	const [authors, setAuthors] = useState<AuthorOption[]>([])
@@ -172,18 +184,14 @@ export function PublishTab({
 		setSaving(true)
 		setActionError(null)
 		try {
-			// schedDate/schedTime are sliced directly from the UTC ISO publishAt
-			// (no zone conversion happens anywhere in this component -- see their
-			// initializers above), so the digits shown here already ARE UTC. Tag
-			// them 'UTC' on save, not a hardcoded zone: sending literal UTC digits
-			// under a non-UTC zone label (this used 'Europe/Paris' unconditionally
-			// until the Falklands P0, 2026-09-08) made the server reinterpret them
-			// in that zone's offset, silently shifting publish_at by that zone's
-			// current UTC offset on every resave -- including an incidental
-			// resave that never touched these fields. 'UTC' makes display and
-			// save agree, so a resave of untouched fields is a true no-op.
+			// These digits are publication-local wall clock (see the initializers),
+			// so they are saved under that SAME zone. Display and save must agree:
+			// sending digits under a zone they were not rendered in made the server
+			// reinterpret them and shift publish_at by that zone's offset on every
+			// resave, including an incidental one that never touched these fields
+			// (the 2026-09-08 P0). Agreement is what keeps a resave a no-op.
 			const localDateTime = `${schedDate}T${schedTime}`
-			const body = buildScheduleBody(localDateTime, 'UTC')
+			const body = buildScheduleBody(localDateTime, publishTimezone)
 			await runAction(docId, 'schedule', body as unknown as Record<string, unknown>)
 			setSelectedStatus('scheduled')
 			onChanged?.()
@@ -192,7 +200,7 @@ export function PublishTab({
 		} finally {
 			setSaving(false)
 		}
-	}, [docId, schedDate, schedTime, saving, onChanged])
+	}, [docId, schedDate, schedTime, saving, onChanged, publishTimezone])
 
 	const handleVisibilityChange = useCallback(
 		async (newVis: 'free' | 'premium') => {
@@ -317,7 +325,7 @@ export function PublishTab({
 				{/* Scheduled date + time inputs */}
 				{showScheduleControls && (
 					<div style={schedGrid} className="fade-only">
-						<Field label="Date (UTC)">
+						<Field label={`Date (${publishTimezone})`}>
 							<input
 								className="input"
 								type="date"
@@ -325,7 +333,7 @@ export function PublishTab({
 								onChange={(e) => setSchedDate(e.target.value)}
 							/>
 						</Field>
-						<Field label="Time (UTC)">
+						<Field label={`Time (${publishTimezone})`}>
 							<input
 								className="input"
 								type="time"