@goodfellow-cms/next 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Goodfellow contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,13 @@
-# Temporary Holding Version
+# @goodfellow-cms/next
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Goodfellow pages and the admin panel in a Next.js App Router site, exported as static files. Links use `next/link` and images `next/image`.
+
+Start from the Next.js starter: `npm create goodfellow@latest my-site -- --template next`.
+
+[Goodfellow](https://github.com/goodfellow-cms/goodfellow-cms) is a website builder for people who aren't developers, with no server or database: pages are files in your own GitHub or GitLab repository, edited in a visual editor built on [Puck](https://puckeditor.com). To start a new site, run `npm create goodfellow@latest my-site`. See the [documentation](https://goodfellow-cms.github.io/goodfellow-cms/) for everything else.
+
+More in the docs: [Next.js](https://goodfellow-cms.github.io/goodfellow-cms/docs/nextjs).
+
+## License
+
+MIT

package/bin/goodfellow-next.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// After `next build`: `goodfellow-next finish out` fixes the export's prefetch files on Windows,
+// writes the calendar files of collections of events and the pages at redirects' old addresses, and the search index for sites with a search block. `index` only writes the index.
+// `goodfellow-next update` updates Goodfellow, as `goodfellow update` does for other sites.
+import { parseArgs } from "node:util";
+import { formatUpdateResult } from "@goodfellow-cms/core";
+import { update } from "@goodfellow-cms/core/node";
+import { writeSearchIndex } from "@goodfellow-cms/core/search-index";
+import { fixSegmentFiles, writeCalendarFiles, writeRedirectFiles } from "@goodfellow-cms/next/export";
+
+const [command, dir = "out"] = process.argv.slice(2);
+if (command === "update") {
+  const { values } = parseArgs({
+    args: process.argv.slice(3),
+    options: { to: { type: "string" }, publish: { type: "boolean" } },
+  });
+  const result = await update({ to: values.to, publish: values.publish });
+  // For the admin panel, which reads it in the host's log.
+  console.log(formatUpdateResult(result));
+  process.exit(result.state === "failed" ? 1 : 0);
+}
+if (command !== "finish" && command !== "index") {
+  console.error(
+    [
+      "Usage: goodfellow-next finish [folder]",
+      "       goodfellow-next index [folder]",
+      "       goodfellow-next update [--to fixes|automatic|latest|<release>] [--publish]",
+      "",
+      "finish  Gets the exported site in folder (default: out) ready to publish: puts the files",
+      "        Next.js uses to load pages ahead where browsers look for them, writes calendar files",
+      "        for collections of events and pages that send visitors on from old addresses, and",
+      "        indexes it for search.",
+      "index   Only indexes the exported site for its search block.",
+      "update  Updates Goodfellow, and blocks from its registry, if the site still builds.",
+    ].join("\n"),
+  );
+  process.exit(1);
+}
+if (command === "finish") {
+  const moved = await fixSegmentFiles(dir);
+  if (moved > 0) console.log(`Moved ${moved} of Next.js's prefetch files to where browsers look for them`);
+  const calendars = await writeCalendarFiles(dir);
+  if (calendars > 0) console.log(`Wrote ${calendars} calendar files`);
+  const redirects = await writeRedirectFiles(dir);
+  if (redirects > 0) console.log(`Wrote ${redirects} redirects`);
+}
+const indexed = await writeSearchIndex(dir);
+console.log(
+  indexed === undefined
+    ? `No page in ${dir} has a search block, so there's nothing to index`
+    : `Indexed ${indexed} pages for search`,
+);

package/dist/admin.d.ts

@@ -0,0 +1,21 @@
+import { GoodfellowConfig } from "@goodfellow-cms/core";
+import { Strings } from "@goodfellow-cms/admin";
+import "@puckeditor/core/puck.css";
+import "@goodfellow-cms/admin/styles.css";
+//#region src/admin.d.ts
+export interface GoodfellowAdminProps {
+  /** The site's `goodfellow.config.tsx`. */
+  config: GoodfellowConfig;
+  /** The live site's address, for "View" links. Defaults to the site's base path, such as `/` or `/my-site/`. */
+  siteUrl?: string;
+  /** Replaces any of the admin panel's text, for rewording or translation. */
+  strings?: Partial<Strings>;
+}
+/**
+ * The admin panel, for a Next.js site's `app/admin/page.tsx`, which must be a
+ * Client Component (`"use client"`) that imports the site's config.
+ * In `next dev` it saves to the files on disk; on the live site, editors sign
+ * in to the config's git backend.
+ */
+export declare function GoodfellowAdmin({ config, siteUrl, strings }: GoodfellowAdminProps): import("react").JSX.Element | null;
+//#endregion

package/dist/admin.js

@@ -0,0 +1,77 @@
+import { useEffect, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { Admin } from "@goodfellow-cms/admin";
+import "@puckeditor/core/puck.css";
+import "@goodfellow-cms/admin/styles.css";
+//#region src/generated/theme-css.ts
+var theme_css_default = "/*\n * Maps the site theme (CSS variables written from content/site.json) onto\n * Tailwind, so classes like bg-primary, text-muted-foreground, font-heading and\n * rounded-lg follow the theme. Import after \"tailwindcss\".\n */\n@theme inline {\n  --color-background: var(--background);\n  --color-foreground: var(--foreground);\n  --color-primary: var(--primary);\n  --color-primary-foreground: var(--primary-foreground);\n  --color-secondary: var(--secondary);\n  --color-secondary-foreground: var(--secondary-foreground);\n  --color-muted: var(--muted);\n  --color-muted-foreground: var(--muted-foreground);\n  --color-accent: var(--accent);\n  --color-accent-foreground: var(--accent-foreground);\n  --color-border: var(--border);\n  /* The rest of shadcn/ui's colors, for blocks built with it, follow the ones above unless custom CSS sets them. */\n  --color-card: var(--card, var(--background));\n  --color-card-foreground: var(--card-foreground, var(--foreground));\n  --color-popover: var(--popover, var(--background));\n  --color-popover-foreground: var(--popover-foreground, var(--foreground));\n  --color-destructive: var(--destructive, #dc2626);\n  --color-input: var(--input, var(--border));\n  --color-ring: var(--ring, var(--primary));\n  --font-sans: var(--gf-font-body);\n  --font-heading: var(--gf-font-heading);\n  --radius-sm: calc(var(--radius) - 4px);\n  --radius-md: calc(var(--radius) - 2px);\n  --radius-lg: var(--radius);\n  --radius-xl: calc(var(--radius) + 4px);\n}\n\n@layer base {\n  *,\n  ::before,\n  ::after {\n    border-color: var(--color-border);\n  }\n\n  body {\n    background-color: var(--color-background);\n    color: var(--color-foreground);\n    /* Keeps the footer at the bottom of short pages. */\n    display: flex;\n    flex-direction: column;\n    min-height: 100dvh;\n  }\n\n  .gf-main {\n    flex: 1;\n  }\n\n  h1,\n  h2,\n  h3,\n  h4,\n  h5,\n  h6 {\n    font-family: var(--font-heading);\n  }\n}\n";
+//#endregion
+//#region src/admin.tsx
+/**
+* The site's own stylesheets, as Next.js serves them, for previews to look like
+* the site. Next.js names them as it builds them, so they're read from the
+* site's home page rather than known in advance.
+*/
+async function siteStylesheets(siteUrl) {
+	try {
+		const response = await fetch(siteUrl, { headers: { accept: "text/html" } });
+		const html = await response.text();
+		const doc = new DOMParser().parseFromString(html, "text/html");
+		return Array.from(doc.querySelectorAll("link[rel=\"stylesheet\"][href]")).map((link) => new URL(link.getAttribute("href") ?? "", response.url).href).filter((href) => !href.startsWith("https://fonts.googleapis.com/"));
+	} catch {
+		return [];
+	}
+}
+/** Set by `withGoodfellow()` from Next.js's `basePath`, such as `/my-site`, or empty. */
+const BASE_PATH = process.env.GOODFELLOW_BASE_PATH ?? "";
+async function setUp(siteUrl) {
+	const [stylesheets, tailwindBrowser, store] = await Promise.all([
+		siteStylesheets(siteUrl),
+		import("./tailwind-browser-Ds-ZH7sO.js").then((module) => module.default),
+		process.env.NODE_ENV === "development" ? import("@goodfellow-cms/admin/dev").then((module) => module.localStore(`${BASE_PATH}/__goodfellow/api`)) : void 0
+	]);
+	return {
+		stylesheets,
+		tailwindBrowserUrl: URL.createObjectURL(new Blob([tailwindBrowser], { type: "text/javascript" })),
+		...store && { store }
+	};
+}
+/**
+* The admin panel, for a Next.js site's `app/admin/page.tsx`, which must be a
+* Client Component (`"use client"`) that imports the site's config.
+* In `next dev` it saves to the files on disk; on the live site, editors sign
+* in to the config's git backend.
+*/
+function GoodfellowAdmin({ config, siteUrl = `${BASE_PATH}/`, strings }) {
+	const [setup, setSetup] = useState(null);
+	useEffect(() => {
+		let current = true;
+		let url;
+		setUp(siteUrl).then((result) => {
+			url = result.tailwindBrowserUrl;
+			if (current) setSetup(result);
+			else URL.revokeObjectURL(url);
+		});
+		return () => {
+			current = false;
+			if (url) URL.revokeObjectURL(url);
+		};
+	}, [siteUrl]);
+	if (!setup) return null;
+	return /* @__PURE__ */ jsx(Admin, {
+		config,
+		...setup.store && {
+			store: setup.store,
+			registry: `${BASE_PATH}/__goodfellow/api/registry/{name}.json`
+		},
+		preview: {
+			stylesheets: setup.stylesheets,
+			themeCss: theme_css_default,
+			tailwindBrowserUrl: setup.tailwindBrowserUrl
+		},
+		siteUrl,
+		...strings && { strings }
+	});
+}
+//#endregion
+export { GoodfellowAdmin };

package/dist/components.d.ts

@@ -0,0 +1,17 @@
+import { ImageSize } from "@goodfellow-cms/core";
+import { SiteImageProps, SiteLinkProps } from "@goodfellow-cms/react";
+//#region src/components.d.ts
+/** A link to one of the site's pages, with Next.js's client-side navigation. Next.js adds the base path. */
+export declare function NextLink(props: SiteLinkProps): import("react").JSX.Element;
+/** One of the site's images, through Next.js's image component. Its address already has the base path. */
+export declare function NextImage({ src, alt, width, height, loading, ...props }: SiteImageProps & ImageSize): import("react").JSX.Element;
+/**
+ * Marks the current page's links in the site's menus (`data-current`, and
+ * `aria-current` for the page itself), as Menu does when it knows the page. The
+ * layout's header and footer are shared by every page, so they can't know it;
+ * this runs in the browser after every navigation instead.
+ */
+export declare function CurrentMenuLinks({ basePath }: {
+  basePath?: string;
+}): null;
+//#endregion

package/dist/components.js

@@ -0,0 +1,51 @@
+"use client";
+import { usePathname } from "next/navigation";
+import { useEffect } from "react";
+import Image from "next/image";
+import Link from "next/link";
+import { jsx } from "react/jsx-runtime";
+//#region src/components.tsx
+/** A link to one of the site's pages, with Next.js's client-side navigation. Next.js adds the base path. */
+function NextLink(props) {
+	return /* @__PURE__ */ jsx(Link, { ...props });
+}
+/** One of the site's images, through Next.js's image component. Its address already has the base path. */
+function NextImage({ src, alt, width, height, loading = "eager", ...props }) {
+	return /* @__PURE__ */ jsx(Image, {
+		...props,
+		src,
+		alt,
+		width,
+		height,
+		loading
+	});
+}
+/** A path without its trailing slash, but for the site's home page: `/news/` → `/news`. */
+function trimSlash(path) {
+	return path.length > 1 ? path.replace(/\/+$/, "") : path;
+}
+/**
+* Marks the current page's links in the site's menus (`data-current`, and
+* `aria-current` for the page itself), as Menu does when it knows the page. The
+* layout's header and footer are shared by every page, so they can't know it;
+* this runs in the browser after every navigation instead.
+*/
+function CurrentMenuLinks({ basePath = "" }) {
+	const pathname = usePathname();
+	useEffect(() => {
+		const here = trimSlash(location.pathname);
+		const home = trimSlash(`${basePath}/`);
+		for (const link of document.querySelectorAll("[data-gf-menu] a[href]")) {
+			const url = new URL(link.href, location.href);
+			const target = trimSlash(url.pathname);
+			const local = url.origin === location.origin;
+			const exact = local && target === here;
+			link.toggleAttribute("data-current", exact || local && target !== home && here.startsWith(`${target}/`));
+			if (exact) link.setAttribute("aria-current", "page");
+			else link.removeAttribute("aria-current");
+		}
+	}, [pathname, basePath]);
+	return null;
+}
+//#endregion
+export { CurrentMenuLinks, NextImage, NextLink };

package/dist/config.d.ts

@@ -0,0 +1,26 @@
+import { NextConfig } from "next";
+//#region src/config.d.ts
+export interface GoodfellowNextOptions {
+  /** The site's folder, holding `content/` and `public/media/`. Defaults to the folder Next.js runs in. */
+  root?: string;
+}
+/**
+ * Sets up Next.js for a Goodfellow site, in `next.config.ts`:
+ * `export default withGoodfellow({ ... })`.
+ *
+ * - Builds the site as static files (`output: "export"`), so any static host can serve it,
+ *   with each page in its own folder (`trailingSlash: true`), as `goodfellow build` does.
+ *   `next dev` serves pages as usual, so an unknown address shows the "not found" page.
+ * - Serves the site from `basePath`, or else the `GOODFELLOW_BASE` environment
+ *   variable, as `goodfellow build` does (GitHub Pages serves most sites from `/repository-name/`).
+ * - Serves images as they are unless the site sets an image loader, since static files can't be optimized on request.
+ * - Adds the site's redirects (Site Settings → Redirects) ahead of the site's own, for hosts that
+ *   send them, such as Vercel. Others get the pages `goodfellow-next finish` writes at old addresses.
+ * - In `next dev`, runs the admin panel's local backend, so publishing saves to
+ *   the files on disk. It's never part of a build.
+ * - In `next dev`, turns off React's debug channel (`experimental.reactDebugChannel`)
+ *   unless the site sets it: with the header and footer in a layout, it made the
+ *   browser's memory grow to gigabytes on every page, until pages crashed.
+ */
+export declare function withGoodfellow(nextConfig?: NextConfig, options?: GoodfellowNextOptions): (phase: string) => Promise<NextConfig>;
+//#endregion

package/dist/config.js

@@ -0,0 +1,139 @@
+import { CALENDARS_DIR, allPages, loadSiteContent, normalizeBase, redirectFrom, redirectProblems } from "@goodfellow-cms/core";
+import { DEV_API_PREFIX, fileSystemSource, handleDevApi, isLocalOrigin, localFileStore, localRegistryDir } from "@goodfellow-cms/core/node";
+import { createServer } from "node:http";
+import { resolve } from "node:path";
+//#region src/config.ts
+/** `PHASE_DEVELOPMENT_SERVER` from `next/constants`, which Node can't import by that name. */
+const PHASE_DEVELOPMENT_SERVER = "phase-development-server";
+const SERVER_KEY = Symbol.for("goodfellow.next.devApi");
+/**
+* The admin panel's local backend, which reads and writes the site's files on
+* disk. It runs beside `next dev`, on this computer only, and Next.js passes
+* the admin panel's requests to it. Started once however often Next.js loads its config.
+*/
+function startDevApi(root) {
+	const globals = globalThis;
+	globals[SERVER_KEY] ??= new Promise((resolvePort, reject) => {
+		const store = localFileStore(root);
+		const registryDir = localRegistryDir(root);
+		const server = createServer(async (req, res) => {
+			if (!await handleDevApi(store, req, res, {
+				trustOrigin: isLocalOrigin,
+				registryDir
+			})) res.writeHead(404).end();
+		});
+		server.on("error", reject);
+		server.listen(0, "127.0.0.1", () => resolvePort(server.address().port));
+		server.unref();
+	});
+	return globals[SERVER_KEY];
+}
+/** Adds a rewrite ahead of the site's own, whichever form the site's rewrites take. */
+function withRewrite(rewrites, rewrite) {
+	if (!rewrites) return [rewrite];
+	if (Array.isArray(rewrites)) return [rewrite, ...rewrites];
+	return {
+		...rewrites,
+		beforeFiles: [rewrite, ...rewrites.beforeFiles ?? []]
+	};
+}
+/** Next.js's form of a base path: `/my-site`, or empty for the root. */
+function nextBasePath(base) {
+	return normalizeBase(base).slice(0, -1);
+}
+/**
+* Next.js only optimizes images with a server or a custom loader. Without a
+* loader, `next/image` serves images as they are, still with their sizes set.
+*/
+function imageSettings(images) {
+	if (images?.loader && images.loader !== "default") return images;
+	if (images?.loaderFile) return images;
+	return {
+		unoptimized: true,
+		...images
+	};
+}
+/** An address as Next.js matches a redirect's source, with the characters its patterns use escaped. */
+function redirectSource(path) {
+	return encodeURI(path).replace(/[()[\]{}+*?:!]/g, "\\$&");
+}
+/**
+* The site's redirects (`content/redirects.json`) for hosts that send them
+* themselves, such as Vercel, which reads them from the build. Redirects from
+* an address a page or a collection's item has are left out, since pages win,
+* as they do over the pages `goodfellow-next finish` writes at old addresses.
+* Content with a problem gives none, and the build reports the problem.
+*/
+async function siteRedirects(root) {
+	const content = await loadSiteContent(fileSystemSource(root)).catch(() => void 0);
+	if (!content?.redirects) return [];
+	const taken = new Set(allPages(content).map((page) => page.path));
+	const problems = redirectProblems(content.redirects);
+	return content.redirects.flatMap((redirect, index) => {
+		const from = redirectFrom(redirect.from);
+		if (problems[index] || !from.ok || taken.has(from.path)) return [];
+		return [{
+			source: redirectSource(from.path),
+			destination: redirect.to.trim(),
+			permanent: true
+		}];
+	});
+}
+/**
+* Sets up Next.js for a Goodfellow site, in `next.config.ts`:
+* `export default withGoodfellow({ ... })`.
+*
+* - Builds the site as static files (`output: "export"`), so any static host can serve it,
+*   with each page in its own folder (`trailingSlash: true`), as `goodfellow build` does.
+*   `next dev` serves pages as usual, so an unknown address shows the "not found" page.
+* - Serves the site from `basePath`, or else the `GOODFELLOW_BASE` environment
+*   variable, as `goodfellow build` does (GitHub Pages serves most sites from `/repository-name/`).
+* - Serves images as they are unless the site sets an image loader, since static files can't be optimized on request.
+* - Adds the site's redirects (Site Settings → Redirects) ahead of the site's own, for hosts that
+*   send them, such as Vercel. Others get the pages `goodfellow-next finish` writes at old addresses.
+* - In `next dev`, runs the admin panel's local backend, so publishing saves to
+*   the files on disk. It's never part of a build.
+* - In `next dev`, turns off React's debug channel (`experimental.reactDebugChannel`)
+*   unless the site sets it: with the header and footer in a layout, it made the
+*   browser's memory grow to gigabytes on every page, until pages crashed.
+*/
+function withGoodfellow(nextConfig = {}, options = {}) {
+	const root = resolve(options.root ?? process.cwd());
+	const basePath = nextBasePath(nextConfig.basePath ?? process.env.GOODFELLOW_BASE);
+	return async (phase) => {
+		const config = {
+			trailingSlash: true,
+			...nextConfig,
+			...basePath && { basePath },
+			images: imageSettings(nextConfig.images),
+			env: {
+				...nextConfig.env,
+				GOODFELLOW_BASE_PATH: basePath
+			}
+		};
+		if (phase !== PHASE_DEVELOPMENT_SERVER) return {
+			output: "export",
+			...config,
+			redirects: async () => [...await siteRedirects(root), ...await nextConfig.redirects?.() ?? []]
+		};
+		const port = await startDevApi(root);
+		const rewrite = {
+			source: `${DEV_API_PREFIX}/:path*`,
+			destination: `http://127.0.0.1:${port}${DEV_API_PREFIX}/:path*`
+		};
+		const calendars = {
+			source: `/${CALENDARS_DIR}/:file(.+\\.ics)`,
+			destination: `http://127.0.0.1:${port}${DEV_API_PREFIX}/${CALENDARS_DIR}/:file`
+		};
+		return {
+			...config,
+			experimental: {
+				reactDebugChannel: false,
+				...nextConfig.experimental
+			},
+			rewrites: async () => withRewrite(withRewrite(await nextConfig.rewrites?.(), calendars), rewrite)
+		};
+	};
+}
+//#endregion
+export { withGoodfellow };

package/dist/export.d.ts

@@ -0,0 +1,22 @@
+//#region src/export.d.ts
+/**
+ * Writes the calendar files of the site's collections of events into the
+ * export, as `goodfellow build` does: Next.js has no route for them. Returns
+ * how many it wrote.
+ */
+export declare function writeCalendarFiles(outDir: string, root?: string): Promise<number>;
+/**
+ * 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.
+ */
+export declare function writeRedirectFiles(outDir: string, root?: string): Promise<number>;
+/**
+ * Puts a static export's prefetch files where the browser asks for them.
+ * Next.js names each after its segment path with `/` turned into `.`
+ * (`__next.$oc$path.__PAGE__.txt`), but on Windows the path has `\` instead, so
+ * the export writes folders (`__next.$oc$path/__PAGE__.txt`), and every
+ * prefetch is "not found". Returns how many files it moved; none elsewhere.
+ */
+export declare function fixSegmentFiles(outDir: string): Promise<number>;
+//#endregion

package/dist/export.js

@@ -0,0 +1,92 @@
+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 { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+//#region src/export.ts
+/**
+* Writes the calendar files of the site's collections of events into the
+* export, as `goodfellow build` does: Next.js has no route for them. Returns
+* how many it wrote.
+*/
+async function writeCalendarFiles(outDir, root = process.cwd()) {
+	const files = calendarFiles(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;
+}
+/** The `basePath` the export was built with, which Next.js records in `.next/routes-manifest.json`. */
+async function exportBasePath(root) {
+	try {
+		const manifest = JSON.parse(await readFile(join(root, ".next/routes-manifest.json"), "utf8"));
+		return typeof manifest.basePath === "string" ? manifest.basePath : "";
+	} catch {
+		return "";
+	}
+}
+async function exists(path) {
+	return access(path).then(() => true, () => false);
+}
+/**
+* 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.
+*/
+async function writeRedirectFiles(outDir, root = process.cwd()) {
+	const dir = resolve(root);
+	const content = await loadSiteContent(fileSystemSource(dir));
+	const files = redirectFiles(content, {
+		taken: allPages(content).map((page) => page.path),
+		base: await exportBasePath(dir)
+	});
+	let written = 0;
+	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++;
+	}
+	return written;
+}
+/**
+* Puts a static export's prefetch files where the browser asks for them.
+* Next.js names each after its segment path with `/` turned into `.`
+* (`__next.$oc$path.__PAGE__.txt`), but on Windows the path has `\` instead, so
+* the export writes folders (`__next.$oc$path/__PAGE__.txt`), and every
+* prefetch is "not found". Returns how many files it moved; none elsewhere.
+*/
+async function fixSegmentFiles(outDir) {
+	let moved = 0;
+	async function visit(dir) {
+		for (const entry of await readdir(dir, { withFileTypes: true })) {
+			if (!entry.isDirectory() || entry.name === "_next") continue;
+			const path = join(dir, entry.name);
+			if (!entry.name.startsWith("__next.")) {
+				await visit(path);
+				continue;
+			}
+			for (const file of await readdir(path, {
+				recursive: true,
+				withFileTypes: true
+			})) {
+				if (!file.isFile()) continue;
+				const source = join(file.parentPath, file.name);
+				const parts = relative(path, source).split(/[\\/]/);
+				await rename(source, join(dir, [entry.name, ...parts].join(".")));
+				moved++;
+			}
+			await rm(path, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	await visit(outDir);
+	return moved;
+}
+//#endregion
+export { fixSegmentFiles, writeCalendarFiles, writeRedirectFiles };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { GoodfellowConfig, Page, SiteContent } from "@goodfellow-cms/core";
+import { ReactNode } from "react";
+import { Metadata, MetadataRoute } from "next";
+//#region src/index.d.ts
+export interface GoodfellowPagesOptions {
+  /** The site's folder, holding `content/`. Defaults to the folder Next.js runs in. */
+  root?: string;
+  /**
+   * The path the site is served from, such as `/my-site`. Defaults to the
+   * `basePath` that `withGoodfellow()` gave Next.js.
+   */
+  basePath?: string;
+}
+/** The route parameters of an optional catch-all route named `[[...path]]`. */
+export interface PageProps {
+  params: Promise<{
+    path?: string[];
+  }>;
+}
+/**
+ * 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.
+ */
+export declare const loadSite: (root?: string) => Promise<SiteContent>;
+/** A page's title, description and link previews, as Next.js metadata. */
+export declare function pageMetadata(content: SiteContent, page: Page, basePath?: string): Metadata;
+/**
+ * Renders the site's pages in a Next.js App Router site, as Server Components.
+ * Blocks' links to the site's pages use `next/link`, and their images
+ * `next/image`, through `<SiteLink>` and `<SiteImage>`; Client Components in
+ * blocks run in the browser. Use the results in `app/(site)/layout.tsx`,
+ * which shows the header and footer once for every page, in
+ * `app/(site)/[[...path]]/page.tsx`, and in `app/not-found.tsx`.
+ */
+export declare function goodfellowPages(config: GoodfellowConfig, options?: GoodfellowPagesOptions): {
+  /** Every page's address, so Next.js builds them all. Any other address is "not found". */
+  generateStaticParams(): Promise<Array<{
+    path: string[];
+  }>>;
+  generateMetadata({ params }: PageProps): Promise<Metadata>;
+  /** For `app/admin/layout.tsx`: the admin panel's title, kept out of search engines, with the site's icon. */
+  adminMetadata(): Promise<Metadata>;
+  /**
+   * For `app/(site)/layout.tsx`: the site's header and footer around every page, kept as
+   * they are when moving between pages. Menus mark the current page in the browser.
+   */
+  Layout({ children }: {
+    children: ReactNode;
+  }): Promise<import("react").JSX.Element>;
+  /** The page at the route's address, inside `Layout`'s header and footer. */
+  Page({ params }: PageProps): Promise<import("react").JSX.Element>;
+  /**
+   * The site's "Page not found" page (`content/pages/404.json`), for `app/not-found.tsx`,
+   * 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. */
+  sitemap(): Promise<MetadataRoute.Sitemap>;
+  /**
+   * For `app/admin/demo-content.json/route.ts`: in a demo (the config's `demo`), the copy of
+   * the site's content its admin panel starts from. A static export can't leave a route out,
+   * so other sites get an empty file.
+   */
+  demoContent(): Promise<Response>;
+  /** For `app/robots.ts`: lets search engines in, and points them at the sitemap once the site's address is set. */
+  robots(): Promise<MetadataRoute.Robots>;
+};
+//#endregion