camox 0.47.0 → 0.51.0

package/dist/features/runtime/runtime.js

@@ -5,24 +5,37 @@ import { UNNAMED_DEFAULT_LOCALE, localizedPath, parseLocalePath } from "../../li
 import { draftNamedBy } from "../../lib/draft-scope.js";
 import { RUNTIME_ROUTE_PATHS, matchRuntimeOwnedRoute } from "./runtimeRoutes.js";
 import { reads } from "../../lib/studio-reads.js";
-import { asCollectionItem, recordMarkdownTemplate, recordPlainText } from "../../core/recordItem.js";
+import { asCollectionItem, recordMarkdownTemplate, recordPageValues } from "../../core/recordItem.js";
+import { buildLayoutContext, curatedLayoutContext } from "../../core/layoutContext.js";
 import { PLATFORM_SCRIPT } from "../../lib/platform.js";
-import { STUDIO_ASSETS_PATH, STUDIO_CANVAS_PATH, STUDIO_CONTENT_PATH, matchCollectionContentPath } from "../studio/routes.js";
+import { STUDIO_ASSETS_PATH, STUDIO_CANVAS_PATH, STUDIO_CONTENT_PATH, STUDIO_SETTINGS_PATH, matchCollectionContentPath } from "../studio/routes.js";
 import { STUDIO_THEME_SCRIPT } from "../studio/studioTheme.js";
+import { DefaultPageImage, renderPageImage } from "../og/pageImage.js";
 import { discoverLayoutPages, matchDerivedLayout } from "../../core/derivedRoutes.js";
-import { buildCamoxPageHead, buildFaviconUrl, buildPageHead, buildPageMeta, createMarkdownResponse, createServerApiClient, createServerStudioCache, isNotFoundError, loadCamoxPageForRequest, parseMarkdownPath, prefersMarkdown, readDraftOrLive, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter } from "../routes/pageRuntime.js";
+import { buildCamoxPageHead, buildFaviconUrl, buildPageHead, buildPageMeta, createServerApiClient, createServerStudioCache, curatedMarkdownResponse, declarePage, isNotFoundError, loadCamoxPageForRequest, parseMarkdownPath, prefersMarkdown, readDraftOrLive, readPageMarkdown, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter } from "../routes/pageRuntime.js";
 import { alternatesByPage, findAlternates, hreflangLinks } from "./alternates.js";
 import { configuredProviders, renderAnalyticsScripts } from "./analytics.js";
 import { omitArtifactSources } from "./artifactSources.js";
+import { readBreadcrumb } from "./breadcrumbs.js";
 import { RouteDiscoveryError, listLivePages } from "./livePages.js";
 import { formatLlmsTxt } from "./llmsTxt.js";
 import { getPageBlockTypes } from "./pageBlockTypes.js";
+import { withPageUrls } from "./structuredData.js";
+import { curatedPageDescription, pageRecords, placedBlockNodes, withStructuredData } from "./pageGraph.js";
+import { createProjectLogoResponse, projectLogo } from "./projectLogo.js";
 import { DEVELOPMENT_DRAFT, LOCALE_HEADER } from "@camox/api-contract/drafts";
 import { QueryClient, dehydrate } from "@tanstack/react-query";
 import { createHead, renderSSRHead } from "@unhead/react/server";
 
 //#region src/features/runtime/runtime.ts
 const DEFAULT_RUNTIME_BASE_PATH = "";
+/** The studio's own routes, rather than a page or the Canvas. */
+const STUDIO_ROUTE_KINDS = [
+	"studio",
+	"studio-content",
+	"studio-settings",
+	"studio-nested"
+];
 function normalizeRuntimeBasePath(basePath) {
 	if (basePath === void 0) return DEFAULT_RUNTIME_BASE_PATH;
 	if (!basePath || basePath === "/") return "";
@@ -51,6 +64,26 @@ function getRequestDraftId(request, options) {
 function isPrivateRender(request, options) {
 	return !!getServerAuthCookieHeader(request.headers) || getRequestDraftId(request, options) !== void 0;
 }
+/** The routes whose response is the same for every visitor, unless the request is private. */
+const PUBLIC_ROUTE_KINDS = /* @__PURE__ */ new Set([
+	"page",
+	"data",
+	"og",
+	"logo",
+	"sitemap",
+	"llms-txt"
+]);
+/**
+* Whether a request reads what every visitor sees, so a shared cache may answer it: a GET or
+* HEAD of a page or a public output, with no session, no draft named and no preview handoff. A
+* response that comes out private all the same, such as the Studio's, still says so.
+*/
+function isPublicRequest(request, options = {}) {
+	if (request.method !== "GET" && request.method !== "HEAD") return false;
+	if (isPrivateRender(request, options) || isPreviewHandoff(request, options)) return false;
+	const pathname = getRuntimePathname(request.url, options.runtimeBasePath);
+	return pathname !== null && PUBLIC_ROUTE_KINDS.has(matchRuntimeRoute(pathname).kind);
+}
 function escapeXml(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
 }
@@ -84,6 +117,10 @@ function matchRuntimeRoute(pathname) {
 		kind: "studio-content",
 		pathname
 	};
+	if (pathname === "/camox/settings" || pathname === `${"/camox/settings"}/`) return {
+		kind: "studio-settings",
+		pathname
+	};
 	if (pathname.startsWith("/camox/")) return {
 		kind: "studio-nested",
 		pathname
@@ -151,15 +188,22 @@ function absoluteUrl(request, options) {
 	const { origin } = new URL(request.url);
 	return (path) => `${origin}${withRuntimeBasePath(path, options.runtimeBasePath)}`;
 }
+/** An ETag derived from `text`. */
+async function etagOf(text) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+	return `"${[...new Uint8Array(digest)].slice(0, 16).map((byte) => byte.toString(16).padStart(2, "0")).join("")}"`;
+}
+/** Whether the request's `If-None-Match` names `etag`, so a 304 answers it. */
+function namesEtag(request, etag) {
+	return (request.headers.get("If-None-Match") ?? "").split(",").map((tag) => tag.trim().replace(/^W\//, "")).some((tag) => tag === etag || tag === "*");
+}
 /** `body` with an ETag derived from it, or a 304 when the request's `If-None-Match` names it. */
 async function withEtag(request, body, headers) {
-	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
-	const etag = `"${[...new Uint8Array(digest)].slice(0, 16).map((byte) => byte.toString(16).padStart(2, "0")).join("")}"`;
 	const taggedHeaders = {
 		...headers,
-		ETag: etag
+		ETag: await etagOf(body)
 	};
-	if ((request.headers.get("If-None-Match") ?? "").split(",").map((tag) => tag.trim().replace(/^W\//, "")).some((tag) => tag === etag || tag === "*")) return new Response(null, {
+	if (namesEtag(request, taggedHeaders.ETag)) return new Response(null, {
 		status: 304,
 		headers: taggedHeaders
 	});
@@ -171,10 +215,7 @@ function createLlmsTxtResponse(request, options) {
 		pages: website.localizations[0].pages,
 		layouts: (website.app?.getLayouts() ?? []).map(({ _internal }) => _internal),
 		url: absoluteUrl(request, options)
-	}), {
-		"Content-Type": "text/plain; charset=utf-8",
-		"Cache-Control": "public, max-age=300, stale-while-revalidate=3600"
-	}));
+	}), { "Content-Type": "text/plain; charset=utf-8" }));
 }
 /** Tells LLM tools fetching a page's HTML where the website's llms.txt is. */
 function llmsTxtLinkHeader(options) {
@@ -250,21 +291,94 @@ async function createRoutesResponse(request, options) {
 		});
 	}
 }
+/**
+* The image of the page `/og?path=` names, by its path with its locale's prefix: its layout's
+* `toImage`, or Camox's default image, rendered with the page's context. Only real pages have
+* one, read as the page itself would be, in the draft the URL names for a member.
+*/
 async function createOgResponse(request, options) {
 	const camoxApp = await options.getCamoxApp?.();
 	if (!camoxApp) return Response.json({ message: "Camox app registry is not available." }, { status: 500 });
-	const url = new URL(request.url);
-	const layoutId = url.searchParams.get("layoutId") || "";
-	const title = url.searchParams.get("title") || "";
-	const description = url.searchParams.get("description") || "";
-	const projectName = url.searchParams.get("projectName") || "";
-	const layout = camoxApp.getLayoutById(layoutId);
-	if (!layout?._internal.buildOgImage) return new Response("Not found", { status: 404 });
-	return layout._internal.buildOgImage({
-		title,
-		description,
-		projectName
+	const source = await readPageImageSource(request, options, camoxApp);
+	if (!source) return new Response("Not found", { status: 404 });
+	const headers = {
+		ETag: await etagOf(JSON.stringify([source.layout?.id ?? null, source.context])),
+		"Cache-Control": isPrivateRender(request, options) ? "private, no-store" : "public, no-cache"
+	};
+	if (namesEtag(request, headers.ETag)) return new Response(null, {
+		status: 304,
+		headers
 	});
+	const toImage = source.layout?.toImage ?? DefaultPageImage;
+	const image = await renderPageImage(toImage(source.context));
+	for (const [name, value] of Object.entries(headers)) image.headers.set(name, value);
+	return image;
+}
+/** The layout and context of the page `/og` names, or null when it names no page. */
+async function readPageImageSource(request, options, app) {
+	const { apiUrl, projectUuid } = options;
+	const path = new URL(request.url).searchParams.get("path");
+	if (!apiUrl || !projectUuid || !path?.startsWith("/")) return null;
+	const located = await locateRequest(request, options, path);
+	if (matchLocalizedRoute(located.path)?.kind !== "page") return null;
+	const { project } = await resolveRequestMember(request, options);
+	const member = project !== void 0;
+	const authCookieHeader = member ? getServerAuthCookieHeader(request.headers) : void 0;
+	const requestedDraft = getRequestDraftId(request, options);
+	const api = (draftId) => createServerApiClient(apiUrl, {
+		authCookieHeader,
+		draftId,
+		locale: located.locale
+	});
+	const match = matchDerivedLayout(app.getLayouts(), located.path);
+	/** A code-owned page: its loader runs in the draft the layout read settled on. */
+	const codeOwned = async (match) => {
+		const layout = match.layout._internal;
+		const { value: shared, draftId } = await readDraftOrLive(requestedDraft, member, (draftId) => api(draftId).layouts.get({
+			projectUuid,
+			layoutId: layout.id
+		}));
+		const result = await loadLayoutResult(app, match, createLayoutRequestContext(options, member ? "draft" : "live", {
+			authCookieHeader,
+			draftId,
+			locale: located.locale
+		}), located.locale);
+		const record = asCollectionItem(result);
+		const collection = record && app.getCollectionById(record.collectionId);
+		return {
+			layout,
+			context: buildLayoutContext(layout, {
+				path,
+				locale: located.locale.tag,
+				projectName: shared.projectName,
+				data: result?.data,
+				params: match.params,
+				record: record && collection ? recordPageValues(collection, record) : void 0
+			})
+		};
+	};
+	/** A curated page, or else a derived layout's page, as the page's HTML falls back. */
+	const curated = async () => {
+		try {
+			const { value: page } = await readDraftOrLive(requestedDraft, member, (draftId) => api(draftId).pages.getByPath({
+				path: located.path,
+				projectUuid
+			}));
+			return {
+				layout: page.layout ? app.getLayoutById(page.layout.layoutId)?._internal : void 0,
+				context: curatedLayoutContext(page, located.locale)
+			};
+		} catch (error) {
+			if (isNotFoundError(error) && match) return codeOwned(match);
+			throw error;
+		}
+	};
+	try {
+		return match?.layout._internal.kind === "singleton" ? await codeOwned(match) : await curated();
+	} catch (error) {
+		if (isNotFoundError(error)) return null;
+		throw error;
+	}
 }
 function createDefaultHeadInput(stylesheetUrl) {
 	return {
@@ -303,9 +417,9 @@ function createPageHeadInput(head) {
 	const pageLinks = [];
 	for (const entry of links) {
 		if (!entry.href) continue;
-		if (entry.rel === "icon") {
+		if (entry.rel === "icon" || entry.rel === "canonical") {
 			pageLinks.push({
-				rel: "icon",
+				rel: entry.rel,
 				href: entry.href,
 				"data-camox-page-head": "true"
 			});
@@ -319,10 +433,16 @@ function createPageHeadInput(head) {
 			"data-camox-page-head": "true"
 		});
 	}
+	const pageScripts = (head.scripts ?? []).filter((entry) => entry.type === "application/ld+json").map((entry) => ({
+		type: "application/ld+json",
+		innerHTML: entry.text,
+		"data-camox-page-head": "true"
+	}));
 	return {
 		...title && { title },
 		meta: pageMeta,
-		link: pageLinks
+		link: pageLinks,
+		script: pageScripts
 	};
 }
 function renderHead(document, pageHead, stylesheetUrl, studioStylesheetUrl, locale) {
@@ -400,16 +520,114 @@ function isPreviewHandoff(request, options) {
 * The alternates of the page a request renders, where it exists in each of the scope's locales,
 * and its head with their `hreflang` links. Without a head, there is none to add them to.
 */
-async function readAlternates(request, options, { located, identity, head, ...reading }) {
-	const alternates = await findRequestAlternates(options, located, identity, reading);
-	const links = hreflangLinks(alternates, located.locales, absoluteUrl(request, options));
+async function readAlternates(request, options, { located, identity, head, described, localeReads }) {
+	const [alternates, crumbs] = await Promise.all([findRequestAlternates(options, located, identity, localeReads), head ? readRequestBreadcrumb(options, located, described.title, localeReads) : []]);
+	const url = absoluteUrl(request, options);
+	const links = hreflangLinks(alternates, located.locales, url);
+	const place = {
+		url: url(localizedPath(located.path, located.locale)),
+		locale: located.locale.tag,
+		alternates
+	};
+	const site = {
+		url: url("/"),
+		name: described.project.name,
+		logo: projectLogo(url, described.project),
+		socialProfiles: described.project.socialProfiles ?? []
+	};
+	const breadcrumb = crumbs.map((crumb) => ({
+		name: crumb.name,
+		url: url(localizedPath(crumb.path, located.locale))
+	}));
+	const defaultLocale = located.locales.find((locale) => locale.isDefault) ?? located.locale;
+	const pageUrl = (marker) => {
+		const locale = located.locales.find((candidate) => candidate.tag === marker.locale);
+		return url(localizedPath(marker.path, locale ?? defaultLocale));
+	};
+	const blocks = withPageUrls(described.blocks ?? [], pageUrl);
+	const localeHome = url(localizedPath("/", located.locale));
+	const records = described.records && {
+		...described.records,
+		nodes: withPageUrls(described.records.nodes, pageUrl),
+		id: (recordId) => `${localeHome}#record-${recordId}`
+	};
 	return {
 		alternates,
-		head: head && withHreflangs(head, links)
+		head: head && withStructuredData(withLocatedTags(withHreflangs(head, links), place), place, site, {
+			...described,
+			breadcrumb,
+			blocks,
+			records
+		})
+	};
+}
+/** An Open Graph locale: a locale tag with an underscore, as in `de_CH`. */
+const ogLocale = (tag) => tag.replaceAll("-", "_");
+/**
+* A page's head with where it is: its canonical URL, which never names a draft, and its locale
+* among the locales it exists in.
+*/
+function withLocatedTags(head, { url, locale, alternates }) {
+	const others = alternates.filter((alternate) => alternate.locale !== locale);
+	return {
+		...head,
+		meta: [
+			...head.meta ?? [],
+			{
+				property: "og:url",
+				content: url
+			},
+			{
+				property: "og:locale",
+				content: ogLocale(locale)
+			},
+			...others.map((other) => ({
+				property: "og:locale:alternate",
+				content: ogLocale(other.locale)
+			}))
+		],
+		links: [...head.links ?? [], {
+			rel: "canonical",
+			href: url
+		}]
+	};
+}
+function requestLocaleReads(options, { authCookieHeader, draftId, queryClient }) {
+	const { apiUrl, projectUuid } = options;
+	const reading = {
+		authCookieHeader: draftId ? authCookieHeader : void 0,
+		draftId
+	};
+	const source = draftId ? "draft" : "live";
+	const pagesByLocale = /* @__PURE__ */ new Map();
+	const studioCache = apiUrl && queryClient ? createServerStudioCache(queryClient, { apiUrl }) : void 0;
+	return {
+		pages: (locale) => {
+			if (!apiUrl || !projectUuid) return Promise.resolve([]);
+			const loaded = studioCache?.get(reads.pageList({ projectUuid }), {
+				in: draftId ?? null,
+				locale
+			});
+			if (loaded) return Promise.resolve(loaded);
+			const read = pagesByLocale.get(locale.tag) ?? createServerApiClient(apiUrl, {
+				...reading,
+				locale
+			}).pages.listBySlug({ projectUuid }).then(({ pages }) => pages);
+			pagesByLocale.set(locale.tag, read);
+			return read;
+		},
+		context: (locale) => createLayoutRequestContext(options, source, {
+			...reading,
+			locale
+		}),
+		records: (locale) => createRecordLookup(options, source, {
+			...reading,
+			locale
+		})
 	};
 }
 /** Where the page a request renders exists in each of the scope's locales: itself alone in one. */
-async function findRequestAlternates(options, located, identity, { authCookieHeader, draftId }) {
+async function findRequestAlternates(options, located, identity, reads) {
 	const { apiUrl, projectUuid } = options;
 	const here = [{
 		locale: located.locale.tag,
@@ -417,26 +635,33 @@ async function findRequestAlternates(options, located, identity, { authCookieHea
 	}];
 	if (!apiUrl || !projectUuid || located.locales.length < 2) return here;
 	const app = await options.getCamoxApp?.();
-	const reading = {
-		authCookieHeader: draftId ? authCookieHeader : void 0,
-		draftId
-	};
 	return findAlternates({
 		identity,
 		located,
 		layouts: app?.getLayouts() ?? [],
-		reads: {
-			pages: async (locale) => (await createServerApiClient(apiUrl, {
-				...reading,
-				locale
-			}).pages.listBySlug({ projectUuid })).pages,
-			context: (locale) => createLayoutRequestContext(options, draftId ? "draft" : "live", {
-				...reading,
-				locale
-			})
-		}
+		reads
 	});
 }
+/**
+* The crumbs of the page a request renders, in its locale. Without them, the page still renders:
+* a breadcrumb that can't be read is left out.
+*/
+async function readRequestBreadcrumb(options, located, title, reads) {
+	try {
+		return await readBreadcrumb({
+			path: located.path,
+			title,
+			app: await options.getCamoxApp?.(),
+			reads: {
+				pages: () => reads.pages(located.locale),
+				records: reads.records(located.locale)
+			}
+		});
+	} catch (error) {
+		console.error("[camox] Couldn't read the page's breadcrumb.", error);
+		return [];
+	}
+}
 /** A page's head with its alternates' `hreflang` links. */
 function withHreflangs(head, hreflangs) {
 	if (!hreflangs.length) return head;
@@ -478,27 +703,89 @@ async function createPreviewHandoffResponse({ options, pathname, request }) {
 		"Referrer-Policy": "no-referrer"
 	} });
 }
-async function createPageHtmlResponse({ options, pathname, located, request }) {
+/** Starts reading the curated page at a locale-relative path, as the request reads it. */
+function readCuratedPage(options, request, { locale, path }) {
+	const queryClient = new QueryClient();
+	return {
+		queryClient,
+		result: loadCamoxPageForRequest({
+			apiUrl: options.apiUrl,
+			authCookieHeader: getServerAuthCookieHeader(request.headers),
+			draftId: getRequestDraftId(request, options),
+			locale,
+			origin: new URL(request.url).origin,
+			pathname: path,
+			projectUuid: options.projectUuid,
+			queryClient
+		})
+	};
+}
+/** A first path segment that could be a locale's prefix: a language tag, in lowercase. */
+const LOCALE_PREFIX_LIKE = /^\/[a-z]{2,3}(?:-[a-z0-9]{1,8})*(?:\/|$)/;
+/**
+* The read of the curated page a path names in the default locale, started while the request's
+* locales are read, or none where it couldn't be the request's page. A default-locale page sits
+* at its own path, so its read needn't wait for the locales: once read, they only confirm the path
+* names no other locale. A path whose first segment looks like a locale's prefix waits for them
+* instead, rather than reading a page it likely doesn't name, and a singleton's path reads no
+* curated page.
+*/
+async function readDefaultLocalePageEarly(options, request, pathname) {
+	const { apiUrl, projectUuid } = options;
+	if (!apiUrl || !projectUuid) return void 0;
+	if (matchLocalizedRoute(pathname)?.kind !== "page" || LOCALE_PREFIX_LIKE.test(pathname)) return;
+	const app = await options.getCamoxApp?.().catch(() => void 0);
+	if (app && matchDerivedLayout(app.getLayouts(), pathname)?.layout._internal.kind === "singleton") return void 0;
+	const read = readCuratedPage({
+		...options,
+		apiUrl,
+		projectUuid
+	}, request, {
+		locale: UNNAMED_DEFAULT_LOCALE,
+		path: pathname
+	});
+	read.result.catch(() => void 0);
+	return read;
+}
+/**
+* The reads of each locale the head of the request's curated page makes, and those it can make
+* while the page is read. When the request reads Live, whatever the page's read finds about its
+* draft, the pages of the locales the page's read doesn't load start loading now. Otherwise they
+* wait for the page's read to settle the draft.
+*/
+function curatedPageLocaleReads(options, request, located, queryClient) {
+	const authCookieHeader = getServerAuthCookieHeader(request.headers);
+	const forDraft = (draftId) => requestLocaleReads(options, {
+		authCookieHeader,
+		draftId,
+		queryClient
+	});
+	if (!(!getRequestDraftId(request, options) || !authCookieHeader)) return forDraft;
+	const live = forDraft(void 0);
+	if (located.locales.length > 1) for (const locale of located.locales) {
+		if (locale.tag === located.locale.tag || locale.isDefault) continue;
+		live.pages(locale).catch(() => void 0);
+	}
+	return () => live;
+}
+async function createPageHtmlResponse({ options, pathname, located, request, pageRead }) {
 	if (!options.apiUrl || !options.authenticationUrl || !options.projectUuid || !options.renderPage) return createPageDataResponse({
 		options,
 		pathname,
 		located,
-		request
+		request,
+		pageRead
 	});
 	const singleton = await createDerivedResponse(options, pathname, located, request, { singletonOnly: true });
 	if (singleton) return singleton;
-	const queryClient = new QueryClient();
+	const { queryClient, result: reading } = pageRead ?? readCuratedPage({
+		...options,
+		apiUrl: options.apiUrl,
+		projectUuid: options.projectUuid
+	}, request, located);
+	const localeReads = curatedPageLocaleReads(options, request, located, queryClient);
 	try {
-		const result = await loadCamoxPageForRequest({
-			apiUrl: options.apiUrl,
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: getRequestDraftId(request, options),
-			locale: located.locale,
-			origin: new URL(request.url).origin,
-			pathname: located.path,
-			projectUuid: options.projectUuid,
-			queryClient
-		});
+		const result = await reading;
 		const headers = new Headers({
 			"Content-Type": "text/html; charset=utf-8",
 			Vary: "Cookie",
@@ -515,8 +802,8 @@ async function createPageHtmlResponse({ options, pathname, located, request }) {
 				pageId: result.data.page.page.id
 			},
 			head: camoxApp ? buildCamoxPageHead(camoxApp, result.data, located.locale) : {},
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: result.draftId
+			described: curatedPageDescription(camoxApp, result.data.page, located.locale),
+			localeReads: localeReads(result.draftId)
 		});
 		const dehydratedState = dehydrate(queryClient);
 		const { project } = result;
@@ -662,7 +949,7 @@ async function createLayoutMarkdownResponse(options, match, locale, page) {
 				toMarkdown: template
 			})],
 			data,
-			item: recordPlainText(collection, data.content)
+			record: recordPageValues(collection, record)
 		};
 	};
 	let rendered;
@@ -685,13 +972,14 @@ async function createLayoutMarkdownResponse(options, match, locale, page) {
 	});
 	const meta = buildPageMeta({
 		layout: match.layout._internal,
-		pageMetaTitle: match.layout._internal.title,
-		pageMetaDescription: void 0,
-		data: rendered.data,
-		item: rendered.item,
-		params: match.params,
-		projectName: slots.projectName,
-		pageFullPath: page.pathname
+		context: buildLayoutContext(match.layout._internal, {
+			path: page.pathname,
+			locale: locale.tag,
+			projectName: slots.projectName,
+			data: rendered.data,
+			params: match.params,
+			record: "record" in rendered ? rendered.record : void 0
+		})
 	});
 	const markdown = [
 		slots.before,
@@ -746,6 +1034,15 @@ async function createDerivedResponse(options, pathname, located, request, { data
 		}), serializedResult ?? null, shownIn);
 		const record = asCollectionItem(serializedResult);
 		const recordCollection = record && app.getCollectionById(record.collectionId);
+		const recordValues = record && recordCollection ? recordPageValues(recordCollection, record) : void 0;
+		const context = buildLayoutContext(match.layout._internal, {
+			path: pathname,
+			locale: located.locale.tag,
+			projectName: shared.projectName,
+			data: serializedResult?.data,
+			params: match.params,
+			record: recordValues
+		});
 		const { alternates, head: pageHead } = await readAlternates(request, options, {
 			located,
 			identity: record && match.layout._internal.kind === "derived" ? {
@@ -755,19 +1052,34 @@ async function createDerivedResponse(options, pathname, located, request, { data
 			} : { kind: "code-owned" },
 			head: buildPageHead({
 				layout: match.layout._internal,
-				pageMetaTitle: match.layout._internal.title,
-				pageMetaDescription: void 0,
-				data: serializedResult?.data,
-				item: record && recordCollection ? recordPlainText(recordCollection, record.data.content) : void 0,
-				params: match.params,
-				projectName: shared.projectName,
-				pageFullPath: pathname,
+				context,
 				origin: new URL(request.url).origin,
 				faviconUrl: buildFaviconUrl(options.apiUrl, shared.project),
-				hasMarkdown: match.layout._internal.toMarkdown !== void 0
+				hasMarkdown: match.layout._internal.toMarkdown !== void 0,
+				recordType: record?.structuredData?.node?.["@type"]
 			}),
-			authCookieHeader,
-			draftId: read.draftId
+			described: {
+				project: {
+					...shared.project,
+					name: shared.projectName
+				},
+				title: context.page.title,
+				declared: declarePage({
+					layout: match.layout._internal,
+					context
+				}),
+				blocks: placedBlockNodes(shared.layout, [], shared.structuredData),
+				...record?.published && { published: record.published },
+				records: pageRecords(shared.recordStructuredData, record && {
+					id: record.data.id,
+					structuredData: record.structuredData,
+					titles: recordValues?.titles
+				})
+			},
+			localeReads: requestLocaleReads(options, {
+				authCookieHeader,
+				draftId: read.draftId
+			})
 		});
 		const analytics = dataOnly ? void 0 : visitorAnalytics(options, {
 			studio,
@@ -794,6 +1106,11 @@ async function createDerivedResponse(options, pathname, located, request, { data
 			locales: located.locales,
 			derived: {
 				layoutId: match.layout._internal.id,
+				page: {
+					params: match.params,
+					path: pathname,
+					projectName: shared.projectName
+				},
 				result: serializedResult,
 				layout: shared.layout
 			}
@@ -801,7 +1118,7 @@ async function createDerivedResponse(options, pathname, located, request, { data
 		const document = await options.getDocument?.() ?? {};
 		await preparePreviewDocument(input, options, document, !studio && !dataOnly ? "" : void 0);
 		if (dataOnly) return Response.json(input, { headers: {
-			"Cache-Control": "private, no-store",
+			...isPrivateRender(request, options) ? { "Cache-Control": "private, no-store" } : {},
 			Vary: "Cookie",
 			...clearAuthCookie ? { "Set-Cookie": buildClearServerAuthCookieHeader() } : {}
 		} });
@@ -915,30 +1232,26 @@ async function createCanvasOnlyResponse({ options, pathname, located, request, d
 		...headers
 	} });
 }
-async function createPageDataResponse({ options, pathname, located, request }) {
+async function createPageDataResponse({ options, pathname, located, request, pageRead }) {
 	if (!options.apiUrl || !options.projectUuid) return Response.json({ message: "Camox page loader is not configured." }, { status: 500 });
 	const singleton = await createDerivedResponse(options, pathname, located, request, {
 		dataOnly: true,
 		singletonOnly: true
 	});
 	if (singleton) return singleton;
-	const queryClient = new QueryClient();
+	const { queryClient, result: reading } = pageRead ?? readCuratedPage({
+		...options,
+		apiUrl: options.apiUrl,
+		projectUuid: options.projectUuid
+	}, request, located);
+	const localeReads = curatedPageLocaleReads(options, request, located, queryClient);
 	try {
-		const result = await loadCamoxPageForRequest({
-			apiUrl: options.apiUrl,
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: getRequestDraftId(request, options),
-			locale: located.locale,
-			origin: new URL(request.url).origin,
-			pathname: located.path,
-			projectUuid: options.projectUuid,
-			queryClient
-		});
+		const result = await reading;
 		const headers = new Headers({
 			"Content-Type": "application/json; charset=utf-8",
-			"Cache-Control": "private, no-store",
 			Vary: "Cookie"
 		});
+		if (isPrivateRender(request, options)) headers.set("Cache-Control", "private, no-store");
 		if (result.shouldClearAuthCookie) headers.append("Set-Cookie", buildClearServerAuthCookieHeader());
 		const camoxApp = await options.getCamoxApp?.();
 		const { alternates, head } = await readAlternates(request, options, {
@@ -948,8 +1261,8 @@ async function createPageDataResponse({ options, pathname, located, request }) {
 				pageId: result.data.page.page.id
 			},
 			head: camoxApp ? buildCamoxPageHead(camoxApp, result.data, located.locale) : null,
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: result.draftId
+			described: curatedPageDescription(camoxApp, result.data.page, located.locale),
+			localeReads: localeReads(result.draftId)
 		});
 		const dehydratedState = dehydrate(queryClient);
 		const input = {
@@ -1000,6 +1313,7 @@ async function handleCamoxRequest(request, options = {}) {
 		});
 	}
 	if (match.kind === "og") return createOgResponse(request, options);
+	if (match.kind === "logo") return createProjectLogoResponse(request, options);
 	if (match.kind === "sitemap") return createSitemapResponse(request, options);
 	if (match.kind === "llms-txt") return createLlmsTxtResponse(request, options);
 	if (match.kind === "routes") return createRoutesResponse(request, options);
@@ -1016,19 +1330,17 @@ async function handleCamoxRequest(request, options = {}) {
 	const { apiUrl, projectUuid } = options;
 	const markdownPathname = parseMarkdownPath(pathname);
 	if (apiUrl && projectUuid && (markdownPathname || prefersMarkdown(request.headers.get("Accept") ?? ""))) {
-		const located = await locateRequest(request, options, markdownPathname ?? pathname, { live: true });
-		if (markdownPathname || matchLocalizedRoute(located.path)?.kind === "page") {
-			const markdownResponse = await createPageMarkdownResponse({
-				...options,
-				apiUrl,
-				projectUuid
-			}, located, {
-				pathname: markdownPathname ?? pathname,
-				request
-			});
-			if (markdownResponse) return markdownResponse;
-			if (markdownPathname) return new Response("Page not found", { status: 404 });
-		}
+		const markdownResponse = await createPageMarkdownResponse({
+			...options,
+			apiUrl,
+			projectUuid
+		}, {
+			pathname: markdownPathname ?? pathname,
+			request,
+			pagesOnly: !markdownPathname
+		});
+		if (markdownResponse) return markdownResponse;
+		if (markdownPathname) return new Response("Page not found", { status: 404 });
 	}
 	return respondInLocale(options, request, pathname);
 }
@@ -1037,7 +1349,7 @@ async function handleCamoxRequest(request, options = {}) {
 * With `dataOnly`, as the JSON client navigation loads.
 */
 async function respondInLocale(options, request, pathname, { dataOnly = false } = {}) {
-	const located = await locateRequest(request, options, pathname);
+	const [early, located] = await Promise.all([readDefaultLocalePageEarly(options, request, pathname), locateRequest(request, options, pathname)]);
 	const localized = matchLocalizedRoute(located.path);
 	if (!localized) return new Response("Not found", { status: 404 });
 	const target = {
@@ -1055,13 +1367,29 @@ async function respondInLocale(options, request, pathname, { dataOnly = false }
 		match: localized,
 		dataOnly
 	});
-	return dataOnly ? createPageDataResponse(target) : createPageHtmlResponse(target);
+	const page = {
+		...target,
+		pageRead: located.locale.isDefault ? early : void 0
+	};
+	return dataOnly ? createPageDataResponse(page) : createPageHtmlResponse(page);
 }
 /**
 * A page's Markdown Representation in its locale, with the same precedence as its HTML:
-* singleton, curated page, then derived layout. Null when the page has none.
+* singleton, curated page, then derived layout. Null when the page has none. Markdown is a public
+* output: it reads Live, whoever asks, and one read finds the path's locale and its curated page.
 */
-async function createPageMarkdownResponse(options, { locale, path }, { pathname, request }) {
+async function createPageMarkdownResponse(options, { pathname, request, pagesOnly }) {
+	let read;
+	try {
+		read = await readPageMarkdown({
+			...options,
+			path: pathname
+		});
+	} catch {
+		return null;
+	}
+	const { locale, path } = read;
+	if (pagesOnly && matchLocalizedRoute(path)?.kind !== "page") return null;
 	const page = {
 		pathname,
 		url: absoluteUrl(request, options)(pathname)
@@ -1069,20 +1397,12 @@ async function createPageMarkdownResponse(options, { locale, path }, { pathname,
 	const app = await options.getCamoxApp?.();
 	const layoutMatch = app && matchDerivedLayout(app.getLayouts(), path);
 	if (layoutMatch?.layout._internal.kind === "singleton") return createLayoutMarkdownResponse(options, layoutMatch, locale, page);
-	return createMarkdownResponse({
-		apiUrl: options.apiUrl,
-		camoxApp: app,
-		locale,
-		pathname: path,
-		projectUuid: options.projectUuid,
-		request,
-		url: page.url,
-		onNotFound: async () => layoutMatch ? createLayoutMarkdownResponse(options, layoutMatch, locale, page) : null
-	});
+	if (read.page) return curatedMarkdownResponse(app, read, page.url);
+	return layoutMatch ? createLayoutMarkdownResponse(options, layoutMatch, locale, page) : null;
 }
 /** Whether a route is one of the studio's own, rather than a page or the Canvas. */
 function isStudioRoute(match) {
-	return match.kind === "studio" || match.kind === "studio-content" || match.kind === "studio-nested";
+	return STUDIO_ROUTE_KINDS.includes(match.kind);
 }
 /**
 * The studio or page route a locale-relative path names, or null for a runtime-owned route
@@ -1094,19 +1414,16 @@ function matchLocalizedRoute(path) {
 }
 /**
 * The locale a request's path names, among the locales of the scope it reads: the URL's draft's
-* for a session naming one, else Live's. `live` reads Live's whatever the request names. Without
-* an API there are none to read: every path is the default locale's, which then says it can't
-* render.
+* for a session naming one, else Live's. Without an API there are none to read: every path is the
+* default locale's, which then says it can't render.
 */
-async function locateRequest(request, options, pathname, { live = false } = {}) {
+async function locateRequest(request, options, pathname) {
 	const { apiUrl, projectUuid } = options;
 	const locales = apiUrl && projectUuid ? await readScopeLocales({
 		apiUrl,
 		projectUuid,
-		...!live && {
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: getRequestDraftId(request, options)
-		}
+		authCookieHeader: getServerAuthCookieHeader(request.headers),
+		draftId: getRequestDraftId(request, options)
 	}) : [UNNAMED_DEFAULT_LOCALE];
 	return {
 		...parseLocalePath(pathname, locales),
@@ -1115,4 +1432,4 @@ async function locateRequest(request, options, pathname, { live = false } = {})
 }
 
 //#endregion
-export { createPageHeadInput, getRuntimePathname, handleCamoxRequest, matchRuntimeRoute };
+export { createPageHeadInput, getRuntimePathname, handleCamoxRequest, isPublicRequest, matchRuntimeRoute };