camox 0.46.0 → 0.48.0

package/dist/features/routes/pageRuntime.js

@@ -1,7 +1,10 @@
-import { localeHeaders, localizedPath } from "../../lib/locale-path.js";
+import { UNNAMED_DEFAULT_LOCALE, localeHeaders } from "../../lib/locale-path.js";
 import { createDraftScope, withoutDraft } from "../../lib/draft-scope.js";
 import { createStudioCache, reads } from "../../lib/studio-reads.js";
 import { linkFallbackLocale } from "../../lib/link-pages.js";
+import { curatedLayoutContext } from "../../core/layoutContext.js";
+import { PAGE_IMAGE_SIZE, pageImageUrl } from "../og/pageImage.js";
+import { isArticle } from "../../core/structuredData.js";
 import { DRAFT_ENDED_ERROR_CODE, DRAFT_HEADER, NO_DEVELOPMENT_DRAFT_ERROR } from "@camox/api-contract/drafts";
 import { createORPCClient } from "@orpc/client";
 import { RPCLink } from "@orpc/client/fetch";
@@ -235,39 +238,25 @@ async function createMarkdownResponse({ apiUrl, camoxApp, locale, pathname, proj
 		return null;
 	}
 }
-/** A page's title and description, built by its layout's callbacks. */
+/** A page's title and description, built by its layout's `toTitle` and `toDescription`. */
 function buildPageMeta(input) {
-	const context = {
-		data: input.data,
-		...input.item && { item: input.item },
-		params: input.params,
-		projectName: input.projectName,
-		pageFullPath: input.pageFullPath
-	};
-	const title = input.layout?.buildMetaTitle({
-		...context,
-		pageMetaTitle: input.pageMetaTitle
-	}) ?? input.pageMetaTitle;
-	const description = input.layout?.buildMetaDescription ? input.layout.buildMetaDescription({
-		...context,
-		pageMetaDescription: input.pageMetaDescription
-	}) : input.pageMetaDescription;
+	const { layout, context } = input;
+	const title = layout ? layout.toTitle(context) : context.page.title;
+	const description = layout ? layout.toDescription(context) : context.page.description;
 	return {
 		title,
 		...description && { description }
 	};
 }
-/** A curated page's meta input: its editor metadata and its layout. */
+/** What a page's layout says the page is, from the page's context. */
+function declarePage(input) {
+	return input.layout?.toStructuredData(input.context);
+}
 /** A curated page's meta input. Its path keeps the prefix of the page's `locale`. */
-function curatedPageMetaInput(camoxApp, page, locale) {
+function curatedPageMetaInput(camoxApp, page, locale = UNNAMED_DEFAULT_LOCALE) {
 	return {
 		layout: page.layout ? camoxApp?.getLayoutById(page.layout.layoutId)?._internal : void 0,
-		pageMetaTitle: page.page.metaTitle ?? page.page.pathSegment,
-		pageMetaDescription: page.page.metaDescription ?? void 0,
-		data: void 0,
-		params: {},
-		projectName: page.projectName,
-		pageFullPath: locale ? localizedPath(page.page.fullPath, locale) : page.page.fullPath
+		context: curatedLayoutContext(page, locale)
 	};
 }
 /** A Markdown Representation, opened by YAML front matter stating the page's title, description and URL. */
@@ -281,18 +270,18 @@ function withFrontMatter(markdown, meta) {
 /** The head every page gets, whatever its layout kind. */
 function buildPageHead(input) {
 	const { title, description } = buildPageMeta(input);
+	const mainEntity = declarePage(input) ?? (input.recordType ? { "@type": input.recordType } : void 0);
 	const meta = [{ title }];
 	if (description) meta.push({
 		name: "description",
 		content: description
 	});
-	const ogImageParams = new URLSearchParams({
-		...input.layout && { layoutId: input.layout.id },
-		title: input.ogImageTitle ?? title,
-		...description && { description },
-		...input.projectName && { projectName: input.projectName }
+	const { page, project } = input.context;
+	const ogImageUrl = pageImageUrl({
+		origin: input.origin,
+		path: page.path,
+		customImageUrl: input.customOgImageUrl
 	});
-	const ogImageUrl = input.customOgImageUrl ?? `${input.origin}/og?${ogImageParams.toString()}`;
 	meta.push({
 		property: "og:title",
 		content: title
@@ -301,15 +290,25 @@ function buildPageHead(input) {
 		content: ogImageUrl
 	}, {
 		property: "og:image:width",
-		content: "1200"
+		content: String(PAGE_IMAGE_SIZE.width)
 	}, {
 		property: "og:image:height",
-		content: "630"
+		content: String(PAGE_IMAGE_SIZE.height)
 	});
 	if (description) meta.push({
 		property: "og:description",
 		content: description
 	});
+	meta.push({
+		property: "og:type",
+		content: isArticle(mainEntity ?? { "@type": "" }) ? "article" : "website"
+	}, {
+		property: "og:site_name",
+		content: project.name
+	}, {
+		name: "twitter:card",
+		content: "summary_large_image"
+	});
 	const links = [{
 		rel: "icon",
 		href: input.faviconUrl
@@ -317,7 +316,7 @@ function buildPageHead(input) {
 	if (input.hasMarkdown) links.push({
 		rel: "alternate",
 		type: "text/markdown",
-		href: `${input.origin}${getMarkdownPath(input.pageFullPath)}`
+		href: `${input.origin}${getMarkdownPath(page.path)}`
 	});
 	return {
 		meta,
@@ -328,10 +327,8 @@ function buildPageHead(input) {
 function buildCamoxPageHead(camoxApp, loaderData, locale) {
 	if (!loaderData) return {};
 	const { page, origin, faviconUrl } = loaderData;
-	const metaInput = curatedPageMetaInput(camoxApp, page, locale);
 	return buildPageHead({
-		...metaInput,
-		ogImageTitle: metaInput.pageMetaTitle,
+		...curatedPageMetaInput(camoxApp, page, locale),
 		customOgImageUrl: page.page.customOgImageUrl,
 		origin,
 		faviconUrl,
@@ -340,4 +337,4 @@ function buildCamoxPageHead(camoxApp, loaderData, locale) {
 }
 
 //#endregion
-export { buildCamoxPageHead, buildCamoxPageLoaderData, buildDefaultFaviconUrl, buildFaviconUrl, buildPageHead, buildPageMeta, createMarkdownResponse, createServerApiClient, createServerStudioCache, getMarkdownPath, isAuthSessionError, isNotFoundError, loadCamoxPage, loadCamoxPageForRequest, parseMarkdownPath, parseQuality, prefersMarkdown, readDraftOrLive, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter };
+export { buildCamoxPageHead, buildCamoxPageLoaderData, buildDefaultFaviconUrl, buildFaviconUrl, buildPageHead, buildPageMeta, createMarkdownResponse, createServerApiClient, createServerStudioCache, curatedPageMetaInput, declarePage, getMarkdownPath, isAuthSessionError, isNotFoundError, loadCamoxPage, loadCamoxPageForRequest, parseMarkdownPath, parseQuality, prefersMarkdown, readDraftOrLive, readScopeLocales, renderedHref, resolveMemberProject, withFrontMatter };

package/dist/features/runtime/RuntimeChrome.js

@@ -1,8 +1,8 @@
 import { previewStore, selectIsCanvasShown } from "../preview/previewStore.js";
 import { shownRecordPage } from "../preview/pageRecord.js";
 import { Navbar } from "../studio/components/Navbar.js";
-import { PreviewToolbar } from "../preview/components/PreviewToolbar.js";
 import { EditingFallbackContext } from "./editingFallback.js";
+import { PreviewToolbar } from "../preview/components/PreviewToolbar.js";
 import { StudioEditingFallback } from "../preview/components/StudioEditingFallback.js";
 import { ChatSidebar } from "../studio/components/ChatSidebar.js";
 import { FollowAgentProvider } from "../studio/FollowAgentProvider.js";
@@ -22,7 +22,7 @@ function RuntimeChrome(t0) {
 	const website = !input.routeKind;
 	const hidden = useSelector(previewStore, _temp);
 	const isCanvasShown = useSelector(previewStore, selectIsCanvasShown);
-	const showChat = !website || isCanvasShown;
+	const showChat = website && isCanvasShown;
 	const t1 = input.runtimeBasePath;
 	let t2;
 	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {

package/dist/features/runtime/breadcrumbs.js

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

package/dist/features/runtime/livePages.js

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

package/dist/features/runtime/pageApp.js

@@ -1,11 +1,12 @@
 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";
 import { Frame } from "../preview/components/Frame.js";
 import { PreviewSignInPage } from "../provider/PreviewSignInPage.js";
-import { CoreCamoxProvider, isLocalhostPreview } from "../provider/CoreCamoxProvider.js";
+import { CoreCamoxProvider } from "../provider/CoreCamoxProvider.js";
 import { CuratedPageContent } from "../page/CuratedPageContent.js";
 import { EditingFallbackSlot } from "./editingFallback.js";
 import { PageNavigationProvider } from "./pageNavigation.js";
@@ -96,7 +97,6 @@ function PageApp(t0) {
 	return t6;
 }
 const LazyEditablePageExperience = React.lazy(() => import("../preview/EditablePageExperience.js").then((module) => ({ default: module.EditablePageExperience })));
-const LazyLocalhostPreviewProvider = React.lazy(() => import("../provider/LocalhostPreviewProvider.js").then((module) => ({ default: module.LocalhostPreviewProvider })));
 /** 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());
@@ -116,7 +116,7 @@ var EditingActivationBoundary = class extends React.Component {
 };
 const subscribeToHydration = () => () => {};
 function PageExperience(t0) {
-	const $ = c(46);
+	const $ = c(38);
 	const { camoxApp, input, queryClient, studioDocument } = t0;
 	const { isAuthenticated, isLoading } = useAuthState();
 	const hasHydrated = React.useSyncExternalStore(subscribeToHydration, _temp, _temp2);
@@ -145,6 +145,7 @@ function PageExperience(t0) {
 		t2 = $[5];
 	}
 	React.useEffect(t1, t2);
+	useSignInShortcut(hasHydrated && !studioOnly && !isAuthenticated && !isLoading);
 	let t3;
 	if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
 		t3 = /* @__PURE__ */ jsx("div", {
@@ -248,50 +249,21 @@ function PageExperience(t0) {
 		return t11;
 	}
 	if (studioOnly) return null;
-	if (hasHydrated && isLocalhostPreview()) {
-		let t7;
-		if ($[35] !== readOnlyPage) {
-			t7 = /* @__PURE__ */ jsx(LazyLocalhostPreviewProvider, { children: readOnlyPage });
-			$[35] = readOnlyPage;
-			$[36] = t7;
-		} else t7 = $[36];
-		let t8;
-		if ($[37] !== camoxApp || $[38] !== t7) {
-			t8 = /* @__PURE__ */ jsx(AllBlocks, {
-				camoxApp,
-				children: t7
-			});
-			$[37] = camoxApp;
-			$[38] = t7;
-			$[39] = t8;
-		} else t8 = $[39];
-		let t9;
-		if ($[40] !== readOnlyPage || $[41] !== t8) {
-			t9 = /* @__PURE__ */ jsx(React.Suspense, {
-				fallback: readOnlyPage,
-				children: t8
-			});
-			$[40] = readOnlyPage;
-			$[41] = t8;
-			$[42] = t9;
-		} else t9 = $[42];
-		return t9;
-	}
 	if (studioDocument) {
 		let t7;
-		if ($[43] === Symbol.for("react.memo_cache_sentinel")) {
+		if ($[35] === Symbol.for("react.memo_cache_sentinel")) {
 			t7 = { height: "100vh" };
-			$[43] = t7;
-		} else t7 = $[43];
+			$[35] = t7;
+		} else t7 = $[35];
 		let t8;
-		if ($[44] !== isolatedPage) {
+		if ($[36] !== isolatedPage) {
 			t8 = /* @__PURE__ */ jsx("div", {
 				style: t7,
 				children: isolatedPage
 			});
-			$[44] = isolatedPage;
-			$[45] = t8;
-		} else t8 = $[45];
+			$[36] = isolatedPage;
+			$[37] = t8;
+		} else t8 = $[37];
 		return t8;
 	}
 	return readOnlyPage;

package/dist/features/runtime/pageGraph.js

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

package/dist/features/runtime/projectLogo.js

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

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

@@ -1,11 +1,11 @@
 import { CamoxDocument } from "../../core/defineDocument.js";
+import { AlternatePath, LocaleView } from "../../lib/locale-path.js";
 import { AnyLayoutLoaderResult } from "../../core/createLayout.js";
 import { CamoxApp } from "../../core/createApp.js";
-import { AlternatePath, LocaleView } from "../../lib/locale-path.js";
 import { AnalyticsProviders } from "./analytics.js";
 import { RuntimeOwnedRouteKind } from "./runtimeRoutes.js";
 import { StudioRenderInput } from "./studioApp.js";
-import { DraftRead, MemberProject, createServerApiClient } from "../routes/pageRuntime.js";
+import { DraftRead, MemberProject, PageHead, createServerApiClient } from "../routes/pageRuntime.js";
 import { UseHeadInput } from "unhead/types";
 //#region src/features/runtime/runtime.d.ts
 export type RuntimeRouteKind = RuntimeOwnedRouteKind | "canvas" | "page" | "studio" | "studio-content" | "studio-nested";
@@ -39,6 +39,14 @@ export interface PageRenderInput extends DraftRead {
   presentation?: "public" | "studio";
   derived?: {
     layoutId: string;
+    /** What the layout's context names, beside the loader's result. */
+    page?: {
+      /** The params the page's route matched. */
+      params: Record<string, string>;
+      /** The page's path, with its locale's prefix. */
+      path: string;
+      projectName: string;
+    };
     result?: AnyLayoutLoaderResult;
     layout: Awaited<ReturnType<ReturnType<typeof createServerApiClient>["layouts"]["get"]>>["layout"];
   };
@@ -89,9 +97,6 @@ export interface RuntimeOptions {
 }
 export declare function getRuntimePathname(url: string, runtimeBasePath?: string): string | null;
 export declare function matchRuntimeRoute(pathname: string): RuntimeRouteMatch;
-export declare function createPageHeadInput(head: {
-  meta?: Array<Record<string, string>>;
-  links?: Array<Record<string, string>>;
-}): UseHeadInput;
+export declare function createPageHeadInput(head: PageHead): UseHeadInput;
 export declare function handleCamoxRequest(request: Request, options?: RuntimeOptions): Promise<Response | null>;
 //#endregion