camox 0.76.0 → 0.77.0

package/dist/features/runtime/runtime.js

@@ -1,19 +1,19 @@
 import { serializeJsonForHtml } from "../../lib/html.js";
+import { notFound } from "../../core/notFound.js";
 import { createRequestContext } from "../../core/requestContext.js";
 import { UNNAMED_DEFAULT_LOCALE, localizedPath, parseLocalePath } from "../../lib/locale-path.js";
-import { draftNamedBy } from "../../lib/draft-scope.js";
-import { buildClearServerAuthCookieHeader, buildServerAuthCookieHeader, getLookToken, getServerAuthCookieHeader } from "../../lib/server-auth-cookie.js";
+import { buildServerAuthCookieHeader } from "../../lib/server-auth-cookie.js";
 import { getCookie, getSetCookie } from "../../lib/stored-auth-cookies.js";
 import { ARTIFACTS_PATH_PREFIX, RUNTIME_ROUTE_PATHS, matchRuntimeOwnedRoute } from "./runtimeRoutes.js";
 import { reads } from "../../lib/studio-reads.js";
-import { asCollectionItem, recordMarkdownTemplate, recordPageValues } from "../../core/recordItem.js";
+import { recordMarkdownTemplate } from "../../core/recordItem.js";
 import { PLATFORM_SCRIPT } from "../../lib/platform.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 { buildLayoutContext, curatedLayoutContext } from "../../core/layoutContext.js";
-import { buildCamoxPageHead, buildCamoxPageLoaderData, buildFaviconUrl, buildPageHead, buildPageMeta, createServerApiClient, createServerStudioCache, curatedMarkdownResponse, declarePage, isAuthSessionError, isNotFoundError, loadCamoxPage, loadCamoxPageForRequest, parseMarkdownPath, prefersMarkdown, readDraftOrLive, readPageMarkdown, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter } from "../routes/pageRuntime.js";
+import { discoverLayoutPages } from "../../core/derivedRoutes.js";
+import { curatedLayoutContext } from "../../core/layoutContext.js";
+import { buildCamoxPageHead, buildCamoxPageLoaderData, buildFaviconUrl, buildPageHead, buildPageMeta, createServerStudioCache, curatedMarkdownResponse, declarePage, isAuthSessionError, isNotFoundError, loadCamoxPage, parseMarkdownPath, prefersMarkdown, readPageMarkdown, renderedHref, withFrontMatter } from "../routes/pageRuntime.js";
 import { assetPrefix } from "./assetPrefix.js";
 import { documentGoogleFonts } from "../og/documentFonts.js";
 import { alternatesByPage, findAlternates, hreflangLinks } from "./alternates.js";
@@ -26,7 +26,9 @@ import { formatLlmsTxt } from "./llmsTxt.js";
 import { getPageBlockTypes } from "./pageBlockTypes.js";
 import { withPageUrls } from "./structuredData.js";
 import { curatedPageDescription, pageRecords, placedBlockNodes, withStructuredData } from "./pageGraph.js";
+import { mayShowCuratedPage, readPage } from "./pageRead.js";
 import { createProjectLogoResponse, projectLogo } from "./projectLogo.js";
+import { isPrivateRequest, lookReader, resolveReader, visitorReader } from "./reader.js";
 import { DRAFT_SEARCH_PARAM, LOCALE_HEADER, LOOK_BLOCKS_PARAM, LOOK_BLOCK_DEFINITION_PARAM, LOOK_CONTENT_PARAM, LOOK_LAYOUT_DEFINITION_PARAM, LOOK_LOCALE_PARAM, LOOK_PATH_PARAM, LOOK_PLACEHOLDER_HEIGHTS, LOOK_PLACEHOLDER_PARAM, LOOK_SETTINGS_PARAM, UNPLACED_BLOCK_ID } from "@camox/api-contract/drafts";
 import { QueryClient, dehydrate } from "@tanstack/react-query";
 import { createHead, renderSSRHead } from "@unhead/react/server";
@@ -53,16 +55,19 @@ function getRuntimePathname(url, runtimeBasePath = DEFAULT_RUNTIME_BASE_PATH) {
 	if (!pathname.startsWith(`${basePath}/`)) return null;
 	return pathname.slice(basePath.length) || "/";
 }
-/** The draft the request's URL names, if any. Sitemaps and Markdown ignore it: they read Live. */
-function getRequestDraftId(request) {
-	return draftNamedBy(request.url) ?? void 0;
-}
+/** What a response says when no cache may keep it. */
+const PRIVATE_HEADERS = { "Cache-Control": "private, no-store" };
 /**
-* Whether a response may show what only this visitor sees: a session, or a draft named in the
-* URL. Shared caches must never keep it.
+* The headers of what a request reads as `reader`: private when it may show what only this
+* reader sees (or `alwaysPrivate`), varying by the session's cookie, which a stale session's
+* response clears.
 */
-function isPrivateRender(request) {
-	return !!getServerAuthCookieHeader(request.headers) || getRequestDraftId(request) !== void 0;
+function readerHeaders(reader, { alwaysPrivate = false } = {}) {
+	return {
+		...(alwaysPrivate || reader.private) && PRIVATE_HEADERS,
+		Vary: "Cookie",
+		...reader.setCookie && { "Set-Cookie": reader.setCookie }
+	};
 }
 /** The routes whose response is the same for every visitor, unless the request is private. */
 const PUBLIC_ROUTE_KINDS = /* @__PURE__ */ new Set([
@@ -80,7 +85,7 @@ const PUBLIC_ROUTE_KINDS = /* @__PURE__ */ new Set([
 */
 function isPublicRequest(request, options = {}) {
 	if (request.method !== "GET" && request.method !== "HEAD") return false;
-	if (isPrivateRender(request) || new URL(request.url).searchParams.has("ott")) return false;
+	if (isPrivateRequest(request) || new URL(request.url).searchParams.has("ott")) return false;
 	const pathname = getRuntimePathname(request.url, options.runtimeBasePath);
 	return pathname !== null && PUBLIC_ROUTE_KINDS.has(matchRuntimeRoute(pathname).kind);
 }
@@ -147,9 +152,10 @@ async function respondWithLiveWebsite(options, name, respond, { everyLocale = fa
 	const { apiUrl, projectUuid } = options;
 	if (!apiUrl || !projectUuid) return Response.json({ message: `Camox ${name} is not configured.` }, { status: 500 });
 	const app = await options.getCamoxApp?.();
+	const reader = visitorReader(options);
 	const readLocale = async (locale) => {
-		const { projectName, pages } = await createServerApiClient(apiUrl, { locale }).pages.listBySlug({ projectUuid });
-		const records = createRecordLookup(options, "live", { locale });
+		const { projectName, pages } = await reader.api({ locale }).pages.listBySlug({ projectUuid });
+		const records = createRecordLookup(options, reader, { locale });
 		return {
 			locale,
 			projectName,
@@ -163,10 +169,7 @@ async function respondWithLiveWebsite(options, name, respond, { everyLocale = fa
 	let locales;
 	let localizations;
 	try {
-		locales = everyLocale ? [...await readScopeLocales({
-			apiUrl,
-			projectUuid
-		})].sort((a, b) => Number(b.isDefault) - Number(a.isDefault)) : [UNNAMED_DEFAULT_LOCALE];
+		locales = everyLocale ? [...await reader.locales()].sort((a, b) => Number(b.isDefault) - Number(a.isDefault)) : [UNNAMED_DEFAULT_LOCALE];
 		localizations = await Promise.all(locales.map(readLocale));
 	} catch (error) {
 		const discovery = error instanceof RouteDiscoveryError;
@@ -242,15 +245,6 @@ ${entries}
 </urlset>`, { headers: { "Content-Type": "application/xml; charset=utf-8" } });
 	}, { everyLocale: true });
 }
-/** The request's member project, if its session is valid. Without an API, nobody is a member. */
-async function resolveRequestMember(request, options) {
-	if (!options.apiUrl || !options.projectUuid) return { clearAuthCookie: false };
-	return resolveMemberProject({
-		apiUrl: options.apiUrl,
-		authCookieHeader: getServerAuthCookieHeader(request.headers),
-		projectUuid: options.projectUuid
-	});
-}
 /**
 * The first discovered page of a derived layout, which the Canvas previews by default. With
 * `recordId`, the page rendering that record, which the Studio follows when its slug changes.
@@ -265,21 +259,17 @@ async function createRoutesResponse(request, options) {
 	const recordId = searchParams.get("recordId");
 	const layout = camoxApp.getLayoutById(layoutId);
 	if (layout?._internal.kind !== "derived") return new Response("Not found", { status: 404 });
-	const { project, clearAuthCookie } = await resolveRequestMember(request, options);
+	const reader = await resolveReader(request, options);
 	const headers = {
-		"Cache-Control": "private, no-store",
-		Vary: `Cookie, ${LOCALE_HEADER}`,
-		...clearAuthCookie ? { "Set-Cookie": buildClearServerAuthCookieHeader() } : {}
+		...readerHeaders(reader, { alwaysPrivate: true }),
+		Vary: `Cookie, ${LOCALE_HEADER}`
 	};
 	const tag = request.headers.get(LOCALE_HEADER);
 	try {
-		const pages = await discoverLayoutPages(layout, createLayoutRequestContext(options, project ? "draft" : "live", {
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			locale: tag ? {
-				tag,
-				isDefault: false
-			} : void 0
-		}));
+		const pages = await discoverLayoutPages(layout, createLayoutRequestContext(options, reader, { locale: tag ? {
+			tag,
+			isDefault: false
+		} : void 0 }));
 		const page = recordId ? pages.find((entry) => entry.recordId === recordId) : pages[0];
 		return Response.json({ path: page?.path ?? null }, { headers });
 	} catch (error) {
@@ -313,7 +303,7 @@ async function createOgResponse(request, options) {
 			source.context,
 			style
 		])),
-		"Cache-Control": isPrivateRender(request) ? "private, no-store" : "public, no-cache"
+		"Cache-Control": isPrivateRequest(request) ? PRIVATE_HEADERS["Cache-Control"] : "public, no-cache"
 	};
 	if (namesEtag(request, headers.ETag)) return new Response(null, {
 		status: 304,
@@ -329,66 +319,38 @@ 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);
+	const requestReader = await resolveReader(request, options);
+	const located = await locateRequest(requestReader, 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);
-	const api = (draftId) => createServerApiClient(apiUrl, {
-		authCookieHeader,
+	const reader = pageReaderOf(options, requestReader, located.locale);
+	const api = (draftId) => requestReader.api({
 		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({
+	const shown = await readPage({
+		app,
+		path: located.path,
+		pathname: path,
+		reader,
+		curated: () => reader.inScope((draftId) => api(draftId).pages.getByPath({
+			path: located.path,
+			projectUuid
+		})),
+		layout: (draftId, layoutId) => 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
-			})
-		};
+			layoutId
+		})
+	});
+	if (shown.kind === "none") return null;
+	if (shown.kind === "layout") return {
+		layout: shown.layout._internal,
+		context: shown.context
 	};
-	/** 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;
-		}
+	const { page } = shown;
+	return {
+		layout: page.layout ? app.getLayoutById(page.layout.layoutId)?._internal : void 0,
+		context: curatedLayoutContext(page, located.locale)
 	};
-	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 {
@@ -491,17 +453,19 @@ function renderBlockPreloads(options, dehydratedState) {
 * 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",
+	return htmlResponse(htmlDocument({
+		before: `<meta charset="utf-8"><meta name="robots" content="noindex"><title>Camox renderer</title>`,
+		data: {
+			apiUrl: options.apiUrl,
+			authenticationUrl: options.authenticationUrl,
+			projectUuid: options.projectUuid,
+			runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath)
+		},
+		entryUrl: options.rendererClientEntryUrl
+	}), {
+		...PRIVATE_HEADERS,
 		"X-Robots-Tag": "noindex"
-	} });
+	});
 }
 /**
 * Marks the look document ready (`data-camox-ready` on its root element) for the browser to wait
@@ -515,7 +479,7 @@ function createRendererDocumentResponse(options) {
 const LOOK_READY_SCRIPT = `(()=>{const loaded=new WeakSet();let hydrated=false,marked=false;const mark=()=>{if(marked||!hydrated||document.readyState!=="complete")return;const frames=[...document.querySelectorAll("iframe")];for(const frame of frames)if(frame.getAttribute("loading")==="lazy")frame.setAttribute("loading","eager");if(!frames.every((frame)=>loaded.has(frame)))return;marked=true;requestAnimationFrame(()=>requestAnimationFrame(()=>document.documentElement.setAttribute("data-camox-ready","")))};const settle=(event)=>{if(event.target&&event.target.tagName==="IFRAME")loaded.add(event.target);mark()};document.addEventListener("load",settle,true);document.addEventListener("error",settle,true);addEventListener("load",mark,{once:true});addEventListener("camox:hydrated",()=>{hydrated=true;mark()},{once:true})})()`;
 /** The headers every look document answer carries: private, never cached, never indexed. */
 const LOOK_HEADERS = {
-	"Cache-Control": "private, no-store",
+	...PRIVATE_HEADERS,
 	"X-Robots-Tag": "noindex"
 };
 /** What the look document answers when it shows nothing: no token, or one the API refused. */
@@ -566,9 +530,9 @@ function overrideParam(searchParams, name) {
 async function createLookDocumentResponse(request, options) {
 	const { apiUrl, authenticationUrl, projectUuid, renderPage } = options;
 	const { searchParams } = new URL(request.url);
-	const lookToken = getLookToken(request.headers);
-	const draftId = searchParams.get(DRAFT_SEARCH_PARAM) ?? void 0;
-	if (!lookToken || !draftId || !apiUrl || !authenticationUrl || !projectUuid || !renderPage) return lookNotFound();
+	const reader = lookReader(request, options);
+	if (!reader || !apiUrl || !authenticationUrl || !projectUuid || !renderPage) return lookNotFound();
+	const draftId = reader.draftId;
 	const tag = searchParams.get(LOOK_LOCALE_PARAM)?.toLowerCase();
 	const blockDefinition = searchParams.get(LOOK_BLOCK_DEFINITION_PARAM);
 	const layoutDefinition = searchParams.get(LOOK_LAYOUT_DEFINITION_PARAM);
@@ -577,15 +541,12 @@ async function createLookDocumentResponse(request, options) {
 	let locale;
 	let shown;
 	try {
-		locales = await createServerApiClient(apiUrl, {
-			lookToken,
-			draftId
-		}).locales.list({ projectUuid });
+		locales = await reader.locales();
 		locale = locales.find((each) => tag ? each.tag.toLowerCase() === tag : each.isDefault);
 		if (!locale) return lookNotFound();
 		const reading = {
 			apiUrl,
-			lookToken,
+			reader,
 			draftId,
 			locale,
 			projectUuid,
@@ -613,27 +574,16 @@ async function createLookDocumentResponse(request, options) {
 		locales
 	};
 	const appHtml = await renderPage(input);
-	const renderedHead = renderHead(document, createPageHeadInput(shown.head), options.stylesheetUrl, void 0, locale);
-	return new Response(`<!doctype html>
-<html${renderedHead.htmlAttrs}>
-<head>
-${renderedHead.headTags}
-<meta name="robots" content="noindex">
-<script>${LOOK_READY_SCRIPT}<\/script>
-${renderBlockPreloads(options, dehydratedState)}
-<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(hydrationInputFor(input, appHtml))}<\/script>
-</head>
-<body${renderedHead.bodyAttrs}>
-${renderedHead.bodyTagsOpen}
-<div id="root">${appHtml}</div>
-${renderedHead.bodyTags}
-${renderClientEntryScript(options.pageClientEntryUrl)}
-</body>
-</html>`, { headers: {
+	return htmlResponse(htmlDocument({
+		head: renderHead(document, createPageHeadInput(shown.head), options.stylesheetUrl, void 0, locale),
+		after: `<meta name="robots" content="noindex"><script>${LOOK_READY_SCRIPT}<\/script>${renderBlockPreloads(options, dehydratedState)}`,
+		data: hydrationInputFor(input, appHtml),
+		root: appHtml,
+		entryUrl: options.pageClientEntryUrl
+	}), {
 		...LOOK_HEADERS,
-		"Content-Type": "text/html; charset=utf-8",
 		"Referrer-Policy": "no-referrer"
-	} });
+	});
 }
 /** Where the look document's client believes it is: `path` of the draft, in its Locale. */
 function lookHref(request, options, pathname, draftId) {
@@ -642,65 +592,38 @@ function lookHref(request, options, pathname, draftId) {
 	return href;
 }
 /**
-* The look document's page at `path`, with its head, as a visitor would see it. A path is
-* matched as the website serves it: a singleton layout's route first, then a curated page, then a
-* derived layout's route.
+* The look document's page at `path`, with its head, as a visitor would see it: whatever Page
+* Read finds there, read with the look token in its draft. A Layout's route whose loader finds
+* nothing answers why.
 */
 async function lookAtPage(request, options, reading) {
-	const { apiUrl, draftId, locale } = reading;
+	const { apiUrl, draftId, locale, projectUuid, queryClient } = reading;
 	const path = normalizePagePath(new URL(request.url).searchParams.get(LOOK_PATH_PARAM));
-	const camoxApp = await options.getCamoxApp?.();
-	const match = camoxApp && matchDerivedLayout(camoxApp.getLayouts(), path);
-	if (match?.layout._internal.kind === "singleton") return lookAtLayoutPage(request, options, reading, path, match);
-	let page;
-	try {
-		page = await loadCamoxPage({
-			...reading,
-			pathname: path
-		});
-	} catch (error) {
-		if (match && isNotFoundError(error)) return lookAtLayoutPage(request, options, reading, path, match);
-		throw error;
-	}
-	const pathname = localizedPath(path, locale);
-	const href = lookHref(request, options, pathname, draftId);
-	const loaderData = buildCamoxPageLoaderData(apiUrl, page, href.origin);
-	return {
-		head: camoxApp ? buildCamoxPageHead(camoxApp, loaderData, locale) : {},
-		href: href.href,
-		layoutIdentity: getLayoutIdentity(page.layout),
-		loaderData,
-		pathname
-	};
-}
-/**
-* The look document's page of a singleton or derived layout at `path`: the layout's blocks, read
-* with the look token, around what its loader returns, its records read from the draft. A loader
-* that finds nothing answers why.
-*/
-async function lookAtLayoutPage(request, options, reading, path, match) {
-	const { apiUrl, lookToken, draftId, locale, projectUuid, queryClient } = reading;
 	const app = await options.getCamoxApp?.();
-	const layout = match.layout._internal;
 	const pathname = localizedPath(path, locale);
-	let result;
-	let shared;
-	try {
-		[result, shared] = await Promise.all([loadLayoutResult(app, match, createLayoutRequestContext(options, "draft", {
-			lookToken,
-			draftId,
-			locale
-		}), locale), createServerApiClient(apiUrl, {
-			lookToken,
-			draftId,
-			locale
-		}).layouts.get({
+	const api = (inDraft) => reading.reader.api({
+		draftId: inDraft,
+		locale
+	});
+	const reader = pageReaderOf(options, reading.reader, locale);
+	const shown = await readPage({
+		app,
+		path,
+		pathname,
+		reader,
+		curated: () => reader.inScope((inDraft) => loadCamoxPage({
+			...reading,
+			draftId: inDraft,
+			pathname: path
+		})),
+		layout: (inDraft, layoutId) => api(inDraft).layouts.get({
 			projectUuid,
-			layoutId: layout.id
-		})]);
-	} catch (error) {
-		if (!isNotFoundError(error)) throw error;
-		return new Response(`The draft has no page at ${path}: the ${layout.id} layout's loader found nothing to show.`, {
+			layoutId
+		})
+	});
+	if (shown.kind === "none") {
+		if (!shown.layout) return lookNotFound();
+		return new Response(`The draft has no page at ${path}: the ${shown.layout._internal.id} layout's loader found nothing to show.`, {
 			status: 404,
 			headers: {
 				...LOOK_HEADERS,
@@ -708,58 +631,84 @@ async function lookAtLayoutPage(request, options, reading, path, match) {
 			}
 		});
 	}
-	const studioCache = createServerStudioCache(queryClient, {
+	const href = lookHref(request, options, pathname, draftId);
+	if (shown.kind === "curated") return curatedPageShown({
+		app,
 		apiUrl,
-		lookToken,
-		locale
+		page: shown.page,
+		locale,
+		href: href.href,
+		pathname
 	});
-	const inDraft = { in: draftId };
-	const runtimeBasePath = normalizeRuntimeBasePath(options.runtimeBasePath);
-	studioCache.land(reads.layoutStructure({
-		projectUuid,
-		layoutId: layout.id
-	}), shared, inDraft);
-	studioCache.set(reads.derivedPageData({
+	landLayoutPage(createServerStudioCache(queryClient, {
+		reader: reading.reader,
+		locale
+	}), shown, {
 		projectUuid,
-		runtimeBasePath,
+		options,
+		pathname
+	}, { in: draftId });
+	return layoutPageShown({
+		page: shown,
+		apiUrl,
+		href: href.href,
 		pathname
-	}), result ?? null, inDraft);
-	const href = lookHref(request, options, pathname, draftId);
-	const record = asCollectionItem(result);
-	const collection = record && app?.getCollectionById(record.collectionId);
-	const context = buildLayoutContext(layout, {
-		path: pathname,
-		locale: locale.tag,
-		projectName: shared.projectName,
-		data: result?.data,
-		params: match.params,
-		record: record && collection ? recordPageValues(collection, record) : void 0
 	});
+}
+/** What a render shows of a curated page. */
+function curatedPageShown({ app, apiUrl, page, locale, href, pathname }) {
+	const loaderData = buildCamoxPageLoaderData(apiUrl, page, new URL(href).origin);
+	return {
+		head: app ? buildCamoxPageHead(app, loaderData, locale) : {},
+		href,
+		layoutIdentity: getLayoutIdentity(page.layout),
+		loaderData,
+		pathname
+	};
+}
+/**
+* What a render shows of a Layout Page: its head from its layout's options, and the layout, its
+* loader's result and its route's params, which its client renders it from.
+*/
+function layoutPageShown({ page, apiUrl, href, pathname }) {
+	const layout = page.layout._internal;
 	return {
 		head: buildPageHead({
 			layout,
-			context,
-			origin: href.origin,
-			faviconUrl: buildFaviconUrl(apiUrl, shared.project),
+			context: page.context,
+			origin: new URL(href).origin,
+			faviconUrl: buildFaviconUrl(apiUrl, page.blocks.project),
 			hasMarkdown: layout.toMarkdown !== void 0,
-			recordType: record?.structuredData?.node?.["@type"]
+			recordType: page.record?.item.structuredData?.node?.["@type"]
 		}),
-		href: href.href,
-		layoutIdentity: getLayoutIdentity(shared.layout),
+		href,
+		layoutIdentity: getLayoutIdentity(page.blocks.layout),
 		loaderData: null,
 		pathname,
 		derived: {
 			layoutId: layout.id,
 			page: {
-				params: match.params,
+				params: page.params,
 				path: pathname,
-				projectName: shared.projectName
+				projectName: page.blocks.projectName
 			},
-			result,
-			layout: shared.layout
+			result: page.result,
+			layout: page.blocks.layout
 		}
 	};
 }
+/** Lands a Layout Page's reads in the studio's cache, which its client reads them from. */
+function landLayoutPage(studioCache, page, { projectUuid, options, pathname }, inDraft) {
+	studioCache.land(reads.layoutStructure({
+		projectUuid,
+		layoutId: page.layout._internal.id
+	}), page.blocks, inDraft);
+	studioCache.set(reads.derivedPageData({
+		projectUuid,
+		runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
+		pathname
+	}), page.result ?? null, inDraft);
+}
 /**
 * The look document's Block Definition mode: the block of the Block Definition `type` as the
 * draft would show it placed, its content and Block Settings empty but for the overrides the URL
@@ -768,22 +717,20 @@ async function lookAtLayoutPage(request, options, reading, path, match) {
 * as a page's block does; its page is the Locale's home, which links resolve against.
 */
 async function lookAtBlockDefinition(request, options, reading, type) {
-	const { apiUrl, lookToken, draftId, locale, projectUuid, queryClient } = reading;
+	const { reader, draftId, locale, projectUuid, queryClient } = reading;
 	const { searchParams } = new URL(request.url);
 	const content = overrideParam(searchParams, LOOK_CONTENT_PARAM);
 	const settings = overrideParam(searchParams, LOOK_SETTINGS_PARAM);
 	if (!content.ok) return lookRefused(content.error);
 	if (!settings.ok) return lookRefused(settings.error);
 	const studioCache = createServerStudioCache(queryClient, {
-		apiUrl,
-		lookToken,
+		reader,
 		locale
 	});
 	const inDraft = { in: draftId };
 	let bundle;
 	try {
-		[bundle] = await Promise.all([createServerApiClient(apiUrl, {
-			lookToken,
+		[bundle] = await Promise.all([reader.api({
 			draftId,
 			locale
 		}).blocks.getUnplaced({
@@ -815,22 +762,20 @@ async function lookAtBlockDefinition(request, options, reading, type) {
 * says. Its path is the Locale's home, which links resolve against.
 */
 async function lookAtLayoutDefinition(request, options, reading, layoutId) {
-	const { apiUrl, lookToken, draftId, locale, projectUuid, queryClient } = reading;
+	const { reader, draftId, locale, projectUuid, queryClient } = reading;
 	const { searchParams } = new URL(request.url);
 	const blocks = overrideParam(searchParams, LOOK_BLOCKS_PARAM);
 	if (!blocks.ok) return lookRefused(blocks.error);
 	const placeholder = searchParams.get(LOOK_PLACEHOLDER_PARAM) ?? LOOK_PLACEHOLDER_HEIGHTS[0];
 	if (!LOOK_PLACEHOLDER_HEIGHTS.includes(placeholder)) return lookRefused(`The placeholder is ${LOOK_PLACEHOLDER_HEIGHTS.join(" or ")}.`);
 	const studioCache = createServerStudioCache(queryClient, {
-		apiUrl,
-		lookToken,
+		reader,
 		locale
 	});
 	const inDraft = { in: draftId };
 	let shared;
 	try {
-		[shared] = await Promise.all([createServerApiClient(apiUrl, {
-			lookToken,
+		[shared] = await Promise.all([reader.api({
 			draftId,
 			locale
 		}).layouts.getUnplaced({
@@ -871,6 +816,38 @@ function renderClientEntryScript(src) {
 	if (!src) return "";
 	return `<script type="module" src="${escapeXml(src)}"><\/script>`;
 }
+const NO_HEAD = {
+	htmlAttrs: "",
+	headTags: "",
+	bodyAttrs: "",
+	bodyTagsOpen: "",
+	bodyTags: ""
+};
+/**
+* Every document the runtime serves: its head, between what comes `before` and `after` it, the
+* render input its client starts from (`__CAMOX_DATA__`), the app's HTML in its root, if it has
+* one, and the client's entry script.
+*/
+function htmlDocument({ head = NO_HEAD, before = "", after = "", data, root, entryUrl }) {
+	return `<!doctype html>
+<html${head.htmlAttrs}>
+<head>
+${before}${head.headTags}${after}
+<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(data)}<\/script>
+</head>
+<body${head.bodyAttrs}>
+${head.bodyTagsOpen}${root === void 0 ? "" : `<div id="root">${root}</div>`}
+${head.bodyTags}
+${renderClientEntryScript(entryUrl)}
+</body>
+</html>`;
+}
+/** An HTML document's response. */
+function htmlResponse(html, headers) {
+	const response = new Response(html, { headers });
+	response.headers.set("Content-Type", "text/html; charset=utf-8");
+	return response;
+}
 /**
 * 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.
@@ -981,7 +958,7 @@ async function createSignInResponse(request, apiUrl) {
 		status: 302,
 		headers: {
 			Location: `${url.pathname}${url.search}`,
-			"Cache-Control": "private, no-store",
+			...PRIVATE_HEADERS,
 			"Referrer-Policy": "no-referrer",
 			"Set-Cookie": buildServerAuthCookieHeader(session, { secure: url.protocol === "https:" })
 		}
@@ -1063,15 +1040,10 @@ function withLocatedTags(head, { url, locale, alternates }) {
 		}]
 	};
 }
-function requestLocaleReads(options, { authCookieHeader, draftId, queryClient }) {
+function requestLocaleReads(options, { reader, 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;
+	const studioCache = queryClient ? createServerStudioCache(queryClient, { reader }) : void 0;
 	return {
 		pages: (locale) => {
 			if (!apiUrl || !projectUuid) return Promise.resolve([]);
@@ -1080,19 +1052,19 @@ function requestLocaleReads(options, { authCookieHeader, draftId, queryClient })
 				locale
 			});
 			if (loaded) return Promise.resolve(loaded);
-			const read = pagesByLocale.get(locale.tag) ?? createServerApiClient(apiUrl, {
-				...reading,
+			const read = pagesByLocale.get(locale.tag) ?? reader.api({
+				draftId,
 				locale
 			}).pages.listBySlug({ projectUuid }).then(({ pages }) => pages);
 			pagesByLocale.set(locale.tag, read);
 			return read;
 		},
-		context: (locale) => createLayoutRequestContext(options, source, {
-			...reading,
+		context: (locale) => createLayoutRequestContext(options, reader, {
+			draftId,
 			locale
 		}),
-		records: (locale) => createRecordLookup(options, source, {
-			...reading,
+		records: (locale) => createRecordLookup(options, reader, {
+			draftId,
 			locale
 		})
 	};
@@ -1167,71 +1139,116 @@ async function createPreviewHandoffResponse({ options, pathname, request }) {
 		layoutIdentity: null,
 		dehydratedState: dehydrate(new QueryClient())
 	};
-	const html = await options.renderPage(input);
-	return new Response(`<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="referrer" content="no-referrer"><title>Camox draft preview</title><script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(input)}<\/script></head><body><div id="root">${html}</div>${renderClientEntryScript(options.pageClientEntryUrl)}</body></html>`, { headers: {
-		"Content-Type": "text/html; charset=utf-8",
-		"Cache-Control": "private, no-store",
+	return htmlResponse(htmlDocument({
+		before: `<meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="referrer" content="no-referrer"><title>Camox draft preview</title>`,
+		data: input,
+		root: await options.renderPage(input),
+		entryUrl: options.pageClientEntryUrl
+	}), {
+		...PRIVATE_HEADERS,
 		"Referrer-Policy": "no-referrer"
-	} });
+	});
 }
-/** Starts reading the curated page at a locale-relative path, as the request reads it. */
-function readCuratedPage(options, request, { locale, path }) {
+/**
+* What Page Read needs of the request's Reader, in one Locale. Only a Member's Draft can be
+* refused, so only then does the first read settle the Draft; anyone else reads one scope
+* throughout: a Visitor Live, a look token its own Draft.
+*/
+function pageReaderOf(options, reader, locale) {
+	return {
+		locale,
+		inScope: (read) => reader.read(read),
+		...!(reader.member && reader.draftId) && { draft: { id: reader.draftId } },
+		records: (draftId) => createRecordLookup(options, reader, {
+			draftId,
+			locale
+		})
+	};
+}
+/** Starts reading the curated page at a locale-relative path, as the request's Reader reads it. */
+function readCuratedPage(options, reader, { locale, path }) {
 	const queryClient = new QueryClient();
 	return {
 		queryClient,
-		result: loadCamoxPageForRequest({
-			apiUrl: options.apiUrl,
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: getRequestDraftId(request),
+		result: reader.read((draftId) => loadCamoxPage({
+			reader,
+			draftId,
 			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})*(?:\/|$)/;
+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.
+* The read of the curated page a path most likely names, started while the request's locales are
+* read, so the page's read needn't wait for them: when its first segment names a language, as a
+* locale's prefix does, in that language's locale, at the rest of the path; otherwise in the
+* default locale, at the path. A locale's prefix is its tag in lowercase. Once read, the locales
+* confirm the guess, or the read is left unused. A path that never shows a curated page reads
+* none.
 */
-async function readDefaultLocalePageEarly(options, request, pathname) {
+async function readPageEarly(options, reader, pathname) {
 	const { apiUrl, projectUuid } = options;
 	if (!apiUrl || !projectUuid) return void 0;
-	if (matchLocalizedRoute(pathname)?.kind !== "page" || LOCALE_PREFIX_LIKE.test(pathname)) return;
+	const prefixed = LOCALE_PREFIX_LIKE.exec(pathname);
+	const language = prefixed && languageTagOf(prefixed[1]);
+	const guessed = language ? {
+		locale: {
+			tag: language,
+			isDefault: false
+		},
+		path: pathname.slice(prefixed[0].replace(/\/$/, "").length) || "/"
+	} : {
+		locale: UNNAMED_DEFAULT_LOCALE,
+		path: pathname
+	};
+	if (matchLocalizedRoute(guessed.path)?.kind !== "page") return void 0;
 	const app = await options.getCamoxApp?.().catch(() => void 0);
-	if (app && matchDerivedLayout(app.getLayouts(), pathname)?.layout._internal.kind === "singleton") return void 0;
+	if (!mayShowCuratedPage(app, guessed.path)) return void 0;
 	const read = readCuratedPage({
 		...options,
-		apiUrl,
 		projectUuid
-	}, request, {
-		locale: UNNAMED_DEFAULT_LOCALE,
-		path: pathname
-	});
+	}, reader, guessed);
 	read.result.catch(() => void 0);
-	return read;
+	return {
+		locale: guessed.locale,
+		read
+	};
+}
+const languageNames = new Intl.DisplayNames(["en"], {
+	type: "language",
+	fallback: "none"
+});
+/** The canonical tag of the language a locale's prefix names, or null when it names none. */
+function languageTagOf(prefix) {
+	try {
+		const [tag] = Intl.getCanonicalLocales(prefix);
+		return tag && languageNames.of(tag) ? tag : null;
+	} catch {
+		return null;
+	}
+}
+/** The early read, when it's the request's page's: in the locale the request's path names. */
+function earlyReadIn(early, { locale }) {
+	if (!early) return void 0;
+	return (locale.isDefault ? early.locale.isDefault : early.locale.tag === locale.tag) ? early.read : void 0;
 }
 /**
 * 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.
+* while the page is read. When the Reader has no Draft to read, the request reads Live, so 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);
+function curatedPageLocaleReads(options, reader, located, queryClient) {
 	const forDraft = (draftId) => requestLocaleReads(options, {
-		authCookieHeader,
+		reader,
 		draftId,
 		queryClient
 	});
-	if (!(!getRequestDraftId(request) || !authCookieHeader)) return forDraft;
+	if (reader.draftId) 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;
@@ -1239,119 +1256,189 @@ function curatedPageLocaleReads(options, request, located, queryClient) {
 	}
 	return () => live;
 }
-async function createPageHtmlResponse({ options, pathname, located, request, pageRead }) {
-	if (!options.apiUrl || !options.authenticationUrl || !options.projectUuid || !options.renderPage) return createPageDataResponse({
-		options,
+/**
+* A page's HTML, or with `dataOnly` its render input as JSON, which client navigation loads:
+* whatever Page Read finds at the path, as the request reads it. A runtime that can't render
+* pages answers their data.
+*/
+async function createPageResponse({ options, pathname, located, request, reader: requestReader, pageRead, dataOnly: dataRequested }) {
+	const { apiUrl, projectUuid, renderPage } = options;
+	if (!apiUrl || !projectUuid) return Response.json({ message: "Camox page loader is not configured." }, { status: 500 });
+	const dataOnly = dataRequested || !options.authenticationUrl || !renderPage;
+	const app = await options.getCamoxApp?.();
+	const reader = pageReaderOf(options, requestReader, located.locale);
+	const api = (draftId) => requestReader.api({
+		draftId,
+		locale: located.locale
+	});
+	const curatedRead = pageRead ?? {
+		queryClient: new QueryClient(),
+		result: void 0
+	};
+	let localeReads;
+	const shown = await readPage({
+		app,
+		path: located.path,
 		pathname,
-		located,
-		request,
-		pageRead
+		reader,
+		curated: () => {
+			localeReads = curatedPageLocaleReads(options, requestReader, located, curatedRead.queryClient);
+			return curatedRead.result ?? reader.inScope((draftId) => loadCamoxPage({
+				reader: requestReader,
+				draftId,
+				locale: located.locale,
+				pathname: located.path,
+				projectUuid,
+				queryClient: curatedRead.queryClient
+			}));
+		},
+		layout: (draftId, layoutId) => api(draftId).layouts.get({
+			projectUuid,
+			layoutId
+		})
 	});
-	const singleton = await createDerivedResponse(options, pathname, located, request, { singletonOnly: true });
-	if (singleton) return singleton;
-	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 reading;
-		const headers = new Headers({
-			"Content-Type": "text/html; charset=utf-8",
-			Vary: "Cookie",
-			Link: llmsTxtLinkHeader(options)
+	if (shown.kind === "none") {
+		if (shown.layout) return new Response("Page not found", { status: 404 });
+		return dataOnly ? Response.json({
+			kind: "page",
+			message: "No Camox page on this path",
+			pathname
+		}, { status: 404 }) : new Response("No Camox page on this path", { status: 404 });
+	}
+	const href = renderedHref(request.url, shown);
+	const queryClient = shown.kind === "curated" ? curatedRead.queryClient : new QueryClient();
+	let page;
+	let readAlternatesOf;
+	let site;
+	if (shown.kind === "curated") {
+		page = curatedPageShown({
+			app,
+			apiUrl,
+			page: shown.page,
+			locale: located.locale,
+			href,
+			pathname
 		});
-		if (isPrivateRender(request)) headers.set("Cache-Control", "private, no-store");
-		if (result.shouldClearAuthCookie) headers.append("Set-Cookie", buildClearServerAuthCookieHeader());
-		const camoxApp = await options.getCamoxApp?.();
-		const document = await options.getDocument?.() ?? {};
-		if (isHiddenFromSearchEngines(result.data.page.project)) headers.set("X-Robots-Tag", "noindex");
-		const { alternates, head } = await readAlternates(request, options, {
-			located,
+		site = shown.page.project;
+		readAlternatesOf = {
 			identity: {
 				kind: "curated",
-				pageId: result.data.page.page.id
+				pageId: shown.page.page.id
 			},
-			head: withSearchEngineMark(camoxApp ? buildCamoxPageHead(camoxApp, result.data, located.locale) : {}, result.data.page.project),
-			described: curatedPageDescription(camoxApp, result.data.page, located.locale),
-			localeReads: localeReads(result.draftId)
+			described: curatedPageDescription(app, shown.page, located.locale),
+			localeReads: localeReads(shown.draftId)
+		};
+	} else {
+		landLayoutPage(createServerStudioCache(queryClient, {
+			reader: requestReader,
+			locale: located.locale
+		}), shown, {
+			projectUuid,
+			options,
+			pathname
+		}, { in: shown.draftId ?? null });
+		page = layoutPageShown({
+			page: shown,
+			apiUrl,
+			href,
+			pathname
 		});
-		const dehydratedState = dehydrate(queryClient);
-		const { project } = result;
-		const studio = project !== void 0;
-		const analytics = visitorAnalytics({
-			studio,
-			draftId: result.draftId
-		}, result.data.page.project);
-		const pageRenderInput = await withArtifactsByUrl({
-			alternates,
-			project,
-			presentation: studio ? "studio" : "public",
-			...analytics && { analytics },
-			apiUrl: options.apiUrl,
-			authenticationUrl: options.authenticationUrl,
-			dehydratedState,
-			draftId: result.draftId,
-			refusedDraft: result.refusedDraft,
-			head,
-			href: renderedHref(request.url, result),
-			layoutIdentity: getLayoutIdentity(result.data.page.layout),
-			loaderData: result.data,
-			pathname,
-			projectUuid: options.projectUuid,
-			runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
-			locale: located.locale,
-			locales: located.locales
-		}, options);
-		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>
-<html${renderedHead.htmlAttrs}>
-<head>
-${renderStudioThemeScript(studio)}
-${renderedHead.headTags}
-${renderAnalyticsScripts(analytics)}
-${studio ? "" : renderBlockPreloads(options, dehydratedState)}
-<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(hydrationInputFor(pageRenderInput, appHtml))}<\/script>
-</head>
-<body${renderedHead.bodyAttrs}>
-${renderedHead.bodyTagsOpen}
-<div id="root">${appHtml}</div>
-${renderedHead.bodyTags}
-${renderClientEntryScript(options.pageClientEntryUrl)}
-</body>
-</html>`, { headers });
-	} catch (error) {
-		if (isNotFoundError(error)) {
-			const derived = await createDerivedResponse(options, pathname, located, request);
-			if (derived) return derived;
-			return new Response("No Camox page on this path", { status: 404 });
-		}
-		throw error;
+		site = shown.blocks.project;
+		const { blocks, record } = shown;
+		readAlternatesOf = {
+			identity: record && shown.layout._internal.kind === "derived" ? {
+				kind: "record",
+				layout: shown.layout,
+				recordId: record.item.data.id
+			} : { kind: "code-owned" },
+			described: {
+				project: {
+					...blocks.project,
+					name: blocks.projectName
+				},
+				title: shown.context.page.title,
+				declared: declarePage({
+					layout: shown.layout._internal,
+					context: shown.context
+				}),
+				blocks: placedBlockNodes(blocks.layout, [], blocks.structuredData),
+				...record?.item.published && { published: record.item.published },
+				records: pageRecords(blocks.recordStructuredData, record && {
+					id: record.item.data.id,
+					structuredData: record.item.structuredData,
+					titles: record.values.titles
+				})
+			},
+			localeReads: requestLocaleReads(options, {
+				reader: requestReader,
+				draftId: shown.draftId
+			})
+		};
 	}
+	const { alternates, head } = await readAlternates(request, options, {
+		...readAlternatesOf,
+		located,
+		head: withSearchEngineMark(page.head, site)
+	});
+	const studio = requestReader.member !== void 0;
+	const analytics = dataOnly ? void 0 : visitorAnalytics({
+		studio,
+		draftId: shown.draftId
+	}, site);
+	const dehydratedState = dehydrate(queryClient);
+	const input = await withArtifactsByUrl({
+		...page,
+		head,
+		alternates,
+		project: requestReader.member,
+		presentation: studio ? "studio" : "public",
+		...analytics && { analytics },
+		apiUrl,
+		authenticationUrl: options.authenticationUrl ?? "",
+		projectUuid,
+		dehydratedState,
+		draftId: shown.draftId,
+		refusedDraft: shown.refusedDraft,
+		runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
+		locale: located.locale,
+		locales: located.locales
+	}, options);
+	const document = await options.getDocument?.() ?? {};
+	preparePreviewDocument(input, options, document);
+	const headers = readerHeaders(requestReader);
+	if (dataOnly) return Response.json(input, { headers: {
+		...headers,
+		"Content-Type": "application/json; charset=utf-8"
+	} });
+	const appHtml = await renderPage(input);
+	return htmlResponse(htmlDocument({
+		head: renderHead(studio ? {} : document, createPageHeadInput(head), studio ? void 0 : options.stylesheetUrl, studio ? options.studioStylesheetUrl : void 0, studio ? void 0 : located.locale),
+		before: renderStudioThemeScript(studio),
+		after: `${renderAnalyticsScripts(analytics)}${studio ? "" : renderBlockPreloads(options, dehydratedState)}`,
+		data: hydrationInputFor(input, appHtml),
+		root: appHtml,
+		entryUrl: options.pageClientEntryUrl
+	}), {
+		...headers,
+		Link: llmsTxtLinkHeader(options),
+		...isHiddenFromSearchEngines(site) && { "X-Robots-Tag": "noindex" }
+	});
 }
 /**
-* The context `loader` and `routes` get. Its record lookup reads each record's current content;
-* only draft reads carry the editor's session, and `draftId` names the draft they read.
+* The context `loader` and `routes` get. Its record lookup reads each record's current content as
+* the request's Reader, in the draft the request settled on.
 */
-function createLayoutRequestContext(options, source, reading) {
-	return createRequestContext({ records: createRecordLookup(options, source, reading) });
+function createLayoutRequestContext(options, reader, scope) {
+	return createRequestContext({ records: createRecordLookup(options, reader, scope) });
 }
 /**
-* Reads the records `loader` and `routes` ask for, in `locale` or the default locale; none
-* without an API.
+* Reads the records `loader` and `routes` ask for as the request's Reader, in `locale` or the
+* default locale; none without an API.
 */
-function createRecordLookup(options, source, { authCookieHeader, lookToken, draftId, locale } = {}) {
+function createRecordLookup(options, reader, scope = {}) {
 	const { apiUrl, projectUuid } = options;
 	if (!apiUrl || !projectUuid) return void 0;
-	const api = createServerApiClient(apiUrl, {
-		authCookieHeader: source === "draft" ? authCookieHeader : void 0,
-		lookToken: source === "draft" ? lookToken : void 0,
-		draftId,
-		locale
-	});
+	const api = reader.api(scope);
 	return {
 		findByField: (input) => api.collectionDefinitions.findRecordsByField({
 			...input,
@@ -1363,155 +1450,116 @@ function createRecordLookup(options, source, { authCookieHeader, lookToken, draf
 		})
 	};
 }
-const RECORD_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** An envelope names its record; it doesn't authorize anything, the API does. */
-function isValidCollectionItem(app, result) {
-	const data = result.data;
-	return typeof result.collectionId === "string" && !!app?.getCollectionById(result.collectionId) && typeof data?.id === "string" && RECORD_ID.test(data.id) && typeof data.content === "object" && data.content !== null;
-}
-/**
-* Runs a code-owned page's loader in the page's locale. The envelope survives SSR, navigation and
-* hydration, and its data renders as returned: Camox never translates it.
-*/
-async function loadLayoutResult(app, match, context, locale) {
-	const { loader, id } = match.layout._internal;
-	if (!loader) return void 0;
-	const result = await loader({
-		params: match.params,
-		context,
-		locale: locale.tag
-	});
-	const serializedResult = result === void 0 ? void 0 : JSON.parse(JSON.stringify(result));
-	const record = asCollectionItem(serializedResult);
-	if (!(record ? isValidCollectionItem(app, record) : serializedResult?.kind === "data" && Object.hasOwn(serializedResult, "data"))) throw new Error(`Layout "${id}" loader must return { kind: "data", data } with JSON-serializable data, or a collection-item envelope naming a registered collection and a record id`);
-	return serializedResult;
+/** Whether an API error refuses the Draft a read named, rather than finding nothing in it. */
+function refusesDraft(error, draftId) {
+	const data = error?.data;
+	return draftId !== void 0 && data?.draftId === draftId;
 }
 /**
-* The Markdown of a singleton or derived page: front matter, its before blocks, the layout's
-* toMarkdown output, then its after blocks. Null without toMarkdown: the page is then HTML only.
-* The layout's blocks settle which draft it reads, as they do for the page's HTML.
+* What a page's Markdown is, at a path: whatever Page Read finds there, read as `reader` reads
+* it. A curated page's comes from `curated`, a Layout Page's from its layout's blocks and its
+* `toMarkdown`. Null when the page has none: it's then HTML only.
 */
-async function buildLayoutMarkdown(options, match, locale, page, reader = { member: false }) {
-	const { toMarkdown, id } = match.layout._internal;
-	const { apiUrl, projectUuid } = options;
-	if (!toMarkdown || !apiUrl || !projectUuid) return null;
-	const authCookieHeader = reader.member ? reader.authCookieHeader : void 0;
-	const api = (draftId) => createServerApiClient(apiUrl, {
-		authCookieHeader,
+async function readPageMarkdownShown(options, { app, path, page, reader, requestReader, curated }) {
+	const { projectUuid } = options;
+	const api = (draftId) => requestReader.api({
 		draftId,
-		locale
+		locale: reader.locale
 	});
-	const { value: slots, draftId } = await readDraftOrLive(reader.requestedDraft, reader.member, (draftId) => api(draftId).blocks.getLayoutMarkdown({
-		projectUuid,
-		layoutId: id
-	})).catch((error) => {
-		if (!isNotFoundError(error)) throw error;
-		return {
-			value: {
+	const shown = await readPage({
+		app,
+		path,
+		pathname: page.pathname,
+		reader,
+		curated: async () => ({ value: curated?.page ? curated : null }),
+		layout: (draftId, layoutId) => api(draftId).blocks.getLayoutMarkdown({
+			projectUuid,
+			layoutId
+		}).catch((error) => {
+			if (!isNotFoundError(error) || refusesDraft(error, draftId)) throw error;
+			return {
 				before: "",
 				after: "",
 				projectName: ""
-			},
-			draftId: reader.member ? reader.requestedDraft : void 0
-		};
+			};
+		})
 	});
-	const app = await options.getCamoxApp?.();
-	/** The layout's own Markdown, between its before and after blocks, and what built it. */
-	const layoutMarkdown = async () => {
-		const result = await loadLayoutResult(app, match, createLayoutRequestContext(options, reader.member ? "draft" : "live", {
-			authCookieHeader,
-			draftId,
-			locale
-		}), locale);
-		const record = asCollectionItem(result);
-		const collection = record && app?.getCollectionById(record.collectionId);
-		if (!record || !collection) return {
-			body: toMarkdown({
-				data: result?.data,
-				params: match.params
-			}),
-			data: result?.data
-		};
-		const { data } = record;
-		const template = recordMarkdownTemplate(collection, (item) => toMarkdown({
+	if (shown.kind === "none") {
+		if (shown.layout) throw notFound();
+		return null;
+	}
+	if (shown.kind === "curated") return {
+		kind: "curated",
+		read: shown.page
+	};
+	const layout = shown.layout._internal;
+	const { toMarkdown } = layout;
+	if (!toMarkdown) return {
+		kind: "layout",
+		markdown: null
+	};
+	const { record, params, blocks } = shown;
+	const data = shown.result?.data;
+	const body = record ? [await api(shown.draftId).collectionDefinitions.recordMarkdown({
+		projectUuid,
+		collectionId: record.item.collectionId,
+		id: record.item.data.id,
+		toMarkdown: recordMarkdownTemplate(record.collection, (item) => toMarkdown({
 			data,
-			params: match.params,
+			params,
 			item
-		}));
-		return {
-			body: [await api(draftId).collectionDefinitions.recordMarkdown({
-				projectUuid,
-				collectionId: record.collectionId,
-				id: data.id,
-				toMarkdown: template
-			})],
-			data,
-			record: recordPageValues(collection, record)
-		};
-	};
-	const rendered = await layoutMarkdown();
+		}))
+	})] : toMarkdown({
+		data,
+		params
+	});
 	const meta = buildPageMeta({
-		layout: match.layout._internal,
-		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
-		})
+		layout,
+		context: shown.context
 	});
 	const markdown = [
-		slots.before,
-		...rendered.body,
-		slots.after
+		blocks.before,
+		...body,
+		blocks.after
 	].filter(Boolean).join("\n\n");
-	return withFrontMatter(markdown, {
-		...meta,
-		url: page.url
-	});
-}
-/**
-* A singleton or derived page's public Markdown Representation. Markdown is a public output: it
-* reads published records and blocks whoever asks.
-*/
-async function createLayoutMarkdownResponse(options, match, locale, page) {
-	let markdown;
-	try {
-		markdown = await buildLayoutMarkdown(options, match, locale, page);
-	} catch (error) {
-		if (isNotFoundError(error)) return new Response("Page not found", { status: 404 });
-		throw error;
-	}
-	if (markdown === null) return null;
-	return new Response(markdown, { headers: { "Content-Type": "text/markdown; charset=utf-8" } });
+	return {
+		kind: "layout",
+		markdown: withFrontMatter(markdown, {
+			...meta,
+			url: page.url
+		})
+	};
 }
 /**
-* A singleton or derived page's Markdown Representation as JSON (`/_camox/data?markdown`), read
-* like the page's data: in the draft the URL names, for a member. The studio shows it, while the
-* page's `.md` URL always reads Live. `markdown` is null when the layout declares none.
+* A Layout Page's Markdown Representation as JSON (`/_camox/data?markdown`), read like the page's
+* data: in the draft the URL names, for a member. The studio shows it, while the page's `.md` URL
+* always reads Live. `markdown` is null when the layout declares none. A curated page's Markdown
+* is the API's to read.
 */
 async function createLayoutMarkdownDataResponse(options, request, pathname) {
-	const located = await locateRequest(request, options, pathname);
-	const app = await options.getCamoxApp?.();
-	const match = app && matchDerivedLayout(app.getLayouts(), located.path);
-	if (!match || matchLocalizedRoute(located.path)?.kind !== "page") return new Response("Not found", { status: 404 });
-	const { project, clearAuthCookie } = await resolveRequestMember(request, options);
-	const headers = {
-		...isPrivateRender(request) ? { "Cache-Control": "private, no-store" } : {},
-		Vary: "Cookie",
-		...clearAuthCookie ? { "Set-Cookie": buildClearServerAuthCookieHeader() } : {}
-	};
+	const { apiUrl, projectUuid } = options;
+	const requestReader = await resolveReader(request, options);
+	const located = await locateRequest(requestReader, options, pathname);
+	if (!apiUrl || !projectUuid || matchLocalizedRoute(located.path)?.kind !== "page") return new Response("Not found", { status: 404 });
+	const headers = readerHeaders(requestReader);
+	const reader = pageReaderOf(options, requestReader, located.locale);
+	let shown;
 	try {
-		const markdown = await buildLayoutMarkdown(options, match, located.locale, {
-			pathname,
-			url: absoluteUrl(request, options)(pathname)
+		shown = await readPageMarkdownShown({
+			...options,
+			apiUrl,
+			projectUuid
 		}, {
-			member: project !== void 0,
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			requestedDraft: getRequestDraftId(request)
+			app: await options.getCamoxApp?.(),
+			path: located.path,
+			page: {
+				pathname,
+				url: absoluteUrl(request, options)(pathname)
+			},
+			reader,
+			requestReader,
+			curated: null
 		});
-		return Response.json({ markdown }, { headers });
 	} catch (error) {
 		if (isNotFoundError(error)) return new Response("Not found", {
 			status: 404,
@@ -1519,160 +1567,16 @@ async function createLayoutMarkdownDataResponse(options, request, pathname) {
 		});
 		throw error;
 	}
+	if (shown?.kind !== "layout") return new Response("Not found", { status: 404 });
+	return Response.json({ markdown: shown.markdown }, { headers });
 }
-async function createDerivedResponse(options, pathname, located, request, { dataOnly = false, singletonOnly = false } = {}) {
-	const app = await options.getCamoxApp?.();
-	const match = app && matchDerivedLayout(app.getLayouts(), located.path);
-	if (!match || !dataOnly && !options.renderPage) return null;
-	if (singletonOnly && match.layout._internal.kind !== "singleton") return null;
-	try {
-		const queryClient = new QueryClient();
-		const { project, clearAuthCookie } = await resolveRequestMember(request, options);
-		const studio = project !== void 0;
-		const authCookieHeader = studio ? getServerAuthCookieHeader(request.headers) : void 0;
-		const requestedDraft = getRequestDraftId(request);
-		const readLayout = () => readDraftOrLive(requestedDraft, studio, (draftId) => createServerApiClient(options.apiUrl, {
-			authCookieHeader,
-			draftId,
-			locale: located.locale
-		}).layouts.get({
-			projectUuid: options.projectUuid,
-			layoutId: match.layout._internal.id
-		}));
-		const runLoader = (draftId) => loadLayoutResult(app, match, createLayoutRequestContext(options, studio ? "draft" : "live", {
-			authCookieHeader,
-			draftId,
-			locale: located.locale
-		}), located.locale);
-		const [serializedResult, { value: shared, ...read }] = studio && requestedDraft ? await readLayout().then(async (read) => [await runLoader(read.draftId), read]) : await Promise.all([runLoader(), readLayout()]);
-		const studioCache = createServerStudioCache(queryClient, {
-			apiUrl: options.apiUrl,
-			authCookieHeader,
-			locale: located.locale
-		});
-		const projectUuid = options.projectUuid;
-		const shownIn = { in: read.draftId ?? null };
-		studioCache.land(reads.layoutStructure({
-			projectUuid,
-			layoutId: match.layout._internal.id
-		}), shared, shownIn);
-		studioCache.set(reads.derivedPageData({
-			projectUuid,
-			runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
-			pathname
-		}), 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" ? {
-				kind: "record",
-				layout: match.layout,
-				recordId: record.data.id
-			} : { kind: "code-owned" },
-			head: withSearchEngineMark(buildPageHead({
-				layout: match.layout._internal,
-				context,
-				origin: new URL(request.url).origin,
-				faviconUrl: buildFaviconUrl(options.apiUrl, shared.project),
-				hasMarkdown: match.layout._internal.toMarkdown !== void 0,
-				recordType: record?.structuredData?.node?.["@type"]
-			}), shared.project),
-			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({
-			studio,
-			draftId: read.draftId
-		}, shared.project);
-		const input = await withArtifactsByUrl({
-			alternates,
-			project,
-			presentation: studio ? "studio" : "public",
-			...analytics && { analytics },
-			apiUrl: options.apiUrl,
-			authenticationUrl: options.authenticationUrl,
-			projectUuid: options.projectUuid,
-			dehydratedState: dehydrate(queryClient),
-			draftId: read.draftId,
-			refusedDraft: read.refusedDraft,
-			head: pageHead,
-			href: renderedHref(request.url, read),
-			layoutIdentity: getLayoutIdentity(shared.layout),
-			loaderData: null,
-			pathname,
-			runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
-			locale: located.locale,
-			locales: located.locales,
-			derived: {
-				layoutId: match.layout._internal.id,
-				page: {
-					params: match.params,
-					path: pathname,
-					projectName: shared.projectName
-				},
-				result: serializedResult,
-				layout: shared.layout
-			}
-		}, options);
-		const document = await options.getDocument?.() ?? {};
-		preparePreviewDocument(input, options, document);
-		if (dataOnly) return Response.json(input, { headers: {
-			...isPrivateRender(request) ? { "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)}${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),
-			...isPrivateRender(request) ? { "Cache-Control": "private, no-store" } : {},
-			...clearAuthCookie ? { "Set-Cookie": buildClearServerAuthCookieHeader() } : {},
-			...isHiddenFromSearchEngines(shared.project) && { "X-Robots-Tag": "noindex" }
-		} });
-	} catch (error) {
-		if (isNotFoundError(error)) return new Response("Page not found", { status: 404 });
-		throw error;
-	}
-}
-async function createStudioHtmlResponse({ match, options, pathname, located, request, dataOnly = false }) {
+async function createStudioHtmlResponse({ match, options, pathname, located, request, reader, dataOnly = false }) {
 	if (!options.apiUrl || !options.authenticationUrl || !options.projectUuid || !dataOnly && !options.renderStudio) return Response.json({
 		message: "Camox Studio renderer is not configured.",
 		...match
 	}, { status: 500 });
 	const queryClient = new QueryClient();
-	const { project, clearAuthCookie } = await resolveRequestMember(request, options);
+	const project = reader.member;
 	const presentation = project ? "studio" : "public";
 	const studioRenderInput = {
 		project,
@@ -1690,46 +1594,30 @@ async function createStudioHtmlResponse({ match, options, pathname, located, req
 		runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
 		locale: located.locale,
 		locales: located.locales,
-		draftId: project ? getRequestDraftId(request) : void 0
+		draftId: reader.draftId
 	};
-	if (dataOnly) return Response.json(studioRenderInput, { headers: {
-		"Cache-Control": "private, no-store",
-		Vary: "Cookie",
-		...clearAuthCookie ? { "Set-Cookie": buildClearServerAuthCookieHeader() } : {}
-	} });
+	const headers = readerHeaders(reader, { alwaysPrivate: true });
+	if (dataOnly) return Response.json(studioRenderInput, { headers });
 	const appHtml = await options.renderStudio(studioRenderInput);
-	const renderedHead = renderHead({}, { title: "Camox Studio" }, void 0, presentation === "studio" ? options.studioStylesheetUrl : void 0);
-	return new Response(`<!doctype html>
-<html${renderedHead.htmlAttrs}>
-<head>
-${renderStudioThemeScript(presentation === "studio")}
-${renderedHead.headTags}
-<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(studioRenderInput)}<\/script>
-</head>
-<body${renderedHead.bodyAttrs}>
-${renderedHead.bodyTagsOpen}
-<div id="root">${appHtml}</div>
-${renderedHead.bodyTags}
-${renderClientEntryScript(options.studioClientEntryUrl)}
-</body>
-</html>`, { headers: {
-		"Content-Type": "text/html; charset=utf-8",
-		"Cache-Control": "private, no-store",
-		Vary: "Cookie",
-		...clearAuthCookie ? { "Set-Cookie": buildClearServerAuthCookieHeader() } : {}
-	} });
+	return htmlResponse(htmlDocument({
+		head: renderHead({}, { title: "Camox Studio" }, void 0, presentation === "studio" ? options.studioStylesheetUrl : void 0),
+		before: renderStudioThemeScript(presentation === "studio"),
+		data: studioRenderInput,
+		root: appHtml,
+		entryUrl: options.studioClientEntryUrl
+	}), headers);
 }
 /**
 * The Canvas with nothing selected renders the page app, like a Page, so
 * selecting it keeps the Canvas mounted.
 */
-async function createCanvasOnlyResponse({ options, pathname, located, request, dataOnly = false }) {
+async function createCanvasOnlyResponse({ options, pathname, located, request, reader, dataOnly = false }) {
 	if (!options.apiUrl || !options.authenticationUrl || !options.projectUuid || !dataOnly && !options.renderPage) return Response.json({
 		message: "Camox page renderer is not configured.",
 		kind: "canvas",
 		pathname
 	}, { status: 500 });
-	const { project, clearAuthCookie } = await resolveRequestMember(request, options);
+	const project = reader.member;
 	const studio = project !== void 0;
 	const title = "Canvas";
 	const input = {
@@ -1748,87 +1636,18 @@ async function createCanvasOnlyResponse({ options, pathname, located, request, d
 		loaderData: null,
 		dehydratedState: dehydrate(new QueryClient()),
 		canvasOnly: true,
-		draftId: studio ? getRequestDraftId(request) : void 0
-	};
-	const headers = {
-		"Cache-Control": "private, no-store",
-		Vary: "Cookie",
-		...clearAuthCookie ? { "Set-Cookie": buildClearServerAuthCookieHeader() } : {}
+		draftId: reader.draftId
 	};
+	const headers = readerHeaders(reader, { alwaysPrivate: true });
 	if (dataOnly) return Response.json(input, { headers });
 	const html = await options.renderPage(input);
-	const head = renderHead({}, { title }, void 0, studio ? options.studioStylesheetUrl : void 0);
-	return new Response(`<!doctype html><html${head.htmlAttrs}><head>${renderStudioThemeScript(studio)}${head.headTags}<script id="__CAMOX_DATA__" type="application/json">${serializeJsonForHtml(input)}<\/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",
-		...headers
-	} });
-}
-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, result: reading } = pageRead ?? readCuratedPage({
-		...options,
-		apiUrl: options.apiUrl,
-		projectUuid: options.projectUuid
-	}, request, located);
-	const localeReads = curatedPageLocaleReads(options, request, located, queryClient);
-	try {
-		const result = await reading;
-		const headers = new Headers({
-			"Content-Type": "application/json; charset=utf-8",
-			Vary: "Cookie"
-		});
-		if (isPrivateRender(request)) 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, {
-			located,
-			identity: {
-				kind: "curated",
-				pageId: result.data.page.page.id
-			},
-			head: withSearchEngineMark(camoxApp ? buildCamoxPageHead(camoxApp, result.data, located.locale) : null, result.data.page.project),
-			described: curatedPageDescription(camoxApp, result.data.page, located.locale),
-			localeReads: localeReads(result.draftId)
-		});
-		const dehydratedState = dehydrate(queryClient);
-		const navigationInput = await withArtifactsByUrl({
-			alternates,
-			apiUrl: options.apiUrl,
-			authenticationUrl: options.authenticationUrl ?? "",
-			projectUuid: options.projectUuid,
-			runtimeBasePath: normalizeRuntimeBasePath(options.runtimeBasePath),
-			locale: located.locale,
-			locales: located.locales,
-			href: renderedHref(request.url, result),
-			draftId: result.draftId,
-			refusedDraft: result.refusedDraft,
-			presentation: result.project ? "studio" : "public",
-			pathname,
-			layoutIdentity: getLayoutIdentity(result.data.page.layout),
-			project: result.project,
-			loaderData: result.data,
-			head,
-			dehydratedState
-		}, options);
-		preparePreviewDocument(navigationInput, options, await options.getDocument?.() ?? {});
-		return Response.json(navigationInput, { headers });
-	} catch (error) {
-		if (isNotFoundError(error)) {
-			const derived = await createDerivedResponse(options, pathname, located, request, { dataOnly: true });
-			if (derived) return derived;
-			return Response.json({
-				kind: "page",
-				message: "No Camox page on this path",
-				pathname
-			}, { status: 404 });
-		}
-		throw error;
-	}
+	return htmlResponse(htmlDocument({
+		head: renderHead({}, { title }, void 0, studio ? options.studioStylesheetUrl : void 0),
+		before: renderStudioThemeScript(studio),
+		data: input,
+		root: html,
+		entryUrl: options.pageClientEntryUrl
+	}), headers);
 }
 async function handleCamoxRequest(request, options = {}) {
 	const pathname = getRuntimePathname(request.url, options.runtimeBasePath);
@@ -1889,14 +1708,16 @@ async function handleCamoxRequest(request, options = {}) {
 * With `dataOnly`, as the JSON client navigation loads.
 */
 async function respondInLocale(options, request, pathname, { dataOnly = false } = {}) {
-	const [early, located] = await Promise.all([readDefaultLocalePageEarly(options, request, pathname), locateRequest(request, options, pathname)]);
+	const reader = await resolveReader(request, options);
+	const [early, located] = await Promise.all([readPageEarly(options, reader, pathname), locateRequest(reader, options, pathname)]);
 	const localized = matchLocalizedRoute(located.path);
 	if (!localized) return new Response("Not found", { status: 404 });
 	const target = {
 		options,
 		pathname,
 		located,
-		request
+		request,
+		reader
 	};
 	if (localized.kind === "canvas") return createCanvasOnlyResponse({
 		...target,
@@ -1907,11 +1728,11 @@ async function respondInLocale(options, request, pathname, { dataOnly = false }
 		match: localized,
 		dataOnly
 	});
-	const page = {
+	return createPageResponse({
 		...target,
-		pageRead: located.locale.isDefault ? early : void 0
-	};
-	return dataOnly ? createPageDataResponse(page) : createPageHtmlResponse(page);
+		pageRead: earlyReadIn(early, located),
+		dataOnly
+	});
 }
 /**
 * A page's Markdown Representation in its locale, with the same precedence as its HTML:
@@ -1923,6 +1744,7 @@ async function createPageMarkdownResponse(options, { pathname, request, pagesOnl
 	try {
 		read = await readPageMarkdown({
 			...options,
+			reader: visitorReader(options),
 			path: pathname
 		});
 	} catch {
@@ -1935,10 +1757,25 @@ async function createPageMarkdownResponse(options, { pathname, request, pagesOnl
 		url: absoluteUrl(request, options)(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);
-	if (read.page) return curatedMarkdownResponse(app, read, page.url);
-	return layoutMatch ? createLayoutMarkdownResponse(options, layoutMatch, locale, page) : null;
+	const requestReader = visitorReader(options);
+	const reader = pageReaderOf(options, requestReader, locale);
+	let shown;
+	try {
+		shown = await readPageMarkdownShown(options, {
+			app,
+			path,
+			page,
+			reader,
+			requestReader,
+			curated: read
+		});
+	} catch (error) {
+		if (isNotFoundError(error)) return new Response("Page not found", { status: 404 });
+		throw error;
+	}
+	if (shown?.kind === "curated") return curatedMarkdownResponse(app, shown.read, page.url);
+	if (!shown?.markdown) return null;
+	return new Response(shown.markdown, { headers: { "Content-Type": "text/markdown; charset=utf-8" } });
 }
 /** Whether a route is one of the studio's own, rather than a page or the Canvas. */
 function isStudioRoute(match) {
@@ -1953,18 +1790,13 @@ function matchLocalizedRoute(path) {
 	return match.kind === "page" || match.kind === "canvas" || isStudioRoute(match) ? match : null;
 }
 /**
-* 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. Without an API there are none to read: every path is the
-* default locale's, which then says it can't render.
+* The locale a request's path names, among the locales of the scope its Reader reads: its
+* draft's, 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) {
+async function locateRequest(reader, options, pathname) {
 	const { apiUrl, projectUuid } = options;
-	const locales = apiUrl && projectUuid ? await readScopeLocales({
-		apiUrl,
-		projectUuid,
-		authCookieHeader: getServerAuthCookieHeader(request.headers),
-		draftId: getRequestDraftId(request)
-	}) : [UNNAMED_DEFAULT_LOCALE];
+	const locales = apiUrl && projectUuid ? await reader.locales() : [UNNAMED_DEFAULT_LOCALE];
 	return {
 		...parseLocalePath(pathname, locales),
 		locales