@growth-labs/cms 0.8.32 → 0.8.35

package/src/routes/content-insights.ts

@@ -11,7 +11,11 @@ import {
 	undismissInsight,
 } from '../engine/content-insights.js'
 import { verifyHmac } from '../engine/foundry-dispatch.js'
-import { listPublishedContent, PublishedContentReadError } from '../engine/published-content.js'
+import {
+	getPublishedContentBySlug,
+	listPublishedContent,
+	PublishedContentReadError,
+} from '../engine/published-content.js'
 import { InsightsIngestPayloadSchema } from '../schema/insights-ingest.js'
 import { InsightDismissalReasonCodeSchema } from '../schema/types.js'
 import type { CmsRouteConfig } from './config.js'
@@ -56,6 +60,22 @@ const PublishedArticleStateSchema = z
 	})
 	.strict()
 
+const PublishedArticleSourceSchema = z
+	.object({
+		ok: z.literal(true),
+		schema: z.literal('cms.published-article-source.v1'),
+		site: z.string().min(1),
+		observed_at: z.string().datetime(),
+		article: PublishedArticleStateSchema.extend({
+			hero_image_url: z.string().url().nullable(),
+			body_markdown: z.string().min(1).max(1_000_000),
+			description: z.string().nullable(),
+			byline: z.string().nullable(),
+			tags: z.array(z.string()),
+		}).strict(),
+	})
+	.strict()
+
 const PublishedInputsResponseSchema = z
 	.object({
 		ok: z.literal(true),
@@ -76,6 +96,64 @@ async function publishedInputs(ctx: RouteContext, url: URL, siteId: string): Pro
 		return json({ error: 'invalid_published_mode' }, 400)
 	if (siteId === 'default') return json({ error: 'publication_identity_not_configured' }, 503)
 	if (url.searchParams.get('site') !== siteId) return json({ error: 'publication_mismatch' }, 403)
+	const articleSlug = url.searchParams.get('article')
+	if (articleSlug !== null) {
+		const slug = z
+			.string()
+			.min(1)
+			.max(512)
+			.regex(/^[a-z0-9][a-z0-9-]*$/)
+			.safeParse(articleSlug)
+		if (!slug.success || url.searchParams.has('cursor') || url.searchParams.has('limit'))
+			return json({ error: 'invalid_article_source_request' }, 400)
+		try {
+			const content = await getPublishedContentBySlug(ctx.db, slug.data)
+			if (!content || content.type !== 'article')
+				return json({ error: 'published_article_missing' }, 404)
+			const item = content.payload.item
+			let heroImageUrl: string | null = null
+			if (item.hero_image_id) {
+				const asset = await ctx.db
+					.prepare(
+						"SELECT public_url FROM media_assets WHERE id = ? AND asset_type = 'image' AND status = 'ready'",
+					)
+					.bind(item.hero_image_id)
+					.first<{ public_url: string | null }>()
+				const publicUrl = z.string().url().safeParse(asset?.public_url)
+				if (publicUrl.success) heroImageUrl = publicUrl.data
+			}
+			const result = PublishedArticleSourceSchema.safeParse({
+				ok: true,
+				schema: 'cms.published-article-source.v1',
+				site: siteId,
+				observed_at: new Date().toISOString(),
+				article: {
+					content_id: content.contentId,
+					revision_id: content.revisionId,
+					slug: content.slug,
+					title: item.title,
+					canonical_url: item.canonical_url ?? null,
+					published_at: content.publishedAt,
+					source_id: item.source_id ?? null,
+					youtube_video_id: content.metadata.videoId ?? null,
+					hero_image_id: item.hero_image_id ?? null,
+					hero_image_url: heroImageUrl,
+					hero_image_caption: item.hero_image_caption ?? null,
+					body_markdown: content.payload.content?.body_markdown,
+					description: item.description ?? null,
+					byline: item.byline ?? null,
+					tags: content.payload.tags,
+				},
+			})
+			if (!result.success) return json({ error: 'published_article_source_invalid' }, 409)
+			if (new TextEncoder().encode(JSON.stringify(result.data)).byteLength > 4 << 20)
+				return json({ error: 'published_article_source_too_large' }, 409)
+			return json(result.data)
+		} catch (error) {
+			if (error instanceof PublishedContentReadError) return json({ error: error.code }, 409)
+			throw error
+		}
+	}
 	const limit = z.coerce
 		.number()
 		.int()

package/src/routes/content.ts

@@ -235,6 +235,8 @@ export interface ContentRouteConfig extends CmsRouteConfig {
 	videoSourceProductionEnabled?: boolean
 	/** Internal machine-route constraint: atomically update only in this status. */
 	updateStatusConstraint?: ContentStatus
+	/** Internal machine-route pin; joins the existing status-constrained atomic batch. */
+	updateCanonicalVersionConstraint?: number
 	/**
 	 * Internal (Foundry machine route, M3-18): replaces ONLY the publish action's
 	 * commit step (publishContent + createRevision) with the caller's — publishOne
@@ -1807,6 +1809,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			try {
 				updated = await updateContentItem(ctx.db, id, parsed.data, {
 					requiredStatus: config.updateStatusConstraint,
+					expectedCanonicalVersion: config.updateCanonicalVersionConstraint,
 					...(expectedMediaSource ? { expectedMediaSource } : {}),
 				})
 			} catch (error) {
@@ -1821,6 +1824,9 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			if (updated.statusConflict) {
 				return json({ error: 'update_status_conflict', state: updated.statusConflict }, 409)
 			}
+			if (updated.canonicalVersionConflict) {
+				return json({ error: 'update_canonical_conflict' }, 409)
+			}
 			if (updated.mediaSourceConflict) {
 				return json({ error: 'media_source_conflict' }, 409)
 			}

package/src/routes/foundry-publish.ts

@@ -1,8 +1,10 @@
 import { isCanonicalHost, sha256Hex, verifyFoundryRequest } from '@growth-labs/foundry-signing'
 import { z } from 'zod'
+import { ContentMetadataSchema, mergePinnedArticleMetadata } from '../engine/content-metadata.js'
 import { type PublicationReconciler, publishOne } from '../engine/publication.js'
+import { PublicationCurrentSnapshotError } from '../engine/publication-current-guard.js'
 import { PublishContentValidationError } from '../engine/publisher.js'
-import { createRevisionWithDelta } from '../engine/revisions.js'
+import { createRevisionWithDelta, getRevision } from '../engine/revisions.js'
 import { buildContentPath, slugify } from '../engine/slug.js'
 import { type FoundryArticleV2, FoundryArticleV2Schema } from '../foundry-emit.js'
 import { type ContentRouteConfig, createContentRoutes } from './content.js'
@@ -20,6 +22,10 @@ const PutSchema = z
 	})
 	.strict()
 
+const PinnedPublishSchema = z
+	.object({ expected_request_sha256: z.string().regex(/^[a-f0-9]{64}$/) })
+	.strict()
+
 interface FoundryArticleRow {
 	external_id: string
 	content_id: string
@@ -258,6 +264,9 @@ async function mapUpdateConflict(response: Response, id: string): Promise<Respon
 	if (response.status !== 409) return response
 	try {
 		const payload = (await response.clone().json()) as { error?: unknown; state?: unknown }
+		if (payload.error === 'update_canonical_conflict') {
+			return json({ error: 'human_edit_pending', external_id: id }, 409)
+		}
 		if (payload.error === 'update_status_conflict' && typeof payload.state === 'string') {
 			return approvalConflict(id, payload.state)
 		}
@@ -465,6 +474,7 @@ async function bindAdoption(
 	config: ContentRouteConfig,
 	id: string,
 	candidate: ContentCandidate,
+	expectedVersion?: number,
 ): Promise<boolean> {
 	const sourceId = `${SOURCE_PREFIX}${id}`
 	await ctx.db.batch([
@@ -472,9 +482,17 @@ async function bindAdoption(
 			.prepare(
 				`UPDATE content_items SET source_id = ?, updated_at = unixepoch()
 				 WHERE id = ? AND deleted_at IS NULL AND type = 'article' AND source_id = ?
-				   AND NOT EXISTS (SELECT 1 FROM cms_foundry_articles WHERE content_id = ?)`,
+				   AND NOT EXISTS (SELECT 1 FROM cms_foundry_articles WHERE content_id = ?)
+				   AND (? IS NULL OR canonical_version = ?)`,
 			)
-			.bind(sourceId, candidate.id, candidate.source_id, candidate.id),
+			.bind(
+				sourceId,
+				candidate.id,
+				candidate.source_id,
+				candidate.id,
+				expectedVersion ?? null,
+				expectedVersion ?? null,
+			),
 		ctx.db
 			.prepare(
 				`INSERT INTO cms_activity_log (id, workspace_id, user_id, action, target_id, target_title, type)
@@ -491,6 +509,8 @@ async function bindAdoption(
 }
 
 function publishFailure(id: string, error: unknown): Response {
+	if (error instanceof PublicationCurrentSnapshotError)
+		return json({ error: 'human_edit_pending', external_id: id }, 409)
 	if (error instanceof PublishContentValidationError) {
 		return json({ error: 'publish_validation_failed', external_id: id, errors: error.errors }, 422)
 	}
@@ -511,6 +531,27 @@ async function canonicalVersion(ctx: RouteContext, contentId: string): Promise<n
 	return row?.canonical_version ?? null
 }
 
+/** A signed improvement names the actual immutable CMS revision it read. */
+async function sourceRevisionVersion(
+	ctx: RouteContext,
+	contentId: string,
+	revisionId: string,
+): Promise<number | null> {
+	const revision = await getRevision(ctx.db, contentId, revisionId)
+	if (!revision) return null
+	const item = revision.payload.item as Record<string, unknown> | undefined
+	const version = item?.canonical_version
+	if (
+		item?.id !== contentId ||
+		item.type !== 'article' ||
+		typeof version !== 'number' ||
+		!Number.isSafeInteger(version) ||
+		version < 1
+	)
+		return null
+	return (await canonicalVersion(ctx, contentId)) === version ? version : null
+}
+
 /**
  * Record what this v2 PUT wrote as a History revision (the autosave/restore
  * mechanism; it never moves the published pointer), created_by `foundry` and
@@ -545,29 +586,23 @@ async function recordFoundryWrite(
 	}
 }
 
-/** True while the working copy is still exactly what Foundry's last v2 PUT wrote. */
-async function lastFoundryWriteCurrent(
+/** The immutable last PUT snapshot, only while its canonical version is current. */
+async function lastFoundryWriteSnapshot(
 	ctx: RouteContext,
 	row: FoundryArticleRow,
-): Promise<boolean> {
-	const versions = await ctx.db
-		.prepare(
-			`SELECT c.canonical_version AS current_version,
-			        (SELECT json_extract(r.payload_json, '$.item.canonical_version')
-			         FROM content_revisions r
-			         WHERE r.content_id = c.id AND r.created_by = 'foundry' AND r.tag = ?
-			         ORDER BY r.created_at DESC, r.rowid DESC LIMIT 1) AS put_version
-			 FROM content_items c
-			 WHERE c.id = ? AND c.deleted_at IS NULL
-			 LIMIT 1`,
-		)
-		.bind(`${FOUNDRY_PUT_TAG}${row.request_sha256}`, row.content_id)
-		.first<{ current_version: number | null; put_version: number | null }>()
-	return (
-		versions !== null &&
-		versions.put_version !== null &&
-		versions.current_version === versions.put_version
-	)
+): Promise<Record<string, unknown> | null> {
+	const match = await ctx.db
+		.prepare(`SELECT r.id AS revision_id
+  FROM content_items c JOIN content_revisions r ON r.content_id = c.id
+  WHERE c.id = ? AND c.deleted_at IS NULL AND r.created_by = 'foundry' AND r.tag = ?
+    AND c.canonical_version IS NOT NULL
+    AND c.canonical_version = json_extract(r.payload_json, '$.item.canonical_version')
+  ORDER BY r.created_at DESC, r.rowid DESC LIMIT 1`)
+		.bind(row.content_id, `${FOUNDRY_PUT_TAG}${row.request_sha256}`)
+		.first<{ revision_id: string }>()
+	if (!match) return null
+	const revision = await getRevision(ctx.db, row.content_id, match.revision_id)
+	return revision ? { ...revision.payload } : null
 }
 
 /** The v2 receipt: the four v1 fields plus the stored request hash. */
@@ -594,6 +629,12 @@ async function putV2(
 	const body = parsed.data
 
 	const prior = await findArticle(ctx, id)
+	if (body.createOnly && prior && (prior.request_sha256 !== bodyHash || prior.status !== 'draft')) {
+		return json(
+			{ error: 'article_already_exists', external_id: id, content_id: prior.content_id },
+			409,
+		)
+	}
 	if (prior?.request_sha256 === bodyHash) {
 		console.info('[cms] foundry article request deduplicated', {
 			externalId: id,
@@ -609,8 +650,41 @@ async function putV2(
 	// Scheduled, review and archived items stay human-owned.
 	if (bound && !V2_WRITABLE.has(bound.status)) return approvalConflict(id, bound.status)
 
+	if (body.createOnly) {
+		if (body.expectedRevisionId) return json({ error: 'create_only_has_source_revision' }, 400)
+		if (body.adoptSourceId || bound)
+			return json({ error: 'article_already_exists', external_id: id }, 409)
+		const slugHolder = await findCandidate(ctx, 'slug', body.slug)
+		if (slugHolder) return slugConflict(id, body.slug, slugHolder.id)
+		const videoId = body.metadata?.videoId
+		if (typeof videoId !== 'string' || !/^[A-Za-z0-9_-]{11}$/.test(videoId))
+			return json({ error: 'create_only_requires_source_video' }, 400)
+		// Check the actual CMS working and immutable published projections, not
+		// just Foundry's own relationship ledger. A creation cannot adopt or edit.
+		const associated = await ctx.db
+			.prepare(`SELECT c.id FROM content_items c
+    LEFT JOIN content_revisions r ON r.id=c.published_revision_id AND r.content_id=c.id
+    WHERE c.type='article' AND c.deleted_at IS NULL AND (
+      CASE WHEN json_valid(c.metadata_json) THEN json_extract(c.metadata_json,'$.videoId') END = ?
+      OR CASE WHEN json_valid(json_extract(r.payload_json,'$.item.metadata_json')) THEN json_extract(json_extract(r.payload_json,'$.item.metadata_json'),'$.videoId') END = ?
+    ) LIMIT 1`)
+			.bind(videoId, videoId)
+			.first<{ id: string }>()
+		if (associated)
+			return json(
+				{ error: 'article_video_already_exists', external_id: id, content_id: associated.id },
+				409,
+			)
+	}
 	let adoption: Adoption | null = null
+	let expectedSourceVersion: number | undefined
 	if (bound) {
+		if (body.expectedRevisionId) {
+			const version = await sourceRevisionVersion(ctx, bound.id, body.expectedRevisionId)
+			if (version === null) return json({ error: 'human_edit_pending', external_id: id }, 409)
+			expectedSourceVersion = version
+		}
+
 		const holder = await findCandidate(ctx, 'slug', body.slug)
 		if (holder && holder.id !== bound.id) return slugConflict(id, body.slug, holder.id)
 	} else {
@@ -618,7 +692,12 @@ async function putV2(
 		if ('error' in resolved) return resolved.error
 		if (resolved.candidate && resolved.matchedBy) {
 			const candidate = resolved.candidate
-			if (!(await bindAdoption(ctx, config, id, candidate))) {
+			if (body.expectedRevisionId) {
+				const version = await sourceRevisionVersion(ctx, candidate.id, body.expectedRevisionId)
+				if (version === null) return json({ error: 'human_edit_pending', external_id: id }, 409)
+				expectedSourceVersion = version
+			}
+			if (!(await bindAdoption(ctx, config, id, candidate, expectedSourceVersion))) {
 				return json(
 					{
 						error: 'adoption_conflict',
@@ -655,11 +734,34 @@ async function putV2(
 		}
 	}
 
-	// The canonical version Foundry's write must produce is one over this.
-	const priorVersion = bound ? await canonicalVersion(ctx, bound.id) : null
+	// Preserve a newer human working copy before PUT, not merely at publication.
+	// The native update pins this same canonical version in its atomic batch.
+	if (body.expectedRevisionId && !bound)
+		return json({ error: 'source_revision_missing', external_id: id }, 409)
+	const priorVersion =
+		expectedSourceVersion ?? (bound ? await canonicalVersion(ctx, bound.id) : null)
 	const heroImageId = body.hero_image_url
 		? await heroAssetId(body.hero_image_url)
 		: (body.hero_image_key ?? undefined)
+	// A pinned improvement augments its exact source metadata. Existing dates,
+	// image provenance and other recorded fields survive preparation updates.
+	let metadata = body.metadata
+	if (body.expectedRevisionId && body.metadata !== undefined && bound) {
+		const source = await getRevision(ctx.db, bound.id, body.expectedRevisionId)
+		let original: unknown
+		try {
+			original = JSON.parse(String(source?.payload.item?.metadata_json ?? '{}'))
+		} catch {
+			return json({ error: 'source_metadata_invalid', external_id: id }, 409)
+		}
+		const recorded = ContentMetadataSchema.safeParse(original)
+		if (!recorded.success) return json({ error: 'source_metadata_invalid', external_id: id }, 409)
+		const merged = ContentMetadataSchema.safeParse(
+			mergePinnedArticleMetadata(recorded.data, body.metadata),
+		)
+		if (!merged.success) return json({ error: 'source_metadata_invalid', external_id: id }, 409)
+		metadata = merged.data
+	}
 	const nativeBody = {
 		title: body.title,
 		slug: body.slug,
@@ -671,7 +773,7 @@ async function putV2(
 		...(body.desk !== undefined ? { primaryCategory: body.desk } : {}),
 		...(body.tags !== undefined ? { tags: body.tags } : {}),
 		...(body.visibility !== undefined ? { visibility: body.visibility } : {}),
-		...(body.metadata !== undefined ? { metadata: body.metadata } : {}),
+		...(metadata !== undefined ? { metadata } : {}),
 		content: { bodyMarkdown: body.body_html, bodyHtml: body.body_html },
 	}
 
@@ -680,7 +782,12 @@ async function putV2(
 		// Each write is a CAS on the status it was read in: a draft stays a
 		// draft write, and a published item is edited in place only while it is
 		// still published (its live revision changes only on POST /publish).
-		const writer = bound.status === 'published' ? handlers.published : handlers.draft
+		if (priorVersion === null) return json({ error: 'human_edit_pending', external_id: id }, 409)
+		const writer = createContentRoutes({
+			...machineConfig(config),
+			updateStatusConstraint: bound.status,
+			updateCanonicalVersionConstraint: priorVersion,
+		})
 		nativeResponse = await mapUpdateConflict(
 			await writer.update(nativeContext(ctx, 'PATCH', nativeBody, { id: bound.id })),
 			id,
@@ -697,6 +804,8 @@ async function putV2(
 			)
 		} catch (error) {
 			const raced = await findContentBySource(ctx, id)
+			if (body.createOnly && raced)
+				return json({ error: 'article_already_exists', external_id: id, content_id: raced.id }, 409)
 			if (raced?.type !== 'article') throw error
 			nativeResponse = await mapUpdateConflict(
 				await handlers.draft.update(nativeContext(ctx, 'PATCH', nativeBody, { id: raced.id })),
@@ -777,7 +886,8 @@ async function publishV2(
 	// Publish, schedule and resync alike act on the working copy only while it is
 	// still exactly what Foundry's last v2 PUT wrote: a human edit since then (to
 	// a draft or a published item) is never machine-published or machine-scheduled.
-	if (!(await lastFoundryWriteCurrent(ctx, row))) {
+	const expectedSnapshot = await lastFoundryWriteSnapshot(ctx, row)
+	if (!expectedSnapshot) {
 		return json({ error: 'human_edit_pending', external_id: id }, 409)
 	}
 
@@ -833,6 +943,8 @@ async function publishV2(
 				now: input.now,
 				publishedAt,
 				createdBy: 'foundry',
+				expectedFoundryArticleSnapshot: expectedSnapshot,
+				expectedReceiptIdentity: row.request_sha256,
 				surfaces,
 				...(config.foundryPublish?.requiredSurfaceNames
 					? { requiredSurfaceNames: config.foundryPublish.requiredSurfaceNames }
@@ -1060,14 +1172,32 @@ export function createFoundryPublishRoutes(
 			const rawBody = await ctx.request.text()
 			const auth = await verify(ctx, rawBody)
 			if ('error' in auth) return auth.error
-			// POST /publish takes no body: anything sent is refused, never ignored.
-			if (rawBody.length > 0 || !/^0?$/.test(ctx.request.headers.get('Content-Length') ?? '')) {
-				return json({ error: 'invalid_request', detail: 'publish takes no request body' }, 400)
+			// Legacy callers publish the current write. Strategy execution pins the
+			// exact PUT bytes in the signed body; an unrelated replacement is refused.
+			let expectedHash: string | undefined
+			if (rawBody.length > 0) {
+				let value: unknown
+				try {
+					value = JSON.parse(rawBody)
+				} catch {
+					return json({ error: 'invalid_request' }, 400)
+				}
+				const parsed = PinnedPublishSchema.safeParse(value)
+				if (!parsed.success) return json({ error: 'invalid_request' }, 400)
+				expectedHash = parsed.data.expected_request_sha256
+			} else if (!/^0?$/.test(ctx.request.headers.get('Content-Length') ?? '')) {
+				return json(
+					{ error: 'invalid_request', detail: 'empty publish request declares a body' },
+					400,
+				)
 			}
 			const row = await findArticle(ctx, id)
 			if (!row) return json({ error: 'not_found' }, 404)
 			// Without the publication's opt-in the machine route stays draft-only.
 			if (!autoPublishEnabled(config)) return approvalConflict(id, row.status)
+			if (expectedHash !== undefined && expectedHash !== row.request_sha256) {
+				return json({ error: 'article_revision_changed', external_id: id }, 409)
+			}
 			return publishV2(ctx, config, content, id, row)
 		},
 	}

package/src/ui/editor/ContentForm.tsx

@@ -33,7 +33,7 @@ import {
 	applyMediaSourceReadiness,
 	buildContentCreatePayload,
 	buildContentUpdatePayload,
-	canCreateContentDraft,
+	contentDraftSaveError,
 	foundryDispatchSourceForDraft,
 	initialContentMetadata,
 	type MediaSourceReadinessPayload,
@@ -406,19 +406,14 @@ export function ContentForm({
 			const draft = currentForm
 
 			if (id === null) {
-				if (
-					!canCreateContentDraft(contentType, draft, {
-						requirePrimaryTopic: primaryTopicEnabled,
-					})
-				) {
-					const mediaSource = foundryDispatchSourceForDraft(contentType, draft)
-					const missingMediaDuration =
-						mediaSource && normalizeMediaDurationSeconds(draft.durationSeconds) === null
+				const saveError = contentDraftSaveError(contentType, draft, {
+					requirePrimaryTopic: primaryTopicEnabled,
+					primaryTopicLabel: primaryTopic?.label,
+				})
+				if (saveError) {
 					setForm((prev) => ({
 						...prev,
-						saveError: missingMediaDuration
-							? 'Enter the authoritative media duration in whole seconds before saving.'
-							: 'Add the required title and content before saving.',
+						saveError,
 					}))
 					return
 				}
@@ -543,7 +538,7 @@ export function ContentForm({
 				}
 			}
 		},
-		[contentType, onDocCreated, primaryTopicEnabled, queueFoundryProcessing],
+		[contentType, onDocCreated, primaryTopicEnabled, primaryTopic?.label, queueFoundryProcessing],
 	)
 
 	useEffect(() => {

package/src/ui/editor/content-payload.ts

@@ -156,6 +156,23 @@ export function foundryDispatchSourceForDraft(
 	return null
 }
 
+/** Explain the same prerequisites that gate the first save, using the host's field label. */
+export function contentDraftSaveError(
+	contentType: ContentType,
+	draft: ContentDraftFields,
+	requirements: { requirePrimaryTopic?: boolean; primaryTopicLabel?: string } = {},
+): string | null {
+	if (canCreateContentDraft(contentType, draft, requirements)) return null
+	if (requirements.requirePrimaryTopic && !draft.primaryTopic?.trim()) {
+		return `Select ${requirements.primaryTopicLabel || 'a primary topic'} before saving.`
+	}
+	const mediaSource = foundryDispatchSourceForDraft(contentType, draft)
+	if (mediaSource && normalizeMediaDurationSeconds(draft.durationSeconds) === null) {
+		return 'Enter the authoritative media duration in whole seconds before saving.'
+	}
+	return 'Add the required title and content before saving.'
+}
+
 export function inferVideoSourceKind(sourceUrl: string): 'dropbox' | 'http_url' {
 	try {
 		const { hostname } = new URL(sourceUrl)