bsmnt 0.9.0 → 0.11.0

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/schemas/layout/redirect.ts

@@ -65,7 +65,7 @@ export const redirect = defineType({
 			description:
 				"Where to send visitors. An internal route path without a leading slash (e.g. new-page or blog/new-post), or an absolute URL (e.g. https://example.com).",
 			validation: (Rule) =>
-				Rule.required().custom((value, context) => {
+				Rule.required().custom(async (value, context) => {
 					if (typeof value !== "string") return true;
 
 					const isAbsolute = /^https?:\/\//.test(value);
@@ -79,13 +79,44 @@ export const redirect = defineType({
 						return "Internal destination must not start or end with a forward slash";
 					}
 
-					const source = (
-						context.document as RedirectValidationDocument | undefined
-					)?.source?.current;
+					const document = context.document as
+						| RedirectValidationDocument
+						| undefined;
+					const source = document?.source?.current;
+
 					if (source && source === value) {
 						return "Destination must differ from source";
 					}
 
+					// Rejects a direct loop (a -> b, b -> a); longer chains aren't checked.
+					// Normalizes slashes since docs written outside Studio can skip that validation.
+					if (source) {
+						const id = document?._id?.replace(/^drafts\./, "") ?? "";
+						const client = context.getClient({ apiVersion });
+						const normalize = (path: string) => path.replace(/^\/+|\/+$/g, "");
+						const normalizedSource = normalize(source);
+						const normalizedDestination = normalize(value);
+						const others = await client.fetch<
+							Array<{ source?: string; destination?: string }>
+						>(
+							`*[
+                _type == "redirect" &&
+                !(_id in [$id, "drafts." + $id])
+              ]{ "source": source.current, destination }`,
+							{ id },
+						);
+						const hasInverse = others.some(
+							(redirect) =>
+								redirect.source &&
+								normalize(redirect.source) === normalizedDestination &&
+								redirect.destination &&
+								normalize(redirect.destination) === normalizedSource,
+						);
+						if (hasInverse) {
+							return "This creates a redirect loop — another redirect sends the destination back to this source";
+						}
+					}
+
 					return true;
 				}),
 		}),

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/schemas/shared/page.ts

@@ -204,6 +204,18 @@ export const page = defineType({
 					return `These page builder components do not belong to the "${pageType ?? "generic"}" category: ${invalidMemberTitles.join(", ")}`;
 				}),
 		}),
+		defineField({
+			name: "collectionCategory",
+			title: "Pinned Collection Category",
+			type: "reference",
+			to: [{ type: "blogCategory" }],
+			// Lives on the page because the collection block is deliberately a
+			// singleton (see `singletonComponents`) — editors reuse one block rather
+			// than creating them, so a category set there would apply site-wide. Move
+			// the block to the reusable list if you'd rather scope it per instance.
+			description:
+				"Turns this page into a category page: the content collection shows only this category. Leave empty to show everything.",
+		}),
 		defineField({
 			name: "hiddenPageBuilderKeys",
 			title: "Hidden Blocks",

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/tags.ts

@@ -0,0 +1,56 @@
+// Dependency maps for the publish webhook. Dependency-free on purpose: the
+// modules owning these documents pull in the Studio UI.
+//
+// The strings mirror the `tags: [...]` arrays at each fetch site. Nothing
+// enforces that pairing, so a tag renamed there has to be renamed here.
+
+const SANITY_NAVBAR_TAG = "navbar";
+const SANITY_STRUCTURED_DATA_TAG = "structuredData";
+
+// Crawler routes: broader than any per-slug tag.
+export const SITEMAP_TAG = "sitemap";
+export const FEED_TAG = "feed";
+
+export const BLOG_COLLECTION_TAGS = [
+	"blog-categories",
+	"blog-articles",
+	"blog-articles-count",
+] as const;
+
+// Publishing a `page` revalidates its own path; nothing else reaches the cached
+// collection windows.
+export const BLOG_COLLECTION_TYPES = new Set<string>([
+	"page",
+	"blogContent",
+	"blogCategory",
+	"author",
+]);
+
+// Publishing the left-hand type has to bust the right-hand tags; nothing else
+// reaches them.
+export const CROSS_DOC_TAG_DEPENDENCIES: Record<string, readonly string[]> = {
+	// Redundant while LAYOUT_QUERY is merged; kept so splitting it can't lose this.
+	companyData: [SANITY_STRUCTURED_DATA_TAG],
+	// Nav links deref pages; sitemap and feed move whenever any page does.
+	page: [SANITY_NAVBAR_TAG, SITEMAP_TAG, FEED_TAG],
+	// ...plus the collections, which decide membership on the folder slug, so a
+	// rename changes which pages are articles at all.
+	pageFolder: [
+		SANITY_NAVBAR_TAG,
+		...BLOG_COLLECTION_TAGS,
+		SITEMAP_TAG,
+		FEED_TAG,
+	],
+	// The feed derefs the article's block, then its author and categories.
+	blogContent: [FEED_TAG],
+	author: [FEED_TAG],
+	blogCategory: [FEED_TAG],
+};
+
+// Types a page inlines by reference, so publishing one goes stale on every page
+// pointing at it. `page` is here for `relatedPosts[]->` and rich-text links.
+export const REFERENCEABLE_TYPES = new Set<string>([
+	"page",
+	"author",
+	"blogCategory",
+]);

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/utils/page-builder-markdown.ts

@@ -29,6 +29,18 @@ export const renderPageBuilderMarkdown = (
 					return block.headline ? [`## ${block.headline}`, ""] : [];
 				case "description":
 					return block.description ? [block.description, ""] : [];
+				case "richTextBlock":
+					return block.content
+						? [
+								portableTextToMarkdown(
+									block.content as Parameters<
+										typeof portableTextToMarkdown
+									>[0],
+									markdownOptions,
+								),
+								"",
+							]
+						: [];
 				case "gatedContent": {
 					// The gated payload is withheld from the page query, so it is not
 					// available here either — only the teaser is emitted, matching what

package/src/modules/features/cms/sanity-pagebuilder/files/lib/utils/sitemap.ts

@@ -1,6 +1,7 @@
 import { PINNED_PAGE_ENTRIES } from "@/lib/integrations/sanity/pinned-pages";
 import { PAGE_SITEMAP_QUERY } from "@/lib/integrations/sanity/queries";
 import type { PAGE_SITEMAP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import { SITEMAP_TAG } from "@/lib/integrations/sanity/tags";
 import { getBaseUrl } from "./base-url";
 
 export const getSitemapBaseUrl = getBaseUrl;
@@ -26,15 +27,17 @@ export const getMarkdownPath = (baseUrl: string, slug: string | null) => {
 		: `${baseUrl}/index.md`;
 };
 
+// Tagged, not a bare `client.fetch`: an untagged read can't be invalidated.
 export const getSitemap = async () => {
-	const sanityModule = await import("@/lib/integrations/sanity/client");
-	const client = sanityModule?.client;
-
-	if (!client) return null;
-
-	const p = await client.fetch<PAGE_SITEMAP_QUERY_RESULT>(PAGE_SITEMAP_QUERY, {
-		pinnedIds: PINNED_PAGE_ENTRIES.map((entry) => entry.id),
+	// Lazy: the webhook imports `getPagePath` from here, and a static import would
+	// make it evaluate `defineLive()` for a string helper.
+	const { fetchSanity } = await import("@/lib/integrations/sanity/live");
+
+	const { data } = await fetchSanity<PAGE_SITEMAP_QUERY_RESULT>({
+		query: PAGE_SITEMAP_QUERY,
+		params: { pinnedIds: PINNED_PAGE_ENTRIES.map((entry) => entry.id) },
+		tags: [SITEMAP_TAG],
 	});
 
-	return p;
+	return data;
 };

package/src/modules/features/cms/sanity-pagebuilder/files/proxy.ts

@@ -14,6 +14,15 @@ export function proxy(request: NextRequest) {
 		return NextResponse.next();
 	}
 
+	// Collapse repeated slashes before any rewrite, or the rewrite below would
+	// mask the alias (e.g. /foo//bar.md silently resolving to /foo/bar.md).
+	const collapsedPathname = pathname.replace(/\/{2,}/g, "/");
+	if (collapsedPathname !== pathname) {
+		const url = request.nextUrl.clone();
+		url.pathname = collapsedPathname;
+		return NextResponse.redirect(url, 308);
+	}
+
 	if (pathname === "/" && acceptHeader.includes("text/markdown")) {
 		const url = request.nextUrl.clone();
 		url.pathname = "/api/index.md";

package/src/modules/features/cms/sanity-pagebuilder-cache/files/.knip.json

@@ -0,0 +1,8 @@
+{
+	"$schema": "https://unpkg.com/knip@6/schema.json",
+	"entry": [
+		"lib/integrations/sanity/sanity.cli.ts",
+		"lib/integrations/sanity/sanity.config.ts"
+	],
+	"ignore": ["lib/integrations/sanity/sanity.types.ts"]
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/app/api/[[...slug]]/route.ts

@@ -0,0 +1,112 @@
+import { NextResponse } from "next/server";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import {
+	getDynamicFetchOptions,
+	sanityFetchCached,
+} from "@/lib/integrations/sanity/live";
+import { PAGE_QUERY } from "@/lib/integrations/sanity/queries";
+import type { PAGE_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import { renderPageBuilderMarkdown } from "@/lib/integrations/sanity/utils/page-builder-markdown";
+import { getBaseUrl } from "@/lib/utils/base-url";
+import { getSlugTag } from "@/lib/utils/slug-tag";
+
+type PageResult = NonNullable<PAGE_QUERY_RESULT>;
+
+const isValidSegment = (segment: string) =>
+	segment.length > 0 && segment !== "." && segment !== "..";
+
+const getSlugPath = (slugParts?: string[]) => {
+	if (!slugParts?.length) return null;
+
+	const lastSegment = slugParts.at(-1);
+
+	if (!lastSegment?.endsWith(".md")) return null;
+
+	const pathSegments = [...slugParts];
+	pathSegments[pathSegments.length - 1] = lastSegment.slice(0, -3);
+
+	if (!pathSegments.every(isValidSegment)) return null;
+
+	const slug = pathSegments.join("/");
+
+	return slug === "index" ? null : slug;
+};
+
+export async function GET(
+	_request: Request,
+	props: { params: Promise<{ slug?: string[] }> },
+) {
+	const { slug: rawSlugParts } = await props.params;
+	const slug = getSlugPath(rawSlugParts);
+
+	if (
+		rawSlugParts?.length &&
+		slug === null &&
+		rawSlugParts.join("/") !== "index.md"
+	) {
+		return new NextResponse(null, { status: 404 });
+	}
+
+	if (!rawSlugParts?.length) {
+		return new NextResponse(null, { status: 404 });
+	}
+
+	if (!isSanityConfigured()) {
+		return new NextResponse("# 404 Not Found\n\nCMS not configured.", {
+			status: 404,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+
+	const fetchOptions = await getDynamicFetchOptions();
+	const { data: page } = await sanityFetchCached<PageResult>({
+		query: PAGE_QUERY,
+		params: { slug },
+		...fetchOptions,
+		// This route answers at /api/<slug>.md, which no `revalidatePath` on the
+		// page path reaches. The tag is the only thing that clears it.
+		tags: [getSlugTag(slug)],
+	});
+
+	const baseUrl = getBaseUrl().replace(/\/$/, "");
+
+	if (!page) {
+		return new NextResponse("# 404 Not Found\n\nPage not found.", {
+			status: 404,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+
+	const body = renderPageBuilderMarkdown(page.pageBuilder);
+	const canonicalPath = slug ? `/${slug}` : "/";
+
+	return new NextResponse(
+		[
+			`# ${page.title}`,
+			"",
+			page._updatedAt
+				? `**Updated:** ${new Date(page._updatedAt).toLocaleDateString()}`
+				: null,
+			"",
+			`Canonical URL: ${baseUrl}${canonicalPath}`,
+			"",
+			"---",
+			"",
+			body || "No page builder content yet.",
+			"",
+			"---",
+			"",
+			`[View all content](${baseUrl}/sitemap.md)`,
+		]
+			.filter((part): part is string => part !== null)
+			.join("\n"),
+		{
+			headers: {
+				"Content-Type": "text/markdown; charset=utf-8",
+				Vary: "Accept",
+				"X-Content-Type-Options": "nosniff",
+				Link: `<${baseUrl}${canonicalPath}>; rel="canonical"`,
+			},
+		},
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/app/api/draft-mode/disable/route.ts

@@ -0,0 +1,7 @@
+import { draftMode } from "next/headers";
+import { type NextRequest, NextResponse } from "next/server";
+
+export async function GET(request: NextRequest) {
+	(await draftMode()).disable();
+	return NextResponse.redirect(new URL("/", request.url));
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/app/api/draft-mode/enable/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from "next/server";
+import { defineEnableDraftMode } from "next-sanity/draft-mode";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { client } from "@/lib/integrations/sanity/client";
+import { sanityToken } from "@/lib/integrations/sanity/env";
+
+const draftModeHandler =
+	isSanityConfigured() && client
+		? defineEnableDraftMode({
+				client: client.withConfig({ token: sanityToken }),
+			})
+		: {
+				GET: () =>
+					NextResponse.json(
+						{ error: "Sanity is not configured" },
+						{ status: 503 },
+					),
+			};
+
+export const { GET } = draftModeHandler;

package/src/modules/features/cms/sanity-pagebuilder-cache/files/app/api/revalidate/route.ts

@@ -0,0 +1,292 @@
+import { revalidatePath, revalidateTag } from "next/cache";
+import { type NextRequest, NextResponse } from "next/server";
+import { parseBody } from "next-sanity/webhook";
+// `directClient`, never `client`: a CDN hit returns the pre-mutation slug, which
+// purges the old path twice and never the new one.
+import { directClient } from "@/lib/integrations/sanity/client";
+import { pageBuilderReferenceMembers as pbrm } from "@/lib/integrations/sanity/page-builder-config";
+import {
+	ALL_PAGE_SLUGS_QUERY,
+	FOLDER_PATH_QUERY,
+	P_REF_DOC_PAGES_QUERY,
+	P_REV_FOLDER_DESCENDANTS_QUERY,
+	P_REV_SLUGS_QUERY,
+} from "@/lib/integrations/sanity/queries";
+import {
+	composeDescendantPaths,
+	composeResolvedSlug,
+} from "@/lib/integrations/sanity/revalidate-paths";
+import type {
+	ALL_PAGE_SLUGS_QUERY_RESULT,
+	FOLDER_PATH_QUERY_RESULT,
+	P_REF_DOC_PAGES_QUERY_RESULT,
+	P_REV_FOLDER_DESCENDANTS_QUERY_RESULT,
+} from "@/lib/integrations/sanity/sanity.types";
+import {
+	BLOG_COLLECTION_TAGS,
+	BLOG_COLLECTION_TYPES,
+	CROSS_DOC_TAG_DEPENDENCIES,
+	PURGEABLE_TAGS,
+	REFERENCEABLE_TYPES,
+	SELF_TAGGED_TYPES,
+} from "@/lib/integrations/sanity/tags";
+import { getPagePath } from "@/lib/utils/sitemap";
+import { getSlugTag } from "@/lib/utils/slug-tag";
+
+const ERRORS = {
+	BAD_REQ: ["Bad Request", { status: 400 }],
+	INVALID_SIG: ["Invalid signature", { status: 401 }],
+} as const;
+
+type WebhookSlug = {
+	current?: string | null;
+};
+
+type WebhookReference = {
+	_ref?: string | null;
+};
+
+type WebhookDocument = {
+	_id: string;
+	_type: string;
+	slug?: WebhookSlug | null;
+	pageFolder?: WebhookReference | null;
+	parentFolder?: WebhookReference | null;
+};
+
+type MutationOperation = "create" | "update" | "delete";
+
+type RevalidateWebhookBody = WebhookDocument & {
+	operation?: MutationOperation;
+	purgeAll?: boolean;
+	before?: Partial<WebhookDocument> | null;
+	after?: Partial<WebhookDocument> | null;
+};
+
+const referenceableTypes = new Set<string>([
+	...pbrm.map((m) => m.documentType),
+	...REFERENCEABLE_TYPES,
+]);
+
+// Not `"max"`: a named profile expires a year out, so Next serves the stale entry
+// once while refreshing. A publish should land on the next request.
+const PURGE = { expire: 0 } as const;
+
+const bustTags = (tags: readonly string[]) => {
+	for (const tag of tags) {
+		revalidateTag(tag, PURGE);
+	}
+};
+
+// Both: the path clears the page's route, the tag clears what no page render
+// touches — above all the markdown route at /api/<slug>.md.
+const bustPage = (slug: string | null) => {
+	revalidatePath(getPagePath(slug));
+	revalidateTag(getSlugTag(slug), PURGE);
+};
+
+const normalizeRevalidationSlug = (slug: string | null | undefined) => {
+	if (slug === undefined) return null;
+	if (slug === null) return "/";
+	return `/${slug}`;
+};
+
+const getCanonicalPageSlug = async (documentId: string) => {
+	if (!directClient) return null;
+
+	const pageSlugs = await directClient.fetch<Array<{ slug: string | null }>>(
+		P_REV_SLUGS_QUERY,
+		{ documentIds: [documentId] },
+	);
+
+	return normalizeRevalidationSlug(
+		pageSlugs.find((page) => page.slug !== undefined)?.slug,
+	);
+};
+
+// Homepage comes back as `null`, as `bustPage` expects.
+const getAllPageSlugs = async () => {
+	if (!directClient) return [];
+
+	const pages =
+		await directClient.fetch<ALL_PAGE_SLUGS_QUERY_RESULT>(ALL_PAGE_SLUGS_QUERY);
+
+	return [
+		null,
+		...(pages ?? []).flatMap((page) =>
+			page.slug && page.slug !== "/" ? [`/${page.slug}`] : [],
+		),
+	];
+};
+
+const getFolder = async (folderId: string | null | undefined) => {
+	if (!(directClient && folderId)) return null;
+
+	const folder = await directClient.fetch<FOLDER_PATH_QUERY_RESULT>(
+		FOLDER_PATH_QUERY,
+		{ folderId },
+	);
+
+	return folder ?? null;
+};
+
+const getPagesReferencing = async (documentIds: readonly string[]) => {
+	if (!(directClient && documentIds.length)) return [];
+
+	const pages = await directClient.fetch<P_REF_DOC_PAGES_QUERY_RESULT>(
+		P_REF_DOC_PAGES_QUERY,
+		{ documentIds },
+	);
+
+	return (pages ?? []).map((page) => normalizeRevalidationSlug(page.slug));
+};
+
+// `slug.current` is only the page's own segment, so the URL is rebuilt from the
+// folder. `undefined` means "no such revision", distinct from the `null` a root
+// page resolves to — without that split, a missing `before()` purges the homepage.
+const resolvePageSlug = async (
+	revision: Partial<WebhookDocument> | null | undefined,
+) => {
+	if (!revision) return undefined;
+
+	const folder = await getFolder(revision.pageFolder?._ref);
+
+	return composeResolvedSlug(folder?.path ?? null, revision.slug?.current);
+};
+
+// A folder move rewrites every URL beneath it, and none of those are `page`
+// mutations, so nothing else here would touch them.
+const revalidateFolderSubtree = async (body: RevalidateWebhookBody) => {
+	const { before, after } = body;
+
+	const previousFolderSlug = before?.slug?.current;
+	const moved =
+		previousFolderSlug !== after?.slug?.current ||
+		before?.parentFolder?._ref !== after?.parentFolder?._ref;
+
+	// A title-only edit changes no URL. Deletion is skipped outright: these are hard
+	// references, so Sanity refuses to delete a folder that still has descendants.
+	if (body.operation === "delete") return [];
+	if (!(directClient && moved && previousFolderSlug)) return [];
+
+	const previousParent = await getFolder(before?.parentFolder?._ref);
+
+	const descendants =
+		await directClient.fetch<P_REV_FOLDER_DESCENDANTS_QUERY_RESULT>(
+			P_REV_FOLDER_DESCENDANTS_QUERY,
+			{ folderId: body._id },
+		);
+
+	const movedIds: string[] = [];
+
+	for (const descendant of descendants ?? []) {
+		const paths = composeDescendantPaths({
+			folderChain: descendant.folderChain ?? [],
+			ownSlug: descendant.ownSlug,
+			folderId: body._id,
+			previousFolderSlug,
+			previousParentPath: previousParent?.path ?? null,
+		});
+
+		if (!paths) {
+			console.error("Revalidation: unresolvable folder chain", descendant._id);
+			continue;
+		}
+
+		movedIds.push(descendant._id);
+		bustPage(paths.current);
+		bustPage(paths.previous);
+	}
+
+	// Pages linking into the subtree inline the old slugs too.
+	return getPagesReferencing(movedIds);
+};
+
+const getAffectedPageSlugsForWebhook = async (body: RevalidateWebhookBody) => {
+	const pages: Array<string | null> = [];
+
+	if (body._type === "page" && body.before) {
+		const previousSlug = await resolvePageSlug(body.before);
+
+		// Resolved, not raw: a moved page keeps its own slug but vacates its URL.
+		const vacated =
+			body.operation === "delete" ||
+			(body.operation === "update" &&
+				previousSlug !== (await resolvePageSlug(body.after)));
+
+		if (vacated && previousSlug !== undefined) bustPage(previousSlug);
+	}
+
+	// If the document is a page, get its slug
+	if (body._type === "page") {
+		const data = await getCanonicalPageSlug(body._id);
+		if (data !== null) pages.push(data);
+	}
+
+	// Page-builder blocks, `author`, `blogCategory` and other pages are all
+	// inlined into pages that no other branch here revalidates.
+	if (referenceableTypes.has(body._type)) {
+		pages.push(...(await getPagesReferencing([body._id])));
+	}
+
+	if (body._type === "pageFolder") {
+		pages.push(...(await revalidateFolderSubtree(body)));
+	}
+
+	return [...new Set(pages.filter((page): page is string => page !== null))];
+};
+
+export async function POST(request: NextRequest) {
+	try {
+		const { body, isValidSignature } = await parseBody<RevalidateWebhookBody>(
+			request,
+			process.env.SANITY_REVALIDATE_SECRET,
+		);
+
+		if (!isValidSignature) return new Response(...ERRORS.INVALID_SIG);
+
+		// Ahead of the `_type`/`_id` guard: a purge payload carries neither. The hatch
+		// for a missed `cacheTag`, which the ~1y cacheLife would otherwise freeze.
+		if (body?.purgeAll) {
+			// Enumerated here so PURGEABLE_TAGS stays query-free. Without this the hatch
+			// never reached page entries or /api/<slug>.md.
+			const slugs = await getAllPageSlugs();
+
+			bustTags(PURGEABLE_TAGS);
+			for (const slug of slugs) bustPage(slug);
+
+			return NextResponse.json({
+				status: 200,
+				now: Date.now(),
+				purged: PURGEABLE_TAGS.length + slugs.length,
+				pages: slugs.length,
+			});
+		}
+
+		if (!(body?._type && body._id)) return new Response(...ERRORS.BAD_REQ);
+		if (body._id.startsWith("drafts."))
+			return NextResponse.json({ status: 200, now: Date.now(), skipped: true });
+
+		const affectedPageSlugs = await getAffectedPageSlugsForWebhook(body);
+
+		for (const slug of affectedPageSlugs) {
+			bustPage(slug);
+		}
+
+		// Layout singletons and redirects are tagged with their own `_type`.
+		if (SELF_TAGGED_TYPES.has(body._type)) revalidateTag(body._type, PURGE);
+
+		// Queries that read across document types — a `structuredData` entry that
+		// folds in `companyData`, a navbar that derefs pages.
+		bustTags(CROSS_DOC_TAG_DEPENDENCIES[body._type] ?? []);
+
+		// The content-collection block caches list/count/categories under their own
+		// tags, which no per-page revalidation above touches.
+		if (BLOG_COLLECTION_TYPES.has(body._type)) bustTags(BLOG_COLLECTION_TAGS);
+
+		return NextResponse.json({ status: 200, now: Date.now() });
+	} catch (error) {
+		console.error("Revalidation error:", error);
+		return new Response("Internal Server Error", { status: 500 });
+	}
+}