camox 0.51.0 → 0.52.2

package/dist/features/runtime/pageApp.js

@@ -1,6 +1,5 @@
 import { useAuthState, useSignInRedirect } from "../../lib/auth.js";
 import { DraftScopeContext } from "../../lib/draft-scope.js";
-import { DerivedPageContent } from "../page/DerivedPageContent.js";
 import { useSignInShortcut } from "../provider/signInShortcut.js";
 import { PreviewDocumentContext } from "./PreviewDocumentContext.js";
 import { PreviewActivation } from "../preview/components/PreviewActivation.js";
@@ -8,6 +7,7 @@ import { Frame } from "../preview/components/Frame.js";
 import { PreviewSignInPage } from "../provider/PreviewSignInPage.js";
 import { CoreCamoxProvider } from "../provider/CoreCamoxProvider.js";
 import { CuratedPageContent } from "../page/CuratedPageContent.js";
+import { DerivedPageContent } from "../page/DerivedPageContent.js";
 import { EditingFallbackSlot } from "./editingFallback.js";
 import { PageNavigationProvider } from "./pageNavigation.js";
 import { RuntimeChromeSlot } from "./runtimeChromeLoader.js";
@@ -97,11 +97,6 @@ function PageApp(t0) {
 	return t6;
 }
 const LazyEditablePageExperience = React.lazy(() => import("../preview/EditablePageExperience.js").then((module) => ({ default: module.EditablePageExperience })));
-/** Editing lists and adds any block, so it waits for every definition, not only the page's. */
-function AllBlocks({ camoxApp, children }) {
-	React.use(camoxApp.loadAllBlocks());
-	return children;
-}
 var EditingActivationBoundary = class extends React.Component {
 	state = { failed: false };
 	static getDerivedStateFromError() {
@@ -116,7 +111,7 @@ var EditingActivationBoundary = class extends React.Component {
 };
 const subscribeToHydration = () => () => {};
 function PageExperience(t0) {
-	const $ = c(38);
+	const $ = c(31);
 	const { camoxApp, input, queryClient, studioDocument } = t0;
 	const { isAuthenticated, isLoading } = useAuthState();
 	const hasHydrated = React.useSyncExternalStore(subscribeToHydration, _temp, _temp2);
@@ -175,96 +170,75 @@ function PageExperience(t0) {
 		$[13] = t5;
 	} else t5 = $[13];
 	const isolatedPage = t5;
-	let t6;
-	if ($[14] !== input.routeKind || $[15] !== isolatedPage) {
-		t6 = input.routeKind ? /* @__PURE__ */ jsx(StudioLoadError, {}) : isolatedPage;
-		$[14] = input.routeKind;
-		$[15] = isolatedPage;
-		$[16] = t6;
-	} else t6 = $[16];
-	const fallback = t6;
 	if (isAuthenticated) {
-		let t7;
-		if ($[17] !== camoxApp || $[18] !== hasHydrated || $[19] !== input || $[20] !== queryClient) {
-			t7 = hasHydrated ? /* @__PURE__ */ jsx(AllBlocks, {
+		let t6;
+		if ($[14] !== camoxApp || $[15] !== hasHydrated || $[16] !== input || $[17] !== queryClient) {
+			t6 = hasHydrated ? /* @__PURE__ */ jsx(LazyEditablePageExperience, {
 				camoxApp,
-				children: /* @__PURE__ */ jsx(LazyEditablePageExperience, {
-					camoxApp,
-					input,
-					queryClient
-				})
+				input,
+				queryClient
 			}) : null;
-			$[17] = camoxApp;
-			$[18] = hasHydrated;
-			$[19] = input;
-			$[20] = queryClient;
-			$[21] = t7;
-		} else t7 = $[21];
-		const editor = t7;
-		const t8 = input.routeKind ? loading : isolatedPage;
+			$[14] = camoxApp;
+			$[15] = hasHydrated;
+			$[16] = input;
+			$[17] = queryClient;
+			$[18] = t6;
+		} else t6 = $[18];
+		const editor = t6;
+		const t7 = input.routeKind ? loading : studioDocument ? null : isolatedPage;
+		let t8;
+		if ($[19] === Symbol.for("react.memo_cache_sentinel")) {
+			t8 = /* @__PURE__ */ jsx(StudioLoadError, {});
+			$[19] = t8;
+		} else t8 = $[19];
 		let t9;
-		if ($[22] !== editor || $[23] !== input.derived || $[24] !== input.previewDocument || $[25] !== input.routeKind || $[26] !== readOnlyPage) {
-			t9 = input.routeKind ? /* @__PURE__ */ jsx(React.Suspense, {
-				fallback: loading,
-				children: editor ?? loading
-			}) : /* @__PURE__ */ jsx(PreviewActivation, {
-				fallback: /* @__PURE__ */ jsx(EditingFallbackSlot, {
-					layoutPage: !!input.derived,
-					children: /* @__PURE__ */ jsx(Frame, {
-						serverOnly: !!input.previewDocument,
-						children: readOnlyPage
-					})
-				}),
-				children: editor
+		if ($[20] !== editor || $[21] !== input.derived || $[22] !== input.routeKind) {
+			t9 = /* @__PURE__ */ jsx(EditingActivationBoundary, {
+				fallback: t8,
+				children: input.routeKind ? /* @__PURE__ */ jsx(React.Suspense, {
+					fallback: loading,
+					children: editor ?? loading
+				}) : /* @__PURE__ */ jsx(PreviewActivation, {
+					fallback: /* @__PURE__ */ jsx(EditingFallbackSlot, { layoutPage: !!input.derived }),
+					children: editor
+				})
 			});
-			$[22] = editor;
-			$[23] = input.derived;
-			$[24] = input.previewDocument;
-			$[25] = input.routeKind;
-			$[26] = readOnlyPage;
-			$[27] = t9;
-		} else t9 = $[27];
+			$[20] = editor;
+			$[21] = input.derived;
+			$[22] = input.routeKind;
+			$[23] = t9;
+		} else t9 = $[23];
 		let t10;
-		if ($[28] !== fallback || $[29] !== t9) {
-			t10 = /* @__PURE__ */ jsx(EditingActivationBoundary, {
-				fallback,
-				children: t9
-			});
-			$[28] = fallback;
-			$[29] = t9;
-			$[30] = t10;
-		} else t10 = $[30];
-		let t11;
-		if ($[31] !== input || $[32] !== t10 || $[33] !== t8) {
-			t11 = /* @__PURE__ */ jsx(RuntimeChromeSlot, {
+		if ($[24] !== input || $[25] !== t7 || $[26] !== t9) {
+			t10 = /* @__PURE__ */ jsx(RuntimeChromeSlot, {
 				input,
-				fallback: t8,
-				children: t10
+				fallback: t7,
+				children: t9
 			});
-			$[31] = input;
-			$[32] = t10;
-			$[33] = t8;
-			$[34] = t11;
-		} else t11 = $[34];
-		return t11;
+			$[24] = input;
+			$[25] = t7;
+			$[26] = t9;
+			$[27] = t10;
+		} else t10 = $[27];
+		return t10;
 	}
 	if (studioOnly) return null;
 	if (studioDocument) {
+		let t6;
+		if ($[28] === Symbol.for("react.memo_cache_sentinel")) {
+			t6 = { height: "100vh" };
+			$[28] = t6;
+		} else t6 = $[28];
 		let t7;
-		if ($[35] === Symbol.for("react.memo_cache_sentinel")) {
-			t7 = { height: "100vh" };
-			$[35] = t7;
-		} else t7 = $[35];
-		let t8;
-		if ($[36] !== isolatedPage) {
-			t8 = /* @__PURE__ */ jsx("div", {
-				style: t7,
+		if ($[29] !== isolatedPage) {
+			t7 = /* @__PURE__ */ jsx("div", {
+				style: t6,
 				children: isolatedPage
 			});
-			$[36] = isolatedPage;
-			$[37] = t8;
-		} else t8 = $[37];
-		return t8;
+			$[29] = isolatedPage;
+			$[30] = t7;
+		} else t7 = $[30];
+		return t7;
 	}
 	return readOnlyPage;
 }

package/dist/features/runtime/pageClient.js

@@ -18,7 +18,7 @@ async function hydratePageWithApp(camoxApp) {
 		...hydrationData,
 		dehydratedState: restoreArtifactSources(hydrationData.dehydratedState, root)
 	};
-	await Promise.all([camoxApp.loadBlocks(getPageBlockTypes(input.dehydratedState)).catch((error) => console.error("Camox: a block of this page failed to load.", error)), input.presentation === "studio" ? loadRuntimeChrome() : void 0]);
+	await (input.presentation === "studio" ? loadRuntimeChrome() : camoxApp.loadBlocks(getPageBlockTypes(input.dehydratedState)).catch((error) => console.error("Camox: a block of this page failed to load.", error)));
 	const draftScope = createDraftScope({
 		queryClient,
 		browser: window

package/dist/features/runtime/pageNavigation.js

@@ -93,12 +93,13 @@ function PageNavigationProvider({ camoxApp, children, initialInput, queryClient
 		if (!response.ok) throw new Error(`Navigation failed: ${response.status}`);
 		const next = await response.json();
 		if (next.pathname !== pathname || !next.dehydratedState) throw new Error("Invalid navigation response");
-		await camoxApp.loadBlocks(getPageBlockTypes(next.dehydratedState));
+		if (initialInput.presentation !== "studio") await camoxApp.loadBlocks(getPageBlockTypes(next.dehydratedState));
 		return next;
 	}, [
 		camoxApp,
 		draftScope,
-		initialInput.runtimeBasePath
+		initialInput.runtimeBasePath,
+		initialInput.presentation
 	]);
 	const [prefetched] = React.useState(() => createPrefetchCache());
 	const headManager = React.useRef(null);

package/dist/features/runtime/publicCache.js

@@ -1,6 +1,8 @@
 import { prefersMarkdown } from "../routes/pageRuntime.js";
 
 //#region src/features/runtime/publicCache.ts
+/** The named cache public renders are kept in. */
+const PUBLIC_CACHE_NAME = "camox-public-renders";
 /** How long the edge keeps a render. Live changing replaces its key long before. */
 const EDGE_MAX_AGE = 86400;
 /** Browsers can't be purged, so they ask again each time; the edge answers them. */
@@ -24,11 +26,21 @@ async function respondThroughPublicCache(request, publicCache, render) {
 	const liveCacheKey = await publicCache.liveCacheKey();
 	if (!liveCacheKey) return render();
 	const key = cacheKeyOf(request, `${liveCacheKey}.${publicCache.build}`);
-	const cached = await publicCache.cache.match(withValidators(key, request));
+	let cache;
+	let cached;
+	try {
+		cache = await publicCache.cache();
+		cached = await cache.match(withValidators(key, request));
+	} catch (error) {
+		console.error("The edge cache couldn't be read: the page renders without it", error);
+		return render();
+	}
 	if (cached) return forVisitors(cached, request);
 	const response = await render();
 	if (!response || !mayBeShared(response)) return response;
-	publicCache.waitUntil(publicCache.cache.put(key, forEdge(response.clone())));
+	publicCache.waitUntil((async () => cache.put(key, forEdge(response.clone())))().catch((error) => {
+		console.error("The edge cache couldn't keep a render", error);
+	}));
 	return forVisitors(response, request);
 }
 /**
@@ -80,4 +92,4 @@ function forVisitors(response, request) {
 }
 
 //#endregion
-export { readLiveCacheKey, respondThroughPublicCache };
+export { PUBLIC_CACHE_NAME, readLiveCacheKey, respondThroughPublicCache };

package/dist/features/runtime/publishingDraft.js

@@ -0,0 +1,23 @@
+import { PUBLISHING_DRAFT_VAR } from "@camox/api-contract/drafts";
+
+//#region src/features/runtime/publishingDraft.ts
+/**
+* The Worker a publish with code uploaded carries the publishing draft's ID as a variable
+* (`PUBLISHING_DRAFT_VAR`). Its reads of the API name that draft, so while the draft publishes
+* they see Live overlaid with it, the content its code was previewed with. Once the draft has
+* ended, the API reads Live for them. The variable is the same for every request a Worker
+* serves, so it's kept from the first.
+*/
+const PUBLISHING_DRAFT_GLOBAL = "__CAMOX_PUBLISHING_DRAFT__";
+/** Keeps the publishing draft a Worker's environment names, if it names one. */
+function rememberPublishingDraft(env) {
+	const draft = env?.[PUBLISHING_DRAFT_VAR];
+	if (typeof draft === "string" && draft) globalThis[PUBLISHING_DRAFT_GLOBAL] = draft;
+}
+/** The draft this Worker publishes, if a publish with code uploaded it. */
+function publishingDraft() {
+	return globalThis[PUBLISHING_DRAFT_GLOBAL];
+}
+
+//#endregion
+export { publishingDraft, rememberPublishingDraft };

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

@@ -0,0 +1,8 @@
+import { CamoxApp } from "../../core/createApp.js";
+//#region src/features/runtime/rendererClient.d.ts
+/**
+ * Starts the renderer frame's document (ADR 0023): connects to the studio that loaded it, and
+ * renders the pages of the frames it is given with the site's code, in a cache of its own.
+ */
+export declare function startRendererWithApp(camoxApp: CamoxApp): Promise<void>;
+//#endregion

package/dist/features/runtime/rendererClient.js

@@ -0,0 +1,77 @@
+import { getDraftReadClient } from "../../lib/api-client.js";
+import { DraftScopeContext, createDraftScope, followUrl } from "../../lib/draft-scope.js";
+import { StudioCacheContext, createStudioCache } from "../../lib/studio-reads.js";
+import { STUDIO_HANDLE_KEY } from "../renderer/protocol.js";
+import { CoreCamoxProvider } from "../provider/CoreCamoxProvider.js";
+import { readHydrationData } from "./hydrationData.js";
+import { CompleteBlockEditingRuntimeProvider } from "../../core/editing/CompleteBlockEditingRuntime.js";
+import { RendererApp } from "../renderer/RendererApp.js";
+import { connectToStudio } from "../renderer/studioConnection.js";
+import { jsx } from "react/jsx-runtime";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { createRoot } from "react-dom/client";
+
+//#region src/features/runtime/rendererClient.tsx
+/**
+* Starts the renderer frame's document (ADR 0023): connects to the studio that loaded it, and
+* renders the pages of the frames it is given with the site's code, in a cache of its own.
+*/
+async function startRendererWithApp(camoxApp) {
+	const handle = window.frameElement?.[STUDIO_HANDLE_KEY];
+	if (!handle) {
+		console.error("Camox: the renderer document only runs in the studio's renderer frame.");
+		return;
+	}
+	const input = readHydrationData();
+	if (!input.apiUrl || !input.authenticationUrl || !input.projectUuid) {
+		console.error("Camox: the renderer document is missing its API or project.");
+		return;
+	}
+	const codeLoaded = camoxApp.loadAllBlocks();
+	codeLoaded.catch((error) => console.error("Camox: the site's code failed to load.", error));
+	const queryClient = new QueryClient();
+	const draftScope = createDraftScope({
+		queryClient,
+		browser: window
+	});
+	followUrl(draftScope, window.location.href);
+	const studioCache = createStudioCache({
+		queryClient,
+		scope: draftScope,
+		api: getDraftReadClient
+	});
+	const connection = connectToStudio(handle, {
+		queryClient,
+		studioCache,
+		draftScope,
+		camoxApp
+	});
+	const container = document.createElement("div");
+	document.body.append(container);
+	createRoot(container).render(/* @__PURE__ */ jsx(QueryClientProvider, {
+		client: queryClient,
+		children: /* @__PURE__ */ jsx(DraftScopeContext.Provider, {
+			value: draftScope,
+			children: /* @__PURE__ */ jsx(StudioCacheContext.Provider, {
+				value: studioCache,
+				children: /* @__PURE__ */ jsx(CoreCamoxProvider, {
+					apiUrl: input.apiUrl,
+					authenticationUrl: input.authenticationUrl,
+					camoxApp,
+					projectUuid: input.projectUuid,
+					initialAuthenticated: true,
+					children: /* @__PURE__ */ jsx(CompleteBlockEditingRuntimeProvider, { children: /* @__PURE__ */ jsx(RendererApp, {
+						connection,
+						camoxApp,
+						codeLoaded,
+						projectUuid: input.projectUuid,
+						runtimeBasePath: input.runtimeBasePath
+					}) })
+				})
+			})
+		})
+	}));
+}
+
+//#endregion
+export { startRendererWithApp };

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

@@ -89,6 +89,8 @@ export interface RuntimeOptions {
   developmentDraft?: boolean;
   pageClientEntryUrl?: string;
   studioClientEntryUrl?: string;
+  /** The renderer frame's client entry, which renders the studio's pages (ADR 0023). */
+  rendererClientEntryUrl?: string;
   getCamoxApp?: () => Promise<CamoxApp>;
   getDocument?: () => Promise<CamoxDocument>;
   projectUuid?: string;
@@ -107,6 +109,13 @@ export declare function getRuntimePathname(url: string, runtimeBasePath?: string
 export declare function isPublicRequest(request: Request, options?: RuntimeOptions): boolean;
 export declare function matchRuntimeRoute(pathname: string): RuntimeRouteMatch;
 export declare function createPageHeadInput(head: PageHead): UseHeadInput;
+/** What the renderer document tells its client: where the API, sign-in and runtime are. */
+export interface RendererDocumentInput {
+  apiUrl?: string;
+  authenticationUrl?: string;
+  projectUuid?: string;
+  runtimeBasePath: string;
+}
 export declare function handleCamoxRequest(request: Request, options?: RuntimeOptions): Promise<Response | null>;
 //#endregion
 export {};

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, 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, 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";
@@ -459,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;
@@ -470,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
@@ -832,7 +850,7 @@ async function createPageHtmlResponse({ options, pathname, located, request, pag
 			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>
@@ -841,7 +859,7 @@ async function createPageHtmlResponse({ options, pathname, located, request, pag
 ${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}>
@@ -1116,7 +1134,7 @@ 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: {
 			...isPrivateRender(request, options) ? { "Cache-Control": "private, no-store" } : {},
 			Vary: "Cookie",
@@ -1124,7 +1142,7 @@ async function createDerivedResponse(options, pathname, located, request, { data
 		} });
 		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),
@@ -1284,7 +1302,7 @@ async function createPageDataResponse({ options, pathname, located, request, pag
 			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)) {
@@ -1313,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);

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,10 +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, _env?: unknown, context?: WorkerContext): Promise<Response>;
+  fetch(request: Request, env?: unknown, context?: WorkerContext): Promise<Response>;
 };
 //#endregion
 export { _default as default };

package/dist/features/runtime/worker.js

@@ -1,7 +1,9 @@
+import { rememberPublishingDraft } from "./publishingDraft.js";
 import { fetchLocalhostOnLoopback } from "./loopbackFetch.js";
-import { readLiveCacheKey, respondThroughPublicCache } from "./publicCache.js";
+import { PUBLIC_CACHE_NAME, readLiveCacheKey, respondThroughPublicCache } from "./publicCache.js";
 import { shouldHandleRequest, withDevHtml } from "./workerRequest.js";
-import { devHtml, handleCamoxRequest, isPublicRequest, publicCacheSource, 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
 /**
@@ -19,17 +21,28 @@ function notFound() {
 * its context can't keep anything past the response.
 */
 function respond(request, context) {
-	const cache = globalThis.caches?.default;
-	if (devHtml || !context || !cache || !isPublicRequest(request)) return handleCamoxRequest(request);
+	const caches = globalThis.caches;
+	if (devHtml || !context || !caches || !isPublicRequest(request)) return handleCamoxRequest(request);
 	const { apiUrl, projectUuid, build } = publicCacheSource;
 	return respondThroughPublicCache(request, {
-		cache,
+		cache: () => caches.open(PUBLIC_CACHE_NAME),
 		liveCacheKey: () => readLiveCacheKey(apiUrl, projectUuid),
 		build,
 		waitUntil: (promise) => context.waitUntil(promise)
 	}, () => handleCamoxRequest(request));
 }
-var worker_default = { async fetch(request, _env, context) {
+/**
+* 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 respond(request, context);
 	if (!response) return notFound();
@@ -37,4 +50,4 @@ var worker_default = { async fetch(request, _env, context) {
 } };
 
 //#endregion
-export { worker_default as default };
+export { CamoxDefinitionSet, worker_default as default };