emdash 1.2.0 → 1.3.1

package/src/api/authorize.ts

@@ -71,6 +71,48 @@ export function requireOwnerPerm(
 	return null;
 }
 
+/**
+ * How `user` may edit an entry: `"full"` through `content:edit_own` or
+ * `content:edit_any`, `"draft"` through `content:edit_own_drafts` only, or
+ * `null` when they can't edit it.
+ *
+ * A `"draft"` grant holds only while the entry is still a draft, so the caller
+ * must make its write fail if the entry changes after this check, for example
+ * by conditioning the update on the `_rev` it checked.
+ */
+export function entryEditAccess(
+	user: UserLike | null | undefined,
+	entry: { authorId: string; status: unknown },
+): "full" | "draft" | null {
+	if (canActOnOwn(user, entry.authorId, "content:edit_own", "content:edit_any")) return "full";
+	if (
+		entry.status === "draft" &&
+		canActOnOwn(user, entry.authorId, "content:edit_own_drafts", "content:edit_any")
+	) {
+		return "draft";
+	}
+	return null;
+}
+
+/**
+ * Check if user can edit an entry, including an owner editing their own draft
+ * through `content:edit_own_drafts`. Returns a 401/403 Response if not, or null
+ * if authorized. See {@link entryEditAccess} for what a draft-only grant requires
+ * of the caller.
+ */
+export function requireEntryEditPerm(
+	user: UserLike | null | undefined,
+	entry: { authorId: string; status: unknown },
+): Response | null {
+	if (!user) {
+		return apiError("UNAUTHORIZED", "Authentication required", 401);
+	}
+	if (!entryEditAccess(user, entry)) {
+		return apiError("FORBIDDEN", "Insufficient permissions", 403);
+	}
+	return null;
+}
+
 /**
  * Like {@link requirePerm}, but authorized when the user has any of
  * `permissions`.

package/src/api/handlers/bulk-tag.ts

@@ -6,7 +6,7 @@ import { ContentRepository } from "../../database/repositories/content.js";
 import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
 import type { ContentItem } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
-import { getI18nConfig } from "../../i18n/config.js";
+import { getI18nConfig, resolveConfiguredLocale } from "../../i18n/config.js";
 import { localizePath, resolveLocalizedContentRoutePath } from "../../i18n/resolve.js";
 import { SchemaRegistry } from "../../schema/registry.js";
 import { compileUrlPattern } from "../../schema/url-pattern.js";
@@ -155,7 +155,9 @@ export async function handleBulkTag(
 		for (const [key, group] of slugNeeds) {
 			bySlug.set(
 				key,
-				await content.findManyBySlugsInLocale(group.collection, [...group.slugs], group.locale),
+				await content.findManyBySlugsInLocale(group.collection, [...group.slugs], group.locale, {
+					publishedOnly: true,
+				}),
 			);
 		}
 		const prepared: Array<{
@@ -175,7 +177,13 @@ export async function handleBulkTag(
 							: bySlug
 									.get(`${candidate.collection.slug}:${candidate.locale}`)
 									?.get(candidate.identifier);
-					if (!item || item.locale !== candidate.locale || item.status !== "published") continue;
+					if (
+						!item ||
+						item.locale === null ||
+						resolveConfiguredLocale(item.locale) !== resolveConfiguredLocale(candidate.locale) ||
+						item.status !== "published"
+					)
+						continue;
 					const canonical = await resolveLocalizedContentRoutePath({
 						pattern: candidate.collection.urlPattern ?? `/${candidate.collection.slug}/{slug}`,
 						collection: candidate.collection.slug,

package/src/api/handlers/bylines.ts

@@ -31,7 +31,7 @@ function bylineFixedFieldsMatch(
 		norm(existing.websiteUrl) === norm(input.websiteUrl) &&
 		norm(existing.userId) === norm(input.userId) &&
 		existing.isGuest === (input.isGuest ?? false) &&
-		existing.locale === effectiveLocale
+		resolveConfiguredLocale(existing.locale) === resolveConfiguredLocale(effectiveLocale)
 	);
 }
 
@@ -176,7 +176,11 @@ export async function handleBylineCreate(
 		// net; this is the friendly error.
 		if (sourceGroup) {
 			const siblings = await repo.findByTranslationGroup(sourceGroup);
-			if (siblings.some((b) => b.locale === effectiveLocale)) {
+			if (
+				siblings.some(
+					(b) => resolveConfiguredLocale(b.locale) === resolveConfiguredLocale(effectiveLocale),
+				)
+			) {
 				return {
 					success: false,
 					error: {

package/src/api/handlers/content.ts

@@ -26,6 +26,7 @@ import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
 import {
 	ContentCollectionNotFoundError,
 	ContentMutationConflictError,
+	ContentSlugConflictError,
 	EmDashValidationError,
 	ScheduledNotDueError,
 	InvalidCursorError,
@@ -43,6 +44,7 @@ import { withTransaction } from "../../database/transaction.js";
 import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
 import { getI18nConfig, isI18nEnabled, resolveConfiguredLocale } from "../../i18n/config.js";
+import { interpolateUrlPattern } from "../../i18n/resolve.js";
 import {
 	scheduledPolicyRejectionKey,
 	type ScheduledPolicyRejection,
@@ -811,6 +813,45 @@ async function createSlugChangeRedirect(
 	return redirect !== null;
 }
 
+/**
+ * Remove any auto-redirect whose source is the URL a newly published entry
+ * now occupies. This prevents an earlier slug-change redirect from shadowing
+ * the new live page, because the redirect middleware runs before routing.
+ */
+async function removeShadowingAutoRedirect(
+	db: Kysely<Database>,
+	collection: string,
+	slug: string | null | undefined,
+	contentId: string,
+	publishedAt: string | null | undefined,
+): Promise<boolean> {
+	if (!slug) return false;
+	validateIdentifier(collection, "collection slug");
+
+	const collectionRow = await db
+		.selectFrom("_emdash_collections")
+		.select("url_pattern")
+		.where("slug", "=", collection)
+		.executeTakeFirst();
+
+	const url = interpolateUrlPattern({
+		pattern: collectionRow?.url_pattern ?? null,
+		collection,
+		slug,
+		id: contentId,
+		date: publishedAt,
+	});
+
+	const result = await db
+		.deleteFrom("_emdash_redirects")
+		.where("source", "=", url)
+		.where("auto", "=", 1)
+		.executeTakeFirst();
+	const removed = BigInt(result.numDeletedRows ?? 0n) > 0n;
+	if (removed) invalidateRedirectCache();
+	return removed;
+}
+
 /** Whether a row other than `contentId` still holds `slug` in this collection. */
 async function slugStillTaken(
 	db: Kysely<Database>,
@@ -1250,6 +1291,7 @@ export async function handleContentCreate(
 		if (!requiredReferences.success) return requiredReferences;
 
 		// Wrap content + SEO writes in a transaction for atomicity
+		let redirectChanged = false;
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const bylineRepo = new BylineRepository(trx);
@@ -1390,8 +1432,19 @@ export async function handleContentCreate(
 				}
 			}
 
+			if (created.status === "published") {
+				redirectChanged = await removeShadowingAutoRedirect(
+					trx,
+					collection,
+					created.slug,
+					created.id,
+					created.publishedAt,
+				);
+			}
+
 			return created;
 		});
+		if (redirectChanged) after(() => publishRedirectChanges(db));
 
 		return {
 			success: true,
@@ -1415,6 +1468,18 @@ export async function handleContentCreate(
 				},
 			};
 		}
+		if (error instanceof ContentMutationConflictError) {
+			return { success: false, error: { code: "CONFLICT", message: error.message } };
+		}
+		if (error instanceof ContentSlugConflictError) {
+			return {
+				success: false,
+				error: {
+					code: "SLUG_CONFLICT",
+					message: `Slug '${body.slug ?? "(auto-generated)"}' already exists in collection '${collection}'`,
+				},
+			};
+		}
 		if (error instanceof EmDashValidationError) {
 			if (error.message === "Translation source content not found") {
 				return {
@@ -1542,7 +1607,7 @@ export async function handleContentUpdate(
 		// Wrap content + SEO writes in a transaction for atomicity.
 		// The _rev check is inside the transaction so the read-then-write
 		// is atomic -- no concurrent write can slip between the check and update.
-		let redirectCreated = false;
+		let redirectChanged = false;
 		const item = await withTransaction(db, async (trx) => {
 			const trxRepo = new ContentRepository(trx);
 			const bylineRepo = new BylineRepository(trx);
@@ -1610,12 +1675,17 @@ export async function handleContentUpdate(
 				}
 			}
 
+			// Collections without revisions save to the columns, and reads show any
+			// draft revision over them, so no draft pointer may outlive a save.
+			const { supportsRevisions } = await getCollectionPublishConfig(trx, collection);
 			const updated = await trxRepo.update(collection, resolvedId, {
 				data: body.data,
 				slug: body.slug,
+				locale: existing?.locale ?? body.locale,
 				status: body.status,
 				authorId: body.authorId,
 				publishedAt: body.publishedAt,
+				...(supportsRevisions ? {} : { draftRevisionId: null }),
 			});
 
 			if (body.bylines !== undefined) {
@@ -1632,7 +1702,7 @@ export async function handleContentUpdate(
 			// pre-update date (the URL that was actually live) and the new URL
 			// the post-update one.
 			if (oldSlug && body.slug) {
-				redirectCreated = await createSlugChangeRedirect(
+				redirectChanged = await createSlugChangeRedirect(
 					trx,
 					collection,
 					oldSlug,
@@ -1685,9 +1755,20 @@ export async function handleContentUpdate(
 				await writeReferenceSelection(trx, write);
 			}
 
+			if (updated.status === "published") {
+				redirectChanged =
+					(await removeShadowingAutoRedirect(
+						trx,
+						collection,
+						updated.slug,
+						updated.id,
+						updated.publishedAt,
+					)) || redirectChanged;
+			}
+
 			return updated;
 		});
-		if (redirectCreated) after(() => publishRedirectChanges(db));
+		if (redirectChanged) after(() => publishRedirectChanges(db));
 
 		return {
 			success: true,
@@ -1717,6 +1798,15 @@ export async function handleContentUpdate(
 				error: { code: "VALIDATION_ERROR", message: error.message },
 			};
 		}
+		if (error instanceof ContentSlugConflictError) {
+			return {
+				success: false,
+				error: {
+					code: "SLUG_CONFLICT",
+					message: `Slug '${body.slug ?? id}' already exists in collection '${collection}'`,
+				},
+			};
+		}
 		const message = error instanceof Error ? error.message.toLowerCase() : "";
 		if (message.includes("unique constraint failed") || message.includes("duplicate key")) {
 			if (message.includes("slug")) {
@@ -2352,7 +2442,7 @@ export async function handleContentPublish(
 ): Promise<ApiResult<ContentResponse>> {
 	try {
 		const expectedRevision = decodeRevisionPrecondition(options._rev);
-		let redirectCreated = false;
+		let redirectChanged = false;
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
@@ -2472,7 +2562,7 @@ export async function handleContentPublish(
 				published.slug &&
 				existing.slug !== published.slug
 			) {
-				redirectCreated = await createSlugChangeRedirect(
+				redirectChanged = await createSlugChangeRedirect(
 					trx,
 					collection,
 					existing.slug,
@@ -2483,9 +2573,18 @@ export async function handleContentPublish(
 				);
 			}
 
+			redirectChanged =
+				(await removeShadowingAutoRedirect(
+					trx,
+					collection,
+					published.slug,
+					published.id,
+					published.publishedAt,
+				)) || redirectChanged;
+
 			return published;
 		});
-		if (redirectCreated) after(() => publishRedirectChanges(db));
+		if (redirectChanged) after(() => publishRedirectChanges(db));
 
 		const hasSeo = await collectionHasSeo(db, collection);
 		await hydrateSeo(db, collection, item, hasSeo);
@@ -2583,7 +2682,8 @@ export async function handleContentUnpublish(
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
-			return repo.unpublish(collection, resolvedId, expectedRevision);
+			const { supportsRevisions } = await getCollectionPublishConfig(trx, collection);
+			return repo.unpublish(collection, resolvedId, expectedRevision, supportsRevisions);
 		});
 
 		const hasSeo = await collectionHasSeo(db, collection);

package/src/api/handlers/dashboard.ts

@@ -20,6 +20,7 @@ import {
 	type ScheduledPolicyRejection,
 	type VersionedScheduledPolicyRejection,
 } from "../../plugins/content-policy.js";
+import type { VersionedValue } from "../../plugins/types.js";
 import { getSchedulerHealth, type SchedulerHealth } from "../../scheduler-health.js";
 import type { ApiResult } from "../types.js";
 
@@ -46,8 +47,10 @@ export interface RecentItem {
 
 export interface DashboardStats {
 	collections: CollectionStats[];
-	mediaCount: number;
-	userCount: number;
+	/** Omitted for callers without `media:read`. */
+	mediaCount?: number;
+	/** Omitted for callers without `users:read`. */
+	userCount?: number;
 	recentItems: RecentItem[];
 	schedulerHealth: SchedulerHealth;
 	policyRejectedScheduled: number;
@@ -61,9 +64,19 @@ const POLICY_REJECTION_PREVIEW_LIMIT = 20;
  *
  * Queries are intentionally lightweight — counts use indexed columns,
  * and recent items are capped at 10.
+ *
+ * Without `includeDrafts` (callers lacking `content:read_drafts`), only
+ * published entries are counted or listed, and scheduled-publication policy
+ * rejections are omitted. Without `includeMediaCount` / `includeUserCount`,
+ * `mediaCount` / `userCount` are omitted.
  */
 export async function handleDashboardStats(
 	db: Kysely<Database>,
+	{
+		includeDrafts,
+		includeMediaCount,
+		includeUserCount,
+	}: { includeDrafts: boolean; includeMediaCount: boolean; includeUserCount: boolean },
 	now = new Date(),
 ): Promise<ApiResult<DashboardStats>> {
 	try {
@@ -79,6 +92,17 @@ export async function handleDashboardStats(
 		const collectionStats: CollectionStats[] = await Promise.all(
 			collections.map(async (col) => {
 				const stats = await contentRepo.getStats(col.slug, now);
+				if (!includeDrafts) {
+					return {
+						slug: col.slug,
+						label: col.label,
+						total: stats.published,
+						published: stats.published,
+						draft: 0,
+						scheduled: 0,
+						overdueScheduled: 0,
+					};
+				}
 				return {
 					slug: col.slug,
 					label: col.label,
@@ -102,23 +126,25 @@ export async function handleDashboardStats(
 			policyRejectedScheduled,
 			versionedPolicyRejectionOptions,
 		] = await Promise.all([
-			mediaRepo.count(),
-			userRepo.count(),
+			includeMediaCount ? mediaRepo.count() : undefined,
+			includeUserCount ? userRepo.count() : undefined,
 			getSchedulerHealth(db, now),
-			optionsRepo.countByPrefix(SCHEDULED_POLICY_REJECTION_PREFIX),
-			optionsRepo.getVersionedByPrefix<ScheduledPolicyRejection>(
-				SCHEDULED_POLICY_REJECTION_PREFIX,
-				{
-					limit: POLICY_REJECTION_PREVIEW_LIMIT,
-				},
-			),
+			includeDrafts ? optionsRepo.countByPrefix(SCHEDULED_POLICY_REJECTION_PREFIX) : 0,
+			includeDrafts
+				? optionsRepo.getVersionedByPrefix<ScheduledPolicyRejection>(
+						SCHEDULED_POLICY_REJECTION_PREFIX,
+						{
+							limit: POLICY_REJECTION_PREVIEW_LIMIT,
+						},
+					)
+				: new Map<string, VersionedValue<ScheduledPolicyRejection>>(),
 		]);
 		const policyRejections = [...versionedPolicyRejectionOptions.values()]
 			.filter(({ value }) => isScheduledPolicyRejection(value))
 			.map(({ value, revision }) => ({ ...value, _rev: revision }));
 
-		// Recent items across all collections (last 10 updated, any status)
-		const recentItems = await fetchRecentItems(db, collections);
+		// Recent items across all collections (last 10 updated)
+		const recentItems = await fetchRecentItems(db, collections, includeDrafts);
 
 		return {
 			success: true,
@@ -165,10 +191,13 @@ interface RecentItemRow {
  * `title` is not a standard column — it's a user-defined field. We query
  * `_emdash_fields` to discover which collections have one and fall back
  * to `slug` (which is always present) otherwise.
+ *
+ * Without `includeDrafts`, only published entries are considered.
  */
 async function fetchRecentItems(
 	db: Kysely<Database>,
 	collections: Array<{ slug: string; label: string }>,
+	includeDrafts: boolean,
 ): Promise<RecentItem[]> {
 	if (collections.length === 0) return [];
 
@@ -181,6 +210,7 @@ async function fetchRecentItems(
 		.execute();
 
 	const collectionsWithTitle = new Set(titleFields.map((r) => r.collection_slug));
+	const statusFilter = includeDrafts ? sql`` : sql`AND status = 'published'`;
 
 	// Issue one query per collection in parallel, then merge in JS.
 	// A single UNION ALL across N collections trips D1's
@@ -208,7 +238,7 @@ async function fetchRecentItems(
 					updated_at,
 					author_id
 				FROM ${sql.ref(table)}
-				WHERE deleted_at IS NULL
+				WHERE deleted_at IS NULL ${statusFilter}
 				ORDER BY updated_at DESC
 				LIMIT 10
 			`.execute(db);

package/src/api/handlers/manifest.ts

@@ -353,6 +353,7 @@ function dbFieldDescriptor(
 		id: field.id,
 	};
 	if (field.unsupportedType) entry.unsupportedType = field.unsupportedType;
+	if (field.type === "integer") entry.integer = true;
 	if (field.blockTypes) entry.blockTypes = field.blockTypes;
 	if (field.blockTypeFingerprint) entry.blockTypeFingerprint = field.blockTypeFingerprint;
 

package/src/api/handlers/menus.ts

@@ -15,6 +15,7 @@ import type { Kysely } from "kysely";
 
 import {
 	MenuGoneError,
+	MenuItemParentError,
 	MenuRepository,
 	type CreateMenuItemInput as CreateMenuItemRepoInput,
 	type Menu,
@@ -25,7 +26,7 @@ import {
 	type UpdateMenuItemInput as UpdateMenuItemRepoInput,
 } from "../../database/repositories/menu.js";
 import type { Database } from "../../database/types.js";
-import { getI18nConfig, resolveConfiguredLocale } from "../../i18n/config.js";
+import { getI18nConfig, getLocaleRank, resolveConfiguredLocale } from "../../i18n/config.js";
 import type { ApiResult } from "../types.js";
 
 // Re-export entity types so route files and tests can import them from the
@@ -100,16 +101,20 @@ async function resolveMenu(
 			},
 		};
 	}
-	if (matches.length > 1) {
+	const canonicalLocales = new Set(matches.map((match) => resolveConfiguredLocale(match.locale)));
+	if (locale === undefined && canonicalLocales.size > 1) {
 		return {
 			success: false,
-			error: ambiguousMenuLocaleError(
-				name,
-				matches.map((m) => m.locale),
-			).error,
+			error: ambiguousMenuLocaleError(name, [...canonicalLocales]).error,
 		};
 	}
-	return { success: true, menu: matches[0] };
+	const preferredLocale = locale ?? resolveConfiguredLocale(matches[0].locale);
+	const menu = matches.toSorted(
+		(a, b) =>
+			getLocaleRank(a.locale, preferredLocale) - getLocaleRank(b.locale, preferredLocale) ||
+			a.id.localeCompare(b.id),
+	)[0];
+	return { success: true, menu };
 }
 
 // ---------------------------------------------------------------------------
@@ -369,7 +374,10 @@ export async function handleMenuItemCreate(
 
 		const item = await repo.createItem(resolved.menu.id, resolved.menu.locale, input);
 		return { success: true, data: item };
-	} catch {
+	} catch (error) {
+		if (error instanceof MenuItemParentError) {
+			return { success: false, error: { code: "VALIDATION_ERROR", message: error.message } };
+		}
 		return {
 			success: false,
 			error: { code: "MENU_ITEM_CREATE_ERROR", message: "Failed to create menu item" },
@@ -400,7 +408,10 @@ export async function handleMenuItemUpdate(
 			};
 		}
 		return { success: true, data: updated };
-	} catch {
+	} catch (error) {
+		if (error instanceof MenuItemParentError) {
+			return { success: false, error: { code: "VALIDATION_ERROR", message: error.message } };
+		}
 		return {
 			success: false,
 			error: { code: "MENU_ITEM_UPDATE_ERROR", message: "Failed to update menu item" },
@@ -528,7 +539,10 @@ export async function handleMenuItemReorder(
 
 		const updated = await repo.reorderItems(resolved.menu.id, items);
 		return { success: true, data: updated };
-	} catch {
+	} catch (error) {
+		if (error instanceof MenuItemParentError) {
+			return { success: false, error: { code: "VALIDATION_ERROR", message: error.message } };
+		}
 		return {
 			success: false,
 			error: { code: "MENU_REORDER_ERROR", message: "Failed to reorder menu items" },

package/src/api/handlers/plugins.ts

@@ -41,6 +41,7 @@ export interface PluginInfo {
 	mcpToolsEnabled: boolean;
 	mcpTools: Array<{
 		name: string;
+		mcpName?: string;
 		description: string;
 		route: string;
 		permission: string;

package/src/api/handlers/relations.ts

@@ -13,6 +13,7 @@ import { InvalidCursorError } from "../../database/repositories/types.js";
 import type { ContentItem } from "../../database/repositories/types.js";
 import { withTransaction } from "../../database/transaction.js";
 import type { Database } from "../../database/types.js";
+import { getLocaleCandidates, getLocaleRank } from "../../i18n/config.js";
 import { invalidateCollectionCache } from "../../object-cache/index.js";
 import {
 	pageStagedGroups,
@@ -378,7 +379,20 @@ async function resolveRelation(
  * `locale` so callers never mistake a fallback for the requested locale.
  */
 function pickVariant(items: ContentItem[], locale: string | null): ContentItem | undefined {
-	return items.find((i) => i.locale === locale) ?? items[0];
+	if (locale === null) return items[0];
+
+	const candidates = getLocaleCandidates(locale);
+	let best: ContentItem | undefined;
+	let bestRank = candidates.length;
+	for (const item of items) {
+		if (item.locale === null) continue;
+		const rank = getLocaleRank(item.locale, locale);
+		if (rank < bestRank) {
+			best = item;
+			bestRank = rank;
+		}
+	}
+	return best ?? items[0];
 }
 
 /**

package/src/api/handlers/revision.ts

@@ -6,7 +6,11 @@ import type { Kysely } from "kysely";
 
 import { after } from "../../after.js";
 import { ContentRepository } from "../../database/repositories/content.js";
-import { RevisionRepository, type Revision } from "../../database/repositories/revision.js";
+import {
+	RevisionRepository,
+	type Revision,
+	type RevisionWithAuthor,
+} from "../../database/repositories/revision.js";
 import { ContentMutationConflictError } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
 import { encodeRev } from "../rev.js";
@@ -19,7 +23,7 @@ import {
 } from "./staged-references.js";
 
 export interface RevisionListResponse {
-	items: Revision[];
+	items: RevisionWithAuthor[];
 	total: number;
 }
 

package/src/api/handlers/site-domain.ts

@@ -47,8 +47,15 @@ export function parseSiteDomain(input: string): string | undefined {
 	return url.origin;
 }
 
-function checkFailed(message: string): ApiResult<never> {
-	return { success: false, error: { code: "DOMAIN_CHECK_FAILED", message } };
+/** Why a domain check failed, sent as `error.details` with the addresses its message names. */
+type DomainCheckFailure =
+	| { reason: "NO_PUBLIC_ADDRESS"; host: string }
+	| { reason: "UNREACHABLE"; origin: string }
+	| { reason: "REDIRECT"; origin: string; target?: string }
+	| { reason: "NOT_SERVING"; origin: string };
+
+function checkFailed(message: string, details: DomainCheckFailure): ApiResult<never> {
+	return { success: false, error: { code: "DOMAIN_CHECK_FAILED", message, details } };
 }
 
 /**
@@ -79,7 +86,11 @@ export async function handleSiteDomainChange(
 		try {
 			await resolveAndValidateExternalUrl(proofUrl);
 		} catch {
-			return checkFailed(`${new URL(origin).hostname} does not resolve to a public address`);
+			const host = new URL(origin).hostname;
+			return checkFailed(`${host} does not resolve to a public address`, {
+				reason: "NO_PUBLIC_ADDRESS",
+				host,
+			});
 		}
 
 		let response: Response;
@@ -91,18 +102,20 @@ export async function handleSiteDomainChange(
 				signal: AbortSignal.timeout(CHECK_TIMEOUT_MS),
 			});
 		} catch {
-			return checkFailed(`Could not reach ${origin}`);
+			return checkFailed(`Could not reach ${origin}`, { reason: "UNREACHABLE", origin });
 		}
 
 		if (response.status >= 300 && response.status < 400) {
 			const location = response.headers.get("Location");
 			const target =
 				location && URL.canParse(location, proofUrl) ? new URL(location, proofUrl) : null;
-			return checkFailed(
-				target
-					? `${origin} redirects to ${target.origin}. Enter that address instead.`
-					: `${origin} redirects elsewhere`,
-			);
+			return target
+				? checkFailed(`${origin} redirects to ${target.origin}. Enter that address instead.`, {
+						reason: "REDIRECT",
+						origin,
+						target: target.origin,
+					})
+				: checkFailed(`${origin} redirects elsewhere`, { reason: "REDIRECT", origin });
 		}
 
 		const body: unknown = response.ok ? await response.json().catch(() => null) : null;
@@ -115,7 +128,10 @@ export async function handleSiteDomainChange(
 				? (body.data as { token?: unknown }).token
 				: undefined;
 		if (received !== token) {
-			return checkFailed(`${origin} does not serve this site yet`);
+			return checkFailed(`${origin} does not serve this site yet`, {
+				reason: "NOT_SERVING",
+				origin,
+			});
 		}
 
 		await setSiteSettings({ url: origin }, db);