@goodfellow-cms/next 0.4.0 → 0.6.0

package/dist/export.js

@@ -1,7 +1,11 @@
-import { allPages, calendarFiles, loadSiteContent, redirectFiles } from "@goodfellow-cms/core";
-import { fileSystemSource } from "@goodfellow-cms/core/node";
-import { dirname, join, relative, resolve } from "node:path";
+import { i as loadSiteConfig, n as buildPluginFrames, r as configHasPlugins } from "./plugins-eLJalBij.js";
+import { r as NEXT_SITE_FILES } from "./site-files-BeLnLxCl.js";
+import { CALENDARS_DIR, CLOUDFLARE_REDIRECTS_PATH, EDITOR_PRELUDE, FEEDS_DIR, SITE_DESCRIPTION_PATH, TASK_RESULT_FILE, absoluteUrl, allPages, calendarFiles, cloudflareRedirects, editorPolicy, feedFiles, hasLanguages, loadSiteContent, parseSiteDescription, pathLanguage, pluginId, redirectFiles, rootRobotsUrl, sealTaskAnswer, shownContent, siteLanguages, taskRequestProblem } from "@goodfellow-cms/core";
+import { BUILD_DATES_DIR, fileSystemSource, guardBuiltSite, reportedDate, runPluginBuildSteps, runPluginTask, selfHostFonts, taskSecretsFrom, writeBuildRecord } from "@goodfellow-cms/core/node";
 import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { checkBuiltPages } from "@goodfellow-cms/core/accessibility";
 //#region src/export.ts
 /**
 * Writes the calendar files of the site's collections of events into the
@@ -9,7 +13,20 @@ import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs
 * how many it wrote.
 */
 async function writeCalendarFiles(outDir, root = process.cwd()) {
-	const files = calendarFiles(await loadSiteContent(fileSystemSource(resolve(root))));
+	const files = calendarFiles(shownContent(await loadSiteContent(fileSystemSource(resolve(root)))));
+	for (const file of files) {
+		const target = join(outDir, file.path.slice(1));
+		await mkdir(dirname(target), { recursive: true });
+		await writeFile(target, file.content);
+	}
+	return files.length;
+}
+/**
+* Writes the feeds of the site's collections into the export, as `goodfellow
+* build` does. Returns how many it wrote: none without the site's address.
+*/
+async function writeFeedFiles(outDir, root = process.cwd()) {
+	const files = feedFiles(shownContent(await loadSiteContent(fileSystemSource(resolve(root)))));
 	for (const file of files) {
 		const target = join(outDir, file.path.slice(1));
 		await mkdir(dirname(target), { recursive: true });
@@ -17,6 +34,15 @@ async function writeCalendarFiles(outDir, root = process.cwd()) {
 	}
 	return files.length;
 }
+/**
+* The folders the calendar files and feeds go in: `calendars/` and `feeds/`,
+* and on a site in several languages, the same under each other language's
+* code, such as `es/feeds/`.
+*/
+async function buildFileFolders(root = process.cwd()) {
+	const { settings } = await loadSiteContent(fileSystemSource(resolve(root)));
+	return siteLanguages(settings).flatMap((language) => [CALENDARS_DIR, FEEDS_DIR].map((dir) => `${language.prefix.slice(1)}${language.prefix ? "/" : ""}${dir}`));
+}
 /** The `basePath` the export was built with, which Next.js records in `.next/routes-manifest.json`. */
 async function exportBasePath(root) {
 	try {
@@ -26,31 +52,123 @@ async function exportBasePath(root) {
 		return "";
 	}
 }
+/**
+* Plugins' parts that builds make: each plugin's admin frame, beside the
+* editor's frames at `admin/plugins/<id>/`, and its build steps, each in a
+* process of its own held to what the plugin declared. Into a static export
+* (`outDir`), or a full-stack site's `public/`, where `next start` serves
+* them. The config is loaded outside Next.js only when it lists plugins.
+*/
+async function writePluginFiles(outDir, root = process.cwd()) {
+	const site = resolve(root);
+	if (!await configHasPlugins(site)) return {
+		frames: [],
+		steps: []
+	};
+	const config = await loadSiteConfig(site);
+	const base = `${await exportBasePath(site)}/`;
+	const dir = resolve(site, outDir);
+	return {
+		frames: await buildPluginFrames(config.plugins, {
+			root: site,
+			outDir: dir
+		}),
+		steps: (await runPluginBuildSteps({
+			root: site,
+			outDir: dir,
+			base,
+			plugins: config.plugins ?? [],
+			onStep: (step) => console.log(`Running ${step.title}, from ${step.plugin}…`)
+		})).map((step) => `${step.plugin}: ${step.title}`)
+	};
+}
 async function exists(path) {
 	return access(path).then(() => true, () => false);
 }
 /**
+* Copies the site's Google Fonts into the export and points its pages at
+* them, as `goodfellow build` does (`selfHostFonts()`), with the export's base
+* path, and says where search engines read `robots.txt` for a site in a
+* subfolder (`rootRobotsUrl()`).
+*/
+async function writeFontFiles(outDir, root = process.cwd()) {
+	const { settings } = await loadSiteContent(fileSystemSource(resolve(root)));
+	const fonts = await selfHostFonts(outDir, settings.theme, { base: await exportBasePath(root) });
+	const robotsElsewhere = rootRobotsUrl(settings.url);
+	return {
+		...fonts && { fonts },
+		...robotsElsewhere && { robotsElsewhere },
+		...settings.url && { sitemap: absoluteUrl(settings.url, "/sitemap.xml") }
+	};
+}
+/**
+* Writes the build record (`goodfellow-build.json`) into the export, as
+* `goodfellow build` does, from the dates the processes that rendered its
+* pages wrote into `.next/` (see `withGoodfellow()`). Returns when the site
+* stops being current, if it does.
+*/
+async function writeBuildRecordFile(outDir, root = process.cwd()) {
+	const dir = resolve(root);
+	const content = await loadSiteContent(fileSystemSource(dir));
+	const date = await reportedDate(join(dir, ".next", BUILD_DATES_DIR));
+	return (await writeBuildRecord(outDir, {
+		root: dir,
+		content,
+		now: /* @__PURE__ */ new Date(),
+		...date && { date }
+	})).currentUntil;
+}
+/**
 * Writes a page at each of the site's old addresses that sends visitors on, as
-* `goodfellow build` does. Pages win: an address the export has a page at keeps
-* it. Returns how many it wrote.
+* `goodfellow build` does, and the same redirects in `_redirects` for
+* Cloudflare Pages, which sends them itself. Pages win: an address the export
+* has a page at keeps it.
 */
 async function writeRedirectFiles(outDir, root = process.cwd()) {
 	const dir = resolve(root);
-	const content = await loadSiteContent(fileSystemSource(dir));
+	const content = shownContent(await loadSiteContent(fileSystemSource(dir)));
+	const base = await exportBasePath(dir);
 	const files = redirectFiles(content, {
 		taken: allPages(content).map((page) => page.path),
-		base: await exportBasePath(dir)
+		base
 	});
-	let written = 0;
+	const written = [];
 	for (const file of files) {
 		const target = join(outDir, file.path.slice(1));
 		const page = join(outDir, `${file.path.replace(/\/index\.html$/, "")}.html`);
 		if (await exists(target) || await exists(page)) continue;
 		await mkdir(dirname(target), { recursive: true });
 		await writeFile(target, file.content);
-		written++;
+		written.push(file);
 	}
-	return written;
+	const cloudflare = cloudflareRedirects(written, base);
+	const redirects = join(outDir, CLOUDFLARE_REDIRECTS_PATH.slice(1));
+	if (cloudflare.file && !await exists(redirects)) await writeFile(redirects, cloudflare.file.content);
+	return {
+		pages: written.length,
+		cloudflareLeft: cloudflare.left
+	};
+}
+/**
+* For a site with an admin address (its config's `admin`, which the exported
+* `goodfellow-site.json` carries), puts the guard first in every page of the
+* export and adds Cloudflare Pages' header rules, as `goodfellow build` does.
+* Run it last, once every page is written. Returns how many pages it guarded,
+* or `undefined` for a site without an admin address.
+*/
+async function guardExport(outDir, root = process.cwd()) {
+	const text = await readFile(join(outDir, SITE_DESCRIPTION_PATH), "utf8").catch(() => void 0);
+	const parsed = text === void 0 ? void 0 : parseSiteDescription(text);
+	const admin = parsed?.ok ? parsed.description.admin : void 0;
+	if (!admin) return void 0;
+	const dir = resolve(root);
+	const content = await loadSiteContent(fileSystemSource(dir));
+	return guardBuiltSite(outDir, {
+		admin,
+		...parsed?.ok && parsed.description.broker && { broker: parsed.description.broker },
+		siteUrl: content.settings.url,
+		base: `${await exportBasePath(dir)}/`
+	});
 }
 /**
 * Puts a static export's prefetch files where the browser asks for them.
@@ -88,6 +206,61 @@ async function fixSegmentFiles(outDir) {
 	await visit(outDir);
 	return moved;
 }
+/** Where the editor's frames' page is in an export, and in a full-stack site's build. */
+const EDITOR_PAGES = ["admin/editor/index.html", "admin/editor.html"];
+function scriptHash(text) {
+	return `sha256-${createHash("sha256").update(text).digest("base64")}`;
+}
+/**
+* Gives the editor's frames' page (`app/admin/editor/`) its Content Security
+* Policy and first script, which removes WebRTC, as the first things in its
+* head, so they apply before anything Next.js put there. The policy runs only
+* the site's own scripts, Next.js's inline ones by their hashes, and fetches
+* nothing (`editorPolicy()`). Returns whether it found the page.
+*/
+async function writeEditorPolicy(dir) {
+	let found = false;
+	for (const name of EDITOR_PAGES) {
+		const file = join(dir, name);
+		const html = await readFile(file, "utf8").catch(() => void 0);
+		if (html === void 0 || html.includes("http-equiv=\"Content-Security-Policy\"")) continue;
+		const inline = [...html.matchAll(/<script(?![^>]*\ssrc=)[^>]*>([\s\S]*?)<\/script>/g)].map((match) => match[1] ?? "");
+		const head = `<meta http-equiv="Content-Security-Policy" content="${editorPolicy({
+			scriptHashes: [EDITOR_PRELUDE, ...inline].map(scriptHash),
+			blobScripts: true
+		})}"/><script>${EDITOR_PRELUDE}<\/script>`;
+		await writeFile(file, html.replace(/<head([^>]*)>/, (open) => `${open}${head}`));
+		found = true;
+	}
+	return found;
+}
+/** Says a page's language on its `<html>`, in place of the root layout's. */
+function withPageLanguage(html, language) {
+	return html.replace(/<html\b([^>]*?)\slang="[^"]*"/, `<html$1 lang="${language}"`);
+}
+/**
+* On a site in several languages, puts each page's language on its `<html>`,
+* which Next.js's root layout, shared by every page, says is the main one:
+* in a static export's pages (`outDir`), or, without one, in the pages a
+* full-stack site's `next build` rendered ahead. Returns how many it changed.
+*/
+async function writePageLanguages(outDir, root = process.cwd()) {
+	const dir = resolve(root);
+	const { settings } = await loadSiteContent(fileSystemSource(dir));
+	if (!hasLanguages(settings)) return 0;
+	const base = outDir ?? join(dir, ".next/server/app");
+	const files = (await readdir(base, { recursive: true })).map((file) => file.split("\\").join("/")).filter((file) => file.endsWith(".html") && !/^(admin|_next|pagefind)\//.test(file));
+	let changed = 0;
+	for (const file of files) {
+		const path = `/${file.replace(/(^|\/)index\.html$/, "").replace(/\.html$/, "")}`.replace(/\/$/, "") || "/";
+		const html = await readFile(join(base, file), "utf8");
+		const fixed = withPageLanguage(html, pathLanguage(settings, path));
+		if (fixed === html) continue;
+		await writeFile(join(base, file), fixed);
+		changed++;
+	}
+	return changed;
+}
 /**
 * The pages `next build` rendered ahead for a full-stack site (`withGoodfellow(config,
 * { server: true })`), at their addresses on the site, without its base path, as the
@@ -111,5 +284,79 @@ async function builtPages(root = process.cwd()) {
 	}
 	return pages;
 }
+/**
+* The pages a static export has, at their addresses on the site, without its
+* base path: `about.html` and `about/index.html` are `/about`. The admin panel
+* and Next.js's own files are left out.
+*/
+async function exportedPages(outDir) {
+	const files = (await readdir(outDir, { recursive: true })).map((file) => file.split("\\").join("/")).filter((file) => file.endsWith(".html") && !/^(admin|_next|pagefind)\//.test(file) && !file.startsWith("_not-found") && file !== "404/index.html");
+	const pages = [];
+	for (const file of files) {
+		const url = `/${file.replace(/(^|\/)index\.html$/, "").replace(/\.html$/, "")}`.replace(/\/$/, "") || "/";
+		pages.push({
+			url,
+			html: await readFile(join(outDir, file), "utf8")
+		});
+	}
+	return pages;
+}
+/** The content file a page comes from: its own, or, for pages blocks add such as a list's second page, its page's. */
+function contentFile(pages, path) {
+	const own = pages.find((page) => page.path === path);
+	if (own) return own.file;
+	return pages.filter((page) => page.path !== "/" && path.startsWith(`${page.path}/`)).sort((a, b) => b.path.length - a.path.length)[0]?.file;
+}
+/**
+* What automated checks find on the pages Next.js built, as `goodfellow build`
+* reports them: images without alt text, headings that skip a level, links
+* that don't say where they go, and axe-core's checks (`checkBuiltPages()`).
+* Pages that aren't the site's, such as Next.js's own, are left out.
+*/
+async function checkPages(pages, root = process.cwd()) {
+	const known = allPages(shownContent(await loadSiteContent(fileSystemSource(resolve(root)))));
+	return checkBuiltPages(pages.flatMap((page) => {
+		const path = page.url.replace(/(.)\/$/, "$1");
+		const file = contentFile(known, path);
+		return file ? [{
+			path,
+			file,
+			html: page.html
+		}] : [];
+	}));
+}
+/**
+* Runs one of a plugin's tasks for the admin panel, as `goodfellow task`
+* does for other sites, with the site's config loaded in Node, and writes its
+* answer sealed to the request's key, even when the task fails. Secrets are
+* taken out of the environment before the config loads.
+*/
+async function writeTaskResult(root, request, out = TASK_RESULT_FILE) {
+	const secrets = taskSecretsFrom(process.env);
+	const problem = taskRequestProblem(request);
+	if (problem) throw new Error(problem);
+	let answer;
+	try {
+		const plugin = ((await loadSiteConfig(resolve(root))).plugins ?? []).find((candidate) => pluginId(candidate.name) === request.plugin);
+		answer = plugin ? await runPluginTask({
+			root: resolve(root),
+			plugin,
+			task: request.task,
+			input: request.input,
+			secrets
+		}) : {
+			ok: false,
+			error: `The site has no plugin ${request.plugin}.`
+		};
+	} catch (error) {
+		answer = {
+			ok: false,
+			error: `The site couldn't run the task: ${error instanceof Error ? error.message : error}`
+		};
+	}
+	const sealed = await sealTaskAnswer(answer, request.key);
+	await writeFile(resolve(root, out), `${JSON.stringify(sealed)}\n`);
+	return sealed;
+}
 //#endregion
-export { builtPages, fixSegmentFiles, writeCalendarFiles, writeRedirectFiles };
+export { EDITOR_PAGES, NEXT_SITE_FILES, buildFileFolders, builtPages, checkPages, exportedPages, fixSegmentFiles, guardExport, writeBuildRecordFile, writeCalendarFiles, writeEditorPolicy, writeFeedFiles, writeFontFiles, writePageLanguages, writePluginFiles, writeRedirectFiles, writeTaskResult };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { GoodfellowConfig, Page, SiteContent } from "@goodfellow-cms/core";
+import { AdminSite, GoodfellowConfig, Page, SiteContent } from "@goodfellow-cms/core";
 import { ReactNode } from "react";
 import { Metadata, MetadataRoute } from "next";
 //#region src/index.d.ts
@@ -18,8 +18,10 @@ export interface PageProps {
   }>;
 }
 /**
- * Reads the site's content from disk. Cached for the length of one request, so
- * a page and its metadata read it once, and content edits show on reload in development.
+ * Reads the site's content from disk, as visitors see it now: without pages
+ * and items scheduled for later, or hidden again (`shownContent()`). Cached
+ * for the length of one request, so a page and its metadata read it once, and
+ * content edits show on reload in development.
  */
 export declare const loadSite: (root?: string) => Promise<SiteContent>;
 /** A page's title, description and link previews, as Next.js metadata. */
@@ -38,6 +40,12 @@ export declare function goodfellowPages(config: GoodfellowConfig, options?: Good
     path: string[];
   }>>;
   generateMetadata({ params }: PageProps): Promise<Metadata>;
+  /**
+   * For `app/admin/page.tsx`: what the admin panel's page knows about the
+   * site, which never loads its config. The site's blocks run in the
+   * editor's frames, at `app/admin/editor/page.tsx`.
+   */
+  admin(): AdminSite;
   /** For `app/admin/layout.tsx`: the admin panel's title, kept out of search engines, with the site's icon. */
   adminMetadata(): Promise<Metadata>;
   /**
@@ -54,7 +62,7 @@ export declare function goodfellowPages(config: GoodfellowConfig, options?: Good
    * with the header and footer, since Next.js shows it outside the `(site)` layout.
    */
   NotFound(): Promise<import("react").JSX.Element>;
-  /** For `app/sitemap.ts`: every page but "Page not found", once the site's address is set. */
+  /** For `app/sitemap.ts`: every page but "Page not found" and pages hidden from search engines, once the site's address is set. */
   sitemap(): Promise<MetadataRoute.Sitemap>;
   /**
    * For `app/admin/demo-content.json/route.ts`: in a demo (the config's `demo`), the copy of

package/dist/index.js

@@ -1,12 +1,14 @@
-import { CurrentMenuLinks, NextImage, NextLink } from "./components.js";
-import { absoluteUrl, colorSchemeMeta, colorSchemeScript, demoContent, findRedirect, fontPreloads, getPageHead, googleFontsUrl, loadSiteContent, normalizePagePath, sitePages, themeToCss, todayIn, withBase } from "@goodfellow-cms/core";
-import { fileSystemSource, fontStandIns, readMediaSizes, readStylesheet } from "@goodfellow-cms/core/node";
-import { BodyCode, HeadCode, PageBody, PageContent, PageFooter, PageHeader, applyPageEntry, createPuckConfigs, describeSite, prepareLayout, preparePage } from "@goodfellow-cms/react";
+import { ByLanguage, CurrentMenuLinks, NextImage, NextLink, PageLanguage } from "./components.js";
+import { absoluteUrl, colorSchemeMeta, colorSchemeScript, contentForPage, demoContent, feedLinks, findRedirect, fontPreloads, googleFontsUrl, hasLanguages, languageMap, loadSiteContent, normalizePagePath, pageHead, shownContent, siteLanguages, sitePages, sitemapPages, storedMediaSizes, themeToCss, todayIn, withBase } from "@goodfellow-cms/core";
+import { BUILD_DATES_ENV, fileSystemSource, fontStandIns, readMediaSizes, readStylesheet, reportDatesTo } from "@goodfellow-cms/core/node";
+import { BodyCode, HeadCode, PageBody, PageContent, PageFooter, PageHeader, adminSite, applyPageEntry, createPuckConfigs, describeSite, prepareLayout, preparePage } from "@goodfellow-cms/react";
 import { notFound, redirect } from "next/navigation";
 import { cache } from "react";
 import { preload } from "react-dom";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/index.tsx
+const buildDates = process.env[BUILD_DATES_ENV];
+if (buildDates) reportDatesTo(buildDates);
 /** Next.js's own link and image components, for blocks' `<SiteLink>` and `<SiteImage>`. */
 const components = {
 	Link: NextLink,
@@ -17,10 +19,12 @@ function configuredBasePath() {
 	return process.env.GOODFELLOW_BASE_PATH ?? "";
 }
 /**
-* Reads the site's content from disk. Cached for the length of one request, so
-* a page and its metadata read it once, and content edits show on reload in development.
+* Reads the site's content from disk, as visitors see it now: without pages
+* and items scheduled for later, or hidden again (`shownContent()`). Cached
+* for the length of one request, so a page and its metadata read it once, and
+* content edits show on reload in development.
 */
-const loadSite = cache((root = process.cwd()) => loadSiteContent(fileSystemSource(root)));
+const loadSite = cache(async (root = process.cwd()) => shownContent(await loadSiteContent(fileSystemSource(root))));
 function pathOf(segments) {
 	try {
 		return normalizePagePath(`/${(segments ?? []).map((segment) => decodeURIComponent(segment)).join("/")}`);
@@ -41,14 +45,22 @@ function toAbsolute(siteUrl, url) {
 }
 /** A page's title, description and link previews, as Next.js metadata. */
 function pageMetadata(content, page, basePath = configuredBasePath()) {
-	const head = getPageHead(content.settings, page);
+	const head = pageHead(content, page);
 	const socialImage = toAbsolute(content.settings.url, head.socialImage);
+	const feeds = feedLinks(contentForPage(content, page));
 	return {
 		...content.settings.url && { metadataBase: new URL(content.settings.url) },
 		title: { absolute: head.title },
 		...head.description && { description: head.description },
 		...head.noIndex && { robots: { index: false } },
-		...head.canonicalUrl && { alternates: { canonical: head.canonicalUrl } },
+		...(head.canonicalUrl || feeds.length > 0) && { alternates: {
+			...head.canonicalUrl && { canonical: head.canonicalUrl },
+			...head.alternates && { languages: Object.fromEntries(head.alternates.map(({ language, href }) => [language, href])) },
+			...feeds.length > 0 && { types: { "application/rss+xml": feeds.map((feed) => ({
+				url: withBase(feed.href, basePath),
+				title: feed.title
+			})) } }
+		} },
 		...head.favicon && { icons: { icon: withBase(head.favicon, basePath) } },
 		openGraph: {
 			type: "website",
@@ -75,7 +87,10 @@ function goodfellowPages(config, options = {}) {
 	const renderOptions = async () => ({
 		base: basePath(),
 		components,
-		media: await readMediaSizes(root)
+		media: {
+			...await readMediaSizes(root),
+			...storedMediaSizes((await site()).mediaStorage)
+		}
 	});
 	/** The site's theme and fonts, which React moves into the document's head. themeToCss escapes its output. */
 	async function Theme({ content }) {
@@ -99,22 +114,11 @@ function goodfellowPages(config, options = {}) {
 				precedence: "default",
 				children: themeToCss(content.settings.theme, standIns)
 			}),
-			fontsUrl && /* @__PURE__ */ jsxs(Fragment, { children: [
-				/* @__PURE__ */ jsx("link", {
-					rel: "preconnect",
-					href: "https://fonts.googleapis.com"
-				}),
-				/* @__PURE__ */ jsx("link", {
-					rel: "preconnect",
-					href: "https://fonts.gstatic.com",
-					crossOrigin: ""
-				}),
-				/* @__PURE__ */ jsx("link", {
-					rel: "stylesheet",
-					href: fontsUrl,
-					precedence: "default"
-				})
-			] })
+			fontsUrl && /* @__PURE__ */ jsx("link", {
+				rel: "stylesheet",
+				href: fontsUrl,
+				precedence: "default"
+			})
 		] });
 	}
 	return {
@@ -127,6 +131,14 @@ function goodfellowPages(config, options = {}) {
 			const page = findPage(content, config.blocks, pathOf((await params).path));
 			return page ? pageMetadata(content, applyPageEntry(configs, content, page), basePath()) : {};
 		},
+		/**
+		* For `app/admin/page.tsx`: what the admin panel's page knows about the
+		* site, which never loads its config. The site's blocks run in the
+		* editor's frames, at `app/admin/editor/page.tsx`.
+		*/
+		admin() {
+			return adminSite(config);
+		},
 		/** For `app/admin/layout.tsx`: the admin panel's title, kept out of search engines, with the site's icon. */
 		async adminMetadata() {
 			const favicon = await site().then((content) => content.settings.favicon, () => void 0);
@@ -142,21 +154,53 @@ function goodfellowPages(config, options = {}) {
 		*/
 		async Layout({ children }) {
 			const content = await site();
-			const layout = await prepareLayout(configs, content, await renderOptions());
-			return /* @__PURE__ */ jsxs(Fragment, { children: [
-				/* @__PURE__ */ jsx(Theme, { content }),
-				/* @__PURE__ */ jsx(HeadCode, { code: content.code?.head }),
-				/* @__PURE__ */ jsx(PageHeader, {
+			const options = await renderOptions();
+			let header;
+			let footer;
+			if (hasLanguages(content.settings)) {
+				const languageMap$1 = languageMap(content, exportedPages(content, config.blocks));
+				const layouts = await Promise.all(siteLanguages(content.settings).map(async (language) => ({
+					prefix: language.prefix,
+					layout: await prepareLayout(configs, content, {
+						...options,
+						languageMap: languageMap$1
+					}, language.code)
+				})));
+				header = /* @__PURE__ */ jsx(ByLanguage, { variants: layouts.map(({ prefix, layout }) => ({
+					prefix,
+					children: /* @__PURE__ */ jsx(PageHeader, {
+						site: layout.site,
+						layoutConfig: layout.layoutConfig,
+						data: layout.header
+					})
+				})) });
+				footer = /* @__PURE__ */ jsx(ByLanguage, { variants: layouts.map(({ prefix, layout }) => ({
+					prefix,
+					children: /* @__PURE__ */ jsx(PageFooter, {
+						site: layout.site,
+						layoutConfig: layout.layoutConfig,
+						data: layout.footer
+					})
+				})) });
+			} else {
+				const layout = await prepareLayout(configs, content, options);
+				header = /* @__PURE__ */ jsx(PageHeader, {
 					site: layout.site,
 					layoutConfig: layout.layoutConfig,
 					data: layout.header
-				}),
-				children,
-				/* @__PURE__ */ jsx(PageFooter, {
+				});
+				footer = /* @__PURE__ */ jsx(PageFooter, {
 					site: layout.site,
 					layoutConfig: layout.layoutConfig,
 					data: layout.footer
-				}),
+				});
+			}
+			return /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Theme, { content }),
+				/* @__PURE__ */ jsx(HeadCode, { code: content.code?.head }),
+				header,
+				children,
+				footer,
 				/* @__PURE__ */ jsx(CurrentMenuLinks, { basePath: basePath() }),
 				/* @__PURE__ */ jsx(BodyCode, { code: content.code?.body })
 			] });
@@ -172,11 +216,14 @@ function goodfellowPages(config, options = {}) {
 				notFound();
 			}
 			const prepared = await preparePage(configs, content, page, await renderOptions());
-			return /* @__PURE__ */ jsx(PageContent, {
+			const pageContent = /* @__PURE__ */ jsx(PageContent, {
 				site: prepared.site,
 				pageConfig: prepared.pageConfig,
-				page: prepared.data
+				page: prepared.data,
+				...prepared.structuredData && { structuredData: prepared.structuredData }
 			});
+			if (!hasLanguages(content.settings)) return pageContent;
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(PageLanguage, { language: prepared.site.settings.language }), pageContent] });
 		},
 		/**
 		* The site's "Page not found" page (`content/pages/404.json`), for `app/not-found.tsx`,
@@ -188,7 +235,7 @@ function goodfellowPages(config, options = {}) {
 			if (!page) return /* @__PURE__ */ jsx("h1", { children: "Page not found" });
 			const prepared = await preparePage(configs, content, page, await renderOptions());
 			return /* @__PURE__ */ jsxs(Fragment, { children: [
-				/* @__PURE__ */ jsx("title", { children: getPageHead(content.settings, page).title }),
+				/* @__PURE__ */ jsx("title", { children: pageHead(content, page).title }),
 				/* @__PURE__ */ jsx(Theme, { content }),
 				/* @__PURE__ */ jsx(HeadCode, { code: content.code?.head }),
 				/* @__PURE__ */ jsx(PageBody, {
@@ -202,12 +249,13 @@ function goodfellowPages(config, options = {}) {
 				/* @__PURE__ */ jsx(BodyCode, { code: content.code?.body })
 			] });
 		},
-		/** For `app/sitemap.ts`: every page but "Page not found", once the site's address is set. */
+		/** For `app/sitemap.ts`: every page but "Page not found" and pages hidden from search engines, once the site's address is set. */
 		async sitemap() {
 			const content = await site();
-			const url = content.settings.url;
-			if (!url) return [];
-			return exportedPages(content, config.blocks).filter((page) => page.path !== "/404").map((page) => ({ url: absoluteUrl(url, page.path) }));
+			return sitemapPages(content, exportedPages(content, config.blocks)).map(({ url, alternates }) => ({
+				url,
+				...alternates && { alternates: { languages: alternates } }
+			}));
 		},
 		/**
 		* For `app/admin/demo-content.json/route.ts`: in a demo (the config's `demo`), the copy of