@goodfellow-cms/next 0.3.0 → 0.5.0

package/dist/export.js

@@ -1,7 +1,10 @@
-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 { r as NEXT_SITE_FILES } from "./site-files-BeLnLxCl.js";
+import { CALENDARS_DIR, CLOUDFLARE_REDIRECTS_PATH, EDITOR_PRELUDE, FEEDS_DIR, SITE_DESCRIPTION_PATH, absoluteUrl, allPages, calendarFiles, cloudflareRedirects, editorPolicy, feedFiles, hasLanguages, loadSiteContent, parseSiteDescription, pathLanguage, redirectFiles, rootRobotsUrl, shownContent, siteLanguages } from "@goodfellow-cms/core";
+import { BUILD_DATES_DIR, fileSystemSource, guardBuiltSite, reportedDate, selfHostFonts, 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 +12,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 +33,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 {
@@ -30,27 +55,89 @@ 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,5 +175,124 @@ 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
+* Search block looks them up. Next.js lists them in `.next/prerender-manifest.json`
+* and keeps their HTML in `.next/server/app/`. The admin panel and Next.js's own pages are left out.
+*/
+async function builtPages(root = process.cwd()) {
+	const next = join(resolve(root), ".next");
+	const manifest = JSON.parse(await readFile(join(next, "prerender-manifest.json"), "utf8"));
+	const trailingSlash = JSON.parse(await readFile(join(next, "required-server-files.json"), "utf8")).config?.trailingSlash === true;
+	const pages = [];
+	for (const route of Object.keys(manifest.routes ?? {})) {
+		if (route.startsWith("/_") || route === "/admin" || route.startsWith("/admin/")) continue;
+		const file = join(next, "server/app", `${route === "/" ? "/index" : route}.html`);
+		if (!await exists(file)) continue;
+		const url = route === "/" ? "/" : trailingSlash ? `${route}/` : route;
+		pages.push({
+			url,
+			html: await readFile(file, "utf8")
+		});
+	}
+	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
+		}] : [];
+	}));
+}
 //#endregion
-export { fixSegmentFiles, writeCalendarFiles, writeRedirectFiles };
+export { EDITOR_PAGES, NEXT_SITE_FILES, buildFileFolders, builtPages, checkPages, exportedPages, fixSegmentFiles, guardExport, writeBuildRecordFile, writeCalendarFiles, writeEditorPolicy, writeFeedFiles, writeFontFiles, writePageLanguages, writeRedirectFiles };

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, 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",
@@ -99,22 +111,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 +128,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 +151,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 +213,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 +232,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 +246,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

package/dist/server.d.ts

@@ -0,0 +1,57 @@
+import { GoodfellowConfig } from "@goodfellow-cms/core";
+import { AppApiOptions } from "@goodfellow-cms/core/node";
+import { ServerKeys } from "@goodfellow-cms/ai";
+//#region src/server.d.ts
+/** The environment variable the server's token is read from, unless `goodfellowApi({ token })` gives one. */
+export declare const GIT_TOKEN_VARIABLE = "GOODFELLOW_GIT_TOKEN";
+export interface GoodfellowApiOptions {
+  /** The site's `goodfellow.config.tsx`, whose `backend` says where the site is stored. */
+  config: GoodfellowConfig;
+  /**
+   * A token that can read and publish to the site's repository, such as a
+   * fine-grained GitHub token or a GitLab project access token. It never
+   * reaches a browser. Defaults to the `GOODFELLOW_GIT_TOKEN` environment variable.
+   */
+  token?: string | (() => Promise<string>);
+  /**
+   * Who's signed in, from the site's own sign-in (such as Better Auth's
+   * `auth.api.getSession({ headers: request.headers })`): their name, email
+   * address and role, or `null` if nobody is, or `false` if they may not edit.
+   */
+  authorize: AppApiOptions["authorize"];
+  /** Where the admin panel sends people to sign in, such as `/sign-in?next=/admin/`. */
+  signIn: string;
+  /** Where the admin panel's Sign out button goes, if the site has an address for it. */
+  signOut?: string;
+  /**
+   * Keys for AI services, such as `{ anthropic: process.env.ANTHROPIC_API_KEY }`,
+   * so the AI assistant's requests go through the server and editors need no
+   * keys of their own. Services without a key are left out.
+   */
+  ai?: ServerKeys;
+  /** Told about failures editors only hear about as "something went wrong". Defaults to `console.error`. */
+  onError?: (error: unknown) => void;
+}
+/** The route parameters of a catch-all route named `[...path]`. */
+interface RouteContext {
+  params: Promise<{
+    path?: string[];
+  }>;
+}
+/**
+ * The admin panel's API on a full-stack Next.js site, for
+ * `app/api/goodfellow/[...path]/route.ts`:
+ *
+ * ```ts
+ * export const { GET, POST } = goodfellowApi({ config, authorize, signIn: "/sign-in" });
+ * ```
+ *
+ * The admin panel (`<GoodfellowAdmin server="/api/goodfellow" />`) reads and
+ * publishes through it, and the server reaches the repository with its own
+ * token, naming each editor as the author of what they publish.
+ */
+export declare function goodfellowApi(options: GoodfellowApiOptions): {
+  GET: (request: Request, context: RouteContext) => Promise<Response>;
+  POST: (request: Request, context: RouteContext) => Promise<Response>;
+};
+//#endregion

package/dist/server.js

@@ -0,0 +1,45 @@
+import { appApi } from "@goodfellow-cms/core/node";
+import { aiServer } from "@goodfellow-cms/ai";
+//#region src/server.ts
+/** The environment variable the server's token is read from, unless `goodfellowApi({ token })` gives one. */
+const GIT_TOKEN_VARIABLE = "GOODFELLOW_GIT_TOKEN";
+/**
+* The admin panel's API on a full-stack Next.js site, for
+* `app/api/goodfellow/[...path]/route.ts`:
+*
+* ```ts
+* export const { GET, POST } = goodfellowApi({ config, authorize, signIn: "/sign-in" });
+* ```
+*
+* The admin panel (`<GoodfellowAdmin server="/api/goodfellow" />`) reads and
+* publishes through it, and the server reaches the repository with its own
+* token, naming each editor as the author of what they publish.
+*/
+function goodfellowApi(options) {
+	let api;
+	function handler() {
+		if (api) return api;
+		const { backend } = options.config;
+		if (!backend?.server) throw new Error("goodfellowApi() needs the config's `backend`, such as github({ repo }) or gitlab({ project }).");
+		const token = options.token || process.env["GOODFELLOW_GIT_TOKEN"] || (() => {
+			throw new Error(`goodfellowApi() needs a token: set GOODFELLOW_GIT_TOKEN, or pass \`token\`.`);
+		})();
+		const ai = options.ai && aiServer(options.ai);
+		api = appApi({
+			git: backend.server({ token }),
+			authorize: options.authorize,
+			signIn: options.signIn,
+			...options.signOut && { signOut: options.signOut },
+			...ai && ai.services.length > 0 && { ai },
+			...options.onError && { onError: options.onError }
+		});
+		return api;
+	}
+	const route = async (request, context) => handler()(request, ((await context.params).path ?? []).join("/"));
+	return {
+		GET: route,
+		POST: route
+	};
+}
+//#endregion
+export { GIT_TOKEN_VARIABLE, goodfellowApi };