@goodfellow-cms/admin 0.4.0 → 0.5.0

package/dist/entry-values-ocbalc9U.js

@@ -0,0 +1,3952 @@
+import { COLOR_SCHEME_ATTRIBUTE, ConflictError, DraftError, FOOTER_FILE, GOODFELLOW_REGISTRY, HEADER_FILE, MAX_UPLOAD_BYTES, MEDIA_DIR, MENUS_FILE, REDIRECTS_FILE, SHADCN_NAMESPACE, SHADCN_REGISTRY, SITE_FILE, ScheduledBuildsError, SignInError, addressPatternFor, adminOrigin, allPages, checkEntrySlug, checkPageAddress, checkSite, codeFileChanges, collectionFileChange, collectionFileChange as collectionFileChange$1, customCssFileChange, deleteCollectionChanges, describedConfig, duplicatePageData, entryFileChange, entryFileChange as entryFileChange$1, entryLanguage, entryPathIn, entryTitle, escapeStyleText, extensionOf, fileName, goodfellowRegistryUrl, googleFontsUrl, isDemoStore, keptDrafts, layoutFileChange, loadSiteContent, markdownToHtml, mediaFileChange, mediaKind, mediaKind as mediaKind$1, memoryKeeper, menusFileChange, moveEntryChanges, movePageChanges, newCollectionSettings, newDraftName, newPageData, outsideHost, pageFileChange, pageTitle, publishProblems, redirectsFileChange, relinkSite, relinkedChanges, scheduleOf, scheduleProblem, scheduleState, siteLanguages, siteSettingsFileChange, slugify, storedCss, storedData, storedEntryFields, themeToCss, todayIn, trimChars, uniqueName, upcomingChanges, updateSettingsFileChange, uploadName, wallClock, withoutCredits, writeChanges } from "@goodfellow-cms/core";
+import { createContext, useCallback, useContext, useEffect, useId, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region src/markdown-text.ts
+let service;
+/** Converts the formatted editor's HTML to Markdown, in the style most Markdown is written in. */
+function htmlToMarkdown(html) {
+	if (!service) {
+		service = new TurndownService({
+			headingStyle: "atx",
+			bulletListMarker: "-",
+			codeBlockStyle: "fenced",
+			emDelimiter: "*",
+			strongDelimiter: "**",
+			hr: "---"
+		});
+		service.use(gfm);
+		service.addRule("underline", {
+			filter: ["u"],
+			replacement: (content) => content
+		});
+		service.addRule("strikethrough", {
+			filter: ["del", "s"],
+			replacement: (content) => `~~${content}~~`
+		});
+		service.addRule("listItem", {
+			filter: "li",
+			replacement(content, node) {
+				const parent = node.parentNode;
+				let marker = "- ";
+				if (parent?.nodeName === "OL") marker = `${Number(parent.getAttribute("start") ?? "1") + Array.prototype.indexOf.call(parent.children, node)}. `;
+				const indent = " ".repeat(marker.length);
+				const text = content.replace(/^\n+/, "").replace(/\n+$/, "").replace(/\n/g, `\n${indent}`);
+				return `${marker}${text}${node.nextSibling ? "\n" : ""}`;
+			}
+		});
+	}
+	return service.turndown(html).replace(/[ \t]+$/gm, "").trim();
+}
+/** The HTML the formatted editor starts from for some Markdown. */
+function formattedHtml(markdown) {
+	return markdownToHtml(markdown);
+}
+/**
+* The Markdown to save after the formatted editor changed `html`. If the text
+* is the same as `original`'s, only written differently (the formatted editor
+* tidies what it loads), `original` is kept, so the file isn't rewritten.
+*/
+function editedMarkdown(original, html) {
+	const edited = htmlToMarkdown(html);
+	return edited === htmlToMarkdown(formattedHtml(original)) ? original : edited;
+}
+//#endregion
+//#region src/changes.ts
+/**
+* The file changes the admin panel saves. Most are built by core's helpers,
+* which the Claude connector shares; converting a collection's items between
+* Markdown and formatted text needs the browser's HTML handling, so it's here.
+*/
+/**
+* A stored value as it fits its collection's field now, or `undefined` if it
+* doesn't: the field must exist, and a choice must still be offered. Tags
+* keep the ones that still are.
+*/
+function keptValue(fields, name, value) {
+	const field = fields.get(name);
+	if (!field) return void 0;
+	const offered = (choice) => field.options?.some((option) => option.value === choice) === true;
+	if (field.type === "select") return offered(value) ? value : void 0;
+	if (field.type === "tags" && Array.isArray(value)) {
+		const tags = value.filter(offered);
+		if (tags.length === value.length) return value;
+		return tags.length > 0 ? tags : void 0;
+	}
+	return value;
+}
+/** Where each item's page goes when its collection's address patterns change, in each of the site's languages. */
+function movedEntryPages(site, collection, settings) {
+	if (!collection.settings.path || !settings.path) return [];
+	return collection.entries.flatMap((entry) => {
+		const to = entryPathIn(site, settings, entry.slug, entryLanguage(site, entry));
+		return entry.path && to && to !== entry.path ? [{
+			from: entry.path,
+			to
+		}] : [];
+	});
+}
+/**
+* Saves a collection's new settings. Values of fields that were removed, and
+* choices that are no longer offered, are removed from every entry in the
+* same save, so a field added later with the same name starts empty. Given
+* the `site`, a new address pattern points every link to an item's page at
+* its new address, in the same save.
+*/
+function collectionSettingsChanges(collection, settings, site) {
+	const relinked = site ? relinkSite({
+		...site.content,
+		collections: site.content.collections.map((candidate) => candidate.id === collection.id ? {
+			...collection,
+			settings: {
+				...collection.settings,
+				template: settings.template
+			}
+		} : candidate)
+	}, movedEntryPages(site.content.settings, collection, settings), site.blocks) : void 0;
+	const current = relinked?.content.collections.find((candidate) => candidate.id === collection.id) ?? collection;
+	const relinkedFiles = new Set(relinked?.files);
+	const fields = new Map(settings.fields.map((field) => [field.name, field]));
+	const changes = [collectionFileChange(collection.id, {
+		...settings,
+		template: current.settings.template
+	})];
+	const before = collection.settings.markdown?.body;
+	const after = settings.markdown?.body;
+	const reformat = before !== after;
+	for (const entry of current.entries) {
+		const values = Object.entries(entry.content.fields);
+		const remaining = values.flatMap(([name, value]) => {
+			const kept = keptValue(fields, name, value);
+			return kept === void 0 ? [] : [[name, kept]];
+		});
+		if (!(remaining.length !== values.length || remaining.some(([name, value]) => value !== entry.content.fields[name])) && !reformat && !relinkedFiles.has(entry.file)) continue;
+		const kept = Object.fromEntries(remaining);
+		if (reformat) {
+			if (before !== void 0 && typeof kept[before] === "string") kept[before] = formattedHtml(kept[before]);
+			if (after !== void 0 && typeof kept[after] === "string") kept[after] = htmlToMarkdown(kept[after]);
+		}
+		const change = entryFileChange({
+			id: collection.id,
+			settings
+		}, entry.slug, kept, entry.content);
+		if (change.path !== entry.file) changes.push({
+			path: entry.file,
+			delete: true
+		});
+		changes.push(change);
+	}
+	if (relinked) changes.push(...relinkedChanges(relinked, [collection.file, ...collection.entries.map((entry) => entry.file)]));
+	return changes;
+}
+//#endregion
+//#region src/media.ts
+/** Files in `public/media/` are served from `/media/` on the site. */
+const MEDIA_URL_PREFIX = "/media/";
+/** `public/media/photo.jpg` → `/media/photo.jpg`. */
+function mediaUrl(path) {
+	return `${MEDIA_URL_PREFIX}${path.slice(MEDIA_DIR.length + 1)}`;
+}
+/** `/media/photo.jpg` → `public/media/photo.jpg`, or `undefined` for addresses outside the media folder. */
+function mediaPath(url) {
+	if (!url.startsWith("/media/")) return void 0;
+	const rest = url.slice(7).split(/[?#]/)[0] ?? "";
+	if (!rest || rest.split("/").some((part) => part === "" || part === "." || part === "..")) return void 0;
+	return `${MEDIA_DIR}/${decodeURIComponent(rest)}`;
+}
+/** Where a media file is used, by name, so editors know what deleting or replacing it affects. */
+function mediaUsage(content, url, names) {
+	const uses = (value) => JSON.stringify(value).includes(url);
+	const used = [];
+	if (uses(content.settings)) used.push(names.settings);
+	if (uses(content.header)) used.push(names.header);
+	if (uses(content.footer)) used.push(names.footer);
+	for (const page of content.pages) if (uses(page.content)) used.push(pageTitle(page));
+	for (const collection of content.collections) {
+		if (uses(collection.settings)) used.push(collection.settings.name);
+		for (const entry of collection.entries) if (uses(entry.content)) used.push(entryTitle(entry));
+	}
+	if (content.customCss.includes(url)) used.push(names.css);
+	return used;
+}
+/** The addresses of the site's uploaded images, such as `/media/photo.jpg`. */
+function siteImages(media) {
+	return media.filter((path) => mediaKind(path) === "image").map(mediaUrl);
+}
+//#endregion
+//#region src/site-code.ts
+/**
+* What the admin panel needs the site's own code for: the pages its blocks add
+* (a calendar's months, a list's later pages), and pages rendered to check a
+* publish. The admin panel's page never runs that code: it asks the frame that
+* does (`frameSiteCode()` in `frame/host.tsx`), which answers with `localSiteCode()` (`frame/local-code.ts`).
+*/
+/** The page at an address, as `findSitePage()` gives it: a page a build writes, or "Page not found". */
+async function findPage(code, content, today, path) {
+	const pages = await code.sitePages(content, today);
+	const page = pages.find((candidate) => candidate.path === path);
+	if (page) return {
+		page,
+		status: 200
+	};
+	const notFound = pages.find((candidate) => candidate.path === "/404");
+	return notFound && {
+		page: notFound,
+		status: 404
+	};
+}
+/**
+* The pages a publish changes, each with the file its own content comes from:
+* a page or item, an item's page for its collection's design, and the home
+* page for the header and footer.
+*/
+function pagesToRender(content, changed) {
+	const pages = allPages(content);
+	const targets = pages.filter((page) => changed.has(page.file)).map((page) => ({
+		page,
+		file: page.file
+	}));
+	for (const collection of content.collections) {
+		if (!changed.has(collection.file)) continue;
+		const first = pages.find((page) => page.entry?.collection === collection.id);
+		if (first && !targets.some((target) => target.page === first)) targets.push({
+			page: first,
+			file: collection.file
+		});
+	}
+	if ((changed.has(HEADER_FILE) || changed.has(FOOTER_FILE)) && targets.length === 0) {
+		const home = pages.find((page) => page.path === "/") ?? pages[0];
+		if (home) targets.push({
+			page: home,
+			file: home.file
+		});
+	}
+	return targets.slice(0, 10);
+}
+//#endregion
+//#region src/site-checks.ts
+/** The media library's files as the addresses content uses, such as `/media/photo.jpg`. */
+function mediaAddresses(paths) {
+	return [...paths].filter((path) => path.startsWith(`${MEDIA_DIR}/`)).map(mediaUrl);
+}
+/** The site as it would be once the changes are published, read like the site itself. */
+function contentWithChanges(source, changes) {
+	const changed = new Map(changes.map((change) => [change.path, change]));
+	return loadSiteContent({
+		read: async (path) => {
+			const change = changed.get(path);
+			if (!change) return source.read(path);
+			return "content" in change ? change.content : void 0;
+		},
+		list: async (dir) => {
+			const listed = new Set(await source.list(dir));
+			for (const change of changes) {
+				if (!change.path.startsWith(`${dir}/`)) continue;
+				if ("delete" in change) listed.delete(change.path);
+				else listed.add(change.path);
+			}
+			return [...listed];
+		}
+	});
+}
+/**
+* The site checks for a publish: the site as it's loaded, and as the changes
+* would leave it, with the pages they change rendered. A site the changes
+* would leave unreadable isn't checked; loading it again after publishing
+* says what's wrong.
+*/
+async function checkPublish(source, loaded, changes, site) {
+	const { blocks, code } = site;
+	let after;
+	try {
+		after = await contentWithChanges(source, changes);
+	} catch {
+		return {
+			blocking: [],
+			warnings: [],
+			content: loaded.content
+		};
+	}
+	const media = new Set(loaded.media);
+	for (const change of changes) if ("delete" in change) media.delete(change.path);
+	else if ("bytes" in change) media.add(change.path);
+	const today = todayIn(after.settings.timeZone);
+	const changed = new Set(changes.map((change) => change.path));
+	const [pagesBefore, pagesAfter, rendered] = await Promise.all([
+		code.sitePages(loaded.content, today).catch(() => allPages(loaded.content)),
+		code.sitePages(after, today).catch(() => allPages(after)),
+		code.renderedProblems(after, pagesToRender(after, changed), today).catch(() => [])
+	]);
+	const before = checkSite(loaded.content, {
+		media: mediaAddresses(loaded.media),
+		blocks,
+		pages: pagesBefore
+	});
+	const problems = [...checkSite(after, {
+		media: mediaAddresses(media),
+		blocks,
+		pages: pagesAfter
+	}), ...rendered];
+	return {
+		...publishProblems(before, problems, changed),
+		content: after
+	};
+}
+/** Where a problem is, as the admin panel names it, such as `The page "About us"`. */
+function problemPlace(t, content, file) {
+	if (file === HEADER_FILE) return t("checks.place.header");
+	if (file === FOOTER_FILE) return t("checks.place.footer");
+	if (file === MENUS_FILE) return t("checks.place.menus");
+	if (file === SITE_FILE) return t("checks.place.settings");
+	if (file === REDIRECTS_FILE) return t("checks.place.redirects");
+	const page = content.pages.find((candidate) => candidate.file === file);
+	if (page) return t("checks.place.page", { title: pageTitle(page) });
+	for (const collection of content.collections) {
+		if (collection.file === file) return t("checks.place.design", { collection: collection.settings.name });
+		const entry = collection.entries.find((candidate) => candidate.file === file);
+		if (entry) return t("checks.place.entry", {
+			title: entryTitle(entry),
+			collection: collection.settings.name
+		});
+	}
+	return t("checks.place.file", { file });
+}
+/** What a theme color problem means, which needs no content to say. */
+function describeContrast(t, problem) {
+	return t(problem.dark ? "checks.low-contrast.dark" : "checks.low-contrast", {
+		text: t(`theme.color.${problem.text}`),
+		background: t(`theme.color.${problem.background}`),
+		ratio: problem.ratio.toFixed(1)
+	});
+}
+/** One of the site's languages, as it's named in the switch. */
+function languageName$1(content, code) {
+	return siteLanguages(content.settings).find((language) => language.code === code)?.name ?? code;
+}
+/** What a problem means, in plain words. */
+function describeProblem(t, content, problem) {
+	switch (problem.kind) {
+		case "missing-page":
+		case "missing-media": return t(`checks.${problem.kind}`, {
+			place: problemPlace(t, content, problem.file),
+			target: problem.target
+		});
+		case "no-title":
+		case "no-description": return t(`checks.${problem.kind}`, { place: problemPlace(t, content, problem.file) });
+		case "bad-translation": return t("checks.bad-translation", {
+			place: problemPlace(t, content, problem.file),
+			target: problem.target
+		});
+		case "missing-translation":
+		case "outdated-translation": return t(`checks.${problem.kind}`, {
+			place: problemPlace(t, content, problem.file),
+			language: languageName$1(content, problem.language)
+		});
+		case "low-contrast": return describeContrast(t, problem);
+		case "no-alt": return t("checks.no-alt", {
+			place: problemPlace(t, content, problem.file),
+			image: problem.target.slice(problem.target.lastIndexOf("/") + 1) || problem.target
+		});
+		case "skipped-heading": return problem.previous === void 0 ? t("checks.skipped-heading.first", {
+			place: problemPlace(t, content, problem.file),
+			text: problem.text,
+			level: String(problem.level)
+		}) : t("checks.skipped-heading", {
+			place: problemPlace(t, content, problem.file),
+			text: problem.text,
+			level: String(problem.level),
+			previous: String(problem.previous)
+		});
+		case "vague-link": return t("checks.vague-link", {
+			place: problemPlace(t, content, problem.file),
+			text: problem.text
+		});
+		case "empty-link": return t("checks.empty-link", {
+			place: problemPlace(t, content, problem.file),
+			target: problem.target
+		});
+		case "accessibility": return t("checks.accessibility", {
+			place: problemPlace(t, content, problem.file),
+			help: problem.help
+		});
+	}
+}
+//#endregion
+//#region src/strings.tsx
+/**
+* Every piece of text the admin panel shows, so it can be reworded or
+* translated. `{name}` placeholders are filled in when the text is used.
+* Puck's own editor text is translated separately, with its `dictionary`.
+*/
+const defaultStrings = {
+	"app.title": "Site admin",
+	"app.viewSite": "View site",
+	"nav.pages": "Pages",
+	"nav.collections": "Collections",
+	"nav.media": "Media",
+	"nav.blocks": "Blocks",
+	"nav.layout": "Header & Footer",
+	"nav.settings": "Site Settings",
+	loading: "Loading…",
+	"setup.noBackend": "This site's settings don't say where the site is stored, so the admin panel can't open it. A developer needs to add a backend to goodfellow.config.tsx.",
+	"signIn.title": "Sign in to edit this site",
+	"signIn.intro": "The site is stored on {host}. Sign in with a {host} account that's allowed to change it.",
+	"signIn.redirect": "Sign in with {host}",
+	"signIn.orToken": "Or sign in with an access token",
+	"signIn.token.title": "Sign in with an access token",
+	"signIn.token.step1": "Create an access token on {host}. This link opens {host} with the right settings already chosen:",
+	"signIn.token.create": "Create a token on {host}",
+	"signIn.token.createBroad": "Create a broader token instead",
+	"signIn.token.createBroadHint": "Use this if the site belongs to someone else and the first link doesn't let you choose it. This kind of token can change everything your account can.",
+	"signIn.token.chooseSite": "If {host} asks what the token can access, choose this site.",
+	"signIn.token.step2": "Copy the token and paste it here:",
+	"signIn.token.label": "Access token",
+	"signIn.remember": "Stay signed in on this device",
+	"signIn.rememberHint": "Leave this off on shared or public computers.",
+	"signIn.submit": "Sign in",
+	"signIn.checking": "Signing in…",
+	"signIn.error.invalid": "That sign-in didn't work. Check that the whole token was copied and that it hasn't expired.",
+	"signIn.error.no-access": "That account can't see this site. Make sure the token was given access to it.",
+	"signIn.error.cant-publish": "That account can see the site but isn't allowed to change it. Ask the site's owner to give it permission.",
+	"signIn.error.redirect-failed": "Signing in didn't finish. Try again.",
+	"signIn.error.not-installed": "Goodfellow isn't installed on this site on {host} yet, so editors can't sign in with {host}. If you own the site, install it now, which signs you in too. Otherwise, ask an owner to, or sign in with an access token.",
+	"signIn.error.no-address": "Signing in with {host} needs the site's address in Site settings. Sign in with an access token for now, and add the address there.",
+	"signIn.error.wrong-address": "Signing in with {host} works only at the site's own address, as Site settings give it. Sign in there, or with an access token here.",
+	"signIn.error.local-address": "Signing in with {host} works only on the published site. Sign in with an access token here.",
+	"signIn.error.not-owner": "That account isn't an owner of this site on {host}.",
+	"signIn.error.unavailable": "Signing in with {host} isn't available right now, perhaps because it's been used as much as it can be today. Sign in with an access token instead.",
+	"signIn.install": "Install Goodfellow on {host}",
+	"signIn.error.expired": "You were signed out because your sign-in expired. Sign in again to keep editing.",
+	"signIn.error.other": "Couldn't reach {host}. Check your connection and try again.",
+	"signIn.app.intro": "Sign in with your account on this site to edit it.",
+	"signIn.app.button": "Sign in",
+	"signIn.app.expired": "You've been signed out. Sign in again to keep editing.",
+	"signIn.app.notAllowed": "You're signed in, but your account isn't allowed to edit this site. Ask one of its owners to give you access.",
+	"signIn.app.error": "Couldn't reach the site. Check your connection and try again.",
+	"owners.only": "Only the site's owners can change this.",
+	"owners.onlyHint": "Ask one of them if something here needs changing.",
+	"account.signedInAs": "Signed in as {name}",
+	"account.signOut": "Sign out",
+	"deploy.building": "Updating the live site…",
+	"deploy.live": "The live site is up to date",
+	"deploy.failed": "The live site couldn't be updated",
+	"build.why": "What went wrong?",
+	"build.title": "Why the live site wasn't updated",
+	"build.saved": "Your changes are published and saved. Visitors see the site as it was until it's rebuilt, which every publish tries again.",
+	"build.notStarted": "{host} didn't start rebuilding the site. That usually means the account the site belongs to has used up its free build minutes for the month, or its billing on {host} needs attention. One of the site's owners can check the account's billing settings on {host}.",
+	"build.install": "The site's packages couldn't be installed, so it couldn't be rebuilt. That's sometimes a passing problem with the service the packages come from, so publishing again later may work. If it keeps happening, a developer needs to look at the details.",
+	"build.pages": "{host} Pages isn't set up for the site, so there's nowhere to put it online. One of the site's owners needs to turn it on in the site's settings on {host}, under Pages.",
+	"build.deploy": "The site was rebuilt, but {host} couldn't put it online. That's usually a passing problem, so the next publish may work. If it keeps happening, check the site's Pages settings on {host}.",
+	"build.host": "A problem on {host}'s side stopped the rebuild. That's usually a passing problem, so the next publish may work.",
+	"build.content": "The site couldn't be rebuilt, because {file} has a problem. Fix it in the admin panel, or put back a version that worked from its version history.",
+	"build.contentHistory": "Version history of {file}",
+	"build.codeChanged": "The site couldn't be rebuilt after its blocks changed. Undo the change under Blocks, by removing what was just added or adding back what was removed, and ask a developer to look at the details.",
+	"build.blocks": "Go to Blocks",
+	"build.codeFile": "The site's code couldn't be rebuilt: there's a problem in {file}. A developer needs to look at the details.",
+	"build.code": "The site couldn't be rebuilt. A developer needs to look at the details.",
+	"build.unknown": "{host} didn't say why the rebuild failed. Its details may help a developer.",
+	"build.hostDetails": "See the details on {host}",
+	"loadError.title": "The admin panel couldn't open this site",
+	"outdatedAdminPage.title": "This site's admin page needs updating",
+	"outdatedAdminPage.message": "This site's admin page is from before the editor kept blocks away from your sign-in, so the admin panel doesn't open on it. Goodfellow's next update changes it, unless someone has changed the page. Whoever looks after the site's code can also change it now: the details say how.",
+	"outdatedAdminPage.details": "Run npx goodfellow-next update, or replace these files with the Next.js starter's, as they are below. The site's blocks then run in the editor's sandboxed frames, at /admin/editor/.",
+	"loadError.contentProblems": "Some of the site's files have problems, so they can't be edited until they're fixed.",
+	"loadError.other": "Something went wrong while loading the site. Check your connection and try again.",
+	"action.tryAgain": "Try again",
+	"action.cancel": "Cancel",
+	"action.close": "Close",
+	"action.reload": "Reload",
+	"action.undo": "Undo",
+	"action.redo": "Redo",
+	"action.undoHint": "Undo the last change (Ctrl+Z, or ⌘Z on a Mac)",
+	"action.redoHint": "Redo what you undid (Ctrl+Shift+Z, or ⇧⌘Z on a Mac)",
+	"details.show": "Details",
+	"publish.button": "Publish",
+	"editor.leftSidebar": "Show or hide blocks and outline",
+	"editor.rightSidebar": "Show or hide settings",
+	"editor.viewport": "Preview width",
+	"editor.viewport.full": "Full width",
+	"editor.viewport.tablet": "Tablet",
+	"editor.viewport.phone": "Phone",
+	"editor.failed": "The editor stopped working. Reload the page to start it again.",
+	"editor.frame": "Editing {title}",
+	"publish.publishing": "Publishing…",
+	"publish.done": "Published.",
+	"publish.conflict": "Someone else changed the site since you opened this page, so your changes weren't published. Reload to see their changes, then make yours again.",
+	"publish.error": "Your changes couldn't be published. Check your connection and try again.",
+	"publish.invalid": "Fix the highlighted problems before publishing.",
+	"draft.label": "Draft",
+	"draft.add": "Add to draft",
+	"draft.addHint": "Keep this change with others to publish together later, instead of publishing it now",
+	"draft.adding": "Adding to the draft…",
+	"draft.added": "Added to the draft.",
+	"draft.banner": "You're working in a draft started {date}. What you change goes into it, and visitors see it when it's published.",
+	"draft.bannerKept": "You're working in a draft started {date}, kept in this browser. What you change goes into it, and visitors see it when it's published.",
+	"draft.changes": "{count} files changed",
+	"draft.oneChange": "1 file changed",
+	"draft.publishAll": "Publish all",
+	"draft.publishing": "Publishing the draft…",
+	"draft.published": "The draft is published.",
+	"draft.submit": "Submit for review",
+	"draft.submitted": "Submitted for review.",
+	"draft.seeReview": "See it",
+	"draft.discard": "Throw away",
+	"draft.discardTitle": "Throw away this draft?",
+	"draft.discardBody": "Everything in it will be lost. The live site stays as it is.",
+	"draft.leave": "Back to the live site",
+	"draft.waiting": "A draft started {date} is waiting to be published.",
+	"draft.waitingMany": "{count} drafts are waiting to be published.",
+	"draft.choose": "Draft to open",
+	"draft.started": "Started {date}",
+	"draft.open": "Open",
+	"draft.gone": "That draft has been published or thrown away.",
+	"draft.conflict": "Someone else has published changes to some of the same pages or settings since this draft started, so it can't be published as it is. Submit it for review, or throw it away and make the changes again.",
+	"draft.conflictKept": "Someone else has published changes to some of the same pages or settings since this draft started, so it can't be published as it is. Throw it away and make the changes again.",
+	"draft.error": "The draft couldn't be published. Check your connection and try again.",
+	"draft.submitError": "The draft couldn't be submitted for review. Check your connection and try again.",
+	"draft.discardError": "The draft couldn't be thrown away. Check your connection and try again.",
+	"draft.message": "Publish the draft {name}",
+	"draft.reviewTitle": "Draft {name}, from the admin panel",
+	"draft.reviewDescription": "Changes made in the admin panel:",
+	"checks.blocked.title": "This can't be published yet",
+	"checks.blocked.intro": "Publishing this would leave links that go nowhere. Change or remove them first.",
+	"checks.warnings.title": "Publish anyway?",
+	"checks.warnings.intro": "A few things could be better. You can publish anyway, or go back and fix them first.",
+	"checks.alsoWarnings": "These could be better too:",
+	"checks.publishAnyway": "Publish anyway",
+	"checks.goBack": "Go back",
+	"checks.missing-page": "{place} links to {target}, which isn't a page on the site.",
+	"checks.missing-media": "{place} uses {target}, which isn't in the media library.",
+	"checks.no-title": "{place} has no title, so browser tabs and search results show only the site's name.",
+	"checks.missing-translation": "{place} has no translation in {language} yet. Visitors reading in {language} are sent to its home page instead.",
+	"checks.outdated-translation": "{place} has changed since its translation in {language} was made. Update the translation, then mark it as up to date.",
+	"checks.bad-translation": "{place} says it's a translation of {target}, but only pages and items in the site's main language have translations.",
+	"checks.no-description": "{place} has no description for search results and link previews to show.",
+	"checks.low-contrast": "Text in \"{text}\" is hard to read on \"{background}\": its contrast is {ratio} to 1, and text needs at least 4.5 to 1.",
+	"checks.low-contrast.dark": "In dark mode, text in \"{text}\" is hard to read on \"{background}\": its contrast is {ratio} to 1, and text needs at least 4.5 to 1.",
+	"checks.no-alt": "{place} has an image, {image}, with no description for people who can't see it. Describe it in the image's settings, or say it's only decoration.",
+	"checks.skipped-heading": "{place} has the heading \"{text}\" at level {level}, after one at level {previous}. Headings shouldn't skip a level, or people who move through a page by its headings think they've missed something.",
+	"checks.skipped-heading.first": "{place} starts with the heading \"{text}\", at level {level}. Start with the page's title (level 1) or a section (level 2).",
+	"checks.vague-link": "{place} has a link, \"{text}\", that doesn't say where it goes. Say what people will find there, such as \"Our Mass times\" rather than \"Click here\".",
+	"checks.empty-link": "{place} has a link to {target} with no text, so people who can't see the page don't know where it goes.",
+	"checks.accessibility": "{place}: {help}",
+	"checks.place.page": "The page \"{title}\"",
+	"checks.place.entry": "\"{title}\" in {collection}",
+	"checks.place.design": "The design of {collection}",
+	"checks.place.header": "The header",
+	"checks.place.footer": "The footer",
+	"checks.place.menus": "A menu",
+	"checks.place.settings": "Site Settings",
+	"checks.place.redirects": "A redirect",
+	"checks.place.file": "{file}",
+	"unsaved.confirm": "You have changes that aren't published yet. Leave anyway and lose them?",
+	"unsaved.label": "Unpublished changes",
+	"pages.title": "Pages",
+	"pages.new": "New page",
+	"pages.empty": "This site has no pages yet.",
+	"pages.column.title": "Title",
+	"pages.column.address": "Address",
+	"pages.edit": "Edit",
+	"pages.move": "Change address",
+	"pages.duplicate": "Duplicate",
+	"pages.delete": "Delete",
+	"pages.view": "View",
+	"pages.homeCantDelete": "The home page can't be deleted.",
+	"pages.schedule": "Schedule",
+	"sharePreview.title": "When a link to this page is shared",
+	"sharePreview.noImage": "No image",
+	"sharePreview.noAddress": "Link previews show the image once the site's address is set in Site Settings, since they need its full address.",
+	"sharePreview.hidden": "This page is hidden from search engines, so it isn't in search results or the sitemap.",
+	"schedulePage.title": "When “{title}” is on the site",
+	"schedulePage.submit": "Publish",
+	"schedulePage.message": "Schedule page \"{title}\"",
+	"schedule.title": "When it's on the site",
+	"schedule.showFrom": "Show from",
+	"schedule.showFromHint": "Leave empty to show it as soon as it's published.",
+	"schedule.hideAfter": "Hide after",
+	"schedule.hideAfterHint": "Leave empty to keep it on the site.",
+	"schedule.zone": "Times are in the site's time zone, {zone}.",
+	"schedule.zoneNew": "Times are in your computer's time zone, {zone}, which becomes the site's time zone.",
+	"schedule.zoneNone": "Times are in UTC, since the site has no time zone. Choose one in Site Settings.",
+	"schedule.invalid": "Enter a date and a time.",
+	"schedule.order": "Choose a time after the one it's shown from.",
+	"schedule.timing.exact": "The site is rebuilt at each of these times, so changes go live then.",
+	"schedule.timing.hourly": "The site checks each hour for changes that are due, so changes go live within an hour of their time.",
+	"schedule.timing.nightly": "The site is rebuilt each night, so changes go live with the first rebuild after their time.",
+	"schedule.timing.none": "Changes go live the next time the site is rebuilt after their time, such as when someone publishes.",
+	"schedule.timing.notAllowed": "{host} didn't let you have the site rebuilt at these times, so changes go live with the nightly rebuild after their time, or at their time once an owner opens the admin panel.",
+	"schedule.public": "Anyone can read what's scheduled before it's shown, since the site's files on {host} are public. Don't schedule anything that must stay secret until then.",
+	"schedule.internal": "Anyone signed in to {host} can read what's scheduled before it's shown, since the site's files are visible to all of them. Don't schedule anything that must stay secret until then.",
+	"schedule.status.waiting": "Shown from {time}",
+	"schedule.status.hides": "Hidden after {time}",
+	"schedule.status.hidden": "Hidden since {time}",
+	"comingUp.title": "Coming up",
+	"comingUp.show": "Shown",
+	"comingUp.hide": "Hidden",
+	"comingUp.zone": "Times are in the site's time zone, {zone}.",
+	"newPage.title": "New page",
+	"newPage.pageTitle": "Page title",
+	"newPage.address": "Address",
+	"newPage.addressHint": "The part of the web address after the site's name, such as /about or /events/picnic.",
+	"newPage.create": "Create page",
+	"newPage.message": "Add page \"{title}\"",
+	"duplicatePage.title": "Duplicate \"{title}\"",
+	"duplicatePage.pageTitle": "{title} (copy)",
+	"duplicatePage.create": "Duplicate page",
+	"duplicatePage.message": "Add page \"{title}\", a copy of \"{from}\"",
+	"movePage.title": "Change the address of {title}",
+	"movePage.address": "New address",
+	"movePage.links": "Links to it anywhere on this site, menus included, change to the new address.",
+	"movePage.redirect": "Keep {from} working by sending visitors on to the page",
+	"movePage.redirectHint": "Links to the old address elsewhere, such as on other websites, keep working. Site Settings → Redirects lists it.",
+	"movePage.warning": "Links to the old address on other websites will stop working.",
+	"movePage.submit": "Change address",
+	"movePage.message": "Move page \"{title}\" from {from} to {to}",
+	"deletePage.title": "Delete {title}?",
+	"deletePage.body": "The page at {path} will be removed from the site. If anything on the site links to it, those links need changing first.",
+	"deletePage.submit": "Delete page",
+	"deletePage.message": "Delete page \"{title}\"",
+	"address.invalid": "Use lowercase letters, numbers and hyphens, with / between parts, such as /about-us.",
+	"address.reserved": "This address is used by the admin panel. Choose another.",
+	"address.taken": "Another page already uses this address.",
+	"field.required": "This can't be empty.",
+	"editPage.message": "Update page \"{title}\"",
+	"editPage.notFound": "This page doesn't exist. It may have been moved or deleted.",
+	"editPage.backToPages": "Back to pages",
+	"versions.button": "Version history",
+	"versions.title": "Version history: {title}",
+	"versions.back": "Back to editing",
+	"versions.intro": "Every version that's been published, newest first. Choose one to see it, then restore it to put it back. Something that was moved to a new address starts a new history there.",
+	"versions.notFound": "There's no history to show here. It may have been moved or deleted.",
+	"versions.local": "Version history is in the published site's admin panel, where you sign in with GitHub or GitLab.",
+	"versions.demo": "Version history isn't kept in a demo.",
+	"versions.loading": "Loading versions…",
+	"versions.loadingVersion": "Loading this version…",
+	"versions.error": "The versions couldn't be loaded. Check your connection and try again.",
+	"versions.empty": "Nothing has been published here yet.",
+	"versions.current": "Current version",
+	"versions.by": "{date}, by {author}",
+	"versions.more": "Show older versions",
+	"versions.preview": "The version from {date}",
+	"versions.noPreview": "This item has no page of its own, so there's nothing to preview.",
+	"versions.restore": "Restore this version",
+	"versions.restoreTitle": "Restore the version from {date}?",
+	"versions.restoreBody": "{title} goes back to how it was then, and that's published straight away. The current version stays in the history, so you can restore it later.",
+	"versions.restoring": "Restoring…",
+	"versions.restoreMessage": "Restore \"{title}\" to the version from {date}",
+	"versions.restored": "Restored the version from {date}.",
+	"versions.readError": "This version couldn't be loaded. Check your connection and try again.",
+	"versions.unfit": "This version can't be restored, because it doesn't fit the site as it is now, for example because the choices for one of its fields have changed.",
+	"versions.unknownBlocks": "This version can't be restored, because it uses blocks the site doesn't have any more: {blocks}.",
+	"layout.header": "Header",
+	"layout.footer": "Footer",
+	"layout.headerWord": "header",
+	"layout.footerWord": "footer",
+	"layout.headerMessage": "Update the header",
+	"layout.footerMessage": "Update the footer",
+	"collections.title": "Collections",
+	"collections.intro": "Collections are groups of similar items, such as videos, events or staff. Each collection has its own fields, and can give every item a page that shares one design.",
+	"collections.new": "New collection",
+	"collections.empty": "There are no collections yet.",
+	"collections.column.name": "Name",
+	"collections.column.count": "Items",
+	"collections.column.address": "Pages",
+	"collections.noPages": "No pages of their own",
+	"newCollection.title": "New collection",
+	"newCollection.kind": "Start with",
+	"newCollection.kindBlank": "A title and text",
+	"newCollection.kindEvents": "Events",
+	"newCollection.kindEventsHint": "Each item has a date and time, which can repeat, a place and a summary. Calendar blocks show them, and visitors can add them to their own calendars.",
+	"newCollection.eventsName": "Events",
+	"newCollection.eventsEntryName": "Event",
+	"newCollection.timeZone": "The site's time zone will be set to {zone}. You can change it in Site Settings.",
+	"newCollection.name": "Name",
+	"newCollection.nameHint": "What the whole collection is called, such as Videos or Events.",
+	"newCollection.nameTaken": "Another collection already has a name like this. Choose another.",
+	"newCollection.entryName": "One item is called",
+	"newCollection.entryNameHint": "Such as Video or Event.",
+	"newCollection.pages": "Give each item its own page",
+	"newCollection.address": "Address of the pages",
+	"newCollection.addressHint": "Each item's page goes inside this address, such as /videos/easter-vigil.",
+	"newCollection.create": "Create collection",
+	"newCollection.message": "Add collection \"{name}\"",
+	"collection.tab.entries": "Items",
+	"collection.tab.template": "Page design",
+	"collection.tab.settings": "Settings",
+	"collection.notFound": "This collection doesn't exist. It may have been deleted.",
+	"collection.back": "Back to collections",
+	"entries.add": "Add {entry}",
+	"entries.empty": "There's nothing in {name} yet.",
+	"entries.column.title": "Title",
+	"entries.column.address": "Address",
+	"newEntry.title": "Add {entry}",
+	"newEntry.entryTitle": "Title",
+	"newEntry.address": "Address",
+	"newEntry.addressHint": "The last part of the page's address, as in {example}.",
+	"newEntry.message": "Add {entry} \"{title}\"",
+	"entryName.invalid": "Use lowercase letters, numbers and hyphens only, such as easter-vigil.",
+	"entryName.reserved": "This address is used by the admin panel. Choose another.",
+	"entryName.taken": "Something else on the site already uses this address.",
+	"moveEntry.message": "Move {entry} \"{title}\" from {from} to {to}",
+	"deleteEntry.body": "{title} will be removed from {name}.",
+	"deleteEntry.bodyPage": "{title} will be removed from {name}, and its page at {path} from the site. If anything on the site links to it, those links need changing first.",
+	"deleteEntry.message": "Delete {entry} \"{title}\"",
+	"editEntry.message": "Update {entry} \"{title}\"",
+	"editEntry.invalidSchedule": "Check when it's on the site: each time needs a date and a time, and it can only be hidden after it's shown.",
+	"editEntry.notFound": "This item doesn't exist. It may have been renamed or deleted.",
+	"editEntry.back": "Back to {name}",
+	"editEntry.required": "Fill in {fields} before publishing.",
+	"editEntry.invalidEvent": "Check {fields}: an event has to end after it starts.",
+	"editEntry.noPage": "Items in {name} don't have pages of their own. They appear wherever a Collection list block shows {name}.",
+	"template.help": "Every item's page uses this design. To show an item's information, add an Entry field block, or type a field's name in braces in any text:",
+	"template.message": "Update the page design for {name}",
+	"template.noPages": "Items in {name} don't have pages of their own, so there's no page design. To give them pages, turn that on in Settings.",
+	"collectionSettings.markdown": "Store items as Markdown files",
+	"collectionSettings.markdownHint": "Each item's text is saved as Markdown, a plain-text format that developers can also edit in their own tools. It's edited here as before.",
+	"collectionSettings.markdownNeedsText": "To store items as Markdown files, add a formatted-text field first.",
+	"collectionSettings.markdownBody": "Field saved as the Markdown text",
+	"collectionSettings.markdownConverts": "Every item will be converted when you publish.",
+	"collectionSettings.calendar": "Show items in calendars",
+	"collectionSettings.calendarHint": "Items become events that Calendar blocks show, which visitors can add to their own calendars or subscribe to.",
+	"collectionSettings.calendarNeedsDate": "To show items in calendars, add a \"Date and time, for events\" field first.",
+	"collectionSettings.calendarWhen": "When items happen",
+	"collectionSettings.calendarPlace": "Where",
+	"collectionSettings.calendarSummary": "Summary",
+	"collectionSettings.calendarNone": "None",
+	"event.starts": "Starts",
+	"event.ends": "Ends (optional)",
+	"event.time": "Time",
+	"event.allDay": "All day",
+	"event.repeats": "Repeats",
+	"event.repeat.none": "Doesn't repeat",
+	"event.repeat.day": "Daily",
+	"event.repeat.week": "Weekly",
+	"event.repeat.month": "Monthly",
+	"event.repeat.year": "Yearly",
+	"event.interval.days": "Every how many days",
+	"event.interval.weeks": "Every how many weeks",
+	"event.interval.months": "Every how many months",
+	"event.interval.years": "Every how many years",
+	"event.onDays": "On",
+	"event.monthlyOn": "On",
+	"event.monthly.date": "Day {day} of the month",
+	"event.monthly.weekday": "The {nth} {weekday} of the month",
+	"event.monthly.last": "The last {weekday} of the month",
+	"event.nth.1": "first",
+	"event.nth.2": "second",
+	"event.nth.3": "third",
+	"event.nth.4": "fourth",
+	"event.nth.5": "fifth",
+	"event.until": "Until (optional)",
+	"event.skip": "Dates it doesn't happen",
+	"event.skipDate": "A date it doesn't happen",
+	"event.addSkip": "Skip this date",
+	"event.next": "Next: {when}",
+	"event.when": "{when}",
+	"collectionSettings.general": "General",
+	"collectionSettings.path": "Address of each item's page",
+	"collectionSettings.pathHint": "{slug} stands for each item's own address, as in /videos/{slug}.",
+	"collectionSettings.pathWarning": "Changing this changes the address of every item's page, and links to them on this site change with it. Links to the old addresses on other websites will stop working.",
+	"collectionSettings.sortField": "Order items by",
+	"collectionSettings.sortOrder": "Direction",
+	"collectionSettings.ascending": "A to Z, oldest or smallest first",
+	"collectionSettings.descending": "Z to A, newest or largest first",
+	"collectionSettings.message": "Update the settings for {name}",
+	"collectionSettings.addressClash": "With this address, {title} would have the same address as another page.",
+	"collectionSettings.delete": "Delete collection",
+	"collectionSettings.deleteTitle": "Delete {name}?",
+	"collectionSettings.deleteBody": "{name} and everything in it ({count} items) will be removed from the site, along with their pages. Collection lists showing it will be empty.",
+	"collectionSettings.deleteMessage": "Delete collection \"{name}\"",
+	"fields.title": "Fields",
+	"fields.intro": "The information each item has. Every item has a title. A field's kind can't be changed once it's published, but you can add a new field instead.",
+	"fields.add": "Add field",
+	"fields.label": "Label",
+	"fields.type": "Kind of information",
+	"fields.required": "Must be filled in",
+	"fields.hint": "Help text",
+	"fields.options": "Choices",
+	"fields.option": "Choice {number}",
+	"fields.addOption": "Add choice",
+	"fields.optionsRequired": "Add at least one choice.",
+	"fields.placeholder": "Show it on the page design with {placeholder}",
+	"fields.remove": "Remove field",
+	"fields.removed": "Removed fields are also removed from every item when you publish.",
+	"fields.newLabel": "New field",
+	"fields.type.text": "Short text",
+	"fields.type.textarea": "Long text",
+	"fields.type.richtext": "Formatted text",
+	"fields.type.number": "Number",
+	"fields.type.date": "Date",
+	"fields.type.event": "Date and time, for events",
+	"fields.type.link": "Link",
+	"fields.type.image": "Image (URL)",
+	"fields.type.select": "Choice from a list",
+	"fields.type.tags": "Tags (any number of choices from a list)",
+	"demo.banner": "This is a demo. Try anything you like: your changes show here in the admin panel and are saved in this browser only. The site itself never changes.",
+	"demo.published": "Saved in this browser. The site itself doesn't change in a demo.",
+	"demo.startOver": "Start over",
+	"demo.startOverTitle": "Start over?",
+	"demo.startOverBody": "Everything you've changed in this demo, including uploads, will be undone.",
+	"blocks.contentOnly": "This site's blocks are added by its developer.",
+	"blocks.contentOnlyHint": "Its code is kept apart from its content, so adding or removing a block is done where the code is, and shows up here once the site has been rebuilt.",
+	"blocks.demo": "In this demo you can see which blocks there are, but not add or remove them: a block is added to a real site by updating its code.",
+	"markdown.formatted": "Formatted",
+	"markdown.source": "Markdown",
+	"markdown.sourceOnly": "This text uses things the formatted view can't show, such as tables or pictures, so it can only be edited as Markdown.",
+	"blocks.title": "Blocks",
+	"blocks.intro": "Add blocks to the editor, or remove ones you don't use. A change shows in the editor once the site has been updated, usually within a few minutes.",
+	"blocks.otherRegistries": "Blocks from other registries can be added once the admin panel has an address of its own, where the site's pages can't reach it (Site Settings → Domain).",
+	"blocks.installed": "Added to this site",
+	"blocks.noneInstalled": "No blocks have been added yet. The editor offers the built-in ones.",
+	"blocks.loading": "Loading the blocks you can add…",
+	"blocks.recommended": "Recommended",
+	"blocks.add": "Add",
+	"blocks.addLabel": "Add {name}",
+	"blocks.added": "Added",
+	"blocks.remove": "Remove",
+	"blocks.removeLabel": "Remove {name}",
+	"blocks.undo": "Undo",
+	"blocks.undoAddLabel": "Don't add {name}",
+	"blocks.undoRemoveLabel": "Don't remove {name}",
+	"blocks.willAdd": "Will be added",
+	"blocks.willRemove": "Will be removed",
+	"blocks.pendingTitle": "Changes to publish",
+	"blocks.pendingAdd": "Add {name}",
+	"blocks.pendingRemove": "Remove {name}",
+	"blocks.discard": "Discard changes",
+	"blocks.publish": "Publish",
+	"blocks.publishedNotice": "Published. Added blocks will be in the editor's list of blocks, and removed ones gone from it, once the site has been updated.",
+	"blocks.addMessage": "Add the {name} block",
+	"blocks.removeMessage": "Remove the {name} block",
+	"blocks.changeMessage": "Change blocks: {changes}",
+	"blocks.addPart": "add {names}",
+	"blocks.removePart": "remove {names}",
+	"blocks.inUseTitle": "{name} can't be removed yet",
+	"blocks.inUse": "{name} is used in: {places}. Take it out of those first, then remove it.",
+	"blocks.usedTemplate": "the page design of {name}",
+	"blocks.error.record": "The list of blocks added to this site couldn't be read. Tell whoever looks after the site.",
+	"blocks.error.unreachable": "The blocks you can add couldn't be loaded. Check your internet connection and try again.",
+	"blocks.error.invalid": "The list of blocks you can add has a problem, so it couldn't be read. Try again later.",
+	"blocks.error.untrusted": "This block comes from somewhere this site doesn't trust, so it can't be added.",
+	"blocks.error.not-a-block": "This can't be added to the editor as a block.",
+	"blocks.error.already-installed": "{name} has already been added.",
+	"blocks.error.name-taken": "The site already has a block with the same name as {name}, so it can't be added.",
+	"blocks.error.packages": "This block needs software the site doesn't have ({packages}). Ask whoever looks after the site to add it.",
+	"blocks.error.unsupported-file": "This block includes a file that can't be added from here ({path}). Ask whoever looks after the site to add it.",
+	"blocks.error.file-exists": "The site already has a different file where this block goes ({path}). Ask whoever looks after the site to add it.",
+	"blocks.error.not-installed": "{name} hasn't been added, so there's nothing to remove.",
+	"blocks.error.in-use": "{name} is still used on the site. Take it out first, then remove it.",
+	"media.title": "Media",
+	"media.cloudflareVideo": "This site is published with Cloudflare Pages, whose terms limit serving video and other large files on its free plans without one of its paid services. To be safe, put videos on YouTube or Vimeo and show them with the Video block, which plays them from there.",
+	"media.cloudflareVideoTerms": "Cloudflare's terms",
+	"media.intro": "Images and files for the site. Upload them here, or while editing a page. Large photos are made smaller, and details hidden in photos, such as where they were taken, are removed.",
+	"media.upload": "Upload files",
+	"media.uploading": "Uploading…",
+	"media.drop": "Drop files here to upload them",
+	"media.empty": "There are no images or files yet.",
+	"media.search": "Find a file",
+	"media.noMatches": "No files match.",
+	"media.copy": "Copy address",
+	"media.copied": "Copied",
+	"media.replace": "Replace",
+	"media.delete": "Delete",
+	"media.uploaded": "Uploaded. Visitors see new files once the live site is updated.",
+	"media.uploadMessage": "Add {names}",
+	"media.replaceMessage": "Replace {name}",
+	"media.deleteMessage": "Delete {name}",
+	"media.deleteTitle": "Delete {name}?",
+	"media.deleteBody": "{name} will be removed from the site.",
+	"media.deleteUsed": "It's used in: {places}. Choose another file there first, since the site can't be published using a file that's gone.",
+	"media.notUsed": "Nothing on the site uses it.",
+	"media.error.type": "{name} can't be uploaded. The site can use images (JPEG, PNG, GIF, WebP, AVIF and SVG), PDFs, office documents, MP3 audio, MP4 and WebM video, and captions for videos (WebVTT).",
+	"media.error.size": "{name} is too large: files can be up to 25 MB. For long videos, upload them to YouTube or Vimeo and link to them instead.",
+	"media.error.unreadable": "{name} couldn't be read. It may be damaged, or in a format browsers can't open, such as HEIC. Save it as a JPEG and try again.",
+	"media.choose": "Choose image",
+	"media.chooseFile": "Choose file",
+	"media.chooseVideo": "Choose video",
+	"media.pickerTitle": "Choose an image",
+	"media.pickerTitleFile": "Choose a file",
+	"media.pickerTitleVideo": "Choose a video",
+	"media.pickerEmpty": "Nothing has been uploaded yet. Upload a file to use it here.",
+	"media.clear": "Remove",
+	"media.credit": "Credit: {credit}",
+	"ai.label": "AI",
+	"ai.title": "Write with AI",
+	"ai.mode.add": "Describe what to add to this page, and AI will write it at the end of the page.",
+	"ai.mode.edit": "Describe how to change the selected {block}.",
+	"ai.mode.fill": "Describe this {item}, or paste your notes, and AI will fill in its fields.",
+	"ai.instruction": "What should it write?",
+	"ai.placeholder.add": "For example: a section about our Christmas Mass schedule, with a heading, a short welcome and a button to the contact page.",
+	"ai.placeholder.edit": "For example: make it shorter and friendlier, or translate it into Spanish.",
+	"ai.placeholder.fill": "For example: Fr. Smith's homily from Sunday, about hope. Paste any notes here.",
+	"ai.photos": "Find openly licensed photos where the media library has none that fit",
+	"ai.photosHint": "Photos come from Openverse and are added to the media library. Pages that use them credit who made them, as their licenses require.",
+	"ai.photos.finding": "Finding photos…",
+	"ai.photos.message": "Add photos from Openverse: {names}",
+	"ai.photos.added": "Photos from Openverse added to the media library: {names}.",
+	"ai.photos.missing": "No photo was found for {count} of the images, so they're left empty.",
+	"ai.photos.error.busy": "Openverse has had too many requests from this computer, so some images are left empty. Try again later, or choose them from the media library.",
+	"ai.photos.error.unreachable": "Couldn't reach Openverse, so some images are left empty. Check your connection, or choose them from the media library.",
+	"ai.photos.error.publish": "The photos found couldn't be added to the media library, so their images are left empty.",
+	"ai.translate": "Translate into {language}",
+	"ai.translate.hint": "This page is in {language}. The AI can translate all of it, blocks and settings, keeping its layout. Anything you write below is passed on too, such as how formal to be.",
+	"ai.translate.entryHint": "This item is in {language}. The AI can translate all its fields. Anything you write below is passed on too.",
+	"ai.write": "Write it",
+	"ai.change": "Change it",
+	"ai.fill": "Fill it in",
+	"ai.stop": "Stop",
+	"ai.working": "Writing…",
+	"ai.progress": "Writing… {count} characters so far",
+	"ai.done": "Done. Check it over, then publish when you're happy. Undo takes it back.",
+	"ai.check": "AI can get things wrong, so read what it writes before publishing. It won't make up times, names or prices: it leaves [placeholders] for you to fill in.",
+	"ai.needsKey": "To use {service}, add an API key under the AI service settings below, or choose another service.",
+	"ai.settings": "AI service: {service}",
+	"ai.provider": "AI service",
+	"ai.provider.manual": "Copy and paste into a chat app (free)",
+	"ai.provider.custom": "Another service (OpenAI-compatible)",
+	"ai.noKey": "(free, no key needed)",
+	"ai.siteKey": "(provided by this site)",
+	"ai.siteKeyHint": "This site provides {service}, so you don't need a key of your own.",
+	"ai.baseUrl": "Address of the service's API",
+	"ai.baseUrlHint": "Such as https://example.org/v1.",
+	"ai.key": "API key",
+	"ai.keyHint": "Your key stays in this browser and is only ever sent to {service}.",
+	"ai.getKey": "Get a key from {service}",
+	"ai.remember": "Remember the key on this device",
+	"ai.forget": "Forget the key",
+	"ai.costHint": "{service} may charge the account the key belongs to for each request. Setting a spending limit there is a good idea.",
+	"ai.model": "Model",
+	"ai.modelHint": "Choose one from the list, or type its name.",
+	"ai.model.claude-opus-5-5": "Claude Opus 5.5 (best results)",
+	"ai.model.claude-sonnet-5-5": "Claude Sonnet 5.5 (faster, costs less)",
+	"ai.model.claude-haiku-4-5": "Claude Haiku 4.5 (fastest, costs least)",
+	"ai.manual.step1": "Copy this request into Claude.ai, ChatGPT or another chat app:",
+	"ai.manual.copy": "Copy the request",
+	"ai.manual.copied": "Copied",
+	"ai.manual.step2": "Then paste the chat app's whole answer here:",
+	"ai.manual.use": "Use this answer",
+	"ai.error.key": "{service} didn't accept the API key. Check that it was copied in full, that it hasn't been deleted, and that it can use this model.",
+	"ai.error.limit": "{service} is limiting requests right now, or the account is out of credit. Wait a minute and try again, or choose another service.",
+	"ai.error.network": "Couldn't reach {service}. Check your connection and try again.",
+	"ai.error.refused": "{service} declined to write this. Try asking a different way.",
+	"ai.error.answer": "The answer couldn't be used. Try again, or try a different model or service.",
+	"ai.error.service": "{service} reported a problem. Try again in a moment.",
+	"settings.title": "Site Settings",
+	"appearance.choice": "Colors of the admin panel",
+	"appearance.system": "Match my computer",
+	"appearance.light": "Light",
+	"appearance.dark": "Dark",
+	"settings.tab.general": "General",
+	"settings.tab.languages": "Languages",
+	"settings.tab.theme": "Colors & fonts",
+	"settings.tab.menus": "Menus",
+	"settings.tab.css": "Custom CSS",
+	"settings.tab.code": "Code",
+	"settings.tab.redirects": "Redirects",
+	"settings.sidebar.collapse": "Hide names",
+	"settings.sidebar.expand": "Show names",
+	"settings.tab.domain": "Domain",
+	"settings.message": "Update site settings",
+	"settings.preview": "Preview of the home page",
+	"settings.previewEmpty": "Add a home page to see a preview here.",
+	"domain.intro": "Connect a domain you own, such as example.org, so the site is at that address.",
+	"domain.current": "The site is at {address} now.",
+	"domain.connected": "Connected to {domain}.",
+	"domain.signIn": "Editors sign in by going to {host} and coming back here. Add {address} to the redirect URIs of the application they sign in with on {host}, or signing in will stop working once the site moves.",
+	"domain.local": "Domains are connected in the published site's admin panel, where you sign in with GitHub or GitLab.",
+	"domain.admin.title": "Admin address",
+	"domain.admin.intro": "An address of its own for the admin panel, such as admin.example.org, keeps the site's pages from reaching what the admin panel keeps, such as editors' sign-in. Editors then sign in there. Blocks from registries other than Goodfellow's can be added only once the admin panel has one.",
+	"domain.admin.unsupported": "{host} serves each site at one address, so the admin panel can't have one of its own here.",
+	"domain.admin.contentOnly": "The admin panel's address is named in the site's code, which is kept apart from its content, so a developer finishes setting it up there.",
+	"domain.admin.code.unknown": "This sign-in can't read the site's code, so this screen can't tell whether a developer has done that yet.",
+	"domain.admin.code.add": "A developer names the address in the site's code, then publishes the code:",
+	"domain.admin.code.check": "Once the site has been rebuilt and works at {address}, the developer checks the address. From the next rebuild, the admin panel opens only there:",
+	"domain.admin.code.remove": "To stop using it, a developer removes it from the site's code:",
+	"domain.admin.noConfig": "The admin panel's address goes in the site's {file}, which doesn't have the usual defineConfig({ for it, so a developer sets it there.",
+	"domain.admin.noSiteAddress": "Connect the site's own domain first: the admin address goes beside it.",
+	"domain.admin.field": "Admin address",
+	"domain.admin.fieldHint": "An address of the site's domain that nothing else uses, such as admin.example.org.",
+	"domain.admin.connect": "Give the admin panel this address",
+	"domain.admin.elsewhere": "Add this address to the site's project on {host} too, under its custom domains, so it serves the site there as well. The site's build writes {host}'s rules for it.",
+	"domain.admin.message": "Give the admin panel its own address, {domain}",
+	"domain.admin.connected": "The admin panel's address is {domain}",
+	"domain.admin.ready": "The site answers at {address}. Open the admin panel there to start using it.",
+	"domain.admin.pending": "Once the site has been rebuilt and works at {address}, open the admin panel there: it checks the address, then you can start using it.",
+	"domain.admin.open": "Open the admin panel at {address}",
+	"domain.admin.signInAgain": "You'll sign in again there: it's a different address, so it keeps its own sign-in.",
+	"domain.admin.checking": "Checking {address}…",
+	"domain.admin.check.ok": "The site's pages at this address leave it for the site's own address before running anything.",
+	"domain.admin.check.no-guard": "The site's pages at this address don't start with the script that sends them away yet. Wait for the site to be rebuilt, then check again.",
+	"domain.admin.check.no-sandbox": "{host} doesn't sandbox the site's pages at this address yet. Wait for the site to be rebuilt, then check again.",
+	"domain.admin.check.failed": "The admin panel couldn't check this address. Try again in a moment.",
+	"domain.admin.use": "Start using {address}",
+	"domain.admin.useMessage": "Open the admin panel only at {domain}",
+	"domain.admin.using": "The admin panel's address is {address}. Once the site has been rebuilt, the admin panel opens only there.",
+	"domain.admin.stop": "Stop using the admin address",
+	"domain.admin.stopMessage": "Stop using {domain} for the admin panel",
+	"domain.admin.stopBody": "The admin panel goes back to the site's own address once the site has been rebuilt, and blocks from registries other than Goodfellow's can't be added there.",
+	"domain.demo": "Domains can't be connected in a demo.",
+	"domain.loading": "Finding where the site is published…",
+	"domain.elsewhere": "This site isn't published with {host} Pages, so its domain is connected where it is published.",
+	"domain.elsewhere.cloudflare": "On Cloudflare Pages: open the site's project, go to Custom domains and set up the domain. For a domain such as www.example.org, Cloudflare shows a CNAME record to add at your registrar. For example.org itself, the domain has to use Cloudflare's nameservers, which Cloudflare walks you through. Once the site works at its new address, put the address in General → Site address and publish.",
+	"domain.elsewhere.vercel": "On Vercel: open the site's project, go to Settings → Domains and add the domain. Vercel shows the records to add at your registrar. Once the site works at its new address, put the address in General → Site address and publish.",
+	"domain.field": "Domain",
+	"domain.fieldHint": "Such as example.org or www.example.org. Buy one first from a registrar, such as Cloudflare, Namecheap or Porkbun. For example.org, www.example.org works too.",
+	"domain.invalid": "That isn't a domain. Type it like example.org.",
+	"domain.warning": "Once it's connected, the site's current address sends visitors to the new one, which works only once the records are in place. Have your registrar's DNS settings open, and add the records straight away.",
+	"domain.connect": "Connect domain",
+	"domain.connecting": "Connecting…",
+	"domain.message": "Use the domain {domain}",
+	"domain.records.title": "1. Add these records at your registrar",
+	"domain.records.hint": "Your registrar is where you bought the domain. In its DNS settings, add each record below. Delete any other A, AAAA or CNAME records with the same names, such as a page the registrar shows on new domains.",
+	"domain.records.type": "Type",
+	"domain.records.name": "Name",
+	"domain.records.value": "Value",
+	"domain.records.state": "Found",
+	"domain.records.ok": "In place",
+	"domain.records.missing": "Not there yet",
+	"domain.records.wrong": "Something else is there: {found}",
+	"domain.records.optional": "optional",
+	"domain.purpose.site": "Points the domain at the site.",
+	"domain.purpose.verification": "Proves to {host} that the domain is yours. Leave it in place.",
+	"domain.purpose.www": "Sends www. to the site too.",
+	"domain.guides": "How to add records at:",
+	"domain.cloudflare": "On Cloudflare, set each record's proxy status to DNS only, or {host} can't set up HTTPS for the domain.",
+	"domain.host.title": "2. {host} checks the domain and sets up HTTPS",
+	"domain.host.unverified": "Waiting for {host} to find the record that proves the domain is yours.",
+	"domain.host.pending": "Waiting for the HTTPS certificate, which {host} asks for once the records are in place. It can take up to a day.",
+	"domain.host.ready": "The HTTPS certificate is ready.",
+	"domain.host.failed": "The HTTPS certificate couldn't be set up. Check the records, then remove the domain and connect it again.",
+	"domain.site.title": "3. The site opens at {address}",
+	"domain.site.waiting": "Not yet. New records can take from a few minutes to a day to reach everyone.",
+	"domain.site.ok": "It does.",
+	"domain.secure": "Send everyone to {address}",
+	"domain.secureHint": "Visitors always get the secure address, and the site's old address sends them there too.",
+	"domain.done": "Done: the site is at {address}.",
+	"domain.check": "Check again",
+	"domain.checking": "Checking…",
+	"domain.checkFailed": "Couldn't check the records just now. Try again in a moment.",
+	"domain.remove": "Remove domain",
+	"domain.removeTitle": "Remove {domain}?",
+	"domain.removeBody": "The site goes back to its address on {host}. Delete the records at your registrar afterwards, so nobody else can use the domain for a site.",
+	"domain.removeMessage": "Stop using the domain {domain}",
+	"domain.error.not-allowed": "Your account can't change the site's {host} Pages settings. Ask one of the site's owners to make you an owner too, or to connect the domain for you.",
+	"domain.error.taken": "Another site on {host} already uses this domain. If it's yours too, remove it there first.",
+	"domain.error.invalid": "{host} doesn't accept this domain.",
+	"domain.error.not-ready": "The HTTPS certificate isn't ready yet. Try again in a while.",
+	"domain.error.other": "Something went wrong.",
+	"owner.signIn.title": "Sign in as an owner",
+	"owner.signIn.intro": "Inviting and removing editors, and connecting a domain, need an owner's access on {host}, which everyday sign-in doesn't have. Sign in as an owner for this tab only.",
+	"owner.signIn.button": "Sign in as an owner with {host}",
+	"owner.signIn.orToken": "Or use an owner token",
+	"owner.token.title": "Use an owner token",
+	"owner.token.intro": "Inviting and removing editors, and connecting a domain, need more access on {host} than signing in has. Create a second token for them. It's kept only until you close this tab, and stops working after a day; you can delete it on {host} sooner.",
+	"owner.token.create": "Create an owner token on {host}",
+	"owner.token.chooseSite": "If {host} asks what the token can access, choose only this site.",
+	"owner.token.paste": "Copy the token and paste it here:",
+	"settings.tab.security": "Security",
+	"security.demo": "A demo has no sign-in to keep safe.",
+	"security.local": "The sign-in page is set in the published site's admin panel, where you sign in with GitHub or GitLab.",
+	"security.contentOnly": "The sign-in page is set in the site's code, which is kept apart from its content, so a developer sets it there.",
+	"security.broker.title": "Sign-in page",
+	"security.broker.intro": "A sign-in page of its own, called a token broker, keeps editors' sign-in and AI keys at an address that holds nothing else, and shows the admin panel from there, so nothing on the site's pages can reach them. It asks the editor before publishing the site's code. It needs an address of its own, such as signin.example.org, that serves nothing else.",
+	"security.broker.useTitle": "Sign in at a sign-in page that's online",
+	"security.add.title": "Add a token broker",
+	"security.add.intro": "Makes a project on {host} for the sign-in page, from Goodfellow's released files and a file naming this site, and puts it online where you choose. It needs a token that can create projects, used only now and kept only until you leave this screen.",
+	"security.add.place": "Where to put it online",
+	"security.add.place.gitlab-pages": "GitLab Pages, at an address GitLab gives it",
+	"security.add.place.gitlab-domain": "GitLab Pages, at a domain of yours",
+	"security.add.place.github-domain": "GitHub Pages, at a domain of yours",
+	"security.add.place.cloudflare-pages": "Cloudflare Pages",
+	"security.add.place.vercel": "Vercel",
+	"security.add.placeHint.gitlab-pages": "GitLab gives the project an address of its own, which nothing else shares. You'll find it under Deploy → Pages once it's online. No domain needed.",
+	"security.add.placeHint.gitlab-domain": "A domain, or part of one, such as signin.example.org, that you point at GitLab Pages as its settings say.",
+	"security.add.placeHint.github-domain": "GitHub Pages' own addresses are shared by every site in the same account, so the sign-in page needs a domain, or part of one, such as signin.example.org, which you point at GitHub Pages as its settings say.",
+	"security.add.placeHint.cloudflare-pages": "Free, with an address of its own. Once the project is made, connect it to a Cloudflare Pages project, as its README says.",
+	"security.add.placeHint.vercel": "Free for non-commercial sites, with an address of its own. Once the project is made, import it as a Vercel project, as its README says.",
+	"security.add.domain": "Its domain",
+	"security.add.domainHint": "Such as signin.example.org. It serves only the sign-in page.",
+	"security.add.problem.domain": "That doesn't look like a domain, such as signin.example.org.",
+	"security.add.problem.shared": "github.io and gitlab.io addresses are shared with other sites, so the sign-in page needs a domain of yours.",
+	"security.add.problem.site": "That's the site's own address. The sign-in page needs one of its own.",
+	"security.add.name": "Its name on {host}",
+	"security.add.nameHint": "Made beside the site's on {host}, public, since it holds only Goodfellow's released files.",
+	"security.add.token": "A {host} token that can create projects",
+	"security.add.tokenHint": "Used only to make the project, and forgotten when you leave this screen.",
+	"security.add.create": "Make the sign-in page",
+	"security.add.creating": "Making the sign-in page…",
+	"security.add.description": "The sign-in page for {site}",
+	"security.add.message": "Add the sign-in page",
+	"security.add.error.token": "{host} didn't accept that token. Check it's whole, and that it can create projects.",
+	"security.add.error.owner": "That token can't create projects anywhere.",
+	"security.add.error.taken": "There's already a project with that name. Choose another.",
+	"security.add.error.release": "Goodfellow's sign-in page couldn't be downloaded. Try again in a moment.",
+	"security.add.error.name-taken": "There's already a project with that name. Choose another.",
+	"security.add.error.name-invalid": "{host} can't use that as a project's name.",
+	"security.add.error.not-allowed": "That token can't create projects, or write their build setup.",
+	"security.add.error.not-installed": "{host} needs the sign-in service's app installed there first.",
+	"security.add.error.other": "The sign-in page couldn't be made.",
+	"security.added.project": "The sign-in page's project is ready:",
+	"security.added.github-pages": "GitHub Pages is putting it online. Point the domain at GitHub Pages as the project's Settings → Pages says, and wait for its certificate.",
+	"security.added.gitlab-pages": "GitLab Pages is putting it online. Its address is under Deploy → Pages in the new project once the first build has finished.",
+	"security.added.cloudflare-pages": "Now connect it to Cloudflare Pages: create a Pages project from the project, with no build command and site as the output directory.",
+	"security.added.vercel": "Now import it as a Vercel project, with site as its root directory and no build command.",
+	"security.added.domainUnavailable": "The domain couldn't be set for it, perhaps because another site has it. Set it in the project's Pages settings.",
+	"security.added.pagesUnavailable": "Pages couldn't be turned on for it. Turn them on in the project's settings.",
+	"security.added.address": "Once it opens at {address}, choose Sign in there from now on below. Editors sign in there once the site has rebuilt.",
+	"security.added.then": "Once it's online, type its address below and choose Sign in there from now on. Editors sign in there once the site has rebuilt.",
+	"security.broker.field": "The sign-in page's address",
+	"security.broker.fieldHint": "An address that serves only the token broker, such as https://broker.example.org.",
+	"security.broker.problem.invalid": "That needs to be an https:// address of its own, with nothing after the domain.",
+	"security.broker.problem.shared": "github.io addresses are shared with every site in the same account, so the sign-in page needs a domain of its own.",
+	"security.broker.problem.same-as-site": "That's the site's own address. The sign-in page needs one of its own.",
+	"security.broker.redirect": "Editors sign in by going to {host} and coming back, so add the sign-in page's address to the redirect URIs of the application they sign in with on {host}.",
+	"security.broker.use": "Sign in there from now on",
+	"security.broker.message": "Sign in at {address}",
+	"security.broker.error": "The sign-in page's address couldn't be published.",
+	"security.broker.pending": "Once the site has been rebuilt, editors sign in at {address}, and the admin panel opens only there.",
+	"security.broker.using": "Editors sign in at {address}, which keeps their sign-in and shows the admin panel.",
+	"security.broker.stop": "Stop using the sign-in page",
+	"security.broker.stopMessage": "Stop signing in at {address}",
+	"security.broker.stopBody": "Once the site has been rebuilt, editors sign in in the admin panel itself again, which keeps their sign-in where the site's pages could reach it, and blocks from registries other than Goodfellow's can't be added there.",
+	"broker.elsewhere": "Editors sign in to this site on its own sign-in page, which keeps your sign-in where the site's pages can't reach it, and shows the admin panel from there.",
+	"broker.open": "Go to the sign-in page",
+	"broker.invalid": "The site's config names a sign-in page whose address isn't one of its own, so the admin panel can't open. Ask the site's developer to fix the broker address in goodfellow.config.tsx.",
+	"owner.token.pasteInBroker": "Copy the token, choose Use this token, and paste it where the sign-in page around the admin panel asks for it. It keeps the token, so the admin panel never sees it.",
+	"owner.token.label": "Owner token",
+	"owner.token.use": "Use this token",
+	"owner.token.checking": "Checking…",
+	"owner.token.error": "That token can't manage this site. Check that it was made by one of the site's owners, that it can access this site, and that the whole token was copied.",
+	"owner.token.active": "This tab is using an owner token.",
+	"owner.token.forget": "Stop using it",
+	"settings.tab.editors": "Editors",
+	"settings.tab.updates": "Updates",
+	"settings.tab.history": "Site history",
+	"settings.tab.import": "WordPress",
+	"siteHistory.intro": "Every publish that changed the site's pages, items, settings or media, newest first. Choose one to see how the site looked after it and what has changed since, then restore the whole site as it was.",
+	"siteHistory.local": "Site history is in the published site's admin panel, where you sign in with GitHub or GitLab.",
+	"siteHistory.demo": "Site history isn't kept in a demo.",
+	"siteHistory.error": "The site's history couldn't be loaded. Check your connection and try again.",
+	"siteHistory.current": "The site now",
+	"siteHistory.preview": "The site on {date}",
+	"siteHistory.loadingVersion": "Loading the site as it was…",
+	"siteHistory.readError": "The site as it was then couldn't be loaded. Check your connection and try again.",
+	"siteHistory.unfit": "The site as it was then can't be shown or restored, because it doesn't fit the site as it is now.",
+	"siteHistory.unknownBlocks": "The site as it was then can't be restored, because it uses blocks the site doesn't have any more: {blocks}.",
+	"siteHistory.same": "Nothing has changed since: this is how the site is now.",
+	"siteHistory.since": "What has changed since",
+	"siteHistory.changed": "Changed since (restoring puts them back as they were):",
+	"siteHistory.added": "Added since (restoring removes them):",
+	"siteHistory.removed": "Removed since (restoring brings them back):",
+	"siteHistory.page": "Page to look at",
+	"siteHistory.restore": "Restore the site as it was",
+	"siteHistory.restoreTitle": "Restore the site as it was on {date}?",
+	"siteHistory.restoreBody": "Everything listed ({count}) goes back to how it was then, in one publish. The site as it is now stays in the history, so you can restore it again later. The site's code and update settings stay as they are.",
+	"siteHistory.restoreMessage": "Restore the site as it was on {date}",
+	"siteHistory.restored": "Restored the site as it was on {date}.",
+	"siteHistory.subject.page": "{title} ({path})",
+	"siteHistory.subject.entry": "{title}, in {collection}",
+	"siteHistory.subject.collection": "The settings and page design of {name}",
+	"siteHistory.subject.settings": "Site settings",
+	"siteHistory.subject.menus": "Menus",
+	"siteHistory.subject.redirects": "Redirects",
+	"siteHistory.subject.credits": "Photo credits",
+	"siteHistory.subject.css": "Custom CSS",
+	"siteHistory.subject.code": "Code added to every page",
+	"import.title": "Import from WordPress",
+	"import.intro": "Bring a WordPress site's pages, posts, categories, tags, menus and media into this site. Pages keep their addresses, posts become a collection, and old addresses send visitors on to the new ones. You'll see what comes across before anything changes.",
+	"import.file": "WordPress export file",
+	"import.fileHint": "In WordPress, go to Tools → Export, choose All content and download the file. It brings the menus too.",
+	"import.address": "Or the WordPress site's address",
+	"import.addressHint": "Such as example.org. Only what visitors can see is read, and menus can't be.",
+	"import.read": "Read the site",
+	"import.reading": "Reading the WordPress site…",
+	"import.ready": "Ready to import {title}",
+	"import.summary.pages": "Pages: {count}",
+	"import.summary.posts": "Posts: {count}, at {path}, listed on {list}",
+	"import.summary.terms": "Categories: {categories}. Tags: {tags}.",
+	"import.summary.menus": "Menus: {count}",
+	"import.summary.redirects": "Old addresses sent on to new ones: {count}",
+	"import.summary.media": "Media files to copy: {count}",
+	"import.replaces": "These pages will be replaced: {pages}. Version history keeps the old ones.",
+	"import.check": "Check these",
+	"import.start": "Import",
+	"import.another": "Choose another site",
+	"import.copying": "Copying media: {done} of {total}…",
+	"import.publishing": "Publishing…",
+	"import.done": "Imported {title}.",
+	"import.viewPages": "See the pages",
+	"import.message": "Import {title} from WordPress",
+	"import.note.leftOut.drafts": "Drafts and pages waiting for review aren't imported: {count}.",
+	"import.note.leftOut.private": "Private pages and posts aren't imported: {count}.",
+	"import.note.leftOut.trash": "Pages and posts in the trash aren't imported: {count}.",
+	"import.note.leftOut.comments": "Comments aren't imported: {count}.",
+	"import.note.leftOut.other": "WordPress content of the kind “{name}” isn't imported: {count}.",
+	"import.note.more": "{items} and {count} more",
+	"import.note.block": "The “{name}” block, from another plugin, was brought across as its text and pictures: {items}.",
+	"import.note.dropped": "The “{name}” block shows something only WordPress has, so it was left out: {items}.",
+	"import.note.shortcode": "The [{name}] shortcode only works in WordPress, so it was left out: {items}.",
+	"import.note.embed": "Something from {name} is now a link to it: {items}.",
+	"import.note.form": "A form was left out. Add a Form block in its place: {items}.",
+	"import.note.script": "A script was left out: {items}.",
+	"import.note.table": "A table became text, since pages have no tables: {items}.",
+	"import.note.posts": "A list of the latest posts was left out of a post: {items}.",
+	"import.note.video": "A video is now a link to it, since posts show videos as links: {items}.",
+	"import.note.oldLinks": "Links that still go to the WordPress site, to pages that weren't imported: {count}, such as {url}.",
+	"import.note.notCopied": "Media files that couldn't be copied, so pages show them from the WordPress site until you upload them: {count}, such as {url}. Most WordPress sites don't let other sites download their files; importing from the command line copies them.",
+	"import.note.unusedMedia": "Files in the media library that no page or post uses, so they weren't copied: {count}.",
+	"import.note.noMenus": "Menus can't be read from a site's address, so the main menu lists the top-level pages. Import an export file to bring the menus across.",
+	"import.error.notExportFile": "That file isn't a WordPress export file. In WordPress, go to Tools → Export, choose All content and download the file.",
+	"import.error.unreachable": "The WordPress site couldn't be read from {address}. Check the address. Some sites don't let other sites read them; then import an export file instead.",
+	"import.error.notWordPress": "{address} doesn't look like a WordPress site, or its API is turned off. Import an export file instead.",
+	"import.error.blocks": "Importing needs blocks this site doesn't have: {blocks}. A developer can add Goodfellow's built-in blocks to goodfellow.config.tsx.",
+	"import.error.other": "The WordPress site couldn't be imported.",
+	"import.names.posts": "Posts",
+	"import.names.post": "Post",
+	"import.names.title": "Title",
+	"import.names.date": "Date",
+	"import.names.summary": "Summary",
+	"import.names.image": "Image",
+	"import.names.categories": "Categories",
+	"import.names.tags": "Tags",
+	"import.names.text": "Text",
+	"import.names.allPosts": "All posts",
+	"export.title": "Export to WordPress",
+	"export.intro": "Download this site as a WordPress export file, to move it to WordPress or keep a copy. Pages keep their addresses and blocks become WordPress's, items of collections with pages become posts, and menus come too. In WordPress, go to Tools → Import → WordPress, choose the file and tick “Download and import file attachments”, which copies the media from this site.",
+	"export.download": "Download the export file",
+	"export.done": "Downloaded the export file.",
+	"export.error": "The export file couldn't be made.",
+	"export.summary.pages": "Pages: {count}",
+	"export.summary.posts": "Posts: {count}",
+	"export.summary.media": "Media files, which WordPress copies from this site: {count}",
+	"export.note.leftOutBlock": "WordPress has nothing like the {name} block, so it was left out: {items}.",
+	"export.note.noPages": "Collections without pages of their own aren't in the file, since WordPress's posts each have a page: {collections}.",
+	"export.note.hidden": "Hidden by their schedule, so they're drafts in the file: {items}.",
+	"export.note.redirects": "Redirects aren't in the file, since WordPress needs a plugin for them: {count}.",
+	"export.note.noAddress": "The site has no address yet, so WordPress can't copy its media. Set it on the General tab, then download the file again.",
+	"export.note.layout": "The header and footer aren't in the file. WordPress's theme shows its own, with the menus.",
+	"updates.intro": "Goodfellow, the software the site runs on, gets fixes and new releases. Fixes install on their own each night, and only once the site has been checked to still build with them.",
+	"updates.contentOnly": "This site's code is kept apart from its content, so Goodfellow's updates are installed where the code is, by the site's own setup or its developer.",
+	"updates.code": "This site's code is kept apart from its content, at {place}, where Goodfellow's updates are installed.",
+	"updates.code.link": "See it on {host}",
+	"updates.noAccess": "Your sign-in can't see the site's code, at {place}, where its updates are installed. Ask the site's developer to give you access to it. On GitHub, an access token needs to reach it too, or with Sign in with GitHub, Goodfellow's app needs to be installed there.",
+	"updates.back.skip": "Don't install Goodfellow {version} again",
+	"updates.local": "Updates are shown in the published site's admin panel, where you sign in with GitHub or GitLab.",
+	"updates.demo": "Updates aren't installed in a demo.",
+	"updates.loading": "Checking for updates…",
+	"updates.current": "This site uses Goodfellow {version}.",
+	"updates.unknownVersion": "This site's Goodfellow release couldn't be found.",
+	"updates.missing": "This site's build setup doesn't install updates on its own, for example because it was made before it could, or because it's published with Vercel. A developer can add it, as the documentation explains.",
+	"updates.needsSetup": "Automatic updates aren't turned on yet. They need {host} to let the site's build publish the update, and to run it each night.",
+	"updates.enable": "Turn on automatic updates",
+	"updates.fixes.title": "Fixes",
+	"updates.fixes.ready": "Fixes up to Goodfellow {version} are ready. They install on their own tonight, or you can install them now.",
+	"updates.fixes.readyPaused": "Fixes up to Goodfellow {version} are ready. Automatic fixes are turned off, so they're only installed if you install them now.",
+	"updates.fixes.now": "Install fixes now",
+	"updates.fixes.none": "The site has every fix for its release.",
+	"updates.newer.title": "Goodfellow {version} is out",
+	"updates.newer.body": "Newer releases can change how some things work, so they're only installed when one of the site's owners chooses to. Read what's new first.",
+	"updates.newer.whatsNew": "What's new",
+	"updates.newer.install": "Update to {version}",
+	"updates.newer.onlyOwners": "Only the site's owners can install a newer release.",
+	"updates.automatic.label": "Install fixes automatically each night",
+	"updates.automatic.hint": "Turn this off to keep the site on the release it has now, for example while something an update changed is looked into. Fixes are then only installed when someone installs them here.",
+	"updates.automatic.onlyOwners": "Only the site's owners can change this.",
+	"updates.automatic.turnOff": "Turn off automatic fixes",
+	"updates.automatic.turnOn": "Turn on automatic fixes",
+	"updates.back.title": "Something stopped working?",
+	"updates.back.body": "If something stopped working when Goodfellow {current} was installed, you can go back to {version}. The site is checked to still build with it first. Updates won't install {current} again, but will install fixes that come after it.",
+	"updates.back.button": "Go back to {version}",
+	"updates.back.confirm": "Go back to Goodfellow {version}? It takes a few minutes.",
+	"updates.skipped.title": "Releases that won't be installed",
+	"updates.skipped.body": "The site went back from these releases, so updates don't install them.",
+	"updates.skipped.allow": "Allow {version} again",
+	"updates.skipped.allowMessage": "Allow Goodfellow {version} again",
+	"updates.nightly.title": "Rebuilding overnight",
+	"updates.nightly.body": "Each night, the site can check whether it needs rebuilding: for fixes to install, for something it shows by today's date, such as an event's next date, or for a change that didn't go live.",
+	"updates.nightly.changed": "Only when something changed (recommended)",
+	"updates.nightly.always": "Every night",
+	"updates.nightly.off": "Never",
+	"updates.nightly.offWarning": "Without rebuilding overnight, what the site shows by today's date, such as lists of what's coming up, goes out of date, and fixes aren't installed on their own. The site is still rebuilt each time someone publishes.",
+	"updates.nightly.unknown": "Sign in as an owner to see or change this.",
+	"updates.nightly.onlyOwners": "Only the site's owners can change this.",
+	"updates.nightly.old": "This site's build setup rebuilds it every night. A newer setup from Goodfellow's starter rebuilds it only when something changed.",
+	"updates.rebuild.title": "Rebuild the site",
+	"updates.rebuild.body": "Rebuilds the site now without publishing anything, so the live site catches up, such as with another calendar's events or after a rebuild that didn't work.",
+	"updates.rebuild.button": "Rebuild now",
+	"updates.rebuild.started": "The site is rebuilding. It takes a few minutes.",
+	"updates.started": "The update has started. It takes a few minutes, and this page shows how it went.",
+	"updates.last.title": "Last update",
+	"updates.last.none": "No update has run yet.",
+	"updates.last.running": "An update is running now. It takes a few minutes.",
+	"updates.last.updated": "On {date}, Goodfellow {version} was installed.",
+	"updates.last.updatedSome": "On {date}, an update was installed.",
+	"updates.last.wentBack": "On {date}, the site went back to Goodfellow {version}.",
+	"updates.last.paused": "On {date}, automatic fixes were turned off, so nothing was installed.",
+	"updates.last.upToDate": "On {date}, there was nothing new to install.",
+	"updates.last.failed": "On {date}, the update didn't work, so nothing changed and the site stayed as it was.",
+	"updates.last.unknown": "An update ran on {date}.",
+	"updates.last.details": "See the details on {host}",
+	"updates.failed.build": "The site didn't build with Goodfellow {version}; a developer may need to look at the details.",
+	"updates.failed.install": "Its packages couldn't be installed. The next night tries again.",
+	"updates.failed.blocks": "One of the site's blocks couldn't be updated.",
+	"updates.failed.publish": "Someone published at the same time. The next night tries again.",
+	"updates.kept": "Someone changed these files of the site's blocks, so the update left them as they were. A developer can compare them with the new versions:",
+	"updates.error.load": "The updates couldn't be checked. Check your connection and try again.",
+	"updates.error.not-allowed": "Your account can't do that on {host}. Ask one of the site's owners.",
+	"updates.error.missing": "This site's build setup doesn't install updates, so there's nothing to run.",
+	"updates.error.save": "The change couldn't be saved. Try again in a moment.",
+	"updates.error.other": "Something went wrong. Try again in a moment.",
+	"editors.intro": "The people who can edit this site.",
+	"editors.roles": "Editors can change and publish everything in the admin panel. Owners can also invite and remove editors, and connect a domain.",
+	"editors.local": "Editors are invited in the published site's admin panel, where you sign in with GitHub or GitLab.",
+	"editors.demo": "Editors can't be invited in a demo.",
+	"editors.loading": "Loading editors…",
+	"editors.onlyOwners": "Only the site's owners can invite and remove editors.",
+	"editors.cantPublish": "Editors can't publish yet: {host} only lets owners publish to the site until it's told to let editors publish too.",
+	"editors.letPublish": "Let editors publish",
+	"editors.person": "Person",
+	"editors.role": "Can",
+	"editors.roleFor": "What {name} can do",
+	"editors.actions": "Actions",
+	"editors.role.owner": "Owner",
+	"editors.role.editor": "Editor",
+	"editors.role.viewer": "Can't publish",
+	"editors.you": "You",
+	"editors.invited": "Invited, hasn't accepted yet",
+	"editors.inherited": "Through a group on {host}",
+	"editors.remove": "Remove",
+	"editors.withdraw": "Withdraw invitation",
+	"editors.removeTitle": "Remove {name}?",
+	"editors.removeBody": "They won't be able to edit the site any more. Their account on {host} stays as it is.",
+	"editors.withdrawTitle": "Withdraw the invitation to {name}?",
+	"editors.withdrawBody": "The invitation stops working. You can invite them again later.",
+	"editors.invite.title": "Invite someone",
+	"editors.invite.field": "Their {host} username",
+	"editors.invite.hint": "They need a {host} account. {host} emails them an invitation, which they accept before they can sign in here.",
+	"editors.invite.fieldEmail": "Their email address or {host} username",
+	"editors.invite.hintEmail": "With an email address, {host} emails them an invitation, and they make an account if they don't have one.",
+	"editors.invite.submit": "Invite",
+	"editors.error.load": "The editors couldn't be loaded. Check your connection and try again.",
+	"editors.error.not-allowed": "You can't change who edits the site.",
+	"editors.error.not-found": "There's no {host} account with that name. Check the spelling.",
+	"editors.error.invalid": "That isn't a username or email address that {host} accepts.",
+	"editors.error.already": "They already edit the site, or have been invited.",
+	"editors.error.other": "Something went wrong. Try again in a moment.",
+	"general.siteTitle": "Site name",
+	"general.description": "Description",
+	"general.descriptionHint": "Shown by search engines when a page doesn't have its own description.",
+	"general.url": "Site address",
+	"general.urlHint": "The full public address, such as https://example.org. Used for search engines and link previews.",
+	"general.externalLinksInNewTab": "Open links to other sites in a new tab",
+	"general.externalLinksInNewTabHint": "Applies to every link to another site: menus, buttons and text. Links to this site's own pages open in the same tab.",
+	"general.language": "Language code",
+	"general.languageHint": "Such as en, es or fr.",
+	"languages.intro": "A site can be in several languages. Pages in the main language are at the site's address; each other language's pages are under its code, such as /es/about for Spanish. Translate a page from the Pages screen once its language is published.",
+	"languages.main": "Main language",
+	"languages.mainCodeHintUsed": "It can't change while the site has pages or items in other languages.",
+	"languages.name": "Name",
+	"languages.nameHint": "How the language switch names it, in that language.",
+	"languages.new": "New language",
+	"languages.add": "Add a language",
+	"languages.remove": "Remove this language",
+	"languages.codeHint": "Such as es, fr or pt-BR. Its pages go under its code, so it can't change once published.",
+	"languages.codeHintPublished": "Its pages are under {prefix}.",
+	"languages.codeInvalid": "Use a language code, such as es, fr or pt-BR.",
+	"languages.codeTaken": "The site has this language already.",
+	"languages.codeUsed": "The site has pages under {prefix} already. Move them first, or choose another code.",
+	"languages.titleHint": "The site's title in this language. Left empty, it's the main language's.",
+	"languages.inUse": "Pages and items in this language: {count}. To remove the language, delete them or move them out of it first.",
+	"general.timeZone": "Time zone",
+	"general.timeZoneHint": "The time zone events' times are in. Calendars show them in it, and visitors' calendars move them to their own.",
+	"general.timeZoneNone": "Not set: times are shown as they're written",
+	"general.timeZoneUseMine": "Use {zone}",
+	"general.titleTemplate": "Browser tab title",
+	"general.titleTemplateHint": "%s is replaced by the page title, so \"%s | My site\" shows \"About | My site\".",
+	"general.favicon": "Browser tab icon",
+	"general.logo": "Logo",
+	"general.logoAlt": "Logo description",
+	"general.logoDark": "Logo in dark mode",
+	"general.logoDarkHint": "A version of the logo that shows up on dark backgrounds, such as a white one. Leave it empty to use the same logo.",
+	"general.socialImage": "Image when shared on social media",
+	"general.contact": "Contact details",
+	"general.contactHint": "Shown wherever a Contact details block is placed, such as the footer.",
+	"general.address": "Address",
+	"general.phone": "Phone",
+	"general.email": "Email",
+	"forms.title": "Forms",
+	"forms.hint": "Where answers to the site's forms go. The form service emails them to you: they're never kept with the site's pages.",
+	"forms.service": "Form service",
+	"forms.service.web3forms": "Web3Forms: free for 250 answers a month, with no account",
+	"forms.service.formspree": "Formspree",
+	"forms.service.other": "Another service",
+	"forms.accessKey": "Web3Forms access key",
+	"forms.accessKeyHint": "On Web3Forms' site, enter the email address answers should go to. Web3Forms emails you a key: paste it here.",
+	"forms.accessKeyLink": "Get an access key from Web3Forms",
+	"forms.captcha": "Ask visitors to show they aren't robots (hCaptcha)",
+	"forms.captchaHint": "Adds Web3Forms' hCaptcha and its script to pages with a form. To turn away answers without it, also turn hCaptcha on for the form in a Web3Forms account.",
+	"forms.formspree": "Formspree form address",
+	"forms.formspreeHint": "Make a form in Formspree and copy its address, such as https://formspree.io/f/xyzabcde. On Formspree's free plan, visitors see Formspree's own thank-you page.",
+	"forms.address": "Address forms send answers to",
+	"forms.addressHint": "The service's address for forms, starting with https://. Forms send the thank-you page's address as _next, the subject as _subject, and a hidden _gotcha field that only robots fill in, as Formspree, FormSubmit and Formcarry expect.",
+	"forms.error.key": "This isn't a Web3Forms access key. Copy it from Web3Forms' email: it looks like 0b5c4f7e-1a2b-4c3d-8e9f-0123456789ab.",
+	"forms.error.formspree": "This isn't a Formspree form's address. It looks like https://formspree.io/f/xyzabcde.",
+	"forms.error.address": "The address must be a full address starting with https://.",
+	"theme.colors": "Colors",
+	"theme.fonts": "Fonts",
+	"theme.fontsHint": "Choose from Google Fonts. Site default uses each visitor's standard font.",
+	"font.default": "Site default",
+	"font.defaultHint": "Visitor's standard font",
+	"font.search": "Search fonts",
+	"font.searchHint": "Type to search Google Fonts, then use the arrow keys and Enter to choose.",
+	"font.loading": "Loading fonts…",
+	"font.noMatch": "No fonts match “{query}”.",
+	"font.category.sans-serif": "Sans serif",
+	"font.category.serif": "Serif",
+	"font.category.display": "Display",
+	"font.category.handwriting": "Handwriting",
+	"font.category.monospace": "Monospace",
+	"theme.headingFont": "Headings",
+	"theme.bodyFont": "Text",
+	"theme.radius": "Corner rounding",
+	"theme.radiusHint": "Such as 0.5rem, or 0 for square corners.",
+	"theme.color.background": "Background",
+	"theme.color.foreground": "Text",
+	"theme.color.primary": "Main color",
+	"theme.color.primaryForeground": "Text on main color",
+	"theme.color.secondary": "Second color",
+	"theme.color.secondaryForeground": "Text on second color",
+	"theme.color.muted": "Subtle background",
+	"theme.color.mutedForeground": "Subtle text",
+	"theme.color.accent": "Highlight",
+	"theme.color.accentForeground": "Text on highlight",
+	"theme.color.border": "Borders",
+	"theme.default": "Default",
+	"theme.darkMode": "Dark mode",
+	"theme.darkModeOn": "Follow each visitor's light or dark setting",
+	"theme.darkModeHint": "Off by default, so the site is always light. When it's on, visitors whose computer or phone is set to dark see the site in the colors below.",
+	"theme.darkColors": "Colors in dark mode",
+	"theme.preview": "Preview",
+	"theme.previewLight": "Light",
+	"theme.previewDark": "Dark",
+	"theme.pickColor": "Choose a color for {name}",
+	"theme.code": "Code colors",
+	"theme.codeHint": "The colors of code in Code blocks and Markdown. Code that looks like the page uses the light colors, and the dark colors in dark mode.",
+	"theme.codeLight": "Light colors",
+	"theme.codeDark": "Dark colors",
+	"theme.codeBackground": "Show code on the subtle background color",
+	"theme.codeBackgroundHint": "Code that looks like the page sits on the site's Subtle background color instead of its colors' own background, so it matches the rest of the site. Check that it's still easy to read.",
+	"menus.intro": "Menus are lists of links. Show one anywhere with the Menu block, using its name.",
+	"menus.empty": "There are no menus yet.",
+	"menus.add": "Add menu",
+	"menus.newName": "New menu name",
+	"menus.nameInvalid": "Use lowercase letters, numbers and hyphens, and a name no other menu uses.",
+	"menus.deleteMenu": "Delete menu",
+	"menus.addLink": "Add link",
+	"menus.addSublink": "Add link below this one",
+	"menus.label": "Label",
+	"menus.href": "Link to",
+	"menus.moveUp": "Move up",
+	"menus.moveDown": "Move down",
+	"menus.remove": "Remove",
+	"translations.add": "Translate into {language}",
+	"translations.current": "Up to date",
+	"translations.outdated": "Out of date",
+	"translations.optionOutdated": "{language} (out of date)",
+	"translations.optionAdd": "Translate into {language}…",
+	"translations.markCurrent": "Mark as up to date",
+	"translations.markCurrentMessage": "Mark {title} as up to date",
+	"translations.of": "Translation of {title}",
+	"translations.entryOf": "In {language}: translation of {title}",
+	"translations.inLanguage": "In {language}",
+	"translations.addTitle": "Translate {title} into {language}",
+	"translations.addHint": "This makes a copy in {language} for you to translate. The Pages screen says when the original changes, so you know to update the translation.",
+	"translations.addSubmit": "Make the copy",
+	"translations.addMessage": "Translate {title} into {language}",
+	"translations.addressLanguage": "Pages in {language} have addresses starting with {prefix}.",
+	"menus.language": "Language",
+	"layout.languageShared": "Pages in {language} show the main language's {part}, with {language}'s menus and site name. Give {language} a {part} of its own to translate the words typed into it.",
+	"layout.languageCopy": "Make a {part} for {language}",
+	"layout.languageCopyMessage": "Make a {part} for {language}",
+	"layout.languageRemove": "Use the main language's {part}",
+	"layout.languageRemoveMessage": "Use the main language's {part} in {language}",
+	"layout.languageMessage": "Update the {part} in {language}",
+	"newEntry.languageHint": "For an item only in this language. To translate an item, use “Translate into” in the list instead, which keeps the two linked.",
+	"menus.ownMenus": "{language} has menus of its own",
+	"menus.sameAsMain": "Pages in {language} show the main language's menus. Give it menus of its own to translate their links' names and point them at its pages.",
+	"menus.newLink": "New link",
+	"redirects.intro": "Send visitors from an old address to a new one, such as when a page has moved or this site replaced an older one. Search engines move the old address's place in their results to the new one.",
+	"redirects.empty": "There are no redirects yet.",
+	"redirects.from": "Old address",
+	"redirects.to": "Send visitors to",
+	"redirects.add": "Add redirect",
+	"redirects.remove": "Remove",
+	"redirects.message": "Message while visitors are sent on",
+	"redirects.messageHint": "Shown at an old address for a moment, or for good in browsers without JavaScript. {placeholder} becomes a link to where visitors are going. Leave it empty for the message shown here.",
+	"redirects.unused": "A page has this address, so visitors see the page instead. Remove the redirect, or move the page.",
+	"redirects.problem.noFrom": "Add the old address, such as /about-us.",
+	"redirects.problem.badFrom": "This isn't an address on this site. Start with /, such as /about-us, or paste the old page's full address.",
+	"redirects.problem.query": "Addresses with a ? in them can't be redirected, since the site can't tell them apart from the address before the ?.",
+	"redirects.problem.home": "The home page can't be redirected.",
+	"redirects.problem.reserved": "This address is used by the site itself, so it can't be redirected.",
+	"redirects.problem.noTo": "Add where to send visitors, such as /about.",
+	"redirects.problem.badTo": "Send visitors to a page on this site, starting with /, or to another website's address, starting with https://.",
+	"redirects.problem.loop": "This sends visitors back to the same address.",
+	"redirects.problem.duplicate": "Another redirect is from the same address. Remove one of them.",
+	"css.intro": "CSS here applies to every page and overrides the blocks' own styles. Tailwind's @apply works too.",
+	"css.label": "Custom CSS",
+	"code.editorHint": "Tab indents, and suggestions appear as you type. Press Escape, then Tab, to leave the editor. Ctrl+F finds and replaces.",
+	"code.intro": "Code from services such as analytics or site verification, added to every page of the site. It never runs in the admin panel, so check it on the site once it's published. Paste only code you trust: it can change anything on the site.",
+	"code.head": "In the page head",
+	"code.headHint": "Script, style, link, meta and noscript tags, such as the ones Google Analytics gives you.",
+	"code.body": "At the end of the page",
+	"code.bodyHint": "Any HTML, such as a chat widget, added just before the end of every page.",
+	"code.error.text": "The code in the page head has text outside a tag: \"{text}\". Only tags such as <script> and <meta> can go there.",
+	"code.error.tag": "A <{tag}> tag can't go in the page head. Put it in \"At the end of the page\" instead.",
+	"code.error.unclosed": "A {tag} tag in the page head isn't closed."
+};
+const StringsContext = createContext(defaultStrings);
+function StringsProvider({ strings, children }) {
+	const value = useMemo(() => ({
+		...defaultStrings,
+		...strings
+	}), [strings]);
+	return /* @__PURE__ */ jsx(StringsContext.Provider, {
+		value,
+		children
+	});
+}
+/** The whole table, with any strings the admin panel was given, for frames, which show some of the admin panel's text. */
+function useStringTable() {
+	return useContext(StringsContext);
+}
+/** Returns `t(key, values)`, which looks up a string and fills in its `{placeholders}`. */
+function useStrings() {
+	const strings = useContext(StringsContext);
+	return (key, values) => strings[key].replace(/\{(\w+)\}/g, (match, name) => values?.[name] ?? match);
+}
+//#endregion
+//#region src/ui.tsx
+function Button({ variant = "secondary", type = "button", ...props }) {
+	return /* @__PURE__ */ jsx("button", {
+		type,
+		...props,
+		className: `gfa-button gfa-button-${variant} ${props.className ?? ""}`
+	});
+}
+/** A labelled form control with an optional hint and error message. */
+function Field({ label, hint, error, children }) {
+	const id = useId();
+	const describedBy = [hint && `${id}-hint`, error && `${id}-error`].filter(Boolean).join(" ") || void 0;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "gfa-field",
+		children: [
+			/* @__PURE__ */ jsx("label", {
+				htmlFor: id,
+				className: "gfa-label",
+				children: label
+			}),
+			children({
+				id,
+				"aria-describedby": describedBy,
+				"aria-invalid": error ? true : void 0
+			}),
+			hint && /* @__PURE__ */ jsx("p", {
+				id: `${id}-hint`,
+				className: "gfa-hint",
+				children: hint
+			}),
+			error && /* @__PURE__ */ jsx("p", {
+				id: `${id}-error`,
+				className: "gfa-error-text",
+				children: error
+			})
+		]
+	});
+}
+function TextField({ label, hint, error, value, onChange, ...input }) {
+	return /* @__PURE__ */ jsx(Field, {
+		label,
+		hint,
+		error,
+		children: (props) => /* @__PURE__ */ jsx("input", {
+			...input,
+			...props,
+			className: "gfa-input",
+			value,
+			onChange: (event) => onChange(event.target.value)
+		})
+	});
+}
+/** Shows what went wrong in plain words, with the technical details behind a toggle. */
+function ErrorMessage({ message, error, action }) {
+	const t = useStrings();
+	const details = error instanceof Error ? `${error.name}: ${error.message}` : error ? String(error) : "";
+	return /* @__PURE__ */ jsxs("div", {
+		className: "gfa-notice gfa-notice-error",
+		role: "alert",
+		children: [
+			/* @__PURE__ */ jsx("p", { children: message }),
+			details && /* @__PURE__ */ jsxs("details", {
+				className: "gfa-details",
+				children: [/* @__PURE__ */ jsx("summary", { children: t("details.show") }), /* @__PURE__ */ jsx("pre", { children: details })]
+			}),
+			action
+		]
+	});
+}
+/** A modal dialog using the native `<dialog>` element. */
+function Dialog({ title, onClose, children }) {
+	const ref = useRef(null);
+	const titleId = useId();
+	useEffect(() => {
+		ref.current?.showModal();
+	}, []);
+	return /* @__PURE__ */ jsxs("dialog", {
+		ref,
+		className: "gfa-dialog",
+		onClose,
+		"aria-labelledby": titleId,
+		children: [/* @__PURE__ */ jsx("h2", {
+			id: titleId,
+			className: "gfa-dialog-title",
+			children: title
+		}), children]
+	});
+}
+/** How long "Published." shows under the Publish button. */
+const PUBLISHED_NOTICE_MS = 5e3;
+/**
+* "Published.", just under the Publish button, which goes after a few seconds.
+* Put it in the `gfa-header-actions` the button is in; screens hide it sooner
+* when anything changes. `onHide` must keep its identity, or the time restarts.
+* It's placed on the screen, under its parent's right-hand edge, since editors'
+* headers clip what hangs below them.
+*/
+function PublishedNotice({ onHide }) {
+	const t = useStrings();
+	const ref = useRef(null);
+	const [place, setPlace] = useState();
+	useLayoutEffect(() => {
+		const anchor = ref.current?.parentElement?.getBoundingClientRect();
+		if (anchor) setPlace({
+			top: anchor.bottom + 8,
+			right: document.documentElement.clientWidth - anchor.right
+		});
+	}, []);
+	useEffect(() => {
+		const timer = window.setTimeout(onHide, PUBLISHED_NOTICE_MS);
+		return () => window.clearTimeout(timer);
+	}, [onHide]);
+	return /* @__PURE__ */ jsx("p", {
+		ref,
+		className: "gfa-published",
+		role: "status",
+		style: place ?? { visibility: "hidden" },
+		children: t("publish.done")
+	});
+}
+/** `value`, once it's stayed the same for `ms`: for work too slow to do on every keystroke, such as previews. */
+function useDebounced(value, ms) {
+	const [settled, setSettled] = useState(value);
+	useEffect(() => {
+		const timer = setTimeout(() => setSettled(value), ms);
+		return () => clearTimeout(timer);
+	}, [value, ms]);
+	return settled;
+}
+//#endregion
+//#region src/checks-dialog.tsx
+function ProblemList({ content, problems }) {
+	const t = useStrings();
+	return /* @__PURE__ */ jsx("ul", {
+		className: "gfa-check-list",
+		children: problems.map((problem) => /* @__PURE__ */ jsx("li", { children: describeProblem(t, content, problem) }, JSON.stringify(problem)))
+	});
+}
+/**
+* What the site checks found in a publish: errors it would bring stop it,
+* and the rest, which the editor can publish anyway, are listed to fix first.
+*/
+function ChecksDialog({ checks, content, onDecide }) {
+	const t = useStrings();
+	const blocked = checks.blocking.length > 0;
+	return /* @__PURE__ */ jsxs(Dialog, {
+		title: t(blocked ? "checks.blocked.title" : "checks.warnings.title"),
+		onClose: () => onDecide(false),
+		children: [
+			/* @__PURE__ */ jsx("p", { children: t(blocked ? "checks.blocked.intro" : "checks.warnings.intro") }),
+			/* @__PURE__ */ jsx(ProblemList, {
+				content,
+				problems: blocked ? checks.blocking : checks.warnings
+			}),
+			blocked && checks.warnings.length > 0 && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("p", { children: t("checks.alsoWarnings") }), /* @__PURE__ */ jsx(ProblemList, {
+				content,
+				problems: checks.warnings
+			})] }),
+			/* @__PURE__ */ jsxs("div", {
+				className: "gfa-dialog-actions",
+				children: [/* @__PURE__ */ jsx(Button, {
+					onClick: () => onDecide(false),
+					children: t("checks.goBack")
+				}), !blocked && /* @__PURE__ */ jsx(Button, {
+					variant: "primary",
+					onClick: () => onDecide(true),
+					children: t("checks.publishAnyway")
+				})]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/drafts.ts
+const DATABASE = "goodfellow-drafts";
+const TABLE = "drafts";
+const CURRENT_KEY = "goodfellow.draft";
+function request(pending) {
+	return new Promise((resolve, reject) => {
+		pending.onsuccess = () => resolve(pending.result);
+		pending.onerror = () => reject(pending.error);
+	});
+}
+/**
+* Keeps the draft of a site whose backend has no drafts of its own (a
+* full-stack site's server, a demo, the development servers) in the browser's
+* IndexedDB, which can hold uploads too large for local storage, so it stays
+* when the tab closes. `key` tells apart sites served from the same address.
+* Where the browser keeps nothing, such as in some private windows, it's kept
+* only while the page is open.
+*/
+function browserDraftKeeper(key) {
+	if (typeof indexedDB === "undefined") return memoryKeeper();
+	let database;
+	const open = () => {
+		database ??= new Promise((resolve, reject) => {
+			const opening = indexedDB.open(DATABASE, 1);
+			opening.onupgradeneeded = () => opening.result.createObjectStore(TABLE);
+			opening.onsuccess = () => resolve(opening.result);
+			opening.onerror = () => reject(opening.error);
+		});
+		return database;
+	};
+	const table = async (mode) => (await open()).transaction(TABLE, mode).objectStore(TABLE);
+	return {
+		load: async () => await request((await table("readonly")).get(key)),
+		save: async (draft) => {
+			const store = await table("readwrite");
+			if (draft) await request(store.put(draft, key));
+			else await request(store.delete(key));
+		}
+	};
+}
+/** The draft this browser was working in on a site, so it opens again when the admin panel does. */
+function rememberedDraft(site) {
+	try {
+		return localStorage.getItem(`${CURRENT_KEY}:${site}`) ?? void 0;
+	} catch {
+		return;
+	}
+}
+function rememberDraft(site, name) {
+	try {
+		if (name) localStorage.setItem(`${CURRENT_KEY}:${site}`, name);
+		else localStorage.removeItem(`${CURRENT_KEY}:${site}`);
+	} catch {}
+}
+/** When a draft started, from its name (`newDraftName()`), as the computer writes dates, or its name where that doesn't say. */
+function draftStarted(name) {
+	const match = /^(\d{4})(\d{2})(\d{2})-/.exec(name);
+	if (!match) return name;
+	const [, year, month, day] = match;
+	const date = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
+	return Number.isNaN(date.getTime()) ? name : date.toLocaleDateString(void 0, {
+		dateStyle: "long",
+		timeZone: "UTC"
+	});
+}
+//#endregion
+//#region src/frame/channel.ts
+/**
+* Requests and events between the admin panel and a frame running the site's
+* code, over one `MessagePort`. The admin panel's side treats everything a
+* frame sends as untrusted: the site's blocks run there, and could send anything.
+*/
+/** The message the admin panel's page sends a frame once it has loaded, with the port to talk on. */
+const CONNECT_MESSAGE = "goodfellow:connect";
+/** A request the other side refused or couldn't answer. */
+var ChannelError = class extends Error {
+	name = "ChannelError";
+};
+function isMessage(data) {
+	if (typeof data !== "object" || data === null) return false;
+	const type = data.type;
+	return type === "request" || type === "response" || type === "event";
+}
+/** What an error says, as text: errors can't cross the port as they are. */
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function createChannel(port, handlers = {}) {
+	const own = { ...handlers };
+	const pending = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	let next = 1;
+	let closed = false;
+	port.onmessage = async (event) => {
+		const message = event.data;
+		if (!isMessage(message)) return;
+		if (message.type === "response") {
+			const waiting = pending.get(message.id);
+			if (!waiting) return;
+			pending.delete(message.id);
+			if (message.ok) waiting.resolve(message.result);
+			else waiting.reject(new ChannelError(message.error));
+			return;
+		}
+		if (message.type === "event") {
+			for (const listener of listeners.get(message.name) ?? []) listener(message.payload);
+			return;
+		}
+		const handler = typeof message.method === "string" ? Object.hasOwn(own, message.method) && own[message.method] : void 0;
+		if (!handler) {
+			port.postMessage({
+				type: "response",
+				id: message.id,
+				ok: false,
+				error: `No such request: ${message.method}`
+			});
+			return;
+		}
+		try {
+			const result = await handler(message.params);
+			if (!closed) port.postMessage({
+				type: "response",
+				id: message.id,
+				ok: true,
+				result
+			});
+		} catch (error) {
+			if (!closed) port.postMessage({
+				type: "response",
+				id: message.id,
+				ok: false,
+				error: errorText(error)
+			});
+		}
+	};
+	return {
+		call(method, params, transfer = []) {
+			if (closed) return Promise.reject(new ChannelError("The frame has closed."));
+			const id = next++;
+			return new Promise((resolve, reject) => {
+				pending.set(id, {
+					resolve,
+					reject
+				});
+				port.postMessage({
+					type: "request",
+					id,
+					method,
+					params
+				}, transfer);
+			});
+		},
+		emit(name, payload) {
+			if (!closed) port.postMessage({
+				type: "event",
+				name,
+				payload
+			});
+		},
+		on(name, listener) {
+			const set = listeners.get(name) ?? /* @__PURE__ */ new Set();
+			listeners.set(name, set);
+			set.add(listener);
+			return () => set.delete(listener);
+		},
+		handle(method, handler) {
+			own[method] = handler;
+			return () => {
+				if (own[method] === handler) delete own[method];
+			};
+		},
+		close() {
+			closed = true;
+			port.close();
+			for (const waiting of pending.values()) waiting.reject(new ChannelError("The frame has closed."));
+			pending.clear();
+		}
+	};
+}
+//#endregion
+//#region src/frame/protocol.ts
+/** A frame sends this to the admin panel's page once it's listening, and the page answers with a port. */
+const READY_MESSAGE = "goodfellow:frame-ready";
+//#endregion
+//#region src/frame/host.tsx
+/** The only thing frames are allowed: no `allow-same-origin`, so they never reach the admin panel's page or storage. */
+const FRAME_SANDBOX = "allow-scripts";
+function frameClient(channel) {
+	return {
+		call: (method, ...params) => channel.call(method, params[0]),
+		on: (name, listener) => channel.on(name, listener)
+	};
+}
+/** How many times a frame may start again, such as after the development server reloads it, before it's given up on. */
+const MAX_CONNECTIONS = 5;
+/** Each frame's way of loading its page again, for `reloadFrames()`. */
+const reloaders = /* @__PURE__ */ new Set();
+/**
+* Loads every frame's page again, as development servers do once they've
+* rebuilt the frames with the site's new code, leaving the admin panel's own
+* page, and whatever is open on it, as it is. Frames reloaded this way
+* don't count towards the times one may start again.
+*/
+function reloadFrames() {
+	for (const reload of reloaders) reload();
+}
+const FrameServicesContext = createContext(null);
+function FrameServicesProvider({ value, children }) {
+	return /* @__PURE__ */ jsx(FrameServicesContext.Provider, {
+		value,
+		children
+	});
+}
+function useFrameServices() {
+	const value = useContext(FrameServicesContext);
+	if (!value) throw new Error("Frames need the admin panel around them.");
+	return value;
+}
+/** Whether a frame asked to go somewhere it may: one of the admin panel's own screens. */
+function isAdminScreen(href) {
+	return typeof href === "string" && /^#\/[\w\-/?=&%.]*$/.test(href);
+}
+/** Makes a frame of the site's code and connects to it. */
+function useFrame({ mode, onConnect, media }) {
+	const services = useFrameServices();
+	const element = useRef(null);
+	const [client, setClient] = useState();
+	const [failed, setFailed] = useState(false);
+	const latest = useRef({
+		services,
+		onConnect,
+		media
+	});
+	latest.current = {
+		services,
+		onConnect,
+		media
+	};
+	useEffect(() => {
+		let current;
+		let stopRemembering;
+		let connections = 0;
+		let stopped = false;
+		const handlers = {
+			navigate: (href) => {
+				if (isAdminScreen(href)) latest.current.services.navigate(href);
+			},
+			"media.choose": (params) => {
+				const kind = params?.kind;
+				if (kind !== "image" && kind !== "video" && kind !== "file") return null;
+				return latest.current.services.chooseMedia(kind, typeof params.value === "string" ? params.value : "");
+			},
+			"media.bytes": async (url) => {
+				if (typeof url !== "string" || !url.startsWith("/media/") || url.includes("..")) return null;
+				return await (latest.current.media ?? latest.current.services.mediaPreviews).bytes(url) ?? null;
+			}
+		};
+		const onMessage = (event) => {
+			const frame = element.current?.contentWindow;
+			if (!frame || event.source !== frame || event.data !== "goodfellow:frame-ready") return;
+			current?.close();
+			setClient(void 0);
+			connections += 1;
+			if (connections > MAX_CONNECTIONS) {
+				setFailed(true);
+				return;
+			}
+			const { port1, port2 } = new MessageChannel();
+			const channel = createChannel(port1, handlers);
+			current = channel;
+			frame.postMessage({ type: CONNECT_MESSAGE }, "*", [port2]);
+			const next = frameClient(channel);
+			(async () => {
+				try {
+					const { services } = latest.current;
+					const siteCss = mode === "editor" ? await services.siteCss() : void 0;
+					await next.call("init", {
+						...services.init,
+						mode,
+						...siteCss && { siteCss }
+					});
+					const previews = latest.current.media ?? services.mediaPreviews;
+					stopRemembering?.();
+					stopRemembering = previews.onRemember((url, bytes) => {
+						next.call("media.remember", {
+							url,
+							bytes
+						}).catch(() => {});
+					});
+					await latest.current.onConnect?.(next);
+					if (!stopped && current === channel) setClient(next);
+				} catch {
+					if (!stopped && current === channel) setFailed(true);
+				}
+			})();
+		};
+		const reload = () => {
+			connections = 0;
+			setFailed(false);
+			if (element.current) element.current.src = latest.current.services.source.url;
+		};
+		reloaders.add(reload);
+		window.addEventListener("message", onMessage);
+		return () => {
+			stopped = true;
+			reloaders.delete(reload);
+			window.removeEventListener("message", onMessage);
+			stopRemembering?.();
+			current?.close();
+		};
+	}, [mode]);
+	const { source } = services;
+	return {
+		client,
+		failed,
+		frameProps: {
+			ref: useCallback((frame) => {
+				element.current = frame;
+			}, []),
+			sandbox: FRAME_SANDBOX,
+			src: source.url
+		}
+	};
+}
+/** Keeps frames told about the site, the admin panel's light or dark choice, and the like, as they change. */
+function useFrameUpdates(client) {
+	const { content, media, schedule, theme } = useFrameServices().init;
+	useEffect(() => {
+		client?.call("site", {
+			content,
+			media,
+			schedule
+		}).catch(() => {});
+	}, [
+		client,
+		content,
+		media,
+		schedule
+	]);
+	useEffect(() => {
+		client?.call("theme", theme).catch(() => {});
+	}, [client, theme]);
+}
+/** The site's code, run in a hidden frame of its own, for screens that need it without showing anything. */
+function frameSiteCode(client) {
+	return {
+		async sitePages(content, today) {
+			return (await client()).call("code.sitePages", {
+				content,
+				today
+			});
+		},
+		async pageView(page, content, today) {
+			return await (await client()).call("code.pageView", {
+				page,
+				content,
+				today
+			}) ?? void 0;
+		},
+		async renderedProblems(content, targets, today) {
+			return (await client()).call("code.renderedProblems", {
+				content,
+				targets,
+				today
+			});
+		}
+	};
+}
+const HIDDEN = {
+	position: "absolute",
+	width: 0,
+	height: 0,
+	border: 0,
+	visibility: "hidden"
+};
+/**
+* The hidden frame `frameSiteCode()` asks. `onClient` gets a function that
+* answers with the frame once it's connected.
+*/
+function SiteCodeFrame({ onClient }) {
+	const { client, frameProps } = useFrame({ mode: "code" });
+	useEffect(() => onClient(client), [client, onClient]);
+	return /* @__PURE__ */ jsx("iframe", {
+		title: "",
+		"aria-hidden": "true",
+		tabIndex: -1,
+		style: HIDDEN,
+		...frameProps
+	});
+}
+//#endregion
+//#region src/publish-failure.tsx
+/** Explains why a publish from a dialog or form didn't go through. */
+function PublishFailure({ failure }) {
+	const t = useStrings();
+	if (!failure || failure.reason === "checks") return null;
+	return /* @__PURE__ */ jsx(ErrorMessage, {
+		message: t(failure.reason === "conflict" ? "publish.conflict" : "publish.error"),
+		error: failure.error
+	});
+}
+//#endregion
+//#region src/site-host.ts
+/**
+* The host outside GitHub and GitLab that builds the site, as its setup files
+* say, such as Cloudflare Pages: `undefined` while they're read, `null` for none.
+* They're outside the folders the site's files are read from, so they're read
+* as version history reads files, at the loaded revision.
+*/
+function useOutsideHost() {
+	const { readFile, versions, state } = useAdmin();
+	const revision = state.status === "ready" ? state.revision : void 0;
+	const [host, setHost] = useState();
+	useEffect(() => {
+		let cancelled = false;
+		outsideHost(versions && revision ? (path) => versions.readAt(path, revision) : readFile).then((found) => !cancelled && setHost(found ?? null), () => !cancelled && setHost(null));
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		readFile,
+		versions,
+		revision
+	]);
+	return host;
+}
+//#endregion
+//#region src/upload.ts
+/** Photos are made no larger than this on their longest side, which is plenty for any screen. */
+const MAX_IMAGE_SIDE = 2400;
+var UploadError = class extends Error {
+	problem;
+	file;
+	name = "UploadError";
+	constructor(problem, file, message) {
+		super(message);
+		this.problem = problem;
+		this.file = file;
+	}
+};
+const REENCODED = {
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	webp: "image/webp"
+};
+async function canvasBlob(canvas, type) {
+	return new Promise((resolve) => canvas.toBlob(resolve, type, .85));
+}
+/**
+* Re-saves a photo: smaller if it's larger than any screen needs, and always
+* for JPEGs, which drops details hidden in the file such as where it was taken.
+* Returns `undefined` to keep the file as it is.
+*/
+async function resized(file, extension) {
+	const type = REENCODED[extension];
+	if (!type || typeof createImageBitmap !== "function") return void 0;
+	let bitmap;
+	try {
+		bitmap = await createImageBitmap(file, { imageOrientation: "from-image" });
+	} catch {
+		throw new UploadError("unreadable", file.name, `${file.name} couldn't be read as an image.`);
+	}
+	const scale = Math.min(1, MAX_IMAGE_SIDE / Math.max(bitmap.width, bitmap.height));
+	if (scale === 1 && type !== "image/jpeg") {
+		bitmap.close();
+		return;
+	}
+	const canvas = document.createElement("canvas");
+	canvas.width = Math.round(bitmap.width * scale);
+	canvas.height = Math.round(bitmap.height * scale);
+	canvas.getContext("2d")?.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
+	bitmap.close();
+	const blob = await canvasBlob(canvas, type);
+	return blob && (scale < 1 || blob.size < file.size) ? blob : void 0;
+}
+const UNSAFE_SVG_ELEMENTS = [
+	"script",
+	"foreignObject",
+	"iframe",
+	"embed",
+	"object",
+	"audio",
+	"video"
+];
+/**
+* Removes anything from an SVG that could run code if someone opens the
+* file directly: scripts, embedded pages, event handlers, and javascript:, vbscript:
+* and data: links other than images.
+*/
+function cleanSvg(text) {
+	const doc = new DOMParser().parseFromString(text, "image/svg+xml");
+	if (doc.querySelector("parsererror") || doc.documentElement.nodeName.toLowerCase() !== "svg") return void 0;
+	for (const name of UNSAFE_SVG_ELEMENTS) for (const element of [...doc.getElementsByTagName(name)]) element.remove();
+	for (const element of [doc.documentElement, ...doc.documentElement.querySelectorAll("*")]) for (const attribute of [...element.attributes]) {
+		const value = attribute.value.trim().toLowerCase();
+		if (attribute.name.toLowerCase().startsWith("on") || value.startsWith("javascript:") || value.startsWith("vbscript:") || value.startsWith("data:") && !value.startsWith("data:image/")) element.removeAttribute(attribute.name);
+	}
+	return new XMLSerializer().serializeToString(doc);
+}
+/** Checks a file chosen for upload and gets it ready: photos made web-sized, SVGs made safe. */
+async function prepareUpload(file) {
+	const extension = extensionOf(file.name);
+	if (!mediaKind$1(file.name)) throw new UploadError("type", file.name, `${file.name} isn't a kind of file the site can use.`);
+	let blob = file;
+	if (extension === "svg") {
+		const cleaned = cleanSvg(await file.text());
+		if (cleaned === void 0) throw new UploadError("unreadable", file.name, `${file.name} isn't a valid SVG image.`);
+		blob = new Blob([cleaned], { type: "image/svg+xml" });
+	} else blob = await resized(file, extension) ?? file;
+	if (blob.size > MAX_UPLOAD_BYTES) throw new UploadError("size", file.name, `${file.name} is ${blob.size} bytes, over the ${MAX_UPLOAD_BYTES}-byte limit.`);
+	return {
+		name: file.name,
+		bytes: new Uint8Array(await blob.arrayBuffer()),
+		type: blob.type || file.type
+	};
+}
+//#endregion
+//#region src/media-library.tsx
+/** A media file's picture: the image itself, or its kind of file for anything else. */
+function MediaThumb({ url, className }) {
+	const { mediaPreviews } = useAdmin();
+	const [src, setSrc] = useState(() => mediaPreviews.resolve(url));
+	const tried = useRef(false);
+	if (mediaKind$1(url) !== "image") return /* @__PURE__ */ jsx("span", {
+		className: `gfa-media-thumb gfa-media-file ${className ?? ""}`,
+		"aria-hidden": "true",
+		children: extensionOf(url).toUpperCase()
+	});
+	return /* @__PURE__ */ jsx("img", {
+		className: `gfa-media-thumb ${className ?? ""}`,
+		src,
+		alt: "",
+		loading: "lazy",
+		onError: () => {
+			if (tried.current) return;
+			tried.current = true;
+			mediaPreviews.load(url).then((loaded) => loaded && setSrc(loaded));
+		}
+	});
+}
+/** A button that opens the file chooser. */
+function UploadButton({ label, multiple = true, accept, disabled, variant = "primary", onFiles }) {
+	const input = useRef(null);
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Button, {
+		variant,
+		disabled,
+		onClick: () => input.current?.click(),
+		children: label
+	}), /* @__PURE__ */ jsx("input", {
+		ref: input,
+		type: "file",
+		hidden: true,
+		multiple,
+		accept,
+		"aria-label": label,
+		onChange: (event) => {
+			const files = [...event.target.files ?? []];
+			event.target.value = "";
+			if (files.length > 0) onFiles(files);
+		}
+	})] });
+}
+const uploadProblems = {
+	type: "media.error.type",
+	size: "media.error.size",
+	unreadable: "media.error.unreadable"
+};
+/**
+* Uploads files to the media folder in one publish, and shows them in the
+* admin panel straight away. `replace` overwrites one existing file instead.
+*/
+function useUploadMedia() {
+	const t = useStrings();
+	const { publish, mediaPreviews } = useAdmin();
+	const { content, media } = useSiteContent();
+	return async (files, replace) => {
+		const taken = media.map(fileName);
+		const changes = [];
+		const uploads = [];
+		for (const file of files) {
+			let prepared;
+			try {
+				prepared = await prepareUpload(file);
+			} catch (error) {
+				return {
+					ok: false,
+					message: error instanceof UploadError ? t(uploadProblems[error.problem], { name: error.file }) : String(error)
+				};
+			}
+			const path = replace ?? `${MEDIA_DIR}/${uploadName(file.name, taken)}`;
+			taken.push(fileName(path));
+			changes.push({
+				path,
+				bytes: prepared.bytes
+			});
+			uploads.push({
+				url: mediaUrl(path),
+				bytes: prepared.bytes
+			});
+		}
+		for (const upload of uploads) mediaPreviews.remember(upload.url, upload.bytes);
+		const names = changes.map((change) => fileName(change.path)).join(", ");
+		const credits = replace ? withoutCredits(content.credits, [mediaUrl(replace)]) : void 0;
+		const result = await publish(credits ? [...changes, credits] : changes, replace ? t("media.replaceMessage", { name: names }) : t("media.uploadMessage", { names }), { checks: false });
+		if (!result.ok) return {
+			ok: false,
+			message: t(result.reason === "conflict" ? "publish.conflict" : "publish.error"),
+			failure: result
+		};
+		return {
+			ok: true,
+			urls: uploads.map((upload) => upload.url)
+		};
+	};
+}
+function DeleteMediaDialog({ url, onClose }) {
+	const t = useStrings();
+	const { publish } = useAdmin();
+	const { content } = useSiteContent();
+	const [busy, setBusy] = useState(false);
+	const [failure, setFailure] = useState(null);
+	const name = fileName(url);
+	const used = mediaUsage(content, url, {
+		header: t("layout.header"),
+		footer: t("layout.footer"),
+		settings: t("nav.settings"),
+		css: t("settings.tab.css")
+	});
+	const onDelete = async () => {
+		const path = mediaPath(url);
+		if (!path) return;
+		setBusy(true);
+		const credits = withoutCredits(content.credits, [url]);
+		const result = await publish([{
+			path,
+			delete: true
+		}, ...credits ? [credits] : []], t("media.deleteMessage", { name }));
+		setBusy(false);
+		if (result.ok) onClose();
+		else setFailure(result);
+	};
+	return /* @__PURE__ */ jsxs(Dialog, {
+		title: t("media.deleteTitle", { name }),
+		onClose,
+		children: [
+			/* @__PURE__ */ jsx("p", { children: t("media.deleteBody", { name }) }),
+			/* @__PURE__ */ jsx("p", { children: used.length > 0 ? t("media.deleteUsed", { places: used.join(", ") }) : t("media.notUsed") }),
+			/* @__PURE__ */ jsx(PublishFailure, { failure }),
+			/* @__PURE__ */ jsxs("div", {
+				className: "gfa-dialog-actions",
+				children: [/* @__PURE__ */ jsx(Button, {
+					onClick: onClose,
+					children: t("action.cancel")
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "danger",
+					disabled: busy,
+					onClick: () => void onDelete(),
+					children: busy ? t("publish.publishing") : t("media.delete")
+				})]
+			})
+		]
+	});
+}
+/** Who made a photo and its license, which pages that use it show. */
+function MediaCredit({ credit }) {
+	const t = useStrings();
+	const text = [credit.creator, credit.license].filter(Boolean).join(" · ");
+	return /* @__PURE__ */ jsx("span", {
+		className: "gfa-media-credit",
+		title: [credit.title, credit.source].filter(Boolean).join(" · "),
+		children: credit.sourceUrl ? /* @__PURE__ */ jsx("a", {
+			href: credit.sourceUrl,
+			target: "_blank",
+			rel: "noreferrer",
+			children: t("media.credit", { credit: text })
+		}) : t("media.credit", { credit: text })
+	});
+}
+/** Lets files be dropped onto an area to upload them. */
+function DropZone({ onFiles, children }) {
+	const t = useStrings();
+	const [over, setOver] = useState(false);
+	return /* @__PURE__ */ jsxs("section", {
+		className: `gfa-dropzone${over ? " gfa-dropzone-over" : ""}`,
+		"aria-label": t("media.drop"),
+		onDragOver: (event) => {
+			if (!event.dataTransfer.types.includes("Files")) return;
+			event.preventDefault();
+			setOver(true);
+		},
+		onDragLeave: () => setOver(false),
+		onDrop: (event) => {
+			event.preventDefault();
+			setOver(false);
+			const files = [...event.dataTransfer.files];
+			if (files.length > 0) onFiles(files);
+		},
+		children: [children, over && /* @__PURE__ */ jsx("p", {
+			className: "gfa-dropzone-hint",
+			children: t("media.drop")
+		})]
+	});
+}
+function UploadStatus({ status }) {
+	const t = useStrings();
+	if (status.type === "uploading") return /* @__PURE__ */ jsx("p", {
+		className: "gfa-notice",
+		children: t("media.uploading")
+	});
+	if (status.type === "done") return /* @__PURE__ */ jsx("p", {
+		className: "gfa-notice gfa-notice-success",
+		role: "status",
+		children: t("media.uploaded")
+	});
+	if (status.type === "failed") return status.failure ? /* @__PURE__ */ jsx(PublishFailure, { failure: status.failure }) : /* @__PURE__ */ jsx(ErrorMessage, { message: status.message });
+	return null;
+}
+function useUploads() {
+	const upload = useUploadMedia();
+	const [status, setStatus] = useState({ type: "idle" });
+	const run = async (files, replace) => {
+		setStatus({ type: "uploading" });
+		const result = await upload(files, replace);
+		setStatus(result.ok ? { type: "done" } : {
+			type: "failed",
+			message: result.message,
+			failure: result.failure
+		});
+		return result;
+	};
+	return {
+		status,
+		run
+	};
+}
+/** Every uploaded image and file, with buttons to upload, replace and delete them. */
+/** Cloudflare's terms for its CDN, which limit serving video on its free plans. */
+const CLOUDFLARE_TERMS = "https://www.cloudflare.com/service-specific-terms-application-services/";
+function MediaScreen() {
+	const t = useStrings();
+	const { content, media } = useSiteContent();
+	const { status, run } = useUploads();
+	const [query, setQuery] = useState("");
+	const [deleting, setDeleting] = useState(null);
+	const [copied, setCopied] = useState(null);
+	const searchId = useId();
+	useEffect(() => {
+		const stop = (event) => {
+			if (event.dataTransfer?.types.includes("Files")) event.preventDefault();
+		};
+		window.addEventListener("dragover", stop);
+		window.addEventListener("drop", stop);
+		return () => {
+			window.removeEventListener("dragover", stop);
+			window.removeEventListener("drop", stop);
+		};
+	}, []);
+	const cloudflareVideos = useOutsideHost() === "cloudflare-pages" && media.some((path) => mediaKind$1(mediaUrl(path)) === "video");
+	const urls = useMemo(() => media.map(mediaUrl).filter((url) => fileName(url).toLowerCase().includes(query.trim().toLowerCase())).sort((a, b) => fileName(a).localeCompare(fileName(b))), [media, query]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "gfa-screen gfa-screen-wide",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "gfa-screen-header",
+				children: [/* @__PURE__ */ jsx("h1", { children: t("media.title") }), /* @__PURE__ */ jsx(UploadButton, {
+					label: t("media.upload"),
+					disabled: status.type === "uploading",
+					onFiles: (files) => void run(files)
+				})]
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "gfa-hint",
+				children: t("media.intro")
+			}),
+			cloudflareVideos && /* @__PURE__ */ jsxs("p", {
+				className: "gfa-notice",
+				role: "note",
+				children: [
+					t("media.cloudflareVideo"),
+					" ",
+					/* @__PURE__ */ jsx("a", {
+						href: CLOUDFLARE_TERMS,
+						target: "_blank",
+						rel: "noreferrer",
+						children: t("media.cloudflareVideoTerms")
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx(UploadStatus, { status }),
+			media.length > 0 && /* @__PURE__ */ jsxs("div", {
+				className: "gfa-field gfa-media-search",
+				children: [/* @__PURE__ */ jsx("label", {
+					htmlFor: searchId,
+					className: "gfa-label",
+					children: t("media.search")
+				}), /* @__PURE__ */ jsx("input", {
+					id: searchId,
+					className: "gfa-input",
+					type: "search",
+					value: query,
+					onChange: (event) => setQuery(event.target.value)
+				})]
+			}),
+			/* @__PURE__ */ jsx(DropZone, {
+				onFiles: (files) => void run(files),
+				children: media.length === 0 ? /* @__PURE__ */ jsx("p", { children: t("media.empty") }) : urls.length === 0 ? /* @__PURE__ */ jsx("p", { children: t("media.noMatches") }) : /* @__PURE__ */ jsx("ul", {
+					className: "gfa-media-grid",
+					children: urls.map((url) => /* @__PURE__ */ jsxs("li", {
+						className: "gfa-media-card",
+						children: [
+							/* @__PURE__ */ jsx(MediaThumb, { url }),
+							/* @__PURE__ */ jsx("span", {
+								className: "gfa-media-name",
+								title: url,
+								children: fileName(url)
+							}),
+							content.credits?.[url] && /* @__PURE__ */ jsx(MediaCredit, { credit: content.credits[url] }),
+							/* @__PURE__ */ jsxs("div", {
+								className: "gfa-media-actions",
+								children: [
+									/* @__PURE__ */ jsx(Button, {
+										variant: "ghost",
+										onClick: () => void navigator.clipboard?.writeText(url).then(() => setCopied(url), () => setCopied(null)),
+										children: copied === url ? t("media.copied") : t("media.copy")
+									}),
+									/* @__PURE__ */ jsx(UploadButton, {
+										label: t("media.replace"),
+										variant: "secondary",
+										multiple: false,
+										disabled: status.type === "uploading",
+										onFiles: (files) => void run(files.slice(0, 1), mediaPath(url))
+									}),
+									/* @__PURE__ */ jsx(Button, {
+										variant: "ghost",
+										onClick: () => setDeleting(url),
+										children: t("media.delete")
+									})
+								]
+							})
+						]
+					}, url))
+				})
+			}),
+			deleting && /* @__PURE__ */ jsx(DeleteMediaDialog, {
+				url: deleting,
+				onClose: () => setDeleting(null)
+			})
+		]
+	});
+}
+const PICKER_TITLES = {
+	image: "media.pickerTitle",
+	video: "media.pickerTitleVideo",
+	file: "media.pickerTitleFile"
+};
+const CHOOSE_LABELS = {
+	image: "media.choose",
+	video: "media.chooseVideo",
+	file: "media.chooseFile"
+};
+const ACCEPT = {
+	image: "image/*",
+	video: "video/mp4,video/webm",
+	file: void 0
+};
+/** Picks a file from the media library, or uploads a new one, for a field. */
+function MediaPickerDialog({ kind, onSelect, onClose }) {
+	const t = useStrings();
+	const { media } = useSiteContent();
+	const { status, run } = useUploads();
+	const urls = media.map(mediaUrl).filter((url) => kind === "file" || mediaKind$1(url) === kind).sort((a, b) => fileName(a).localeCompare(fileName(b)));
+	return /* @__PURE__ */ jsx(Dialog, {
+		title: t(PICKER_TITLES[kind]),
+		onClose,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "gfa-form",
+			children: [
+				/* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(UploadButton, {
+					label: t("media.upload"),
+					multiple: false,
+					accept: ACCEPT[kind],
+					disabled: status.type === "uploading",
+					onFiles: async (files) => {
+						const result = await run(files.slice(0, 1));
+						const [url] = result.ok ? result.urls : [];
+						if (url) {
+							onSelect(url);
+							onClose();
+						}
+					}
+				}) }),
+				/* @__PURE__ */ jsx(UploadStatus, { status }),
+				urls.length === 0 ? /* @__PURE__ */ jsx("p", {
+					className: "gfa-hint",
+					children: t("media.pickerEmpty")
+				}) : /* @__PURE__ */ jsx("ul", {
+					className: "gfa-media-grid gfa-media-picker",
+					children: urls.map((url) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs("button", {
+						type: "button",
+						className: "gfa-media-card gfa-media-pick",
+						onClick: () => {
+							onSelect(url);
+							onClose();
+						},
+						children: [/* @__PURE__ */ jsx(MediaThumb, { url }), /* @__PURE__ */ jsx("span", {
+							className: "gfa-media-name",
+							children: fileName(url)
+						})]
+					}) }, url))
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "gfa-dialog-actions",
+					children: /* @__PURE__ */ jsx(Button, {
+						onClick: onClose,
+						children: t("action.cancel")
+					})
+				})
+			]
+		})
+	});
+}
+/**
+* Where choosing a file happens, where it isn't here: in the site's frames,
+* the media library opens in the admin panel's own page, which can upload.
+*/
+const MediaChoiceContext = createContext(void 0);
+/** The picture of the chosen file and a button to choose another, shown with a field that holds a media address. */
+function MediaChooser({ value, kind, onChange }) {
+	const t = useStrings();
+	const [open, setOpen] = useState(false);
+	const chooseElsewhere = useContext(MediaChoiceContext);
+	const choose = () => {
+		if (!chooseElsewhere) setOpen(true);
+		else chooseElsewhere(kind, value).then((url) => url !== null && onChange(url));
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "gfa-media-chooser",
+		children: [
+			value && /* @__PURE__ */ jsx(MediaThumb, {
+				url: value,
+				className: "gfa-media-chosen"
+			}, value),
+			/* @__PURE__ */ jsxs("div", {
+				className: "gfa-media-chooser-actions",
+				children: [/* @__PURE__ */ jsx(Button, {
+					onClick: choose,
+					children: t(CHOOSE_LABELS[kind])
+				}), value && /* @__PURE__ */ jsx(Button, {
+					variant: "ghost",
+					onClick: () => onChange(""),
+					children: t("media.clear")
+				})]
+			}),
+			open && /* @__PURE__ */ jsx(MediaPickerDialog, {
+				kind,
+				onSelect: onChange,
+				onClose: () => setOpen(false)
+			})
+		]
+	});
+}
+/** A text field for a media address, with the media chooser below it. For the admin panel's own forms. */
+function MediaField({ label, hint, error, value, kind = "image", onChange }) {
+	return /* @__PURE__ */ jsx(Field, {
+		label,
+		hint,
+		error,
+		children: (props) => /* @__PURE__ */ jsxs("div", {
+			className: "gfa-media-field",
+			children: [/* @__PURE__ */ jsx("input", {
+				...props,
+				className: "gfa-input",
+				value,
+				onChange: (event) => onChange(event.target.value)
+			}), /* @__PURE__ */ jsx(MediaChooser, {
+				value,
+				kind,
+				onChange
+			})]
+		})
+	});
+}
+//#endregion
+//#region src/media-previews.ts
+const TYPES = {
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	avif: "image/avif",
+	svg: "image/svg+xml",
+	ico: "image/x-icon",
+	pdf: "application/pdf",
+	mp3: "audio/mpeg",
+	m4a: "audio/mp4",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	vtt: "text/vtt"
+};
+/** The type to show a file as, from its name. Needed so browsers display SVGs from memory. */
+function mediaType(name) {
+	return TYPES[extensionOf(name)] ?? "application/octet-stream";
+}
+function createMediaPreviews(store, siteUrl) {
+	const local = /* @__PURE__ */ new Map();
+	const remembered = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	const loading = /* @__PURE__ */ new Map();
+	const base = trimChars(siteUrl, "/", { start: false });
+	const remember = (url, bytes) => {
+		const previous = local.get(url);
+		if (previous) URL.revokeObjectURL(previous);
+		remembered.set(url, bytes);
+		for (const listener of listeners) listener(url, bytes);
+		local.set(url, URL.createObjectURL(new Blob([new Uint8Array(bytes)], { type: mediaType(url) })));
+	};
+	return {
+		resolve(url) {
+			if (!url.startsWith("/media/")) return url;
+			return local.get(url) ?? `${base}${url}`;
+		},
+		remember,
+		onRemember(listener) {
+			for (const [url, bytes] of remembered) listener(url, bytes);
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		async bytes(url) {
+			const known = remembered.get(url);
+			if (known) return known;
+			const path = mediaPath(url);
+			return path ? await store.readBytes(path).catch(() => void 0) : void 0;
+		},
+		load(url) {
+			const known = local.get(url);
+			if (known) return Promise.resolve(known);
+			const path = mediaPath(url);
+			if (!path) return Promise.resolve(void 0);
+			let pending = loading.get(url);
+			if (!pending) {
+				pending = store.readBytes(path).then((bytes) => {
+					if (!bytes) return void 0;
+					remember(url, bytes);
+					return local.get(url);
+				}).catch(() => void 0);
+				loading.set(url, pending);
+			}
+			return pending;
+		}
+	};
+}
+const URL_ATTRIBUTES = [
+	"src",
+	"href",
+	"poster"
+];
+const MEDIA_IN_STYLE = /url\((['"]?)(\/media\/[^'")]+)\1\)/g;
+/**
+* Keeps media in a preview document showing: rewrites `/media/…` addresses in
+* images, links and inline styles as the preview changes, and if an image
+* still doesn't load, reads it from the repository instead.
+*/
+function showMediaInPreview(doc, previews) {
+	const fix = (element) => {
+		for (const attribute of URL_ATTRIBUTES) {
+			const value = element.getAttribute(attribute);
+			if (!value?.startsWith("/media/")) continue;
+			const resolved = previews.resolve(value);
+			if (resolved !== value) {
+				element.setAttribute(`data-gf-${attribute}`, value);
+				element.setAttribute(attribute, resolved);
+			}
+		}
+		const style = element.getAttribute("style");
+		if (style?.includes("/media/")) {
+			const resolved = style.replace(MEDIA_IN_STYLE, (_match, quote, url) => `url(${quote}${previews.resolve(url)}${quote})`);
+			if (resolved !== style) element.setAttribute("style", resolved);
+		}
+	};
+	const fixTree = (root) => {
+		fix(root);
+		for (const element of root.querySelectorAll("[src], [href], [poster], [style]")) fix(element);
+	};
+	const observer = new MutationObserver((records) => {
+		for (const record of records) {
+			if (record.type === "attributes" && record.target.nodeType === 1) fix(record.target);
+			for (const node of record.addedNodes) if (node.nodeType === 1) fixTree(node);
+		}
+	});
+	observer.observe(doc.documentElement, {
+		subtree: true,
+		childList: true,
+		attributes: true,
+		attributeFilter: [...URL_ATTRIBUTES, "style"]
+	});
+	fixTree(doc.documentElement);
+	const onError = (event) => {
+		const image = event.target;
+		if (image?.tagName !== "IMG") return;
+		const original = image.getAttribute("data-gf-src") ?? image.getAttribute("src") ?? "";
+		if (!original.startsWith("/media/") || image.hasAttribute("data-gf-loaded")) return;
+		image.setAttribute("data-gf-loaded", "");
+		previews.load(original).then((url) => {
+			if (url) {
+				image.setAttribute("data-gf-src", original);
+				image.setAttribute("src", url);
+			}
+		});
+	};
+	doc.addEventListener("error", onError, true);
+	return () => {
+		observer.disconnect();
+		doc.removeEventListener("error", onError, true);
+	};
+}
+//#endregion
+//#region src/registry-version.ts
+/** The release of Goodfellow's block registry this admin panel was built with, so a site gets blocks that match it. */
+const REGISTRY_VERSION = "0.5.0";
+//#endregion
+//#region src/router.tsx
+function parseHash(hash) {
+	const [path = "", query = ""] = hash.replace(/^#\/?/, "").split("?");
+	return {
+		segments: path.split("/").filter(Boolean),
+		params: new URLSearchParams(query)
+	};
+}
+function subscribe$1(onChange) {
+	window.addEventListener("hashchange", onChange);
+	return () => window.removeEventListener("hashchange", onChange);
+}
+function useRoute() {
+	return parseHash(useSyncExternalStore(subscribe$1, () => window.location.hash, () => ""));
+}
+const guards = /* @__PURE__ */ new Set();
+/** Whether any screen has unpublished changes. */
+function hasUnsavedChanges() {
+	return [...guards].some((isDirty) => isDirty());
+}
+/**
+* Registers a screen's unpublished changes, so leaving it (inside the admin
+* panel or by closing the tab) asks for confirmation first.
+*/
+function useUnsavedChanges(isDirty) {
+	useEffect(() => {
+		if (!isDirty) return;
+		const guard = () => true;
+		guards.add(guard);
+		const onBeforeUnload = (event) => event.preventDefault();
+		window.addEventListener("beforeunload", onBeforeUnload);
+		return () => {
+			guards.delete(guard);
+			window.removeEventListener("beforeunload", onBeforeUnload);
+		};
+	}, [isDirty]);
+}
+/** Goes to another screen, asking first if there are unpublished changes. Returns whether it navigated. */
+function navigate(to, confirmLeave) {
+	if (hasUnsavedChanges() && !confirmLeave()) return false;
+	guards.clear();
+	window.location.hash = to;
+	return true;
+}
+/** Sections of Site Settings' General tab that links can scroll to, as `#/settings/general?section=forms`. */
+const SETTINGS_SECTIONS = {
+	contact: "contact",
+	forms: "forms"
+};
+function pageEditorHref(path) {
+	return `#/pages/edit?path=${encodeURIComponent(path)}`;
+}
+/** An in-app link that asks before leaving a screen with unpublished changes. */
+function Link({ href, confirmLeave, ...props }) {
+	return /* @__PURE__ */ jsx("a", {
+		...props,
+		href,
+		onClick: (event) => {
+			if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey) return;
+			event.preventDefault();
+			navigate(href, confirmLeave);
+		}
+	});
+}
+function collectionHref(id, tab = "entries") {
+	return tab === "entries" ? `#/collections/${id}` : `#/collections/${id}/${tab}`;
+}
+function entryEditorHref(collection, slug) {
+	return `#/collections/${collection}/edit?slug=${encodeURIComponent(slug)}`;
+}
+//#endregion
+//#region src/schedule.tsx
+/** The computer's own time zone, which a site without one takes when something is first scheduled. */
+function computerTimeZone() {
+	return Intl.DateTimeFormat().resolvedOptions().timeZone || void 0;
+}
+/** The time zone schedules are in: the site's, or the computer's, which `scheduleSettingsChanges()` gives it. */
+function scheduleTimeZone(content) {
+	return content.settings.timeZone ?? computerTimeZone();
+}
+/**
+* The change to the site's settings a schedule needs, if any: the computer's
+* time zone, for a site without one, so times mean what the editor meant.
+*/
+function scheduleSettingsChanges(content, schedule) {
+	const zone = computerTimeZone();
+	if (content.settings.timeZone || !zone || !(schedule.showFrom || schedule.hideAfter)) return [];
+	return [siteSettingsFileChange({
+		...content.settings,
+		timeZone: zone
+	})];
+}
+/** A scheduled time as people read it, in the site's language: "29 Nov 2026, 09:00". */
+function formatScheduleTime(time, language) {
+	const ms = wallClock(time);
+	if (ms === void 0) return time;
+	const options = {
+		dateStyle: "medium",
+		timeStyle: "short",
+		timeZone: "UTC"
+	};
+	try {
+		return new Intl.DateTimeFormat(language, options).format(new Date(ms));
+	} catch {
+		return new Intl.DateTimeFormat("en", options).format(new Date(ms));
+	}
+}
+const infoCache = /* @__PURE__ */ new WeakMap();
+/** When scheduled changes go live on this site, and who can read the repository, once the backend has said. */
+function useScheduleInfo() {
+	const { scheduledBuilds, repositoryVisibility } = useAdmin();
+	return useScheduleInfoOf(scheduledBuilds, repositoryVisibility);
+}
+/** `useScheduleInfo()` for a backend's own. */
+function useScheduleInfoOf(scheduledBuilds, repositoryVisibility) {
+	const [info, setInfo] = useState({});
+	useEffect(() => {
+		if (!scheduledBuilds && !repositoryVisibility) return;
+		const key = scheduledBuilds ?? repositoryVisibility;
+		let found = infoCache.get(key);
+		if (!found) {
+			found = Promise.all([scheduledBuilds?.timing().catch(() => void 0), repositoryVisibility?.().catch(() => void 0)]).then(([timing, visibility]) => ({
+				...timing && { timing },
+				...visibility && { visibility }
+			}));
+			infoCache.set(key, found);
+		}
+		let cancelled = false;
+		found.then((next) => {
+			if (!cancelled) setInfo(next);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [scheduledBuilds, repositoryVisibility]);
+	return info;
+}
+const TIMING = {
+	exact: "schedule.timing.exact",
+	hourly: "schedule.timing.hourly",
+	nightly: "schedule.timing.nightly",
+	none: "schedule.timing.none"
+};
+/** When scheduled changes go live, and, where the repository can be read by others, that scheduled content can be too. */
+function ScheduleNotes() {
+	const t = useStrings();
+	const { account, scheduleSyncProblem } = useAdmin();
+	const { timing, visibility } = useScheduleInfo();
+	const host = account?.hostName ?? "";
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [timing && /* @__PURE__ */ jsx("p", {
+		className: "gfa-hint",
+		children: t(scheduleSyncProblem === "not-allowed" ? "schedule.timing.notAllowed" : TIMING[timing], { host })
+	}), (visibility === "public" || visibility === "internal") && /* @__PURE__ */ jsx("p", {
+		className: "gfa-notice gfa-notice-warning",
+		role: "note",
+		children: t(visibility === "public" ? "schedule.public" : "schedule.internal", { host })
+	})] });
+}
+/** Two date and time fields, for when something is shown and hidden again, in the site's time zone. */
+function ScheduleFields({ value, onChange, content, showErrors = true }) {
+	const t = useStrings();
+	const problem = showErrors ? scheduleProblem(value) : void 0;
+	const zone = scheduleTimeZone(content);
+	const set = (key, time) => {
+		const { [key]: _old, ...rest } = value;
+		onChange(time ? {
+			...rest,
+			[key]: time
+		} : rest);
+	};
+	const zoneHint = !zone ? t("schedule.zoneNone") : t(content.settings.timeZone ? "schedule.zone" : "schedule.zoneNew", { zone: zone.replace(/_/g, " ") });
+	return /* @__PURE__ */ jsxs("fieldset", {
+		className: "gfa-schedule",
+		children: [
+			/* @__PURE__ */ jsx("legend", {
+				className: "gfa-label",
+				children: t("schedule.title")
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "gfa-schedule-times",
+				children: [/* @__PURE__ */ jsx(Field, {
+					label: t("schedule.showFrom"),
+					hint: t("schedule.showFromHint"),
+					children: (props) => /* @__PURE__ */ jsx("input", {
+						...props,
+						type: "datetime-local",
+						className: "gfa-input",
+						value: value.showFrom ?? "",
+						onChange: (event) => set("showFrom", event.target.value)
+					})
+				}), /* @__PURE__ */ jsx(Field, {
+					label: t("schedule.hideAfter"),
+					hint: t("schedule.hideAfterHint"),
+					error: problem ? t(problem === "order" ? "schedule.order" : "schedule.invalid") : void 0,
+					children: (props) => /* @__PURE__ */ jsx("input", {
+						...props,
+						type: "datetime-local",
+						className: "gfa-input",
+						value: value.hideAfter ?? "",
+						onChange: (event) => set("hideAfter", event.target.value)
+					})
+				})]
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "gfa-hint",
+				children: zoneHint
+			}),
+			(value.showFrom || value.hideAfter) && /* @__PURE__ */ jsx(ScheduleNotes, {})
+		]
+	});
+}
+/** Whether a page or item is on the site now, for lists: nothing for one that's shown with nothing to come. */
+function ScheduleStatus({ schedule, content }) {
+	const t = useStrings();
+	const { language, timeZone } = content.settings;
+	const state = scheduleState(schedule, /* @__PURE__ */ new Date(), timeZone);
+	const time = (value) => formatScheduleTime(value, language);
+	if (state === "waiting" && schedule.showFrom) return /* @__PURE__ */ jsx("span", {
+		className: "gfa-schedule-status",
+		children: t("schedule.status.waiting", { time: time(schedule.showFrom) })
+	});
+	if (state === "hidden" && schedule.hideAfter) return /* @__PURE__ */ jsx("span", {
+		className: "gfa-schedule-status",
+		children: t("schedule.status.hidden", { time: time(schedule.hideAfter) })
+	});
+	if (schedule.hideAfter) return /* @__PURE__ */ jsx("span", {
+		className: "gfa-schedule-status",
+		children: t("schedule.status.hides", { time: time(schedule.hideAfter) })
+	});
+	return null;
+}
+/** What the site's schedules show and hide next, soonest first, with when it goes live. */
+function ComingUp({ content }) {
+	const t = useStrings();
+	const upcoming = upcomingChanges(content);
+	if (upcoming.length === 0) return null;
+	const { language, timeZone } = content.settings;
+	return /* @__PURE__ */ jsxs("section", {
+		className: "gfa-coming-up",
+		"aria-labelledby": "gfa-coming-up-title",
+		children: [
+			/* @__PURE__ */ jsx("h2", {
+				id: "gfa-coming-up-title",
+				className: "gfa-section-title",
+				children: t("comingUp.title")
+			}),
+			/* @__PURE__ */ jsx("ul", { children: upcoming.map((change) => {
+				const href = change.entry ? entryEditorHref(change.entry.collection, change.entry.slug) : change.path ? pageEditorHref(change.path) : void 0;
+				const collection = change.entry && content.collections.find((item) => item.id === change.entry?.collection);
+				return /* @__PURE__ */ jsxs("li", { children: [
+					/* @__PURE__ */ jsx("time", {
+						dateTime: change.at.toISOString(),
+						children: formatScheduleTime(change.time, language)
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "gfa-coming-up-kind",
+						children: t(change.kind === "show" ? "comingUp.show" : "comingUp.hide")
+					}),
+					href ? /* @__PURE__ */ jsx("a", {
+						href,
+						children: change.title
+					}) : change.title,
+					collection && /* @__PURE__ */ jsx("span", {
+						className: "gfa-hint",
+						children: collection.settings.name
+					})
+				] }, `${change.file} ${change.kind}`);
+			}) }),
+			/* @__PURE__ */ jsx("p", {
+				className: "gfa-hint",
+				children: t("comingUp.zone", { zone: (timeZone ?? "UTC").replace(/_/g, " ") })
+			}),
+			/* @__PURE__ */ jsx(ScheduleNotes, {})
+		]
+	});
+}
+//#endregion
+//#region src/site-icon.ts
+/**
+* Shows the site's icon in the browser tab, as the site's own pages do: the
+* live site's copy, or, for an icon the live site doesn't have yet, the
+* repository's. Returns a function that stops waiting for it.
+*/
+function showSiteIcon(doc, favicon, previews) {
+	let stopped = false;
+	const set = (href) => {
+		if (stopped) return;
+		let link = doc.head.querySelector("link[rel~=\"icon\"]");
+		if (!link) {
+			link = doc.createElement("link");
+			link.rel = "icon";
+			doc.head.append(link);
+		}
+		link.href = href;
+	};
+	const live = previews.resolve(favicon);
+	const probe = new Image();
+	probe.onload = () => set(live);
+	probe.onerror = () => void previews.load(favicon).then((loaded) => loaded && set(loaded));
+	probe.src = live;
+	return () => {
+		stopped = true;
+		probe.onload = probe.onerror = null;
+	};
+}
+//#endregion
+//#region src/theme.ts
+const KEY = "goodfellow-admin-theme";
+const listeners = /* @__PURE__ */ new Set();
+function read() {
+	try {
+		const saved = localStorage.getItem(KEY);
+		return saved === "light" || saved === "dark" ? saved : "system";
+	} catch {
+		return "system";
+	}
+}
+let current;
+function choice() {
+	current ??= read();
+	return current;
+}
+/** Shows the choice: the stylesheet's colors follow `data-gfa-theme`, or the computer's setting without it. */
+function apply(next) {
+	const root = document.documentElement;
+	if (next === "system") delete root.dataset.gfaTheme;
+	else root.dataset.gfaTheme = next;
+}
+function setThemeChoice(next) {
+	current = next;
+	try {
+		if (next === "system") localStorage.removeItem(KEY);
+		else localStorage.setItem(KEY, next);
+	} catch {}
+	apply(next);
+	for (const listener of listeners) listener();
+}
+function subscribe(listener) {
+	listeners.add(listener);
+	const media = matchMedia("(prefers-color-scheme: dark)");
+	media.addEventListener("change", listener);
+	return () => {
+		listeners.delete(listener);
+		media.removeEventListener("change", listener);
+	};
+}
+/** The choice, kept in this browser. */
+function useThemeChoice() {
+	return useSyncExternalStore(subscribe, choice, () => "system");
+}
+/** Applies the choice to the page while the admin panel is open. Used once, by the admin panel itself. */
+function useApplyThemeChoice() {
+	const value = useThemeChoice();
+	useEffect(() => {
+		apply(value);
+		return () => {
+			delete document.documentElement.dataset.gfaTheme;
+		};
+	}, [value]);
+}
+/** Whether the admin panel is dark at the moment, by choice or by the computer's setting. */
+function useDarkMode() {
+	return useSyncExternalStore(subscribe, () => {
+		const value = choice();
+		return value === "dark" || value === "system" && matchMedia("(prefers-color-scheme: dark)").matches;
+	}, () => false);
+}
+//#endregion
+//#region src/admin-context.tsx
+/** Whether the admin panel runs at the site's admin address, once it's checked (`AdminAddress.checked`). */
+function atAdminAddress(admin) {
+	return admin?.checked === true && typeof location !== "undefined" && location.origin === adminOrigin(admin);
+}
+/** Provided by `AdminProvider`, and in the site's frames by a stand-in with only what their components use. */
+const AdminContext = createContext(null);
+/** How long a publish waits for the frame running the site's code before checking without it. */
+const CODE_TIMEOUT = 2e4;
+const DEPLOY_CHECK_INTERVAL = 5e3;
+const DEPLOY_CHECK_LIMIT = 12e5;
+async function load(store) {
+	try {
+		const revision = await store.revision();
+		const [content, media] = await Promise.all([loadSiteContent(store), store.list(MEDIA_DIR)]);
+		return {
+			status: "ready",
+			content,
+			revision,
+			media
+		};
+	} catch (error) {
+		return {
+			status: "error",
+			error
+		};
+	}
+}
+function isGitBackend(store) {
+	return "deployStatus" in store && typeof store.deployStatus === "function";
+}
+/** Tells apart sites served from the same address, for what this browser keeps about each. */
+function siteKey(siteUrl) {
+	return typeof location === "undefined" ? siteUrl : new URL(siteUrl, location.href).href;
+}
+function AdminProvider({ site, frames, store, account, preview, siteUrl, registry, onSignInError, children }) {
+	const t = useStrings();
+	const [state, setState] = useState({ status: "loading" });
+	const [deploy, setDeploy] = useState();
+	const key = siteKey(siteUrl);
+	const backendDrafts = isGitBackend(store) ? store.drafts : void 0;
+	const siteDrafts = useMemo(() => backendDrafts ?? keptDrafts(store, browserDraftKeeper(key)), [
+		backendDrafts,
+		store,
+		key
+	]);
+	const [draft, setDraft] = useState();
+	const [draftFound, setDraftFound] = useState(false);
+	const [draftNames, setDraftNames] = useState([]);
+	const [draftPaths, setDraftPaths] = useState([]);
+	const content = draft?.store ?? store;
+	const [checking, setChecking] = useState();
+	const blocks = useMemo(() => describedConfig(site.description, "template").components, [site.description]);
+	const mediaPreviews = useMemo(() => createMediaPreviews(content, siteUrl), [content, siteUrl]);
+	const outOfReach = registry !== void 0 || atAdminAddress(site.admin) || site.broker !== void 0;
+	const registries = useMemo(() => ({
+		[GOODFELLOW_REGISTRY]: registry ?? goodfellowRegistryUrl("0.5.0"),
+		...outOfReach && {
+			[SHADCN_NAMESPACE]: SHADCN_REGISTRY,
+			...site.registries
+		}
+	}), [
+		registry,
+		site.registries,
+		outOfReach
+	]);
+	const codeFrame = useRef({ waiting: [] });
+	const onCodeClient = useCallback((client) => {
+		codeFrame.current.client = client;
+		if (client) for (const resolve of codeFrame.current.waiting.splice(0)) resolve(client);
+	}, []);
+	const code = useMemo(() => frameSiteCode(() => {
+		const { client, waiting } = codeFrame.current;
+		if (client) return Promise.resolve(client);
+		return new Promise((resolve, reject) => {
+			waiting.push(resolve);
+			setTimeout(() => reject(/* @__PURE__ */ new Error("The site's code didn't start.")), CODE_TIMEOUT);
+		});
+	}), []);
+	const favicon = state.status === "ready" ? state.content.settings.favicon : void 0;
+	useEffect(() => favicon ? showSiteIcon(document, favicon, mediaPreviews) : void 0, [favicon, mediaPreviews]);
+	const readFile = useCallback((path) => content.read(path), [content]);
+	const listFiles = useCallback((dir) => content.list(dir), [content]);
+	const demo = isDemoStore(store) ? store : void 0;
+	const pages = isGitBackend(store) ? store.pages : void 0;
+	const versions = isGitBackend(store) ? store : void 0;
+	const changedPaths = useMemo(() => isGitBackend(store) ? (from, to) => store.changedPaths(from, to) : void 0, [store]);
+	const editors = isGitBackend(store) ? store.editors : void 0;
+	const updates = isGitBackend(store) ? store.updates : void 0;
+	const contentOnly = isGitBackend(store) && store.contentOnly === true;
+	const scheduledBuilds = isGitBackend(store) ? store.scheduledBuilds : void 0;
+	const repositoryVisibility = useMemo(() => isGitBackend(store) ? store.repositoryVisibility?.bind(store) : void 0, [store]);
+	const [scheduleSyncProblem, setScheduleSyncProblem] = useState();
+	const backendOwner = isGitBackend(store) ? store.ownerAccess : void 0;
+	const [ownerActive, setOwnerActive] = useState(backendOwner?.active ?? false);
+	const ownerAccess = useMemo(() => backendOwner && {
+		tokenLink: backendOwner.tokenLink,
+		active: ownerActive,
+		problem: backendOwner.problem,
+		...backendOwner.startRedirect && { startRedirect: (options) => backendOwner.startRedirect?.(options) ?? Promise.resolve() },
+		async applyToken(token) {
+			await backendOwner.applyToken(token);
+			setOwnerActive(true);
+		},
+		forget() {
+			backendOwner.forget();
+			setOwnerActive(false);
+		}
+	}, [backendOwner, ownerActive]);
+	useEffect(() => {
+		if (!demo) return;
+		demo.changes().then((changes) => {
+			for (const change of changes) if ("bytes" in change && change.path.startsWith(`${MEDIA_DIR}/`)) mediaPreviews.remember(mediaUrl(change.path), change.bytes);
+		});
+	}, [demo, mediaPreviews]);
+	const loadedFrom = useRef(void 0);
+	const views = useRef(0);
+	const loadFrom = useCallback(async (from) => {
+		loadedFrom.current = from;
+		const view = views.current;
+		const next = await load(from);
+		if (next.status === "error" && next.error instanceof SignInError) onSignInError?.(next.error);
+		if (loadedFrom.current === from) setState(next.status === "ready" ? {
+			...next,
+			view
+		} : next);
+	}, [onSignInError]);
+	const reload = useCallback(() => loadFrom(content), [loadFrom, content]);
+	useEffect(() => {
+		let cancelled = false;
+		(async () => {
+			const names = await siteDrafts.list().catch(() => []);
+			const remembered = rememberedDraft(key);
+			const opened = remembered && names.includes(remembered) ? await siteDrafts.open(remembered).catch(() => void 0) : void 0;
+			if (!opened) rememberDraft(key, void 0);
+			if (cancelled) return;
+			setDraftNames(names);
+			setDraft(opened);
+			setDraftFound(true);
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [siteDrafts, key]);
+	useEffect(() => {
+		if (draftFound && loadedFrom.current !== content) reload();
+	}, [
+		draftFound,
+		content,
+		reload
+	]);
+	const refreshDrafts = useCallback(async (current) => {
+		const [names, paths] = await Promise.all([siteDrafts.list().catch(() => []), current ? current.paths().catch(() => []) : []]);
+		setDraftNames(names);
+		setDraftPaths(paths);
+	}, [siteDrafts]);
+	useEffect(() => {
+		if (draftFound) refreshDrafts(draft);
+	}, [
+		draftFound,
+		draft,
+		refreshDrafts
+	]);
+	/** Shows the site checks' dialog where they found anything, and says whether to go ahead. */
+	const confirmChecks = useCallback(async (checks) => {
+		if (!checks || checks.blocking.length === 0 && checks.warnings.length === 0) return true;
+		const go = await new Promise((decide) => setChecking({
+			checks,
+			content: checks.content,
+			decide
+		}));
+		setChecking(void 0);
+		return go;
+	}, []);
+	const publish = useCallback(async (changes, message, options) => {
+		if (state.status !== "ready") return {
+			ok: false,
+			reason: "error",
+			error: /* @__PURE__ */ new Error("The site isn't loaded.")
+		};
+		const checks = options?.checks === false ? void 0 : await checkPublish(content, state, changes, {
+			blocks,
+			code
+		});
+		if (!await confirmChecks(checks)) return {
+			ok: false,
+			reason: "checks",
+			error: void 0
+		};
+		let target = draft;
+		let started;
+		let revision;
+		try {
+			let expectedRevision = state.revision;
+			if (!target && options?.draft) {
+				target = started = await siteDrafts.create(newDraftName(), { from: state.revision });
+				expectedRevision = await started.store.revision();
+			}
+			({revision} = await writeChanges(target?.store ?? store, changes, {
+				message,
+				expectedRevision
+			}));
+		} catch (error) {
+			if (started) await started.discard().catch(() => void 0);
+			if (error instanceof SignInError && error.problem === "invalid") onSignInError?.(error);
+			return {
+				ok: false,
+				reason: error instanceof ConflictError ? "conflict" : "error",
+				error
+			};
+		}
+		if (started) {
+			rememberDraft(key, started.name);
+			setDraft(started);
+		} else if (target) refreshDrafts(target);
+		else if (isGitBackend(store)) setDeploy({
+			revision,
+			previous: state.revision,
+			state: "building"
+		});
+		await loadFrom(target?.store ?? store);
+		return { ok: true };
+	}, [
+		store,
+		content,
+		draft,
+		siteDrafts,
+		key,
+		state,
+		blocks,
+		code,
+		confirmChecks,
+		refreshDrafts,
+		loadFrom,
+		onSignInError
+	]);
+	const openDraft = useCallback(async (name) => {
+		if (name === draft?.name) return true;
+		let next;
+		try {
+			next = name ? await siteDrafts.open(name) : void 0;
+		} catch (error) {
+			if (!(error instanceof DraftError)) throw error;
+			refreshDrafts(draft);
+			return false;
+		}
+		rememberDraft(key, name);
+		views.current++;
+		setDraft(next);
+		return true;
+	}, [
+		draft,
+		siteDrafts,
+		key,
+		refreshDrafts
+	]);
+	const publishAll = useCallback(async () => {
+		if (!draft) return {
+			ok: false,
+			reason: "error",
+			error: /* @__PURE__ */ new Error("There's no draft open.")
+		};
+		let changes;
+		let live;
+		try {
+			[changes, live] = await Promise.all([draft.changes(), load(store)]);
+		} catch (error) {
+			return {
+				ok: false,
+				reason: "error",
+				error
+			};
+		}
+		if (live.status !== "ready") return {
+			ok: false,
+			reason: "error",
+			error: live.status === "error" && live.error
+		};
+		if (!await confirmChecks(await checkPublish(store, live, changes, {
+			blocks,
+			code
+		}))) return {
+			ok: false,
+			reason: "checks",
+			error: void 0
+		};
+		let revision;
+		try {
+			({revision} = await draft.publish(t("draft.message", { name: draft.name })));
+		} catch (error) {
+			if (error instanceof SignInError && error.problem === "invalid") onSignInError?.(error);
+			return {
+				ok: false,
+				reason: error instanceof ConflictError ? "conflict" : "error",
+				error
+			};
+		}
+		rememberDraft(key, void 0);
+		if (isGitBackend(store)) setDeploy({
+			revision,
+			previous: live.revision,
+			state: "building"
+		});
+		views.current++;
+		setDraft(void 0);
+		return { ok: true };
+	}, [
+		draft,
+		store,
+		blocks,
+		code,
+		key,
+		t,
+		confirmChecks,
+		onSignInError
+	]);
+	const submitDraft = useCallback(async () => {
+		if (!draft) return {
+			ok: false,
+			error: /* @__PURE__ */ new Error("There's no draft open.")
+		};
+		try {
+			const paths = await draft.paths();
+			const { url } = await draft.submitForReview({
+				title: t("draft.reviewTitle", { name: draft.name }),
+				description: [
+					t("draft.reviewDescription"),
+					"",
+					...paths.map((path) => `- \`${path}\``)
+				].join("\n")
+			});
+			return {
+				ok: true,
+				url
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error
+			};
+		}
+	}, [draft, t]);
+	const discardDraft = useCallback(async () => {
+		if (!draft) return { ok: true };
+		try {
+			await draft.discard();
+		} catch (error) {
+			return {
+				ok: false,
+				error
+			};
+		}
+		rememberDraft(key, void 0);
+		views.current++;
+		setDraft(void 0);
+		return { ok: true };
+	}, [draft, key]);
+	const drafts = useMemo(() => ({
+		kept: backendDrafts === void 0,
+		names: draftNames,
+		...draft && { current: {
+			name: draft.name,
+			paths: draftPaths
+		} },
+		open: openDraft,
+		publishAll,
+		submit: submitDraft,
+		discard: discardDraft
+	}), [
+		backendDrafts,
+		draftNames,
+		draft,
+		draftPaths,
+		openDraft,
+		publishAll,
+		submitDraft,
+		discardDraft
+	]);
+	const syncedTimes = useRef(void 0);
+	useEffect(() => {
+		const sync = scheduledBuilds?.sync?.bind(scheduledBuilds);
+		if (!sync || state.status !== "ready") return;
+		const times = [...new Set(upcomingChanges(state.content).map((change) => change.at.getTime()))];
+		const key = times.join(" ");
+		if (key === syncedTimes.current || syncedTimes.current === void 0 && times.length === 0) return;
+		syncedTimes.current = key;
+		sync(times.map((time) => new Date(time))).then(() => setScheduleSyncProblem(void 0), (error) => {
+			if (error instanceof ScheduledBuildsError) setScheduleSyncProblem(error.problem);
+			else syncedTimes.current = void 0;
+		});
+	}, [scheduledBuilds, state]);
+	useEffect(() => {
+		if (deploy?.state !== "building" || !isGitBackend(store)) return;
+		const started = Date.now();
+		let cancelled = false;
+		let timer;
+		const check = async () => {
+			const status = await store.deployStatus(deploy.revision).catch(() => ({ state: "unknown" }));
+			if (cancelled) return;
+			if (status.state === "building" && Date.now() - started < DEPLOY_CHECK_LIMIT) timer = setTimeout(check, DEPLOY_CHECK_INTERVAL);
+			else setDeploy({
+				revision: deploy.revision,
+				previous: deploy.previous,
+				...status
+			});
+		};
+		timer = setTimeout(check, DEPLOY_CHECK_INTERVAL);
+		return () => {
+			cancelled = true;
+			clearTimeout(timer);
+		};
+	}, [deploy, store]);
+	const followBuild = useCallback(() => {
+		if (state.status === "ready" && isGitBackend(store)) setDeploy({
+			revision: state.revision,
+			previous: state.revision,
+			state: "building"
+		});
+	}, [state, store]);
+	const value = useMemo(() => ({
+		site,
+		blocks,
+		code,
+		preview,
+		siteUrl,
+		state,
+		account,
+		deploy,
+		mediaPreviews,
+		reload,
+		publish,
+		drafts,
+		readFile,
+		listFiles,
+		registries,
+		outOfReach,
+		demo,
+		pages,
+		versions,
+		changedPaths,
+		editors,
+		ownerAccess,
+		updates,
+		contentOnly,
+		scheduledBuilds,
+		repositoryVisibility,
+		scheduleSyncProblem,
+		followBuild
+	}), [
+		site,
+		blocks,
+		code,
+		preview,
+		siteUrl,
+		state,
+		account,
+		deploy,
+		mediaPreviews,
+		reload,
+		publish,
+		drafts,
+		readFile,
+		listFiles,
+		registries,
+		outOfReach,
+		demo,
+		pages,
+		versions,
+		changedPaths,
+		editors,
+		ownerAccess,
+		updates,
+		contentOnly,
+		scheduledBuilds,
+		repositoryVisibility,
+		scheduleSyncProblem,
+		followBuild
+	]);
+	const table = useStringTable();
+	const strings = useMemo(() => draft ? {
+		...table,
+		"publish.button": table["draft.add"],
+		"publish.publishing": table["draft.adding"],
+		"publish.done": table["draft.added"]
+	} : table, [draft, table]);
+	return /* @__PURE__ */ jsx(AdminContext.Provider, {
+		value,
+		children: /* @__PURE__ */ jsxs(StringsProvider, {
+			strings,
+			children: [state.status === "ready" ? /* @__PURE__ */ jsx(SiteFrames, {
+				frames,
+				state,
+				onCodeClient,
+				children
+			}) : children, checking && /* @__PURE__ */ jsx(ChecksDialog, {
+				checks: checking.checks,
+				content: checking.content,
+				onDecide: checking.decide
+			})]
+		})
+	});
+}
+/** The site's compiled CSS as text, read once, for the editor's frame, which can't read anything itself. */
+function useSiteCss(stylesheets) {
+	const key = stylesheets.join("\n");
+	return useMemo(() => {
+		let found;
+		return () => {
+			found ??= Promise.all(key.split("\n").filter(Boolean).map((href) => fetch(href).then((response) => response.ok ? response.text() : "").catch(() => "")));
+			return found;
+		};
+	}, [key]);
+}
+/**
+* What the site's frames are told and can ask for, once the site has loaded,
+* and the hidden frame that runs the site's code for the screens.
+*/
+function SiteFrames({ frames, state, onCodeClient, children }) {
+	const t = useStrings();
+	const strings = useStringTable();
+	const theme = useThemeChoice();
+	const { preview, siteUrl, mediaPreviews, account, scheduledBuilds, repositoryVisibility, scheduleSyncProblem } = useAdmin();
+	const { timing, visibility } = useScheduleInfoOf(scheduledBuilds, repositoryVisibility);
+	const schedule = useMemo(() => ({
+		...timing && { timing },
+		...visibility && { visibility },
+		...scheduleSyncProblem && { syncProblem: scheduleSyncProblem }
+	}), [
+		timing,
+		visibility,
+		scheduleSyncProblem
+	]);
+	const siteCss = useSiteCss(preview.stylesheets);
+	const [choosing, setChoosing] = useState();
+	const confirmLeave = t("unsaved.confirm");
+	const services = useMemo(() => ({
+		source: frames,
+		init: {
+			content: state.content,
+			media: state.media,
+			schedule,
+			siteUrl,
+			preview,
+			strings,
+			theme,
+			hostName: account?.hostName ?? ""
+		},
+		siteCss,
+		mediaPreviews,
+		chooseMedia: (kind) => new Promise((resolve) => {
+			setChoosing((current) => {
+				current?.resolve(null);
+				return {
+					kind,
+					resolve
+				};
+			});
+		}),
+		navigate: (href) => navigate(href, () => window.confirm(confirmLeave))
+	}), [
+		frames,
+		state,
+		schedule,
+		siteUrl,
+		preview,
+		strings,
+		theme,
+		account,
+		siteCss,
+		mediaPreviews,
+		confirmLeave
+	]);
+	return /* @__PURE__ */ jsxs(FrameServicesProvider, {
+		value: services,
+		children: [
+			children,
+			/* @__PURE__ */ jsx(SiteCodeFrame, { onClient: onCodeClient }),
+			choosing && /* @__PURE__ */ jsx(MediaPickerDialog, {
+				kind: choosing.kind,
+				onSelect: (url) => {
+					choosing.resolve(url);
+					setChoosing(void 0);
+				},
+				onClose: () => {
+					choosing.resolve(null);
+					setChoosing(void 0);
+				}
+			})
+		]
+	});
+}
+/** Whether the signed-in person may change Site Settings, blocks, and collections' settings and templates. */
+function useCanChangeSettings() {
+	return useAdmin().account?.role !== "editor";
+}
+function useAdmin() {
+	const value = useContext(AdminContext);
+	if (!value) throw new Error("useAdmin() must be used inside <Admin>.");
+	return value;
+}
+/** The loaded site. Only call from screens rendered once loading has finished. */
+function useSiteContent() {
+	const { state } = useAdmin();
+	if (state.status !== "ready") throw new Error("The site isn't loaded yet.");
+	return state;
+}
+//#endregion
+//#region src/preview.tsx
+function upsert(doc, key, tag, setup) {
+	let element = doc.head.querySelector(`[data-gf="${key}"]`);
+	if (!element) {
+		element = doc.createElement(tag);
+		element.dataset.gf = key;
+		setup(element);
+		doc.head.append(element);
+	}
+	return element;
+}
+/**
+* Styles a preview document like the live site: the site's compiled CSS, the
+* theme being edited, and the custom CSS being edited. Tailwind runs in the
+* browser too, so classes typed in the editor take effect before the site is rebuilt.
+*/
+function installPreviewStyles(doc, options, styles) {
+	doc.documentElement.setAttribute(COLOR_SCHEME_ATTRIBUTE, styles.theme.darkMode ? styles.scheme : "light");
+	options.stylesheets.forEach((href, index) => {
+		upsert(doc, `stylesheet-${index}`, "link", (link) => {
+			link.rel = "stylesheet";
+			link.href = href;
+		});
+	});
+	const fonts = googleFontsUrl(styles.theme);
+	const fontsLink = doc.head.querySelector("[data-gf=\"fonts\"]");
+	if (fonts) upsert(doc, "fonts", "link", (link) => {
+		link.rel = "stylesheet";
+	}).href = fonts;
+	else fontsLink?.remove();
+	upsert(doc, "theme", "style", () => {}).textContent = themeToCss(styles.theme);
+	const tailwindCss = escapeStyleText(`${options.themeCss}\n${styles.customCss}`);
+	const current = doc.head.querySelector("[data-gf=\"tailwind\"]");
+	if (current?.textContent !== tailwindCss) {
+		current?.remove();
+		const style = doc.createElement("style");
+		style.type = "text/tailwindcss";
+		style.dataset.gf = "tailwind";
+		style.textContent = tailwindCss;
+		doc.head.append(style);
+	}
+	if (options.tailwindBrowserUrl) {
+		const url = options.tailwindBrowserUrl;
+		upsert(doc, "tailwind-browser", "script", (script) => {
+			script.src = url;
+		});
+	}
+}
+/** Keeps links in a preview from navigating away from the editor. */
+function preventNavigation(doc) {
+	if (doc.documentElement.dataset.gfNoNavigate) return;
+	doc.documentElement.dataset.gfNoNavigate = "true";
+	doc.addEventListener("click", (event) => {
+		if (event.target?.closest?.("a[href]")) event.preventDefault();
+	});
+}
+/**
+* Applies preview styles to a document whenever the theme or custom CSS
+* change, and keeps its media showing: the site's own, or `media`, such as the
+* site's media as it was at an earlier publish.
+*/
+function usePreviewStyles(doc, styles, media) {
+	const { preview, mediaPreviews: current } = useAdmin();
+	const mediaPreviews = media ?? current;
+	const dark = useDarkMode();
+	const scheme = styles.scheme ?? (dark ? "dark" : "light");
+	useEffect(() => {
+		if (!doc) return;
+		preventNavigation(doc);
+		installPreviewStyles(doc, preview, {
+			...styles,
+			scheme
+		});
+	}, [
+		doc,
+		preview,
+		styles,
+		scheme
+	]);
+	useEffect(() => doc ? showMediaInPreview(doc, mediaPreviews) : void 0, [doc, mediaPreviews]);
+}
+const FRAME_WIDTH = 1280;
+/**
+* A scaled-down, read-only view of a page as it will look on a desktop screen,
+* rendered by the site's code in a sandboxed frame of its own, so the site's
+* styles and the admin panel's don't mix and its blocks can't reach the admin panel.
+*/
+function PreviewFrame({ title, show, media }) {
+	const container = useRef(null);
+	const [scale, setScale] = useState(.5);
+	const [height, setHeight] = useState(800);
+	const latest = useRef(show);
+	latest.current = show;
+	const { client, frameProps } = useFrame({
+		mode: "render",
+		onConnect: useCallback(async (client) => {
+			if (latest.current) await client.call("render.show", latest.current);
+		}, []),
+		...media && { media }
+	});
+	useFrameUpdates(client);
+	useEffect(() => {
+		if (client && show) client.call("render.show", show).catch(() => {});
+	}, [client, show]);
+	useEffect(() => {
+		const element = container.current;
+		if (!element) return;
+		let frame = 0;
+		const observer = new ResizeObserver(([entry]) => {
+			if (!entry) return;
+			const { width, height } = entry.contentRect;
+			cancelAnimationFrame(frame);
+			frame = requestAnimationFrame(() => {
+				setScale(Math.min(1, width / FRAME_WIDTH));
+				setHeight(height);
+			});
+		});
+		observer.observe(element);
+		return () => {
+			cancelAnimationFrame(frame);
+			observer.disconnect();
+		};
+	}, []);
+	return /* @__PURE__ */ jsx("div", {
+		ref: container,
+		className: "gfa-preview",
+		children: /* @__PURE__ */ jsx("iframe", {
+			title,
+			...frameProps,
+			style: {
+				width: FRAME_WIDTH,
+				height: height / scale,
+				transform: `scale(${scale})`
+			}
+		})
+	});
+}
+//#endregion
+//#region src/entry-values.ts
+/**
+* Where the item's schedule is among the values Puck edits. Fields' names are
+* lowercase letters, numbers and hyphens, so none can have this one.
+*/
+const SCHEDULE_PROP = "_schedule";
+/** The values Puck edits: the entry's stored values, with every field present so Puck shows it, and its schedule. */
+function formValues(collection, entry) {
+	const values = { ...entry.content.fields };
+	for (const field of collection.settings.fields) if (values[field.name] === void 0 && field.type !== "number") values[field.name] = "";
+	values[SCHEDULE_PROP] = scheduleOf(entry.content);
+	return values;
+}
+//#endregion
+export { defaultStrings as $, MediaChoiceContext as A, storedCss as At, useFrameUpdates as B, navigate as C, newCollectionSettings as Ct, REGISTRY_VERSION as D, redirectsFileChange as Dt, useUnsavedChanges as E, pageTitle as Et, useOutsideHost as F, editedMarkdown as Ft, Button as G, CONNECT_MESSAGE as H, PublishFailure as I, formattedHtml as It, Field as J, Dialog as K, FrameServicesProvider as L, MediaField as M, storedEntryFields as Mt, MediaScreen as N, uniqueName as Nt, createMediaPreviews as O, siteSettingsFileChange as Ot, prepareUpload as P, updateSettingsFileChange as Pt, StringsProvider as Q, reloadFrames as R, hasUnsavedChanges as S, movePageChanges as St, useRoute as T, pageFileChange as Tt, createChannel as U, READY_MESSAGE as V, draftStarted as W, TextField as X, PublishedNotice as Y, useDebounced as Z, scheduleSettingsChanges as _, entryFileChange$1 as _t, AdminContext as a, mediaUrl as at, collectionHref as b, menusFileChange as bt, useCanChangeSettings as c, addressPatternFor as ct, useApplyThemeChoice as d, codeFileChanges as dt, useStringTable as et, useDarkMode as f, collectionFileChange$1 as ft, ScheduleStatus as g, duplicatePageData as gt, ScheduleFields as h, deleteCollectionChanges as ht, usePreviewStyles as i, fileName as it, MediaChooser as j, storedData as jt, showMediaInPreview as k, slugify as kt, useSiteContent as l, checkEntrySlug as lt, ComingUp as m, customCssFileChange as mt, formValues as n, describeContrast as nt, AdminProvider as o, siteImages as ot, useThemeChoice as p, collectionSettingsChanges as pt, ErrorMessage as q, PreviewFrame as r, findPage as rt, useAdmin as s, uploadName as st, SCHEDULE_PROP as t, useStrings as tt, setThemeChoice as u, checkPageAddress as ut, Link as v, layoutFileChange as vt, pageEditorHref as w, newPageData as wt, entryEditorHref as x, moveEntryChanges as xt, SETTINGS_SECTIONS as y, mediaFileChange as yt, useFrame as z };