@goodfellow-cms/next 0.5.0 → 0.6.0

package/README.md

@@ -4,7 +4,7 @@ Goodfellow pages and the admin panel in a Next.js App Router site, exported as s
 
 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.
+[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, GitLab or Bitbucket 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) and [Full-stack Next.js sites](https://goodfellow-cms.github.io/goodfellow-cms/docs/full-stack-nextjs).
 

package/bin/goodfellow-next.js

@@ -1,9 +1,10 @@
 #!/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, 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, 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.
+// 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 due [--since <time>]` says whether a scheduled change has come due, as `goodfellow due` does.
+// `goodfellow-next task [--out <file>]` runs one of a plugin's tasks for the admin panel, 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.
@@ -53,7 +54,9 @@ import {
   writeFeedFiles,
   writeFontFiles,
   writePageLanguages,
+  writePluginFiles,
   writeRedirectFiles,
+  writeTaskResult,
 } from "@goodfellow-cms/next/export";
 
 const [command, dir = "out"] = process.argv.slice(2);
@@ -80,6 +83,10 @@ if (command === "finish" && dir === "--server") {
   // 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`);
+  // Plugins' admin frames and build steps, into public/, which next start serves.
+  const plugins = await writePluginFiles("public");
+  if (plugins.frames.length > 0)
+    console.log(`Wrote the admin frames of ${plugins.frames.join(", ")}, in public/admin/plugins`);
   const pages = await builtPages();
   const indexed = await writePagesSearchIndex(pages, "public/pagefind");
   console.log(
@@ -102,9 +109,30 @@ if (command === "update") {
   console.log(formatUpdateResult(result));
   process.exit(result.state === "failed" ? 1 : 0);
 }
+if (command === "task") {
+  const { values } = parseArgs({ args: process.argv.slice(3), options: { out: { type: "string" } } });
+  const env = process.env;
+  await writeTaskResult(
+    ".",
+    {
+      id: env.GOODFELLOW_TASK_REQUEST ?? "",
+      plugin: env.GOODFELLOW_TASK_PLUGIN ?? "",
+      task: env.GOODFELLOW_TASK_NAME ?? "",
+      input: env.GOODFELLOW_TASK_INPUT ?? "",
+      key: env.GOODFELLOW_TASK_KEY ?? "",
+    },
+    values.out,
+  );
+  process.exit(0);
+}
 if (command === "due") {
-  const { values } = parseArgs({ args: process.argv.slice(3), options: { since: { type: "string" } } });
-  for (const line of await reportDue(await scheduleDue({ since: values.since }))) console.log(line);
+  const { values } = parseArgs({
+    args: process.argv.slice(3),
+    options: { since: { type: "string" }, output: { type: "string" } },
+  });
+  const result = await scheduleDue({ since: values.since });
+  for (const line of await reportDue(result, process.env, values.output ?? process.env.GITHUB_OUTPUT))
+    console.log(line);
   process.exit(0);
 }
 if (command === "nightly") {
@@ -206,7 +234,7 @@ if (command !== "finish" && command !== "index") {
       "       goodfellow-next finish --server",
       "       goodfellow-next index [folder]",
       "       goodfellow-next update [--to fixes|automatic|latest|<release>] [--publish | --commit]",
-      "       goodfellow-next due [--since <time>]",
+      "       goodfellow-next due [--since <time>] [--output <file>]",
       "       goodfellow-next nightly [--mode changed|always|off] [--output <file>]",
       "       goodfellow-next content link|copy [folder]",
       "       goodfellow-next import wordpress <file or address> [--dry-run]",
@@ -217,7 +245,8 @@ if (command !== "finish" && command !== "index") {
       "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, collections' feeds and pages that send visitors on from",
-      "        old addresses, indexes it for search, and lists what automated accessibility checks",
+      "        old addresses, builds plugins' admin frames and runs their build steps, indexes it",
+      "        for search, and lists what automated accessibility checks",
       "        find on its pages. With --server, for a full-stack site, writes the calendar files",
       "        and feeds into public/calendars and public/feeds and indexes and checks the pages",
       "        next build rendered, with the index in public/pagefind, instead.",
@@ -227,7 +256,7 @@ if (command !== "finish" && command !== "index") {
       "        that runs none of the site's code to publish.",
       "due     Says whether a scheduled change has come due since --since (default: the last",
       "        hour), so the site needs building again, and sets the step's due output on",
-      "        GitHub Actions.",
+      "        GitHub Actions, or adds it to --output.",
       "nightly Says whether tonight's build is needed: when the site has changed since the live",
       "        site was built, what it shows by today's date has, or an update is available",
       "        (--mode, or GOODFELLOW_NIGHTLY: changed, the default, always or off), and sets the",
@@ -271,6 +300,9 @@ if (command === "finish") {
     );
   }
   for (const line of buildNotes(await writeFontFiles(dir))) console.log(line);
+  // Plugins' admin frames and build steps, once Goodfellow has written the rest, before the index and the guards.
+  const plugins = await writePluginFiles(dir);
+  if (plugins.frames.length > 0) console.log(`Wrote the admin frames of ${plugins.frames.join(", ")}`);
   // What the site was built from, and when it stops being current, for the nightly check.
   const currentUntil = await writeBuildRecordFile(dir);
   if (currentUntil) {

package/dist/admin.js

@@ -58,6 +58,7 @@ function useEditorRebuilds() {
 * dependencies are.
 */
 const HOSTS = {
+	"@goodfellow-cms/bitbucket": () => import("@goodfellow-cms/bitbucket"),
 	"@goodfellow-cms/github": () => import("@goodfellow-cms/github"),
 	"@goodfellow-cms/gitlab": () => import("@goodfellow-cms/gitlab")
 };

package/dist/config.js

@@ -41,15 +41,21 @@ function startDevApi(root) {
 	globals[SERVER_KEY] ??= new Promise((resolvePort, reject) => {
 		const store = localFileStore(root);
 		const registryDir = localRegistryDir(root);
-		const editor = import("./dev-editor-DiPKrIAS.js").then(({ startDevEditor }) => startDevEditor(root)).catch((error) => {
+		const editor = import("./dev-editor-EIZQe3qO.js").then(({ startDevEditor }) => startDevEditor(root)).catch((error) => {
 			console.error(`The editor's frames can't be served: ${error.message}`);
 			return { serve: async () => false };
 		});
+		const tasks = {
+			root,
+			plugins: async () => (await (await import("./plugins-eLJalBij.js").then((n) => n.a)).loadSiteConfig(root)).plugins ?? [],
+			server: "next-dev"
+		};
 		const server = createServer(async (req, res) => {
 			if (await (await editor).serve(req, res)) return;
 			if (!await handleDevApi(store, req, res, {
 				trustOrigin: isLocalOrigin,
-				registryDir
+				registryDir,
+				tasks
 			})) res.writeHead(404).end();
 		});
 		server.on("error", reject);

package/dist/{dev-editor-DiPKrIAS.js → dev-editor-EIZQe3qO.js}

@@ -1,4 +1,5 @@
-import { DEV_EDITOR_PREFIX, EDITOR_PRELUDE, editorPage } from "@goodfellow-cms/core";
+import { i as loadSiteConfig, t as buildPluginFrame } from "./plugins-eLJalBij.js";
+import { DEV_EDITOR_PREFIX, EDITOR_PRELUDE, editorPage, pluginId } from "@goodfellow-cms/core";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
@@ -101,8 +102,53 @@ async function startDevEditor(root) {
 			built();
 		}
 	});
+	const pluginsDir = join(root, "node_modules/.goodfellow/next-plugins");
+	const pluginsPrefix = DEV_EDITOR_PREFIX.replace(/editor\/$/, "plugins/");
+	const pluginBuilds = /* @__PURE__ */ new Map();
+	const pluginFrame = (id) => {
+		let ready = pluginBuilds.get(id);
+		if (!ready) {
+			ready = (async () => {
+				const plugin = (await loadSiteConfig(root)).plugins?.find((candidate) => pluginId(candidate.name) === id && candidate.admin);
+				if (!plugin) {
+					pluginBuilds.delete(id);
+					return false;
+				}
+				await new Promise((done) => {
+					buildPluginFrame(plugin, {
+						root,
+						dir: join(pluginsDir, id),
+						watch: { onBuilt(error) {
+							if (error) console.error(`${plugin.title}'s admin frame couldn't be built: ${error.message}`);
+							done();
+						} }
+					}).catch((error) => {
+						console.error(`${plugin.title}'s admin frame couldn't be built: ${error.message}`);
+						done();
+					});
+				});
+				return true;
+			})();
+			pluginBuilds.set(id, ready);
+		}
+		return ready;
+	};
 	return { async serve(req, res) {
 		const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+		if (pathname.startsWith(pluginsPrefix) && (req.method === "GET" || req.method === "HEAD")) {
+			const [id = "", ...rest] = decodeURIComponent(pathname.slice(pluginsPrefix.length)).split("/");
+			const file = resolve(pluginsDir, id, rest.join("/") || "index.html");
+			if (!file.startsWith(`${pluginsDir}${sep}`) || !await pluginFrame(id)) return false;
+			try {
+				const data = await readFile(file);
+				res.setHeader("Content-Type", TYPES[file.slice(file.lastIndexOf(".") + 1)] ?? "application/octet-stream");
+				res.setHeader("Cache-Control", "no-store");
+				res.end(req.method === "HEAD" ? void 0 : data);
+			} catch {
+				res.writeHead(404).end();
+			}
+			return true;
+		}
 		const page = pathname === DEV_EDITOR_PREFIX.slice(0, -1);
 		if (!(page || pathname.startsWith(DEV_EDITOR_PREFIX)) || req.method !== "GET" && req.method !== "HEAD") return false;
 		await ready;

package/dist/export.d.ts

@@ -1,4 +1,4 @@
-import { SelfHostedResult, SiteProblem } from "@goodfellow-cms/core";
+import { PluginTaskRequest, SelfHostedResult, SiteProblem, TaskResultFile } from "@goodfellow-cms/core";
 import { SiteFile } from "@goodfellow-cms/core/node";
 //#region src/site-files.d.ts
 /**
@@ -26,6 +26,21 @@ export declare function writeFeedFiles(outDir: string, root?: string): Promise<n
  * code, such as `es/feeds/`.
  */
 export declare function buildFileFolders(root?: string): Promise<string[]>;
+/** What `writePluginFiles()` wrote and ran. */
+export interface PluginFilesWritten {
+  /** The plugins whose admin frames were written. */
+  frames: string[];
+  /** The build steps that ran, as `plugin: step`. */
+  steps: string[];
+}
+/**
+ * Plugins' parts that builds make: each plugin's admin frame, beside the
+ * editor's frames at `admin/plugins/<id>/`, and its build steps, each in a
+ * process of its own held to what the plugin declared. Into a static export
+ * (`outDir`), or a full-stack site's `public/`, where `next start` serves
+ * them. The config is loaded outside Next.js only when it lists plugins.
+ */
+export declare function writePluginFiles(outDir: string, root?: string): Promise<PluginFilesWritten>;
 /** What `writeFontFiles()` did, for `buildNotes()`. */
 export interface FontsWritten {
   fonts?: SelfHostedResult;
@@ -118,4 +133,11 @@ export declare function exportedPages(outDir: string): Promise<BuiltPage[]>;
  * Pages that aren't the site's, such as Next.js's own, are left out.
  */
 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. Secrets are
+ * taken out of the environment before the config loads.
+ */
+export declare function writeTaskResult(root: string, request: PluginTaskRequest, out?: string): Promise<TaskResultFile>;
 //#endregion

package/dist/export.js

@@ -1,6 +1,7 @@
+import { i as loadSiteConfig, n as buildPluginFrames, r as configHasPlugins } from "./plugins-eLJalBij.js";
 import { r as NEXT_SITE_FILES } from "./site-files-BeLnLxCl.js";
-import { CALENDARS_DIR, CLOUDFLARE_REDIRECTS_PATH, EDITOR_PRELUDE, FEEDS_DIR, SITE_DESCRIPTION_PATH, 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 { CALENDARS_DIR, CLOUDFLARE_REDIRECTS_PATH, EDITOR_PRELUDE, FEEDS_DIR, SITE_DESCRIPTION_PATH, TASK_RESULT_FILE, absoluteUrl, allPages, calendarFiles, cloudflareRedirects, editorPolicy, feedFiles, hasLanguages, loadSiteContent, parseSiteDescription, pathLanguage, pluginId, redirectFiles, rootRobotsUrl, sealTaskAnswer, shownContent, siteLanguages, taskRequestProblem } from "@goodfellow-cms/core";
+import { BUILD_DATES_DIR, fileSystemSource, guardBuiltSite, reportedDate, runPluginBuildSteps, runPluginTask, selfHostFonts, taskSecretsFrom, writeBuildRecord } from "@goodfellow-cms/core/node";
 import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import { createHash } from "node:crypto";
@@ -51,6 +52,36 @@ async function exportBasePath(root) {
 		return "";
 	}
 }
+/**
+* Plugins' parts that builds make: each plugin's admin frame, beside the
+* editor's frames at `admin/plugins/<id>/`, and its build steps, each in a
+* process of its own held to what the plugin declared. Into a static export
+* (`outDir`), or a full-stack site's `public/`, where `next start` serves
+* them. The config is loaded outside Next.js only when it lists plugins.
+*/
+async function writePluginFiles(outDir, root = process.cwd()) {
+	const site = resolve(root);
+	if (!await configHasPlugins(site)) return {
+		frames: [],
+		steps: []
+	};
+	const config = await loadSiteConfig(site);
+	const base = `${await exportBasePath(site)}/`;
+	const dir = resolve(site, outDir);
+	return {
+		frames: await buildPluginFrames(config.plugins, {
+			root: site,
+			outDir: dir
+		}),
+		steps: (await runPluginBuildSteps({
+			root: site,
+			outDir: dir,
+			base,
+			plugins: config.plugins ?? [],
+			onStep: (step) => console.log(`Running ${step.title}, from ${step.plugin}…`)
+		})).map((step) => `${step.plugin}: ${step.title}`)
+	};
+}
 async function exists(path) {
 	return access(path).then(() => true, () => false);
 }
@@ -294,5 +325,38 @@ 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. Secrets are
+* taken out of the environment before the config loads.
+*/
+async function writeTaskResult(root, request, out = TASK_RESULT_FILE) {
+	const secrets = taskSecretsFrom(process.env);
+	const problem = taskRequestProblem(request);
+	if (problem) throw new Error(problem);
+	let answer;
+	try {
+		const plugin = ((await loadSiteConfig(resolve(root))).plugins ?? []).find((candidate) => pluginId(candidate.name) === request.plugin);
+		answer = plugin ? await runPluginTask({
+			root: resolve(root),
+			plugin,
+			task: request.task,
+			input: request.input,
+			secrets
+		}) : {
+			ok: false,
+			error: `The site has no plugin ${request.plugin}.`
+		};
+	} catch (error) {
+		answer = {
+			ok: false,
+			error: `The site couldn't run the task: ${error instanceof Error ? error.message : error}`
+		};
+	}
+	const sealed = await sealTaskAnswer(answer, request.key);
+	await writeFile(resolve(root, out), `${JSON.stringify(sealed)}\n`);
+	return sealed;
+}
 //#endregion
-export { EDITOR_PAGES, NEXT_SITE_FILES, buildFileFolders, builtPages, checkPages, exportedPages, fixSegmentFiles, guardExport, writeBuildRecordFile, writeCalendarFiles, writeEditorPolicy, writeFeedFiles, writeFontFiles, writePageLanguages, writeRedirectFiles };
+export { EDITOR_PAGES, NEXT_SITE_FILES, buildFileFolders, builtPages, checkPages, exportedPages, fixSegmentFiles, guardExport, writeBuildRecordFile, writeCalendarFiles, writeEditorPolicy, writeFeedFiles, writeFontFiles, writePageLanguages, writePluginFiles, writeRedirectFiles, writeTaskResult };

package/dist/index.js

@@ -1,5 +1,5 @@
 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 { absoluteUrl, colorSchemeMeta, colorSchemeScript, contentForPage, demoContent, feedLinks, findRedirect, fontPreloads, googleFontsUrl, hasLanguages, languageMap, loadSiteContent, normalizePagePath, pageHead, shownContent, siteLanguages, sitePages, sitemapPages, storedMediaSizes, themeToCss, todayIn, withBase } from "@goodfellow-cms/core";
 import { BUILD_DATES_ENV, fileSystemSource, fontStandIns, readMediaSizes, readStylesheet, reportDatesTo } from "@goodfellow-cms/core/node";
 import { BodyCode, HeadCode, PageBody, PageContent, PageFooter, PageHeader, adminSite, applyPageEntry, createPuckConfigs, describeSite, prepareLayout, preparePage } from "@goodfellow-cms/react";
 import { notFound, redirect } from "next/navigation";
@@ -87,7 +87,10 @@ function goodfellowPages(config, options = {}) {
 	const renderOptions = async () => ({
 		base: basePath(),
 		components,
-		media: await readMediaSizes(root)
+		media: {
+			...await readMediaSizes(root),
+			...storedMediaSizes((await site()).mediaStorage)
+		}
 	});
 	/** The site's theme and fonts, which React moves into the document's head. themeToCss escapes its output. */
 	async function Theme({ content }) {

package/dist/plugins-eLJalBij.js

@@ -0,0 +1,191 @@
+import { EDITOR_PRELUDE, INSTALLED_PLUGINS_INDEX, PLUGINS_PATH, framedPlugins, pluginFrameEntry, pluginFramePage, pluginId } from "@goodfellow-cms/core";
+import { LICENSES_FILE, licensesPlugin } from "@goodfellow-cms/core/node";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/plugins.ts
+/**
+* Plugins on Next.js sites: their admin frames, bundled with Rolldown as
+* `next dev` bundles the editor's frames, and their build steps, both run by
+* `goodfellow-next finish` from the site's config, which Next.js alone
+* bundles otherwise. Node only.
+*/
+var plugins_exports = /* @__PURE__ */ __exportAll({
+	buildPluginFrame: () => buildPluginFrame,
+	buildPluginFrames: () => buildPluginFrames,
+	configHasPlugins: () => configHasPlugins,
+	findConfigFile: () => findConfigFile,
+	loadSiteConfig: () => loadSiteConfig
+});
+const CONFIG_FILES = [
+	"goodfellow.config.tsx",
+	"goodfellow.config.ts",
+	"goodfellow.config.jsx",
+	"goodfellow.config.js"
+];
+const FRAME_ENTRY = "\0goodfellow:plugin-frame";
+function findConfigFile(root) {
+	return CONFIG_FILES.map((name) => join(root, name)).find((file) => existsSync(file));
+}
+/**
+* Whether the site's config lists plugins, read from its text, so builds of
+* sites without any never load the config outside Next.js: plugins of its
+* own, or any installed from the admin panel, which `plugins/installed/`
+* lists.
+*/
+async function configHasPlugins(root) {
+	const file = findConfigFile(root);
+	const listed = file && /\bplugins\s*:\s*([^\n]*)/.exec(await readFile(file, "utf8"))?.[1];
+	if (!listed) return false;
+	if (!/^installedPlugins\s*,?$/.test(listed.trim())) return true;
+	const index = join(root, INSTALLED_PLUGINS_INDEX);
+	return existsSync(index) && /\binstalledPlugin\(/.test(await readFile(index, "utf8"));
+}
+/**
+* The site's config, loaded in Node: bundled with Rolldown, with the
+* packages it imports left for Node to load and stylesheets left out, then
+* imported. Only what plugins need is read from it.
+*/
+async function loadSiteConfig(root) {
+	const configFile = findConfigFile(root);
+	if (!configFile) throw new Error(`No goodfellow.config.tsx in ${root}.`);
+	const { build } = await import("rolldown");
+	const outDir = join(root, "node_modules/.goodfellow");
+	await mkdir(outDir, { recursive: true });
+	const file = join(outDir, `config-${process.pid}-${Date.now()}.mjs`);
+	await build({
+		input: configFile,
+		cwd: root,
+		platform: "node",
+		tsconfig: existsSync(join(root, "tsconfig.json")) ? join(root, "tsconfig.json") : false,
+		transform: { jsx: { runtime: "automatic" } },
+		external: (id, _importer, resolved) => resolved ? /[\\/]node_modules[\\/]/.test(id) : !id.startsWith(".") && !isAbsolute(id) && !id.startsWith("@/"),
+		plugins: [{
+			name: "goodfellow:no-styles",
+			load: (id) => id.endsWith(".css") ? {
+				code: "",
+				moduleType: "js"
+			} : void 0
+		}],
+		onLog(level, log, handler) {
+			if (log.code === "MODULE_LEVEL_DIRECTIVE") return;
+			handler(level, log);
+		},
+		output: {
+			file,
+			format: "esm",
+			codeSplitting: false
+		}
+	});
+	try {
+		return (await import(pathToFileURL(file).href)).default;
+	} finally {
+		await rm(file, { force: true });
+	}
+}
+/** A plugin's admin module as the bundler imports it: a package's export, or a path from the site's root. */
+function adminModule(root, specifier) {
+	return specifier.startsWith("./") || specifier.startsWith("../") ? resolve(root, specifier) : specifier;
+}
+/**
+* Bundles a plugin's admin module into its frame, at `admin/plugins/<id>/`
+* under `outDir`: one classic script starting with `EDITOR_PRELUDE`, its
+* stylesheets in one file, `pluginFramePage()`, whose Content Security
+* Policy reaches only the addresses the plugin declared, and the notices of
+* what it bundles (`LICENSES_FILE`). Answers a function that stops rebuilding.
+*/
+async function buildPluginFrame(plugin, { root, dir, watch }) {
+	if (!plugin.admin) throw new Error(`${plugin.name} has no admin module.`);
+	const rolldown = await import("rolldown");
+	await mkdir(dir, { recursive: true });
+	const stylesheets = /* @__PURE__ */ new Set();
+	const writePage = async () => {
+		const css = await Promise.all([...stylesheets].map((file) => readFile(file, "utf8")));
+		await writeFile(join(dir, "plugin.css"), css.join("\n"));
+		await writeFile(join(dir, "index.html"), pluginFramePage({
+			permissions: plugin.permissions ?? {},
+			scripts: ["plugin.js"],
+			stylesheets: ["plugin.css"],
+			licenses: LICENSES_FILE
+		}));
+	};
+	const options = {
+		input: { plugin: FRAME_ENTRY },
+		cwd: root,
+		platform: "browser",
+		tsconfig: existsSync(join(root, "tsconfig.json")) ? join(root, "tsconfig.json") : false,
+		transform: {
+			jsx: { runtime: "automatic" },
+			define: { "process.env.NODE_ENV": JSON.stringify(watch ? "development" : "production") }
+		},
+		plugins: [{
+			name: "goodfellow:plugin-frame",
+			resolveId: (id) => id === FRAME_ENTRY ? id : void 0,
+			load(id) {
+				if (id === FRAME_ENTRY) return pluginFrameEntry(adminModule(root, plugin.admin ?? ""));
+				if (id.endsWith(".css")) {
+					stylesheets.add(id);
+					return {
+						code: "",
+						moduleType: "js"
+					};
+				}
+			}
+		}, licensesPlugin(plugin.title, LICENSES_FILE)],
+		onLog(level, log, handler) {
+			if (log.code === "MODULE_LEVEL_DIRECTIVE") return;
+			handler(level, log);
+		},
+		output: {
+			dir,
+			format: "iife",
+			codeSplitting: false,
+			entryFileNames: "plugin.js",
+			banner: EDITOR_PRELUDE,
+			...watch ? { sourcemap: true } : { minify: true }
+		}
+	};
+	if (!watch) {
+		await rolldown.build(options);
+		await writePage();
+		return async () => {};
+	}
+	const watcher = rolldown.watch(options);
+	watcher.on("event", (event) => {
+		if (event.code === "BUNDLE_END") {
+			event.result.close();
+			writePage().then(() => watch.onBuilt(), (error) => watch.onBuilt(error));
+		} else if (event.code === "ERROR") {
+			event.result?.close();
+			watch.onBuilt(event.error);
+		}
+	});
+	return () => watcher.close();
+}
+/** Builds every plugin's admin frame into `admin/plugins/<id>/` in `outDir`. Answers the plugins' names. */
+async function buildPluginFrames(plugins, { root, outDir }) {
+	const built = [];
+	for (const plugin of framedPlugins(plugins)) {
+		await buildPluginFrame(plugin, {
+			root,
+			dir: join(outDir, PLUGINS_PATH, pluginId(plugin.name))
+		});
+		built.push(plugin.name);
+	}
+	return built;
+}
+//#endregion
+export { plugins_exports as a, loadSiteConfig as i, buildPluginFrames as n, configHasPlugins as r, buildPluginFrame as t };

package/dist/server.d.ts

@@ -31,6 +31,13 @@ export interface GoodfellowApiOptions {
   ai?: ServerKeys;
   /** Told about failures editors only hear about as "something went wrong". Defaults to `console.error`. */
   onError?: (error: unknown) => void;
+  /**
+   * The server modules of the config's plugins, by plugin name, imported in
+   * the route's file, such as `{ "goodfellow-plugin-s3": s3Server }` from
+   * `import s3Server from "goodfellow-plugin-s3/server"`. Each answers
+   * `plugins/<id>/…`, and runs with everything the server has.
+   */
+  plugins?: AppApiOptions["plugins"];
 }
 /** The route parameters of a catch-all route named `[...path]`. */
 interface RouteContext {

package/dist/server.js

@@ -31,7 +31,8 @@ function goodfellowApi(options) {
 			signIn: options.signIn,
 			...options.signOut && { signOut: options.signOut },
 			...ai && ai.services.length > 0 && { ai },
-			...options.onError && { onError: options.onError }
+			...options.onError && { onError: options.onError },
+			...options.plugins && { plugins: options.plugins }
 		});
 		return api;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfellow-cms/next",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Goodfellow pages and the admin panel in a Next.js site.",
   "keywords": [
     "goodfellow",
@@ -63,22 +63,23 @@
     "dist"
   ],
   "dependencies": {
-    "@goodfellow-cms/ai": "0.5.0",
-    "@goodfellow-cms/core": "0.5.0",
-    "@goodfellow-cms/react": "0.5.0",
+    "@goodfellow-cms/ai": "0.6.0",
+    "@goodfellow-cms/core": "0.6.0",
+    "@goodfellow-cms/react": "0.6.0",
     "rolldown": "1.2.12"
   },
   "peerDependencies": {
-    "@goodfellow-cms/admin": "0.5.0",
+    "@goodfellow-cms/admin": "0.6.0",
     "@puckeditor/core": "0.23.0",
     "next": "^16.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@goodfellow-cms/admin": "0.5.0",
-    "@goodfellow-cms/github": "0.5.0",
-    "@goodfellow-cms/gitlab": "0.5.0",
+    "@goodfellow-cms/admin": "0.6.0",
+    "@goodfellow-cms/bitbucket": "0.6.0",
+    "@goodfellow-cms/github": "0.6.0",
+    "@goodfellow-cms/gitlab": "0.6.0",
     "@puckeditor/core": "0.23.0",
     "@tailwindcss/browser": "4.3.3",
     "@types/react": "^19.2.0",