camox 0.48.0 → 0.51.0

package/dist/features/runtime/runtime.js

@@ -8,11 +8,11 @@ import { reads } from "../../lib/studio-reads.js";
 import { asCollectionItem, recordMarkdownTemplate, recordPageValues } from "../../core/recordItem.js";
 import { buildLayoutContext, curatedLayoutContext } from "../../core/layoutContext.js";
 import { PLATFORM_SCRIPT } from "../../lib/platform.js";
-import { STUDIO_ASSETS_PATH, STUDIO_CANVAS_PATH, STUDIO_CONTENT_PATH, matchCollectionContentPath } from "../studio/routes.js";
+import { STUDIO_ASSETS_PATH, STUDIO_CANVAS_PATH, STUDIO_CONTENT_PATH, STUDIO_SETTINGS_PATH, matchCollectionContentPath } from "../studio/routes.js";
 import { STUDIO_THEME_SCRIPT } from "../studio/studioTheme.js";
 import { DefaultPageImage, renderPageImage } from "../og/pageImage.js";
 import { discoverLayoutPages, matchDerivedLayout } from "../../core/derivedRoutes.js";
-import { buildCamoxPageHead, buildFaviconUrl, buildPageHead, buildPageMeta, createMarkdownResponse, createServerApiClient, createServerStudioCache, declarePage, isNotFoundError, loadCamoxPageForRequest, parseMarkdownPath, prefersMarkdown, readDraftOrLive, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter } from "../routes/pageRuntime.js";
+import { buildCamoxPageHead, buildFaviconUrl, buildPageHead, buildPageMeta, createServerApiClient, createServerStudioCache, curatedMarkdownResponse, declarePage, isNotFoundError, loadCamoxPageForRequest, parseMarkdownPath, prefersMarkdown, readDraftOrLive, readPageMarkdown, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter } from "../routes/pageRuntime.js";
 import { alternatesByPage, findAlternates, hreflangLinks } from "./alternates.js";
 import { configuredProviders, renderAnalyticsScripts } from "./analytics.js";
 import { omitArtifactSources } from "./artifactSources.js";
@@ -29,6 +29,13 @@ import { createHead, renderSSRHead } from "@unhead/react/server";
 
 //#region src/features/runtime/runtime.ts
 const DEFAULT_RUNTIME_BASE_PATH = "";
+/** The studio's own routes, rather than a page or the Canvas. */
+const STUDIO_ROUTE_KINDS = [
+	"studio",
+	"studio-content",
+	"studio-settings",
+	"studio-nested"
+];
 function normalizeRuntimeBasePath(basePath) {
 	if (basePath === void 0) return DEFAULT_RUNTIME_BASE_PATH;
 	if (!basePath || basePath === "/") return "";
@@ -57,6 +64,26 @@ function getRequestDraftId(request, options) {
 function isPrivateRender(request, options) {
 	return !!getServerAuthCookieHeader(request.headers) || getRequestDraftId(request, options) !== void 0;
 }
+/** The routes whose response is the same for every visitor, unless the request is private. */
+const PUBLIC_ROUTE_KINDS = /* @__PURE__ */ new Set([
+	"page",
+	"data",
+	"og",
+	"logo",
+	"sitemap",
+	"llms-txt"
+]);
+/**
+* Whether a request reads what every visitor sees, so a shared cache may answer it: a GET or
+* HEAD of a page or a public output, with no session, no draft named and no preview handoff. A
+* response that comes out private all the same, such as the Studio's, still says so.
+*/
+function isPublicRequest(request, options = {}) {
+	if (request.method !== "GET" && request.method !== "HEAD") return false;
+	if (isPrivateRender(request, options) || isPreviewHandoff(request, options)) return false;
+	const pathname = getRuntimePathname(request.url, options.runtimeBasePath);
+	return pathname !== null && PUBLIC_ROUTE_KINDS.has(matchRuntimeRoute(pathname).kind);
+}
 function escapeXml(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
 }
@@ -90,6 +117,10 @@ function matchRuntimeRoute(pathname) {
 		kind: "studio-content",
 		pathname
 	};
+	if (pathname === "/camox/settings" || pathname === `${"/camox/settings"}/`) return {
+		kind: "studio-settings",
+		pathname
+	};
 	if (pathname.startsWith("/camox/")) return {
 		kind: "studio-nested",
 		pathname
@@ -184,10 +215,7 @@ function createLlmsTxtResponse(request, options) {
 		pages: website.localizations[0].pages,
 		layouts: (website.app?.getLayouts() ?? []).map(({ _internal }) => _internal),
 		url: absoluteUrl(request, options)
-	}), {
-		"Content-Type": "text/plain; charset=utf-8",
-		"Cache-Control": "public, max-age=300, stale-while-revalidate=3600"
-	}));
+	}), { "Content-Type": "text/plain; charset=utf-8" }));
 }
 /** Tells LLM tools fetching a page's HTML where the website's llms.txt is. */
 function llmsTxtLinkHeader(options) {
@@ -492,8 +520,7 @@ function isPreviewHandoff(request, options) {
 * The alternates of the page a request renders, where it exists in each of the scope's locales,
 * and its head with their `hreflang` links. Without a head, there is none to add them to.
 */
-async function readAlternates(request, options, { located, identity, head, described, ...reading }) {
-	const localeReads = requestLocaleReads(options, reading);
+async function readAlternates(request, options, { located, identity, head, described, localeReads }) {
 	const [alternates, crumbs] = await Promise.all([findRequestAlternates(options, located, identity, localeReads), head ? readRequestBreadcrumb(options, located, described.title, localeReads) : []]);
 	const url = absoluteUrl(request, options);
 	const links = hreflangLinks(alternates, located.locales, url);
@@ -565,7 +592,7 @@ function withLocatedTags(head, { url, locale, alternates }) {
 		}]
 	};
 }
-function requestLocaleReads(options, { authCookieHeader, draftId }) {
+function requestLocaleReads(options, { authCookieHeader, draftId, queryClient }) {
 	const { apiUrl, projectUuid } = options;
 	const reading = {
 		authCookieHeader: draftId ? authCookieHeader : void 0,
@@ -573,9 +600,15 @@ function requestLocaleReads(options, { authCookieHeader, draftId }) {
 	};
 	const source = draftId ? "draft" : "live";
 	const pagesByLocale = /* @__PURE__ */ new Map();
+	const studioCache = apiUrl && queryClient ? createServerStudioCache(queryClient, { apiUrl }) : void 0;
 	return {
 		pages: (locale) => {
 			if (!apiUrl || !projectUuid) return Promise.resolve([]);
+			const loaded = studioCache?.get(reads.pageList({ projectUuid }), {
+				in: draftId ?? null,
+				locale
+			});
+			if (loaded) return Promise.resolve(loaded);
 			const read = pagesByLocale.get(locale.tag) ?? createServerApiClient(apiUrl, {
 				...reading,
 				locale
@@ -670,27 +703,89 @@ async function createPreviewHandoffResponse({ options, pathname, request }) {
 		"Referrer-Policy": "no-referrer"
 	} });
 }
-async function createPageHtmlResponse({ options, pathname, located, request }) {
+/** Starts reading the curated page at a locale-relative path, as the request reads it. */
+function readCuratedPage(options, request, { locale, path }) {
+	const queryClient = new QueryClient();
+	return {
+		queryClient,
+		result: loadCamoxPageForRequest({
+			apiUrl: options.apiUrl,
+			authCookieHeader: getServerAuthCookieHeader(request.headers),
+			draftId: getRequestDraftId(request, options),
+			locale,
+			origin: new URL(request.url).origin,
+			pathname: path,
+			projectUuid: options.projectUuid,
+			queryClient
+		})
+	};
+}
+/** A first path segment that could be a locale's prefix: a language tag, in lowercase. */
+const LOCALE_PREFIX_LIKE = /^\/[a-z]{2,3}(?:-[a-z0-9]{1,8})*(?:\/|$)/;
+/**
+* The read of the curated page a path names in the default locale, started while the request's
+* locales are read, or none where it couldn't be the request's page. A default-locale page sits
+* at its own path, so its read needn't wait for the locales: once read, they only confirm the path
+* names no other locale. A path whose first segment looks like a locale's prefix waits for them
+* instead, rather than reading a page it likely doesn't name, and a singleton's path reads no
+* curated page.
+*/
+async function readDefaultLocalePageEarly(options, request, pathname) {
+	const { apiUrl, projectUuid } = options;
+	if (!apiUrl || !projectUuid) return void 0;
+	if (matchLocalizedRoute(pathname)?.kind !== "page" || LOCALE_PREFIX_LIKE.test(pathname)) return;
+	const app = await options.getCamoxApp?.().catch(() => void 0);
+	if (app && matchDerivedLayout(app.getLayouts(), pathname)?.layout._internal.kind === "singleton") return void 0;
+	const read = readCuratedPage({
+		...options,
+		apiUrl,
+		projectUuid
+	}, request, {
+		locale: UNNAMED_DEFAULT_LOCALE,
+		path: pathname
+	});
+	read.result.catch(() => void 0);
+	return read;
+}
+/**
+* The reads of each locale the head of the request's curated page makes, and those it can make
+* while the page is read. When the request reads Live, whatever the page's read finds about its
+* draft, the pages of the locales the page's read doesn't load start loading now. Otherwise they
+* wait for the page's read to settle the draft.
+*/
+function curatedPageLocaleReads(options, request, located, queryClient) {
+	const authCookieHeader = getServerAuthCookieHeader(request.headers);
+	const forDraft = (draftId) => requestLocaleReads(options, {
+		authCookieHeader,
+		draftId,
+		queryClient
+	});
+	if (!(!getRequestDraftId(request, options) || !authCookieHeader)) return forDraft;
+	const live = forDraft(void 0);
+	if (located.locales.length > 1) for (const locale of located.locales) {
+		if (locale.tag === located.locale.tag || locale.isDefault) continue;
+		live.pages(locale).catch(() => void 0);
+	}
+	return () => live;
+}
+async function createPageHtmlResponse({ options, pathname, located, request, pageRead }) {
 	if (!options.apiUrl || !options.authenticationUrl || !options.projectUuid || !options.renderPage) return createPageDataResponse({
 		options,
 		pathname,
 		located,
-		request
+		request,
+		pageRead
 	});
 	const singleton = await createDerivedResponse(options, pathname, located, request, { singletonOnly: true });
 	if (singleton) return singleton;
-	const queryClient = new QueryClient();
+	const { queryClient, result: reading } = pageRead ?? readCuratedPage({
+		...options,
+		apiUrl: options.apiUrl,
+		projectUuid: options.projectUuid
+	}, request, located);
+	const localeReads = curatedPageLocaleReads(options, request, located, queryClient);
 	try {
-		const result = await loadCamoxPageForRequest({
-			apiUrl: options.apiUrl,
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: getRequestDraftId(request, options),
-			locale: located.locale,
-			origin: new URL(request.url).origin,
-			pathname: located.path,
-			projectUuid: options.projectUuid,
-			queryClient
-		});
+		const result = await reading;
 		const headers = new Headers({
 			"Content-Type": "text/html; charset=utf-8",
 			Vary: "Cookie",
@@ -708,8 +803,7 @@ async function createPageHtmlResponse({ options, pathname, located, request }) {
 			},
 			head: camoxApp ? buildCamoxPageHead(camoxApp, result.data, located.locale) : {},
 			described: curatedPageDescription(camoxApp, result.data.page, located.locale),
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: result.draftId
+			localeReads: localeReads(result.draftId)
 		});
 		const dehydratedState = dehydrate(queryClient);
 		const { project } = result;
@@ -982,8 +1076,10 @@ async function createDerivedResponse(options, pathname, located, request, { data
 					titles: recordValues?.titles
 				})
 			},
-			authCookieHeader,
-			draftId: read.draftId
+			localeReads: requestLocaleReads(options, {
+				authCookieHeader,
+				draftId: read.draftId
+			})
 		});
 		const analytics = dataOnly ? void 0 : visitorAnalytics(options, {
 			studio,
@@ -1022,7 +1118,7 @@ async function createDerivedResponse(options, pathname, located, request, { data
 		const document = await options.getDocument?.() ?? {};
 		await preparePreviewDocument(input, options, document, !studio && !dataOnly ? "" : void 0);
 		if (dataOnly) return Response.json(input, { headers: {
-			"Cache-Control": "private, no-store",
+			...isPrivateRender(request, options) ? { "Cache-Control": "private, no-store" } : {},
 			Vary: "Cookie",
 			...clearAuthCookie ? { "Set-Cookie": buildClearServerAuthCookieHeader() } : {}
 		} });
@@ -1136,30 +1232,26 @@ async function createCanvasOnlyResponse({ options, pathname, located, request, d
 		...headers
 	} });
 }
-async function createPageDataResponse({ options, pathname, located, request }) {
+async function createPageDataResponse({ options, pathname, located, request, pageRead }) {
 	if (!options.apiUrl || !options.projectUuid) return Response.json({ message: "Camox page loader is not configured." }, { status: 500 });
 	const singleton = await createDerivedResponse(options, pathname, located, request, {
 		dataOnly: true,
 		singletonOnly: true
 	});
 	if (singleton) return singleton;
-	const queryClient = new QueryClient();
+	const { queryClient, result: reading } = pageRead ?? readCuratedPage({
+		...options,
+		apiUrl: options.apiUrl,
+		projectUuid: options.projectUuid
+	}, request, located);
+	const localeReads = curatedPageLocaleReads(options, request, located, queryClient);
 	try {
-		const result = await loadCamoxPageForRequest({
-			apiUrl: options.apiUrl,
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: getRequestDraftId(request, options),
-			locale: located.locale,
-			origin: new URL(request.url).origin,
-			pathname: located.path,
-			projectUuid: options.projectUuid,
-			queryClient
-		});
+		const result = await reading;
 		const headers = new Headers({
 			"Content-Type": "application/json; charset=utf-8",
-			"Cache-Control": "private, no-store",
 			Vary: "Cookie"
 		});
+		if (isPrivateRender(request, options)) headers.set("Cache-Control", "private, no-store");
 		if (result.shouldClearAuthCookie) headers.append("Set-Cookie", buildClearServerAuthCookieHeader());
 		const camoxApp = await options.getCamoxApp?.();
 		const { alternates, head } = await readAlternates(request, options, {
@@ -1170,8 +1262,7 @@ async function createPageDataResponse({ options, pathname, located, request }) {
 			},
 			head: camoxApp ? buildCamoxPageHead(camoxApp, result.data, located.locale) : null,
 			described: curatedPageDescription(camoxApp, result.data.page, located.locale),
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: result.draftId
+			localeReads: localeReads(result.draftId)
 		});
 		const dehydratedState = dehydrate(queryClient);
 		const input = {
@@ -1239,19 +1330,17 @@ async function handleCamoxRequest(request, options = {}) {
 	const { apiUrl, projectUuid } = options;
 	const markdownPathname = parseMarkdownPath(pathname);
 	if (apiUrl && projectUuid && (markdownPathname || prefersMarkdown(request.headers.get("Accept") ?? ""))) {
-		const located = await locateRequest(request, options, markdownPathname ?? pathname, { live: true });
-		if (markdownPathname || matchLocalizedRoute(located.path)?.kind === "page") {
-			const markdownResponse = await createPageMarkdownResponse({
-				...options,
-				apiUrl,
-				projectUuid
-			}, located, {
-				pathname: markdownPathname ?? pathname,
-				request
-			});
-			if (markdownResponse) return markdownResponse;
-			if (markdownPathname) return new Response("Page not found", { status: 404 });
-		}
+		const markdownResponse = await createPageMarkdownResponse({
+			...options,
+			apiUrl,
+			projectUuid
+		}, {
+			pathname: markdownPathname ?? pathname,
+			request,
+			pagesOnly: !markdownPathname
+		});
+		if (markdownResponse) return markdownResponse;
+		if (markdownPathname) return new Response("Page not found", { status: 404 });
 	}
 	return respondInLocale(options, request, pathname);
 }
@@ -1260,7 +1349,7 @@ async function handleCamoxRequest(request, options = {}) {
 * With `dataOnly`, as the JSON client navigation loads.
 */
 async function respondInLocale(options, request, pathname, { dataOnly = false } = {}) {
-	const located = await locateRequest(request, options, pathname);
+	const [early, located] = await Promise.all([readDefaultLocalePageEarly(options, request, pathname), locateRequest(request, options, pathname)]);
 	const localized = matchLocalizedRoute(located.path);
 	if (!localized) return new Response("Not found", { status: 404 });
 	const target = {
@@ -1278,13 +1367,29 @@ async function respondInLocale(options, request, pathname, { dataOnly = false }
 		match: localized,
 		dataOnly
 	});
-	return dataOnly ? createPageDataResponse(target) : createPageHtmlResponse(target);
+	const page = {
+		...target,
+		pageRead: located.locale.isDefault ? early : void 0
+	};
+	return dataOnly ? createPageDataResponse(page) : createPageHtmlResponse(page);
 }
 /**
 * A page's Markdown Representation in its locale, with the same precedence as its HTML:
-* singleton, curated page, then derived layout. Null when the page has none.
+* singleton, curated page, then derived layout. Null when the page has none. Markdown is a public
+* output: it reads Live, whoever asks, and one read finds the path's locale and its curated page.
 */
-async function createPageMarkdownResponse(options, { locale, path }, { pathname, request }) {
+async function createPageMarkdownResponse(options, { pathname, request, pagesOnly }) {
+	let read;
+	try {
+		read = await readPageMarkdown({
+			...options,
+			path: pathname
+		});
+	} catch {
+		return null;
+	}
+	const { locale, path } = read;
+	if (pagesOnly && matchLocalizedRoute(path)?.kind !== "page") return null;
 	const page = {
 		pathname,
 		url: absoluteUrl(request, options)(pathname)
@@ -1292,20 +1397,12 @@ async function createPageMarkdownResponse(options, { locale, path }, { pathname,
 	const app = await options.getCamoxApp?.();
 	const layoutMatch = app && matchDerivedLayout(app.getLayouts(), path);
 	if (layoutMatch?.layout._internal.kind === "singleton") return createLayoutMarkdownResponse(options, layoutMatch, locale, page);
-	return createMarkdownResponse({
-		apiUrl: options.apiUrl,
-		camoxApp: app,
-		locale,
-		pathname: path,
-		projectUuid: options.projectUuid,
-		request,
-		url: page.url,
-		onNotFound: async () => layoutMatch ? createLayoutMarkdownResponse(options, layoutMatch, locale, page) : null
-	});
+	if (read.page) return curatedMarkdownResponse(app, read, page.url);
+	return layoutMatch ? createLayoutMarkdownResponse(options, layoutMatch, locale, page) : null;
 }
 /** Whether a route is one of the studio's own, rather than a page or the Canvas. */
 function isStudioRoute(match) {
-	return match.kind === "studio" || match.kind === "studio-content" || match.kind === "studio-nested";
+	return STUDIO_ROUTE_KINDS.includes(match.kind);
 }
 /**
 * The studio or page route a locale-relative path names, or null for a runtime-owned route
@@ -1317,19 +1414,16 @@ function matchLocalizedRoute(path) {
 }
 /**
 * The locale a request's path names, among the locales of the scope it reads: the URL's draft's
-* for a session naming one, else Live's. `live` reads Live's whatever the request names. Without
-* an API there are none to read: every path is the default locale's, which then says it can't
-* render.
+* for a session naming one, else Live's. Without an API there are none to read: every path is the
+* default locale's, which then says it can't render.
 */
-async function locateRequest(request, options, pathname, { live = false } = {}) {
+async function locateRequest(request, options, pathname) {
 	const { apiUrl, projectUuid } = options;
 	const locales = apiUrl && projectUuid ? await readScopeLocales({
 		apiUrl,
 		projectUuid,
-		...!live && {
-			authCookieHeader: getServerAuthCookieHeader(request.headers),
-			draftId: getRequestDraftId(request, options)
-		}
+		authCookieHeader: getServerAuthCookieHeader(request.headers),
+		draftId: getRequestDraftId(request, options)
 	}) : [UNNAMED_DEFAULT_LOCALE];
 	return {
 		...parseLocalePath(pathname, locales),
@@ -1338,4 +1432,4 @@ async function locateRequest(request, options, pathname, { live = false } = {})
 }
 
 //#endregion
-export { createPageHeadInput, getRuntimePathname, handleCamoxRequest, matchRuntimeRoute };
+export { createPageHeadInput, getRuntimePathname, handleCamoxRequest, isPublicRequest, matchRuntimeRoute };

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

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

package/dist/features/runtime/worker.js

@@ -1,6 +1,7 @@
 import { fetchLocalhostOnLoopback } from "./loopbackFetch.js";
+import { readLiveCacheKey, respondThroughPublicCache } from "./publicCache.js";
 import { shouldHandleRequest, withDevHtml } from "./workerRequest.js";
-import { devHtml, handleCamoxRequest, runtimeBasePath } from "virtual:camox/server";
+import { devHtml, handleCamoxRequest, isPublicRequest, publicCacheSource, runtimeBasePath } from "virtual:camox/server";
 
 //#region src/features/runtime/worker.ts
 /**
@@ -12,9 +13,25 @@ if (devHtml) globalThis.fetch = fetchLocalhostOnLoopback(globalThis.fetch.bind(g
 function notFound() {
 	return new Response("Not found", { status: 404 });
 }
-var worker_default = { async fetch(request) {
+/**
+* Answers a request, from the edge cache when every visitor sees the same. Dev renders the
+* developer's development draft, which nothing shares, and a Worker calling this one without
+* its context can't keep anything past the response.
+*/
+function respond(request, context) {
+	const cache = globalThis.caches?.default;
+	if (devHtml || !context || !cache || !isPublicRequest(request)) return handleCamoxRequest(request);
+	const { apiUrl, projectUuid, build } = publicCacheSource;
+	return respondThroughPublicCache(request, {
+		cache,
+		liveCacheKey: () => readLiveCacheKey(apiUrl, projectUuid),
+		build,
+		waitUntil: (promise) => context.waitUntil(promise)
+	}, () => handleCamoxRequest(request));
+}
+var worker_default = { async fetch(request, _env, context) {
 	if (!shouldHandleRequest(request, runtimeBasePath)) return notFound();
-	const response = await handleCamoxRequest(request);
+	const response = await respond(request, context);
 	if (!response) return notFound();
 	return withDevHtml(response, devHtml);
 } };