@hollware/core 0.6.0 → 0.9.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
@@ -1715,6 +2428,8 @@ const ID_PREFIXES = {
 	reviewComment: "rvc",
 	schedule: "sch",
 	session: "ses",
+	siteChange: "sit",
+	siteSecret: "sec",
 	token: "tok",
 	user: "usr"
 };
@@ -3112,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({
@@ -3209,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)
 });
@@ -3608,23 +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
@@ -3739,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, commentReview, 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, requestReview, 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 };