camox 0.47.0 → 0.51.0

package/dist/features/routes/pageRuntime.js

@@ -1,7 +1,10 @@
-import { localeHeaders, localizedPath } from "../../lib/locale-path.js";
+import { UNNAMED_DEFAULT_LOCALE, localeHeaders } from "../../lib/locale-path.js";
 import { createDraftScope, withoutDraft } from "../../lib/draft-scope.js";
 import { createStudioCache, reads } from "../../lib/studio-reads.js";
 import { linkFallbackLocale } from "../../lib/link-pages.js";
+import { curatedLayoutContext } from "../../core/layoutContext.js";
+import { PAGE_IMAGE_SIZE, pageImageUrl } from "../og/pageImage.js";
+import { isArticle } from "../../core/structuredData.js";
 import { DRAFT_ENDED_ERROR_CODE, DRAFT_HEADER, NO_DEVELOPMENT_DRAFT_ERROR } from "@camox/api-contract/drafts";
 import { createORPCClient } from "@orpc/client";
 import { RPCLink } from "@orpc/client/fetch";
@@ -215,59 +218,52 @@ async function loadCamoxPageForRequest({ apiUrl, authCookieHeader, draftId, loca
 		shouldClearAuthCookie: member.clearAuthCookie
 	};
 }
-async function createMarkdownResponse({ apiUrl, camoxApp, locale, pathname, projectUuid, request, url, onNotFound }) {
-	const api = createServerApiClient(apiUrl, { locale });
-	const requestPathname = pathname ?? new URL(request.url).pathname;
-	try {
-		const page = await api.pages.getByPath({
-			path: requestPathname,
-			projectUuid
-		});
-		const { markdown } = await api.blocks.getPageMarkdown({ pageId: page.page.id });
-		if (!markdown) return null;
-		const meta = buildPageMeta(curatedPageMetaInput(camoxApp, page, locale));
-		return new Response(withFrontMatter(markdown, {
-			...meta,
-			url
-		}), { headers: { "Content-Type": "text/markdown; charset=utf-8" } });
-	} catch (error) {
-		if (onNotFound && isNotFoundError(error)) return onNotFound();
-		return null;
-	}
+/**
+* Reads the Markdown Representation of the page at a runtime path, with its locale's prefix, in
+* one API read: the API finds the locale the prefix names, the page there, its Markdown and what
+* its front matter is built from. Markdown is a public output, so it reads Live whoever asks.
+*/
+function readPageMarkdown({ apiUrl, path, projectUuid }) {
+	return createServerApiClient(apiUrl).pages.getMarkdown({
+		path,
+		projectUuid
+	});
+}
+/**
+* A curated page's Markdown Representation, opened by front matter stating its title,
+* description and absolute `url`. Null when the path has no curated page, or the page has no
+* Markdown.
+*/
+function curatedMarkdownResponse(camoxApp, read, url) {
+	if (!read.page || !read.markdown) return null;
+	const meta = buildPageMeta(curatedPageMetaInput(camoxApp, {
+		...read,
+		page: read.page
+	}, read.locale));
+	return new Response(withFrontMatter(read.markdown, {
+		...meta,
+		url
+	}), { headers: { "Content-Type": "text/markdown; charset=utf-8" } });
 }
-/** A page's title and description, built by its layout's callbacks. */
+/** A page's title and description, built by its layout's `toTitle` and `toDescription`. */
 function buildPageMeta(input) {
-	const context = {
-		data: input.data,
-		...input.item && { item: input.item },
-		params: input.params,
-		projectName: input.projectName,
-		pageFullPath: input.pageFullPath
-	};
-	const title = input.layout?.buildMetaTitle({
-		...context,
-		pageMetaTitle: input.pageMetaTitle
-	}) ?? input.pageMetaTitle;
-	const description = input.layout?.buildMetaDescription ? input.layout.buildMetaDescription({
-		...context,
-		pageMetaDescription: input.pageMetaDescription
-	}) : input.pageMetaDescription;
+	const { layout, context } = input;
+	const title = layout ? layout.toTitle(context) : context.page.title;
+	const description = layout ? layout.toDescription(context) : context.page.description;
 	return {
 		title,
 		...description && { description }
 	};
 }
-/** A curated page's meta input: its editor metadata and its layout. */
+/** What a page's layout says the page is, from the page's context. */
+function declarePage(input) {
+	return input.layout?.toStructuredData(input.context);
+}
 /** A curated page's meta input. Its path keeps the prefix of the page's `locale`. */
-function curatedPageMetaInput(camoxApp, page, locale) {
+function curatedPageMetaInput(camoxApp, page, locale = UNNAMED_DEFAULT_LOCALE) {
 	return {
 		layout: page.layout ? camoxApp?.getLayoutById(page.layout.layoutId)?._internal : void 0,
-		pageMetaTitle: page.page.metaTitle ?? page.page.pathSegment,
-		pageMetaDescription: page.page.metaDescription ?? void 0,
-		data: void 0,
-		params: {},
-		projectName: page.projectName,
-		pageFullPath: locale ? localizedPath(page.page.fullPath, locale) : page.page.fullPath
+		context: curatedLayoutContext(page, locale)
 	};
 }
 /** A Markdown Representation, opened by YAML front matter stating the page's title, description and URL. */
@@ -281,18 +277,18 @@ function withFrontMatter(markdown, meta) {
 /** The head every page gets, whatever its layout kind. */
 function buildPageHead(input) {
 	const { title, description } = buildPageMeta(input);
+	const mainEntity = declarePage(input) ?? (input.recordType ? { "@type": input.recordType } : void 0);
 	const meta = [{ title }];
 	if (description) meta.push({
 		name: "description",
 		content: description
 	});
-	const ogImageParams = new URLSearchParams({
-		...input.layout && { layoutId: input.layout.id },
-		title: input.ogImageTitle ?? title,
-		...description && { description },
-		...input.projectName && { projectName: input.projectName }
+	const { page, project } = input.context;
+	const ogImageUrl = pageImageUrl({
+		origin: input.origin,
+		path: page.path,
+		customImageUrl: input.customOgImageUrl
 	});
-	const ogImageUrl = input.customOgImageUrl ?? `${input.origin}/og?${ogImageParams.toString()}`;
 	meta.push({
 		property: "og:title",
 		content: title
@@ -301,15 +297,25 @@ function buildPageHead(input) {
 		content: ogImageUrl
 	}, {
 		property: "og:image:width",
-		content: "1200"
+		content: String(PAGE_IMAGE_SIZE.width)
 	}, {
 		property: "og:image:height",
-		content: "630"
+		content: String(PAGE_IMAGE_SIZE.height)
 	});
 	if (description) meta.push({
 		property: "og:description",
 		content: description
 	});
+	meta.push({
+		property: "og:type",
+		content: isArticle(mainEntity ?? { "@type": "" }) ? "article" : "website"
+	}, {
+		property: "og:site_name",
+		content: project.name
+	}, {
+		name: "twitter:card",
+		content: "summary_large_image"
+	});
 	const links = [{
 		rel: "icon",
 		href: input.faviconUrl
@@ -317,7 +323,7 @@ function buildPageHead(input) {
 	if (input.hasMarkdown) links.push({
 		rel: "alternate",
 		type: "text/markdown",
-		href: `${input.origin}${getMarkdownPath(input.pageFullPath)}`
+		href: `${input.origin}${getMarkdownPath(page.path)}`
 	});
 	return {
 		meta,
@@ -328,10 +334,8 @@ function buildPageHead(input) {
 function buildCamoxPageHead(camoxApp, loaderData, locale) {
 	if (!loaderData) return {};
 	const { page, origin, faviconUrl } = loaderData;
-	const metaInput = curatedPageMetaInput(camoxApp, page, locale);
 	return buildPageHead({
-		...metaInput,
-		ogImageTitle: metaInput.pageMetaTitle,
+		...curatedPageMetaInput(camoxApp, page, locale),
 		customOgImageUrl: page.page.customOgImageUrl,
 		origin,
 		faviconUrl,
@@ -340,4 +344,4 @@ function buildCamoxPageHead(camoxApp, loaderData, locale) {
 }
 
 //#endregion
-export { buildCamoxPageHead, buildCamoxPageLoaderData, buildDefaultFaviconUrl, buildFaviconUrl, buildPageHead, buildPageMeta, createMarkdownResponse, createServerApiClient, createServerStudioCache, getMarkdownPath, isAuthSessionError, isNotFoundError, loadCamoxPage, loadCamoxPageForRequest, parseMarkdownPath, parseQuality, prefersMarkdown, readDraftOrLive, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter };
+export { buildCamoxPageHead, buildCamoxPageLoaderData, buildDefaultFaviconUrl, buildFaviconUrl, buildPageHead, buildPageMeta, createServerApiClient, createServerStudioCache, curatedMarkdownResponse, curatedPageMetaInput, declarePage, getMarkdownPath, isAuthSessionError, isNotFoundError, loadCamoxPage, loadCamoxPageForRequest, parseMarkdownPath, parseQuality, prefersMarkdown, readDraftOrLive, readPageMarkdown, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter };

package/dist/features/runtime/RuntimeChrome.js

@@ -22,7 +22,7 @@ function RuntimeChrome(t0) {
 	const website = !input.routeKind;
 	const hidden = useSelector(previewStore, _temp);
 	const isCanvasShown = useSelector(previewStore, selectIsCanvasShown);
-	const showChat = !website || isCanvasShown;
+	const showChat = website && isCanvasShown;
 	const t1 = input.runtimeBasePath;
 	let t2;
 	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {

package/dist/features/runtime/breadcrumbs.js

@@ -0,0 +1,68 @@
+import { recordPageValues } from "../../core/recordItem.js";
+import { curatedPageTitle } from "../../core/layoutContext.js";
+import { getPageDestinations } from "../../core/pageDestinations.js";
+import { matchDerivedLayout } from "../../core/derivedRoutes.js";
+
+//#region src/features/runtime/breadcrumbs.ts
+/** The paths above a page's, from the home page down: none for the home page itself. */
+function ancestorPaths(path) {
+	const segments = path.split("/").filter(Boolean);
+	if (segments.length === 0) return [];
+	return ["/", ...segments.slice(1).map((_, index) => `/${segments.slice(0, index + 1).join("/")}`)];
+}
+/**
+* A page's crumbs, ending with the page itself, which `title` names. The home page has none. An
+* ancestor that isn't a page, or is a derived page other than a record page, is left out.
+*/
+async function readBreadcrumb({ path, title, app, reads }) {
+	const ancestors = ancestorPaths(path);
+	if (ancestors.length === 0) return [];
+	const layouts = app?.getLayouts() ?? [];
+	const pages = await reads.pages();
+	const destinations = getPageDestinations(pages, layouts);
+	const pagesByPath = new Map(pages.map((page) => [page.fullPath, page]));
+	return [...(await Promise.all(ancestors.map(async (ancestor) => {
+		const destination = destinations.find((d) => d.kind === "singleton" && d.fullPath === ancestor) ?? destinations.find((d) => d.kind === "curated" && d.fullPath === ancestor);
+		if (destination?.kind === "singleton") return {
+			name: destination.title,
+			path: ancestor
+		};
+		if (destination?.kind === "curated") {
+			const page = pagesByPath.get(ancestor);
+			return {
+				name: curatedPageTitle(page),
+				path: ancestor
+			};
+		}
+		const name = await recordPageTitle(app, ancestor, reads.records);
+		return name === void 0 ? void 0 : {
+			name,
+			path: ancestor
+		};
+	}))).filter((crumb) => crumb !== void 0), {
+		name: title,
+		path
+	}];
+}
+/**
+* The title of the record a record page at `path` renders, found by its route param as the
+* page's own read finds it. Undefined when no record page is there.
+*/
+async function recordPageTitle(app, path, records) {
+	const match = app && matchDerivedLayout(app.getLayouts(), path);
+	const recordPages = match?.layout._internal.recordPages;
+	if (!match || !recordPages || !records) return void 0;
+	const value = recordPages.param ? match.params[recordPages.param] : Object.values(match.params).length === 1 ? Object.values(match.params)[0] : void 0;
+	const collection = app.getCollectionById(recordPages.collectionId);
+	if (!value || !collection) return void 0;
+	const found = await records.findByField({
+		collectionId: recordPages.collectionId,
+		field: recordPages.field,
+		value
+	});
+	if (found.length !== 1) return void 0;
+	return recordPageValues(collection, { data: found[0] }).title;
+}
+
+//#endregion
+export { readBreadcrumb };

package/dist/features/runtime/livePages.js

@@ -1,4 +1,5 @@
 import { createRequestContext } from "../../core/requestContext.js";
+import { curatedPageTitle } from "../../core/layoutContext.js";
 import { getPageDestinations } from "../../core/pageDestinations.js";
 import { discoverLayoutPages } from "../../core/derivedRoutes.js";
 
@@ -27,7 +28,7 @@ async function listLivePages({ pages, app, records }) {
 			key: destination.key,
 			fullPath: page.fullPath,
 			layoutId: page.layoutId,
-			title: page.metaTitle || page.nickname,
+			title: curatedPageTitle(page),
 			...page.metaDescription && { description: page.metaDescription },
 			hasMarkdown: true,
 			updatedAt: page.updatedAt
@@ -41,7 +42,7 @@ async function listLivePages({ pages, app, records }) {
 			key: page.recordId ? `record:${layout._internal.id}:${page.recordId}` : `derived:${page.path}`,
 			fullPath: page.path,
 			layoutId: layout._internal.id,
-			title: page.label || page.path,
+			title: page.title || page.path,
 			hasMarkdown: servesMarkdown(layout)
 		}));
 	}));

package/dist/features/runtime/pageGraph.js

@@ -0,0 +1,92 @@
+import { curatedPageTitle } from "../../core/layoutContext.js";
+import { curatedPageMetaInput, declarePage } from "../routes/pageRuntime.js";
+import { buildPageGraph, serializeStructuredData } from "./structuredData.js";
+
+//#region src/features/runtime/pageGraph.ts
+/**
+* The records a page's graph can hold: those its blocks reference, and on a record page, the
+* page's record and those it references.
+*/
+function pageRecords(blocks, page) {
+	const own = page?.structuredData;
+	return {
+		nodes: {
+			...blocks?.nodes,
+			...own?.records.nodes,
+			...page && own?.node && { [page.id]: own.node }
+		},
+		referenced: [.../* @__PURE__ */ new Set([...blocks?.referenced ?? [], ...own?.records.referenced ?? []])],
+		...page?.titles && { titles: page.titles },
+		...page && { main: page.id }
+	};
+}
+/** Each placed block's nodes, its layout's before and after the page's own. */
+function placedBlockNodes(layout, pageBlockIds, structuredData) {
+	if (!structuredData) return [];
+	return [
+		...layout?.beforeBlockIds ?? [],
+		...pageBlockIds,
+		...layout?.afterBlockIds ?? []
+	].flatMap((id) => {
+		const nodes = structuredData?.[id];
+		return nodes?.length ? [{
+			id,
+			nodes
+		}] : [];
+	});
+}
+/** What a curated page's Structured Data says beyond its head. */
+function curatedPageDescription(camoxApp, structure, locale) {
+	const { page, project, projectName } = structure;
+	return {
+		project: {
+			...project,
+			name: projectName
+		},
+		title: curatedPageTitle(page),
+		published: {
+			first: page.firstPublishedAt,
+			last: page.publishedAt
+		},
+		declared: declarePage(curatedPageMetaInput(camoxApp, structure, locale)),
+		blocks: placedBlockNodes(structure.layout, page.blockIds, structure.structuredData),
+		records: pageRecords(structure.recordStructuredData)
+	};
+}
+/** The value of a head's meta tag, by its name or property. */
+function headMeta(head, key) {
+	return head.meta?.find((entry) => entry.name === key || entry.property === key)?.content;
+}
+/**
+* A page's head with its Structured Data, which names and describes the page as the head does,
+* with the head's page image.
+*/
+function withStructuredData(head, place, site, { published, declared, breadcrumb, blocks, records }) {
+	const name = head.meta?.find((entry) => entry.title)?.title ?? "";
+	const graph = buildPageGraph({
+		site,
+		page: {
+			url: place.url,
+			name,
+			description: headMeta(head, "description"),
+			inLanguage: place.locale,
+			image: headMeta(head, "og:image"),
+			...published?.first && { datePublished: new Date(published.first) },
+			...published?.last && { dateModified: new Date(published.last) },
+			breadcrumb
+		},
+		declared,
+		blocks,
+		records
+	});
+	return {
+		...head,
+		scripts: [...head.scripts ?? [], {
+			type: "application/ld+json",
+			text: serializeStructuredData(graph)
+		}]
+	};
+}
+
+//#endregion
+export { curatedPageDescription, pageRecords, placedBlockNodes, withStructuredData };

package/dist/features/runtime/projectLogo.js

@@ -0,0 +1,110 @@
+import { RUNTIME_ROUTE_PATHS } from "./runtimeRoutes.js";
+import { buildDefaultFaviconUrl, buildFaviconUrl, createServerApiClient, isNotFoundError } from "../routes/pageRuntime.js";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/features/runtime/projectLogo.tsx
+/**
+* The project's logo in its Structured Data: its favicon, rendered as a PNG by the runtime.
+* Search engines want a raster logo at least 112px wide, and favicons are often SVGs or tiny.
+*/
+/** The size the logo is served at: square, and wider than search engines' minimum. */
+const LOGO_SIZE = 512;
+/**
+* Where the runtime serves its project's logo. `url` makes a runtime path absolute. The project's
+* version only busts caches: the route always serves the project's current logo.
+*/
+function projectLogo(url, project) {
+	const search = new URLSearchParams({ v: String(project.updatedAt) });
+	return {
+		url: `${url(RUNTIME_ROUTE_PATHS.logo)}?${search}`,
+		width: 512,
+		height: 512
+	};
+}
+/** An image fetched as a data URL, which the renderer reads without fetching it again. */
+async function asDataUrl(url) {
+	const response = await fetch(new Request(url));
+	if (!response.ok) return null;
+	const type = response.headers.get("Content-Type") ?? "application/octet-stream";
+	const bytes = new Uint8Array(await response.arrayBuffer());
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return `data:${type};base64,${btoa(binary)}`;
+}
+async function renderLogo(source) {
+	const { ImageResponse } = await import("camox/_internal/imageResponse");
+	return new ImageResponse(/* @__PURE__ */ jsx("div", {
+		style: {
+			display: "flex",
+			width: "100%",
+			height: "100%"
+		},
+		children: /* @__PURE__ */ jsx("img", {
+			src: source,
+			style: {
+				width: "100%",
+				height: "100%",
+				objectFit: "contain"
+			}
+		})
+	}), {
+		width: 512,
+		height: 512,
+		format: "png"
+	}).arrayBuffer();
+}
+/** The project's favicon as a PNG. A favicon the renderer can't read gives way to the default. */
+async function renderProjectLogo(apiUrl, project) {
+	for (const url of [buildFaviconUrl(apiUrl, project), buildDefaultFaviconUrl(apiUrl)]) {
+		const source = await asDataUrl(url);
+		if (!source) continue;
+		try {
+			return await renderLogo(source);
+		} catch {}
+	}
+	return null;
+}
+/**
+* The last logo rendered, with the version of the project it was rendered for, by project. A
+* runtime serves one project, so it keeps one logo, and renders again only once the project
+* changed.
+*/
+const renderedLogos = /* @__PURE__ */ new Map();
+/**
+* The website's own project's logo, as a PNG. The request names no project, and its `v` only
+* busts caches: whatever it says, the logo is the project's current one, rendered once per
+* version of the project.
+*/
+async function createProjectLogoResponse(request, { apiUrl, projectUuid }) {
+	if (!apiUrl || !projectUuid) return new Response("Not found", { status: 404 });
+	let project;
+	try {
+		project = await createServerApiClient(apiUrl).projects.getSummary({ projectUuid });
+	} catch (error) {
+		if (isNotFoundError(error)) return new Response("Not found", { status: 404 });
+		throw error;
+	}
+	const version = String(project.updatedAt);
+	const key = `${apiUrl} ${projectUuid}`;
+	let rendered = renderedLogos.get(key);
+	if (rendered?.version !== version) {
+		rendered = {
+			version,
+			png: renderProjectLogo(apiUrl, project)
+		};
+		renderedLogos.set(key, rendered);
+	}
+	const png = await rendered.png;
+	if (!png) {
+		if (renderedLogos.get(key) === rendered) renderedLogos.delete(key);
+		return new Response("Not found", { status: 404 });
+	}
+	const current = new URL(request.url).searchParams.get("v") === version;
+	return new Response(png, { headers: {
+		"Content-Type": "image/png",
+		"Cache-Control": current ? "public, max-age=86400" : "public, no-cache"
+	} });
+}
+
+//#endregion
+export { createProjectLogoResponse, projectLogo };

package/dist/features/runtime/publicCache.js

@@ -0,0 +1,83 @@
+import { prefersMarkdown } from "../routes/pageRuntime.js";
+
+//#region src/features/runtime/publicCache.ts
+/** How long the edge keeps a render. Live changing replaces its key long before. */
+const EDGE_MAX_AGE = 86400;
+/** Browsers can't be purged, so they ask again each time; the edge answers them. */
+const VISITOR_CACHE_CONTROL = "public, max-age=0, must-revalidate";
+/** The search parameter the cache key adds to a request's URL. */
+const CACHE_KEY_PARAM = "__camox_cache";
+/** The project's Live cache key, as the API serves it from its edge cache. */
+async function readLiveCacheKey(apiUrl, projectUuid) {
+	try {
+		const response = await fetch(`${apiUrl}/live-cache-keys/${encodeURIComponent(projectUuid)}`);
+		return response.ok ? await response.text() || null : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Answers a public request from the cache, or renders it and keeps the render when it may be
+* shared. Without a Live cache key, it renders without the cache: nothing tells when Live changed.
+*/
+async function respondThroughPublicCache(request, publicCache, render) {
+	const liveCacheKey = await publicCache.liveCacheKey();
+	if (!liveCacheKey) return render();
+	const key = cacheKeyOf(request, `${liveCacheKey}.${publicCache.build}`);
+	const cached = await publicCache.cache.match(withValidators(key, request));
+	if (cached) return forVisitors(cached, request);
+	const response = await render();
+	if (!response || !mayBeShared(response)) return response;
+	publicCache.waitUntil(publicCache.cache.put(key, forEdge(response.clone())));
+	return forVisitors(response, request);
+}
+/**
+* What a request's render is kept under: its URL, the representation it asks for, and the
+* version of Live and of the website it renders.
+*/
+function cacheKeyOf(request, version) {
+	const url = new URL(request.url);
+	const representation = prefersMarkdown(request.headers.get("Accept") ?? "") ? "md" : "any";
+	url.searchParams.set(CACHE_KEY_PARAM, `${version}.${representation}`);
+	return new Request(url.toString(), { method: "GET" });
+}
+/** The cache key, asking for the part of the render the request does. */
+function withValidators(key, request) {
+	const headers = new Headers();
+	for (const name of [
+		"Range",
+		"If-None-Match",
+		"If-Modified-Since"
+	]) {
+		const value = request.headers.get(name);
+		if (value !== null) headers.set(name, value);
+	}
+	return new Request(key, { headers });
+}
+/** Whether a response is the same for every visitor: what a private render never is. */
+function mayBeShared(response) {
+	if (response.status !== 200 || response.headers.has("Set-Cookie")) return false;
+	const cacheControl = response.headers.get("Cache-Control") ?? "";
+	return !/\b(private|no-store)\b/i.test(cacheControl);
+}
+/** How long browsers may keep a render: what it asked for, if it's versioned, else not at all. */
+function visitorCacheControl(response) {
+	const cacheControl = response.headers.get("Cache-Control") ?? "";
+	return /\bmax-age=[1-9]/.test(cacheControl) ? cacheControl : VISITOR_CACHE_CONTROL;
+}
+/** The render as the edge keeps it: as visitors get it, for as long as the edge keeps renders. */
+function forEdge(response) {
+	const kept = new Response(response.body, response);
+	kept.headers.set("Cache-Control", `${visitorCacheControl(response)}, s-maxage=${EDGE_MAX_AGE}`);
+	return kept;
+}
+/** The render as visitors get it, without the edge's lifetime, which no cache downstream gets. */
+function forVisitors(response, request) {
+	const cacheControl = visitorCacheControl(response).replace(/,\s*s-maxage=\d+/, "");
+	const answered = new Response(request.method === "HEAD" ? null : response.body, response);
+	answered.headers.set("Cache-Control", cacheControl);
+	return answered;
+}
+
+//#endregion
+export { readLiveCacheKey, respondThroughPublicCache };

package/dist/features/runtime/runtime.d.ts

@@ -1,14 +1,17 @@
 import { CamoxDocument } from "../../core/defineDocument.js";
+import { AlternatePath, LocaleView } from "../../lib/locale-path.js";
 import { AnyLayoutLoaderResult } from "../../core/createLayout.js";
 import { CamoxApp } from "../../core/createApp.js";
-import { AlternatePath, LocaleView } from "../../lib/locale-path.js";
 import { AnalyticsProviders } from "./analytics.js";
 import { RuntimeOwnedRouteKind } from "./runtimeRoutes.js";
 import { StudioRenderInput } from "./studioApp.js";
-import { DraftRead, MemberProject, createServerApiClient } from "../routes/pageRuntime.js";
+import { DraftRead, MemberProject, PageHead, createServerApiClient } from "../routes/pageRuntime.js";
 import { UseHeadInput } from "unhead/types";
 //#region src/features/runtime/runtime.d.ts
-export type RuntimeRouteKind = RuntimeOwnedRouteKind | "canvas" | "page" | "studio" | "studio-content" | "studio-nested";
+/** The studio's own routes, rather than a page or the Canvas. */
+declare const STUDIO_ROUTE_KINDS: readonly ["studio", "studio-content", "studio-settings", "studio-nested"];
+export type StudioRouteKind = (typeof STUDIO_ROUTE_KINDS)[number];
+export type RuntimeRouteKind = RuntimeOwnedRouteKind | "canvas" | "page" | StudioRouteKind;
 export interface RuntimeRouteMatch {
   kind: RuntimeRouteKind;
   pathname: string;
@@ -32,13 +35,21 @@ export interface PageRenderInput extends DraftRead {
   /** Authenticate before rendering, to show the Studio around the page. */
   previewHandoff?: boolean;
   previewDocument?: string;
-  routeKind?: "studio" | "studio-content" | "studio-nested";
+  routeKind?: StudioRouteKind;
   /** Whether the location is the Canvas with nothing selected, which only the Canvas shows. */
   canvasOnly?: boolean;
   project?: MemberProject;
   presentation?: "public" | "studio";
   derived?: {
     layoutId: string;
+    /** What the layout's context names, beside the loader's result. */
+    page?: {
+      /** The params the page's route matched. */
+      params: Record<string, string>;
+      /** The page's path, with its locale's prefix. */
+      path: string;
+      projectName: string;
+    };
     result?: AnyLayoutLoaderResult;
     layout: Awaited<ReturnType<ReturnType<typeof createServerApiClient>["layouts"]["get"]>>["layout"];
   };
@@ -88,10 +99,14 @@ export interface RuntimeOptions {
   studioStylesheetUrl?: string;
 }
 export declare function getRuntimePathname(url: string, runtimeBasePath?: string): string | null;
+/**
+ * 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.
+ */
+export declare function isPublicRequest(request: Request, options?: RuntimeOptions): boolean;
 export declare function matchRuntimeRoute(pathname: string): RuntimeRouteMatch;
-export declare function createPageHeadInput(head: {
-  meta?: Array<Record<string, string>>;
-  links?: Array<Record<string, string>>;
-}): UseHeadInput;
+export declare function createPageHeadInput(head: PageHead): UseHeadInput;
 export declare function handleCamoxRequest(request: Request, options?: RuntimeOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};