@hollware/core 0.5.0 → 0.8.0

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as z from "zod";
+import { Validator } from "@cfworker/json-schema";
 //#region src/config/define.ts
 /**
 * The `define*` helpers only give the config its types: the frontmatter type of a collection
@@ -124,7 +125,7 @@ function runtimeOf(contractId, context) {
 */
 /** The most characters of the entry's own text that a message repeats. */
 const MAX_ECHO_LENGTH = 80;
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** Orders two texts by UTF-16 code units: the same in every runtime, unlike `localeCompare`. */
@@ -177,11 +178,11 @@ function fragmentAt(schema, segments) {
 	let node = schema;
 	for (const segment of segments) {
 		const properties = node.properties;
-		if (isRecord$2(properties) && Object.hasOwn(properties, segment)) {
+		if (isRecord$3(properties) && Object.hasOwn(properties, segment)) {
 			const next = properties[segment];
-			if (!isRecord$2(next)) return void 0;
+			if (!isRecord$3(next)) return void 0;
 			node = next;
-		} else if (/^\d+$/.test(segment) && isRecord$2(node.items)) node = node.items;
+		} else if (/^\d+$/.test(segment) && isRecord$3(node.items)) node = node.items;
 		else return;
 	}
 	return node;
@@ -189,7 +190,7 @@ function fragmentAt(schema, segments) {
 function valueAt(input, segments) {
 	let node = input;
 	for (const segment of segments) if (Array.isArray(node) && /^\d+$/.test(segment)) node = node[Number(segment)];
-	else if (isRecord$2(node) && Object.hasOwn(node, segment)) node = node[segment];
+	else if (isRecord$3(node) && Object.hasOwn(node, segment)) node = node[segment];
 	else return void 0;
 	return node;
 }
@@ -225,11 +226,11 @@ function numberExpectation(type, schema) {
 }
 function arrayExpectation(schema) {
 	const size = range(schema.minItems, schema.maxItems, "item");
-	const items = isRecord$2(schema.items) ? expectation(schema.items) : void 0;
+	const items = isRecord$3(schema.items) ? expectation(schema.items) : void 0;
 	return `an array${size === void 0 ? "" : ` of ${size}`}${items === void 0 ? "" : `, each ${items}`}`;
 }
 function objectExpectation(schema) {
-	const keys = isRecord$2(schema.properties) ? Object.keys(schema.properties) : [];
+	const keys = isRecord$3(schema.properties) ? Object.keys(schema.properties) : [];
 	return keys.length === 0 ? "an object" : `an object with the keys ${keys.join(", ")}`;
 }
 function typeExpectation(type, schema) {
@@ -252,13 +253,13 @@ function expectation(schema) {
 	if ("const" in schema) return `exactly ${JSON.stringify(schema.const)}`;
 	if (Array.isArray(schema.enum)) return `one of ${listValues(schema.enum)}`;
 	const alternatives = schema.anyOf ?? schema.oneOf;
-	const parts = Array.isArray(alternatives) ? alternatives.map((option) => isRecord$2(option) ? expectation(option) : void 0) : (Array.isArray(schema.type) ? schema.type : [schema.type]).map((type) => typeExpectation(type, schema));
+	const parts = Array.isArray(alternatives) ? alternatives.map((option) => isRecord$3(option) ? expectation(option) : void 0) : (Array.isArray(schema.type) ? schema.type : [schema.type]).map((type) => typeExpectation(type, schema));
 	return parts.every((part) => part !== void 0) ? parts.join(" or ") : void 0;
 }
 /** The keys of `value` that an object schema closed to other keys does not list. */
 function unknownKeys(fragment, value) {
 	const { additionalProperties, properties } = fragment;
-	if (additionalProperties !== false || !isRecord$2(properties) || !isRecord$2(value)) return [];
+	if (additionalProperties !== false || !isRecord$3(properties) || !isRecord$3(value)) return [];
 	return Object.keys(value).filter((key) => !Object.hasOwn(properties, key));
 }
 /** The fix for one issue: imperative, naming the field and what the schema accepts there. */
@@ -268,7 +269,7 @@ function fixForIssue({ subject, schema, input, segments, message }) {
 	if (fragment !== void 0) {
 		const unknown = unknownKeys(fragment, valueAt(input, segments));
 		if (unknown.length > 0) {
-			const allowed = isRecord$2(fragment.properties) ? Object.keys(fragment.properties) : [];
+			const allowed = isRecord$3(fragment.properties) ? Object.keys(fragment.properties) : [];
 			const nouns = unknown.length === 1 ? subject.noun : `${subject.noun}s`;
 			const where = allowed.length === 0 ? `no ${subject.noun}s are allowed there` : `the ${subject.noun}s allowed there are: ${allowed.join(", ")}`;
 			return `Remove the ${nouns} ${unknown.map((key) => quote$1(key)).join(", ")} from ${target}; ${where}.`;
@@ -280,7 +281,7 @@ function fixForIssue({ subject, schema, input, segments, message }) {
 //#endregion
 //#region src/contracts/schema.ts
 const SNAPSHOTS = /* @__PURE__ */ new WeakMap();
-function toJsonSchema$1(schema) {
+function toJsonSchema$2(schema) {
 	try {
 		return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
 	} catch {
@@ -291,8 +292,8 @@ function schemaSnapshot(collection) {
 	let snapshot = SNAPSHOTS.get(collection);
 	if (snapshot === void 0) {
 		snapshot = {
-			frontmatter: toJsonSchema$1(collection.schema),
-			components: new Map([...collection.components].map(([name, component]) => [name, toJsonSchema$1(component.props)]))
+			frontmatter: toJsonSchema$2(collection.schema),
+			components: new Map([...collection.components].map(([name, component]) => [name, toJsonSchema$2(component.props)]))
 		};
 		SNAPSHOTS.set(collection, snapshot);
 	}
@@ -540,6 +541,211 @@ function describeBuiltInContracts() {
 	].map((contract) => describeContract(contract));
 }
 //#endregion
+//#region src/search/chunks.ts
+/**
+* The pieces of an entry that semantic search embeds (v0.5): one summary, and one piece for each
+* section the body has under an `h2`. Vectors are derived data, like the Comark document: a change
+* of this version makes every vector one to make again.
+*/
+const CHUNKER_VERSION = "1";
+/** How long a piece may grow, in characters, before it is cut at a word. */
+const CHUNK_LIMITS = {
+	summary: 1200,
+	section: 2e3
+};
+/** The text a reader sees in a document, its blocks on lines of their own. */
+function documentText(document) {
+	return document.nodes.map((node) => textOf(node)).join("\n");
+}
+/** The text a reader sees in a node: its strings, never its tag, attributes or comments. */
+function textOf(node) {
+	if (typeof node === "string") return node;
+	if (!Array.isArray(node) || node[0] === null) return "";
+	return node.slice(2).map((child) => textOf(child)).join("");
+}
+function tagOf(node) {
+	return Array.isArray(node) && typeof node[0] === "string" ? node[0] : null;
+}
+/** The words of a text in one line, cut at the last word that fits in `limit`. */
+function fit(text, limit) {
+	const flat = text.replace(/\s+/g, " ").trim();
+	if (flat.length <= limit) return flat;
+	const cut = flat.slice(0, limit);
+	const lastSpace = cut.lastIndexOf(" ");
+	return (lastSpace > 0 ? cut.slice(0, lastSpace) : cut).trim();
+}
+/**
+* The pieces of an entry: the summary (its title, its description and the text before the first
+* `h2`), then each section (its heading and its text up to the next `h2`). An `h1` adds nothing:
+* it repeats the title. A section with no text is left out.
+*/
+function chunksOf(entry) {
+	const intro = [];
+	const sections = [];
+	for (const node of entry.document.nodes) {
+		const tag = tagOf(node);
+		if (tag === "h1") continue;
+		if (tag === "h2") {
+			sections.push({
+				heading: textOf(node).trim(),
+				parts: []
+			});
+			continue;
+		}
+		const text = textOf(node);
+		const current = sections.at(-1);
+		if (current === void 0) intro.push(text);
+		else current.parts.push(text);
+	}
+	const chunks = [{
+		index: 0,
+		kind: "summary",
+		heading: null,
+		text: fit([
+			entry.title,
+			entry.description ?? "",
+			intro.join(" ")
+		].filter((part) => part !== "").join("\n"), CHUNK_LIMITS.summary)
+	}];
+	for (const section of sections) {
+		const body = section.parts.join(" ").trim();
+		if (body === "") continue;
+		chunks.push({
+			index: chunks.length,
+			kind: "section",
+			heading: section.heading,
+			text: fit(`${section.heading}\n${body}`, CHUNK_LIMITS.section)
+		});
+	}
+	return chunks;
+}
+//#endregion
+//#region src/contracts/rules.ts
+function present(frontmatter, field) {
+	return isRecord$3(frontmatter) ? frontmatter[field] : void 0;
+}
+const GRAPHEMES = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+/** The length of a value as a reader counts it: characters of a text (an emoji is one), items of a list. */
+function lengthOf(value) {
+	if (typeof value === "string") return [...GRAPHEMES.segment(value)].length;
+	return Array.isArray(value) ? value.length : void 0;
+}
+/** A text, or a list, of a field has between `min` and `max` characters or items. */
+function fieldLength(params, options = {}) {
+	const bounds = [params.min === void 0 ? null : `at least ${params.min}`, params.max === void 0 ? null : `at most ${params.max}`].filter((bound) => bound !== null);
+	const unless = params.unless === void 0 ? "" : `, unless ${quote$1(params.unless)} is given`;
+	return registerBuiltIn({
+		id: options.id ?? "field-length",
+		severity: options.severity ?? "error",
+		description: `${quote$1(params.field)} has ${bounds.join(" and ")} characters or items${unless}.`,
+		rule: {
+			name: "field-length",
+			params: { ...params }
+		},
+		check: ({ frontmatter }) => {
+			const value = present(frontmatter, params.field);
+			const length = lengthOf(value);
+			if (length === void 0) return [];
+			const unit = typeof value === "string" ? "character" : "item";
+			if (params.unless !== void 0 && present(frontmatter, params.unless) !== void 0) return [];
+			const path = `/frontmatter/${params.field}`;
+			if (params.max !== void 0 && length > params.max) return [{
+				path,
+				message: `${quote$1(params.field)} has ${count(length, unit)}; the most is ${params.max}.`,
+				fix: `Shorten ${quote$1(params.field)} to ${count(params.max, unit)} or fewer${params.unless === void 0 ? "" : `, or add ${quote$1(params.unless)}`}.`
+			}];
+			if (params.min !== void 0 && length < params.min) return [{
+				path,
+				message: `${quote$1(params.field)} has ${count(length, unit)}; the least is ${params.min}.`,
+				fix: `Lengthen ${quote$1(params.field)} to ${count(params.min, unit)} or more.`
+			}];
+			return [];
+		}
+	}, { readsFrontmatter: true });
+}
+/** A text field matches a pattern. */
+function fieldPattern(params, options = {}) {
+	const pattern = new RegExp(`^(?:${params.pattern})$`, "u");
+	return registerBuiltIn({
+		id: options.id ?? "field-pattern",
+		severity: options.severity ?? "error",
+		description: `${quote$1(params.field)} is ${params.description}.`,
+		rule: {
+			name: "field-pattern",
+			params: { ...params }
+		},
+		check: ({ frontmatter }) => {
+			const value = present(frontmatter, params.field);
+			if (typeof value !== "string" || pattern.test(value)) return [];
+			return [{
+				path: `/frontmatter/${params.field}`,
+				message: `${quote$1(params.field)} is not ${params.description}.`,
+				fix: `Write ${quote$1(params.field)} as ${params.description}.`
+			}];
+		}
+	}, { readsFrontmatter: true });
+}
+/** Fields a draft may lack and a published entry must have, with something in them. */
+function requiredToPublish(params, options = {}) {
+	const empty = (value) => value === void 0 || value === null || typeof value === "string" && value.trim() === "" || Array.isArray(value) && value.length === 0;
+	return registerBuiltIn({
+		id: options.id ?? "required-to-publish",
+		severity: options.severity ?? "error",
+		phases: ["publish"],
+		description: `To publish, ${params.fields.map(quote$1).join(", ")} must have a value.`,
+		rule: {
+			name: "required-to-publish",
+			params: { fields: [...params.fields] }
+		},
+		check: ({ frontmatter }) => params.fields.filter((field) => empty(present(frontmatter, field))).map((field) => ({
+			path: `/frontmatter/${field}`,
+			message: `${quote$1(field)} is empty, and the entry cannot be published without it.`,
+			fix: `Give ${quote$1(field)} a value, then publish.`
+		}))
+	}, { readsFrontmatter: true });
+}
+function escape(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Words that may appear neither in a text field of the frontmatter nor in the body. */
+function bannedWords(params, options = {}) {
+	const words = params.words.filter((word) => word.trim() !== "");
+	const pattern = words.length === 0 ? null : new RegExp(`(?<![\\p{L}\\p{N}])(?:${words.map(escape).join("|")})(?![\\p{L}\\p{N}])`, "giu");
+	const because = params.reason === void 0 ? "" : ` (${params.reason})`;
+	const found = (text) => [...new Set([...text.matchAll(pattern ?? /$^/g)].map((m) => m[0]))];
+	return registerBuiltIn({
+		id: options.id ?? "banned-words",
+		severity: options.severity ?? "error",
+		description: `None of these words: ${words.map(quote$1).join(", ")}${because}.`,
+		rule: {
+			name: "banned-words",
+			params: {
+				...params,
+				words: [...params.words]
+			}
+		},
+		check: (context) => {
+			if (pattern === null) return [];
+			const findings = [];
+			const frontmatter = isRecord$3(context.frontmatter) ? context.frontmatter : {};
+			for (const [field, value] of Object.entries(frontmatter)) {
+				if (typeof value !== "string") continue;
+				for (const word of found(value)) findings.push({
+					path: `/frontmatter/${field}`,
+					message: `${quote$1(field)} uses ${quote$1(word)}.`,
+					fix: `Write ${quote$1(field)} without ${quote$1(word)}${because}.`
+				});
+			}
+			for (const word of found(documentText(context.markdown.document))) findings.push({
+				path: "/body",
+				message: `The body uses ${quote$1(word)}.`,
+				fix: `Rewrite the body without ${quote$1(word)}${because}.`
+			});
+			return findings;
+		}
+	}, { readsFrontmatter: false });
+}
+//#endregion
 //#region src/contracts/opt-in.ts
 /**
 * Every locale of the site has an entry in the translation group of this one. It reads the group
@@ -549,7 +755,11 @@ function describeBuiltInContracts() {
 */
 function translationPair(options = {}) {
 	return registerBuiltIn({
-		id: "translation-pair",
+		id: options.id ?? "translation-pair",
+		rule: {
+			name: "translation-pair",
+			params: {}
+		},
 		severity: options.severity ?? "error",
 		phases: ["publish"],
 		description: "Every locale of the site has an entry in the translation group of this entry. Checked when publishing.",
@@ -558,7 +768,7 @@ function translationPair(options = {}) {
 			const field = collection.translationGroupField;
 			if (field === null) return [];
 			const path = `/frontmatter${pointer([field])}`;
-			const group = isRecord$2(context.frontmatter) ? context.frontmatter[field] : void 0;
+			const group = isRecord$3(context.frontmatter) ? context.frontmatter[field] : void 0;
 			if (typeof group !== "string" || group === "") return [{
 				path,
 				message: `The entry has no translation group: its frontmatter field ${field} is empty.`,
@@ -581,7 +791,11 @@ function translationPair(options = {}) {
 */
 function internalLinksResolve(options = {}) {
 	return registerBuiltIn({
-		id: "internal-links-resolve",
+		id: options.id ?? "internal-links-resolve",
+		rule: {
+			name: "internal-links-resolve",
+			params: {}
+		},
 		severity: options.severity ?? "error",
 		phases: ["publish"],
 		description: "Every link to another entry of the site points at a published entry. Checked when publishing.",
@@ -635,7 +849,11 @@ function isThisEntry(target, context) {
 /** Every image has alt text. An alt of only spaces counts as none. Checked on every write. */
 function imagesHaveAlt(options = {}) {
 	return registerBuiltIn({
-		id: "images-have-alt",
+		id: options.id ?? "images-have-alt",
+		rule: {
+			name: "images-have-alt",
+			params: {}
+		},
 		severity: options.severity ?? "error",
 		phases: ["write", "publish"],
 		description: "Every image has alt text that describes it.",
@@ -673,12 +891,81 @@ function custom(options) {
 	};
 }
 const contracts = {
+	bannedWords,
 	custom,
+	fieldLength,
+	fieldPattern,
 	imagesHaveAlt,
 	internalLinksResolve,
+	requiredToPublish,
 	translationPair
 };
 //#endregion
+//#region src/contracts/catalog.ts
+/**
+* The catalog of rules (ADR-033): every rule a collection may list in its definition, by name,
+* with the JSON Schema of its parameters. A site's definition stores `{ rule, severity, params }`
+* and the Worker makes the contract from it here; `describe_site` shows the catalog, so an agent
+* or the admin knows what each rule takes.
+*/
+const fieldName = z.string().min(1).describe("A field of the frontmatter, by its name.");
+const NO_PARAMS = z.strictObject({});
+function isValidPattern(pattern) {
+	try {
+		new RegExp(pattern, "u");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function rule(name, description, params, make) {
+	return {
+		name,
+		description,
+		params,
+		make: (raw, severity, id) => make(params.parse(raw), {
+			severity,
+			...id === void 0 ? {} : { id }
+		})
+	};
+}
+const CATALOG = [
+	rule("banned-words", "Words that may appear neither in a text field of the frontmatter nor in the body.", z.strictObject({
+		words: z.array(z.string().min(1)).min(1).max(200),
+		reason: z.string().min(1).max(200).optional().describe("Why, for the fix.")
+	}), (params, options) => bannedWords(params, options)),
+	rule("field-length", "A text field has between min and max characters, or a list between min and max items; unless names a field that lifts the rule when given.", z.strictObject({
+		field: fieldName,
+		min: z.number().int().min(0).optional(),
+		max: z.number().int().min(0).optional(),
+		unless: fieldName.optional()
+	}).refine((params) => params.min !== void 0 || params.max !== void 0, { message: "Give min, max or both." }).refine((params) => params.min === void 0 || params.max === void 0 || params.min <= params.max, { message: "min is more than max." }), (params, options) => fieldLength(params, options)),
+	rule("field-pattern", "A text field matches a regular expression, as a whole.", z.strictObject({
+		field: fieldName,
+		pattern: z.string().min(1).max(500).refine(isValidPattern, { message: "Not a regular expression." }),
+		description: z.string().min(1).max(200).describe("What the pattern asks for, in words.")
+	}), (params, options) => fieldPattern(params, options)),
+	rule("images-have-alt", "Every image has alt text that describes it.", NO_PARAMS, (_params, options) => contracts.imagesHaveAlt(options)),
+	rule("internal-links-resolve", "Every link to another entry of the site points to one that exists, and is published when this one is.", NO_PARAMS, (_params, options) => contracts.internalLinksResolve(options)),
+	rule("required-to-publish", "Fields a draft may leave empty and a published entry must fill.", z.strictObject({ fields: z.array(fieldName).min(1) }), (params, options) => requiredToPublish(params, options)),
+	rule("translation-pair", "Every locale of the site has an entry in the translation group of this one, to publish.", NO_PARAMS, (_params, options) => contracts.translationPair(options))
+];
+/** A rule of the catalog by its name, or `undefined`. */
+function catalogRule(name) {
+	return CATALOG.find((candidate) => candidate.name === name);
+}
+/** The catalog as `describe_site` shows it: each rule with the JSON Schema of its parameters. */
+function describeCatalog() {
+	return CATALOG.map((entry) => ({
+		name: entry.name,
+		description: entry.description,
+		params: z.toJSONSchema(entry.params, {
+			target: "draft-2020-12",
+			io: "input"
+		})
+	}));
+}
+//#endregion
 //#region src/contracts/hash.ts
 /**
 * `contractsHash` (ADR-004): what a revision was checked against, in a short string. A stored
@@ -708,10 +995,11 @@ async function sha256Hex(text) {
 function hashContracts(snapshot, contracts) {
 	return sha256Hex(canonicalJson({
 		components: Object.fromEntries(snapshot.components),
-		contracts: contracts.toSorted((left, right) => compareText(left.id, right.id)).map(({ id, phases, severity }) => ({
+		contracts: contracts.toSorted((left, right) => compareText(left.id, right.id)).map(({ id, phases, severity, params }) => ({
 			id,
 			phases,
-			severity
+			severity,
+			params: params === void 0 || Object.keys(params).length === 0 ? void 0 : params
 		})),
 		frontmatter: snapshot.frontmatter
 	}));
@@ -830,7 +1118,10 @@ async function runContracts(input) {
 		phase,
 		errors,
 		warnings,
-		contractsHash: await hashContracts(schemaSnapshot(collection), [SCHEMA_CONTRACT, ...contracts].map((contract) => describeContract(contract)))
+		contractsHash: await hashContracts(schemaSnapshot(collection), [SCHEMA_CONTRACT, ...contracts].map((contract) => ({
+			...describeContract(contract),
+			params: contract.rule?.params
+		})))
 	};
 }
 //#endregion
@@ -884,7 +1175,7 @@ function uniqueTranslationViolation(holder, field) {
 //#endregion
 //#region src/config/values.ts
 /** A value with keys: not null, not an array. */
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** A string as the messages show it: quoted, with what could break a line escaped. */
@@ -940,9 +1231,9 @@ const TARGET = "draft-2020-12";
 * The JSON Schema that a schema accepts as input, as plain JSON data. It throws what the library
 * throws when the schema has no JSON Schema (Zod: `z.date()`, `z.custom()`).
 */
-function toJsonSchema(schema) {
+function toJsonSchema$1(schema) {
 	const converted = schema["~standard"].jsonSchema.input({ target: TARGET });
-	if (!isRecord$1(converted)) throw new TypeError(`the library ${wrongType(converted, "a JSON Schema object")}`);
+	if (!isRecord$2(converted)) throw new TypeError(`the library ${wrongType(converted, "a JSON Schema object")}`);
 	return JSON.parse(JSON.stringify(converted));
 }
 /** Reference chains longer than this are cycles. */
@@ -954,7 +1245,7 @@ function pointTo(root, ref) {
 	let node = root;
 	for (const part of ref.slice(2).split("/")) {
 		const key = part.replaceAll("~1", "/").replaceAll("~0", "~");
-		if (!isRecord$1(node) || !Object.hasOwn(node, key)) return void 0;
+		if (!isRecord$2(node) || !Object.hasOwn(node, key)) return void 0;
 		node = node[key];
 	}
 	return node;
@@ -966,7 +1257,7 @@ function pointTo(root, ref) {
 function resolveSchema(root, schema) {
 	let node = schema;
 	for (let hop = 0; hop <= MAX_REF_HOPS; hop += 1) {
-		if (!isRecord$1(node)) return null;
+		if (!isRecord$2(node)) return null;
 		const ref = node["$ref"];
 		if (typeof ref !== "string") return node;
 		node = pointTo(root, ref);
@@ -1015,7 +1306,7 @@ const NO_BUILT_IN = [];
 function describeCollection(collection, builtIn) {
 	return {
 		name: collection.name,
-		schema: toJsonSchema(collection.schema),
+		schema: toJsonSchema$1(collection.schema),
 		routes: { ...collection.routes },
 		translationGroupField: collection.translationGroupField,
 		tagsField: collection.tagsField,
@@ -1024,7 +1315,7 @@ function describeCollection(collection, builtIn) {
 			name,
 			description: component.description ?? null,
 			example: component.example ?? null,
-			props: toJsonSchema(component.props)
+			props: toJsonSchema$1(component.props)
 		})),
 		contracts: [...builtIn, ...collection.contracts].map((contract) => describeContract(contract)),
 		maxMarkdownBytes: collection.maxMarkdownBytes,
@@ -1065,6 +1356,7 @@ function describeResolvedSite(site, options = {}) {
 			key: site.key,
 			locales: [...site.locales],
 			defaultLocale: site.defaultLocale,
+			url: site.url,
 			styleGuide: site.styleGuide,
 			collections: [...site.collections.values()].map((collection) => describeCollection(collection, builtIn))
 		});
@@ -1082,14 +1374,14 @@ function standardProps(value) {
 /** A Standard Schema that also converts to JSON Schema, which is what a collection needs. */
 function isDescribedSchema(value) {
 	const standard = standardProps(value);
-	if (!isRecord$1(standard) || typeof standard["validate"] !== "function") return false;
+	if (!isRecord$2(standard) || typeof standard["validate"] !== "function") return false;
 	const converter = standard["jsonSchema"];
-	return isRecord$1(converter) && typeof converter["input"] === "function";
+	return isRecord$2(converter) && typeof converter["input"] === "function";
 }
 /** What `isDescribedSchema` found missing, for the message. */
 function whyNotDescribed(value) {
 	const standard = standardProps(value);
-	if (!isRecord$1(standard)) return wrongType(value, "a Standard Schema with JSON Schema");
+	if (!isRecord$2(standard)) return wrongType(value, "a Standard Schema with JSON Schema");
 	if (typeof standard["validate"] !== "function") return "has no ~standard.validate function, so it is no Standard Schema";
 	return "has no ~standard.jsonSchema.input function, so describe_site could not show it to agents";
 }
@@ -1107,7 +1399,7 @@ function readSchema(path, raw, kind, problems) {
 	}
 	let document;
 	try {
-		document = toJsonSchema(raw);
+		document = toJsonSchema$1(raw);
 	} catch (error) {
 		problems.add(path, `cannot be converted to JSON Schema (${oneLine(errorMessage(error))})`, "Remove what JSON Schema cannot express, such as z.date() (use z.iso.date() for dates), z.custom() or z.map(), so that agents can read the schema.");
 		return null;
@@ -1159,7 +1451,7 @@ function claimRoute(route, path, site, problems) {
 }
 /** The route of each locale, in the order of the site's locales. */
 function readRoutes(path, raw, collection, site, problems) {
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "an object with one path per locale"), ROUTES_FIX);
 		return {};
 	}
@@ -1207,7 +1499,7 @@ function readField(path, raw, schema, kind, problems) {
 		return null;
 	}
 	if (schema === null) return raw;
-	const properties = isRecord$1(schema.object["properties"]) ? schema.object["properties"] : {};
+	const properties = isRecord$2(schema.object["properties"]) ? schema.object["properties"] : {};
 	if (!Object.hasOwn(properties, raw)) {
 		const names = Object.keys(properties);
 		problems.add(path, `${quote(raw)} is not a property of the schema${names.length === 0 ? ", which declares none" : ` (its properties are ${names.map(quote).join(", ")})`}`, `Name a field that the schema declares, or add ${quote(raw)} to the schema.`);
@@ -1216,7 +1508,7 @@ function readField(path, raw, schema, kind, problems) {
 }
 function readTranslations(path, raw, schema, problems) {
 	if (raw === void 0) return null;
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "an object like { groupBy: \"translationGroup\" }"), "Set it to { groupBy: \"<field>\" }, the field of the frontmatter that holds the key the translations of an entry share, or remove it.");
 		return null;
 	}
@@ -1225,7 +1517,7 @@ function readTranslations(path, raw, schema, problems) {
 const COMPONENT_FIX = "Declare it with defineComponent({ props: z.strictObject({ … }) }).";
 function readComponent(path, name, raw, problems) {
 	if (!NAME$1.test(name)) problems.add(path, `${quote(name)} is not a valid component name`, nameFix("callout"));
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "a component"), COMPONENT_FIX);
 		return null;
 	}
@@ -1243,7 +1535,7 @@ function readComponent(path, name, raw, problems) {
 function readComponents(path, raw, problems) {
 	const components = /* @__PURE__ */ new Map();
 	if (raw === void 0) return components;
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "an object that maps each component name to its definition"), COMPONENT_FIX);
 		return components;
 	}
@@ -1284,7 +1576,7 @@ function checkPhases(path, raw, problems) {
 * what makes it a `Contract`. Whether it may have its id is a question for `checkIdentity`.
 */
 function isContract(item, path, problems) {
-	if (!isRecord$1(item)) {
+	if (!isRecord$2(item)) {
 		problems.add(path, wrongType(item, "a contract"), "Write it as { id, severity, description, check }.");
 		return false;
 	}
@@ -1332,7 +1624,7 @@ function readContracts(path, raw, problems) {
 		if (isContract(item, itemAt, problems)) {
 			checkIdentity(item.id, isBuiltInContract(item), itemAt, ids, problems);
 			contracts.push(item);
-		} else if (isRecord$1(item) && typeof item["id"] === "string" && CONTRACT_ID.test(item["id"])) checkIdentity(item["id"], false, itemAt, ids, problems);
+		} else if (isRecord$2(item) && typeof item["id"] === "string" && CONTRACT_ID.test(item["id"])) checkIdentity(item["id"], false, itemAt, ids, problems);
 	}
 	return contracts;
 }
@@ -1348,7 +1640,7 @@ function readMaxMarkdownBytes(path, raw, problems) {
 */
 function readCollection(path, name, raw, site, problems) {
 	if (!NAME$1.test(name)) problems.add(path, `${quote(name)} is not a valid collection name`, nameFix("blog"));
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "a collection"), "Declare it with defineCollection({ schema, routes, … }).");
 		return null;
 	}
@@ -1399,7 +1691,7 @@ function readSiteUrl(path, raw, problems) {
 /** The origins of a site's pages that may read its published content from the browser. */
 function readCors(path, raw, problems) {
 	if (raw === void 0) return { origins: [] };
-	if (!isRecord$1(raw) || !Array.isArray(raw["origins"])) {
+	if (!isRecord$2(raw) || !Array.isArray(raw["origins"])) {
 		problems.add(path, wrongType(raw, "an object with origins"), "Declare it as { origins: [\"https://example.com\"] }, or remove it.");
 		return { origins: [] };
 	}
@@ -1416,7 +1708,7 @@ function readBindingName(path, raw, problems) {
 	return null;
 }
 function readWebhook(path, raw, problems) {
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "a webhook"), "Declare it as { name: \"newsletter\", url: \"https://…\", secret: \"WEBHOOK_SECRET\" }.");
 		return null;
 	}
@@ -1425,8 +1717,9 @@ function readWebhook(path, raw, problems) {
 	const url = raw["url"];
 	const urlOk = typeof url === "string" && URL.canParse(url) && new URL(url).protocol === "https:";
 	if (!urlOk) problems.add(keyPath(path, "url"), wrongType(url, "an https URL"), "Give the https URL that receives the events.");
-	const secret = readBindingName(keyPath(path, "secret"), raw["secret"], problems);
-	if (typeof name !== "string" || !NAME.test(name) || !urlOk || secret === null) return null;
+	const secret = raw["secret"] === void 0 ? null : readBindingName(keyPath(path, "secret"), raw["secret"], problems);
+	if (typeof name !== "string" || !NAME.test(name) || !urlOk) return null;
+	if (raw["secret"] !== void 0 && secret === null) return null;
 	return {
 		name,
 		url: String(url),
@@ -1440,7 +1733,7 @@ function readEvents(path, raw, siteUrl, problems) {
 		indexNow: null
 	};
 	if (raw === void 0) return events;
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "an object"), "Declare { webhooks: [ … ], indexNow: { … } }.");
 		return events;
 	}
@@ -1464,7 +1757,7 @@ function readEvents(path, raw, siteUrl, problems) {
 	const indexNow = raw["indexNow"];
 	if (indexNow !== void 0) {
 		const indexPath = keyPath(path, "indexNow");
-		if (!isRecord$1(indexNow)) problems.add(indexPath, wrongType(indexNow, "an object"), "Declare { key: \"INDEXNOW_KEY\" }.");
+		if (!isRecord$2(indexNow)) problems.add(indexPath, wrongType(indexNow, "an object"), "Declare { key: \"INDEXNOW_KEY\" }.");
 		else {
 			const key = readBindingName(keyPath(indexPath, "key"), indexNow["key"], problems);
 			if (siteUrl === null) problems.add(indexPath, "needs the URL of the site", "Set url on the site: IndexNow is told the public URLs of the entries.");
@@ -1550,7 +1843,7 @@ function readDefaultLocale(path, raw, locales, problems) {
 const COLLECTIONS_FIX = "Declare at least one: collections: { blog: defineCollection({ schema, routes }) }.";
 function readCollections(path, raw, site, problems) {
 	const collections = /* @__PURE__ */ new Map();
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "an object that maps each collection name to its collection"), COLLECTIONS_FIX);
 		return collections;
 	}
@@ -1566,7 +1859,7 @@ function readCollections(path, raw, site, problems) {
 function readSite(key, raw, problems) {
 	const path = keyPath("sites", key);
 	if (!isSiteKey(key)) problems.add(path, `${quote(key)} is not a valid site key`, SITE_KEY_FIX);
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add(path, wrongType(raw, "a site"), "Declare it as { locales: [\"en\"], defaultLocale: \"en\", collections: { … } }.");
 		return null;
 	}
@@ -1593,7 +1886,7 @@ function readSite(key, raw, problems) {
 }
 function readSites(raw, problems) {
 	const sites = /* @__PURE__ */ new Map();
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add("sites", wrongType(raw, "an object that maps the site key to the site"), SITE_FIX);
 		return sites;
 	}
@@ -1608,7 +1901,7 @@ function readSites(raw, problems) {
 /** `auth` of the config: absent, or an object whose `dynamicClientRegistration` is a boolean. */
 function readAuth(raw, problems) {
 	if (raw === void 0) return { dynamicClientRegistration: false };
-	if (!isRecord$1(raw)) {
+	if (!isRecord$2(raw)) {
 		problems.add("auth", wrongType(raw, "an object"), "Write auth: { dynamicClientRegistration: true }, or leave auth out.");
 		return { dynamicClientRegistration: false };
 	}
@@ -1650,7 +1943,7 @@ function resolveConfig(config) {
 	const problems = new Problems();
 	let sites = /* @__PURE__ */ new Map();
 	let auth = { dynamicClientRegistration: false };
-	if (isRecord$1(config)) {
+	if (isRecord$2(config)) {
 		sites = readSites(config["sites"], problems);
 		auth = readAuth(config["auth"], problems);
 	} else problems.add("config", wrongType(config, "an object"), "Export the result of defineConfig({ sites: { … } }) from hollware.config.ts.");
@@ -1661,6 +1954,426 @@ function resolveConfig(config) {
 	};
 }
 //#endregion
+//#region src/structure/definition.ts
+/**
+* The definition of a site as data (ADR-033): what D1 stores for it and what the operations that
+* change the structure take. Its shape is checked here; what only makes sense of the whole (a
+* route with `:slug`, a default locale among the locales, a rule's parameters) is checked when it
+* is compiled, with one problem for each thing wrong.
+*/
+const jsonSchema = z.record(z.string(), z.unknown()).describe("A JSON Schema, draft 2020-12, of an object.");
+const severity$1 = z.enum(["error", "warning"]);
+const ruleDefinition = z.strictObject({
+	rule: z.string().min(1).describe("The name of a rule of the catalog that describe_site lists."),
+	severity: severity$1.default("error"),
+	params: z.record(z.string(), z.unknown()).default({}).describe("The parameters of the rule, as the catalog describes them."),
+	id: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional().describe("The id of the contract, when a collection lists one rule twice; its name otherwise.")
+});
+const componentDefinitionData = z.strictObject({
+	props: jsonSchema.describe("The JSON Schema of the props."),
+	description: z.string().min(1).optional(),
+	example: z.string().min(1).optional()
+});
+const collectionDefinitionData = z.strictObject({
+	schema: jsonSchema.describe("The JSON Schema of the frontmatter."),
+	routes: z.record(z.string(), z.string()).describe("The public path of an entry in each locale, with :slug: { \"en\": \"/blog/:slug/\" }."),
+	translationGroupField: z.string().min(1).nullable().default(null),
+	tagsField: z.string().min(1).nullable().default(null),
+	sortByField: z.string().min(1).nullable().default(null),
+	components: z.record(z.string(), componentDefinitionData).default({}),
+	rules: z.array(ruleDefinition).default([]),
+	maxMarkdownBytes: z.number().int().positive().nullable().default(null),
+	styleGuide: z.string().nullable().default(null)
+});
+const webhookDefinition = z.strictObject({
+	name: z.string().min(1),
+	url: z.string().min(1).describe("The https URL that receives each event, signed."),
+	secret: z.string().min(1).optional().describe("The Worker secret that signs the deliveries. Leave it out for Hollware to make one with make_webhook_secret and keep it sealed.")
+});
+const siteDefinitionData = z.strictObject({
+	locales: z.array(z.string().min(1)).min(1),
+	defaultLocale: z.string().min(1),
+	url: z.string().min(1).nullable().default(null),
+	styleGuide: z.string().nullable().default(null),
+	cors: z.strictObject({ origins: z.array(z.string().min(1)) }).default({ origins: [] }),
+	events: z.strictObject({
+		webhooks: z.array(webhookDefinition).default([]),
+		indexNow: z.strictObject({ key: z.string().min(1) }).nullable().default(null)
+	}).default({
+		webhooks: [],
+		indexNow: null
+	}),
+	collections: z.record(z.string(), collectionDefinitionData)
+});
+//#endregion
+//#region src/structure/json-schema.ts
+/** The keywords that only say that a part below them failed; that part says what. */
+const SUMMARIES = /* @__PURE__ */ new Set([
+	"properties",
+	"items",
+	"prefixItems",
+	"additionalProperties",
+	"unevaluatedProperties",
+	"unevaluatedItems",
+	"allOf",
+	"patternProperties",
+	"contains",
+	"dependentSchemas",
+	"$ref"
+]);
+/** `#/tags/0` as the path of an issue: `['tags', '0']`. */
+function segmentsOf$1(location) {
+	return location.replace(/^#\/?/, "").split("/").filter((segment) => segment !== "").map((segment) => decodeURIComponent(segment).replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The schema of the object at `segments`, to tell a declared key from an unknown one. */
+function declaredKeys(schema, segments) {
+	let node = schema;
+	for (const segment of segments) {
+		if (!isRecord$1(node)) return /* @__PURE__ */ new Set();
+		const properties = node["properties"];
+		node = isRecord$1(properties) && Object.hasOwn(properties, segment) ? properties[segment] : node["items"];
+	}
+	const properties = isRecord$1(node) ? node["properties"] : void 0;
+	return new Set(isRecord$1(properties) ? Object.keys(properties) : []);
+}
+/** The issues of a validation: one for each part that failed, at the path of the value. */
+function issuesOf(schema, errors) {
+	const issues = [];
+	for (const error of errors) {
+		if (SUMMARIES.has(error.keyword)) continue;
+		const path = segmentsOf$1(error.instanceLocation);
+		if (error.keyword === "required") {
+			const missing = /required property "(.*)"/.exec(error.error)?.[1];
+			issues.push({
+				message: missing === void 0 ? error.error : `Missing required field "${missing}".`,
+				path: missing === void 0 ? path : [...path, missing]
+			});
+			continue;
+		}
+		if (error.keyword === "false") {
+			const key = path.at(-1);
+			if (key === void 0 || declaredKeys(schema, path.slice(0, -1)).has(key)) continue;
+			issues.push({
+				message: `Unrecognized key "${key}".`,
+				path
+			});
+			continue;
+		}
+		issues.push({
+			message: error.error,
+			path
+		});
+	}
+	return issues;
+}
+/** A JSON Schema (draft 2020-12) as a schema of Hollware. */
+function describedSchemaOf(schema) {
+	const validator = new Validator(schema, "2020-12", false);
+	return { "~standard": {
+		version: 1,
+		vendor: "hollware-json-schema",
+		validate: (value) => {
+			const result = validator.validate(value);
+			return result.valid ? { value } : { issues: issuesOf(schema, result.errors) };
+		},
+		jsonSchema: {
+			input: () => schema,
+			output: () => schema
+		}
+	} };
+}
+//#endregion
+//#region src/structure/compile.ts
+/**
+* The sites of a deployment from their definitions in D1 (ADR-033), resolved as a config is: the
+* same checks, the same defaults, the same `ResolvedSite` the rest of the server reads. It throws
+* one `ConfigError` with every problem, each at its path (`sites.blog.collections.posts.rules[0]`)
+* and with its fix, so that an operation that changes the structure answers what to change.
+*/
+function isObjectSchema(schema) {
+	return schema["type"] === "object";
+}
+function compileCollection(path, collection, problems) {
+	if (!isObjectSchema(collection.schema)) problems.add(keyPath(path, "schema"), "the schema of the frontmatter is not of an object", "Give a JSON Schema with \"type\": \"object\" and the fields under \"properties\".");
+	const components = {};
+	for (const [name, component] of Object.entries(collection.components)) components[name] = {
+		props: describedSchemaOf(component.props),
+		...component.description === void 0 ? {} : { description: component.description },
+		...component.example === void 0 ? {} : { example: component.example }
+	};
+	const contracts = [];
+	collection.rules.forEach((rule, index) => {
+		const at = itemPath(keyPath(path, "rules"), index);
+		const entry = catalogRule(rule.rule);
+		if (entry === void 0) {
+			problems.add(keyPath(at, "rule"), `there is no rule "${rule.rule}" in the catalog`, "Use the name of a rule that describe_site lists in its catalog.");
+			return;
+		}
+		const params = entry.params.safeParse(rule.params);
+		if (!params.success) {
+			problems.add(keyPath(at, "params"), `the parameters of "${rule.rule}" are not valid: ${z.prettifyError(params.error).replaceAll("\n", " ")}`, "Give the parameters as the catalog describes them for this rule.");
+			return;
+		}
+		contracts.push(entry.make(params.data, rule.severity, rule.id));
+	});
+	return {
+		schema: describedSchemaOf(collection.schema),
+		routes: collection.routes,
+		...collection.translationGroupField === null ? {} : { translations: { groupBy: collection.translationGroupField } },
+		...collection.tagsField === null ? {} : { tags: collection.tagsField },
+		...collection.sortByField === null ? {} : { sortBy: collection.sortByField },
+		components,
+		contracts,
+		...collection.maxMarkdownBytes === null ? {} : { maxMarkdownBytes: collection.maxMarkdownBytes },
+		...collection.styleGuide === null ? {} : { styleGuide: collection.styleGuide }
+	};
+}
+function compileSite(path, site, problems) {
+	const collections = {};
+	for (const [name, collection] of Object.entries(site.collections)) collections[name] = compileCollection(keyPath(keyPath(path, "collections"), name), collection, problems);
+	const [first, ...rest] = site.locales;
+	return {
+		locales: [first ?? "", ...rest],
+		defaultLocale: site.defaultLocale,
+		collections,
+		...site.url === null ? {} : { url: site.url },
+		...site.styleGuide === null ? {} : { styleGuide: site.styleGuide },
+		cors: { origins: site.cors.origins },
+		events: {
+			webhooks: site.events.webhooks.map((webhook) => ({
+				name: webhook.name,
+				url: webhook.url,
+				...webhook.secret === void 0 ? {} : { secret: webhook.secret }
+			})),
+			...site.events.indexNow === null ? {} : { indexNow: site.events.indexNow }
+		}
+	};
+}
+/** The definitions of the sites, read from D1 as JSON, checked and resolved. */
+function compileSites(definitions) {
+	const problems = new Problems();
+	const sites = {};
+	for (const [key, raw] of Object.entries(definitions)) {
+		const path = keyPath("sites", key);
+		const parsed = siteDefinitionData.safeParse(raw);
+		if (!parsed.success) {
+			for (const issue of parsed.error.issues) problems.add([path, ...issue.path.map(String)].join("."), issue.message.replace(/\.$/, ""), "Write the definition as describe_site shows one.");
+			continue;
+		}
+		sites[key] = compileSite(path, parsed.data, problems);
+	}
+	if (problems.list.length > 0) throw new ConfigError(problems.list);
+	if (Object.keys(sites).length === 0) return {
+		sites: /* @__PURE__ */ new Map(),
+		auth: { dynamicClientRegistration: false }
+	};
+	return resolveConfig({ sites });
+}
+//#endregion
+//#region src/structure/from-config.ts
+function toJsonSchema(schema) {
+	return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+}
+function collectionOf(path, collection, problems) {
+	const rules = [];
+	(collection.contracts ?? []).forEach((contract, index) => {
+		if (contract.rule === void 0) {
+			problems.add(itemPath(keyPath(path, "contracts"), index), `the contract "${contract.id}" is code of the config's own, which a definition cannot hold`, "Replace it with a rule of the catalog (contracts.fieldLength, contracts.fieldPattern, contracts.requiredToPublish, contracts.bannedWords, or the built-in ones), then deploy again.");
+			return;
+		}
+		rules.push({
+			rule: contract.rule.name,
+			severity: contract.severity,
+			params: { ...contract.rule.params },
+			...contract.id === contract.rule.name ? {} : { id: contract.id }
+		});
+	});
+	return {
+		schema: toJsonSchema(collection.schema),
+		routes: { ...collection.routes },
+		translationGroupField: collection.translations?.groupBy ?? null,
+		tagsField: collection.tags ?? null,
+		sortByField: collection.sortBy ?? null,
+		components: Object.fromEntries(Object.entries(collection.components ?? {}).map(([name, component]) => [name, {
+			props: toJsonSchema(component.props),
+			...component.description === void 0 ? {} : { description: component.description },
+			...component.example === void 0 ? {} : { example: component.example }
+		}])),
+		rules,
+		maxMarkdownBytes: collection.maxMarkdownBytes ?? null,
+		styleGuide: collection.styleGuide ?? null
+	};
+}
+/** Every site of the config as a definition, or a `ConfigError` with what keeps one from moving. */
+function definitionsFromConfig(config) {
+	const problems = new Problems();
+	const definitions = {};
+	for (const [key, site] of Object.entries(config.sites ?? {})) {
+		const path = keyPath("sites", key);
+		definitions[key] = {
+			locales: [...site.locales],
+			defaultLocale: site.defaultLocale,
+			url: site.url ?? null,
+			styleGuide: site.styleGuide ?? null,
+			cors: { origins: [...site.cors?.origins ?? []] },
+			events: {
+				webhooks: (site.events?.webhooks ?? []).map((webhook) => ({ ...webhook })),
+				indexNow: site.events?.indexNow ?? null
+			},
+			collections: Object.fromEntries(Object.entries(site.collections).map(([name, collection]) => [name, collectionOf(keyPath(keyPath(path, "collections"), name), collection, problems)]))
+		};
+	}
+	if (problems.list.length > 0) throw new ConfigError(problems.list);
+	return definitions;
+}
+//#endregion
+//#region src/structure/presets.ts
+const PRESETS = [
+	"blog",
+	"docs",
+	"empty"
+];
+/** The path of an entry in each locale: the default one at the root, the others under theirs. */
+function routesFor(name, locales, defaultLocale) {
+	return Object.fromEntries(locales.map((locale) => [locale, locale === defaultLocale ? `/${name}/:slug/` : `/${locale}/${name}/:slug/`]));
+}
+function collectionPreset(preset, name, locales, defaultLocale) {
+	const translated = locales.length > 1;
+	const base = {
+		routes: routesFor(name, locales, defaultLocale),
+		translationGroupField: null,
+		tagsField: null,
+		sortByField: null,
+		components: {},
+		rules: [],
+		maxMarkdownBytes: null,
+		styleGuide: null
+	};
+	switch (preset) {
+		case "empty": return {
+			...base,
+			schema: {
+				type: "object",
+				properties: { title: {
+					type: "string",
+					minLength: 1
+				} },
+				required: ["title"]
+			}
+		};
+		case "blog": return {
+			...base,
+			schema: {
+				type: "object",
+				properties: {
+					title: {
+						type: "string",
+						minLength: 1
+					},
+					description: {
+						type: "string",
+						minLength: 1,
+						maxLength: 160
+					},
+					date: {
+						type: "string",
+						format: "date"
+					},
+					tags: {
+						type: "array",
+						items: {
+							type: "string",
+							minLength: 1
+						}
+					},
+					...translated ? { translationGroup: {
+						type: "string",
+						minLength: 1
+					} } : {}
+				},
+				required: [
+					"title",
+					"description",
+					"date",
+					...translated ? ["translationGroup"] : []
+				]
+			},
+			translationGroupField: translated ? "translationGroup" : null,
+			tagsField: "tags",
+			sortByField: "date",
+			rules: [
+				{
+					rule: "images-have-alt",
+					severity: "error",
+					params: {}
+				},
+				{
+					rule: "internal-links-resolve",
+					severity: "warning",
+					params: {}
+				},
+				...translated ? [{
+					rule: "translation-pair",
+					severity: "warning",
+					params: {}
+				}] : []
+			]
+		};
+		case "docs": return {
+			...base,
+			schema: {
+				type: "object",
+				properties: {
+					title: {
+						type: "string",
+						minLength: 1,
+						maxLength: 70
+					},
+					description: {
+						type: "string",
+						minLength: 1,
+						maxLength: 160
+					},
+					order: {
+						type: "integer",
+						minimum: 0
+					}
+				},
+				required: ["title", "description"]
+			},
+			rules: [{
+				rule: "images-have-alt",
+				severity: "error",
+				params: {}
+			}, {
+				rule: "internal-links-resolve",
+				severity: "warning",
+				params: {}
+			}]
+		};
+	}
+}
+/** A new site: its locales, and one collection from the preset. */
+function sitePreset(preset, locales, defaultLocale) {
+	const name = preset === "empty" ? "pages" : preset;
+	const collections = { [name]: collectionPreset(preset, name, locales, defaultLocale) };
+	return {
+		locales: [...locales],
+		defaultLocale,
+		url: null,
+		styleGuide: null,
+		cors: { origins: [] },
+		events: {
+			webhooks: [],
+			indexNow: null
+		},
+		collections
+	};
+}
+//#endregion
 //#region src/errors.ts
 /**
 * The errors of an operation that are none of its outcomes: the caller asked for something it
@@ -1712,8 +2425,11 @@ const ID_PREFIXES = {
 	revision: "rev",
 	revisionTag: "tag",
 	review: "rvw",
+	reviewComment: "rvc",
 	schedule: "sch",
 	session: "ses",
+	siteChange: "sit",
+	siteSecret: "sec",
 	token: "tok",
 	user: "usr"
 };
@@ -3050,6 +3766,7 @@ var schemas_exports = /* @__PURE__ */ __exportAll({
 	phase: () => phase,
 	publication: () => publication,
 	review: () => review,
+	reviewComment: () => reviewComment,
 	reviewId: () => reviewId,
 	reviewStatus: () => reviewStatus,
 	revisionId: () => revisionId,
@@ -3110,6 +3827,7 @@ const entrySummary = z.object({
 	tags: z.array(z.string()),
 	hasUnpublishedChanges: z.boolean().describe("Whether the latest revision differs from the published one."),
 	publishedAt: z.string().nullable().describe("When the entry was first published, or null."),
+	scheduledAt: z.string().nullable().describe("When a scheduled entry will be published, or null for one that is not scheduled."),
 	updatedAt: z.string()
 });
 const publication = z.object({
@@ -3155,6 +3873,15 @@ const review = z.object({
 	decidedAt: z.string().nullable(),
 	note: z.string().nullable().describe("What the reviewer asked to change, or null.")
 });
+/** A comment on a review (v0.6), by a person or by the agent of one. */
+const reviewComment = z.object({
+	id: z.string(),
+	author: z.string().describe("The user who wrote it, or whose token their agent used."),
+	authorName: z.string().nullable(),
+	client: z.string().nullable().describe("The name the client gave, such as hollware-agents for the agents; null for none."),
+	body: z.string(),
+	at: z.string()
+});
 const conflict = z.object({
 	currentVersion: z.number().int().min(1),
 	headRevision: revisionId
@@ -3198,6 +3925,7 @@ const siteDescription = z.object({
 	key: z.string(),
 	locales: z.array(z.string()),
 	defaultLocale: z.string(),
+	url: z.string().nullable().describe("The public origin of the site, which starts the URL of each entry, or null."),
 	styleGuide: z.string().nullable(),
 	collections: z.array(collectionDescription)
 });
@@ -3454,7 +4182,10 @@ const listReviews = defineOperation({
 	}),
 	output: z.object({
 		outcome: z.enum(["ok"]),
-		reviews: z.array(review.extend({ entry: entrySummary }))
+		reviews: z.array(review.extend({
+			entry: entrySummary,
+			comments: z.array(reviewComment).describe("What was said about it, oldest first.")
+		}))
 	}),
 	scopes: ["content:read"],
 	effect: "read",
@@ -3490,6 +4221,62 @@ const approveReview = defineOperation({
 		not_found: { isError: true }
 	}
 });
+const requestReview = defineOperation({
+	name: "request_review",
+	title: "Ask for a review",
+	description: "Asks a person who may publish to review the latest revision of an entry, after the same checks publish makes, if the entry is still at the version you read. It never publishes, whatever your scopes: the answer is pending_review, or why not (blocked by the contracts, warnings to acknowledge, a conflict). A new revision of the entry cancels the request.",
+	input: z.strictObject({
+		id: entryId,
+		version,
+		acknowledgeWarnings: z.array(acknowledgedWarning).default([]).describe("The warnings you accept, as needs_acknowledgement listed them.")
+	}),
+	output: z.object({
+		outcome: z.enum([
+			"pending_review",
+			"blocked",
+			"needs_acknowledgement",
+			"conflict",
+			"not_found"
+		]),
+		entry: entrySummary.optional(),
+		verdict: verdict.optional(),
+		conflict: conflict.optional(),
+		review: review.optional().describe("With pending_review: the request, as list_reviews shows it.")
+	}),
+	scopes: ["content:write"],
+	effect: "write",
+	outcomes: {
+		pending_review: { isError: false },
+		blocked: { isError: true },
+		needs_acknowledgement: { isError: false },
+		conflict: { isError: true },
+		not_found: { isError: true }
+	}
+});
+const commentReview = defineOperation({
+	name: "comment_review",
+	title: "Comment on a review",
+	description: "Adds a comment to a pending review, for the person who decides it and for the author: what to change, what reads well, what the contracts cannot check. It neither approves nor closes the review.",
+	input: z.strictObject({
+		id: reviewId,
+		body: z.string().trim().min(1).max(4e3).describe("The comment, in Markdown.")
+	}),
+	output: z.object({
+		outcome: z.enum([
+			"commented",
+			"not_pending",
+			"not_found"
+		]),
+		comment: reviewComment.optional()
+	}),
+	scopes: ["content:write"],
+	effect: "write",
+	outcomes: {
+		commented: { isError: false },
+		not_pending: { isError: true },
+		not_found: { isError: true }
+	}
+});
 const requestChanges = defineOperation({
 	name: "request_changes",
 	title: "Ask for changes",
@@ -3538,21 +4325,205 @@ const contentStats = defineOperation({
 		unavailable: { isError: true }
 	}
 });
+const siteKey = z.string().refine(isSiteKey, { message: "Not a site key: lowercase words joined by hyphens, such as my-site." }).describe("The key of a site: lowercase letters and digits joined by hyphens, such as my-site.");
+const structureVersion = z.number().int().min(0).describe("The version of the structure you read with get_structure. Another one answers conflict.");
+const confirm = z.boolean().default(false).describe("true to go ahead when needs_confirmation listed what the change does to existing entries.");
+const problem = z.object({
+	path: z.string().describe("Where, from the root: sites.<key>.collections.<name>.schema."),
+	message: z.string(),
+	fix: z.string()
+});
+/** What a change of the structure would do to the entries a site already has. */
+const impact = z.object({
+	removedCollections: z.array(z.object({
+		name: z.string(),
+		entries: z.number().int()
+	})).describe("Collections the change removes, with how many entries each holds."),
+	removedLocales: z.array(z.object({
+		locale: z.string(),
+		entries: z.number().int()
+	})).describe("Locales the change removes, with how many entries each holds."),
+	refused: z.array(z.object({
+		collection: z.string(),
+		entries: z.number().int().describe("Entries whose latest frontmatter the new schema refuses."),
+		examples: z.array(z.string()).describe("A few of their slugs.")
+	})).describe("Collections whose new schema refuses entries they hold; they stay, and their next write is checked against it.")
+});
+const structureChange = z.object({
+	outcome: z.enum([
+		"updated",
+		"unchanged",
+		"invalid",
+		"needs_confirmation",
+		"conflict"
+	]),
+	version: z.number().int().optional().describe("The version of the structure now."),
+	problems: z.array(problem).optional().describe("With invalid: every problem, each with its fix."),
+	impact: impact.optional().describe("With needs_confirmation: what the change would do."),
+	currentVersion: z.number().int().optional().describe("With conflict: the version to read again.")
+});
+const STRUCTURE_OUTCOMES = {
+	updated: { isError: false },
+	unchanged: { isError: false },
+	invalid: { isError: true },
+	needs_confirmation: { isError: false },
+	conflict: { isError: true }
+};
+const getStructure = defineOperation({
+	name: "get_structure",
+	title: "Get the structure of the site",
+	description: "Gets the definition of the site as update_site and set_collection take it: its locales, URL, CORS origins, events, style guide, and each collection with the JSON Schema of its frontmatter, its routes, components and rules; with its version, and the catalog of rules a collection may use, each with the JSON Schema of its parameters.",
+	input: z.strictObject({}),
+	output: z.object({
+		outcome: z.enum(["ok"]),
+		site: z.string(),
+		version: z.number().int(),
+		definition: siteDefinitionData,
+		catalog: z.array(z.object({
+			name: z.string(),
+			description: z.string(),
+			params: z.record(z.string(), z.unknown()).describe("The JSON Schema of its parameters.")
+		}))
+	}),
+	scopes: ["content:read"],
+	effect: "read",
+	outcomes: { ok: { isError: false } }
+});
+const updateSite = defineOperation({
+	name: "update_site",
+	title: "Change the structure of the site",
+	description: "Replaces the definition of the site with another, at once and with no deploy: read it with get_structure, change it, and send it with the version you read. Every problem is answered at its path with its fix, and nothing changes. A change that removes a collection or a locale with entries, or a schema that refuses entries the site holds, answers needs_confirmation with what it would do; send it again with confirm to go ahead. Entries are never deleted: a removed collection keeps them out of reach until it comes back.",
+	input: z.strictObject({
+		version: structureVersion,
+		definition: siteDefinitionData,
+		confirm
+	}),
+	output: structureChange.describe("What became of the definition."),
+	scopes: ["schema:admin"],
+	effect: "destructive",
+	outcomes: STRUCTURE_OUTCOMES
+});
+const setCollection = defineOperation({
+	name: "set_collection",
+	title: "Add, change or remove a collection",
+	description: "Adds the collection name to the site, replaces it, or removes it with collection null, leaving the rest of the definition as it is; with the version of the structure you read. Answers as update_site does.",
+	input: z.strictObject({
+		version: structureVersion,
+		name: z.string().regex(/^[a-z][a-z0-9-]*$/).describe("The name of the collection: lowercase letters, digits and hyphens, such as blog."),
+		collection: collectionDefinitionData.nullable().describe("The collection, or null to remove it."),
+		confirm
+	}),
+	output: structureChange.describe("What became of the collection."),
+	scopes: ["schema:admin"],
+	effect: "destructive",
+	outcomes: STRUCTURE_OUTCOMES
+});
+const createSite = defineOperation({
+	name: "create_site",
+	title: "Create a site",
+	description: "Creates a site in this deployment, with its definition, and makes you its owner. It is served at once; to work in it, get a token of that site (the admin switches to it).",
+	input: z.strictObject({
+		key: siteKey,
+		definition: siteDefinitionData
+	}),
+	output: z.object({
+		outcome: z.enum([
+			"created",
+			"taken",
+			"invalid"
+		]),
+		version: z.number().int().optional(),
+		problems: z.array(problem).optional().describe("With invalid: every problem, each with its fix.")
+	}),
+	scopes: ["schema:admin"],
+	effect: "write",
+	outcomes: {
+		created: { isError: false },
+		taken: { isError: true },
+		invalid: { isError: true }
+	}
+});
+const deleteSite = defineOperation({
+	name: "delete_site",
+	title: "Put a site in the trash",
+	description: "Puts a site you own in the trash: it is served no more, and its tokens stop working. Nothing is deleted; restore_site brings it back, from a token of another site you own. The first call answers needs_confirmation with how many entries the site holds; call again with confirm.",
+	input: z.strictObject({
+		key: siteKey,
+		confirm
+	}),
+	output: z.object({
+		outcome: z.enum([
+			"trashed",
+			"needs_confirmation",
+			"not_found"
+		]),
+		entries: z.number().int().optional().describe("With needs_confirmation: the entries the site holds.")
+	}),
+	scopes: ["schema:admin"],
+	effect: "destructive",
+	outcomes: {
+		trashed: { isError: false },
+		needs_confirmation: { isError: false },
+		not_found: { isError: true }
+	}
+});
+const restoreSite = defineOperation({
+	name: "restore_site",
+	title: "Bring a site back from the trash",
+	description: "Brings back a site you own from the trash, as it was: served again, with its entries and tokens.",
+	input: z.strictObject({ key: siteKey }),
+	output: z.object({ outcome: z.enum(["restored", "not_found"]) }),
+	scopes: ["schema:admin"],
+	effect: "write",
+	outcomes: {
+		restored: { isError: false },
+		not_found: { isError: true }
+	}
+});
 /** Every operation, sorted by name: the order of `tools/list`. */
 const OPERATIONS = [
 	approveReview,
+	commentReview,
 	contentStats,
 	createDraft,
+	createSite,
+	deleteSite,
 	describeSite,
 	getEntry,
+	getStructure,
 	getTranslations,
 	listEntries,
 	listReviews,
+	defineOperation({
+		name: "make_webhook_secret",
+		title: "Make the secret of a webhook",
+		description: "Makes a new secret for a webhook of the site that names no Worker secret of its own, keeps it sealed, and answers it once: give it to the receiver, which checks each delivery's signature with it. A new one replaces the old at once. unavailable when the deployment has no HOLLWARE_SECRET to seal it with.",
+		input: z.strictObject({ webhook: z.string().min(1).describe("The name of the webhook, as the definition of the site has it.") }),
+		output: z.object({
+			outcome: z.enum([
+				"made",
+				"not_found",
+				"unavailable"
+			]),
+			secret: z.string().optional().describe("With made: the secret, shown this once.")
+		}),
+		scopes: ["schema:admin"],
+		effect: "write",
+		outcomes: {
+			made: { isError: false },
+			not_found: { isError: true },
+			unavailable: { isError: true }
+		}
+	}),
 	publish,
 	requestChanges,
+	requestReview,
+	restoreSite,
 	search,
+	setCollection,
 	unpublish,
 	updateDraft,
+	updateSite,
 	validate
 ];
 //#endregion
@@ -3667,82 +4638,58 @@ async function verifyWebhook(check) {
 	return sameText(signature, await signWebhook(check.secret, timestamp, check.body));
 }
 //#endregion
-//#region src/search/chunks.ts
+//#region src/cache.ts
 /**
-* The pieces of an entry that semantic search embeds (v0.5): one summary, and one piece for each
-* section the body has under an `h2`. Vectors are derived data, like the Comark document: a change
-* of this version makes every vector one to make again.
+* The cache tags of Hollware's content (S8): one name for each thing a page can show, so that a
+* site tags each page with what it read and purges, when an event says what changed, the pages
+* that showed it. Hollware puts the tags an event invalidates in its payload; `@hollware/nuxt`
+* tags its pages with the same functions. A tag is at most 1,024 characters of printable ASCII
+* with no space or comma, which every cache that purges by tag takes.
+*
+* - `entry:<id>`: a page that shows the entry, its own or one that embeds it;
+* - `list:<collection>:<locale>`: a page that lists the entries of a collection in a locale, and
+*   `list:<collection>:*` one that lists them in every locale;
+* - `group:<collection>:<group>`: a page that links to the translations of a group;
+* - `site`: a page that shows the structure of the site, such as its navigation.
 */
-const CHUNKER_VERSION = "1";
-/** How long a piece may grow, in characters, before it is cut at a word. */
-const CHUNK_LIMITS = {
-	summary: 1200,
-	section: 2e3
-};
-/** The text a reader sees in a node: its strings, never its tag, attributes or comments. */
-function textOf(node) {
-	if (typeof node === "string") return node;
-	if (!Array.isArray(node) || node[0] === null) return "";
-	return node.slice(2).map((child) => textOf(child)).join("");
+const SITE_TAG = "site";
+const MAX = 1024;
+/** A part of a tag in the characters a tag may hold: percent-encoded, commas and all. */
+function part(value) {
+	return encodeURIComponent(value).replaceAll(",", "%2C").replaceAll("'", "%27");
 }
-function tagOf(node) {
-	return Array.isArray(node) && typeof node[0] === "string" ? node[0] : null;
+function cut(tag) {
+	return tag.length <= MAX ? tag : tag.slice(0, MAX);
 }
-/** The words of a text in one line, cut at the last word that fits in `limit`. */
-function fit(text, limit) {
-	const flat = text.replace(/\s+/g, " ").trim();
-	if (flat.length <= limit) return flat;
-	const cut = flat.slice(0, limit);
-	const lastSpace = cut.lastIndexOf(" ");
-	return (lastSpace > 0 ? cut.slice(0, lastSpace) : cut).trim();
+function entryTag(id) {
+	return cut(`entry:${part(id)}`);
+}
+function listTag(collection, locale) {
+	return cut(`list:${part(collection)}:${part(locale)}`);
+}
+function groupTag(collection, group) {
+	return cut(`group:${part(collection)}:${part(group)}`);
+}
+/** The locale of a list of every locale. */
+const EVERY_LOCALE = "*";
+/** The tags of a page that shows these entries, each its own. */
+function tagsOfEntries(entries) {
+	return [...new Set(entries.map((entry) => entryTag(entry.id)))];
 }
 /**
-* The pieces of an entry: the summary (its title, its description and the text before the first
-* `h2`), then each section (its heading and its text up to the next `h2`). An `h1` adds nothing:
-* it repeats the title. A section with no text is left out.
+* The tags an event about an entry invalidates: the pages that show it, the lists of its
+* collection in its locale and in every locale, and the pages that link to its translations.
 */
-function chunksOf(entry) {
-	const intro = [];
-	const sections = [];
-	for (const node of entry.document.nodes) {
-		const tag = tagOf(node);
-		if (tag === "h1") continue;
-		if (tag === "h2") {
-			sections.push({
-				heading: textOf(node).trim(),
-				parts: []
-			});
-			continue;
-		}
-		const text = textOf(node);
-		const current = sections.at(-1);
-		if (current === void 0) intro.push(text);
-		else current.parts.push(text);
-	}
-	const chunks = [{
-		index: 0,
-		kind: "summary",
-		heading: null,
-		text: fit([
-			entry.title,
-			entry.description ?? "",
-			intro.join(" ")
-		].filter((part) => part !== "").join("\n"), CHUNK_LIMITS.summary)
-	}];
-	for (const section of sections) {
-		const body = section.parts.join(" ").trim();
-		if (body === "") continue;
-		chunks.push({
-			index: chunks.length,
-			kind: "section",
-			heading: section.heading,
-			text: fit(`${section.heading}\n${body}`, CHUNK_LIMITS.section)
-		});
-	}
-	return chunks;
+function tagsOfChange(entry) {
+	return [
+		entryTag(entry.id),
+		listTag(entry.collection, entry.locale),
+		listTag(entry.collection, "*"),
+		...entry.translationGroup === null ? [] : [groupTag(entry.collection, entry.translationGroup)]
+	];
 }
 //#endregion
 //#region src/index.ts
 const name = "@hollware/core";
 //#endregion
-export { BUILT_IN_CONTRACT_IDS, CHUNKER_VERSION, CHUNK_LIMITS, COMARK_VERSION, ConfigError, DEFAULT_MAX_MARKDOWN_BYTES, ERROR_CODES, EVENT_ID_HEADER, HollwareError, ID_PREFIXES, MAX_MARKDOWN_BYTES_CEILING, OPERATIONS, PERSONAL_TOKEN_PREFIX, PERSONAL_TOKEN_TTL_DAYS, PIPELINE_VERSION, READ_TOKEN_PREFIX, REFUSAL_CONTRACT_IDS, SCOPES, SIGNATURE_HEADER, SITE_KEY_MAX_LENGTH, SITE_KEY_PATTERN, TIMESTAMP_HEADER, approveReview, chunksOf, contentStats, contracts, createDraft, defineCollection, defineComponent, defineConfig, defineContract, defineOperation, describeBuiltInContracts, describeContract, describeResolvedSite, describeSite, generatePersonalToken, generateReadToken, getEntry, getTranslations, hashPersonalToken, isBuiltInContract, isId, isPersonalToken, isReadToken, isScope, isSiteKey, listEntries, listReviews, name, newId, processMarkdown, publish, renderHtml, requestChanges, resolveConfig, runContracts, schemas_exports as schemas, search, signWebhook, sizeLimitViolation, ulid, uniqueSlugViolation, uniqueTranslationViolation, unpublish, updateDraft, validate, verifyWebhook };
+export { BUILT_IN_CONTRACT_IDS, CATALOG, CHUNKER_VERSION, CHUNK_LIMITS, COMARK_VERSION, ConfigError, DEFAULT_MAX_MARKDOWN_BYTES, ERROR_CODES, EVENT_ID_HEADER, EVERY_LOCALE, HollwareError, ID_PREFIXES, MAX_MARKDOWN_BYTES_CEILING, OPERATIONS, PERSONAL_TOKEN_PREFIX, PERSONAL_TOKEN_TTL_DAYS, PIPELINE_VERSION, PRESETS, READ_TOKEN_PREFIX, REFUSAL_CONTRACT_IDS, SCOPES, SIGNATURE_HEADER, SITE_KEY_MAX_LENGTH, SITE_KEY_PATTERN, SITE_TAG, TIMESTAMP_HEADER, approveReview, canonicalJson, catalogRule, chunksOf, collectionDefinitionData, collectionPreset, commentReview, compileSites, componentDefinitionData, contentStats, contracts, createDraft, defineCollection, defineComponent, defineConfig, defineContract, defineOperation, definitionsFromConfig, describeBuiltInContracts, describeCatalog, describeContract, describeResolvedSite, describeSite, describedSchemaOf, entryTag, generatePersonalToken, generateReadToken, getEntry, getTranslations, groupTag, hashPersonalToken, isBuiltInContract, isId, isPersonalToken, isReadToken, isScope, isSiteKey, listEntries, listReviews, listTag, name, newId, processMarkdown, publish, renderHtml, requestChanges, requestReview, resolveConfig, routesFor, ruleDefinition, runContracts, schemas_exports as schemas, search, signWebhook, siteDefinitionData, sitePreset, sizeLimitViolation, tagsOfChange, tagsOfEntries, ulid, uniqueSlugViolation, uniqueTranslationViolation, unpublish, updateDraft, validate, verifyWebhook, webhookDefinition };