@goodfellow-cms/next 0.8.0 → 0.9.0

package/bin/goodfellow-next.js

@@ -3,12 +3,14 @@
 // writes the calendar files of collections of events, collections' feeds, the pages at redirects' old addresses and Cloudflare Pages' _redirects, and the search index for sites with a search block,
 // copies the site's Google Fonts into the export, builds plugins' admin frames and runs their build steps, starts every page with the admin address's guard for a site with one, and reports what automated checks find on the exported pages. `index` only writes the index.
 // `goodfellow-next update` updates Goodfellow, as `goodfellow update` does for other sites.
-// `goodfellow-next task [--out <file>]` runs one of a plugin's tasks for the admin panel, as `goodfellow task` does.
+// `goodfellow-next task [--describe] [--out <file>]` runs one of a plugin's tasks for the admin panel, or with
+// --describe only writes it down for a job with no secrets, as `goodfellow task` does.
 // `goodfellow-next due [--since <time>] [--output <file>]` says whether a scheduled change has come due, as `goodfellow due` does.
 // `goodfellow-next nightly [--mode <mode>]` says whether tonight's build is needed, as `goodfellow nightly` does.
 // `goodfellow-next content link|copy [folder]` puts a content repository's files in place, for a site whose
 // content is kept in a repository of its own.
 // `goodfellow-next import wordpress <file or address> [--dry-run]` imports a WordPress site, as `goodfellow import` does.
+// `goodfellow-next import markdown <folder> [--dry-run]` imports a folder of Markdown files, as `goodfellow import` does.
 // `goodfellow-next export wordpress [file]` writes the site as a WordPress export file, as `goodfellow export` does.
 // `goodfellow-next blocks add <item> [--registry <folder>] [--native <app>]` makes a block of a shadcn item, as
 // `goodfellow blocks add` does, and with --native its version for an Expo app.
@@ -16,7 +18,7 @@
 // the token broker, in goodfellow.config.tsx, as `goodfellow admin` and `goodfellow broker` do.
 import { existsSync, readFileSync } from "node:fs";
 import { rm } from "node:fs/promises";
-import { relative, resolve } from "node:path";
+import { join, relative, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { buildNotes, CLOUDFLARE_REDIRECTS_LIMIT, configAdmin, formatUpdateResult } from "@goodfellow-cms/core";
 import { reportSiteProblems } from "@goodfellow-cms/core/accessibility";
@@ -24,13 +26,19 @@ import {
   AdminSetupError,
   BrokerSetupError,
   ContentRepositoryError,
+  checkEarlyTheme,
   checkSiteAdminAddress,
   contentRepositoryProblem,
   exportWordPress,
   formatAdminResult,
+  formatAdminText,
+  formatMarkdownImport,
   formatWordPressExport,
   formatWordPressImport,
+  importMarkdown,
   importWordPress,
+  MarkdownFolderError,
+  markdownFolderChoices,
   nightlyCheck,
   reportDue,
   reportNightly,
@@ -39,6 +47,8 @@ import {
   setBrokerAddress,
   setUpContentRepository,
   update,
+  writeAdminText,
+  writeTaskDescription,
 } from "@goodfellow-cms/core/node";
 import { writePagesSearchIndex, writeSearchIndex } from "@goodfellow-cms/core/search-index";
 import { addShadcnBlock, blockWorks, formatShadcnBlock, ShadcnBlockError } from "@goodfellow-cms/core/shadcn";
@@ -49,9 +59,11 @@ import {
   builtPages,
   checkPages,
   exportedPages,
+  exportTrailingSlash,
   fixSegmentFiles,
   guardExport,
   NEXT_SITE_FILES,
+  nextDistDir,
   writeBuildRecordFile,
   writeCalendarFiles,
   writeContentApi,
@@ -71,6 +83,19 @@ const CONFIG_FILES = ["goodfellow.config.tsx", "goodfellow.config.ts", "goodfell
 // A full-stack site (withGoodfellow(config, { server: true })): Next.js serves its pages and sends redirects
 // itself, so the calendar files, feeds and the search index are written into public/, which `next start` and hosts
 // serve as static files, as they are for an export.
+// A theme installed before it was three days old is used only once its provenance checks out, whatever the
+// admin panel said, since a browser can lie.
+if (command === "finish") {
+  // Pages' full addresses end as Next.js served the pages, unless where the site is built says otherwise.
+  process.env.GOODFELLOW_TRAILING_SLASH ||= String(await exportTrailingSlash());
+  try {
+    const theme = await checkEarlyTheme(process.cwd());
+    if (theme) console.log(`${theme.name} ${theme.release} was installed early: its provenance checks out.`);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
 if (command === "finish" && dir === "--server") {
   // Next.js renders a full-stack site's pages as it serves them, so nothing can put a guard first in each.
   const config = CONFIG_FILES.find((file) => existsSync(file));
@@ -82,13 +107,15 @@ if (command === "finish" && dir === "--server") {
   }
   for (const folder of await buildFileFolders()) await rm(`public/${folder}`, { recursive: true, force: true });
   // The editor's frames' page, which next start serves as it was rendered.
-  await writeEditorPolicy(".next/server/app");
+  await writeEditorPolicy(join(await nextDistDir(), "server/app"));
   const calendars = await writeCalendarFiles("public");
   if (calendars > 0) console.log(`Wrote ${calendars} calendar files, in public/calendars`);
   const feeds = await writeFeedFiles("public");
   if (feeds > 0) console.log(`Wrote ${feeds} feeds, in public/feeds`);
   const api = await writeContentApi("public");
   if (api !== undefined) console.log(`Wrote the content API, with ${api} pages, in public/api`);
+  // The admin panel's text in the site's own languages, for the sign-in screen, which can't read the site yet.
+  for (const line of formatAdminText(await writeAdminText("public"))) console.log(line);
   // Before the pages are read, so the search index and the checks see each page's language.
   const languages = await writePageLanguages(undefined);
   if (languages > 0) console.log(`Marked ${languages} pages with their language`);
@@ -119,8 +146,20 @@ if (command === "update") {
   process.exit(result.state === "failed" ? 1 : 0);
 }
 if (command === "task") {
-  const { values } = parseArgs({ args: process.argv.slice(3), options: { out: { type: "string" } } });
+  const { values } = parseArgs({
+    args: process.argv.slice(3),
+    options: { out: { type: "string" }, describe: { type: "boolean" } },
+  });
   const env = process.env;
+  if (values.describe) {
+    await writeTaskDescription(
+      ".",
+      { module: new URL("../dist/export.js", import.meta.url).href, export: "loadTaskConfig" },
+      { plugin: env.GOODFELLOW_TASK_PLUGIN ?? "", task: env.GOODFELLOW_TASK_NAME ?? "" },
+      values.out,
+    );
+    process.exit(0);
+  }
   await writeTaskResult(
     ".",
     {
@@ -204,10 +243,39 @@ if (command === "import") {
   const { positionals, values } = parseArgs({
     args: process.argv.slice(3),
     allowPositionals: true,
-    options: { "dry-run": { type: "boolean" } },
+    options: {
+      "dry-run": { type: "boolean" },
+      pages: { type: "string", multiple: true },
+      collection: { type: "string", multiple: true },
+      "replace-home": { type: "boolean" },
+      "replace-pages": { type: "boolean" },
+      drafts: { type: "boolean" },
+      menu: { type: "boolean" },
+      "keep-fields": { type: "boolean" },
+    },
   });
   const [kind, from] = positionals;
   const problem = contentRepositoryProblem(".");
+  if (kind === "markdown" && from && !problem) {
+    try {
+      const result = await importMarkdown(".", from, {
+        folders: markdownFolderChoices(values.pages, values.collection),
+        replaceHome: values["replace-home"],
+        replacePages: values["replace-pages"],
+        drafts: values.drafts,
+        menu: values.menu,
+        keepFields: values["keep-fields"],
+        dryRun: values["dry-run"],
+        log: (line) => console.log(line),
+      });
+      console.log(formatMarkdownImport(result));
+      process.exit(0);
+    } catch (error) {
+      if (!(error instanceof MarkdownFolderError)) throw error;
+      console.error(error.message);
+      process.exit(1);
+    }
+  }
   if (kind === "wordpress" && from && !problem) {
     try {
       const result = await importWordPress(".", from, { dryRun: values["dry-run"], log: (line) => console.log(line) });
@@ -272,6 +340,8 @@ if (command !== "finish" && command !== "index") {
       "       goodfellow-next nightly [--mode changed|always|off] [--output <file>]",
       "       goodfellow-next content link|copy [folder]",
       "       goodfellow-next import wordpress <file or address> [--dry-run]",
+      "       goodfellow-next import markdown <folder> [--dry-run] [--pages <folder>] [--collection <folder>]",
+      "                                        [--replace-home] [--replace-pages] [--drafts] [--menu] [--keep-fields]",
       "       goodfellow-next export wordpress [file]",
       "       goodfellow-next blocks add <item> [--registry <folder>] [--native <app>]",
       "       goodfellow-next admin add <address> | check | remove",
@@ -301,7 +371,9 @@ if (command !== "finish" && command !== "index") {
       "        or copies them from it, as builds do.",
       "import  Brings a WordPress site's pages, posts, categories, tags, menus and media into",
       "        this site, from its export file (Tools → Export) or its address. With --dry-run,",
-      "        says what it would bring across and changes nothing.",
+      "        says what it would bring across and changes nothing. import markdown brings a folder",
+      "        of Markdown files in: the files at the top as pages, each folder as a collection,",
+      "        unless --pages or --collection names it (. for the top).",
       "export  Writes this site as a WordPress export file (default: named after the site),",
       "        which WordPress imports with Tools → Import → WordPress.",
       "blocks  Installs a shadcn registry item (button, @acme/hero, or an item's address) with",
@@ -330,6 +402,7 @@ if (command === "finish") {
   if (feeds > 0) console.log(`Wrote ${feeds} feeds`);
   const api = await writeContentApi(dir);
   if (api !== undefined) console.log(`Wrote the content API, with ${api} pages, in api/`);
+  for (const line of formatAdminText(await writeAdminText(dir))) console.log(line);
   const languages = await writePageLanguages(dir);
   if (languages > 0) console.log(`Marked ${languages} pages with their language`);
   // Before the redirects' pages, which aren't the site's.

package/dist/admin.js

@@ -1,5 +1,5 @@
 "use client";
-import { n as EDITOR_PAGE, t as ADMIN_PAGE } from "./site-files-BeLnLxCl.js";
+import { n as EDITOR_PAGE, t as ADMIN_PAGE } from "./site-files-Cmu3ovIs.js";
 import { ADMIN_POLICY, DEV_EDITOR_PREFIX } from "@goodfellow-cms/core";
 import { useEffect, useState } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";

package/dist/components.d.ts

@@ -16,6 +16,13 @@ export declare function NextImage({ src, alt, width, height, loading, ...props }
 export declare function CurrentMenuLinks({ basePath }: {
   basePath?: string;
 }): null;
+/**
+ * Counts each page visitors move to with GoatCounter, whose script counts only
+ * the page it loads on. Plausible's and Umami's scripts follow Next.js's
+ * navigations themselves. Does nothing until the script has loaded, which on a
+ * site that asks visitors first is once they allow statistics.
+ */
+export declare function GoatCounterNavigation(): null;
 /**
  * Opens the Search box's results with Next.js's navigation, and loads them
  * ahead when they're pointed at or reached with the keyboard, as `next/link`

package/dist/components.js

@@ -1,7 +1,7 @@
 "use client";
 import { CurrentPathProvider } from "@goodfellow-cms/react";
 import { usePathname, useRouter } from "next/navigation";
-import { useEffect } from "react";
+import { useEffect, useRef } from "react";
 import Image from "next/image";
 import Link from "next/link";
 import { jsx } from "react/jsx-runtime";
@@ -51,6 +51,24 @@ function CurrentMenuLinks({ basePath = "" }) {
 	return null;
 }
 /**
+* Counts each page visitors move to with GoatCounter, whose script counts only
+* the page it loads on. Plausible's and Umami's scripts follow Next.js's
+* navigations themselves. Does nothing until the script has loaded, which on a
+* site that asks visitors first is once they allow statistics.
+*/
+function GoatCounterNavigation() {
+	const pathname = usePathname();
+	const first = useRef(true);
+	useEffect(() => {
+		if (first.current) {
+			first.current = false;
+			return;
+		}
+		window.goatcounter?.count?.({ path: location.pathname + location.search });
+	}, [pathname]);
+	return null;
+}
+/**
 * Opens the Search box's results with Next.js's navigation, and loads them
 * ahead when they're pointed at or reached with the keyboard, as `next/link`
 * does. The Search box writes its results itself (`searchScript()`), as plain
@@ -117,4 +135,4 @@ function ByLanguage({ variants }) {
 	});
 }
 //#endregion
-export { ByLanguage, CurrentMenuLinks, NextImage, NextLink, PageLanguage, SearchResultLinks };
+export { ByLanguage, CurrentMenuLinks, GoatCounterNavigation, NextImage, NextLink, PageLanguage, SearchResultLinks };

package/dist/config.d.ts

@@ -11,6 +11,14 @@ export interface GoodfellowNextOptions {
    */
   server?: boolean;
 }
+/**
+ * A redirect's target as Next.js's destination: Next.js reads `:name`, `*`,
+ * `+`, `(`, `)`, `{` and `}` in its path and hash as a pattern, which would
+ * fail the build (`/a/:b` names a value the source doesn't have), so they're
+ * percent-encoded there, which browsers and servers read as the same address.
+ * Next.js escapes its query values itself.
+ */
+export declare function redirectDestination(to: string): string;
 /**
  * Sets up Next.js for a Goodfellow site, in `next.config.ts`:
  * `export default withGoodfellow({ ... })`.

package/dist/config.js

@@ -1,6 +1,6 @@
-import { n as IMAGE_SIZES_MARK, t as IMAGE_SIZES_ENV } from "./image-sizes-mark-Ctz9p44g.js";
-import { CALENDARS_DIR, FEEDS_DIR, allPages, brokerOrigin, buildNotes, configAdmin, configBroker, loadSiteContent, normalizeBase, redirectFrom, redirectProblems, shownContent, vercelAdminRedirects, vercelHeaders } from "@goodfellow-cms/core";
-import { BUILD_DATES_DIR, BUILD_DATES_ENV, DEV_API_PREFIX, builtSiteSource, contentRepositoryProblem, handleDevApi, hostFonts, isLocalOrigin, localFileStore, localRegistryDir } from "@goodfellow-cms/core/node";
+import { n as IMAGE_SIZES_ENV, r as IMAGE_SIZES_MARK, t as DIST_DIR_RECORD } from "./image-sizes-mark-BOE7ObB9.js";
+import { CALENDARS_DIR, FEEDS_DIR, TRAILING_SLASH_VARIABLE, allPages, brokerOrigin, buildNotes, configAdmin, configBroker, loadSiteContent, normalizeBase, redirectFrom, redirectProblems, shownContent, vercelAdminRedirects, vercelHeaders } from "@goodfellow-cms/core";
+import { BUILD_DATES_DIR, BUILD_DATES_ENV, DEV_API_PREFIX, builtSiteSource, contentRepositoryProblem, handleDevApi, hostFonts, isAllowedDevHost, isLocalOrigin, localFileStore, localRegistryDir } from "@goodfellow-cms/core/node";
 import { existsSync, readFileSync } from "node:fs";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
@@ -71,6 +71,11 @@ function startDevApi(root) {
 			server: "next-dev"
 		};
 		const server = createServer(async (req, res) => {
+			const forwarded = req.headers["x-forwarded-host"];
+			if (!isAllowedDevHost(req.headers.host) || forwarded !== void 0 && !isAllowedDevHost(String(forwarded))) {
+				res.writeHead(403).end();
+				return;
+			}
 			if (await (await editor).serve(req, res)) return;
 			if (!await handleDevApi(store, req, res, {
 				trustOrigin: isLocalOrigin,
@@ -114,6 +119,25 @@ function redirectSource(path) {
 	return encodeURI(path).replace(/[()[\]{}+*?:!]/g, "\\$&");
 }
 /**
+* A redirect's target as Next.js's destination: Next.js reads `:name`, `*`,
+* `+`, `(`, `)`, `{` and `}` in its path and hash as a pattern, which would
+* fail the build (`/a/:b` names a value the source doesn't have), so they're
+* percent-encoded there, which browsers and servers read as the same address.
+* Next.js escapes its query values itself.
+*/
+function redirectDestination(to) {
+	const target = to.trim();
+	const origin = /^https:\/\/[^/?#]*/i.exec(target)?.[0] ?? "";
+	const rest = target.slice(origin.length);
+	const query = rest.indexOf("?");
+	const hash = rest.indexOf("#");
+	const encode = (part) => part.replace(/[:*+(){}]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
+	const pathEnd = [query, hash].filter((index) => index >= 0).reduce((a, b) => Math.min(a, b), rest.length);
+	const search = query >= 0 && (hash < 0 || query < hash) ? rest.slice(query, hash > query ? hash : void 0) : "";
+	const fragment = hash >= 0 ? rest.slice(hash) : "";
+	return `${origin}${encode(rest.slice(0, pathEnd))}${search}${encode(fragment)}`;
+}
+/**
 * 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,
@@ -130,7 +154,7 @@ async function siteRedirects(root) {
 		if (problems[index] || !from.ok || taken.has(from.path)) return [];
 		return [{
 			source: redirectSource(from.path),
-			destination: redirect.to.trim(),
+			destination: redirectDestination(redirect.to),
 			permanent: true
 		}];
 	});
@@ -193,10 +217,13 @@ function withGoodfellow(nextConfig = {}, options = {}) {
 			images: imageSettings(nextConfig.images),
 			env: {
 				...nextConfig.env,
-				GOODFELLOW_BASE_PATH: basePath
+				GOODFELLOW_BASE_PATH: basePath,
+				[TRAILING_SLASH_VARIABLE]: String(nextConfig.trailingSlash ?? true)
 			}
 		};
 		if (phase === PHASE_PRODUCTION_BUILD) {
+			await mkdir(dirname(join(root, DIST_DIR_RECORD)), { recursive: true });
+			await writeFile(join(root, DIST_DIR_RECORD), nextConfig.distDir ?? ".next");
 			const dates = join(root, nextConfig.distDir ?? ".next", BUILD_DATES_DIR);
 			await rm(dates, {
 				recursive: true,
@@ -276,4 +303,4 @@ function withGoodfellow(nextConfig = {}, options = {}) {
 	};
 }
 //#endregion
-export { withGoodfellow };
+export { redirectDestination, withGoodfellow };

package/dist/export.d.ts

@@ -2,11 +2,6 @@ import { GoodfellowConfig, PluginTaskRequest, SelfHostedResult, SiteProblem, Tas
 import { ImageSizesResult, SiteFile } from "@goodfellow-cms/core/node";
 import { PageRender } from "@goodfellow-cms/core/shadcn";
 //#region src/site-files.d.ts
-/**
- * The Next.js starter's files that `goodfellow-next update` keeps up to date
- * where nobody has changed them, as the starter now has them. A test checks
- * they match `templates/next`.
- */
 export declare const NEXT_SITE_FILES: readonly SiteFile[];
 //#endregion
 //#region src/export.d.ts
@@ -35,6 +30,15 @@ export declare function writeContentApi(outDir: string, root?: string): Promise<
  * code, such as `es/feeds/`.
  */
 export declare function buildFileFolders(root?: string): Promise<string[]>;
+/** The folder `next build` wrote into, as `withGoodfellow()` recorded it: the config's `distDir`, or `.next`. */
+export declare function nextDistDir(root?: string): Promise<string>;
+/**
+ * Whether the export's pages end their addresses with `/`, as Next.js's
+ * `trailingSlash` says, which Next.js records in
+ * `.next/required-server-files.json`. `true` where it can't be read, as
+ * `withGoodfellow()` sets it.
+ */
+export declare function exportTrailingSlash(root?: string): Promise<boolean>;
 /** What `writePluginFiles()` wrote and ran. */
 export interface PluginFilesWritten {
   /** The plugins whose admin frames were written. */
@@ -156,10 +160,14 @@ export declare function exportedPages(outDir: string): Promise<BuiltPage[]>;
  */
 export declare function checkPages(pages: readonly BuiltPage[], root?: string): Promise<SiteProblem[]>;
 /**
- * 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. The config
- * loads in a process of its own, with none of the job's secrets.
+ * Runs one of a plugin's tasks for the admin panel in one job, 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: for sites' task setups from before 0.9. The config loads in a process
+ * of its own, without the job's secrets in its environment, but where it can
+ * read its parent's, so the starters now write the task down with
+ * `goodfellow-next task --describe` in a job with no secrets and run it with
+ * `@goodfellow-cms/core`'s `goodfellow-task`.
  */
 export declare function writeTaskResult(root: string, request: PluginTaskRequest, out?: string): Promise<TaskResultFile>;
 /** The site's config, loaded in Node, for `writeTaskResult()`'s process that loads it apart from the job's secrets. */

package/dist/export.js

@@ -1,6 +1,6 @@
 import { a as loadSiteModule, i as loadSiteConfig, n as buildPluginFrames, r as configHasPlugins } from "./plugins-UKkfu0Uj.js";
-import "./image-sizes-mark-Ctz9p44g.js";
-import { r as NEXT_SITE_FILES } from "./site-files-BeLnLxCl.js";
+import { t as DIST_DIR_RECORD } from "./image-sizes-mark-BOE7ObB9.js";
+import { r as NEXT_SITE_FILES } from "./site-files-Cmu3ovIs.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, sitePages, taskRequestProblem, todayIn } from "@goodfellow-cms/core";
 import { BUILD_DATES_DIR, builtSiteSource, guardBuiltSite, reportedDate, runPluginBuildSteps, runPluginTask, selfHostFonts, sitePluginsApart, taskSecretsFrom, writeBuildRecord, writeImageSizes, writeSiteHeaders } from "@goodfellow-cms/core/node";
 import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
@@ -71,16 +71,34 @@ async function buildFileFolders(root = process.cwd()) {
 	const { settings } = await loadSiteContent(builtSiteSource(resolve(root)));
 	return siteLanguages(settings).flatMap((language) => [CALENDARS_DIR, FEEDS_DIR].map((dir) => `${language.prefix.slice(1)}${language.prefix ? "/" : ""}${dir}`));
 }
+/** The folder `next build` wrote into, as `withGoodfellow()` recorded it: the config's `distDir`, or `.next`. */
+async function nextDistDir(root = process.cwd()) {
+	const recorded = await readFile(join(root, DIST_DIR_RECORD), "utf8").catch(() => "");
+	return join(root, recorded.trim() || ".next");
+}
 /** 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"));
+		const manifest = JSON.parse(await readFile(join(await nextDistDir(root), "routes-manifest.json"), "utf8"));
 		return typeof manifest.basePath === "string" ? manifest.basePath : "";
 	} catch {
 		return "";
 	}
 }
 /**
+* Whether the export's pages end their addresses with `/`, as Next.js's
+* `trailingSlash` says, which Next.js records in
+* `.next/required-server-files.json`. `true` where it can't be read, as
+* `withGoodfellow()` sets it.
+*/
+async function exportTrailingSlash(root = ".") {
+	try {
+		return JSON.parse(await readFile(join(await nextDistDir(root), "required-server-files.json"), "utf8")).config?.trailingSlash !== false;
+	} catch {
+		return true;
+	}
+}
+/**
 * 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
@@ -138,7 +156,7 @@ async function writeFontFiles(outDir, root = process.cwd()) {
 async function writeBuildRecordFile(outDir, root = process.cwd()) {
 	const dir = resolve(root);
 	const content = await loadSiteContent(builtSiteSource(dir));
-	const date = await reportedDate(join(dir, ".next", BUILD_DATES_DIR));
+	const date = await reportedDate(join(await nextDistDir(dir), BUILD_DATES_DIR));
 	return (await writeBuildRecord(outDir, {
 		root: dir,
 		content,
@@ -169,7 +187,7 @@ async function writeRedirectFiles(outDir, root = process.cwd()) {
 		await writeFile(target, file.content);
 		written.push(file);
 	}
-	const cloudflare = cloudflareRedirects(written, base);
+	const cloudflare = cloudflareRedirects(written, base, content.settings.trailingSlash !== false);
 	const redirects = join(outDir, CLOUDFLARE_REDIRECTS_PATH.slice(1));
 	if (cloudflare.file && !await exists(redirects)) await writeFile(redirects, cloudflare.file.content);
 	return {
@@ -185,14 +203,14 @@ async function writeRedirectFiles(outDir, root = process.cwd()) {
 */
 async function writeImageFiles(outDir, root = process.cwd()) {
 	const dir = resolve(root);
-	if (!await exists(join(dir, ".next", "goodfellow-image-sizes"))) return void 0;
+	if (!await exists(join(await nextDistDir(dir), "goodfellow-image-sizes"))) return void 0;
 	return writeImageSizes(dir, outDir, { resize: await sharpResizer() });
 }
-/** Makes the copies with sharp, turned as each photo's details say and without them, unless it can't load here. */
+/** Makes the copies with sharp, as WebP, turned as each photo's details say and without them, unless it can't load here. */
 async function sharpResizer() {
 	try {
 		const { default: sharp } = await import("sharp");
-		return async (image, width) => new Uint8Array(await sharp(image).rotate().resize({ width }).toBuffer());
+		return async (image, width) => new Uint8Array(await sharp(image).rotate().resize({ width }).webp({ quality: 80 }).toBuffer());
 	} catch {
 		return;
 	}
@@ -311,7 +329,7 @@ async function writePageLanguages(outDir, root = process.cwd()) {
 	const dir = resolve(root);
 	const { settings } = await loadSiteContent(builtSiteSource(dir));
 	if (!hasLanguages(settings)) return 0;
-	const base = outDir ?? join(dir, ".next/server/app");
+	const base = outDir ?? join(await nextDistDir(dir), "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) {
@@ -331,7 +349,7 @@ async function writePageLanguages(outDir, root = process.cwd()) {
 * 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 next = await nextDistDir(resolve(root));
 	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 = [];
@@ -389,10 +407,14 @@ async function checkPages(pages, root = process.cwd()) {
 	}));
 }
 /**
-* 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. The config
-* loads in a process of its own, with none of the job's secrets.
+* Runs one of a plugin's tasks for the admin panel in one job, 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: for sites' task setups from before 0.9. The config loads in a process
+* of its own, without the job's secrets in its environment, but where it can
+* read its parent's, so the starters now write the task down with
+* `goodfellow-next task --describe` in a job with no secrets and run it with
+* `@goodfellow-cms/core`'s `goodfellow-task`.
 */
 async function writeTaskResult(root, request, out = TASK_RESULT_FILE) {
 	const secrets = taskSecretsFrom(process.env);
@@ -453,4 +475,4 @@ function blockPageRender(root) {
 	};
 }
 //#endregion
-export { EDITOR_PAGES, NEXT_SITE_FILES, blockPageRender, buildFileFolders, builtPages, checkPages, exportedPages, fixSegmentFiles, guardExport, loadTaskConfig, writeBuildRecordFile, writeCalendarFiles, writeContentApi, writeEditorPolicy, writeExportHeaders, writeFeedFiles, writeFontFiles, writeImageFiles, writePageLanguages, writePluginFiles, writeRedirectFiles, writeTaskResult };
+export { EDITOR_PAGES, NEXT_SITE_FILES, blockPageRender, buildFileFolders, builtPages, checkPages, exportTrailingSlash, exportedPages, fixSegmentFiles, guardExport, loadTaskConfig, nextDistDir, writeBuildRecordFile, writeCalendarFiles, writeContentApi, writeEditorPolicy, writeExportHeaders, writeFeedFiles, writeFontFiles, writeImageFiles, writePageLanguages, writePluginFiles, writeRedirectFiles, writeTaskResult };

package/dist/{image-sizes-mark-Ctz9p44g.js → image-sizes-mark-BOE7ObB9.js}

@@ -7,5 +7,11 @@
 const IMAGE_SIZES_ENV = "GOODFELLOW_IMAGE_SIZES";
 /** The file in `.next/` that tells `goodfellow-next finish` the pages list them. */
 const IMAGE_SIZES_MARK = "goodfellow-image-sizes";
+/**
+* Where `withGoodfellow()` records the folder `next build` writes into (the
+* config's `distDir`, `.next` unless it says otherwise), relative to the site,
+* for `goodfellow-next finish`, which runs after it in a process of its own.
+*/
+const DIST_DIR_RECORD = "node_modules/.goodfellow/next-dist-dir";
 //#endregion
-export { IMAGE_SIZES_MARK as n, IMAGE_SIZES_ENV as t };
+export { IMAGE_SIZES_ENV as n, IMAGE_SIZES_MARK as r, DIST_DIR_RECORD as t };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AdminSite, GoodfellowConfig, Page, SiteContent } from "@goodfellow-cms/core";
+import { AdminSite, GoodfellowConfig, ImageSize, Page, SiteContent } from "@goodfellow-cms/core";
 import { ReactNode } from "react";
 import { Metadata, MetadataRoute } from "next";
 //#region src/index.d.ts
@@ -24,8 +24,11 @@ export interface PageProps {
  * 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;
+/**
+ * A page's title, description, search engine settings and link previews, as
+ * Next.js metadata, with the shared picture's size where `media` has it.
+ */
+export declare function pageMetadata(content: SiteContent, page: Page, basePath?: string, media?: Readonly<Record<string, ImageSize>>): 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
@@ -75,7 +78,10 @@ export declare function goodfellowPages(config: GoodfellowConfig, options?: Good
    * edit its content without its code, such as the Claude connector.
    */
   siteDescription(): Response;
-  /** For `app/robots.ts`: lets search engines in, and points them at the sitemap once the site's address is set. */
+  /**
+   * For `app/robots.ts`: lets search engines in, asks AI training's crawlers to stay out where Site Settings
+   * says so, and points them at the sitemap once the site's address is set (`robotsRules()`).
+   */
   robots(): Promise<MetadataRoute.Robots>;
 };
 //#endregion

package/dist/index.js

@@ -1,8 +1,8 @@
-import { ByLanguage, CurrentMenuLinks, NextImage, NextLink, PageLanguage, SearchResultLinks } from "./components.js";
-import "./image-sizes-mark-Ctz9p44g.js";
-import { BLOCK_SCRIPTS, DARK_MODE_ATTRIBUTE, IMAGE_WIDTHS, absoluteUrl, adminSiteForCopy, colorSchemeMeta, colorSchemeScript, consentScript, contentForPage, demoContent, describedForCopy, feedLinks, findRedirect, fontPreloads, googleFontsUrl, hasLanguages, heldCode, languageMap, loadSiteContent, normalizePagePath, pageHead, shownContent, siteCopyFrom, siteLanguages, sitePages, sitemapPages, storedMediaSizes, themeToCss, todayIn, withBase, withSelfHostedFonts } from "@goodfellow-cms/core";
+import { ByLanguage, CurrentMenuLinks, GoatCounterNavigation, NextImage, NextLink, PageLanguage, SearchResultLinks } from "./components.js";
+import "./image-sizes-mark-BOE7ObB9.js";
+import { BLOCK_SCRIPTS, DARK_MODE_ATTRIBUTE, IMAGE_WIDTHS, TRAILING_SLASH_VARIABLE, absoluteUrl, adminSiteForCopy, colorSchemeMeta, colorSchemeScript, consentScript, contentForPage, customFontPreloads, demoContent, describedForCopy, feedLinks, findRedirect, fontPreloads, googleFontsUrl, hasLanguages, heldCode, heldStats, languageMap, loadSiteContent, normalizePagePath, pageHead, robotsRules, shownContent, siteCopyFrom, siteLanguages, sitePages, sitemapPages, storedMediaSizes, themeToCss, todayIn, withBase, withSelfHostedFonts } from "@goodfellow-cms/core";
 import { BUILD_DATES_ENV, builtSiteSource, 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 { BodyCode, HeadCode, PageBody, PageContent, PageFooter, PageHeader, StatsCode, 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";
@@ -41,7 +41,10 @@ function hostedFonts(source) {
 * 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(async (root = process.cwd()) => shownContent(await loadSiteContent(builtSiteSource(root))));
+const loadSite = cache(async (root = process.cwd()) => shownContent(await loadSiteContent(builtSiteSource(root, {
+	...process.env,
+	[TRAILING_SLASH_VARIABLE]: process.env.GOODFELLOW_TRAILING_SLASH
+}))));
 function pathOf(segments) {
 	try {
 		return normalizePagePath(`/${(segments ?? []).map((segment) => decodeURIComponent(segment)).join("/")}`);
@@ -80,16 +83,25 @@ function toAbsolute(siteUrl, url) {
 	if (!url || !siteUrl || !url.startsWith("/") || url.startsWith("//")) return url;
 	return absoluteUrl(siteUrl, url);
 }
-/** A page's title, description and link previews, as Next.js metadata. */
-function pageMetadata(content, page, basePath = configuredBasePath()) {
+/**
+* A page's title, description, search engine settings and link previews, as
+* Next.js metadata, with the shared picture's size where `media` has it.
+*/
+function pageMetadata(content, page, basePath = configuredBasePath(), media = {}) {
 	const head = pageHead(content, page);
 	const socialImage = toAbsolute(content.settings.url, head.socialImage);
+	const socialSize = head.socialImage ? media[head.socialImage] : void 0;
 	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 } },
+		robots: {
+			...head.noIndex && { index: false },
+			...head.noFollow && { follow: false },
+			...!head.noIndex && head.noSnippet && { nosnippet: true },
+			...!head.noIndex && { "max-image-preview": "large" }
+		},
 		...(head.canonicalUrl || feeds.length > 0) && { alternates: {
 			...head.canonicalUrl && { canonical: head.canonicalUrl },
 			...head.alternates && { languages: Object.fromEntries(head.alternates.map(({ language, href }) => [language, href])) },
@@ -100,12 +112,25 @@ function pageMetadata(content, page, basePath = configuredBasePath()) {
 		} },
 		...head.favicon && { icons: { icon: withBase(head.favicon, basePath) } },
 		openGraph: {
-			type: "website",
+			...head.type === "article" ? {
+				type: "article",
+				...head.publishedTime && { publishedTime: head.publishedTime }
+			} : { type: "website" },
+			siteName: head.siteName,
+			locale: head.locale,
 			title: head.title,
 			...head.description && { description: head.description },
 			...head.canonicalUrl && { url: head.canonicalUrl },
-			...socialImage && /^https?:\/\//.test(socialImage) && { images: [socialImage] }
-		}
+			...socialImage && /^https?:\/\//.test(socialImage) && { images: [{
+				url: socialImage,
+				...socialSize && {
+					width: socialSize.width,
+					height: socialSize.height
+				},
+				...head.socialImageAlt && { alt: head.socialImageAlt }
+			}] }
+		},
+		twitter: { card: head.card }
 	};
 }
 /**
@@ -135,7 +160,12 @@ function goodfellowPages(config, options = {}) {
 		const googleUrl = googleFontsUrl(content.settings.theme);
 		const hosted = googleUrl ? hostedFonts(googleUrl) : void 0;
 		const fontsUrl = googleUrl && hosted ? withSelfHostedFonts(googleUrl, hosted, basePath()) : googleUrl;
-		const [fontFiles, standIns] = await Promise.all([fontPreloads(content.settings.theme, readStylesheet), fontStandIns(content.settings.theme)]);
+		const [fontFiles, standIns] = await Promise.all([fontPreloads(content.settings.theme, readStylesheet), fontStandIns(content.settings.theme, { root })]);
+		for (const file of customFontPreloads(content.settings.theme)) preload(withBase(file, basePath()), {
+			as: "font",
+			type: "font/woff2",
+			crossOrigin: ""
+		});
 		for (const file of fontFiles) {
 			const href = hosted ? withSelfHostedFonts(file, hosted, basePath()) : file;
 			if (hosted && href === file) continue;
@@ -156,7 +186,7 @@ function goodfellowPages(config, options = {}) {
 			/* @__PURE__ */ jsx("style", {
 				href: "goodfellow-theme",
 				precedence: "default",
-				children: themeToCss(content.settings.theme, standIns)
+				children: themeToCss(content.settings.theme, standIns, { base: basePath() })
 			}),
 			fontsUrl && /* @__PURE__ */ jsx("link", {
 				rel: "stylesheet",
@@ -173,7 +203,8 @@ function goodfellowPages(config, options = {}) {
 		async generateMetadata({ params }) {
 			const content = await site();
 			const page = findPage(content, config.blocks, pathOf((await params).path));
-			return page ? pageMetadata(content, applyPageEntry(configs, content, page), basePath()) : {};
+			if (!page) return {};
+			return pageMetadata(content, applyPageEntry(configs, content, page), basePath(), (await renderOptions()).media);
 		},
 		/**
 		* For `app/admin/page.tsx`: what the admin panel's page knows about the
@@ -246,10 +277,15 @@ function goodfellowPages(config, options = {}) {
 					held: heldCode(content.settings.consent, "head"),
 					siteUrl: content.settings.url
 				}),
+				/* @__PURE__ */ jsx(StatsCode, {
+					stats: content.settings.stats,
+					held: heldStats(content.settings.consent, content.settings.stats)
+				}),
 				header,
 				children,
 				footer,
 				/* @__PURE__ */ jsx(CurrentMenuLinks, { basePath: basePath() }),
+				content.settings.stats?.service === "goatcounter" && process.env.NODE_ENV !== "development" && /* @__PURE__ */ jsx(GoatCounterNavigation, {}),
 				/* @__PURE__ */ jsx(SearchResultLinks, { basePath: basePath() }),
 				/* @__PURE__ */ jsx(BodyCode, {
 					code: content.code?.body,
@@ -337,15 +373,15 @@ function goodfellowPages(config, options = {}) {
 		siteDescription() {
 			return Response.json(describedForCopy(describeSite(config), siteCopyFrom(process.env)));
 		},
-		/** For `app/robots.ts`: lets search engines in, and points them at the sitemap once the site's address is set. */
+		/**
+		* For `app/robots.ts`: lets search engines in, asks AI training's crawlers to stay out where Site Settings
+		* says so, and points them at the sitemap once the site's address is set (`robotsRules()`).
+		*/
 		async robots() {
-			const url = (await site()).settings.url;
+			const { settings } = await site();
 			return {
-				rules: {
-					userAgent: "*",
-					allow: "/"
-				},
-				...url && { sitemap: absoluteUrl(url, "/sitemap.xml") }
+				rules: robotsRules(settings),
+				...settings.url && { sitemap: absoluteUrl(settings.url, "/sitemap.xml") }
 			};
 		}
 	};

package/dist/{site-files-BeLnLxCl.js → site-files-Cmu3ovIs.js}

@@ -1,6 +1,8 @@
 //#region src/site-files.ts
 /** The release whose Next.js sites have the editor's sandboxed frames at `app/admin/editor/`. */
 const FRAMES_RELEASE = "0.5.0";
+/** The release whose Next.js sites tell Vercel not to build drafts' and plugins' tasks' branches. */
+const VERCEL_BRANCHES_RELEASE = "0.9.0";
 /** `app/admin/page.tsx` as every release before the frames wrote it, loading the site's config itself. */
 const CLIENT_ADMIN_PAGE = `"use client";
 
@@ -30,21 +32,33 @@ export default function EditorPage() {
   return <GoodfellowEditor config={config} />;
 }
 `;
-/**
-* The Next.js starter's files that `goodfellow-next update` keeps up to date
-* where nobody has changed them, as the starter now has them. A test checks
-* they match `templates/next`.
-*/
-const NEXT_SITE_FILES = [{
-	path: "app/admin/page.tsx",
-	since: FRAMES_RELEASE,
-	content: ADMIN_PAGE,
-	earlier: [CLIENT_ADMIN_PAGE]
-}, {
-	path: "app/admin/editor/page.tsx",
-	since: FRAMES_RELEASE,
-	content: EDITOR_PAGE,
-	earlier: []
-}];
+const NEXT_SITE_FILES = [
+	{
+		path: "app/admin/page.tsx",
+		since: FRAMES_RELEASE,
+		content: ADMIN_PAGE,
+		earlier: [CLIENT_ADMIN_PAGE]
+	},
+	{
+		path: "app/admin/editor/page.tsx",
+		since: FRAMES_RELEASE,
+		content: EDITOR_PAGE,
+		earlier: []
+	},
+	{
+		path: "vercel.json",
+		since: VERCEL_BRANCHES_RELEASE,
+		content: `{
+  "git": {
+    "deploymentEnabled": {
+      "goodfellow-draft-*": false,
+      "goodfellow-task-*": false
+    }
+  }
+}
+`,
+		earlier: []
+	}
+];
 //#endregion
 export { EDITOR_PAGE as n, NEXT_SITE_FILES as r, ADMIN_PAGE as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@goodfellow-cms/next",
-  "version": "0.8.0",
-  "description": "Goodfellow pages and the admin panel in a Next.js site.",
+  "version": "0.9.0",
+  "description": "Goodfellow CMS pages and the admin panel in a Next.js site.",
   "keywords": [
     "goodfellow",
     "cms",
@@ -12,6 +12,10 @@
   ],
   "homepage": "https://goodfellow-cms.github.io/goodfellow-cms/docs/nextjs",
   "bugs": "https://github.com/goodfellow-cms/goodfellow-cms/issues",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/goodfellow-cms"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -63,24 +67,24 @@
     "dist"
   ],
   "dependencies": {
-    "@goodfellow-cms/ai": "0.8.0",
-    "@goodfellow-cms/core": "0.8.0",
-    "@goodfellow-cms/react": "0.8.0",
+    "@goodfellow-cms/ai": "0.9.0",
+    "@goodfellow-cms/core": "0.9.0",
+    "@goodfellow-cms/react": "0.9.0",
     "rolldown": "1.2.12",
     "sharp": "0.35.5"
   },
   "peerDependencies": {
-    "@goodfellow-cms/admin": "0.8.0",
+    "@goodfellow-cms/admin": "0.9.0",
     "@puckeditor/core": "0.23.0",
     "next": "^16.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@goodfellow-cms/admin": "0.8.0",
-    "@goodfellow-cms/bitbucket": "0.8.0",
-    "@goodfellow-cms/github": "0.8.0",
-    "@goodfellow-cms/gitlab": "0.8.0",
+    "@goodfellow-cms/admin": "0.9.0",
+    "@goodfellow-cms/bitbucket": "0.9.0",
+    "@goodfellow-cms/github": "0.9.0",
+    "@goodfellow-cms/gitlab": "0.9.0",
     "@puckeditor/core": "0.23.0",
     "@tailwindcss/browser": "4.3.3",
     "@types/react": "^19.2.0",