@lernapps/app-templates 0.0.1 → 0.1.1

package/dist/explainer-plugin.mjs

@@ -0,0 +1,2132 @@
+import { _ as exampleProblems, a as routes, c as exerciseData, d as templatesOf, g as describedProblems, h as TABLE_CONTRACT, i as hiddenChapter, l as renderExercise, m as SIZE_BUDGET, n as loadSite, o as terms, p as formulaAlternative, r as contentPages, s as dataOf, t as ContentError, u as taskSeeds, v as propertyProblems, y as propsIn } from "./load-RosvaPZf.mjs";
+import { i as inLanguage, s as localeOf, t as escape } from "./html-mffkHGHh.mjs";
+import { n as markerOf } from "./block-BK_ohsH1.mjs";
+import { n as renderMaterial } from "./blocks-CxtCPAa5.mjs";
+import { c as renderMarkdown, l as renderWithFormulas, o as plain, s as renderInline } from "./check-CteIFN96.mjs";
+import { _ as questionIn, a as renderQuestion, i as questionMessagesIn, n as answerText } from "./render-GS1Htlu8.mjs";
+import { n as isSizeless, t as imageType } from "./image-CspJVfyQ.mjs";
+import { a as pageFooter, c as withLanguage, i as notFoundPage, n as fromDepth, o as pageHeader, r as languageRoot, s as relative, t as alternateLinks } from "./pages-9RaaomoO.mjs";
+import { B as label, D as generate, F as questionFor, H as placeholdersIn, S as videoLine, U as plainText, V as placeholderValue, X as kindOf, _ as termId, a as assessments, b as renderVideo, h as allBlocks, m as titleOf, o as drawsTasks, p as stepHint, r as assessmentOf, v as timelineEvents, w as message } from "./assessment-Dy359O1O.mjs";
+import { i as NEW_TASK_ICON } from "./tasks-DADUYy52.mjs";
+import { n as NEEDS, o as languageName, t as LANGUAGES } from "./needs-BzEahJ6X.mjs";
+import { n as vueAlias, r as withServer, t as VUE_OPTIONS } from "./vue-DO1m6q1R.mjs";
+import { Marked } from "marked";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gzipSync } from "node:zlib";
+// runtime/explainer/tutor.ts
+const WORDS$3 = {
+	de: {
+		task: "Aufgabe",
+		answerFormat: "Antwortformat",
+		solution: "Lösung",
+		explanation: "Erklärung",
+		hint: "Tipp der App",
+		mistakes: "Typische Fehler und was die App sagt",
+		componentMistakes: "Typische Fehler (die Meldung der App passt zu einem davon)",
+		options: "Antworten zur Wahl (✓ richtig, ✗ falsch, mit der Meldung der App)",
+		right: "✓",
+		wrong: "✗",
+		component: "interaktive Übung",
+		does: "Was zu tun ist",
+		correct: "Was als richtig zählt",
+		example: "Beispiel",
+		note: "Merke",
+		figure: "Bild",
+		caption: "Bildunterschrift",
+		labels: "Beschriftungen",
+		interactive: "Interaktiv",
+		video: "Video",
+		exerciseHere: "Übung `{id}` (unten)",
+		points: "Eine gute Antwort enthält (P1, P2 … wie die App sie nennt)",
+		pointContent: "Inhalt",
+		pointForm: "Form",
+		source: "Quelle",
+		modelAnswer: "Musterantwort",
+		answerWays: {
+			text: "in eigenen Worten eintippen",
+			photo: "in eigenen Worten auf Papier schreiben und das Blatt fotografieren",
+			both: "in eigenen Worten eintippen oder auf Papier schreiben und das Blatt fotografieren"
+		},
+		openGuide: "So hilfst du: Die App zeigt die Punkte erst nach der Antwort; das Kind hakt selbst ab, welche seine Antwort enthält, und „es fehlen P2, P4“ nennt die anderen. Fehlt dir die Antwort, bitte das Kind, sie einzufügen oder das Foto seines Blatts anzuhängen. Prüf Punkt für Punkt, auch die abgehakten, und sag zuerst, was gelungen ist. Zu einem fehlenden Punkt stell eine Frage, die dorthin führt, und nenn seine Quelle. Verrate die Musterantwort nicht, bevor das Kind es noch einmal versucht hat. Zu einem Punkt der Form zeig an einem Satz des Kindes, wie es besser geht.",
+		formats: {
+			"single-choice": "eine Antwort wählen",
+			"multiple-choice": "alle richtigen Antworten wählen",
+			"true-false": "„Stimmt“ oder „Stimmt nicht“ wählen",
+			number: "eine Zahl eintippen",
+			ordering: "die Einträge in die richtige Reihenfolge bringen (die App zeigt sie gemischt)",
+			matching: "jedem Eintrag links den passenden rechts zuordnen",
+			choice: "eine Antwort wählen",
+			set: "alle richtigen Antworten wählen",
+			order: "die Einträge in die richtige Reihenfolge bringen (die App zeigt sie gemischt)",
+			pairs: "jedem Eintrag links den passenden rechts zuordnen"
+		}
+	},
+	en: {
+		task: "Task",
+		answerFormat: "Answer format",
+		solution: "Solution",
+		explanation: "Explanation",
+		hint: "The app's hint",
+		mistakes: "Typical mistakes and what the app says",
+		componentMistakes: "Typical mistakes (the app's message fits one of them)",
+		options: "Choices (✓ right, ✗ wrong, with the app's message)",
+		right: "✓",
+		wrong: "✗",
+		component: "interactive exercise",
+		does: "What to do",
+		correct: "What counts as right",
+		example: "Example",
+		note: "Remember",
+		figure: "Picture",
+		caption: "Caption",
+		labels: "Labels",
+		interactive: "Interactive",
+		video: "Video",
+		exerciseHere: "Exercise `{id}` (below)",
+		points: "A good answer has (P1, P2 … as the app names them)",
+		pointContent: "content",
+		pointForm: "form",
+		source: "Source",
+		modelAnswer: "Model answer",
+		answerWays: {
+			text: "type it in their own words",
+			photo: "write it in their own words on paper and take a photo of the sheet",
+			both: "type it in their own words, or write it on paper and take a photo of the sheet"
+		},
+		openGuide: "How to help: the app shows the points only after the answer; the child ticks which ones the answer has, and “missing P2, P4” names the others. If you lack the answer, ask the child to paste it or to attach the photo of the sheet. Check point by point, the ticked ones too, and say first what went well. For a missing point, ask a question that leads to it and name its source. Do not give away the model answer before the child has tried again. For a point of form, show with one of the child's sentences how it gets better.",
+		formats: {
+			"single-choice": "choose one answer",
+			"multiple-choice": "choose all right answers",
+			"true-false": "choose “true” or “false”",
+			number: "type a number",
+			ordering: "put the items in the right order (the app shows them shuffled)",
+			matching: "match each item on the left with one on the right",
+			choice: "choose one answer",
+			set: "choose all right answers",
+			order: "put the items in the right order (the app shows them shuffled)",
+			pairs: "match each item on the left with one on the right"
+		}
+	}
+};
+const wordsIn$2 = (lang) => WORDS$3[lang] ?? WORDS$3["de"];
+/** The words of what a tutor reads in `lang`, which the tutor page shares (tutorpage.ts). */
+const tutorWords = (lang) => wordsIn$2(lang);
+/** A text on one line, as a list item holds it. */
+const line$1 = (text) => text.replace(/\s+/g, " ").trim();
+/** The folder of a page's tutor page, in the page's folder: <chapter>/<page>/tutor/ (tutorpage.ts). */
+const TUTOR_PAGE = "tutor";
+/** The address of a page's tutor page within its language tree. */
+const tutorPageOf = (page) => `${page.chapter}/${page.id}/${TUTOR_PAGE}/`;
+/** The answer format of a question of the question types, in `lang`. */
+function questionFormat(question, words) {
+	const format = words.formats[question.type] ?? "";
+	return question.type === "number" && question.unit !== void 0 ? `${format} (${question.unit})` : format;
+}
+/** A question of the question types, in `lang`: its text, format, options, solution, explanation, hint, mistakes. */
+function questionPart(question, lang, words) {
+	const lines = [`- ${words.task}: ${line$1(question.text)}`, `- ${words.answerFormat}: ${questionFormat(question, words)}`];
+	if (question.type === "single-choice" || question.type === "multiple-choice") {
+		lines.push(`- ${words.options}:`);
+		for (const option of question.options) {
+			const info = option.info.trim() === "" ? "" : ` – ${line$1(option.info)}`;
+			lines.push(`  - ${option.correct ? words.right : words.wrong} ${line$1(option.text)}${info}`);
+		}
+	}
+	lines.push(`- ${words.solution}: ${line$1(plainText(answerText(question, lang)))}`);
+	if (question.explanation.trim() !== "") lines.push(`- ${words.explanation}: ${line$1(question.explanation)}`);
+	if (question.hint !== void 0) lines.push(`- ${words.hint}: ${line$1(question.hint)}`);
+	if (question.type === "number" && (question.mistakes ?? []).length > 0) {
+		lines.push(`- ${words.mistakes}:`);
+		for (const mistake of question.mistakes ?? []) lines.push(`  - ${mistake.answer}: ${line$1(mistake.message)}`);
+	}
+	return lines;
+}
+/** A generated exercise's answer format, in `lang`; the tutor page gives the rest (tutorpage.ts). */
+function generatedPart(spec, lang, words) {
+	const kind = kindOf(spec.answer.compare);
+	const unit = kind.kind === "number" && kind.unit !== void 0 ? ` (${inLanguage(kind.unit, lang)})` : "";
+	return [`- ${words.answerFormat}: ${words.formats[kind.kind === "number" ? "number" : kind.kind]}${unit}`];
+}
+/**
+* An open task in `lang`: the task, how the learner answers, the points of a good answer as P1, P2 … (each with its
+* kind and, for content, a link to its source from the tutor page, `base` up to the language tree), the model answer,
+* the hint (their Markdown as written, formulas $…$ kept), and how to help.
+*/
+function openTaskPart(block, lang, words, base) {
+	const ways = block.answer ?? ["text", "photo"];
+	const way = ways.includes("text") && ways.includes("photo") ? "both" : ways.includes("photo") ? "photo" : "text";
+	const lines = [
+		`- ${words.task}: ${line$1(inLanguage(block.task, lang))}`,
+		`- ${words.answerFormat}: ${words.answerWays[way]}`,
+		`- ${words.points}:`,
+		...block.points.map((point, index) => {
+			const kind = point.kind === "form" ? words.pointForm : words.pointContent;
+			const source = point.source === void 0 ? "" : ` ${words.source}: [${point.source}](${base}${point.source.slice(1)})`;
+			return `  - P${index + 1} (${kind}) ${line$1(inLanguage(point.text, lang))}${source}`;
+		}),
+		`- ${words.modelAnswer}: ${line$1(inLanguage(block.solution, lang))}`
+	];
+	if (block.hint !== void 0) lines.push(`- ${words.hint}: ${line$1(inLanguage(block.hint, lang))}`);
+	lines.push(`- ${words.openGuide}`);
+	return lines;
+}
+/**
+* An exercise component: what it says about itself (its about), its typical mistakes as F1, F2 …, which the app's
+* message of a wrong answer names one of, and when it declares its exercise also its task once as its template; F1, F2 …
+* are then the columns of its table of tasks. Its tasks by number are the tutor page's.
+*/
+function componentPart(description, lang, words) {
+	const { about } = description;
+	const exercise = description.exercise?.[lang];
+	const t = (text) => line$1(inLanguage(text, lang));
+	const lines = [`- ${words.does}: ${t(about.task)}`];
+	if (exercise !== void 0) lines.push(`- ${words.task}: „${line$1(exercise.template)}“`);
+	lines.push(`- ${words.answerFormat}: ${t(about.answer)}`, `- ${words.correct}: ${t(about.correct)}`);
+	if (about.mistakes.length > 0) lines.push(`- ${words.componentMistakes}:`, ...about.mistakes.map((mistake, index) => `  - F${index + 1}: ${t(mistake)}`));
+	return lines;
+}
+/** A text of restricted Markdown for a tutor: each link as its words, as its address is the page's (an absolute one stays). */
+const unlinked = (text) => text.replace(/\[([^\]]*)\]\(([^)\s]+)\)/g, (whole, words, target) => /^[a-z][a-z0-9+.-]*:/i.test(target) ? whole : words);
+/**
+* What a tutor reads of `blocks` in `lang`, as Markdown lines, the content of a page for its tutor page (tutorpage.ts):
+* each section as the heading `heading` makes,
+* then its content: texts, formulas as $…$, definitions, examples and notes with their kind and title, figures by their
+* alt text and caption, tables row by row, timelines, quotes, code, a video as a link with its title and channel, a
+* component's own nojs text; an exercise by its
+* id, as it follows in full after the page. `inline` turns a text into what the page shows. A text keeps its lines,
+* so that its lists stay lists.
+*/
+function contentLines(site, blocks, lang, inline, heading) {
+	const words = wordsIn$2(lang);
+	const t = (text) => inline(unlinked(inLanguage(text, lang).trim()));
+	const one = (text) => t(text).replace(/\s+/g, " ");
+	const sentence = (text) => one(text).replace(/[.!?]?$/, (end) => end || ".");
+	const lines = [];
+	const add = (...more) => lines.push(...more, "");
+	const walk = (inner, anchor, depth) => {
+		for (const block of inner) switch (block.type) {
+			case "section": {
+				const id = [...anchor, block.id];
+				add(heading(one(block.title), id.join("/"), depth));
+				walk(block.blocks, id, depth + 1);
+				break;
+			}
+			case "example":
+			case "note":
+				add(`**${block.type === "example" ? words.example : words.note}: ${one(block.title)}**`);
+				walk(block.blocks, anchor, depth);
+				break;
+			case "text":
+				add(t(block.text));
+				break;
+			case "formula":
+				add(inline(`$${inLanguage(block.formula, lang).replace(/\s+/g, " ").trim()}$`));
+				break;
+			case "definition":
+				add(`- **${one(block.term)}**: ${one(block.explanation)}`);
+				break;
+			case "figure":
+				add(`${words.figure}: ${sentence(block.alt)} ${words.caption}: ${one(block.caption)}`);
+				break;
+			case "labelled-figure": {
+				const labels = block.labels.map((label, index) => `${markerOf(label, index)} ${one(label.text)}`).join(", ");
+				const caption = block.caption === void 0 ? "" : ` ${words.caption}: ${one(block.caption)}`;
+				add(`${words.figure}: ${sentence(block.alt)}${caption} ${words.labels}: ${labels}`);
+				break;
+			}
+			case "table":
+				add(`${one(block.caption)}:`, ...[...block.header === void 0 ? [] : [block.header], ...block.rows].map((row) => `- ${row.map(one).join(" | ")}`));
+				break;
+			case "timeline":
+				add(...timelineEvents(site, block).map((event) => {
+					const label = event.label === void 0 ? "" : ` (${one(event.label)})`;
+					const text = event.text === void 0 ? "" : ` – ${one(event.text)}`;
+					return `- ${String(event.date)}${label}: ${one(event.title)}${text}`;
+				}));
+				break;
+			case "quote": {
+				const { origin } = block;
+				const from = [
+					origin.author,
+					origin.work,
+					origin.year
+				].filter((part) => part !== void 0).map((part) => typeof part === "number" ? String(part) : one(part));
+				add(...t(block.text).split("\n").map((text) => `> ${text}`), ">", `> – ${from.join(", ")}`);
+				break;
+			}
+			case "code":
+				add(...block.caption === void 0 ? [] : [`${one(block.caption)}:`, ""], `\`\`\`${block.language}`, block.code.trimEnd(), "```");
+				break;
+			case "video":
+				add(videoLine(block, words.video));
+				break;
+			case "vue-component": {
+				const use = site.components.find((candidate) => candidate.block === block);
+				if (use?.component.exercise === true && use.id !== void 0) add(`- ${words.exerciseHere.replace("{id}", use.id)}`);
+				else if (block.nojs !== void 0) add(`${words.interactive}: ${one(block.nojs)}`);
+				break;
+			}
+			default: if ("id" in block && typeof block.id === "string") add(`- ${words.exerciseHere.replace("{id}", block.id)}`);
+		}
+	};
+	walk(blocks, [], 0);
+	return lines;
+}
+/**
+* An exercise for a tutor in `lang`, or undefined for a block that is none: its id, its type, and its lines (task,
+* answer format, solution, hint, typical mistakes; of a generated exercise and an exercise component what stays the
+* same for each number, the tutor page adds the tasks by number).
+*/
+function exercisePart(site, block, lang, descriptions) {
+	const words = wordsIn$2(lang);
+	switch (block.type) {
+		case "generated": return {
+			id: block.id,
+			type: `generated, ${kindOf(block.answer.compare).kind}`,
+			lines: generatedPart(block, lang, words)
+		};
+		case "open-task": return {
+			id: block.id,
+			type: "open-task",
+			lines: openTaskPart(block, lang, words, "../../../")
+		};
+		case "vue-component": {
+			const use = site.components.find((candidate) => candidate.block === block);
+			const description = descriptions.get(block);
+			if (use?.id === void 0 || description === void 0) return void 0;
+			return {
+				id: use.id,
+				type: `${words.component} ${block.component}`,
+				lines: componentPart(description, lang, words)
+			};
+		}
+		case "single-choice":
+		case "multiple-choice":
+		case "true-false":
+		case "number":
+		case "ordering":
+		case "matching": return {
+			id: block.id,
+			type: block.type,
+			lines: questionPart(questionIn(block, lang), lang, words)
+		};
+		default: return;
+	}
+}
+/** The anchors of a page: its sections (nested as <section>/<subsection>), exercises and components with an id. */
+function anchorsOf(site, page) {
+	const anchors = /* @__PURE__ */ new Set();
+	const walk = (blocks, anchor) => {
+		for (const block of blocks) if (block.type === "section") {
+			anchors.add([...anchor, block.id].join("/"));
+			walk(block.blocks, [...anchor, block.id]);
+		} else if (block.type === "example" || block.type === "note") walk(block.blocks, anchor);
+	};
+	walk(page.blocks, []);
+	for (const block of allBlocks(page.blocks)) if ("id" in block && typeof block.id === "string" && block.type !== "section") anchors.add(block.id);
+	for (const use of site.components) if (use.id !== void 0 && [...allBlocks(page.blocks)].includes(use.block)) anchors.add(use.id);
+	return anchors;
+}
+/**
+* The links of a Markdown file at `file` (an address within a language tree, e.g. "prozent/grundwert/tutor/") that
+* lead nowhere: a relative link must name a file the build writes or a page's
+* folder, and its anchor must be on that page. `files` are the files and page folders of the tree, `anchors` each
+* page folder's anchors. One line per broken link.
+*/
+function linkProblems(file, text, files, anchors) {
+	const problems = [];
+	const base = new URL(file, "https://app.invalid/");
+	for (const [, target = ""] of text.matchAll(/\]\(([^)\s]+)\)/g)) {
+		if (/^[a-z][a-z0-9+.-]*:/i.test(target)) continue;
+		const url = new URL(target, base);
+		const path = decodeURIComponent(url.pathname.slice(1));
+		if (!files.has(path)) {
+			problems.push(`${file}: the link ${target} leads to ${path || "./"}, which the build does not write`);
+			continue;
+		}
+		const id = decodeURIComponent(url.hash.slice(1));
+		if (id !== "" && !(anchors.get(path)?.has(id) ?? false)) problems.push(`${file}: the link ${target} names the anchor #${id}, which ${path || "./"} does not have`);
+	}
+	return problems;
+}
+// runtime/explainer/prompt.ts
+/** Where the start prompt's address starts: replaced by the address of the language tree when the page uses it. */
+const BASE = "⟦base⟧";
+/** Where the start prompt of a content page has the learner's position: replaced by the query the page builds. */
+const QUERY = "⟦query⟧";
+/** The assistants a learner can switch on, the same for every app: each takes the prompt in its address. */
+const PROVIDERS = [
+	{
+		name: "Claude",
+		url: "https://claude.ai/new?q={prompt}"
+	},
+	{
+		name: "ChatGPT",
+		url: "https://chatgpt.com/?q={prompt}"
+	},
+	{
+		name: "Mistral Vibe",
+		url: "https://chat.mistral.ai/chat?q={prompt}",
+		paste: true
+	}
+];
+const MARK = "lernapps-prompt";
+/** A provider's address without the prompt, for the link without JavaScript: its parameter with {prompt} left out. */
+function plainAddress(url) {
+	const parsed = new URL(url.replace(/\{prompt\}/g, MARK));
+	const keys = Array.from(parsed.searchParams.entries()).flatMap(([key, value]) => value.includes(MARK) ? [key] : []);
+	for (const key of keys) parsed.searchParams.delete(key);
+	return parsed.href.replace(/\?$/, "");
+}
+const LOAD = {
+	de: "Lade {url} und sei mein Tutor.",
+	en: "Load {url} and be my tutor."
+};
+const PLACEHOLDER = {
+	de: "Ich brauche Hilfe bei einer Lern-Einheit. Ich schreibe Dir gleich, worum es geht.",
+	en: "I need help with a learning unit. I will tell you in a moment what it is about."
+};
+/** The short message a `paste` assistant gets in its address, in `lang`: it holds no address to fetch. */
+const placeholderPrompt = (lang) => PLACEHOLDER[lang] ?? PLACEHOLDER["de"] ?? "";
+/**
+* The start prompt a provider link carries from a content page, the one kind of page that starts a tutor, in its
+* language: "Lade <chapter>/<page>/tutor/<QUERY> und sei mein Tutor.", the page's tutor page with
+* where the learner is in its query, which the client module fills in (position.ts, pageQuery). Its address starts
+* with BASE.
+*/
+function startPrompt(route) {
+	const page = {
+		chapter: route.page?.chapter ?? "",
+		id: route.page?.id ?? ""
+	};
+	return (LOAD[route.lang] ?? LOAD["de"] ?? "").replace("{url}", `${BASE}${tutorPageOf(page)}${QUERY}`);
+}
+// runtime/explainer/tutorpage.ts
+/** The name of a tutor page's Markdown, beside the page in its folder: for an assistant that fetches nothing. */
+const TUTOR_MARKDOWN = "index.md";
+/** The size a tutor page stays within, in bytes: an exercise component gets as many numbers as fit; the build notes a larger page. */
+const TUTOR_PAGE_BUDGET = 64e3;
+/** The size of a text in bytes, as UTF-8. */
+const bytesOf = (text) => new TextEncoder().encode(text).length;
+const WORDS$2 = {
+	de: {
+		title: "{page} – für deinen KI-Tutor",
+		tutorPage: "Tutor-Seite",
+		forTutor: "Was ein KI-Tutor zur Seite „{page}“ bekommt.",
+		intro: "Du hilfst einem Kind beim Lernen. Es arbeitet mit der Lern-App „{app}“ von lernapps.net, gerade auf der Seite „{page}“, und steckt dort in einer Übung. Gelöst wird in der App, sie prüft die Antworten. Du erklärst.",
+		parents: "Eltern und Lehrkräfte sehen hier, was der Tutor bekommt.",
+		toPage: "Zur Seite",
+		scope: "Der Lernumfang dieser Seite, mit dem, was dazugehört und was nicht: [Scope](../scope/). Lies ihn, bevor du eine offene Antwort beurteilst; liegt die Quelle eines Punkts auf einer anderen Seite, führt er zum Scope des Kapitels. Seine volle Adresse ist die dieser Tutor-Seite mit `scope/` statt `tutor/`. Konntest du ihn nicht abrufen, etwa wegen Sicherheitseinstellungen, nenn dem Kind genau diese volle Adresse und bitte es, sie freizugeben; ruf sie danach noch einmal ab. Bis dahin beurteilst du keine offene Antwort und antwortest nichts zum Inhalt aus Allgemeinwissen.",
+		guideTitle: "So leitest du an",
+		guide: [
+			"Antworte kurz: höchstens drei Sätze und eine Frage. Keine Überschriften, keine Listen.",
+			"Nimm die Beispiele und Aufgaben dieser Seite. Erfinde keine eigenen. Rechne nichts selbst aus: Lösungen und Fehler stehen unten bei jeder Nummer.",
+			"Im Chat erklärst du, am Beispiel der Seite. Gerechnet wird in der App: Die Aufgaben löst das Kind dort. Rechnet es eine Aufgabe im Chat, schick ihm sofort den Link zu ihr.",
+			"Verrate keine Lösung. Ein Wert, der in der Tabelle einer Übung „(verdeckt)“ heißt, steht nicht im Text der Aufgabe: Das Kind sieht ihn nicht, nenn ihn nicht.",
+			"Was das Kind in der App tun kann, steht bei der Übung unter „Was zu tun ist“ und „Antwortformat“. Beschreib keine anderen Knöpfe oder Schritte.",
+			"Bitte das Kind nie, eine Aufgabe abzuschreiben. Du kennst sie aus dem Kontext unten."
+		],
+		startTitle: "So beginnst du",
+		start: ["„Sei mein Tutor“: Frag zuerst, was das Kind über das Thema schon weiß. Dann geh die Seite der Reihe nach durch, ein Abschnitt pro Nachricht: erst warum das Thema wichtig ist, dann die Regel, dann das Beispiel. Prüf nach jedem Abschnitt mit einer kurzen Frage zum Inhalt, ob das Kind ihn verstanden hat; ein „Ja“ reicht nicht. Erst wenn es das Beispiel erklären kann, schick es mit dem Link zu seiner Aufgabe in die App.", "„Hilf mir bei Übung …, Nr. …“ (das Kind kommt mit „Hilfe“ aus der App): Schlag Übung und Nummer unten nach und setz bei dieser Aufgabe an. Steht da „Die App sagt: …“, such den Fehler (F1, F2 …) der Übung, zu dem die Meldung passt: Das ist der Fehler des Kindes. Nennt die Nachricht eine Eingabe und steht sie bei dieser Nummer in einer Spalte F…, bestätigt das den Fehler. Sag in einem Satz, was an genau dieser Eingabe nicht zur Aufgabe passt, und wiederhol die Meldung nicht. Fehlt beides, frag, was das Kind eingegeben oder gebaut hat und wo es hängt. Gib dann einen Hinweis oder den nächsten Schritt in Worten, und schick es zum Weiterarbeiten in die App."],
+		appRules: "Regeln dieser App",
+		whereTitle: "Wo das Kind gerade ist",
+		where: [
+			"Die erste Nachricht des Kindes nennt diese Seite und je Übung die Nummer der Aufgabe, die das Kind gerade vor sich hat, z. B. `?{example}`. Schlag die Nummern unten bei den Übungen nach. Kommt das Kind mit „Hilfe“, nennt `uebung=` die Übung und `abschnitt=` ihren Abschnitt.",
+			"Steht in der Nachricht „Die App sagt: …“, hat die App das zur Eingabe des Kindes gemeldet. Setz dort an, ohne es zu wiederholen.",
+			"Eine Zeile wie „…, Nr. 16: richtig im 2. Versuch.“ kommt von „Zurück“ in der App: Übung, Nummer und wie weit das Kind damit kam.",
+			"„Ich habe auf … geübt:“ kommt von „Zurück zum Tutor“: diese Seite mit den Nummern, dann je geübter Aufgabe, wie es lief, bei einer falschen mit Eingabe und Meldung der App. Setz bei den falschen an, eine nach der anderen.",
+			"Jede Aufgabe hat einen Link: die Adresse der Seite, also dieser Tutor-Seite ohne `tutor/` und ohne `?…`, mit der Nummer und `via=tutor`, z. B. `{link}`. Schick ihn immer als volle Adresse, mit Schema und Host dieser Tutor-Seite (z. B. `https://`). Für eine weitere Aufgabe nimm eine andere Nummer der Übung und nenn ihren Text. Sag dazu: „Löse sie in der App und drück dann ‚Zurück‘. Füg die Zeile hier ein.“"
+		],
+		needsTitle: "Besondere Anforderungen",
+		needsIntro: "Nennt die Adresse dieser Seite `bedarf=`, gilt jeder Abschnitt, den sie nennt, mehrere durch Komma getrennt. Er geht dem oben Gesagten vor; widersprechen sich zwei, gilt der strengere. Ohne `bedarf=` gilt keiner.",
+		needs: {
+			"kurze-schritte": "Im Gegensatz zu oben: höchstens zwei kurze Sätze, ein Gedanke pro Nachricht, jeder Teil eines Abschnitts mit eigener Frage. Sag, wie weit es noch ist.",
+			"wenig-lesen": "Im Gegensatz zu oben: höchstens zwei kurze Sätze ohne Nebensätze; sag den Kern eines Abschnitts selbst, statt ihn lesen zu lassen. Erklär jedes Fachwort einmal, korrigier keine Rechtschreibung.",
+			"mehr-tiefe": "Hak sichere Abschnitte mit einer Prüffrage ab. Im Gegensatz zu oben darfst du an den Beispielen der Seite Warum- und Was-wäre-wenn-Fragen stellen; erfinde aber keine Rechenaufgaben.",
+			"andere-muttersprache": "Antworte in einfachem Deutsch; nenn ein neues Fachwort mit Artikel, Mehrzahl und, wenn du sie sicher kennst, der Übersetzung in Klammern. Versteht das Kind zweimal nicht, erklär einen Satz in seiner Sprache.",
+			"klar-und-woertlich": "Schreib wörtlich: keine Ironie, keine Redewendungen. Im Gegensatz zu oben fragst du am Anfang mit zwei oder drei Antworten zur Auswahl und nennst immer „Abschnitt x von y“.",
+			"rechnen-anschaulich": "Zeig Zahlen der Seite als Menge, z. B. „37 sind 3 Zehner und 7 Einer“, aber nie das Ergebnis einer Aufgabe. Ein Schritt pro Nachricht, nie Zeitdruck."
+		},
+		contextTitle: "Kontext: die Seite „{page}“",
+		exercise: "Übung",
+		steps: "Lösungsweg",
+		link: "Link",
+		linkNumber: "Link zu Nummer n",
+		table: "Aufgaben nach Nummer: die Werte für `{…}`, die Lösung und was bei den Fehlern herauskommt. Ein Fehler ohne Spalte hat keinen festen Wert; die Meldung der App sagt, ob er vorliegt.",
+		hidden: "(verdeckt)",
+		answerIs: "`{answer}` ist die Lösung.",
+		number: "Nr.",
+		choices: "Zur Wahl",
+		tasks: "Aufgaben nach Nummer, mit Lösung",
+		shown: "Hier stehen die Nummern 1 bis {shown} von {count}. Sitzt das Kind an einer anderen Nummer, schick ihm den Link zu einer Nummer von hier.",
+		none: "Die Nummern dieser Übung passen nicht auf diese Seite. Was das Kind dort tut, erfährst du aus seinen Zeilen von „Hilfe“ und „Zurück“."
+	},
+	en: {
+		title: "{page} – for your AI tutor",
+		tutorPage: "tutor page",
+		forTutor: "What an AI tutor gets for the page “{page}”.",
+		intro: "You help a child learn. It works with the learning app “{app}” of lernapps.net, right now on the page “{page}”, and is in an exercise there. Tasks are solved in the app, which checks the answers. You explain.",
+		parents: "Parents and teachers see here what the tutor gets.",
+		toPage: "To the page",
+		scope: "The learning path of this page, with what belongs to it and what does not: [scope](../scope/). Read it before you judge an open answer; if the source of a point is on another page, it leads to the chapter's scope. Its full address is the one of this tutor page with `scope/` in place of `tutor/`. If you could not fetch it, for example because of security settings, give the child exactly this full address and ask them to allow it; then fetch it again. Until then, judge no open answer and answer nothing about the content from general knowledge.",
+		guideTitle: "How you guide",
+		guide: [
+			"Answer briefly: three sentences and one question at most. No headings, no lists.",
+			"Use the examples and tasks of this page. Do not make up your own. Work nothing out yourself: solutions and mistakes are below with each number.",
+			"In the chat you explain, with the page's example. Tasks are worked out in the app: the child solves them there. If it works a task out in the chat, send it the link to the task at once.",
+			"Do not give a solution away. A value the table of an exercise calls “(hidden)” is not in the task's text: the child does not see it, do not name it.",
+			"What the child can do in the app is under “What to do” and “Answer format” with the exercise. Do not describe other buttons or steps.",
+			"Never ask the child to copy a task. You know it from the context below."
+		],
+		startTitle: "How you start",
+		start: ["“Be my tutor”: first ask what the child already knows about the topic. Then go through the page in order, one section per message: first why the topic matters, then the rule, then the example. After each section check with a short question on its content that the child understood it; a “yes” is not enough. Only once it can explain the example, send it to the app with the link to its task.", "“Help me with exercise …, no. …” (the child comes from “Help” in the app): look the exercise and the number up below and start right at this task. If it says “The app says: …”, find the mistake (F1, F2 …) of the exercise that the message fits: that is the child's mistake. If the message names an input and it is in a column F… for this number, that confirms the mistake. Say in one sentence what about exactly this input does not fit the task, and do not repeat the message. If both are missing, ask what the child entered or built and where it is stuck. Then give a hint or the next step in words, and send it back to the app to go on."],
+		appRules: "Rules of this app",
+		whereTitle: "Where the child is",
+		where: [
+			"The child's first message names this page and, for each exercise, the number of the task the child has in front of it, e.g. `?{example}`. Look the numbers up below with the exercises. If the child comes with “Help”, `uebung=` names the exercise and `abschnitt=` its section.",
+			"If the message says “The app says: …”, the app showed that for the child's input. Build on it without repeating it.",
+			"A line like “…, no. 16: right on try 2.” comes from “Back” in the app: the exercise, the number and how far the child got with it.",
+			"“I practised on …:” comes from “Back to the tutor”: this page with the numbers, then for each task practised how it went, a wrong one with the input and the app's message. Start with the wrong ones, one after the other.",
+			"Every task has a link: the address of the page, that is of this tutor page without `tutor/` and without `?…`, with the number and `via=tutor`, e.g. `{link}`. Always send it as a full address, with the scheme and host of this tutor page (e.g. `https://`). For a further task take another number of the exercise and say its text. Add: “Solve it in the app, then press ‘Back’. Paste the line here.”"
+		],
+		needsTitle: "Special requirements",
+		needsIntro: "If the address of this page names `bedarf=`, each section it names holds, several separated by commas. It goes before what is said above; if two contradict each other, the stricter one holds. Without `bedarf=` none holds.",
+		needs: {
+			"kurze-schritte": "Unlike above: two short sentences at most, one thought per message, each part of a section with a question of its own. Say how far there is still to go.",
+			"wenig-lesen": "Unlike above: two short sentences at most, without subordinate clauses; say the core of a section yourself instead of having it read. Explain every technical term once, do not correct spelling.",
+			"mehr-tiefe": "Tick off sections the child knows with one checking question. Unlike above you may ask why and what-if questions about the page's examples; but do not make up tasks to work out.",
+			"andere-muttersprache": "Answer in simple language, in the language of this page; give a new technical term with its article and plural, if any, and, if you know it for sure, its translation in brackets. If the child does not understand twice, explain one sentence in its language.",
+			"klar-und-woertlich": "Write literally: no irony, no idioms. Unlike above, at the start you ask with two or three answers to choose from, and you always say “section x of y”.",
+			"rechnen-anschaulich": "Show numbers of the page as amounts, e.g. “37 is 3 tens and 7 ones”, but never the result of a task. One step per message, never time pressure."
+		},
+		contextTitle: "Context: the page “{page}”",
+		exercise: "Exercise",
+		steps: "Steps of the solution",
+		link: "Link",
+		linkNumber: "Link to number n",
+		table: "Tasks by number: the values for `{…}`, the solution and what the mistakes give. A mistake without a column has no fixed value; the app's message says whether it is there.",
+		hidden: "(hidden)",
+		answerIs: "`{answer}` is the solution.",
+		number: "No.",
+		choices: "Choices",
+		tasks: "Tasks by number, with solution",
+		shown: "Here are the numbers 1 to {shown} of {count}. If the child is at another number, send it the link to a number from here.",
+		none: "The numbers of this exercise do not fit on this page. What the child does there you learn from its lines of “Help” and “Back”."
+	}
+};
+const wordsIn$1 = (lang) => WORDS$2[lang] ?? WORDS$2["de"];
+/** A text on one line, as a list item holds it, for the page's Markdown (formulas). */
+const line = (text) => formulas(text.replace(/\s+/g, " ").trim());
+/**
+* A text for the page's Markdown, its lines kept: no HTML in it, and each formula $…$ on one line, which the page's
+* Markdown keeps as written (FORMULA).
+*/
+const formulas = (text) => text.split(/(\$[^$]+\$)/).map((part, index) => index % 2 === 1 ? part.replace(/\s+/g, " ") : part.replace(/</g, "&lt;")).join("");
+/** The types of the question blocks, exercises without numbers. */
+const QUESTIONS = /* @__PURE__ */ new Set([
+	"single-choice",
+	"multiple-choice",
+	"true-false",
+	"number",
+	"ordering",
+	"matching"
+]);
+/** The exercises of `page` in order, each with its section and the number of its numbered tasks. */
+function pageExercises(site, page, descriptions) {
+	const found = [];
+	const walk = (blocks, anchor, title) => {
+		for (const block of blocks) if (block.type === "section") walk(block.blocks, [...anchor, block.id], block.title);
+		else if (block.type === "example" || block.type === "note") walk(block.blocks, anchor, title);
+		else {
+			const where = anchor.length === 0 ? {} : {
+				section: anchor.join("/"),
+				...title === void 0 ? {} : { sectionTitle: title }
+			};
+			if (block.type === "generated") found.push({
+				id: block.id,
+				block,
+				...where,
+				count: taskSeeds(block, dataOf(block, site.data)).length
+			});
+			else if (block.type === "vue-component") {
+				const use = site.components.find((candidate) => candidate.block === block);
+				const description = descriptions.get(block);
+				if (use?.id !== void 0 && use.component.exercise) found.push({
+					id: use.id,
+					block,
+					...where,
+					count: description?.seeds.length ?? 0
+				});
+			} else if (block.type === "open-task") found.push({
+				id: block.id,
+				block,
+				...where,
+				count: 0
+			});
+			else if (QUESTIONS.has(block.type) && "id" in block && typeof block.id === "string") found.push({
+				id: block.id,
+				block,
+				...where,
+				count: 0
+			});
+		}
+	};
+	walk(page.blocks, [], void 0);
+	return found;
+}
+/** The anchors of the sections of `page`, nested as <section>/<subsection>. */
+function sectionsOf(page) {
+	const walk = (blocks, anchor) => blocks.flatMap((block) => block.type === "section" ? [[...anchor, block.id].join("/"), ...walk(block.blocks, [...anchor, block.id])] : []);
+	return walk(page.blocks, []);
+}
+/** A template of the content with each placeholder {{x}} as {x}, on one line, for the page's Markdown. */
+const template = (text, lang) => line(inLanguage(text, lang).replace(/\{\{\s*([\w.]+)\s*\}\}/g, "{$1}"));
+/** The placeholders of a generated exercise's texts in `lang`, in order and each once, but {{answer}}, the solution. */
+function placeholdersOf(spec, lang) {
+	const texts = [
+		spec.task.text,
+		...spec.hint === void 0 ? [] : [spec.hint],
+		...spec.steps ?? [],
+		...(spec.mistakes ?? []).map((mistake) => mistake.message)
+	];
+	const all = [...new Set(texts.flatMap((text) => placeholdersIn(inLanguage(text, lang))))];
+	return {
+		paths: all.filter((path) => path !== "answer"),
+		answer: all.includes("answer")
+	};
+}
+/** A cell of a table of tasks: on one line, without the table's separator. */
+const cell = (text) => text.replace(/\s+/g, " ").replace(/\|/g, "/").trim() || "–";
+/**
+* A generated exercise for the tutor, once: its task as a template ({G} for the value of G), its answer format, hint
+* and steps, its typical mistakes as F1, F2 … with the app's message, and the link to a number; then a table of each
+* task number's inputs and outputs: the values of the placeholders, the choices of a choice, the solution and what
+* each mistake gives, all as the learner reads them, so that the tutor fills in and works nothing out. The examples
+* stay out: they are test cases. The link leads to the exercise's page at `page`, from where the tutor page is.
+*/
+function generatedLines(spec, site, lang, format, page = "../") {
+	const words = wordsIn$1(lang);
+	const shared = tutorWords(lang);
+	const lines = [`- ${shared.task}: „${template(spec.task.text, lang)}“`, ...format];
+	if (spec.hint !== void 0) lines.push(`- ${shared.hint}: „${template(spec.hint, lang)}“`);
+	if (spec.steps !== void 0) lines.push(`- ${words.steps}:`, ...spec.steps.map((step) => `  - ${template(step, lang)}`));
+	const mistakes = spec.mistakes ?? [];
+	if (mistakes.length > 0) lines.push(`- ${shared.mistakes}:`, ...mistakes.map((mistake, index) => `  - F${index + 1}: „${template(mistake.message, lang)}“`));
+	lines.push(`- ${words.linkNumber}: \`${page}?${spec.id}=n&via=tutor#${spec.id}\``);
+	const { paths, answer } = placeholdersOf(spec, lang);
+	const data = dataOf(spec, site.data);
+	const templates = templatesOf(spec, [lang]);
+	let choices = false;
+	const rows = taskSeeds(spec, data).map((seed, index) => {
+		const task = generate(spec, seed, data);
+		const question = questionFor(spec, task, lang, templates);
+		const options = question.type === "single-choice" || question.type === "multiple-choice" ? [cell(question.options.map((option) => plainText(option.text)).join("; "))] : [];
+		if (options.length > 0) choices = true;
+		const wrong = mistakes.map((_mistake, at) => {
+			try {
+				return cell(label(task.mistakes[at] ?? "", lang));
+			} catch {
+				return "–";
+			}
+		});
+		return [
+			String(index + 1),
+			...paths.map((path) => cell(placeholderValue(spec, task, path, lang)?.text ?? "")),
+			...options,
+			cell(plainText(answerText(question, lang))),
+			...wrong
+		].join(" | ");
+	});
+	const header = [
+		words.number,
+		...paths,
+		...choices ? [words.choices] : [],
+		shared.solution,
+		...mistakes.map((_mistake, index) => `F${index + 1}`)
+	].join(" | ");
+	lines.push(`- ${words.table}${answer ? ` ${words.answerIs}` : ""}`, "", "```", header, ...rows, "```");
+	return lines;
+}
+/**
+* The table of tasks of an exercise component, as a generated exercise has it: each task number's inputs, its
+* solution and what each typical mistake gives, all as the learner reads them ("–" for a mistake without one answer).
+*/
+function componentTable(exercise, lang) {
+	const words = wordsIn$1(lang);
+	const count = exercise.tasks[0]?.mistakes.length ?? 0;
+	const columns = Array.from({ length: count }, (_mistake, index) => index).filter((index) => exercise.tasks.some((row) => (row.mistakes[index] ?? "") !== ""));
+	const shown = new Set([...exercise.template.matchAll(/\{([^{}\s]+)\}/g)].map((match) => match[1]));
+	const header = [
+		words.number,
+		...exercise.inputs.map((input) => shown.has(input) ? input : `${input} ${words.hidden}`),
+		tutorWords(lang).solution,
+		...columns.map((index) => `F${index + 1}`)
+	].join(" | ");
+	const rows = exercise.tasks.map((row, index) => [
+		String(index + 1),
+		...row.inputs,
+		row.solution,
+		...columns.map((column) => row.mistakes[column] ?? "")
+	].map(cell).join(" | "));
+	return [
+		`- ${words.table}`,
+		"",
+		"```",
+		header,
+		...rows,
+		"```"
+	];
+}
+/**
+* The hint of the build for the exercise components that declare no table of tasks (TABLE_CONTRACT), each by its
+* place, or none: their tutor pages have their tasks only as text from describe, as many as fit. A hint for now;
+* rule vue-component-tutor-table.
+*/
+function tableHint(site, descriptions) {
+	const without = site.components.filter((use) => {
+		const description = descriptions.get(use.block);
+		return description !== void 0 && description.exercise === void 0;
+	});
+	if (without.length === 0) return void 0;
+	const one = without.length === 1;
+	return `lernapps explainer: ${without.length} exercise component${one ? " declares" : "s declare"} no table of tasks, so ${one ? "its tutor page has its" : "their tutor pages have their"} tasks only as text, as many as fit; export ${TABLE_CONTRACT} from ${one ? "its" : "their"} logic module: ${without.map((use) => `${use.place}: ${use.component.name}`).join(", ")} (vue-component-tutor-table)`;
+}
+/**
+* The tutor page of `page` in `lang`, as Markdown, its links relative to the page's folder <chapter>/<page>/tutor/,
+* which the build checks: who the tutor helps, how to guide, where the child is, the app's own rules; then the page's
+* content as context, and its exercises. An exercise component shows its table of tasks with every number, or without
+* one each number's task and solution; when the page would grow beyond `budget`, the components without a table share
+* what is left, number by number in turn, and `cut` names those with numbers left out.
+*/
+function tutorPage(site, page, lang, descriptions, budget = TUTOR_PAGE_BUDGET) {
+	const words = wordsIn$1(lang);
+	const exercises = pageExercises(site, page, descriptions);
+	const rows = /* @__PURE__ */ new Map();
+	for (const exercise of exercises) {
+		if (exercise.block.type !== "vue-component" || exercise.count === 0) continue;
+		if (descriptions.get(exercise.block)?.exercise?.[lang] !== void 0) continue;
+		const tasks = descriptions.get(exercise.block)?.tasks[lang] ?? [];
+		rows.set(exercise.id, tasks.map((task) => `  - ${words.number} ${task.number}: ${line(task.task)} → ${tutorWords(lang).solution}: ${line(task.solution)}`));
+	}
+	const shown = /* @__PURE__ */ new Map();
+	const build = () => pageMarkdown(site, page, lang, descriptions, exercises, rows, shown);
+	const size = (text) => bytesOf(tutorPageDocument(text, site, page, lang));
+	let markdown = build();
+	if (size(markdown) > budget && rows.size > 0) {
+		for (const id of rows.keys()) shown.set(id, 0);
+		let room = budget - size(build());
+		const cost = (row) => bytesOf(escape(row)) + 10;
+		for (let more = true; more;) {
+			more = false;
+			for (const [id, all] of rows) {
+				const next = all[shown.get(id) ?? 0];
+				if (next === void 0 || cost(next) > room) continue;
+				room -= cost(next);
+				shown.set(id, (shown.get(id) ?? 0) + 1);
+				more = true;
+			}
+		}
+		markdown = build();
+		while (size(markdown) > budget) {
+			const [largest] = [...shown.entries()].sort((a, b) => b[1] - a[1]);
+			if (largest === void 0 || largest[1] === 0) break;
+			shown.set(largest[0], largest[1] - 1);
+			markdown = build();
+		}
+	}
+	const cut = [...rows].flatMap(([id, all]) => {
+		const n = shown.get(id) ?? all.length;
+		return n < all.length ? [{
+			id,
+			shown: n,
+			count: all.length
+		}] : [];
+	});
+	return {
+		markdown,
+		cut
+	};
+}
+/**
+* The learner's needs on a tutor page, in `lang`, after its guide (dec-tutor-needs): what holds when the query names
+* them in `bedarf=`, then a short section for each, as Markdown lines.
+*/
+function needsLines(lang) {
+	const words = wordsIn$1(lang);
+	return [
+		`## ${words.needsTitle}`,
+		"",
+		words.needsIntro,
+		"",
+		...NEEDS.map((need) => `- \`${need}\`: ${words.needs[need]}`),
+		""
+	];
+}
+/** The Markdown of a tutor page, with of each exercise component the rows by number `shown` names (all if none). */
+function pageMarkdown(site, page, lang, descriptions, exercises, rows, shown) {
+	const words = wordsIn$1(lang);
+	const own = (text) => line(inLanguage(text, lang));
+	const title = own(page.title);
+	const fill = (text) => text.replace("{page}", title).replace("{app}", own(site.app.title));
+	const lines = [
+		`# ${fill(words.title)}`,
+		"",
+		fill(words.intro),
+		"",
+		`${words.parents} [${words.toPage}](../)`,
+		"",
+		...site.app.scope === void 0 ? [] : [words.scope, ""],
+		`## ${words.guideTitle}`,
+		"",
+		...words.guide.map((text) => `- ${text}`),
+		"",
+		`## ${words.startTitle}`,
+		"",
+		...words.start.map((text) => `- ${text}`),
+		""
+	];
+	if (site.app.tutor?.rules !== void 0) lines.push(`## ${words.appRules}`, "", inLanguage(site.app.tutor.rules, lang).trim(), "");
+	const first = exercises.find((exercise) => exercise.count > 0) ?? exercises[0];
+	const example = first === void 0 ? void 0 : first.count > 0 ? {
+		query: `${first.id}=12`,
+		link: `…/${page.chapter}/${page.id}/?${first.id}=12&via=tutor#${first.id}`
+	} : {
+		query: `uebung=${first.id}`,
+		link: `…/${page.chapter}/${page.id}/?via=tutor#${first.id}`
+	};
+	lines.push(`## ${words.whereTitle}`, "", ...words.where.flatMap((text) => !text.includes("{example}") && !text.includes("{link}") ? [`- ${text}`] : example === void 0 ? [] : [`- ${text.replace("{example}", example.query).replace("{link}", example.link)}`]), "", ...needsLines(lang), `## ${fill(words.contextTitle)}`, "");
+	if (page.description !== void 0) lines.push(own(page.description), "");
+	lines.push(...contentLines(site, page.blocks, lang, formulas, (heading, _anchor, depth) => `${"#".repeat(Math.min(3 + depth, 6))} ${heading}`));
+	for (const exercise of exercises) {
+		const part = exercisePart(site, exercise.block, lang, descriptions);
+		if (part === void 0) continue;
+		lines.push(`### ${words.exercise} ${part.id}`, "");
+		if (exercise.block.type === "generated") {
+			const format = part.lines.filter((text) => text.startsWith(`- ${tutorWords(lang).answerFormat}:`)).map(line);
+			lines.push(...generatedLines(exercise.block, site, lang, format));
+		} else {
+			lines.push(...part.lines.map((text) => {
+				const [, indent = "", rest = ""] = /^(\s*- )?(.*)$/.exec(text) ?? [];
+				return `${indent}${line(rest)}`;
+			}));
+			const declared = descriptions.get(exercise.block)?.exercise?.[lang];
+			if (exercise.count > 0) {
+				lines.push(`- ${words.linkNumber}: \`../?${exercise.id}=n&via=tutor#${exercise.id}\``);
+				const all = rows.get(exercise.id) ?? [];
+				const n = shown.get(exercise.id) ?? all.length;
+				if (declared !== void 0) lines.push(...componentTable(declared, lang));
+				else if (n > 0) lines.push(`- ${words.tasks}:`, ...all.slice(0, n));
+				if (n === 0 && all.length > 0) lines.push(`- ${words.none}`);
+				else if (n < all.length) lines.push(`- ${words.shown.replace("{shown}", String(n)).replace("{count}", String(all.length))}`);
+			} else lines.push(`- ${words.link}: [../?via=tutor#${exercise.id}](../?via=tutor#${exercise.id})`);
+		}
+		lines.push("");
+	}
+	return `${lines.join("\n").trimEnd()}\n`;
+}
+const markdown = new Marked({
+	gfm: true,
+	extensions: [{
+		name: "formula",
+		level: "inline",
+		start: (source) => {
+			const at = source.indexOf("$");
+			return at < 0 ? void 0 : at;
+		},
+		tokenizer: (source) => {
+			const match = /^\$(?:\\.|[^\\$\n])+?\$/.exec(source);
+			return match === null ? void 0 : {
+				type: "formula",
+				raw: match[0]
+			};
+		},
+		renderer: (token) => escape(token.raw)
+	}]
+});
+/** The HTML document of a tutor page's Markdown `text`. */
+function tutorPageDocument(text, site, page, lang) {
+	const words = wordsIn$1(lang);
+	const own = (value) => inLanguage(value, lang).replace(/\s+/g, " ").trim();
+	return tutorDocument(text, `${own(page.title)} – ${words.tutorPage} – ${own(site.app.title)}`, words.forTutor.replace("{page}", own(page.title)), lang);
+}
+/** The HTML document of a tutor page's Markdown `text`, with its `title` and `description`: lean, without script. */
+function tutorDocument(text, title, description, lang) {
+	const body = markdown.parse(text, { async: false }).trim();
+	return [
+		"<!doctype html>",
+		`<html lang="${lang}">`,
+		"<head>",
+		"<meta charset=\"utf-8\" />",
+		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />",
+		`<title>${escape(title)}</title>`,
+		`<meta name="description" content="${escape(description)}" />`,
+		"<style>body{margin:0 auto;max-width:48rem;padding:1rem;font:1rem/1.5 system-ui,sans-serif;color:#1a1a1a;background:#fff;overflow-wrap:anywhere}pre{white-space:pre-wrap}code,pre{font-size:.95em}</style>",
+		"</head>",
+		"<body>",
+		"<main id=\"anleitung\">",
+		body,
+		"</main>",
+		"</body>",
+		"</html>",
+		""
+	].join("\n");
+}
+// runtime/explainer/assessment-page.ts
+/** The address of a self-assessment's tutor page within its language tree. */
+const assessmentTutorOf = (assessment) => `${assessment.local}${TUTOR_PAGE}/`;
+const json$1 = (value) => JSON.stringify(value).replace(/</g, "\\u003c");
+/**
+* The offer of a self-assessment on the start page or its chapter's page, in a <template> until the client module
+* puts it into the page; it says "Dein letztes Ergebnis ansehen" when the device keeps one.
+*/
+function assessmentOffer(context, assessment) {
+	const { lang, site } = context;
+	const t = (key, params) => plain(message(lang, key, params));
+	const offer = assessment.chapter === void 0 ? "assessmentOfferApp" : "assessmentOfferChapter";
+	return [
+		`<template class="explainer-assessment-template">`,
+		`<section class="explainer-assessment-offer" aria-labelledby="selbsteinschaetzung" hidden data-key="${plain(assessment.key)}" data-storage="${plain(site.storage ?? "explainer")}">`,
+		`<h2 id="selbsteinschaetzung">${t("assessmentOfferTitle")}</h2>`,
+		`<p>${t(offer, { count: String(assessment.items.length) })}</p>`,
+		`<p><a class="explainer-assessment-link" href="${context.to(assessment.local)}" data-last="${t("assessmentOfferLast")}">${t("assessmentOfferStart")}</a></p>`,
+		`</section>`,
+		`</template>`
+	].join("\n");
+}
+/**
+* One exercise of a self-assessment: its number, and its question, the place of its live task, or the component
+* (`component`, its markup).
+*/
+function itemHtml(context, data, n, component = "") {
+	const { lang } = context;
+	const label = `<p class="explainer-assessment-label">${plain(message(lang, "assessmentTask", { n: String(n) }))}</p>`;
+	if (data.kind === "generated") return `${label}<div class="explainer-assessment-live"></div>`;
+	if (data.kind === "component") return `${label}${component}`;
+	if (data.kind === "open") return `${label}<div class="explainer-open-task-text">${data.task}</div><div class="explainer-open-live" hidden></div>`;
+	const { question, rendered } = data;
+	return `${label}${renderQuestion(question, {
+		lang,
+		format: (text) => rendered[text] ?? renderWithFormulas(text),
+		describe: (text) => formulaAlternative(text, lang),
+		...question.material === void 0 ? {} : { materialHtml: renderMaterial(question.material, context.material) }
+	})}`;
+}
+/**
+* The page of a self-assessment: the line for a reader without JavaScript, and, in a <template> until the client
+* module puts it into the page, the intro with its start button, each of its pages with its exercises and the buttons to move on, the place of the
+* result with the way to the tutor, and the client module's data.
+*/
+function assessmentMain(context, assessment) {
+	const { lang, site } = context;
+	const t = (key, params) => plain(message(lang, key, params));
+	const items = assessment.items.map((item) => {
+		if (item.block.type === "vue-component") {
+			const component = context.component(item.block, item.key);
+			return {
+				item,
+				data: {
+					kind: "component",
+					seeds: component?.seeds ?? [1]
+				},
+				html: component?.html ?? ""
+			};
+		}
+		const data = exerciseData(item.block, lang, site.data, context.resolve);
+		return {
+			item,
+			data: data.kind === "question" ? {
+				...data,
+				question: {
+					...data.question,
+					id: item.key
+				}
+			} : data
+		};
+	});
+	const steps = Array.from({ length: assessment.steps }, (_step, index) => {
+		const own = items.filter(({ item }) => item.step === index);
+		const last = index === assessment.steps - 1;
+		return [
+			`<section class="explainer-assessment-step" data-step="${index}" aria-labelledby="teil-${index + 1}" hidden>`,
+			`<h2 id="teil-${index + 1}" tabindex="-1">${t("assessmentStep", {
+				n: String(index + 1),
+				count: String(assessment.steps)
+			})}</h2>`,
+			`<ol class="explainer-assessment-items">`,
+			...own.map(({ item, data, html }) => `<li class="explainer-assessment-item" data-key="${item.key}">${itemHtml(context, data, items.findIndex((other) => other.item === item) + 1, html)}</li>`),
+			`</ol>`,
+			`<p class="explainer-assessment-nav">${index === 0 ? "" : `<button type="button" class="explainer-assessment-back">${t("assessmentBack")}</button> `}<button type="button" class="${last ? "explainer-assessment-finish" : "explainer-assessment-next"}">${t(last ? "assessmentFinish" : "assessmentNext")}</button></p>`,
+			`</section>`
+		].join("\n");
+	});
+	const tutor = assessmentTutorOf(assessment);
+	const all = assessments(site);
+	const whole = all.find((candidate) => candidate.chapter === void 0);
+	const data = {
+		key: assessment.key,
+		storage: site.storage ?? "explainer",
+		steps: assessment.steps,
+		items: items.map(({ item, data: exercise }) => ({
+			key: item.key,
+			ref: item.ref,
+			page: `${item.page.chapter}/${item.page.id}/`,
+			exercise: item.exercise,
+			step: item.step,
+			data: exercise
+		})),
+		pages: assessment.pages.map((page) => ({
+			page: `${page.chapter}/${page.id}/`,
+			title: titleOf(page, lang),
+			href: context.to(`${page.chapter}/${page.id}/`)
+		})),
+		chapters: site.chapters.map((chapter) => {
+			const own = all.find((candidate) => candidate.chapter === chapter) ?? (site.chapters.length === 1 ? whole : void 0);
+			return {
+				title: inLanguage(chapter.title, lang).replace(/\s+/g, " ").trim(),
+				...own === void 0 ? {} : { assessment: own.local },
+				pages: chapter.pages.map((page) => ({
+					title: titleOf(page, lang),
+					local: `${page.chapter}/${page.id}/`
+				}))
+			};
+		}),
+		whole: whole?.local ?? assessment.local,
+		root: context.to(""),
+		tutor,
+		markdown: `${tutor}${TUTOR_MARKDOWN}`,
+		ways: PROVIDERS.map((provider) => ({
+			name: provider.name,
+			url: provider.url,
+			...provider.paste === true ? { paste: true } : {}
+		})),
+		placeholder: placeholderPrompt(lang)
+	};
+	const back = assessment.chapter === void 0 ? "" : `${assessment.chapter.id}/`;
+	const unasked = assessment.pages.filter((page) => !assessment.items.some((item) => item.page === page));
+	const unaskedText = unasked.length === 0 ? t("assessmentAllAsked") : t(unasked.length === 1 ? "assessmentLeftOutOne" : "assessmentLeftOut", { n: String(unasked.length) });
+	return [
+		`<h1>${t("assessmentTitle")}</h1>`,
+		`<p class="explainer-assessment-nojs">${t("assessmentNojs")} <a href="${context.to(back)}">${plain(assessment.chapter === void 0 ? message(lang, "start") : inLanguage(assessment.chapter.title, lang))}</a></p>`,
+		`<template class="explainer-assessment-template">`,
+		`<div class="explainer-assessment" hidden>`,
+		`<div class="explainer-assessment-intro">`,
+		`<p>${t("assessmentIntro", { count: String(assessment.items.length) })} ${unaskedText}</p>`,
+		...unasked.length === 0 ? [] : [
+			`<ul class="explainer-assessment-unasked">`,
+			...unasked.map((page) => `<li><a href="${context.to(`${page.chapter}/${page.id}/`)}">${plain(titleOf(page, lang))}</a></li>`),
+			`</ul>`
+		],
+		`<p>${t("assessmentHow")}</p>`,
+		`<p class="explainer-assessment-privacy">${t("assessmentPrivacy")}</p>`,
+		`<p><button type="button" class="explainer-assessment-begin">${t("assessmentBegin")}</button></p>`,
+		`</div>`,
+		...steps,
+		`<section class="explainer-assessment-result" aria-labelledby="ergebnis" hidden>`,
+		`<h2 id="ergebnis" tabindex="-1">${t("assessmentResultTitle")}</h2>`,
+		`<p class="explainer-assessment-score"></p>`,
+		`<p class="explainer-assessment-advice"></p>`,
+		`<ol class="explainer-assessment-pages"></ol>`,
+		`<div class="explainer-assessment-tutor">`,
+		`<h3>${t("assessmentTutorTitle")}</h3>`,
+		`<p>${t("assessmentTutorIntro")}</p>`,
+		`<p class="explainer-assessment-tutor-actions"><select class="explainer-assessment-way" aria-label="${t("tutorWay")}">${context.ways}</select> <button type="button" class="explainer-assessment-go"></button></p>`,
+		`<p class="explainer-tutor-hint" role="status" aria-live="polite" hidden></p>`,
+		`<p class="explainer-assessment-tutor-status" role="status" aria-live="polite"></p>`,
+		`<p class="explainer-tutor-note">${t("tutorAccount")}</p>`,
+		`<p><a class="explainer-assessment-tutor-page" href="${context.to(tutor)}">${t("assessmentTutorPage")}</a></p>`,
+		`</div>`,
+		`<p class="explainer-assessment-again"><button type="button" class="explainer-assessment-restart">${t("assessmentRestart")}</button> <button type="button" class="explainer-assessment-delete">${t("assessmentDelete")}</button></p>`,
+		`<p class="explainer-assessment-status" role="status" aria-live="polite"></p>`,
+		`</section>`,
+		`<script type="application/json" class="explainer-assessment-data">${json$1(data)}<\/script>`,
+		`</div>`,
+		`</template>`
+	].join("\n");
+}
+const WORDS$1 = {
+	de: {
+		title: "Selbsteinschätzung – für deinen KI-Tutor",
+		description: "Was ein KI-Tutor zur Selbsteinschätzung von „{app}“ bekommt.",
+		intro: "Du begleitest ein Kind beim Lernen mit der Lern-App „{app}“ von lernapps.net. Es hat die Selbsteinschätzung {scope} gemacht: Aufgaben aus den Seiten der App, ohne Rückmeldung zu einzelnen Aufgaben. Du bist sein Wegweiser: Du schickst es zu den Seiten, die noch nicht sitzen, und danach in eine neue Runde der Selbsteinschätzung ihres Kapitels. Erklärt und geübt wird auf den Seiten selbst; dort hat das Kind „Hilfe“, und jede Seite hat ihre eigene Tutor-Seite.",
+		scopeApp: "der ganzen App",
+		scopeChapter: "des Kapitels „{chapter}“",
+		parents: "Eltern und Lehrkräfte sehen hier, was der Tutor bekommt.",
+		toAssessment: "Zur Selbsteinschätzung",
+		readTitle: "So liest du ein Ergebnis",
+		read: [
+			"Nach einer Runde fügt das Kind ein: das Ergebnis je Seite, eine Zeile je Aufgabe, diese Seite mit dem Ergebnis in der Adresse (z. B. `?a1=17-falsch-F1&a2=richtig&a3=offen&a4=teilweise-P2`) und den „Link für eine neue Runde“. Nimm das Ergebnis je Seite, wie es dasteht; rechne es nicht nach.",
+			"Eine Seite mit allen Aufgaben richtig, und mindestens zwei, kann das Kind wahrscheinlich schon. Mit mindestens der Hälfte richtig soll es sie noch einmal ansehen, mit weniger genau lesen. Eine teilweise richtige Aufgabe zählt halb; `P2` nennt einen Punkt einer guten Antwort, der ihr fehlte. Eine nicht beantwortete Aufgabe (`offen`) zählt als nicht richtig. Eine Seite ohne Aufgabe wurde nicht abgefragt.",
+			"Für jedes Kapitel gilt sein letztes Ergebnis: aus der letzten Runde dieses Kapitels, sonst aus der ersten Selbsteinschätzung. Merk es dir für die Kapitel, die noch kommen.",
+			"„Ich habe auf … geübt:“ kommt von „Zurück zum Tutor“ auf einer Seite: deren Tutor-Seite mit den Nummern, dann je geübter Aufgabe, wie es lief, bei einer falschen mit Eingabe und Meldung der App."
+		],
+		guideTitle: "So leitest du an",
+		guide: [
+			"Antworte kurz: höchstens drei eigene Sätze und eine Frage, dazu, wo du das Kind hinschickst, der feste Satz und der Link. Keine Überschriften, keine Listen.",
+			"Du bist Wegweiser, kein Lehrer: Erklär keinen Stoff, das tun die Seiten. Jede deiner Antworten schickt das Kind mit genau einem Link weiter. Coachen darfst du nur, wenn das Kind mit falschen Aufgaben von einer Seite zurückkommt (siehe unten).",
+			"Geh Kapitel für Kapitel vor, in der Reihenfolge unten. Fang mit dem ersten Kapitel an, in dem eine Seite „Lies sie genau“ oder „Schau sie dir noch einmal an“ hat. Sag dem Kind zuerst in zwei Sätzen, was schon gut lief und womit ihr anfangt.",
+			"Schick das Kind zu einer Seite nach der anderen, in der Reihenfolge der Seiten: zu denen zum genau Lesen und zum noch einmal Ansehen, und einmal zu einer Seite „nicht abgefragt“, wenn ihr bei ihr vorbeikommt. Sag dazu: „Lies die Seite und lös ihre Übungen. Oben und unten auf der Seite ist der Knopf ‚Zurück zum Tutor‘. Drück ihn und füg ein, was er kopiert.“",
+			"Kommt das Kind mit „Ich habe auf … geübt:“ zurück und ist eine Aufgabe falsch oder offen, lade die genannte Tutor-Seite und hilf zu genau diesen Aufgaben, wie sie es sagt. Schick das Kind zum Lösen auf die Seite zurück, mit `?via=tutor`, und bitte es wieder um „Zurück zum Tutor“. Sind die genannten Aufgaben richtig, ist das Coachen vorbei: Es gilt wieder diese Anleitung, und ihr geht zur nächsten Seite.",
+			"Sind die Seiten eines Kapitels durch, schick das Kind in eine neue Runde der Selbsteinschätzung des Kapitels: mit dem „Link für eine neue Runde“ aus seiner letzten Runde, sonst mit dem Link der Selbsteinschätzung des Kapitels aus den Links. Sag dazu: „Mach eine neue Runde. Am Ende drückst du ‚Zurück zum Tutor‘ und fügst das Ergebnis hier ein.“ Ein Kapitel ohne Selbsteinschätzung hat keine Runde.",
+			"Nach jeder Runde entscheidest du: Kann das Kind alle abgefragten Seiten des Kapitels wahrscheinlich schon, geht ihr zum nächsten Kapitel. Sonst geht es noch einmal zu den Seiten, die nicht sitzen, und dann in eine neue Runde. Sitzt eine Seite nach zwei Runden ihres Kapitels noch nicht (die erste Selbsteinschätzung zählt nicht mit), sag dem Kind, es soll sie mit „Mit einem KI-Tutor lernen“ auf der Seite durchgehen, und geht danach weiter.",
+			"Sind alle Kapitel durch, schick das Kind in eine Runde der ganzen App. Sitzt danach eine Seite nicht, geht ihr zu ihrem Kapitel wie oben. Sitzen alle abgefragten Seiten (eine Seite „nicht abgefragt“ zählt nicht), seid ihr fertig: Sag dem Kind in zwei Sätzen, was es geschafft hat, und dass es die Selbsteinschätzung später wiederholen kann, um zu sehen, ob es sitzt.",
+			"Die Aufgaben der Selbsteinschätzung erklärst du nicht und verrätst keine Lösung: Ihre Seiten haben dieselben Übungen, dort übt das Kind.",
+			"Eine Aufgabe „immer dieselbe Aufgabe“ (Liste unten) kann das Kind sich gemerkt haben. Sitzt eine Seite in einer neuen Runde nur mit solchen Aufgaben, frag kurz, warum die Antwort stimmt, bevor ihr weitergeht.",
+			"Jeden Link nimmst du genau so aus dem Block „Links für meinen Tutor“ in der Nachricht des Kindes. Bilde keine Adresse selbst, und schick dem Kind nie eine Tutor-Seite (eine Adresse mit `tutor/`): Die ist nur für dich."
+		],
+		appRules: "Regeln dieser App",
+		chaptersTitle: "Die Kapitel und ihre Seiten, in ihrer Reihenfolge",
+		chapter: "Kapitel",
+		assessmentOf: "Selbsteinschätzung des Kapitels",
+		noAssessment: "keine Selbsteinschätzung",
+		whole: "Selbsteinschätzung der ganzen App",
+		page: "Seite",
+		tutorPage: "Tutor-Seite",
+		asked: "Aufgaben",
+		unasked: "nicht abgefragt",
+		itemsTitle: "Die Aufgaben dieser Selbsteinschätzung",
+		item: "{key}: Übung {exercise} der Seite „{page}“",
+		same: " (immer dieselbe Aufgabe, auch auf der Seite: richtig kann gemerkt sein)",
+		quoted: "„{title}“"
+	},
+	en: {
+		title: "Self-assessment – for your AI tutor",
+		description: "What an AI tutor gets for the self-assessment of “{app}”.",
+		intro: "You accompany a child learning with the learning app “{app}” of lernapps.net. It did the self-assessment {scope}: tasks from the pages of the app, without feedback on any single task. You are its guide: you send it to the pages that do not stick yet, and then into a new round of the self-assessment of their chapter. Explaining and practising happen on the pages themselves; there the child has “Help”, and every page has a tutor page of its own.",
+		scopeApp: "of the whole app",
+		scopeChapter: "of the chapter “{chapter}”",
+		parents: "Parents and teachers see here what the tutor gets.",
+		toAssessment: "To the self-assessment",
+		readTitle: "How you read a result",
+		read: [
+			"After a round the child pastes: the result per page, a line per task, this page with the result in its address (e.g. `?a1=17-falsch-F1&a2=richtig&a3=offen&a4=teilweise-P2`) and the “Link for a new round”. Take the result per page as it stands; do not work it out again.",
+			"A page with all its tasks right, and two at least, the child probably knows already. With at least half of them right it should look at it again, with fewer read it closely. A partly right task (`teilweise`) counts half; `P2` names a point of a good answer it lacked. A task not answered (`offen`) counts as not right. A page without a task was not asked.",
+			"For each chapter its last result holds: of the last round of this chapter, else of the first self-assessment. Keep it in mind for the chapters still to come.",
+			"“I practised on …:” comes from “Back to the tutor” on a page: its tutor page with the numbers, then for each task practised how it went, a wrong one with the input and the app's message."
+		],
+		guideTitle: "How you guide",
+		guide: [
+			"Answer briefly: three sentences of your own and one question at most, plus, where you send the child, the fixed sentence and the link. No headings, no lists.",
+			"You are the guide, not a teacher: explain no subject matter, the pages do. Each of your answers sends the child on with exactly one link. You may coach only when the child comes back from a page with wrong tasks (see below).",
+			"Go chapter by chapter, in the order below. Start with the first chapter that has a page “Read it closely” or “Look at it again”. First tell the child in two sentences what went well already and where you start.",
+			"Send the child to one page after another, in the order of the pages: to those to read closely and to look at again, and once to a page “not asked” when you come by it. Add: “Read the page and do its exercises. At the top and the bottom of the page there is the button ‘Back to the tutor’. Press it and paste what it copies.”",
+			"If the child comes back with “I practised on …:” and a task is wrong or open, load the tutor page it names and help with exactly these tasks, as it says. Send the child back to the page to solve them, with `?via=tutor`, and ask it for “Back to the tutor” again. Once the tasks named are right, the coaching is over: this guide applies again, and you go on to the next page.",
+			"Once the pages of a chapter are done, send the child into a new round of the chapter's self-assessment: with the “Link for a new round” of its last round, else with the link of the chapter's self-assessment from the links. Add: “Do a new round. At the end press ‘Back to the tutor’ and paste the result here.” A chapter without a self-assessment has no round.",
+			"After each round you decide: if the child probably knows every page of the chapter asked, you go on to the next chapter. Else it goes once more to the pages that do not stick, then into a new round. If a page still does not stick after two rounds of its chapter (the first self-assessment does not count), tell the child to go through it with “Learn with an AI tutor” on the page, and go on after that.",
+			"Once every chapter is done, send the child into a round of the whole app. If a page does not stick then, go to its chapter as above. If every page asked sticks (a page “not asked” does not count), you are done: tell the child in two sentences what it has achieved, and that it can repeat the self-assessment later to see whether it sticks.",
+			"You do not explain the tasks of the self-assessment and give no solution away: their pages have the same exercises, the child practises there.",
+			"A task “always the same task” (list below) the child may have remembered. If a page sticks in a new round only by such tasks, ask briefly why the answer is right before you go on.",
+			"Take every link exactly as it is from the block “Links for my tutor” in the child's message. Build no address yourself, and never send the child a tutor page (an address with `tutor/`): it is for you only."
+		],
+		appRules: "Rules of this app",
+		chaptersTitle: "The chapters and their pages, in their order",
+		chapter: "Chapter",
+		assessmentOf: "self-assessment of the chapter",
+		noAssessment: "no self-assessment",
+		whole: "Self-assessment of the whole app",
+		page: "Page",
+		tutorPage: "Tutor page",
+		asked: "Tasks",
+		unasked: "not asked",
+		itemsTitle: "The tasks of this self-assessment",
+		item: "{key}: exercise {exercise} of the page “{page}”",
+		same: " (always the same task, on its page too: right may be remembered)",
+		quoted: "“{title}”"
+	}
+};
+const wordsIn = (lang) => WORDS$1[lang] ?? WORDS$1["de"];
+/**
+* The tutor page of a self-assessment in `lang`, as Markdown, its links relative to its folder <assessment>/tutor/: the
+* guide of a tutor who leads the learner chapter by chapter to the pages that do not stick and into a new round of
+* the chapter's self-assessment, how to read a result, every chapter of the app with its pages (the exercises of this
+* self-assessment by key, or not asked) and the link to its self-assessment, and the exercise behind each key.
+*/
+function assessmentTutorMarkdown(site, assessment, lang) {
+	const words = wordsIn(lang);
+	const own = (text) => inLanguage(text, lang).replace(/\s+/g, " ").trim();
+	const app = own(site.app.title);
+	const scope = assessment.chapter === void 0 ? words.scopeApp : words.scopeChapter.replace("{chapter}", own(assessment.chapter.title));
+	const here = assessmentTutorOf(assessment);
+	const all = assessments(site);
+	const whole = all.find((candidate) => candidate.chapter === void 0);
+	const lines = [
+		`# ${words.title}`,
+		"",
+		words.intro.replace("{app}", app).replace("{scope}", scope),
+		"",
+		`${words.parents} [${words.toAssessment}](../)`,
+		"",
+		`## ${words.readTitle}`,
+		"",
+		...words.read.map((text) => `- ${text}`),
+		"",
+		`## ${words.guideTitle}`,
+		"",
+		...words.guide.map((text) => `- ${text.replace("{here}", here)}`),
+		""
+	];
+	if (site.app.tutor?.rules !== void 0) lines.push(`## ${words.appRules}`, "", inLanguage(site.app.tutor.rules, lang).trim(), "");
+	lines.push(...needsLines(lang), `## ${words.chaptersTitle}`, "");
+	for (const chapter of site.chapters) {
+		const its = all.find((candidate) => candidate.chapter === chapter) ?? (site.chapters.length === 1 ? whole : void 0);
+		lines.push(`### ${words.chapter} ${words.quoted.replace("{title}", own(chapter.title))}`, "", `- ${its === void 0 ? words.noAssessment : words.assessmentOf}`);
+		for (const page of chapter.pages) {
+			const keys = assessment.items.filter((item) => item.page === page).map((item) => item.key.toUpperCase());
+			const asked = assessment.pages.includes(page) ? ` · ${keys.length === 0 ? words.unasked : `${words.asked} ${keys.join(", ")}`}` : "";
+			lines.push(`- ${words.quoted.replace("{title}", titleOf(page, lang))}${asked}`);
+		}
+		lines.push("");
+	}
+	lines.push(`## ${words.itemsTitle}`, "");
+	for (const item of assessment.items) lines.push(`- ${words.item.replace("{key}", item.key.toUpperCase()).replace("{exercise}", item.exercise).replace("{page}", titleOf(item.page, lang))}${drawsTasks(item.block) ? "" : words.same}`);
+	return `${lines.join("\n").trimEnd()}\n`;
+}
+/** The tutor page of a self-assessment in `lang` as a whole HTML document. */
+function assessmentTutorDocument(markdown, site, lang) {
+	const words = wordsIn(lang);
+	const app = inLanguage(site.app.title, lang).replace(/\s+/g, " ").trim();
+	return tutorDocument(markdown, `${words.title} – ${app}`, words.description.replace("{app}", app), lang);
+}
+// runtime/explainer/render.ts
+function sizeless(site, image) {
+	const file = site.images.get(image);
+	return file !== void 0 && isSizeless(file);
+}
+/** What rendering one page needs. */
+var Context = class {
+	locale;
+	site;
+	route;
+	islands;
+	descriptions;
+	/** What the blocks that show content need from this page. */
+	material;
+	/** Whether a component was rendered. */
+	hasIslands = false;
+	constructor(site, route, islands, descriptions) {
+		this.site = site;
+		this.route = route;
+		this.islands = islands;
+		this.descriptions = descriptions;
+		this.locale = localeOf(route.lang);
+		this.material = {
+			lang: route.lang,
+			href: (image) => relative(route.path, image),
+			resolve: this.resolve,
+			sizeless: (image) => sizeless(site, image)
+		};
+	}
+	get lang() {
+		return this.route.lang;
+	}
+	t(key, params) {
+		return message(this.lang, key, params);
+	}
+	/** The text in this page's language, as plain HTML. */
+	text(text) {
+		return plain(inLanguage(text, this.lang));
+	}
+	/** A link from this page to `local` (an address within the language tree, e.g. "prozent/prozentwert/#regel"). */
+	to(local) {
+		return relative(this.route.path, languageRoot(this.lang) + local);
+	}
+	/** Where a link inside a text leads: /<chapter>/<page>/#<section> within this language's tree. */
+	resolve = (href) => this.to(href.replace(/^\//, ""));
+	markdown(text) {
+		return renderMarkdown(inLanguage(text, this.lang), this.resolve);
+	}
+	inline(text) {
+		return renderInline(inLanguage(text, this.lang), this.resolve);
+	}
+};
+const external = (url, text = url) => `<a href="${plain(url)}" rel="noopener">${plain(text)}</a>`;
+function dateLabel(context, event) {
+	const date = String(event.date);
+	const match = /^(-?\d{1,4})(?:-(\d{2}))?(?:-(\d{2}))?$/.exec(date);
+	const year = Number(match?.[1] ?? 0);
+	const datetime = year >= 0 && match !== null ? date.replace(/^\d+/, (digits) => digits.padStart(4, "0")) : void 0;
+	if (event.label !== void 0) return {
+		label: context.text(event.label),
+		...datetime === void 0 ? {} : { datetime }
+	};
+	if (year < 0) return { label: plain(context.t("beforeChrist", { year: String(-year) })) };
+	let label = String(year);
+	if (match?.[2] !== void 0) {
+		const when = new Date(Date.UTC(year, Number(match[2]) - 1, Number(match[3] ?? 1)));
+		when.setUTCFullYear(year);
+		label = new Intl.DateTimeFormat(context.locale, {
+			timeZone: "UTC",
+			year: "numeric",
+			month: "long",
+			...match[3] === void 0 ? {} : { day: "numeric" }
+		}).format(when);
+	}
+	return {
+		label: plain(label),
+		...datetime === void 0 ? {} : { datetime }
+	};
+}
+function renderEvents(context, events) {
+	return `<ol class="explainer-timeline">${events.map((event) => {
+		const { label, datetime } = dateLabel(context, event);
+		const when = datetime === void 0 ? `<span class="explainer-date">${label}</span>` : `<time class="explainer-date" datetime="${datetime}">${label}</time>`;
+		const text = event.text === void 0 ? "" : `<div class="explainer-event-text">${context.markdown(event.text)}</div>`;
+		return `<li><p class="explainer-event">${when} <strong>${context.text(event.title)}</strong></p>${text}</li>`;
+	}).join("")}</ol>`;
+}
+/** The blocks, at heading level `level` (the level of the heading they are under: 1 for the page). */
+function renderBlocks(context, blocks, level, anchor = []) {
+	return blocks.map((block) => renderBlock(context, block, level, anchor)).join("\n");
+}
+function renderBlock(context, block, level, anchor) {
+	switch (block.type) {
+		case "section": {
+			const id = [...anchor, block.id];
+			return [
+				`<section class="explainer-section">`,
+				`<h${level + 1} id="${id.join("/")}">${context.text(block.title)}</h${level + 1}>`,
+				renderBlocks(context, block.blocks, level + 1, id),
+				`</section>`
+			].join("\n");
+		}
+		case "example":
+		case "note": return [
+			`<div class="explainer-box explainer-${block.type}">`,
+			`<h${level + 1} class="explainer-box-title">${context.text(block.title)}</h${level + 1}>`,
+			renderBlocks(context, block.blocks, level + 1, anchor),
+			`</div>`
+		].join("\n");
+		case "text":
+		case "formula":
+		case "figure":
+		case "labelled-figure":
+		case "table": return renderMaterial([block], context.material);
+		case "timeline": return renderEvents(context, timelineEvents(context.site, block));
+		case "definition": {
+			const id = termId(block.term);
+			return [
+				`<dl class="explainer-definition">`,
+				`<dt><dfn id="begriff-${id}"><a href="${context.to(`glossar/#${id}`)}">${context.text(block.term)}</a></dfn></dt>`,
+				`<dd>${context.markdown(block.explanation)}</dd>`,
+				`</dl>`
+			].join("");
+		}
+		case "quote":
+		case "code": return renderMaterial([block], context.material);
+		case "video": return renderVideo(block, context.lang, context.site.storage ?? "explainer");
+		case "vue-component": return renderComponent(context, block);
+		default: return renderExercise(block, context.lang, context.site.data, context.resolve, context.material, context.site.storage ?? "explainer");
+	}
+}
+const json = (value) => JSON.stringify(value).replace(/</g, "\\u003c");
+/**
+* A vue-component block: its island, hidden until it hydrates, its nojs text, its props and its feedback. An exercise
+* component has its anchor, its task number with "Neue Aufgabe" (hidden until it hydrates), its island in a form with
+* the explainer's "Prüfen" (the row of the shared questions, hidden until it hydrates; Enter in a field of the
+* component checks too), and as its no-JS text the task of number 1 as its describe states it, with the solution
+* folded, under the block's own nojs text if it has one.
+*/
+function renderComponent(context, block) {
+	const use = context.site.components.find((candidate) => candidate.block === block);
+	if (use === void 0) return "";
+	context.hasIslands = true;
+	const { component } = use;
+	const markup = context.islands.get(block)?.get(context.lang) ?? "";
+	const messages = questionMessagesIn(context.lang);
+	const feedback = component.exercise ? `<p class="question-feedback" data-right="${plain(messages.right)}" data-wrong="${plain(messages.wrong)}"></p>` : "";
+	const first = context.descriptions.get(block)?.tasks[context.lang]?.[0];
+	const number = (seed) => plain(context.t("taskNumber", { n: String(seed) }));
+	const described = first === void 0 ? "" : [
+		`<div class="explainer-described">`,
+		`<p class="explainer-task-number">${number(first.number)}</p>`,
+		`<div class="explainer-task">${renderMarkdown(first.task, context.resolve)}</div>`,
+		`<details class="explainer-solution"><summary>${plain(messages.solution)}</summary>${renderMarkdown(first.solution, context.resolve)}</details>`,
+		`</div>`
+	].join("");
+	const nojs = (block.nojs === void 0 ? "" : context.markdown(block.nojs)) + described;
+	const controls = component.exercise ? `<p class="explainer-task-controls" hidden><span class="explainer-task-number" tabindex="-1" data-template="${plain(context.t("taskNumber"))}">${number(1)}</span> <button type="button" class="explainer-new-task" aria-label="${plain(context.t("newTask"))}" title="${plain(context.t("newTask"))}">${NEW_TASK_ICON}</button></p>` : "";
+	return [
+		`<div class="explainer-component" ${[
+			...use.id === void 0 ? [] : [`id="${use.id}"`],
+			`data-component="${component.name}"`,
+			...component.exercise ? [`data-exercise data-seeds="${JSON.stringify(context.descriptions.get(block)?.seeds ?? [1])}"`] : [],
+			...component.checked ? ["data-checked"] : [],
+			...component.caption ? [`data-nojs="caption" data-caption="${plain(context.t("textDescription"))}"`] : []
+		].join(" ")}>`,
+		controls,
+		component.exercise ? `<form class="explainer-component-form" novalidate><div class="explainer-island" hidden>${markup}</div><p class="question-actions" hidden><button type="submit" class="question-check" disabled>${plain(messages.check)}</button></p></form>` : `<div class="explainer-island" hidden>${markup}</div>`,
+		`<div class="explainer-nojs">${nojs}</div>`,
+		feedback,
+		`<script type="application/json" class="explainer-component-props">${json(propsIn(block.props, component, context.lang))}<\/script>`,
+		`</div>`
+	].filter((part) => part !== "").join("\n");
+}
+/** The contents of a page with three or more sections: the sections and their subsections. */
+function pageContents(context, blocks) {
+	if (blocks.filter((block) => block.type === "section").length < 3) return "";
+	const list = (items, anchor) => `<ol>${items.filter((block) => block.type === "section").map((section) => {
+		const id = [...anchor, section.id];
+		const inner = section.blocks.some((block) => block.type === "section") ? list(section.blocks, id) : "";
+		return `<li><a href="#${id.join("/")}">${context.text(section.title)}</a>${inner}</li>`;
+	}).join("")}</ol>`;
+	return `<nav class="explainer-toc" aria-label="${plain(context.t("onThisPage"))}"><p class="explainer-toc-title">${plain(context.t("onThisPage"))}</p>${list(blocks, [])}</nav>`;
+}
+function header(context) {
+	const { site, route } = context;
+	return pageHeader({
+		...route,
+		languages: site.app.languages,
+		label: plain(context.t("languages")),
+		name: (lang) => plain(message(lang, "language"))
+	});
+}
+function breadcrumbs(context) {
+	const { route, site } = context;
+	if (route.kind === "start") return "";
+	const items = [`<li><a href="${context.to("")}">${plain(context.t("start"))}</a></li>`];
+	if ((route.kind === "page" || route.kind === "assessment") && route.chapter !== void 0 && !hiddenChapter(site)) items.push(`<li><a href="${context.to(`${route.chapter.id}/`)}">${context.text(route.chapter.title)}</a></li>`);
+	items.push(`<li aria-current="page">${plain(route.title)}</li>`);
+	return `<nav class="explainer-breadcrumbs" aria-label="${plain(context.t("breadcrumbs"))}"><ol>${items.join("")}</ol></nav>`;
+}
+function pager(context) {
+	const { route, site } = context;
+	if (route.page === void 0) return "";
+	const pages = contentPages(site);
+	const index = pages.indexOf(route.page);
+	const link = (rel, key, offset) => {
+		const other = pages[index + offset];
+		if (other === void 0) return "";
+		const title = inLanguage(other.title, context.lang);
+		return `<a rel="${rel}" href="${context.to(`${other.chapter}/${other.id}/`)}">${plain(context.t(key, { title }))}</a>`;
+	};
+	return `<nav class="explainer-pager" aria-label="${plain(context.t("pager"))}">${link("prev", "previous", -1)}${link("next", "next", 1)}</nav>`;
+}
+function pageList(context, pages) {
+	return `<ol class="explainer-pages">${pages.map((page) => {
+		const description = page.description === void 0 ? "" : ` <span class="explainer-description">${context.text(page.description)}</span>`;
+		return `<li><a href="${context.to(`${page.chapter}/${page.id}/`)}">${context.text(page.title)}</a>${description}</li>`;
+	}).join("")}</ol>`;
+}
+function main(context) {
+	const { route, site } = context;
+	const title = `<h1>${plain(route.title)}</h1>`;
+	switch (route.kind) {
+		case "start": {
+			const contents = hiddenChapter(site) ? pageList(context, site.chapters[0]?.pages ?? []) : `<ol class="explainer-chapters">${site.chapters.map((chapter) => {
+				const summary = chapter.summary === void 0 ? "" : context.markdown(chapter.summary);
+				return `<li><a class="explainer-chapter-link" href="${context.to(`${chapter.id}/`)}">${context.text(chapter.title)}</a>${summary}${pageList(context, chapter.pages)}</li>`;
+			}).join("")}</ol>`;
+			const glossary = terms(site).length === 0 ? "" : `<p><a href="${context.to("glossar/")}">${plain(context.t("glossary"))}</a></p>`;
+			const sources = site.app.sources === void 0 ? "" : `<section class="explainer-sources"><h2>${plain(context.t("sources"))}</h2><p>${plain(context.t("sourcesIntro"))}</p><ul>${site.app.sources.map((source) => {
+				const text = inLanguage(source.title, context.lang);
+				return `<li>${source.url === void 0 ? plain(text) : external(source.url, text)}</li>`;
+			}).join("")}</ul></section>`;
+			const assessment = assessmentOf(site);
+			return [
+				title,
+				`<div class="explainer-intro">${context.markdown(site.app.intro)}</div>`,
+				assessment === void 0 ? "" : assessmentOffer(assessmentContext(context), assessment),
+				`<nav class="explainer-contents" aria-labelledby="inhalt"><h2 id="inhalt">${plain(context.t("contents"))}</h2>${contents}</nav>`,
+				glossary,
+				tutorAbout(context),
+				sources
+			].filter((part) => part !== "").join("\n");
+		}
+		case "chapter": {
+			const chapter = route.chapter;
+			if (chapter === void 0) return title;
+			const summary = chapter.summary === void 0 ? "" : `<div class="explainer-intro">${context.markdown(chapter.summary)}</div>`;
+			const assessment = assessmentOf(site, chapter.id);
+			return [
+				title,
+				summary,
+				assessment === void 0 ? "" : assessmentOffer(assessmentContext(context), assessment),
+				`<nav class="explainer-contents" aria-label="${plain(context.t("pages"))}">${pageList(context, chapter.pages)}</nav>`
+			].filter((part) => part !== "").join("\n");
+		}
+		case "assessment": return route.assessment === void 0 ? title : assessmentMain(assessmentContext(context), route.assessment);
+		case "glossary": {
+			const collator = new Intl.Collator(context.locale);
+			const entries = terms(site).sort((a, b) => collator.compare(inLanguage(a.term, context.lang), inLanguage(b.term, context.lang))).map((term) => {
+				const page = inLanguage(term.page.title, context.lang);
+				const back = `<a href="${context.to(`${term.page.chapter}/${term.page.id}/#begriff-${term.id}`)}">${plain(context.t("explainedOn", { page }))}</a>`;
+				return `<dt id="${term.id}"><dfn>${context.text(term.term)}</dfn></dt><dd>${context.markdown(term.explanation)}<p>${back}</p></dd>`;
+			});
+			return [
+				title,
+				`<p>${plain(context.t("glossaryIntro"))}</p>`,
+				`<dl class="explainer-glossary">${entries.join("")}</dl>`
+			].join("\n");
+		}
+		case "page": {
+			const page = route.page;
+			if (page === void 0) return title;
+			return [
+				`<div class="explainer-title-row">`,
+				title,
+				tutorSection(context),
+				`</div>`,
+				pageContents(context, page.blocks),
+				renderBlocks(context, page.blocks, 1)
+			].join("\n");
+		}
+	}
+}
+/** What a part of a self-assessment needs of the page it is on (assessment-page.ts). */
+const assessmentContext = (context) => ({
+	site: context.site,
+	lang: context.lang,
+	to: (local) => context.to(local),
+	resolve: context.resolve,
+	material: context.material,
+	ways: wayOptions(context),
+	component: (block, key) => assessmentComponent(context, block, key)
+});
+/**
+* An exercise component as one exercise of a self-assessment, by its key: its island with the task of number 1 as the
+* build rendered it, its props and its task numbers, without "Prüfen", feedback, task number or nojs text (the
+* self-assessment runs with JavaScript only); the islands hydrate it with the task the self-assessment draws.
+*/
+function assessmentComponent(context, block, key) {
+	const use = context.site.components.find((candidate) => candidate.block === block);
+	if (use === void 0 || !use.component.exercise) return void 0;
+	context.hasIslands = true;
+	const { component } = use;
+	const seeds = context.descriptions.get(block)?.seeds ?? [1];
+	return {
+		html: [
+			`<div class="explainer-component" ${[
+				`id="aufgabe-${key}"`,
+				`data-component="${component.name}"`,
+				`data-exercise data-assessment data-seeds="${JSON.stringify(seeds)}"`,
+				...component.checked ? ["data-checked"] : []
+			].join(" ")}>`,
+			`<div class="explainer-island" hidden>${context.islands.get(block)?.get(context.lang) ?? ""}</div>`,
+			`<script type="application/json" class="explainer-component-props">${json(propsIn(block.props, component, context.lang))}<\/script>`,
+			`</div>`
+		].join("\n"),
+		seeds: [...seeds]
+	};
+}
+/**
+* What a KI tutor is, on the start page: a section of its own that says what the tutor does and where it shows, the
+* choice of the learner's assistant ("Keiner" first; shown by the client module, which keeps it on the device), that the
+* learner uses an account of their own and the assistant is no offer of lernapps.net, and that nothing leaves the app
+* before a click. It starts no tutor itself.
+*/
+function tutorAbout(context) {
+	const { site } = context;
+	return [
+		`<section class="explainer-tutor-about" aria-labelledby="ki-tutor">`,
+		`<h2 id="ki-tutor">${plain(context.t("tutorTitle"))}</h2>`,
+		`<p>${plain(context.t("tutorAbout"))}</p>`,
+		`<p>${plain(context.t("tutorAboutStart"))}</p>`,
+		`<p class="explainer-tutor-choice" hidden><label>${plain(context.t("tutorChoose"))} <select class="explainer-tutor-choose" data-storage="${plain(site.storage ?? "explainer")}"><option value="">${plain(context.t("tutorNone"))}</option>${wayOptions(context)}</select></label> <button type="button" class="explainer-tutor-needs-open" aria-haspopup="dialog" aria-label="${plain(context.t("needsOpen"))}" title="${plain(context.t("needsOpen"))}">${SETTINGS_ICON}</button></p>`,
+		`<p class="explainer-tutor-hint" role="status" aria-live="polite" hidden></p>`,
+		`<p>${plain(context.t("tutorAccount"))}</p>`,
+		`<p>${plain(context.t("tutorAboutPrivacy"))}</p>`,
+		`</section>`,
+		needsChoice(context)
+	].join("\n");
+}
+/** The symbol of "Einstellungen", which opens the dialog of the learner's needs: a gear, its name in aria-label. */
+const SETTINGS_ICON = "<svg width=\"22\" height=\"22\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\" focusable=\"false\"><circle cx=\"12\" cy=\"12\" r=\"3\"/><path d=\"M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 1 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06A1.65 1.65 0 0 0 4.68 15a1.65 1.65 0 0 0-1.51-1H3a2 2 0 1 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06A1.65 1.65 0 0 0 9 4.68a1.65 1.65 0 0 0 1-1.51V3a2 2 0 1 1 4 0v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 1 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z\"/></svg>";
+/** The name and the description of each need on the start page. */
+const NEED_TEXTS = {
+	"kurze-schritte": ["needKurzeSchritte", "needKurzeSchritteAbout"],
+	"wenig-lesen": ["needWenigLesen", "needWenigLesenAbout"],
+	"mehr-tiefe": ["needMehrTiefe", "needMehrTiefeAbout"],
+	"andere-muttersprache": ["needAndereMuttersprache", "needAndereMutterspracheAbout"],
+	"klar-und-woertlich": ["needKlarUndWoertlich", "needKlarUndWoertlichAbout"],
+	"rechnen-anschaulich": ["needRechnenAnschaulich", "needRechnenAnschaulichAbout"]
+};
+/**
+* The choice of the learner's needs for the tutor, on the start page (dec-tutor-needs): a dialog that "Einstellungen"
+* beside the choice of the assistant opens, with a box per need and one or two sentences on what it does, the first
+* language below `andere-muttersprache`, and whether the choice holds for every explainer or for this app only. The
+* tutor needs JavaScript, so the dialog does too: it stays in a <template> until the client module puts it into the
+* page, opens it and keeps the choice on the device.
+*/
+function needsChoice(context) {
+	const { site, lang } = context;
+	const languages = [...LANGUAGES].map((tag) => ({
+		tag,
+		name: languageName(tag, lang)
+	})).sort((a, b) => a.name.localeCompare(b.name, lang));
+	const language = [
+		`<p class="explainer-tutor-language-choice" hidden><label>${plain(context.t("needsLanguage"))} <select class="explainer-tutor-language">`,
+		`<option value="">${plain(context.t("needsLanguageNone"))}</option>`,
+		...languages.map(({ tag, name }) => `<option value="${plain(tag)}">${plain(name)}</option>`),
+		`</select></label></p>`
+	].join("");
+	const needs = NEEDS.map((need) => {
+		const [name, about] = NEED_TEXTS[need];
+		const id = `bedarf-${need}`;
+		return [
+			`<div class="explainer-tutor-need-choice"><input type="checkbox" class="explainer-tutor-need" id="${id}" value="${need}" aria-describedby="${id}-text" />`,
+			`<label for="${id}">${plain(context.t(name))}</label>`,
+			`<p class="explainer-tutor-need-text" id="${id}-text">${plain(context.t(about))}</p></div>`,
+			need === "andere-muttersprache" ? language : ""
+		].join("");
+	});
+	const scope = (value, key) => `<label><input type="radio" class="explainer-tutor-needs-scope" name="bedarf-gilt" value="${value}" /> ${plain(context.t(key))}</label>`;
+	return [
+		`<template class="explainer-tutor-needs-template">`,
+		`<dialog class="explainer-tutor-needs" data-storage="${plain(site.storage ?? "explainer")}" aria-labelledby="bedarf-titel">`,
+		`<form method="dialog">`,
+		`<h2 id="bedarf-titel">${plain(context.t("needsTitle"))}</h2>`,
+		`<p>${plain(context.t("needsAbout"))}</p>`,
+		...needs,
+		`<fieldset class="explainer-tutor-needs-where"><legend>${plain(context.t("needsScopeTitle"))}</legend>${scope("archetype", "needsScopeAll")} ${scope("app", "needsScopeApp")}</fieldset>`,
+		`<p class="explainer-tutor-note">${plain(context.t("needsPrivacy"))}</p>`,
+		`<p><button class="explainer-tutor-needs-done">${plain(context.t("needsDone"))}</button></p>`,
+		`</form>`,
+		`</dialog>`,
+		`</template>`
+	].join("\n");
+}
+/**
+* The assistants of the app as options of a select, each by its name, and copying the prompt last (COPY). An assistant
+* that needs pasting (`paste`) carries its explanation in data-hint, which the client module shows once it is chosen.
+*/
+function wayOptions(context) {
+	return [...PROVIDERS.map((provider) => {
+		const hint = provider.paste === true ? ` data-hint="${plain(context.t("tutorPasteHint", { name: provider.name }))}"` : "";
+		return `<option value="${plain(provider.name)}"${hint}>${plain(provider.name)}</option>`;
+	}), `<option value="copy">${plain(context.t("tutorOther"))}</option>`].join("");
+}
+/**
+* "Mit einem KI-Tutor lernen", way A to the tutor, on each content page alone, beside its title. Folded while no
+* assistant is switched on: unfolded, a select of the app's assistants and copying the text, "Einschalten" (hidden
+* until the client module runs; without it a plain link per assistant), that the learner uses an account of their own
+* and the assistant is no offer of lernapps.net, and the link to the page's tutor page. Once an assistant is on
+* (chosen here or on the start page, kept on the device), a bar in its place: "Mit <name> lernen"; it is changed or
+* switched off on the start page. Then a status line, and what the client module needs (prompt.ts): the start prompt
+* with BASE before its address, the page's tutor page and its Markdown, and the page's id, title, exercises and
+* sections, for the learner's position (position.ts), the result line of "Zurück" (result.ts) and the lines of
+* "Hilfe" (stuck.ts), whose button the client module adds to each exercise with the way chosen here.
+*/
+function tutorSection(context) {
+	const { site, lang, route } = context;
+	const plainLinks = PROVIDERS.map((provider) => `<a class="explainer-tutor-provider" href="${plain(plainAddress(provider.url))}" rel="noopener" target="_blank">${plain(context.t("tutorOpenWith", { name: provider.name }))}</a>`).join(" ");
+	const { page } = route;
+	const data = {
+		start: startPrompt(route),
+		base: BASE,
+		query: QUERY,
+		root: context.to(""),
+		storage: site.storage ?? "explainer",
+		...page === void 0 ? {} : { page: {
+			id: page.id,
+			title: inLanguage(page.title, lang).replace(/\s+/g, " ").trim(),
+			exercises: pageExercises(site, page, context.descriptions).map((exercise) => ({
+				id: exercise.id,
+				...exercise.section === void 0 ? {} : { section: exercise.section },
+				numbered: exercise.count > 0
+			})),
+			sections: sectionsOf(page)
+		} },
+		...page === void 0 ? {} : {
+			tutor: tutorPageOf(page),
+			markdown: `${tutorPageOf(page)}${TUTOR_MARKDOWN}`
+		},
+		ways: PROVIDERS.map((provider) => ({
+			name: provider.name,
+			url: provider.url,
+			...provider.paste === true ? { paste: true } : {}
+		})),
+		placeholder: placeholderPrompt(lang),
+		go: context.t("tutorGo"),
+		done: context.t("tutorDone"),
+		copy: context.t("tutorCopy"),
+		copied: context.t("tutorCopied"),
+		failed: context.t("tutorCopyFailed")
+	};
+	const tutorPage = page === void 0 ? "" : `<p><a class="explainer-tutor-guide" href="${context.to(tutorPageOf(page))}">${plain(context.t("tutorPageLink"))}</a></p>`;
+	return [
+		`<div class="explainer-tutor explainer-tutor-page">`,
+		`<details class="explainer-tutor-off">`,
+		`<summary>${plain(context.t("tutorTitle"))}</summary>`,
+		`<p>${plain(context.t("tutorPageIntro"))}</p>`,
+		`<p class="explainer-tutor-actions"><span class="explainer-tutor-way" hidden><select class="explainer-tutor-select" aria-label="${plain(context.t("tutorWay"))}">${wayOptions(context)}</select> <button type="button" class="explainer-tutor-on">${plain(context.t("tutorOn"))}</button></span> <span class="explainer-tutor-plain">${plainLinks}</span></p>`,
+		`<p class="explainer-tutor-hint" role="status" aria-live="polite" hidden></p>`,
+		`<p class="explainer-tutor-note">${plain(context.t("tutorAccount"))} ${plain(context.t("tutorScope"))}</p>`,
+		tutorPage,
+		`</details>`,
+		`<p class="explainer-tutor-bar" hidden><button type="button" class="explainer-tutor-go"></button></p>`,
+		`<p class="explainer-tutor-status" role="status" aria-live="polite"></p>`,
+		`<script type="application/json" class="explainer-tutor-prompt">${json(data)}<\/script>`,
+		`</div>`
+	].filter((part) => part !== "").join("\n");
+}
+function head(context) {
+	const { route, site } = context;
+	const app = inLanguage(site.app.title, context.lang);
+	const title = route.kind === "start" ? app : `${route.title} – ${app}`;
+	const description = route.page?.description !== void 0 ? inLanguage(route.page.description, context.lang) : route.chapter?.summary !== void 0 && route.kind === "chapter" ? inLanguage(route.chapter.summary, context.lang) : inLanguage(site.app.intro, context.lang);
+	const alternates = alternateLinks({
+		...route,
+		languages: site.app.languages
+	}).join("\n    ");
+	return [
+		`<title>${plain(title)}</title>`,
+		`<meta name="description" content="${plain(description.replace(/\s+/g, " ").trim())}" />`,
+		`<meta name="lernapps-archetype" content="explainer" />`,
+		alternates
+	].join("\n    ");
+}
+function footer(context) {
+	return pageFooter({
+		footer: plain(context.t("footer")),
+		imprint: plain(context.t("imprint")),
+		privacy: plain(context.t("privacy"))
+	});
+}
+/** One page of the app, with the markup of its components as the build rendered them. */
+function renderPage(site, route, islands = /* @__PURE__ */ new Map(), descriptions = /* @__PURE__ */ new Map()) {
+	const context = new Context(site, route, islands, descriptions);
+	const body = [
+		header(context),
+		breadcrumbs(context),
+		`<main class="explainer" id="inhalt-der-seite">`,
+		main(context),
+		`</main>`,
+		pager(context),
+		footer(context)
+	].filter((part) => part !== "").join("\n");
+	return {
+		route,
+		head: head(context),
+		body,
+		islands: context.hasIslands
+	};
+}
+/** Every page of the app, in every language. */
+function renderSite(site, islands = /* @__PURE__ */ new Map(), descriptions = /* @__PURE__ */ new Map()) {
+	return routes(site).map((route) => renderPage(site, route, islands, descriptions));
+}
+// runtime/explainer/scope.ts
+/** The folder of a scope, below the app's root, a chapter's folder or a page's folder in each language tree. */
+const SCOPE_PAGE = "scope/";
+/** The words of a scope by language: its closing part and the links one level up. */
+const WORDS = {
+	de: {
+		out: "Gehört nicht dazu",
+		chapter: "Alle Seiten des Kapitels: [Scope des Kapitels](../../scope/)",
+		app: "Die ganze App: [Scope der App](../../scope/)"
+	},
+	en: {
+		out: "Out of scope",
+		chapter: "All pages of the chapter: [scope of the chapter](../../scope/)",
+		app: "The whole app: [scope of the app](../../scope/)"
+	}
+};
+/**
+* The scopes the build writes for `site` in `lang`, by their folder within the language tree: "" the whole,
+* "<chapter>/" a chapter's with its pages, "<chapter>/<page>/" a page's; each but the whole with a link one level up.
+* None when the app has no scope.
+*/
+function scopeFiles(site, lang) {
+	const files = /* @__PURE__ */ new Map();
+	const { scope } = site.app;
+	if (scope === void 0) return files;
+	const words = lang === "de" ? WORDS.de : WORDS.en;
+	const own = (text) => text === void 0 ? "" : inLanguage(text, lang).trim();
+	const closing = [`## ${words.out}`, scope.out.map((item) => `- ${own(item)}`).join("\n")];
+	const join = (...parts) => `${parts.filter((part) => part !== "").join("\n\n")}\n`;
+	const whole = [`# ${own(site.app.title)}`, own(scope.text)];
+	for (const chapter of site.chapters) {
+		const pages = chapter.pages.map((page) => ({
+			page,
+			title: own(page.title),
+			text: own(page.scope)
+		}));
+		whole.push(`## ${own(chapter.title)}`, own(chapter.scope));
+		for (const { title, text } of pages) whole.push(`### ${title}`, text);
+		files.set(`${chapter.id}/`, join(`# ${own(chapter.title)}`, own(chapter.scope), ...pages.flatMap(({ title, text }) => [`## ${title}`, text]), ...closing, words.app));
+		for (const { page, title, text } of pages) files.set(`${chapter.id}/${page.id}/`, join(`# ${title}`, text, ...closing, words.chapter));
+	}
+	files.set("", join(...whole, ...closing));
+	return files;
+}
+/** The page of the scope in `folder` (as scopeFiles names it) in `lang`: its Markdown rendered, for no menu and no search engine. */
+function scopeDocument(markdown, title, lang, folder = "") {
+	const depth = folder.split("/").filter((segment) => segment !== "").length + 1;
+	const body = renderMarkdown(markdown, (href) => href.startsWith("/") ? `${"../".repeat(depth)}${href.slice(1)}` : href);
+	return [
+		"<!doctype html>",
+		`<html lang="${escape(lang)}">`,
+		"<head>",
+		"<meta charset=\"utf-8\">",
+		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">",
+		"<meta name=\"robots\" content=\"noindex\">",
+		`<title>${escape(title)}</title>`,
+		"</head>",
+		`<body><main>${body}</main></body>`,
+		"</html>"
+	].join("\n");
+}
+// runtime/explainer/plugin.ts
+// @vitejs/plugin-vue and resolves vue to the copy this runtime depends on, so that the components and the islands
+const MARKER = "<!-- explainer -->";
+const ISLANDS = "\0lernapps-explainer-islands";
+/** The shell with the page in it, and `head` (the islands module) at the end of its head. */
+function fill(shell, page, head = "") {
+	if (!shell.includes(MARKER)) throw new Error(`index.html has no ${MARKER}: put it in <body>, where the pages go`);
+	const html = withLanguage(shell, page.route.lang).replace(/\s*<title>[\s\S]*?<\/title>/, "").replace("</head>", `  ${page.head}${head === "" ? "" : `\n    ${head}`}\n  </head>`);
+	return fromDepth(html, page.route.path).replace(MARKER, () => page.body);
+}
+/** The islands module, next to this file: islands.ts in the source, explainer-islands.mjs in dist/. */
+const here = fileURLToPath(import.meta.url);
+const ISLANDS_RUNTIME = here.endsWith(".ts") ? join(dirname(here), "islands.ts") : join(dirname(here), "explainer-islands.mjs");
+/** Whether the app in `root` has components. */
+const hasComponents = (root) => {
+	const dir = join(root, "src/components");
+	return existsSync(dir) && readdirSync(dir).some((file) => file.endsWith(".vue"));
+};
+/** @vitejs/plugin-vue, loaded only when the app has components: an app without them loads nothing of Vue. */
+function vueWhenComponents() {
+	let inner;
+	const delegate = (name) => function(...args) {
+		const hook = inner?.[name];
+		if (hook === void 0) return void 0;
+		return (typeof hook === "function" ? hook : hook.handler).apply(this, args);
+	};
+	return {
+		name: "lernapps-explainer-vue",
+		...Object.fromEntries([
+			"configResolved",
+			"options",
+			"buildStart",
+			"configureServer",
+			"handleHotUpdate",
+			"shouldTransformCachedModule",
+			"resolveId",
+			"load",
+			"transform"
+		].map((name) => [name, delegate(name)])),
+		async config(config, env) {
+			if (!hasComponents(resolve(config.root ?? process.cwd()))) return void 0;
+			const { default: vue } = await import("@vitejs/plugin-vue");
+			inner = vue(VUE_OPTIONS);
+			const own = await delegate("config").call(this, config, env) ?? {};
+			return {
+				...own,
+				resolve: {
+					...own.resolve,
+					alias: vueAlias()
+				}
+			};
+		}
+	};
+}
+const reason = (error) => (error instanceof Error ? error.message : String(error)).split("\n")[0] ?? "";
+/**
+* The property test of each exercise component's logic with each block's props (`test`), what its logic describes
+* (about, and describe for each task number in each language), and the markup of each block's component in each
+* language, rendered by Vue's server renderer, an exercise component with the task number 1; or the problems, one
+* line each.
+*/
+async function renderComponents(site, load, test) {
+	const problems = [];
+	const islands = /* @__PURE__ */ new Map();
+	const descriptions = /* @__PURE__ */ new Map();
+	if (site.components.length === 0) return {
+		islands,
+		descriptions,
+		problems
+	};
+	const { createSSRApp } = await load("vue");
+	const { renderToString } = await load("vue/server-renderer");
+	for (const { block, component, place, examples } of site.components) {
+		if (component.logic !== void 0) {
+			const logic = await load(`/${component.file.replace(/\.vue$/, ".ts")}`);
+			const props = propsIn(block.props, component, "de");
+			const contract = test ? propertyProblems(logic, props) : [];
+			for (const problem of contract) problems.push(`${place}: ${component.name}.ts: ${problem} (vue-component-exercise-contract)`);
+			if (test && contract.length === 0) for (const { kind, index, message } of exampleProblems(logic, props, block.examples)) problems.push(`${examples[kind][index] ?? place}: ${component.name}.ts: ${message} (vue-component-exercise-contract)`);
+			if (contract.length === 0) {
+				const described = describedProblems(logic, (lang) => propsIn(block.props, component, lang), site.app.languages);
+				for (const problem of described.problems) problems.push(`${place}: ${component.name}.ts: ${problem} (vue-component-exercise-contract)`);
+				if (described.description !== void 0) descriptions.set(block, described.description);
+			}
+		}
+		const definition = (await load(`/${component.file}`))["default"];
+		const markup = /* @__PURE__ */ new Map();
+		for (const lang of site.app.languages) {
+			const app = createSSRApp(definition, {
+				...propsIn(block.props, component, lang),
+				...component.exercise ? { seed: descriptions.get(block)?.seeds[0] ?? 1 } : {},
+				...component.checked ? { checked: false } : {}
+			});
+			const warnings = /* @__PURE__ */ new Set();
+			app.config.warnHandler = (message) => warnings.add(message);
+			try {
+				markup.set(lang, await renderToString(app));
+			} catch (error) {
+				problems.push(`${place} (${lang}): ${component.name} throws while the build renders it: ${reason(error)}`);
+			}
+			for (const warning of warnings) problems.push(`${place} (${lang}): Vue warns while the build renders ${component.name}: ${warning}`);
+		}
+		islands.set(block, markup);
+	}
+	return {
+		islands,
+		descriptions,
+		problems
+	};
+}
+/**
+* The islands module of the app: the islands runtime, with each component the pages use and the logic module of each
+* exercise component, which checks its answers in the browser, loaded on first use.
+*/
+function islandsModule(site) {
+	const used = new Map(site.components.map((use) => [use.component.name, use.component]));
+	const loader = (name, file) => `  ${JSON.stringify(name)}: () => import(${JSON.stringify(file)}),`;
+	return [
+		`import { startIslands } from ${JSON.stringify(ISLANDS_RUNTIME)};`,
+		`startIslands({`,
+		...[...used.keys()].map((name) => loader(name, `/src/components/${name}.vue`)),
+		`}, {`,
+		...[...used.values()].filter((component) => component.exercise).map((component) => loader(component.name, `/src/components/${component.name}.ts`)),
+		`});`,
+		""
+	].join("\n");
+}
+/**
+* What the build writes for a tutor beside the pages: the tutor page of each content page and of each self-assessment,
+* by its folder from the app's root (with the language root), its HTML as index.html and its Markdown beside it.
+*/
+function tutorAssets(site, descriptions) {
+	const pages = /* @__PURE__ */ new Map();
+	for (const lang of site.app.languages) {
+		for (const page of contentPages(site)) {
+			const { markdown, cut } = tutorPage(site, page, lang, descriptions);
+			pages.set(`${languageRoot(lang)}${tutorPageOf(page)}`, {
+				markdown,
+				html: tutorPageDocument(markdown, site, page, lang),
+				cut
+			});
+		}
+		for (const assessment of assessments(site)) {
+			const markdown = assessmentTutorMarkdown(site, assessment, lang);
+			pages.set(`${languageRoot(lang)}${assessmentTutorOf(assessment)}`, {
+				markdown,
+				html: assessmentTutorDocument(markdown, site, lang),
+				cut: []
+			});
+		}
+	}
+	return pages;
+}
+/** The build step of an explainer: validates the content in src/ and writes every page. */
+function explainer() {
+	let root = process.cwd();
+	let command = "build";
+	let site;
+	let islands = /* @__PURE__ */ new Map();
+	let descriptions = /* @__PURE__ */ new Map();
+	let islandsChunk;
+	let devServer;
+	const load = () => site ??= loadSite(root);
+	return [vueWhenComponents(), {
+		name: "lernapps-explainer",
+		enforce: "post",
+		configResolved(config) {
+			root = config.root;
+			command = config.command;
+		},
+		async buildStart() {
+			site = void 0;
+			islands = /* @__PURE__ */ new Map();
+			descriptions = /* @__PURE__ */ new Map();
+			islandsChunk = void 0;
+			let content;
+			try {
+				content = load();
+			} catch (error) {
+				this.error(error instanceof Error ? error.message : String(error));
+			}
+			if (command !== "build" || content.components.length === 0) return;
+			const rendered = await withServer(root, (loader) => renderComponents(content, loader, true));
+			if (rendered.problems.length > 0) this.error(new ContentError(rendered.problems).message);
+			islands = rendered.islands;
+			descriptions = rendered.descriptions;
+			islandsChunk = this.emitFile({
+				type: "chunk",
+				id: ISLANDS,
+				name: "islands"
+			});
+		},
+		resolveId(id) {
+			return id === ISLANDS ? ISLANDS : void 0;
+		},
+		load(id) {
+			return id === ISLANDS ? islandsModule(load()) : void 0;
+		},
+		generateBundle(_options, bundle) {
+			const index = bundle["index.html"];
+			if (index === void 0 || index.type !== "asset") return;
+			const shell = String(index.source);
+			const content = load();
+			const script = islandsChunk === void 0 ? "" : `<script type="module" crossorigin src="./${this.getFileName(islandsChunk)}"><\/script>`;
+			for (const page of renderSite(content, islands, descriptions)) {
+				const html = fill(shell, page, page.islands ? script : "");
+				if (page.route.path === "") index.source = html;
+				else this.emitFile({
+					type: "asset",
+					fileName: `${page.route.path}index.html`,
+					source: html
+				});
+			}
+			this.emitFile({
+				type: "asset",
+				fileName: "404.html",
+				source: notFoundPage()
+			});
+			for (const [image, file] of content.images) this.emitFile({
+				type: "asset",
+				fileName: image,
+				source: readFileSync(file)
+			});
+			const problems = [];
+			const tutor = tutorAssets(content, descriptions);
+			for (const lang of content.app.languages) {
+				const files = /* @__PURE__ */ new Set([
+					...routes(content).filter((route) => route.lang === lang).map((route) => route.local),
+					...contentPages(content).map((page) => tutorPageOf(page)),
+					...assessments(content).map((assessment) => assessmentTutorOf(assessment)),
+					...[...scopeFiles(content, lang).keys()].map((folder) => `${folder}${SCOPE_PAGE}`)
+				]);
+				const anchors = new Map(contentPages(content).map((page) => [`${page.chapter}/${page.id}/`, anchorsOf(content, page)]));
+				for (const local of [...contentPages(content).map((contentPage) => tutorPageOf(contentPage)), ...assessments(content).map((assessment) => assessmentTutorOf(assessment))]) {
+					const page = tutor.get(`${languageRoot(lang)}${local}`);
+					if (page === void 0) continue;
+					problems.push(...linkProblems(local, page.markdown, files, anchors).map((problem) => `${languageRoot(lang)}${problem}`));
+					this.emitFile({
+						type: "asset",
+						fileName: `${languageRoot(lang)}${local}index.html`,
+						source: page.html
+					});
+					this.emitFile({
+						type: "asset",
+						fileName: `${languageRoot(lang)}${local}${TUTOR_MARKDOWN}`,
+						source: page.markdown
+					});
+				}
+			}
+			for (const lang of content.app.languages) for (const [folder, markdown] of scopeFiles(content, lang)) {
+				const at = `${languageRoot(lang)}${folder}${SCOPE_PAGE}`;
+				this.emitFile({
+					type: "asset",
+					fileName: `${at}${TUTOR_MARKDOWN}`,
+					source: markdown
+				});
+				this.emitFile({
+					type: "asset",
+					fileName: `${at}index.html`,
+					source: scopeDocument(markdown, inLanguage(content.app.title, lang), lang, folder)
+				});
+				if (folder === "" && bytesOf(markdown) > 64e3) this.info(`lernapps explainer: the scope of the whole app (${languageRoot(lang)}${SCOPE_PAGE}) is larger than ${TUTOR_PAGE_BUDGET / 1e3} kB (${(bytesOf(markdown) / 1e3).toFixed(0)} kB), which a tutor may get cut off`);
+			}
+			const large = [...tutor].filter(([, page]) => bytesOf(page.html) > TUTOR_PAGE_BUDGET);
+			if (large.length > 0) this.info(`lernapps explainer: ${large.length} tutor page${large.length === 1 ? " is" : "s are"} larger than ${TUTOR_PAGE_BUDGET / 1e3} kB, which a tutor may get cut off: ${large.map(([file, page]) => `${file} (${(bytesOf(page.html) / 1e3).toFixed(0)} kB)`).join(", ")}`);
+			const cut = [...tutor].flatMap(([file, page]) => page.cut.map((one) => ({
+				file,
+				...one
+			})));
+			if (cut.length > 0) this.warn(`lernapps explainer: ${cut.length} exercise${cut.length === 1 ? " shows" : "s show"} only some of ${cut.length === 1 ? "its" : "their"} task numbers on the tutor page, to stay within ${TUTOR_PAGE_BUDGET / 1e3} kB; export template, params, mistakes and show from its logic module for a table of all its numbers: ${cut.map((one) => `${one.file} ${one.id} (${one.shown} of ${one.count})`).join(", ")}`);
+			const hint = tableHint(content, descriptions);
+			if (hint !== void 0) this.info(hint);
+			const steps = stepHint(content);
+			if (steps !== void 0) this.info(steps);
+			const few = [...contentPages(content).flatMap((page) => [...allBlocks(page.blocks)].flatMap((block) => block.type === "generated" ? [[block.id, taskSeeds(block, dataOf(block, content.data)).length]] : [])), ...content.components.flatMap((use) => {
+				const seeds = descriptions.get(use.block)?.seeds;
+				return seeds === void 0 || use.id === void 0 ? [] : [[use.id, seeds.length]];
+			})].filter(([, count]) => count < 67);
+			if (few.length > 0) this.info(`lernapps explainer: ${few.length} exercise${few.length === 1 ? " has" : "s have"} fewer than 67 distinct tasks, numbered 1 to N: ${few.map(([id, count]) => `${id} (${count})`).join(", ")}`);
+			const chunks = Object.values(bundle).flatMap((output) => output.type === "chunk" ? [output] : []);
+			const folder = join(root, "src/components");
+			for (const component of new Map(content.components.map((use) => [use.component.name, use.component])).values()) {
+				const chunk = chunks.find((candidate) => candidate.facadeModuleId === component.path);
+				if (chunk === void 0) continue;
+				const own = [chunk.code, ...chunk.imports.map((file) => chunks.find((candidate) => candidate.fileName === file)).filter((imported) => imported !== void 0 && imported.moduleIds.every((id) => id.startsWith(folder))).map((imported) => imported?.code ?? "")].join("\n");
+				const size = gzipSync(own).length;
+				if (size > 2e4) problems.push(`${component.file}: ${(size / 1e3).toFixed(1)} kB gzip of its own code, more than the budget of ${SIZE_BUDGET / 1e3} kB; split it into smaller components, or ask for a built-in block (vue-component-size)`);
+			}
+			if (problems.length > 0) this.error(new ContentError(problems).message);
+		},
+		configureServer(server) {
+			devServer = server;
+			server.watcher.on("all", (_event, file) => {
+				if (file.startsWith(join(root, "src")) && !file.endsWith(".ts")) {
+					site = void 0;
+					server.ws.send({ type: "full-reload" });
+				}
+			});
+			server.middlewares.use((request, response, next) => {
+				const url = new URL(request.url ?? "/", "http://localhost");
+				const path = decodeURIComponent(url.pathname).replace(/^\//, "");
+				if (path.startsWith("images/")) {
+					response.setHeader("content-type", imageType(path));
+					response.end(readFileSync(join(root, "src", path)));
+					return;
+				}
+				const forTutor = new RegExp(`(^|/)tutor/(${TUTOR_MARKDOWN.replace(".", "\\.")})?$`).test(path);
+				const forScope = new RegExp(`(^|/)${SCOPE_PAGE}(${TUTOR_MARKDOWN.replace(".", "\\.")})?$`).test(path);
+				if (!(path === "" || path.endsWith("/") || forTutor || forScope)) return next();
+				const fail = (error) => {
+					response.statusCode = 500;
+					response.setHeader("content-type", "text/plain; charset=utf-8");
+					response.end(error instanceof Error ? error.message : String(error));
+				};
+				let content;
+				try {
+					content = load();
+				} catch (error) {
+					fail(error);
+					return;
+				}
+				const dev = devServer;
+				if (dev === void 0) return next();
+				renderComponents(content, (id) => dev.ssrLoadModule(id), false).then(({ islands: rendered, descriptions: described, problems }) => {
+					if (problems.length > 0) throw new ContentError(problems);
+					if (forScope) {
+						const markdown = path.endsWith(TUTOR_MARKDOWN);
+						const lang = content.app.languages.find((one) => languageRoot(one) !== "" && path.startsWith(languageRoot(one))) ?? content.app.languages[0] ?? "de";
+						const folder = path.slice(languageRoot(lang).length).replace(new RegExp(`${SCOPE_PAGE}(${TUTOR_MARKDOWN.replace(".", "\\.")})?$`), "");
+						const scope = scopeFiles(content, lang).get(folder);
+						if (scope === void 0) return next();
+						response.setHeader("content-type", `text/${markdown ? "markdown" : "html"}; charset=utf-8`);
+						response.end(markdown ? scope : scopeDocument(scope, inLanguage(content.app.title, lang), lang, folder));
+						return;
+					}
+					if (forTutor) {
+						const markdown = path.endsWith(TUTOR_MARKDOWN);
+						const page = tutorAssets(content, described).get(markdown ? path.slice(0, -8) : path);
+						if (page === void 0) return next();
+						response.setHeader("content-type", `text/${markdown ? "markdown" : "html"}; charset=utf-8`);
+						response.end(markdown ? page.markdown : page.html);
+						return;
+					}
+					const page = renderSite(content, rendered, described).find((candidate) => candidate.route.path === path);
+					if (page === void 0) return next();
+					const shell = readFileSync(join(root, "index.html"), "utf8");
+					const head = page.islands ? `<script type="module" src="/@id/__x00__lernapps-explainer-islands"><\/script>` : "";
+					return dev.transformIndexHtml(`/${path}`, fill(shell, {
+						...page,
+						route: {
+							...page.route,
+							path: ""
+						}
+					}, head)).then((html) => {
+						response.setHeader("content-type", "text/html; charset=utf-8");
+						response.end(html);
+					});
+				}).catch(fail);
+			});
+		}
+	}];
+}
+export { explainer, fill };