@getquick/content 0.2.0 → 0.3.0

package/dist/server.js

@@ -1,4 +1,4 @@
-import { a as routeOf, d as routeLanguage, f as siteLanguages, g as renderWordPressBlocks, h as parseWordPressBlocks, l as isLanguageHome, m as hasVideoHero, r as menuItemHref, s as uriPath, t as cmsTime, u as languageSubject } from "./formatting-wOk2jz6J.js";
+import { _ as uriPath, a as siteLanguages, b as parseWordPressBlocks, c as parseDesignBlocks, d as decodeEntities, g as stripHtml, h as routeOf, i as routeLanguage, l as renderDesignPattern, n as isLanguageHome, p as menuItemHref, r as languageSubject, u as cmsTime, x as renderWordPressBlocks, y as hasVideoHero } from "./site-language-cBP8SFrS.js";
 import { t as bearerMatches } from "./bearer-DMOCoSci.js";
 import { _ as consentConfiguration } from "./state-BYWc5TUB.js";
 import { i as rewriteEmbeds, l as parseLegalLanguage } from "./embeds-p9SyGNZI.js";
@@ -3536,7 +3536,7 @@ const unionType = ZodUnion.create;
 ZodDiscriminatedUnion.create;
 ZodIntersection.create;
 ZodTuple.create;
-ZodRecord.create;
+const recordType = ZodRecord.create;
 ZodMap.create;
 ZodSet.create;
 ZodFunction.create;
@@ -3737,7 +3737,8 @@ function publicationStore(db) {
              RETURNING event_id`).bind(event.nodeId, event.id, event.occurredAt).first()))?.event_id ?? null;
 		},
 		async entryIndex() {
-			const [entries, withdrawals] = await guard("be read", () => db.batch([db.prepare(`SELECT p.key, p.state, p.node_id, p.modified_at, coalesce(a.attempted_at, 0) AS attempted_at
+			const [entries, withdrawals] = await guard("be read", () => db.batch([db.prepare(`SELECT p.key, p.state, p.node_id, p.modified_at, p.read_started_at,
+               coalesce(a.attempted_at, 0) AS attempted_at
              FROM publications p LEFT JOIN refresh_attempts a ON a.key = p.key
              WHERE substr(p.key, 1, 6) = 'entry:'
              ORDER BY p.key`), db.prepare("SELECT node_id, withdrawn_at FROM withdrawals WHERE republished_at IS NULL")]));
@@ -3747,6 +3748,7 @@ function publicationStore(db) {
 					state: row.state,
 					nodeId: row.node_id,
 					modifiedAt: row.modified_at,
+					readStartedAt: row.read_started_at,
 					attemptedAt: row.attempted_at
 				})),
 				withdrawals: new Map(withdrawals.results.map((row) => [row.node_id, row.withdrawn_at]))
@@ -3791,7 +3793,7 @@ function publicationStore(db) {
 		},
 		async status() {
 			const [shared, entries, withdrawals, failed] = await guard("be read", () => db.batch([
-				db.prepare("SELECT key, state, format FROM publications WHERE key IN ('home', 'chrome', 'design')"),
+				db.prepare("SELECT key, state, format FROM publications WHERE key IN ('home', 'chrome', 'design', 'archives')"),
 				db.prepare(`SELECT CASE WHEN format = ?1 THEN state ELSE 'unusable' END AS state, count(*) AS count
                FROM publications WHERE substr(key, 1, 6) = 'entry:' GROUP BY 1`).bind(1),
 				db.prepare("SELECT count(*) AS count FROM withdrawals WHERE republished_at IS NULL"),
@@ -3808,11 +3810,47 @@ function publicationStore(db) {
 				home: state("home"),
 				chrome: state("chrome"),
 				design: state("design"),
+				...state("archives") === null ? {} : { archives: state("archives") },
 				entries: Object.fromEntries(entries.results.map((row) => [row.state, Number(row.count)])),
 				withdrawals: count(withdrawals),
 				failedEvents: count(failed)
 			};
 		},
+		async listItems(filter, limit, offset) {
+			const { where, values } = itemsWhere(filter);
+			const { results } = await guard("be read", () => db.prepare(`SELECT key, body, modified_at, count(*) OVER () AS total FROM publications p
+             WHERE ${where}
+             ORDER BY json_extract(p.body, '$.date') DESC, p.key
+             LIMIT ? OFFSET ?`).bind(...values, limit, offset).all());
+			let total = Number(results[0]?.total ?? 0);
+			if (results.length === 0 && offset > 0) {
+				const row = await guard("be read", () => db.prepare(`SELECT count(*) AS total FROM publications p WHERE ${where}`).bind(...values).first());
+				total = Number(row?.total ?? 0);
+			}
+			return {
+				items: results.map((row) => ({
+					key: row.key,
+					body: row.body,
+					modifiedAt: row.modified_at
+				})),
+				total
+			};
+		},
+		async itemTerms(filter, path) {
+			const { where, values } = itemsWhere(filter);
+			const { results } = await guard("be read", () => db.prepare(`SELECT json_extract(t.value, '$.slug') AS slug,
+                    max(json_extract(t.value, '$.name')) AS name,
+                    count(DISTINCT p.key) AS count
+             FROM publications p, json_each(p.body, ?) AS t
+             WHERE ${where} AND json_type(t.value, '$.slug') = 'text'
+             GROUP BY 1
+             ORDER BY 2 COLLATE NOCASE, 1`).bind(path, ...values).all());
+			return results.map((row) => ({
+				slug: row.slug,
+				name: row.name ?? row.slug,
+				count: Number(row.count)
+			}));
+		},
 		async startEvent(id) {
 			await guard("record an event", () => db.prepare("UPDATE publication_events SET attempts = attempts + 1 WHERE id = ?").bind(id).run());
 		},
@@ -3827,6 +3865,33 @@ function publicationStore(db) {
 		}
 	};
 }
+/** The WHERE clause (on `publications p`) for a collection's items, and its values in order. */
+function itemsWhere(filter) {
+	const clauses = [
+		"substr(p.key, 1, 6) = 'entry:'",
+		"p.state = 'published'",
+		"p.format = ?",
+		"json_extract(p.body, '$.collection.name') = ?"
+	];
+	const values = [1, filter.collection];
+	if (filter.language !== null) {
+		clauses.push("coalesce(json_extract(p.body, '$.language'), ?) = ?");
+		values.push(filter.defaultLanguage, filter.language);
+	}
+	if (filter.search !== null) {
+		clauses.push("instr(json_extract(p.body, '$.collection.search'), ?) > 0");
+		values.push(filter.search);
+	}
+	for (const { path, slugs } of filter.terms) {
+		clauses.push(`EXISTS (SELECT 1 FROM json_each(p.body, ?) AS term
+         WHERE json_extract(term.value, '$.slug') IN (SELECT slug.value FROM json_each(?) AS slug))`);
+		values.push(path, JSON.stringify(slugs));
+	}
+	return {
+		where: clauses.join(" AND "),
+		values
+	};
+}
 function movedTo(body) {
 	try {
 		const uri = JSON.parse(body ?? "null")?.uri;
@@ -3837,7 +3902,7 @@ function movedTo(body) {
 }
 //#endregion
 //#region frontend/src/reconciliation.ts
-function configuredReconciliation(languages, delivery, wordpress) {
+function configuredReconciliation(languages, delivery, wordpress, collections = false) {
 	const { eachLimited, reconcileShared, refreshEntries, sharedOutcomes } = delivery;
 	const { getPublishedEntries } = wordpress;
 	const isLanguageHome$4 = (route) => isLanguageHome(route, languages);
@@ -3848,10 +3913,24 @@ function configuredReconciliation(languages, delivery, wordpress) {
 	* is asked again without them. Chrome and design have no block recovery.
 	*/
 	const REQUESTS_PER_READ = 2;
-	/** Reserve design once, and each language's home (including recovery) and chrome. */
-	const SHARED_REQUESTS = 1 + 3 * languages.length;
-	/** Stored entries re-read each run, when the budget allows, though WordPress lists them unchanged. */
+	/**
+	* Reserve design once (and the archives, on a Site with collections), and
+	* each language's home (including recovery) and chrome.
+	*/
+	const SHARED_REQUESTS = 1 + (collections ? 2 : 0) + 3 * languages.length;
+	/**
+	* Stored entries re-read each run, when the budget allows, though WordPress
+	* lists them unchanged: published ones, and listed routes settled missing.
+	*/
 	const VERIFIED_PER_RUN = 2;
+	/**
+	* How much later than an entry's modification time a read must have started
+	* for the missing row it stored to count as settled. The read's start is
+	* the Frontend's clock (ms) and the modification time the CMS's (floored to
+	* the second): the margin covers that rounding and any skew between the two
+	* hosts, so a change made just after a read isn't taken as already read.
+	*/
+	const SETTLED_CLOCK_MARGIN_MS = 3e5;
 	/** How long a run holds the lease; an interrupted run's lease is taken over after it. */
 	const LEASE_MS = 12e4;
 	const ENTRY = "entry:";
@@ -3904,7 +3983,7 @@ function configuredReconciliation(languages, delivery, wordpress) {
 		}
 	}
 	async function run(store, startedAt, siteOrigin, publish) {
-		const [shared, listing] = await Promise.all([reconcileShared(store, siteOrigin), getPublishedEntries()]);
+		const [{ archiveRoutes = [], ...shared }, listing] = await Promise.all([reconcileShared(store, siteOrigin), getPublishedEntries()]);
 		const failures = [];
 		let changed = 0;
 		for (const outcome of sharedOutcomes(shared)) {
@@ -3931,9 +4010,10 @@ function configuredReconciliation(languages, delivery, wordpress) {
 		}
 		const { entries: listed, requests } = listing.content;
 		const index = await store.entryIndex();
-		const found = candidates(listed, index);
+		const { found, settled } = candidates(listed, index);
 		let budget = CMS_REQUEST_BUDGET - SHARED_REQUESTS - requests;
 		const chosen = [];
+		found.unshift(...archived(archiveRoutes, found));
 		let pending = 0;
 		for (const candidate of found) {
 			const cost = (candidate.previousRoute ? 2 : 1) * REQUESTS_PER_READ;
@@ -3944,7 +4024,7 @@ function configuredReconciliation(languages, delivery, wordpress) {
 			budget -= cost;
 			chosen.push(candidate);
 		}
-		if (pending === 0) chosen.push(...verified(index, found, Math.floor(budget / REQUESTS_PER_READ)));
+		if (pending === 0) chosen.push(...verified(index, found, settled, Math.floor(budget / REQUESTS_PER_READ)));
 		const entries = await refresh(store, chosen, publish);
 		for (const outcome of Object.values(entries)) {
 			if (outcome.outcome === "kept") failures.push(outcome.failure);
@@ -3967,7 +4047,8 @@ function configuredReconciliation(languages, delivery, wordpress) {
 		};
 	}
 	/**
-	* What differs between WordPress's list and the store, oldest-attempted first.
+	* What differs between WordPress's list and the store (found),
+	* oldest-attempted first, and the listed routes settled missing (settled).
 	* WordPress's front page (`/`) is the homepage's, reconciled with the shared
 	* rows, unless it is withdrawn and modified since.
 	*/
@@ -3979,6 +4060,7 @@ function configuredReconciliation(languages, delivery, wordpress) {
 			storedAt.set(row.nodeId, [...storedAt.get(row.nodeId) ?? [], row.key.slice(6)]);
 		}
 		const found = [];
+		const settled = /* @__PURE__ */ new Set();
 		const listedRoutes = /* @__PURE__ */ new Set();
 		const left = /* @__PURE__ */ new Set();
 		for (const entry of listed) {
@@ -3999,6 +4081,10 @@ function configuredReconciliation(languages, delivery, wordpress) {
 			if (isLanguageHome$4(route)) continue;
 			if (row?.state === "published" && entry.id !== null && row.nodeId === entry.id && entry.modifiedAt !== null && row.modifiedAt === entry.modifiedAt) continue;
 			const previousRoute = entry.id === null ? void 0 : storedAt.get(entry.id)?.find((stored) => stored !== route);
+			if (row?.state === "missing" && !previousRoute && entry.modifiedAt !== null && row.readStartedAt - SETTLED_CLOCK_MARGIN_MS > entry.modifiedAt) {
+				settled.add(route);
+				continue;
+			}
 			if (previousRoute) left.add(previousRoute);
 			found.push({
 				change: previousRoute ? "moved" : row ? "changed" : "new",
@@ -4017,12 +4103,33 @@ function configuredReconciliation(languages, delivery, wordpress) {
 				attemptedAt: row.attemptedAt
 			});
 		}
-		return found.sort((a, b) => a.attemptedAt - b.attemptedAt || (a.route < b.route ? -1 : a.route > b.route ? 1 : 0));
+		found.sort((a, b) => a.attemptedAt - b.attemptedAt || (a.route < b.route ? -1 : a.route > b.route ? 1 : 0));
+		return {
+			found,
+			settled
+		};
+	}
+	/** The addresses whose archive moved, unless already a change, as changes. */
+	function archived(routes, found) {
+		const changing = new Set(found.flatMap(({ route, previousRoute }) => [route, previousRoute]));
+		return routes.filter((route) => !changing.has(route) && !isLanguageHome$4(route)).map((route) => ({
+			change: "archive",
+			route,
+			attemptedAt: 0
+		}));
 	}
-	/** Up to `limit` (and VERIFIED_PER_RUN) stored entries no change was found in, oldest-attempted first. */
-	function verified(index, found, limit) {
+	/**
+	* Up to `limit` (and VERIFIED_PER_RUN) stored entries no change was found
+	* in, published or settled missing, oldest-attempted first. Other missing
+	* rows (a 404 looked up at an address WordPress doesn't list) aren't re-read.
+	*/
+	function verified(index, found, settled, limit) {
 		const changing = new Set(found.flatMap(({ route, previousRoute }) => [route, previousRoute]));
-		return index.entries.filter((row) => row.state === "published" && !changing.has(row.key.slice(6))).sort((a, b) => a.attemptedAt - b.attemptedAt).slice(0, Math.max(0, Math.min(limit, VERIFIED_PER_RUN))).map((row) => ({
+		return index.entries.filter((row) => {
+			const route = row.key.slice(6);
+			if (changing.has(route)) return false;
+			return row.state === "published" || row.state === "missing" && settled.has(route);
+		}).sort((a, b) => a.attemptedAt - b.attemptedAt).slice(0, Math.max(0, Math.min(limit, VERIFIED_PER_RUN))).map((row) => ({
 			change: "verified",
 			route: row.key.slice(6),
 			attemptedAt: row.attemptedAt
@@ -4053,11 +4160,11 @@ function configuredReconciliation(languages, delivery, wordpress) {
 			};
 			try {
 				const { body } = await publish(store, publication);
-				if (body.status === "refreshed") outcomes[candidate.route] = {
+				if (body.status === "refreshed" && !body.duplicate) outcomes[candidate.route] = {
 					change: candidate.change,
 					outcome: "refreshed"
 				};
-				else if (body.status === "superseded") superseded.push(candidate);
+				else if (body.status === "refreshed" || body.status === "superseded") superseded.push(candidate);
 				else outcomes[candidate.route] = {
 					change: candidate.change,
 					outcome: "kept",
@@ -4134,7 +4241,7 @@ function configuredReconciliation(languages, delivery, wordpress) {
 //#endregion
 //#region frontend/src/events.ts
 function configuredEvents(config, languages, delivery, wordpress) {
-	const { reconcile } = configuredReconciliation(languages, delivery, wordpress);
+	const { reconcile } = configuredReconciliation(languages, delivery, wordpress, Object.keys(config.collections ?? {}).length > 0);
 	const SITE = config.site;
 	const isLanguageHome$3 = (route) => isLanguageHome(route, languages);
 	const routeLanguage$3 = (route) => routeLanguage(route, languages);
@@ -4211,15 +4318,19 @@ function configuredEvents(config, languages, delivery, wordpress) {
 	* The shared settings an event can name, and what each change refreshes: the
 	* menus and the logo are in the chrome every page is served with; the site's
 	* identity is its title and tagline (the front page's) and its icon (the
-	* chrome's); the design presets are the shared design every page uses.
+	* chrome's); the design presets are the shared design every page uses; the
+	* patterns are GQ Design's synced patterns and Header & Footer selection,
+	* the chrome's header and footer.
 	*/
 	const SETTINGS = {
 		menus: ["chrome"],
 		logo: ["chrome"],
 		identity: ["home", "chrome"],
 		design: ["design"],
+		patterns: ["chrome"],
 		legal: ["chrome"],
-		analytics: ["chrome"]
+		analytics: ["chrome"],
+		archives: ["archives"]
 	};
 	/**
 	* What a change in one language refreshes, for the settings a language has
@@ -4565,7 +4676,7 @@ function configuredEvents(config, languages, delivery, wordpress) {
 		await store.startEvent(event.id);
 		const language = languages.find((each) => each.slug === event.language);
 		const { refreshed, ...parts } = await refreshShared(store, language ? [...LANGUAGE_SETTINGS[event.setting]] : [...SETTINGS[event.setting]], siteOrigin, language);
-		const failure = sharedOutcomes(parts).find((outcome) => outcome.outcome === "kept");
+		const failure = [...sharedOutcomes(parts), ...Object.values(parts.entries ?? {})].find((outcome) => outcome.outcome === "kept");
 		await store.finishEvent(recorded, failure?.outcome === "kept" ? {
 			status: "failed",
 			reason: failure.failure.reason,
@@ -4661,10 +4772,32 @@ function configuredRefresh(languages, delivery) {
 function publishedHtml(languages, transform) {
 	const defaultLanguage = languages[0];
 	const languageOf = (slug, fallback) => languages.find((language) => language.slug === slug) ?? fallback;
+	const blocks = (list, language) => list.map((block) => ({
+		...block,
+		content: block.content === null ? null : transform(block.content, language),
+		children: blocks(block.children, language)
+	}));
+	const pattern = (value, language) => value ? {
+		...value,
+		blocks: blocks(value.blocks, language)
+	} : value;
+	/** A language's chrome, its header and footer patterns' HTML transformed. */
+	function chrome(value, language = defaultLanguage) {
+		if (!transform || !value || !value.header && !value.footer) return value;
+		return {
+			...value,
+			header: pattern(value.header, language) ?? null,
+			footer: pattern(value.footer, language) ?? null
+		};
+	}
 	function home(delivery, language = defaultLanguage) {
+		const served = languageOf(language.slug, defaultLanguage);
+		if (transform && delivery.kind === "missing") return {
+			...delivery,
+			chrome: chrome(delivery.chrome, served)
+		};
 		if (!transform || delivery.kind !== "found") return delivery;
 		const { home } = delivery.content;
-		const served = languageOf(language.slug, defaultLanguage);
 		return {
 			...delivery,
 			content: {
@@ -4675,11 +4808,16 @@ function publishedHtml(languages, transform) {
 						...home.page,
 						content: transform(home.page.content, served)
 					}
-				}
+				},
+				chrome: chrome(delivery.content.chrome, served)
 			}
 		};
 	}
 	function entry(delivery, routeLanguage) {
+		if (transform && delivery.kind === "missing") return {
+			...delivery,
+			chrome: chrome(delivery.chrome, routeLanguage)
+		};
 		if (!transform || delivery.kind !== "found") return delivery;
 		const { entry } = delivery.content;
 		const served = languageOf(entry.language, routeLanguage);
@@ -4690,24 +4828,28 @@ function publishedHtml(languages, transform) {
 				entry: {
 					...entry,
 					content: transform(entry.content, served)
-				}
+				},
+				chrome: chrome(delivery.content.chrome, served)
 			}
 		};
 	}
 	return {
 		home,
-		entry
+		entry,
+		chrome
 	};
 }
 //#endregion
 //#region frontend/src/delivery.ts
 function configuredDelivery(config, languages, wordpress, transformHtml) {
 	const defaultLanguage = languages[0];
+	const collections = config.collections ?? {};
+	const hasCollections = Object.keys(collections).length > 0;
 	const html = publishedHtml(languages, transformHtml);
 	const multilingual = languages.length > 1;
 	const routeLanguage$1 = (route) => routeLanguage(route, languages);
 	const isLanguageHome$1 = (route) => isLanguageHome(route, languages);
-	const { getHomeContent, getEntryByUri, getSiteChrome, getDesignPresets, getPublishedRoutes } = wordpress;
+	const { getHomeContent, getEntryByUri, getSiteChrome, getDesignPresets, getPublishedRoutes, getArchives } = wordpress;
 	const HOME = "home";
 	const CHROME = "chrome";
 	/**
@@ -4719,6 +4861,8 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 	const chromeKey = (language) => language.isDefault ? CHROME : `${CHROME}:${language.slug}`;
 	/** The design presets every page is served with, once a refresh has stored them. */
 	const DESIGN = "design";
+	/** Where each collection's archive is, on a Site with collections. */
+	const ARCHIVES = "archives";
 	/** Entries are stored at "entry:<route>". */
 	const ENTRY = "entry:";
 	const entryKey = (route) => `${ENTRY}${route}`;
@@ -4785,7 +4929,24 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 		uri: stringType(),
 		language: stringType()
 	});
+	const term = objectType({
+		slug: stringType(),
+		name: stringType()
+	});
+	/**
+	* The collection an item is in, with its terms; stored with the text a
+	* search matches (`search`), which isn't served.
+	*/
+	const membership = objectType({
+		name: stringType(),
+		terms: recordType(arrayType(term)),
+		search: stringType().optional()
+	}).transform(({ name, terms }) => ({
+		name,
+		terms
+	}));
 	const entryPublication = objectType({
+		collection: membership.optional(),
 		language: stringType().optional(),
 		translations: arrayType(translation).optional(),
 		id: stringType(),
@@ -4816,10 +4977,22 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 		roles: arrayType(legalRole),
 		missingRequired: arrayType(stringType())
 	}).nullable();
+	const designBlock = lazyType(() => objectType({
+		name: stringType().min(1),
+		attributes: recordType(stringType(), unknownType()),
+		content: stringType().nullable(),
+		children: arrayType(designBlock)
+	}));
+	const designPattern = objectType({
+		title: stringType(),
+		blocks: arrayType(designBlock).min(1)
+	}).nullable();
 	const siteChrome = objectType({
 		menuItems: arrayType(menuItem),
 		siteIcon: image,
 		siteLogo: image,
+		header: designPattern.optional().transform((pattern) => pattern ?? null),
+		footer: designPattern.optional().transform((pattern) => pattern ?? null),
 		legal: legal.optional(),
 		analytics: objectType({
 			enabled: booleanType(),
@@ -4830,6 +5003,7 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 		spacingSizes,
 		colors
 	});
+	const archives = recordType(stringType());
 	const parseWith = (schema) => (body) => {
 		const parsed = schema.safeParse(body);
 		return parsed.success ? parsed.data : void 0;
@@ -4838,10 +5012,13 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 	const parseChrome = parseWith(siteChrome);
 	const parseEntry = parseWith(entryPublication);
 	const parseDesign = parseWith(designPresets);
+	const parseArchives = parseWith(archives);
 	const emptyChrome = {
 		menuItems: [],
 		siteIcon: null,
-		siteLogo: null
+		siteLogo: null,
+		header: null,
+		footer: null
 	};
 	async function boundStore() {
 		const { PUBLICATION_DB } = await config.bindings();
@@ -5185,16 +5362,18 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 	async function refreshSite(store, siteOrigin) {
 		const readStartedAt = Date.now();
 		const others = languages.filter((language) => !language.isDefault);
-		const [home, chrome, design, listing, ...otherReads] = await Promise.all([
+		const [home, chrome, design, archiveRead, listing, ...otherReads] = await Promise.all([
 			getHomeContent(),
 			getSiteChrome(siteOrigin),
 			getDesignPresets(),
+			hasCollections ? getArchives() : void 0,
 			getPublishedRoutes(),
 			...others.map((language) => Promise.all([getHomeContent(language), getSiteChrome(siteOrigin, { language })]))
 		]);
 		const homeOutcome = await promoteHome(store, home, readStartedAt);
 		const chromeOutcome = await promoteChrome(store, chrome, readStartedAt);
 		const designOutcome = await promoteDesign(store, design, readStartedAt);
+		const archivesOutcome = archiveRead ? await promoteArchives(store, archiveRead, readStartedAt) : void 0;
 		const languageOutcomes = {};
 		for (const [index, language] of others.entries()) {
 			const [languageHome, languageChrome] = otherReads[index];
@@ -5234,10 +5413,11 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 		}
 		return {
 			ready,
-			refreshed: homeOutcome.outcome !== "kept" && chromeOutcome.outcome !== "kept" && designOutcome.outcome !== "kept" && Object.values(languageOutcomes).every((outcomes) => outcomes.home.outcome !== "kept" && outcomes.chrome.outcome !== "kept") && routes.outcome === "listed" && entries.refreshed,
+			refreshed: homeOutcome.outcome !== "kept" && chromeOutcome.outcome !== "kept" && designOutcome.outcome !== "kept" && archivesOutcome?.outcome !== "kept" && Object.values(languageOutcomes).every((outcomes) => outcomes.home.outcome !== "kept" && outcomes.chrome.outcome !== "kept") && routes.outcome === "listed" && entries.refreshed,
 			home: homeOutcome,
 			chrome: chromeOutcome,
 			design: designOutcome,
+			...archivesOutcome ? { archives: archivesOutcome } : {},
 			routes,
 			entries: entries.entries,
 			moved: entries.moved,
@@ -5250,6 +5430,7 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 			rows.home,
 			rows.chrome,
 			rows.design,
+			rows.archives,
 			...Object.values(rows.languages ?? {}).flatMap((language) => [language.home, language.chrome])
 		].filter((outcome) => outcome !== void 0);
 	}
@@ -5269,7 +5450,11 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 		const readStartedAt = Date.now();
 		const wanted = new Set(parts);
 		const scope = language ? [language] : languages;
-		const [reads, design] = await Promise.all([Promise.all(scope.map((each) => Promise.all([wanted.has("home") ? getHomeContent(each) : void 0, wanted.has("chrome") ? getSiteChrome(siteOrigin, { language: each }) : void 0]))), wanted.has("design") && !language ? getDesignPresets() : void 0]);
+		const [reads, design, archiveRead] = await Promise.all([
+			Promise.all(scope.map((each) => Promise.all([wanted.has("home") ? getHomeContent(each) : void 0, wanted.has("chrome") ? getSiteChrome(siteOrigin, { language: each }) : void 0]))),
+			wanted.has("design") && !language ? getDesignPresets() : void 0,
+			wanted.has("archives") && !language && hasCollections ? getArchives() : void 0
+		]);
 		const report = { refreshed: true };
 		for (const [index, each] of scope.entries()) {
 			const [home, chrome] = reads[index];
@@ -5278,7 +5463,15 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 			if (chrome) rows.chrome = await promoteChrome(store, chrome, readStartedAt, each);
 		}
 		if (design) report.design = await promoteDesign(store, design, readStartedAt);
-		report.refreshed = sharedOutcomes(report).every((outcome) => outcome.outcome !== "kept");
+		if (archiveRead) {
+			const before = archiveRead.kind === "found" ? await storedArchives(store) : void 0;
+			report.archives = await promoteArchives(store, archiveRead, readStartedAt);
+			if (archiveRead.kind === "found" && report.archives.outcome !== "kept") {
+				const routes = archiveRoutes(before, archiveRead.content, "all");
+				if (routes.length > 0) report.entries = (await refreshEntries(store, routes)).entries;
+			}
+		}
+		report.refreshed = [...sharedOutcomes(report), ...Object.values(report.entries ?? {})].every((outcome) => outcome.outcome !== "kept");
 		return report;
 	}
 	/**
@@ -5305,7 +5498,11 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 	*/
 	async function reconcileShared(store, siteOrigin) {
 		const readStartedAt = Date.now();
-		const [reads, design] = await Promise.all([Promise.all(languages.map((language) => Promise.all([getHomeContent(language), getSiteChrome(siteOrigin, { language })]))), getDesignPresets()]);
+		const [reads, design, archiveRead] = await Promise.all([
+			Promise.all(languages.map((language) => Promise.all([getHomeContent(language), getSiteChrome(siteOrigin, { language })]))),
+			getDesignPresets(),
+			hasCollections ? getArchives() : void 0
+		]);
 		const unchanged = async (key, parse, read) => {
 			if (!read) return false;
 			try {
@@ -5338,10 +5535,22 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 				chrome: await unchanged(chromeKey(language), parseChrome, sharedRead(chrome)) ? { outcome: "unchanged" } : await promoteChrome(store, chrome, readStartedAt, language)
 			});
 		}
+		let archives;
+		let changedArchives = [];
+		if (archiveRead) {
+			const before = await storedArchives(store);
+			if (await unchanged(ARCHIVES, parseArchives, sharedRead(archiveRead))) archives = { outcome: "unchanged" };
+			else {
+				archives = await promoteArchives(store, archiveRead, readStartedAt);
+				if (archiveRead.kind === "found" && archives.outcome === "promoted") changedArchives = archiveRoutes(before, archiveRead.content, "changed");
+			}
+		}
 		const [own, ...others] = outcomes;
 		return {
 			...own,
 			design: await unchanged(DESIGN, parseDesign, sharedRead(design)) ? { outcome: "unchanged" } : await promoteDesign(store, design, readStartedAt),
+			...archives ? { archives } : {},
+			...changedArchives.length > 0 ? { archiveRoutes: changedArchives } : {},
 			...multilingual ? { languages: Object.fromEntries(others.map((outcome, index) => [languages[index + 1].slug, outcome])) } : {}
 		};
 	}
@@ -5365,6 +5574,36 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 	function promoteDesign(store, read, readStartedAt) {
 		return promoteShared(store, DESIGN, "the shared design presets", parseDesign, read, readStartedAt);
 	}
+	/** Where each collection's archive is, as stored; undefined when it can't be read. */
+	async function storedArchives(store) {
+		try {
+			const stored = await store.read(ARCHIVES, parseArchives);
+			return stored?.state === "published" ? stored.content : void 0;
+		} catch (error) {
+			if (!(error instanceof StoreFailure)) throw error;
+			return;
+		}
+	}
+	/**
+	* The archive addresses to read again after a read of where the archives
+	* are: every address before or after it ("all"), or only the old and new
+	* address of each post type whose archive moved ("changed"). A language's
+	* front page is its home's, never an entry.
+	*/
+	function archiveRoutes(before, after, which) {
+		const routes = /* @__PURE__ */ new Set();
+		for (const type of /* @__PURE__ */ new Set([...Object.keys(before ?? {}), ...Object.keys(after)])) {
+			const old = before?.[type];
+			const now = after[type];
+			if (which === "changed" && old === now) continue;
+			for (const uri of [old, now]) if (uri) routes.add(routeOf(uri));
+		}
+		return [...routes].filter((route) => !isLanguageHome$1(route));
+	}
+	/** Promotes a read of where each collection's archive is. */
+	function promoteArchives(store, read, readStartedAt) {
+		return promoteShared(store, ARCHIVES, "the archives", parseArchives, read, readStartedAt);
+	}
 	/**
 	* Refreshes a language's front page only (not its chrome or the entries): the
 	* front page itself was published or changed.
@@ -5465,7 +5704,7 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 		}
 		const outcome = await promote(canonical, () => ({
 			state: "published",
-			content: entry,
+			content: stored(entry),
 			nodeId: entry.id,
 			modifiedAt
 		}));
@@ -5490,6 +5729,18 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 			found
 		};
 	}
+	/** An entry as stored: a collection's item with the text its search matches. */
+	function stored(entry) {
+		if (!entry.collection) return entry;
+		const search = searchText(decodeEntities(`${entry.title} ${stripHtml(entry.excerpt)}`));
+		return {
+			...entry,
+			collection: {
+				...entry.collection,
+				search
+			}
+		};
+	}
 	/**
 	* Every other route still serving an entry that was just found at its own
 	* route is marked moved there, unless it was read since `readBefore`: a
@@ -5613,6 +5864,151 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 			withdrawn
 		};
 	}
+	/** The collection's config, or an error: a Site only lists what it declares. */
+	function collectionNamed(name) {
+		if (!Object.hasOwn(collections, name)) throw new Error(`${name} isn't a collection`);
+		return collections[name];
+	}
+	/** A taxonomy's terms in an item's stored body, as a JSON path. */
+	const termsPath = (taxonomy) => `$.collection.terms."${taxonomy}"`;
+	/** The language a listing is in: a multilingual Site's (by slug), else none. */
+	function listingLanguage(slug) {
+		if (!multilingual) return null;
+		if (slug === void 0) return defaultLanguage.slug;
+		if (!languages.some((language) => language.slug === slug)) throw new Error(`${slug} isn't one of the Site's languages`);
+		return slug;
+	}
+	/**
+	* A page of a collection's items, from the store alone: never WordPress,
+	* so a listing is served through outages as its items are. Items whose
+	* stored body this Frontend can't serve are left out.
+	*/
+	async function list(query) {
+		const collection = collectionNamed(query.collection);
+		const subject = `the ${query.collection} collection`;
+		const page = Math.max(1, whole("page", query.page, 1));
+		const perPage = Math.min(100, Math.max(1, whole("perPage", query.perPage, 12)));
+		const taxonomies = collection.taxonomies ?? [];
+		const terms = Object.entries(query.terms ?? {}).flatMap(([taxonomy, slugs]) => {
+			if (!taxonomies.includes(taxonomy)) throw new Error(`${taxonomy} isn't one of the ${query.collection} collection's taxonomies`);
+			return slugs.length > 0 ? [{
+				path: termsPath(taxonomy),
+				slugs: [...slugs]
+			}] : [];
+		});
+		const search = searchText(query.search ?? "");
+		const filter = {
+			collection: query.collection,
+			language: listingLanguage(query.language),
+			defaultLanguage: defaultLanguage.slug,
+			terms,
+			search: search || null
+		};
+		const store = await listingStore(subject);
+		if ("kind" in store) return store;
+		let found;
+		try {
+			found = await store.listItems(filter, perPage, (page - 1) * perPage);
+		} catch (error) {
+			if (!(error instanceof StoreFailure)) throw error;
+			return notServed(subject, "store", error.message);
+		}
+		return {
+			kind: "found",
+			items: found.items.flatMap((row) => {
+				let entry;
+				try {
+					entry = parseEntry(JSON.parse(row.body));
+				} catch {
+					entry = void 0;
+				}
+				if (!entry) {
+					console.error(`Delivery: ${row.key} is stored with a body this Frontend can't read`);
+					return [];
+				}
+				return [{
+					uri: entry.uri,
+					title: entry.title,
+					date: entry.date,
+					modifiedAt: row.modifiedAt,
+					excerpt: entry.excerpt,
+					featuredImage: entry.featuredImage,
+					terms: Object.fromEntries(taxonomies.map((taxonomy) => [taxonomy, entry.collection?.terms[taxonomy] ?? []])),
+					...entry.extension !== void 0 ? { extension: entry.extension } : {},
+					...entry.language !== void 0 ? { language: entry.language } : {}
+				}];
+			}),
+			total: found.total,
+			page,
+			pages: Math.ceil(found.total / perPage)
+		};
+	}
+	/** A listing's whole-number option (as a number, or a string of one, from a URL), else its default. */
+	function whole(option, value, fallback) {
+		if (value === void 0 || value === null || value === "") return fallback;
+		const number = Number(value);
+		if (!Number.isFinite(number)) throw new Error(`${option} must be a number, not ${JSON.stringify(value)}`);
+		return Math.floor(number);
+	}
+	/** The terms of a collection's taxonomy its stored items have, with how many have each. */
+	async function terms(name, taxonomy, options = {}) {
+		if (!(collectionNamed(name).taxonomies ?? []).includes(taxonomy)) throw new Error(`${taxonomy} isn't one of the ${name} collection's taxonomies`);
+		const subject = `the ${name} collection's ${taxonomy}`;
+		const filter = {
+			collection: name,
+			language: listingLanguage(options.language),
+			defaultLanguage: defaultLanguage.slug,
+			terms: [],
+			search: null
+		};
+		const store = await listingStore(subject);
+		if ("kind" in store) return store;
+		try {
+			return {
+				kind: "found",
+				terms: await store.itemTerms(filter, termsPath(taxonomy))
+			};
+		} catch (error) {
+			if (!(error instanceof StoreFailure)) throw error;
+			return notServed(subject, "store", error.message);
+		}
+	}
+	/** The store a listing reads, or why there is none: a listing is never read live. */
+	async function listingStore(subject) {
+		if (!config.isServer()) return notServed(subject, "not-ready", "Content delivery requires a server context");
+		let store;
+		try {
+			store = await boundStore();
+		} catch {
+			return notServed(subject, "store", "The publication store couldn't be loaded");
+		}
+		if (!store) return notServed(subject, "not-ready", "this Frontend has no publication store bound (PUBLICATION_DB); collections are only listed from one");
+		return store;
+	}
+	/**
+	* Where a collection's archive is: the stored archives when there is a
+	* store, else (in explicit development) a live read. Null when it has none,
+	* or neither can be read.
+	*/
+	async function archiveUri(name) {
+		const { postType } = collectionNamed(name);
+		if (!config.isServer()) return null;
+		const store = await boundStore();
+		if (!store) {
+			if (!config.development) return null;
+			const read = await getArchives();
+			return read.kind === "found" ? read.content[postType] ?? null : null;
+		}
+		try {
+			const stored = await store.read(ARCHIVES, parseArchives);
+			if (stored?.state === "unusable") console.error(`Delivery: the archives can't be served: ${stored.message}`);
+			return stored?.state === "published" ? stored.content[postType] ?? null : null;
+		} catch (error) {
+			if (!(error instanceof StoreFailure)) throw error;
+			console.error(`Delivery: the archives can't be served (store): ${error.message}`);
+			return null;
+		}
+	}
 	/** The refresh's credential when the Worker has one bound, and it is strong enough. */
 	async function refreshAuthority() {
 		const { PUBLICATION_DB, FRONTEND_REFRESH_TOKEN: token } = await config.bindings();
@@ -5646,13 +6042,25 @@ function configuredDelivery(config, languages, wordpress, transformHtml) {
 		isAuthorized,
 		publishedHome: (siteOrigin, language) => safely(async () => html.home(await publishedHome(siteOrigin, language), language), () => notServed("the front page", "store", "The publication store couldn't be loaded")),
 		publishedEntry: (path, siteOrigin) => safely(async () => html.entry(await publishedEntry(path, siteOrigin), routeLanguage$1(routeOf(path))), () => notServed("the entry", "store", "The publication store couldn't be loaded")),
-		pageChrome: (siteOrigin) => safely(() => pageChrome(siteOrigin), () => null),
-		designPresets: () => safely(() => pageDesign(), () => null)
+		pageChrome: (siteOrigin) => safely(async () => html.chrome(await pageChrome(siteOrigin)), () => null),
+		designPresets: () => safely(() => pageDesign(), () => null),
+		list,
+		terms,
+		archiveUri: (collection) => {
+			collectionNamed(collection);
+			return safely(() => archiveUri(collection), () => null);
+		}
 	};
 }
+/** Text as a search compares it: lowercase, without accents, its spaces collapsed. */
+function searchText(text) {
+	return text.normalize("NFD").replace(/\p{M}/gu, "").replace(/[\u2018\u2019\u201A\u201B\u2032]/g, "'").replace(/[\u201C\u201D\u201E\u2033]/g, "\"").toLowerCase().replace(/\s+/g, " ").trim();
+}
 //#endregion
 //#region frontend/src/wordpress.ts
 /** The origins a link into this Site may use: WordPress's, and the Frontend's when given. */
+/** The first GQ Design whose `designPattern` serves the default `page` route. */
+const DESIGN_PATTERN_VERSION = "0.4.1";
 function internalOrigins(config, siteOrigin) {
 	return [new URL(config.graphqlEndpoint).origin, ...siteOrigin ? [siteOrigin] : []];
 }
@@ -5660,12 +6068,17 @@ function configuredWordPress(config, languages) {
 	const defaultLanguage = languages[0];
 	const multilingual = languages.length > 1;
 	const extension = config.extension;
+	const collections = Object.entries(config.collections ?? {});
+	/** The collection whose items are of a WPGraphQL type, if one is. */
+	const collectionOf = (typename) => collections.find(([, collection]) => collection.graphqlType === typename);
+	/** The Site's extension fields on a kind of node (an item's, its collection's). */
+	const extensionSelection = (kind, collection) => (kind === "item" ? extension?.fields.collections?.[collection ?? ""] : extension?.fields[kind])?.trim();
 	/**
 	* The Site's extension fields on a kind of node, read with the blocks (left
 	* out with them when WordPress fails on them).
 	*/
-	const extensionFields = (kind) => {
-		const fields = extension?.fields[kind]?.trim();
+	const extensionFields = (kind, collection) => {
+		const fields = extensionSelection(kind, collection);
 		return fields ? `\n... @include(if: $withBlocks) {\n${fields}\n}` : "";
 	};
 	const image = objectType({
@@ -5726,6 +6139,32 @@ function configuredWordPress(config, languages) {
 		pageBy: pageEntry.nullable(),
 		designTokens
 	});
+	const termNode = objectType({
+		slug: stringType(),
+		name: stringType().nullable(),
+		taxonomyName: stringType().nullable()
+	});
+	const nodeEntry = objectType({
+		__typename: stringType(),
+		id: stringType(),
+		uri: stringType().nullable(),
+		status: stringType().nullable(),
+		isRestricted: booleanType().nullable(),
+		modifiedGmt: stringType().nullable().optional(),
+		date: stringType().nullable().optional(),
+		title: stringType().nullable().optional(),
+		content: stringType().nullable().optional(),
+		excerpt: stringType().nullable().optional(),
+		featuredImage: imageEdge.optional(),
+		blocks: unknownType().optional(),
+		terms: objectType({ nodes: arrayType(termNode) }).nullable().optional(),
+		language: languageRef.nullable().optional(),
+		translations: translated.translations.optional()
+	}).passthrough();
+	const nodeEntryData = objectType({
+		node: unionType([nodeEntry, objectType({ __typename: stringType() })]).nullable(),
+		designTokens
+	});
 	const translatedEntryData = objectType({
 		postBy: postEntry.extend(translated).nullable(),
 		pageBy: pageEntry.extend(translated).nullable(),
@@ -5754,13 +6193,21 @@ function configuredWordPress(config, languages) {
 			modifiedGmt: stringType().nullable().optional()
 		}))
 	}) });
-	const siteChromeData = objectType({
+	const designPattern = objectType({
+		title: stringType(),
+		blocksJson: stringType()
+	}).nullable();
+	const chromeWithoutPatternsData = objectType({
 		generalSettings: objectType({
 			siteIcon: imageEdge,
 			siteLogo: imageEdge
 		}),
 		menuItems: objectType({ nodes: arrayType(menuItem) })
 	});
+	const siteChromeData = chromeWithoutPatternsData.extend({
+		header: designPattern,
+		footer: designPattern
+	});
 	const consentSettingsData = objectType({
 		getquickLegal: unknownType(),
 		googleAnalytics: objectType({
@@ -5850,9 +6297,13 @@ function configuredWordPress(config, languages) {
       }
     }
   `;
-	function siteChromeQueryText(inLanguage) {
+	function siteChromeQueryText(inLanguage, withPatterns = true) {
 		return `
-  query SiteChrome($location: MenuLocationEnum!${inLanguage ? ", $language: LanguageCodeEnum!" : ""}) {
+  query SiteChrome(${[
+			"$location: MenuLocationEnum!",
+			...withPatterns ? ["$template: String!"] : [],
+			...inLanguage ? ["$language: LanguageCodeEnum!"] : []
+		].join(", ")}) {
     generalSettings {
       siteIcon {
         node {
@@ -5876,6 +6327,14 @@ function configuredWordPress(config, languages) {
         target
       }
     }
+    ${withPatterns ? `header: designPattern(template: $template, slot: "header") {
+      title
+      blocksJson
+    }
+    footer: designPattern(template: $template, slot: "footer") {
+      title
+      blocksJson
+    }` : ""}
   }
 `;
 	}
@@ -5945,6 +6404,73 @@ function configuredWordPress(config, languages) {
 	}
 	const entryQuery = entryQueryText(false);
 	const translatedEntryQuery = entryQueryText(true);
+	function nodeQueryText(translated) {
+		const languageFields = translated ? `
+      language {
+        slug
+      }
+      translations {
+        uri
+        language {
+          slug
+        }
+      }` : "";
+		const typeFields = (typename, fields) => fields.trim() ? `\n      ... on ${typename} {${fields}\n      }` : "";
+		const itemFields = collections.map(([name, collection]) => typeFields(collection.graphqlType, `${collection.taxonomies?.length ? `
+        terms(first: 100) {
+          nodes {
+            slug
+            name
+            taxonomyName
+          }
+        }` : ""}${languageFields}${extensionFields("item", name)}`)).join("");
+		return `
+  query EntryByUri($uri: String!, $withBlocks: Boolean = true) {
+    designTokens {
+      colors {
+        slug
+        color
+      }
+      spacingSizes {
+        slug
+        size
+      }
+    }
+    node: nodeByUri(uri: $uri) {
+      __typename
+      ... on ContentNode {
+        id
+        uri
+        date
+        status
+        isRestricted
+        modifiedGmt
+        blocks(attributes: true, htmlContent: true, dynamicContent: true, postTemplate: false)
+          @include(if: $withBlocks)
+      }
+      ... on NodeWithTitle {
+        title
+      }
+      ... on NodeWithContentEditor {
+        content
+      }
+      ... on NodeWithExcerpt {
+        excerpt
+      }
+      ... on NodeWithFeaturedImage {
+        featuredImage {
+          node {
+            sourceUrl
+            altText
+          }
+        }
+      }${typeFields("Post", `${languageFields}${extensionFields("post")}`)}${typeFields("Page", `${languageFields}${extensionFields("page")}`)}${itemFields}
+    }
+  }
+`;
+	}
+	const nodeQuery = nodeQueryText(false);
+	const translatedNodeQuery = nodeQueryText(true);
 	const designQuery = `
     query DesignPresets {
       designTokens {
@@ -5959,10 +6485,19 @@ function configuredWordPress(config, languages) {
       }
     }
   `;
+	/** WPGraphQL's ContentTypeEnum: pages, posts and each collection's post type. */
+	const contentTypes = [
+		"PAGE",
+		"POST",
+		...collections.map(([, { postType }]) => {
+			const name = postType.replace(/[^A-Za-z0-9_]/g, "_").toUpperCase();
+			return /^[A-Z_]/.test(name) ? name : `_${name}`;
+		})
+	];
 	function publishedRoutesQueryText(everyLanguage) {
 		return `
   query PublishedRoutes($after: String) {
-    contentNodes(first: 100, after: $after, where: { contentTypes: [PAGE, POST]${everyLanguage ? ", language: ALL" : ""} }) {
+    contentNodes(first: 100, after: $after, where: { contentTypes: [${contentTypes.join(", ")}]${everyLanguage ? ", language: ALL" : ""} }) {
       pageInfo {
         hasNextPage
         endCursor
@@ -6012,18 +6547,22 @@ function configuredWordPress(config, languages) {
 	* nothing: without an extension, fields for its kind, or a value, and when
 	* the blocks (and with them the fields) were left out.
 	*/
-	function extended(kind, node, blocksOmitted) {
-		if (!extension || !extensionFields(kind) || blocksOmitted) return {};
+	function extended(kind, node, blocksOmitted, collection) {
+		if (!extension || !extensionSelection(kind, collection) || blocksOmitted) return {};
 		let value;
 		try {
-			value = extension.read({
+			value = extension.read(collection === void 0 ? {
 				kind,
 				fields: node
+			} : {
+				kind,
+				collection,
+				fields: node
 			});
 		} catch (error) {
 			throw new CmsFailureError({
 				reason: "schema",
-				message: `WordPress's ${kind} doesn't match the Site's extension: ${error instanceof Error ? error.message : String(error)}`
+				message: `WordPress's ${collection === void 0 ? kind : `${collection} item`} doesn't match the Site's extension: ${error instanceof Error ? error.message : String(error)}`
 			}, { cause: error });
 		}
 		return value === void 0 ? {} : { extension: value };
@@ -6203,6 +6742,7 @@ function configuredWordPress(config, languages) {
 	* what any visitor may read.
 	*/
 	async function getEntryByUri(uri) {
+		if (collections.length > 0) return getNodeByUri(uri);
 		return deliver(`the entry ${uri}`, async () => {
 			const { data, blocksOmitted } = multilingual ? await queryWithBlockRecovery(translatedEntryData, translatedEntryQuery, { uri }) : await queryWithBlockRecovery(entryData, entryQuery, { uri });
 			const post = data.postBy ?? data.pageBy;
@@ -6226,6 +6766,59 @@ function configuredWordPress(config, languages) {
 			};
 		});
 	}
+	/**
+	* On a Site with collections, the published page, post or collection item
+	* at a URI. Missing when the node there is none of them (an archive, a
+	* term, an item of a type the Site doesn't store), or isn't public.
+	*/
+	async function getNodeByUri(uri) {
+		return deliver(`the entry ${uri}`, async () => {
+			const { data, blocksOmitted } = await queryWithBlockRecovery(nodeEntryData, multilingual ? translatedNodeQuery : nodeQuery, { uri });
+			const node = data.node;
+			if (!node || !("id" in node)) return { kind: "missing" };
+			const item = collectionOf(node.__typename);
+			const kind = node.__typename === "Page" ? "page" : node.__typename === "Post" ? "post" : null;
+			if (!item && !kind) return { kind: "missing" };
+			if (!node.uri || node.isRestricted || node.status !== "publish") return { kind: "missing" };
+			const entry = {
+				...node,
+				uri: node.uri,
+				title: node.title ?? null,
+				content: node.content ?? null,
+				excerpt: node.excerpt ?? null,
+				date: node.date ?? null,
+				featuredImage: node.featuredImage ?? null
+			};
+			const normalized = normalizePost(entry);
+			const blocks = parseWordPressBlocks(node.blocks);
+			const containsVideoHero = hasVideoHero(blocks);
+			return {
+				kind: "found",
+				content: {
+					...normalized,
+					content: containsVideoHero ? renderWordPressBlocks(blocks) : normalized.content,
+					hasVideoHero: containsVideoHero,
+					blocksOmitted,
+					modifiedAt: cmsTime(node.modifiedGmt),
+					spacingSizes: data.designTokens.spacingSizes,
+					colors: data.designTokens.colors,
+					...multilingual ? languageOf(entry) : {},
+					...item ? { collection: {
+						name: item[0],
+						terms: termsOf(item[1].taxonomies ?? [], node.terms?.nodes ?? [])
+					} } : {},
+					...item ? extended("item", node, blocksOmitted, item[0]) : extended(kind, node, blocksOmitted)
+				}
+			};
+		});
+	}
+	/** An item's terms in each of its collection's taxonomies (every one, if it has none). */
+	function termsOf(taxonomies, nodes) {
+		return Object.fromEntries(taxonomies.map((taxonomy) => [taxonomy, nodes.filter((term) => term.taxonomyName === taxonomy).map((term) => ({
+			slug: term.slug,
+			name: term.name ?? term.slug
+		}))]));
+	}
 	/** An entry's language and published translations, as a multilingual Site stores them. */
 	function languageOf(post) {
 		return {
@@ -6287,6 +6880,93 @@ function configuredWordPress(config, languages) {
 			});
 		});
 	}
+	const names = objectType({ nodes: arrayType(objectType({ name: stringType() })) }).nullable();
+	const archivesData = objectType({
+		getquickArchives: arrayType(objectType({
+			postType: stringType(),
+			uri: stringType().nullable()
+		})).nullable().optional(),
+		contentTypes: objectType({ nodes: arrayType(objectType({
+			name: stringType(),
+			graphqlSingleName: stringType().nullable().optional(),
+			connectedTaxonomies: names.optional()
+		})) }).nullable(),
+		taxonomies: names
+	});
+	const archivesQueryText = (archives) => `
+    query ContentArchives {${archives ? `
+      getquickArchives {
+        postType
+        uri
+      }` : ""}
+      contentTypes(first: 100) {
+        nodes {
+          name
+          graphqlSingleName
+          connectedTaxonomies(first: 100) {
+            nodes {
+              name
+            }
+          }
+        }
+      }
+      taxonomies(first: 100) {
+        nodes {
+          name
+        }
+      }
+    }
+  `;
+	/**
+	* Where each collection's archive is, by post type: the Page assigned to it
+	* in GETQUICK → Archives, else the type's own archive. A CMS whose GETQUICK
+	* Content doesn't have Archives yet gives none. A collection whose post
+	* type or taxonomy WPGraphQL doesn't show fails the read (`schema`).
+	*/
+	async function getArchives() {
+		return deliver("the archives", async () => {
+			let data;
+			try {
+				data = await query(archivesData, archivesQueryText(true));
+			} catch (error) {
+				if (!(error instanceof CmsFailureError) || error.failure.reason !== "graphql" || !/Cannot query field "getquickArchives"/.test(error.failure.message)) throw error;
+				console.warn(`WordPress: GETQUICK Content provides no archives (${error.failure.message}); collections have none`);
+				data = await query(archivesData, archivesQueryText(false));
+			}
+			const shown = (list) => new Set((list?.nodes ?? []).map(({ name }) => name));
+			const postTypes = new Map((data.contentTypes?.nodes ?? []).map((type) => [type.name, type]));
+			const taxonomies = shown(data.taxonomies);
+			const hidden = collections.flatMap(([name, collection]) => [...postTypes.has(collection.postType) ? [] : [`${name}'s post type ${collection.postType}`], ...(collection.taxonomies ?? []).filter((taxonomy) => !taxonomies.has(taxonomy)).map((taxonomy) => `${name}'s taxonomy ${taxonomy}`)]);
+			if (hidden.length > 0) throw new CmsFailureError({
+				reason: "schema",
+				message: `WPGraphQL doesn't show ${hidden.join(", ")} (show_in_graphql)`
+			});
+			const mismatched = collections.flatMap(([name, collection]) => {
+				const type = postTypes.get(collection.postType);
+				const typeName = type.graphqlSingleName ? graphqlTypeName(type.graphqlSingleName) : null;
+				const connected = shown(type.connectedTaxonomies);
+				return [...typeName === null || typeName === collection.graphqlType ? [] : [`${name}'s graphqlType ${collection.graphqlType} isn't post type ${collection.postType}'s GraphQL type, ${typeName}`], ...type.connectedTaxonomies === void 0 ? [] : (collection.taxonomies ?? []).filter((taxonomy) => !connected.has(taxonomy)).map((taxonomy) => `${name}'s taxonomy ${taxonomy} isn't connected to post type ${collection.postType}`)];
+			});
+			if (mismatched.length > 0) throw new CmsFailureError({
+				reason: "schema",
+				message: mismatched.join("; ")
+			});
+			const stored = new Set(collections.map(([, { postType }]) => postType));
+			return {
+				kind: "found",
+				content: Object.fromEntries((data.getquickArchives ?? []).flatMap(({ postType, uri }) => uri && stored.has(postType) ? [[postType, uriPath(uri)]] : []))
+			};
+		});
+	}
+	/**
+	* The GraphQL type WPGraphQL names after a post type's graphql_single_name
+	* (WPGraphQL's Utils::format_type_name): each word, split at `_`, `-` or a
+	* space, capitalised and joined.
+	*/
+	function graphqlTypeName(singleName) {
+		const capital = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+		return singleName.replace(/[^a-zA-Z0-9 -]/g, "_").split(/[_ -]/).map(capital).join("");
+	}
 	/** The URI of every published page and post. */
 	async function getPublishedRoutes() {
 		const listed = await getPublishedEntries();
@@ -6338,17 +7018,68 @@ function configuredWordPress(config, languages) {
 		}
 	}
 	/**
-	* The menu, logo and icon every page in a language shares: the logo and icon
-	* are the site's, the menu the one at the location in that language. A site
-	* without them is found with an empty menu and no images; a failed read is
-	* Unavailable, not that.
+	* The chrome's data in a language. A CMS whose GQ Design predates
+	* `designPattern` (before 0.2.17) has no header or footer patterns to
+	* select: its schema rejects the field, and the chrome is read again without
+	* them, with both null (the Site's own header and footer), as when nothing
+	* is selected. The warning names the cause and the version the default
+	* `page` route needs; menus, logos and icons keep refreshing, and new Sites
+	* and languages are served. Any other failure fails the read, so what is
+	* stored is kept.
+	*/
+	async function chromeData(language, location) {
+		const template = config.designTemplate ?? "page";
+		const variables = language.isDefault ? { location } : {
+			location,
+			language: language.code
+		};
+		try {
+			return await query(siteChromeData, language.isDefault ? siteChromeQuery : languageChromeQuery, {
+				...variables,
+				template
+			});
+		} catch (error) {
+			if (!(error instanceof CmsFailureError) || error.failure.reason !== "graphql" || !/Cannot query field "designPattern"/.test(error.failure.message)) throw error;
+			console.warn(`WordPress: GQ Design has no designPattern field (${error.failure.message}); header and footer patterns need GQ Design ${DESIGN_PATTERN_VERSION} or newer, so the chrome is read without them and the Site's own header and footer are served`);
+			return {
+				...await query(chromeWithoutPatternsData, siteChromeQueryText(!language.isDefault, false), variables),
+				header: null,
+				footer: null
+			};
+		}
+	}
+	/**
+	* A selected pattern's block tree. GQ Design answers a selected pattern it
+	* couldn't resolve (invalid attributes, a cycle, too many blocks) with an
+	* empty tree, not an error; that is a failed read, so the stored chrome is
+	* kept rather than replaced by an empty region.
+	*/
+	function designPatternOf(region, pattern) {
+		if (!pattern) return null;
+		const blocks = parseDesignBlocks(pattern.blocksJson);
+		if (!blocks) throw new CmsFailureError({
+			reason: "schema",
+			message: `The ${region} pattern's blocksJson isn't a JSON list of blocks`
+		});
+		if (blocks.length === 0) throw new CmsFailureError({
+			reason: "schema",
+			message: `The ${region} pattern "${pattern.title}" has no blocks GQ Design could resolve`
+		});
+		return {
+			title: pattern.title,
+			blocks
+		};
+	}
+	/**
+	* The menu, logo, icon, header and footer every page in a language shares:
+	* the logo and icon are the site's, the menu the one at the location in that
+	* language, the header and footer the patterns selected for the configured
+	* design route. A site without them is found with an empty menu, no images
+	* and no patterns; a failed read is Unavailable, not that.
 	*/
 	async function getSiteChrome(siteOrigin, { location = "PRIMARY", language = defaultLanguage } = {}) {
 		return deliver(languageSubject(language, "site chrome"), async () => {
-			const [data, consent] = await Promise.all([language.isDefault ? query(siteChromeData, siteChromeQuery, { location }) : query(siteChromeData, languageChromeQuery, {
-				location,
-				language: language.code
-			}), config.consent?.cmsSettings ? consentSettings(language) : null]);
+			const [data, consent] = await Promise.all([chromeData(language, location), config.consent?.cmsSettings ? consentSettings(language) : null]);
 			const origins = internalOrigins(config, siteOrigin);
 			return {
 				kind: "found",
@@ -6356,6 +7087,8 @@ function configuredWordPress(config, languages) {
 					menuItems: buildMenuTree(data.menuItems.nodes, origins),
 					siteIcon: normalizeImage(data.generalSettings.siteIcon),
 					siteLogo: normalizeImage(data.generalSettings.siteLogo),
+					header: designPatternOf("header", data.header),
+					footer: designPatternOf("footer", data.footer),
 					...consent ? {
 						legal: parseLegalLanguage(consent.getquickLegal),
 						analytics: consent.googleAnalytics ?? {
@@ -6373,6 +7106,7 @@ function configuredWordPress(config, languages) {
 		getDesignPresets,
 		getPublishedEntries,
 		getPublishedRoutes,
+		getArchives,
 		getSiteChrome
 	};
 }
@@ -6381,7 +7115,10 @@ function configuredWordPress(config, languages) {
 function createContentRuntime(input) {
 	const site = input.site.trim();
 	if (!site) throw new Error("A nonempty Site identity is required");
-	for (const [kind, fields] of Object.entries(input.extension?.fields ?? {})) if (fields !== void 0 && !fields.trim()) throw new Error(`The extension's ${kind} fields are empty; leave them out instead`);
+	if (input.designTemplate !== void 0 && (!/^[a-z0-9_-]+$/.test(input.designTemplate) || /^[0-9]+$/.test(input.designTemplate))) throw new Error("designTemplate must be a GQ Design route key, such as page");
+	const { collections: collectionFields, ...kindFields } = input.extension?.fields ?? {};
+	for (const [kind, fields] of Object.entries(kindFields)) if (fields !== void 0 && !fields.trim()) throw new Error(`The extension's ${kind} fields are empty; leave them out instead`);
+	validateCollections(input.collections ?? {}, collectionFields ?? {});
 	const config = {
 		...input,
 		site,
@@ -6436,8 +7173,37 @@ function createContentRuntime(input) {
 		handleRefresh: guarded("Refresh", "Refresh with POST.", refresh.handleRefresh),
 		publishedHome: delivery.publishedHome,
 		publishedEntry: delivery.publishedEntry,
+		/**
+		* A page of a collection's items, from the publication store alone (never
+		* WordPress), newest first: those with the given terms and text, in the
+		* language. Unavailable when the store can't be read, or there is none.
+		*/
+		list: delivery.list,
+		/**
+		* The terms of a collection's taxonomy that its stored items have, with how
+		* many of them have each, by name: for filters.
+		*/
+		terms: delivery.terms,
+		/**
+		* Where a collection's archive is: the Page assigned to it in GETQUICK →
+		* Archives, else its post type's own archive. Null when it has neither, or
+		* the store can't be read.
+		*/
+		archiveUri: delivery.archiveUri,
 		pageChrome: delivery.pageChrome,
 		/**
+		* A chrome pattern as HTML, by the Site's block renderers (see
+		* `renderDesignPattern`), with links into the CMS or `siteOrigin` served
+		* as this Site's paths.
+		*/
+		renderDesignPattern: (pattern, options = {}) => {
+			const { siteOrigin, internalOrigins: extraOrigins = [], ...rest } = options;
+			return renderDesignPattern(pattern, {
+				...rest,
+				internalOrigins: [...internalOrigins(config, siteOrigin), ...extraOrigins]
+			});
+		},
+		/**
 		* The design presets every page shares (GQ Design's spacing sizes and
 		* colors), for a page that isn't a publication: the stored ones when there
 		* is a store, else (in explicit development) a live read. Null when
@@ -6461,5 +7227,27 @@ function createContentRuntime(input) {
 		}) : null
 	};
 }
+/** A collection's names are paths in the store's JSON, and the post type and taxonomies GraphQL names. */
+function validateCollections(collections, fields) {
+	const name = /^[a-z0-9][a-z0-9_-]*$/;
+	const postTypes = /* @__PURE__ */ new Set();
+	for (const [collection, { postType, graphqlType, taxonomies = [] }] of Object.entries(collections)) {
+		if (!name.test(collection)) throw new Error(`The collection ${JSON.stringify(collection)} needs a name such as biblioteca`);
+		if (!/^[a-z0-9_-]{1,20}$/.test(postType)) throw new Error(`The collection ${collection}'s postType isn't a WordPress post type name`);
+		if ([
+			"page",
+			"post",
+			"attachment"
+		].includes(postType)) throw new Error(`The collection ${collection} can't be WordPress's ${postType}s`);
+		if (postTypes.has(postType)) throw new Error(`The collection ${collection}'s post type is another collection's`);
+		postTypes.add(postType);
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(graphqlType)) throw new Error(`The collection ${collection}'s graphqlType isn't a GraphQL type name`);
+		for (const taxonomy of taxonomies) if (!/^[a-z0-9_-]{1,32}$/.test(taxonomy)) throw new Error(`The collection ${collection}'s taxonomy ${taxonomy} isn't a taxonomy name`);
+	}
+	for (const [collection, value] of Object.entries(fields)) {
+		if (!Object.hasOwn(collections, collection)) throw new Error(`The extension has fields for ${collection}, which isn't a collection`);
+		if (value !== void 0 && !value.trim()) throw new Error(`The extension's ${collection} fields are empty; leave them out instead`);
+	}
+}
 //#endregion
 export { createContentRuntime };