camox 0.48.0 → 0.52.1

package/dist/features/runtime/runtime.js

@@ -6,13 +6,14 @@ 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, 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, declarePage, isNotFoundError, loadCamoxPageForRequest, parseMarkdownPath, prefersMarkdown, readDraftOrLive, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter } from "../routes/pageRuntime.js";
+import { buildLayoutContext, curatedLayoutContext } from "../../core/layoutContext.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 { assetPrefix } from "./assetPrefix.js";
 import { alternatesByPage, findAlternates, hreflangLinks } from "./alternates.js";
 import { configuredProviders, renderAnalyticsScripts } from "./analytics.js";
 import { omitArtifactSources } from "./artifactSources.js";
@@ -29,6 +30,13 @@ 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 "";
@@ -57,6 +65,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;");
 }
@@ -90,6 +118,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
@@ -184,10 +216,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) {
@@ -431,8 +460,9 @@ function renderHead(document, pageHead, stylesheetUrl, studioStylesheetUrl, loca
 	return renderSSRHead(head);
 }
 /**
-* The browser loads a page's blocks before hydrating it. Preloading them alongside the entry
-* script avoids a request waterfall.
+* A visitor's browser loads a page's blocks before hydrating it. Preloading them alongside the
+* entry script avoids a request waterfall. A member's document loads none: only its renderer
+* frame runs the site's code.
 */
 function renderBlockPreloads(options, dehydratedState) {
 	const preloads = options.blockPreloads;
@@ -442,24 +472,40 @@ function renderBlockPreloads(options, dehydratedState) {
 		const modulePath = preloads.modulePaths[type];
 		if (!modulePath) continue;
 		if (!preloads.chunks) urls.add(modulePath);
-		for (const chunk of preloads.chunks?.[modulePath] ?? []) urls.add(`/${chunk}`);
+		for (const chunk of preloads.chunks?.[modulePath] ?? []) urls.add(`${assetPrefix()}${chunk}`);
 	}
 	return [...urls].map((url) => `<link rel="modulepreload" href="${escapeXml(url)}">`).join("");
 }
+/**
+* The renderer frame's document (ADR 0023): an empty document running the renderer's client,
+* which renders the studio's pages into its frames, reading them itself. It holds no content, but
+* is only ever the studio's, so no shared cache keeps it.
+*/
+function createRendererDocumentResponse(options) {
+	const input = {
+		apiUrl: options.apiUrl,
+		authenticationUrl: options.authenticationUrl,
+		projectUuid: options.projectUuid,
+		runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath)
+	};
+	return new Response(`<!doctype html><html><head><meta charset="utf-8"><meta name="robots" content="noindex"><title>Camox renderer</title><script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(input)}<\/script></head><body>${renderClientEntryScript(options.rendererClientEntryUrl)}</body></html>`, { headers: {
+		"Content-Type": "text/html; charset=utf-8",
+		"Cache-Control": "private, no-store",
+		"X-Robots-Tag": "noindex"
+	} });
+}
 function renderClientEntryScript(src) {
 	if (!src) return "";
 	return `<script type="module" src="${escapeXml(src)}"><\/script>`;
 }
-async function preparePreviewDocument(input, options, document, content) {
+/**
+* The site document the studio's frames load: the site's head and an empty root, which the
+* renderer frame renders the page into. The studio never renders the site's code itself.
+*/
+function preparePreviewDocument(input, options, document) {
 	const siteHead = renderHead(document, createPageHeadInput(input.head ?? {}), options.stylesheetUrl, void 0, input.locale);
 	const href = new URL(withRuntimeBasePath(input.pathname, options.runtimeBasePath), input.href).href;
-	const siteHtml = content ?? (options.renderPage ? await options.renderPage({
-		...input,
-		href,
-		presentation: "public",
-		previewDocument: void 0
-	}) : "");
-	input.previewDocument = `<!doctype html><html${siteHead.htmlAttrs}><head><base href="${escapeXml(href)}">${siteHead.headTags}</head><body${siteHead.bodyAttrs}>${siteHead.bodyTagsOpen}<div id="root" data-camox-preview-root>${siteHtml}</div>${siteHead.bodyTags}</body></html>`;
+	input.previewDocument = `<!doctype html><html${siteHead.htmlAttrs}><head><base href="${escapeXml(href)}">${siteHead.headTags}</head><body${siteHead.bodyAttrs}>${siteHead.bodyTagsOpen}<div id="root" data-camox-preview-root></div>${siteHead.bodyTags}</body></html>`;
 }
 /**
 * The render input a page's HTML embeds for hydration. Visitors load public pages, whose HTML
@@ -492,8 +538,7 @@ 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, described, ...reading }) {
-	const localeReads = requestLocaleReads(options, reading);
+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);
@@ -565,7 +610,7 @@ function withLocatedTags(head, { url, locale, alternates }) {
 		}]
 	};
 }
-function requestLocaleReads(options, { authCookieHeader, draftId }) {
+function requestLocaleReads(options, { authCookieHeader, draftId, queryClient }) {
 	const { apiUrl, projectUuid } = options;
 	const reading = {
 		authCookieHeader: draftId ? authCookieHeader : void 0,
@@ -573,9 +618,15 @@ function requestLocaleReads(options, { authCookieHeader, 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
@@ -670,27 +721,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",
@@ -708,8 +821,7 @@ async function createPageHtmlResponse({ options, pathname, located, request }) {
 			},
 			head: camoxApp ? buildCamoxPageHead(camoxApp, result.data, located.locale) : {},
 			described: curatedPageDescription(camoxApp, result.data.page, located.locale),
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: result.draftId
+			localeReads: localeReads(result.draftId)
 		});
 		const dehydratedState = dehydrate(queryClient);
 		const { project } = result;
@@ -738,7 +850,7 @@ async function createPageHtmlResponse({ options, pathname, located, request }) {
 			locale: located.locale,
 			locales: located.locales
 		};
-		await preparePreviewDocument(pageRenderInput, options, document, studio ? void 0 : "");
+		preparePreviewDocument(pageRenderInput, options, document);
 		const appHtml = await options.renderPage(pageRenderInput);
 		const renderedHead = renderHead(studio ? {} : document, createPageHeadInput(head), studio ? void 0 : options.stylesheetUrl, studio ? options.studioStylesheetUrl : void 0, studio ? void 0 : located.locale);
 		return new Response(`<!doctype html>
@@ -747,7 +859,7 @@ async function createPageHtmlResponse({ options, pathname, located, request }) {
 ${renderStudioThemeScript(studio)}
 ${renderedHead.headTags}
 ${renderAnalyticsScripts(analytics)}
-${renderBlockPreloads(options, dehydratedState)}
+${studio ? "" : renderBlockPreloads(options, dehydratedState)}
 <script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(hydrationInputFor(pageRenderInput, appHtml))}<\/script>
 </head>
 <body${renderedHead.bodyAttrs}>
@@ -982,8 +1094,10 @@ async function createDerivedResponse(options, pathname, located, request, { data
 					titles: recordValues?.titles
 				})
 			},
-			authCookieHeader,
-			draftId: read.draftId
+			localeReads: requestLocaleReads(options, {
+				authCookieHeader,
+				draftId: read.draftId
+			})
 		});
 		const analytics = dataOnly ? void 0 : visitorAnalytics(options, {
 			studio,
@@ -1020,15 +1134,15 @@ async function createDerivedResponse(options, pathname, located, request, { data
 			}
 		};
 		const document = await options.getDocument?.() ?? {};
-		await preparePreviewDocument(input, options, document, !studio && !dataOnly ? "" : void 0);
+		preparePreviewDocument(input, options, document);
 		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() } : {}
 		} });
 		const html = await options.renderPage(input);
 		const head = renderHead(studio ? {} : document, createPageHeadInput(pageHead), studio ? void 0 : options.stylesheetUrl, studio ? options.studioStylesheetUrl : void 0, studio ? void 0 : located.locale);
-		return new Response(`<!doctype html><html${head.htmlAttrs}><head>${renderStudioThemeScript(studio)}${head.headTags}${renderAnalyticsScripts(analytics)}${renderBlockPreloads(options, input.dehydratedState)}<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(hydrationInputFor(input, html))}<\/script></head><body${head.bodyAttrs}>${head.bodyTagsOpen}<div id="root">${html}</div>${head.bodyTags}${renderClientEntryScript(options.pageClientEntryUrl)}</body></html>`, { headers: {
+		return new Response(`<!doctype html><html${head.htmlAttrs}><head>${renderStudioThemeScript(studio)}${head.headTags}${renderAnalyticsScripts(analytics)}${studio ? "" : renderBlockPreloads(options, input.dehydratedState)}<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(hydrationInputFor(input, html))}<\/script></head><body${head.bodyAttrs}>${head.bodyTagsOpen}<div id="root">${html}</div>${head.bodyTags}${renderClientEntryScript(options.pageClientEntryUrl)}</body></html>`, { headers: {
 			"Content-Type": "text/html; charset=utf-8",
 			Vary: "Cookie",
 			Link: llmsTxtLinkHeader(options),
@@ -1136,30 +1250,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, {
@@ -1170,8 +1280,7 @@ async function createPageDataResponse({ options, pathname, located, request }) {
 			},
 			head: camoxApp ? buildCamoxPageHead(camoxApp, result.data, located.locale) : null,
 			described: curatedPageDescription(camoxApp, result.data.page, located.locale),
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: result.draftId
+			localeReads: localeReads(result.draftId)
 		});
 		const dehydratedState = dehydrate(queryClient);
 		const input = {
@@ -1193,7 +1302,7 @@ async function createPageDataResponse({ options, pathname, located, request }) {
 			head,
 			dehydratedState
 		};
-		await preparePreviewDocument(input, options, await options.getDocument?.() ?? {});
+		preparePreviewDocument(input, options, await options.getDocument?.() ?? {});
 		return Response.json(input, { headers });
 	} catch (error) {
 		if (isNotFoundError(error)) {
@@ -1222,6 +1331,7 @@ async function handleCamoxRequest(request, options = {}) {
 		});
 	}
 	if (match.kind === "og") return createOgResponse(request, options);
+	if (match.kind === "renderer") return createRendererDocumentResponse(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);
@@ -1239,19 +1349,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);
 }
@@ -1260,7 +1368,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 = {
@@ -1278,13 +1386,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)
@@ -1292,20 +1416,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
@@ -1317,19 +1433,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),
@@ -1338,4 +1451,4 @@ async function locateRequest(request, options, pathname, { live = false } = {})
 }
 
 //#endregion
-export { createPageHeadInput, getRuntimePathname, handleCamoxRequest, matchRuntimeRoute };
+export { createPageHeadInput, getRuntimePathname, handleCamoxRequest, isPublicRequest, matchRuntimeRoute };

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

@@ -10,6 +10,8 @@ export declare const RUNTIME_ROUTE_PATHS: {
   readonly data: "/_camox/data";
   readonly health: "/_camox/health";
   readonly registry: "/_camox/registry";
+  /** The renderer frame's document (ADR 0023), which the studio loads to render its pages. */
+  readonly renderer: "/_camox/renderer";
   readonly routes: "/_camox/routes";
   readonly logo: "/_camox/logo.png";
   readonly og: "/og";

package/dist/features/runtime/runtimeRoutes.js

@@ -10,6 +10,8 @@ const RUNTIME_ROUTE_PATHS = {
 	data: "/_camox/data",
 	health: "/_camox/health",
 	registry: "/_camox/registry",
+	/** The renderer frame's document (ADR 0023), which the studio loads to render its pages. */
+	renderer: "/_camox/renderer",
 	routes: "/_camox/routes",
 	logo: "/_camox/logo.png",
 	og: "/og",

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

@@ -1,6 +1,19 @@
+import { WorkerEntrypoint } from "cloudflare:workers";
 //#region src/features/runtime/worker.d.ts
+/** What the Worker gets with each request: only `waitUntil` matters here. */
+interface WorkerContext {
+  waitUntil(promise: Promise<unknown>): void;
+}
+/**
+ * The website's Definition Set, for the Worker that loads a revision, which calls it by the name
+ * `DEFINITION_SET_ENTRYPOINT` holds. A named `WorkerEntrypoint` takes RPC calls only: no HTTP
+ * request reaches it.
+ */
+export declare class CamoxDefinitionSet extends WorkerEntrypoint {
+  read(): Promise<unknown>;
+}
 declare const _default: {
-  fetch(request: Request): Promise<Response>;
+  fetch(request: Request, env?: unknown, context?: WorkerContext): Promise<Response>;
 };
 //#endregion
 export { _default as default };

package/dist/features/runtime/worker.js

@@ -1,6 +1,9 @@
+import { rememberPublishingDraft } from "./publishingDraft.js";
 import { fetchLocalhostOnLoopback } from "./loopbackFetch.js";
+import { PUBLIC_CACHE_NAME, readLiveCacheKey, respondThroughPublicCache } from "./publicCache.js";
 import { shouldHandleRequest, withDevHtml } from "./workerRequest.js";
-import { devHtml, handleCamoxRequest, runtimeBasePath } from "virtual:camox/server";
+import { WorkerEntrypoint } from "cloudflare:workers";
+import { devHtml, handleCamoxRequest, isPublicRequest, publicCacheSource, readDefinitionSet, runtimeBasePath } from "virtual:camox/server";
 
 //#region src/features/runtime/worker.ts
 /**
@@ -12,12 +15,39 @@ if (devHtml) globalThis.fetch = fetchLocalhostOnLoopback(globalThis.fetch.bind(g
 function notFound() {
 	return new Response("Not found", { status: 404 });
 }
-var worker_default = { async fetch(request) {
+/**
+* Answers a request, from the edge cache when every visitor sees the same. Dev renders the
+* developer's development draft, which nothing shares, and a Worker calling this one without
+* its context can't keep anything past the response.
+*/
+function respond(request, context) {
+	const caches = globalThis.caches;
+	if (devHtml || !context || !caches || !isPublicRequest(request)) return handleCamoxRequest(request);
+	const { apiUrl, projectUuid, build } = publicCacheSource;
+	return respondThroughPublicCache(request, {
+		cache: () => caches.open(PUBLIC_CACHE_NAME),
+		liveCacheKey: () => readLiveCacheKey(apiUrl, projectUuid),
+		build,
+		waitUntil: (promise) => context.waitUntil(promise)
+	}, () => handleCamoxRequest(request));
+}
+/**
+* The website's Definition Set, for the Worker that loads a revision, which calls it by the name
+* `DEFINITION_SET_ENTRYPOINT` holds. A named `WorkerEntrypoint` takes RPC calls only: no HTTP
+* request reaches it.
+*/
+var CamoxDefinitionSet = class extends WorkerEntrypoint {
+	read() {
+		return readDefinitionSet();
+	}
+};
+var worker_default = { async fetch(request, env, context) {
+	rememberPublishingDraft(env);
 	if (!shouldHandleRequest(request, runtimeBasePath)) return notFound();
-	const response = await handleCamoxRequest(request);
+	const response = await respond(request, context);
 	if (!response) return notFound();
 	return withDevHtml(response, devHtml);
 } };
 
 //#endregion
-export { worker_default as default };
+export { CamoxDefinitionSet, worker_default as default };