bsmnt 0.9.0 → 0.11.0

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

@@ -1,16 +1,37 @@
 import { revalidatePath, revalidateTag } from "next/cache";
 import { type NextRequest, NextResponse } from "next/server";
 import { parseBody } from "next-sanity/webhook";
-import { client } from "@/lib/integrations/sanity/client";
+// `directClient`, never `client`: the shared client runs `useCdn: true`, and every
+// lookup here reads state the mutation that triggered this request just produced.
+// A CDN hit returns the pre-mutation slug or folder chain, which purges the old
+// path twice and never touches the new one.
+import { directClient } from "@/lib/integrations/sanity/client";
 import { SANITY_LAYOUT_TAGS } from "@/lib/integrations/sanity/fetchers/layout";
 import { SANITY_REDIRECTS_TAG } from "@/lib/integrations/sanity/fetchers/redirects";
 import { pageBuilderReferenceMembers as pbrm } from "@/lib/integrations/sanity/page-builder-config";
 import {
-	P_REF_PB_COMP_QUERY,
+	FOLDER_PATH_QUERY,
+	P_REF_DOC_PAGES_QUERY,
+	P_REV_FOLDER_DESCENDANTS_QUERY,
 	P_REV_SLUGS_QUERY,
 } from "@/lib/integrations/sanity/queries";
-import type { P_REF_PB_COMP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import {
+	composeDescendantPaths,
+	composeResolvedSlug,
+} from "@/lib/integrations/sanity/revalidate-paths";
+import type {
+	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,
+	REFERENCEABLE_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 }],
@@ -21,11 +42,16 @@ type WebhookSlug = {
 	current?: string | null;
 };
 
+type WebhookReference = {
+	_ref?: string | null;
+};
+
 type WebhookDocument = {
 	_id: string;
 	_type: string;
-	resolvedSlug?: string | null;
 	slug?: WebhookSlug | null;
+	pageFolder?: WebhookReference | null;
+	parentFolder?: WebhookReference | null;
 };
 
 type MutationOperation = "create" | "update" | "delete";
@@ -36,7 +62,27 @@ type RevalidateWebhookBody = WebhookDocument & {
 	after?: Partial<WebhookDocument> | null;
 };
 
-const pageBuilderComponent = new Set<string>(pbrm.map((m) => m.documentType));
+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, not the one after.
+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, which answers 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;
@@ -45,9 +91,9 @@ const normalizeRevalidationSlug = (slug: string | null | undefined) => {
 };
 
 const getCanonicalPageSlug = async (documentId: string) => {
-	if (!client) return null;
+	if (!directClient) return null;
 
-	const pageSlugs = await client.fetch<Array<{ slug: string | null }>>(
+	const pageSlugs = await directClient.fetch<Array<{ slug: string | null }>>(
 		P_REV_SLUGS_QUERY,
 		{ documentIds: [documentId] },
 	);
@@ -57,24 +103,114 @@ const getCanonicalPageSlug = async (documentId: string) => {
 	);
 };
 
-const getPagesThatReferenceComp = async (documentId: string) => {
-	if (!client) return [];
+const getFolder = async (folderId: string | null | undefined) => {
+	if (!(directClient && folderId)) return null;
 
-	const pages = await client.fetch<P_REF_PB_COMP_QUERY_RESULT>(
-		P_REF_PB_COMP_QUERY,
-		{
-			documentId,
-		},
+	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));
 };
 
+// The webhook carries the raw document, so a page's URL has to be rebuilt from
+// its folder — `slug.current` alone is the page's own segment, which is empty
+// for a folder-index page and missing the prefix for every nested one.
+//
+// `undefined` means "no such revision", distinct from the `null` that a page at
+// the site root legitimately resolves to. Without that split, a payload missing
+// its `before()` projection would purge the homepage on every delete.
+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 rename or reparent rewrites the URL of everything beneath it. Neither
+// the folder nor its descendants are `page` mutations, so nothing else in this
+// route 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 folder edit that touches neither the slug nor the parent — a title, say —
+	// changes no URL. `pageFolder` still busts the navbar and collection tags
+	// through CROSS_DOC_TAG_DEPENDENCIES below.
+	//
+	// Deletion is skipped outright: `pageFolder` and `parentFolder` are plain hard
+	// references, so Sanity refuses to delete a folder that still has descendants.
+	// There is no orphaned subtree to unwind, and querying for one would just cost
+	// two round trips to find nothing.
+	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 resolved slugs too.
+	return getPagesReferencing(movedIds);
+};
+
 const getAffectedPageSlugsForWebhook = async (body: RevalidateWebhookBody) => {
 	const pages: Array<string | null> = [];
 
-	if (body.operation === "delete" && body?.before?.slug?.current) {
-		revalidateTag(body.before.slug.current, "max");
+	if (body._type === "page" && body.before) {
+		const previousSlug = await resolvePageSlug(body.before);
+
+		// Resolved, not raw: a page moved to another folder keeps its own slug and
+		// still vacates its old URL, so comparing own slugs would miss it.
+		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
@@ -83,13 +219,17 @@ const getAffectedPageSlugsForWebhook = async (body: RevalidateWebhookBody) => {
 		if (data !== null) pages.push(data);
 	}
 
-	// If the document is a page builder component, get the page slugs that reference it
-	if (pageBuilderComponent.has(body._type)) {
-		const data = await getPagesThatReferenceComp(body._id);
-		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])));
 	}
 
-	return pages.filter((page): page is string => page !== null);
+	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) {
@@ -107,15 +247,23 @@ export async function POST(request: NextRequest) {
 		const affectedPageSlugs = await getAffectedPageSlugsForWebhook(body);
 
 		for (const slug of affectedPageSlugs) {
-			revalidatePath(getPagePath(slug));
+			bustPage(slug);
 		}
 
 		if (SANITY_LAYOUT_TAGS.includes(body?._type)) {
-			revalidateTag(body._type, "max");
+			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);
+
 		if (body._type === SANITY_REDIRECTS_TAG) {
-			revalidateTag(SANITY_REDIRECTS_TAG, "max");
+			revalidateTag(SANITY_REDIRECTS_TAG, PURGE);
 		}
 
 		return NextResponse.json({ status: 200, now: Date.now() });

package/src/modules/features/cms/sanity-pagebuilder/files/app/feed.xml/route.ts

@@ -1,20 +1,27 @@
+import { fetchSanity } from "@/lib/integrations/sanity/live";
 import { ALL_BLOG_ARTICLES_QUERY } from "@/lib/integrations/sanity/queries";
+import type { ALL_BLOG_ARTICLES_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import { FEED_TAG } from "@/lib/integrations/sanity/tags";
 import { generateRssFeed, rssErrorResponse } from "@/lib/utils/rss";
 import { getPageUrl, getSitemapBaseUrl } from "@/lib/utils/sitemap";
 
-export const dynamic = "force-dynamic";
-
+// Not `force-dynamic`: feed readers poll, so per-request rendering charged a
+// Sanity round trip per poll. The webhook busts FEED_TAG for `page`, `pageFolder`,
+// `author` and `blogCategory` — this query derefs the byline and resolves slugs
+// through folder chains.
 export async function GET() {
 	const baseUrl = getSitemapBaseUrl();
 
 	try {
-		const sanityModule = await import("@/lib/integrations/sanity/client");
-		const client = sanityModule?.client;
-		if (!client) return rssErrorResponse();
+		const { data: articles } =
+			await fetchSanity<ALL_BLOG_ARTICLES_QUERY_RESULT>({
+				query: ALL_BLOG_ARTICLES_QUERY,
+				tags: [FEED_TAG],
+			});
 
-		const articles = await client.fetch(ALL_BLOG_ARTICLES_QUERY);
+		if (!articles) return rssErrorResponse();
 
-		const items = (articles ?? [])
+		const items = articles
 			.filter((article) => article.resolvedSlug && !article.noIndex)
 			.map((article) => ({
 				title: article.title ?? "Untitled",

package/src/modules/features/cms/sanity-pagebuilder/files/app/sitemap.md/route.ts

@@ -7,7 +7,8 @@ import {
 	getSitemapBaseUrl,
 } from "@/lib/utils/sitemap";
 
-export const dynamic = "force-dynamic";
+// Cached, not per-request: this bills itself as being for AI agents, so its
+// traffic is crawler-driven. `getSitemap` tags the read; the webhook busts it.
 
 type PageDoc = PAGE_SITEMAP_QUERY_RESULT[number];
 
@@ -113,7 +114,12 @@ export const GET = async () => {
 
 		if (pages.length === 0) parts.push("No content published yet.", "");
 
-		return new NextResponse(parts.join("\n"));
+		return new NextResponse(parts.join("\n"), {
+			headers: {
+				"Content-Type": "text/markdown; charset=utf-8",
+				"X-Content-Type-Options": "nosniff",
+			},
+		});
 	} catch (error) {
 		console.error("Error generating sitemap.md:", error);
 		return new NextResponse("# Sitemap\n\nError fetching content.", {

package/src/modules/features/cms/sanity-pagebuilder/files/app/studio/[[...tool]]/page.tsx

@@ -1,8 +1,23 @@
 "use client";
 
 import { NextStudio } from "next-sanity/studio";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
 import config from "@/lib/integrations/sanity/sanity.config";
 
-const StudioPage = () => <NextStudio config={config} />;
+// The Studio throws on an empty `projectId`, which `env.ts` falls back to when
+// Sanity isn't configured — so this route would fail `next build`.
+const StudioPage = () =>
+	isSanityConfigured() ? (
+		<NextStudio config={config} />
+	) : (
+		<main style={{ padding: "2rem", fontFamily: "system-ui, sans-serif" }}>
+			<h1>Studio unavailable</h1>
+			<p>
+				Set <code>NEXT_PUBLIC_SANITY_PROJECT_ID</code> and{" "}
+				<code>NEXT_PUBLIC_SANITY_DATASET</code>, then restart, to load the
+				embedded Studio.
+			</p>
+		</main>
+	);
 
 export default StudioPage;

package/src/modules/features/cms/sanity-pagebuilder/files/components/sanity/rich-text.tsx

@@ -26,6 +26,7 @@ const LinkMark = ({ children, value }: LinkMarkProps) => {
 			href={href}
 			target={attrs.target}
 			rel={attrs.rel}
+			className="text-blue underline underline-offset-2 transition-opacity hover:opacity-70"
 			data-sanity-edit-target
 		>
 			{children}

package/src/modules/features/cms/sanity-pagebuilder/files/components/sanity/visual-editing.tsx

@@ -1,7 +1,6 @@
 import { draftMode } from "next/headers";
 import { VisualEditing } from "next-sanity/visual-editing";
 import { Suspense } from "react";
-import { refreshAction } from "@/app/actions/refresh";
 import { DraftModeToggle } from "@/components/sanity/draft-mode-toggle";
 import { isSanityConfigured } from "@/lib/integrations/check-integration";
 import { SanityLive } from "@/lib/integrations/sanity/live";
@@ -16,7 +15,8 @@ async function VisualEditingInner() {
 		<>
 			<DraftModeToggle />
 			<VisualEditing />
-			<SanityLive action={refreshAction} />
+			{/* No `action`: in draft mode the default is already `"refresh"`. */}
+			<SanityLive />
 		</>
 	);
 }

package/src/modules/features/cms/sanity-pagebuilder/files/components/ui/sanity-image/index.tsx

@@ -10,7 +10,7 @@ interface SanityImageProps extends Omit<ImageProps, "src" | "aspectRatio"> {
 		};
 		alt?: string;
 		hotspot?: object;
-		crop?: object;
+		crop?: { left?: number; right?: number; top?: number; bottom?: number };
 	};
 	maxWidth?: number;
 }
@@ -24,16 +24,26 @@ export function SanityImage({
 }: SanityImageProps) {
 	if (!image?.asset) return null;
 
+	// getImageDimensions is uncropped; the URL builder applies the crop.
+	// Rounding order must match @sanity/image-url: origin first, then subtract.
 	const { width, height } = getImageDimensions(image.asset);
-	const aspectRatio = width / height;
+	const { left = 0, right = 0, top = 0, bottom = 0 } = image.crop ?? {};
+	const cropLeft = Math.round(left * width);
+	const cropTop = Math.round(top * height);
+	const sourceWidth = Math.round(width - right * width - cropLeft);
+	const sourceHeight = Math.round(height - bottom * height - cropTop);
 
-	const imageProps = fill ? { fill: true } : { width, height };
+	const imageProps = fill
+		? { fill: true }
+		: { width: sourceWidth, height: sourceHeight };
 
 	return (
 		<Image
-			src={urlForImage(image).width(maxWidth).url()}
+			src={urlForImage(image)
+				.width(Math.min(maxWidth, sourceWidth))
+				.url()}
 			alt={alt || image.alt || ""}
-			aspectRatio={aspectRatio}
+			aspectRatio={sourceWidth / sourceHeight}
 			{...imageProps}
 			{...props}
 		/>

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

@@ -1,5 +1,6 @@
-export const isSanityConfigured = () =>
-	Boolean(
-		process.env.NEXT_PUBLIC_SANITY_PROJECT_ID &&
-			process.env.NEXT_PUBLIC_SANITY_DATASET,
-	);
+import { dataset, projectId } from "@/lib/integrations/sanity/env";
+
+// Derived from env.ts, not a second read of `process.env`. Read directly these
+// disagreed — env.ts also accepts `SANITY_STUDIO_PROJECT_ID` and defaults the
+// dataset — so a resolvable project reported itself unconfigured.
+export const isSanityConfigured = () => Boolean(projectId && dataset);

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

@@ -25,3 +25,11 @@ export const client: SanityClient | null = isSanityConfigured()
 			},
 		})
 	: null;
+
+/**
+ * Non-CDN clone for the publish webhook, which has to see the mutation it was
+ * notified about rather than whatever the CDN still holds. Reading a stale slug
+ * there invalidates the old path and misses the new one.
+ */
+export const directClient: SanityClient | null =
+	client?.withConfig({ useCdn: false }) ?? null;

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/components/slug-field.tsx

@@ -1,18 +1,24 @@
+import { Stack } from "@sanity/ui";
 import { type FieldProps, useFormValue } from "sanity";
+import { SlugRedirectNotice } from "@/lib/integrations/sanity/components/slug-notices";
 import { getPinnedPageById } from "@/lib/integrations/sanity/pinned-pages";
 
 const DEFAULT_DESCRIPTION = "URL path without leading slash.";
 const PINNED_DESCRIPTION =
 	"URL path without leading slash. Disabled on 📌 pinned pages.";
 
-// Swaps the slug description to a locked-state note on pinned pages.
-// (Sanity descriptions are plain strings, hence the 📌 character.)
+// Swaps the slug description on pinned pages (plain-string field, hence 📌).
 export function SlugField(props: FieldProps) {
 	const documentId = useFormValue(["_id"]) as string | undefined;
-	const isPinned = getPinnedPageById(documentId) !== null;
+	const pinned = getPinnedPageById(documentId);
 
-	return props.renderDefault({
-		...props,
-		description: isPinned ? PINNED_DESCRIPTION : DEFAULT_DESCRIPTION,
-	});
+	return (
+		<Stack space={3}>
+			{props.renderDefault({
+				...props,
+				description: pinned ? PINNED_DESCRIPTION : DEFAULT_DESCRIPTION,
+			})}
+			<SlugRedirectNotice pinnedPath={pinned?.path} />
+		</Stack>
+	);
 }

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/components/slug-notices.tsx

@@ -0,0 +1,125 @@
+import { Box, Button, Card, Stack, Text } from "@sanity/ui";
+import { useEffect, useState } from "react";
+import { useClient, useFormValue } from "sanity";
+import { useRouter } from "sanity/router";
+import { apiVersion } from "@/lib/integrations/sanity/env";
+import { isEmptyPageSlug } from "@/lib/integrations/sanity/page-category";
+import { FOLDER_PATH_QUERY } from "@/lib/integrations/sanity/queries";
+
+const REDIRECT_QUERY = `*[_type == "redirect" && source.current == $source][0]._id`;
+
+// The slug field writes on every keystroke.
+const LOOKUP_DEBOUNCE_MS = 400;
+
+interface SlugRedirectNoticeProps {
+	/** Public path of a pinned page, whose URL is fixed rather than slug-derived. */
+	pinnedPath?: string | undefined;
+}
+
+/**
+ * Warns when a published redirect claims this page's URL — the catch-all
+ * route only runs `checkRedirect` after a page lookup misses, so the page
+ * wins and the redirect silently never fires.
+ *
+ * Reads the `page` form shape; don't reuse for other slug types.
+ */
+export function SlugRedirectNotice({ pinnedPath }: SlugRedirectNoticeProps) {
+	const client = useClient({ apiVersion });
+	const router = useRouter();
+	const slug = useFormValue(["slug", "current"]) as string | undefined;
+	const folderId = useFormValue(["pageFolder", "_ref"]) as string | undefined;
+	const [folderPath, setFolderPath] = useState("");
+	const [redirectId, setRedirectId] = useState<string | null>(null);
+
+	// Separate effect so the folder chain isn't re-resolved on every keystroke.
+	useEffect(() => {
+		if (!folderId) {
+			setFolderPath("");
+			return;
+		}
+
+		let active = true;
+		const published = client.withConfig({ perspective: "published" });
+
+		published
+			// Leaf joins in JS below, so this tracks the live slug rather than the
+			// last saved draft.
+			.fetch<{ path: string | null } | null>(FOLDER_PATH_QUERY, { folderId })
+			.then((folder) => {
+				if (active) setFolderPath(folder?.path ?? "");
+			})
+			.catch(() => {
+				if (active) setFolderPath("");
+			});
+
+		return () => {
+			active = false;
+		};
+	}, [client, folderId]);
+
+	useEffect(() => {
+		const leaf = isEmptyPageSlug(slug) ? "" : slug;
+		const source = pinnedPath
+			? pinnedPath.replace(/^\/+/, "")
+			: [folderPath, leaf].filter(Boolean).join("/");
+
+		if (!source) {
+			setRedirectId(null);
+			return;
+		}
+
+		let active = true;
+		// Drafts never reach visitors, so an unpublished redirect isn't a conflict.
+		const published = client.withConfig({ perspective: "published" });
+
+		const timer = setTimeout(async () => {
+			try {
+				const id = await published.fetch<string | null>(REDIRECT_QUERY, {
+					source,
+				});
+				if (active) setRedirectId(id);
+			} catch {
+				if (active) setRedirectId(null);
+			}
+		}, LOOKUP_DEBOUNCE_MS);
+
+		return () => {
+			active = false;
+			clearTimeout(timer);
+		};
+	}, [client, folderPath, pinnedPath, slug]);
+
+	if (!redirectId) return null;
+
+	return (
+		<Card border padding={3} radius={2} tone="caution">
+			<Stack space={3}>
+				<Stack space={2}>
+					<Text size={1} weight="semibold">
+						A redirect already claims this URL
+					</Text>
+					<Text muted size={1}>
+						Visitors reach this page instead — a redirect only runs when no page
+						matches its path. Remove the redirect, or move this page to another
+						slug.
+					</Text>
+				</Stack>
+				<Box>
+					<Button
+						fontSize={1}
+						mode="ghost"
+						onClick={() =>
+							router.navigateIntent("edit", {
+								id: redirectId,
+								type: "redirect",
+							})
+						}
+						padding={3}
+						text="Go to redirect"
+						tone="caution"
+					/>
+				</Box>
+			</Stack>
+		</Card>
+	);
+}

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

@@ -6,9 +6,9 @@
  * if Sanity is properly set up before making API calls.
  */
 
-/** Sanity API version - defaults to latest stable */
+/** Floor, not a preference: Content Releases need 2025-02-19 or later. */
 export const apiVersion =
-	process.env.NEXT_PUBLIC_SANITY_API_VERSION || "2024-03-15";
+	process.env.NEXT_PUBLIC_SANITY_API_VERSION || "2025-02-19";
 
 /** Sanity dataset name - defaults to 'production' */
 export const dataset = process.env.NEXT_PUBLIC_SANITY_DATASET || "production";