camox 0.47.0 → 0.48.0

package/dist/features/preview/components/useFieldWriter.js

@@ -2,8 +2,8 @@ import { useProjectUuid } from "../../../lib/auth.js";
 import { useCamoxApp } from "../../provider/components/CamoxAppContext.js";
 import { referenceList } from "../../../lib/normalized-data.js";
 import { reads, useStudioCache } from "../../../lib/studio-reads.js";
-import { lexicalStateToPlainText } from "../../../core/lib/lexicalState.js";
 import { referenceListIds } from "../../../core/lib/reference.js";
+import { recordText } from "../../../core/recordItem.js";
 import { blockMutations, collectionMutations, repeatableItemMutations } from "../../../lib/queries.js";
 import { invalidateCollectionRecordViews } from "../../../lib/collection-cache.js";
 import { serializeAssetField } from "../../content/collection-form.js";
@@ -134,13 +134,11 @@ function useFieldWriter(target, schema) {
 						collectionId,
 						id: recordId
 					}));
-					const labelField = camoxApp.getCollectionById(collectionId)?._internal.label;
-					const label = labelField ? record_0.content[labelField] : void 0;
 					return {
 						id: record_0.id,
 						collectionId,
 						content: record_0.content,
-						label: typeof label === "string" ? lexicalStateToPlainText(label) : ""
+						...recordText(camoxApp.getCollectionById(collectionId), record_0.content)
 					};
 				};
 				return (async () => {

package/dist/features/preview/components/useRecordView.js

@@ -302,7 +302,7 @@ function useRecordView(t0) {
 				})
 			}] : [], {
 				key: "record",
-				label: outerRecord.label,
+				label: outerRecord.title,
 				isCurrent: !nested && !fieldHasOwnView,
 				hoverTarget: outerTarget,
 				onClick: nested || fieldHasOwnView ? () => previewStore.send({
@@ -332,7 +332,7 @@ function useRecordView(t0) {
 				},
 				{
 					key: "nested-record",
-					label: recordView.record.label,
+					label: recordView.record.title,
 					isCurrent: !fieldHasOwnView,
 					hoverTarget: nestedTarget,
 					onClick: fieldHasOwnView ? () => previewStore.send({

package/dist/features/preview/entityName.js

@@ -0,0 +1,11 @@
+//#region src/features/preview/entityName.ts
+/**
+* What the studio names a block or repeatable item by: its Summary, generated or hand-written,
+* else its title, from its definition's `toTitle` on default-locale content, else `fallback`.
+*/
+function entityName(entity, fallback) {
+	return entity.summary || entity.title || fallback;
+}
+
+//#endregion
+export { entityName };

package/dist/features/preview/pageRecord.js

@@ -157,32 +157,31 @@ function usePageRecordPlacer() {
 	const app = useCamoxApp();
 	const collection = loaded ? app.getCollectionById(loaded.collectionId) : void 0;
 	const collectionId = loaded?.collectionId ?? "";
-	const t0 = collection?._internal.label ?? "";
-	const t1 = collection ? loaded?.data : void 0;
-	let t2;
-	if ($[0] !== collectionId || $[1] !== t0 || $[2] !== t1) {
-		t2 = {
+	const t0 = collection ? loaded?.data : void 0;
+	let t1;
+	if ($[0] !== collection || $[1] !== collectionId || $[2] !== t0) {
+		t1 = {
 			collectionId,
-			labelField: t0,
-			loaded: t1
+			collection,
+			loaded: t0
 		};
-		$[0] = collectionId;
-		$[1] = t0;
-		$[2] = t1;
-		$[3] = t2;
-	} else t2 = $[3];
-	const record = useLatestRecord(t2);
-	let t3;
+		$[0] = collection;
+		$[1] = collectionId;
+		$[2] = t0;
+		$[3] = t1;
+	} else t1 = $[3];
+	const record = useLatestRecord(t1);
+	let t2;
 	if ($[4] !== collectionId || $[5] !== record) {
-		t3 = record ? {
+		t2 = record ? {
 			collectionId,
 			record
 		} : null;
 		$[4] = collectionId;
 		$[5] = record;
-		$[6] = t3;
-	} else t3 = $[6];
-	return t3;
+		$[6] = t2;
+	} else t2 = $[6];
+	return t2;
 }
 
 //#endregion

package/dist/features/routes/pageRuntime.d.ts

@@ -1,6 +1,7 @@
+import { LocaleView } from "../../lib/locale-path.js";
+import "../../core/structuredData.js";
 import "../../core/createLayout.js";
 import "../../core/createApp.js";
-import { LocaleView } from "../../lib/locale-path.js";
 import "../../lib/studio-reads.js";
 import { Router } from "@camox/api-contract";
 import { EndedDraft } from "@camox/api-contract/drafts";
@@ -14,6 +15,10 @@ export type PageStructure = {
   layout: PageWithBlocks["layout"];
   projectName: string;
   project: PageWithBlocks["project"];
+  /** Each block's Structured Data nodes, from a full read: a structure read has none. */
+  structuredData?: PageWithBlocks["structuredData"];
+  /** The nodes of the records its blocks reference, from a full read. */
+  recordStructuredData?: PageWithBlocks["recordStructuredData"];
 };
 /**
  * Why a member can't see the draft a URL names: it doesn't exist, it's someone else's
@@ -46,5 +51,14 @@ export declare function createServerApiClient(apiUrl: string, options?: {
   draftId?: string;
   locale?: LocaleView;
 }): RouterClient<Router>;
+export type PageHead = {
+  meta?: Array<Record<string, string>>;
+  links?: Array<Record<string, string>>;
+  /** Scripts with their text, such as the page's Structured Data. */
+  scripts?: Array<{
+    type: string;
+    text: string;
+  }>;
+};
 //#endregion
 export {};

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

@@ -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/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