@lernapps/app-templates 0.0.0-stage → 0.1.0

package/runtime/explainer/load.ts

@@ -0,0 +1,457 @@
+// Reads an explainer's content from src/ at build time and validates it: each file against its part of the schema
+// (explainer.v1.schema.json), then what a schema cannot say. The order lists are complete and unique, the depth is
+// app, chapter, page and two section levels, ids are unique per level, every text is complete in each declared
+// language and in no other, texts hold restricted Markdown without raw HTML or headings, formulas are in the command
+// list, bundled images and quotes name source and licence, links to pages of the app find their page and section,
+// every page has an exercise, a question of the question types passes the validation of a question in every declared language,
+// a generated exercise declares what it uses and passes its property test over fixed seeds (generated.ts), the check
+// of each exercise judges its examples as they are listed, a vue-component block names a component of src/components/
+// that passes its checks (components.ts), its props match the component's prop types, it has its nojs text (an exercise
+// component's is generated from its describe) and, for an exercise component, its examples (which the build step
+// runs, plugin.ts) and an anchor once on the page (its id, or its name in kebab case), every data file is named by a timeline, a generated exercise or a component prop, and src/ holds nothing else. Each problem is one line: the file,
+// its line, the place in the file, the language where it matters, and what to do.
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { checkBlocks } from "./check-page.ts";
+import { readComponents } from "./components/read.ts";
+import {
+  isExercise,
+  type App,
+  type BlockOf,
+  type Chapter,
+  type ComponentUse,
+  type DataRecord,
+  type Page,
+  type SelfAssessment,
+  type Site,
+} from "./content.ts";
+import { allBlocks } from "./routes.ts";
+import { ASSESSMENT, drawsTasks, exerciseOf, parseRef } from "./assessment.ts";
+import { SCHEMA_FILE, validate } from "./schema.ts";
+import { appName } from "../shared/appname.ts";
+import { isObject, Problems, readYaml, Texts, type Path, type YamlFile } from "../shared/content.ts";
+import { isLanguage, LANGUAGES, languageListProblems } from "../shared/languages.ts";
+
+export { SCHEMA_ID } from "./schema.ts";
+export const RULE_URL = "https://lernapps.net/tooling/rules/#explainer-content-valid";
+
+/** What src/ may hold besides the chapter folders. */
+const SRC = "src/ holds only app.yaml, the chapter folders, data/, images/, components/ and main.ts";
+/** Chapter ids that would collide with other addresses: data files, images, the glossary, the scope, language trees. */
+const RESERVED = new Set(["data", "images", "glossar", "components", "assets", "scope", ASSESSMENT]);
+const ID = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const IMAGE = /^[a-z0-9]+(-[a-z0-9]+)*\.(svg|png|jpg|webp)$/;
+
+/** The content could not be read: one problem per line in `problems`. */
+export class ContentError extends Error {
+  readonly problems: readonly string[];
+  constructor(problems: readonly string[]) {
+    super(
+      [
+        `the explainer's content in src/ is not valid (${RULE_URL}):`,
+        ...problems.map((problem) => `  - ${problem}`),
+        `Fix the content as its schema says: ${SCHEMA_FILE}`,
+      ].join("\n"),
+    );
+    this.problems = problems;
+  }
+}
+
+/** The files and folders in `dir`, sorted. */
+const entries = (dir: string) => (existsSync(dir) ? readdirSync(dir).sort() : []);
+const isDirectory = (path: string) => statSync(path).isDirectory();
+
+/** Checks the order list `list` (at `key` of `yaml`) against the ids that exist; true when they agree. */
+function checkOrder(
+  yaml: YamlFile,
+  key: string,
+  list: readonly string[],
+  existing: readonly string[],
+  what: { one: string; folder: string; file: (id: string) => string },
+  problems: Problems,
+): boolean {
+  let ok = true;
+  list.forEach((id, index) => {
+    if (list.indexOf(id) !== index) {
+      problems.at(yaml, [key, index], `${id} is listed twice; list each ${what.one} exactly once`);
+      ok = false;
+    } else if (!existing.includes(id)) {
+      problems.at(yaml, [key, index], `${id} is listed, but ${what.file(id)} does not exist`);
+      ok = false;
+    }
+  });
+  for (const id of existing.filter((candidate) => !list.includes(candidate))) {
+    problems.at(yaml, [key], `${id} is not listed; list each ${what.one} of ${what.folder} exactly once`);
+    ok = false;
+  }
+  return ok;
+}
+
+/**
+ * The problems of the self-assessment `assessment` of `yaml`: of the app (no `chapter`), or of the chapter `chapter`,
+ * whose exercises are all its own. Each reference names a page and an exercise of it of a question type or generated;
+ * a question is listed once, a generated exercise may be listed again (each listing draws a task of its own).
+ */
+function checkAssessment(
+  yaml: YamlFile,
+  assessment: SelfAssessment,
+  chapters: readonly Chapter[],
+  chapter: string | undefined,
+  components: Site["components"],
+  problems: Problems,
+): void {
+  const seen = new Set<string>();
+  assessment.pages.forEach((step, index) => {
+    step.exercises.forEach((ref, at) => {
+      const path = ["selfAssessment", "pages", index, "exercises", at];
+      const parts = parseRef(ref);
+      if (parts === undefined) return;
+      const twice = seen.has(ref);
+      seen.add(ref);
+      if (chapter !== undefined && parts.chapter !== chapter) {
+        problems.at(
+          yaml,
+          path,
+          `${ref} is not an exercise of the chapter ${chapter}; a chapter's self-assessment asks only its own pages; the app's is every chapter's together`,
+        );
+        return;
+      }
+      const page = chapters
+        .find((candidate) => candidate.id === parts.chapter)
+        ?.pages.find((candidate) => candidate.id === parts.page);
+      if (page === undefined) {
+        problems.at(yaml, path, `${ref} names no page of the app; write /<chapter>/<page>/#<exercise>`);
+        return;
+      }
+      const exercise = exerciseOf(components, page, parts.exercise);
+      // a generated exercise or an exercise component may be listed again: each listing draws a task of its own
+      if (twice && exercise !== undefined && !drawsTasks(exercise)) {
+        problems.at(
+          yaml,
+          path,
+          `${ref} is listed twice, and a question shows the same task each time; list it once (a generated exercise or an exercise component may be listed again: each listing draws a task of its own)`,
+        );
+        return;
+      }
+      if (exercise !== undefined) return;
+      const component = components.some(
+        (use) => use.id === parts.exercise && [...allBlocks(page.blocks)].some((block) => block === use.block),
+      );
+      problems.at(
+        yaml,
+        path,
+        component
+          ? `${ref} is a component that checks no answer; choose an exercise: generated, a question type, or an exercise component`
+          : `${ref} names no exercise of ${page.file}; use the id of one of its exercises: generated, a question type, or an exercise component`,
+      );
+    });
+  });
+}
+
+/** How many seeds the property test of each generated exercise draws at build time. */
+export const SEEDS = 200;
+
+/** The problems of the content in `root`/src, and the content when there are none. */
+export function check(root: string, seeds = SEEDS): { site?: Site; problems: string[] } {
+  const problems = new Problems();
+  const src = join(root, "src");
+  if (!existsSync(join(src, "app.yaml"))) {
+    problems.file(
+      "src/app.yaml",
+      "is missing: the app's title, intro, languages and the order of its chapters belong there",
+    );
+    return { problems: problems.lines };
+  }
+
+  // what src/ holds
+  const chapterIds: string[] = [];
+  const dataFiles = new Map<string, YamlFile>();
+  for (const name of entries(src)) {
+    const path = join(src, name);
+    if (name === "app.yaml" || name === "main.ts") continue;
+    if (name === "components" && isDirectory(path)) continue;
+    if (!isDirectory(path)) {
+      problems.file(`src/${name}`, `not part of an explainer; ${SRC}`);
+    } else if (name === "images") {
+      for (const image of entries(path)) {
+        if (isDirectory(join(path, image)) || !IMAGE.test(image)) {
+          problems.file(
+            `src/images/${image}`,
+            "not an image of an explainer; src/images/ holds image files <name>.svg, .png, .jpg or .webp, with a lower-case name",
+          );
+        }
+      }
+    } else if (name === "data") {
+      for (const file of entries(path)) {
+        const id = file.replace(/\.yaml$/, "");
+        if (isDirectory(join(path, file)) || !file.endsWith(".yaml") || !ID.test(id)) {
+          problems.file(
+            `src/data/${file}`,
+            "not a data file; src/data/ holds data files <name>.yaml, with a lower-case name",
+          );
+          continue;
+        }
+        const yaml = readYaml(root, `src/data/${file}`, problems);
+        if (yaml !== undefined && validate(yaml, "data", problems)) dataFiles.set(id, yaml);
+      }
+    } else if (!ID.test(name)) {
+      problems.file(
+        `src/${name}/`,
+        `the folder's name is the chapter's id: use lower-case letters, digits and hyphens`,
+      );
+    } else if (RESERVED.has(name) || /^[a-z]{2}$/.test(name)) {
+      problems.file(
+        `src/${name}/`,
+        `${name} is reserved for the app's addresses (data, images, glossar, components, assets, ${ASSESSMENT} and two-letter language codes); rename the chapter`,
+      );
+    } else chapterIds.push(name);
+  }
+
+  // the components, read with Vue's SFC compiler only when there are any
+  const components = existsSync(join(src, "components")) ? readComponents(root) : undefined;
+  for (const problem of components?.problems ?? []) problems.add(problem);
+
+  // the app
+  const appYaml = readYaml(root, "src/app.yaml", problems);
+  if (appYaml === undefined || !validate(appYaml, "app", problems)) return { problems: problems.lines };
+  const app = appYaml.value as App;
+  const languageList = languageListProblems(app.languages, LANGUAGES);
+  for (const problem of languageList) {
+    problems.at(appYaml, ["languages", Math.max(app.languages.lastIndexOf(problem.lang), 0)], problem.message);
+  }
+  if (languageList.length > 0) return { problems: problems.lines };
+  const texts = new Texts(app.languages, problems);
+  texts.check(appYaml, ["title"], "plain");
+  texts.check(appYaml, ["intro"], "markdown");
+  texts.check(appYaml, ["tutor", "rules"], "markdown");
+  app.sources?.forEach((_source, index) => texts.check(appYaml, ["sources", index, "title"], "plain"));
+  // a text by language anywhere in a record, also in the lists and records of a record: a map of strings with a
+  // language among its keys; a record whose fields are all texts ({ name: Geige, familie: Streicher }) is no text
+  const checkDataTexts = (yaml: YamlFile, path: (string | number)[], value: unknown): void => {
+    if (Array.isArray(value)) value.forEach((item, index) => checkDataTexts(yaml, [...path, index], item));
+    else if (isObject(value)) {
+      const fields = Object.entries(value);
+      if (fields.every(([, field]) => typeof field === "string") && fields.some(([key]) => isLanguage(key))) {
+        texts.check(yaml, path, "plain");
+      } else for (const [field, item] of fields) checkDataTexts(yaml, [...path, field], item);
+    }
+  };
+  for (const yaml of dataFiles.values()) {
+    (yaml.value as DataRecord[]).forEach((record, index) => checkDataTexts(yaml, [index], record));
+  }
+  const chaptersOk = checkOrder(
+    appYaml,
+    "chapters",
+    app.chapters,
+    chapterIds,
+    { one: "chapter", folder: "src/", file: (id) => `src/${id}/` },
+    problems,
+  );
+
+  // the chapters and their pages
+  const terms = new Map<string, string>();
+  const images = new Map<string, string>();
+  const anchors = new Map<string, Set<string>>();
+  const uses: ComponentUse[] = [];
+  const dataUsed = new Set<string>();
+  // false once a chapter or page could not be read: what it names is unknown, so no data file counts as unused
+  let complete = true;
+  const chapters: Chapter[] = [];
+  const chapterFiles = new Map<string, YamlFile>();
+  for (const chapterId of chaptersOk ? app.chapters : chapterIds) {
+    const folder = join(src, chapterId);
+    const pageIds: string[] = [];
+    for (const name of entries(folder)) {
+      const file = `src/${chapterId}/${name}`;
+      if (name === "chapter.yaml") continue;
+      if (isDirectory(join(folder, name))) {
+        problems.file(
+          `${file}/`,
+          "a folder inside a chapter; an explainer goes app, chapter, page, and two section levels inside a page: split the app",
+        );
+      } else if (!name.endsWith(".yaml")) {
+        problems.file(
+          file,
+          `not part of an explainer; a chapter folder holds only chapter.yaml and its pages <page>.yaml`,
+        );
+      } else if (!ID.test(name.slice(0, -".yaml".length))) {
+        problems.file(file, `the file's name is the page's id: use lower-case letters, digits and hyphens`);
+      } else if (name === `${ASSESSMENT}.yaml`) {
+        problems.file(file, `${ASSESSMENT} is reserved for the chapter's self-assessment; rename the page`);
+      } else {
+        const pageId = name.slice(0, -".yaml".length);
+        pageIds.push(pageId);
+      }
+    }
+    if (!existsSync(join(folder, "chapter.yaml"))) {
+      problems.file(
+        `src/${chapterId}/chapter.yaml`,
+        "is missing: a chapter folder needs its chapter.yaml with its title and the order of its pages",
+      );
+      complete = false;
+      continue;
+    }
+    const chapterYaml = readYaml(root, `src/${chapterId}/chapter.yaml`, problems);
+    if (chapterYaml === undefined || !validate(chapterYaml, "chapter", problems)) {
+      complete = false;
+      continue;
+    }
+    const chapter = chapterYaml.value as Omit<Chapter, "id" | "pages"> & { pages: string[] };
+    chapterFiles.set(chapterId, chapterYaml);
+    texts.check(chapterYaml, ["title"], "plain");
+    texts.check(chapterYaml, ["summary"], "markdown");
+    const pagesOk = checkOrder(
+      chapterYaml,
+      "pages",
+      chapter.pages,
+      pageIds,
+      { one: "page", folder: `src/${chapterId}/`, file: (id) => `src/${chapterId}/${id}.yaml` },
+      problems,
+    );
+    const pages: Page[] = [];
+    for (const pageId of pagesOk ? chapter.pages : pageIds) {
+      const file = `src/${chapterId}/${pageId}.yaml`;
+      const yaml = readYaml(root, file, problems);
+      if (yaml === undefined || !validate(yaml, "page", problems)) {
+        complete = false;
+        continue;
+      }
+      const page = yaml.value as Omit<Page, "id" | "chapter" | "file">;
+      texts.check(yaml, ["title"], "plain");
+      texts.check(yaml, ["description"], "plain");
+      const pageAnchors = new Set<string>();
+      const exercises = new Map<string, Path>();
+      checkBlocks(
+        {
+          yaml,
+          texts,
+          problems,
+          root,
+          dataFiles,
+          terms,
+          images,
+          anchors: pageAnchors,
+          exercises,
+          seeds,
+          components,
+          uses,
+          dataUsed,
+        },
+        page.blocks,
+        ["blocks"],
+        0,
+      );
+      if (![...allBlocks(page.blocks)].some(isExercise)) {
+        problems.at(
+          yaml,
+          ["blocks"],
+          "the page has no exercise; give it a section with an exercise: one of the question types, or generated",
+        );
+      }
+      for (const [id, path] of exercises) {
+        if (pageAnchors.has(id)) {
+          problems.at(
+            yaml,
+            [...path, "id"],
+            `${id} is also the anchor of a section of this page; give the exercise its own id`,
+          );
+        }
+        pageAnchors.add(id);
+      }
+      anchors.set(`/${chapterId}/${pageId}/`, pageAnchors);
+      pages.push({ ...page, id: pageId, chapter: chapterId, file });
+    }
+    chapters.push({
+      id: chapterId,
+      title: chapter.title,
+      ...(chapter.summary === undefined ? {} : { summary: chapter.summary }),
+      ...(chapter.selfAssessment === undefined ? {} : { selfAssessment: chapter.selfAssessment }),
+      ...(chapter.scope === undefined ? {} : { scope: chapter.scope }),
+      pages,
+    });
+  }
+
+  // the self-assessments: each exercise found, checkable, in its scope and listed once
+  if (complete) {
+    for (const chapter of chapters) {
+      const yaml = chapterFiles.get(chapter.id);
+      if (chapter.selfAssessment === undefined || yaml === undefined) continue;
+      checkAssessment(yaml, chapter.selfAssessment, chapters, chapter.id, uses, problems);
+    }
+  }
+
+  // a data file that nothing names is dead: the author believes its content is in the app
+  if (complete) {
+    for (const id of dataFiles.keys()) {
+      if (dataUsed.has(id)) continue;
+      problems.file(
+        `src/data/${id}.yaml`,
+        `never used; no timeline, generated exercise or component prop names { data: ${id} }. Use it, or remove it (explainer-unused-data)`,
+      );
+    }
+  }
+
+  // links to pages of the app
+  const hidden = app.chapters.length === 1;
+  for (const link of texts.links) {
+    const [path = "", hash] = link.href.split("#");
+    const pageAnchors = anchors.get(path);
+    const generated =
+      path === "/" ||
+      (path === "/glossar/" && terms.size > 0) ||
+      (!hidden && app.chapters.some((id) => path === `/${id}/`));
+    if (pageAnchors === undefined && !generated) {
+      problems.at(
+        link.yaml,
+        link.path,
+        `the link ${link.href} leads to no page of the app; write /<chapter>/<page>/, or /<chapter>/<page>/#<section>`,
+        link.lang,
+      );
+    } else if (hash !== undefined && hash !== "" && (pageAnchors === undefined || !pageAnchors.has(hash))) {
+      problems.at(link.yaml, link.path, `the link ${link.href} leads to no section of its page`, link.lang);
+    }
+  }
+
+  // the scope for the tutor: with the app's, every page has its own; a page's without the app's would be lost
+  for (const chapter of chapters) {
+    for (const page of chapter.pages) {
+      if (app.scope !== undefined && page.scope === undefined) {
+        problems.file(
+          page.file,
+          "has no scope; src/app.yaml has one, so each page says in scope: what it teaches, in your own words from the material",
+        );
+      } else if (app.scope === undefined && page.scope !== undefined) {
+        problems.file(
+          page.file,
+          "has a scope, but src/app.yaml has none; add scope: { out: [...] } to src/app.yaml, what does not belong to the scope",
+        );
+      }
+    }
+  }
+
+  if (problems.lines.length > 0) return { problems: problems.lines };
+  const data: Record<string, DataRecord[]> = {};
+  for (const [id, yaml] of dataFiles) data[id] = yaml.value as DataRecord[];
+  return {
+    site: {
+      app,
+      chapters,
+      data,
+      images,
+      components: uses,
+      storage: appName(root, "explainer"),
+    },
+    problems: [],
+  };
+}
+
+/**
+ * The content in `root`/src, its generated exercises tested over `seeds` seeds (0: not at all, for a reader of content
+ * the build has checked); throws a ContentError with every problem when it is not valid. */
+export function loadSite(root: string, seeds = SEEDS): Site {
+  const { site, problems } = check(root, seeds);
+  if (site === undefined) throw new ContentError(problems);
+  return site;
+}
+
+export type { BlockOf };

package/runtime/explainer/messages/de.json

@@ -0,0 +1,200 @@
+{
+  "language": "Deutsch",
+  "languages": "Sprache",
+  "start": "Start",
+  "breadcrumbs": "Du bist hier",
+  "contents": "Inhalt",
+  "onThisPage": "Auf dieser Seite",
+  "pages": "Seiten",
+  "chapters": "Kapitel",
+  "pager": "Weiterblättern",
+  "previous": "Zurück: {title}",
+  "next": "Weiter: {title}",
+  "glossary": "Glossar",
+  "glossaryIntro": "Die Begriffe dieser App, von A bis Z, jeder mit der Seite, die ihn erklärt.",
+  "inGlossary": "im Glossar",
+  "explainedOn": "Erklärt auf der Seite {page}",
+  "sources": "Quellen",
+  "sourcesIntro": "Die Fakten in dieser App stammen aus diesen Quellen:",
+  "beforeChrist": "{year} v. Chr.",
+  "code": "Code in {language}",
+  "footer": "Eine Erklär-App auf lernapps.net",
+  "imprint": "Impressum",
+  "privacy": "Datenschutz",
+  "workedTasks": "Drei Beispielaufgaben, jede mit ihrer Lösung:",
+  "practice": "Übe selbst, mit immer neuen Aufgaben:",
+  "newTask": "Neue Aufgabe",
+  "hint": "Tipp",
+  "textDescription": "Beschreibung als Text",
+  "taskNumber": "Aufgabe Nr. {n}",
+  "backToTutor": "Zurück zum Tutor",
+  "backToTutorOpen": "Wechsel zurück zum Chat mit {name}.",
+  "backToTutorCopied": "Wechsel zurück zu {name} und füg es dort ein. Diesen Tab kannst du offen lassen.",
+  "backToTutorFailed": "Kopieren ging nicht. Kopier die markierten Zeilen, wechsel zurück zu {name} und füg sie dort ein.",
+  "resultLabel": "Ergebniszeile für deinen Tutor",
+  "resultLine": "{page}, {exercise}{number}: {status}.",
+  "resultNumber": ", Nr. {n}",
+  "resultRight": "richtig im {n}. Versuch",
+  "resultSolution": "Lösung angesehen",
+  "resultOpen": "noch nicht gelöst",
+  "resultTry": "1 Versuch",
+  "resultTries": "{n} Versuche",
+  "resultInput": "Eingabe {input}",
+  "resultSession": "Sitzung: {right} von {total} richtig.",
+  "resultTutor": "Tutor-Seite:",
+  "resultTrue": "stimmt",
+  "resultFalse": "stimmt nicht",
+  "stuckAsk": "Lade {url} und hilf mir bei Übung {exercise}{number}. Ich komme nicht weiter.",
+  "stuckTask": "Übung {exercise}{number}:",
+  "stuckInput": "Ich habe {input} eingegeben ({tries}).",
+  "stuckTries": "Bisher {tries}.",
+  "stuckRight": "Ich habe sie im {n}. Versuch richtig gelöst.",
+  "stuckMessage": "Die App sagt: „{message}“",
+  "stuckHint": "Ich habe den Tipp geöffnet.",
+  "stuckSolution": "Ich habe mir die Lösung angesehen.",
+  "stuckPrivacy": "„Warum?“ gibt {name} mit deinem Klick die Aufgabe, deine Eingabe und die Meldung der App.",
+  "stuckPrivacyCopy": "Dein Klick kopiert die Aufgabe, deine Eingabe und die Meldung der App für den Chat mit deinem Tutor; die App schickt nichts weg.",
+  "stuckCopied": "Wechsel zurück zu {name} und füg die Zeilen dort ein.",
+  "stuckFailed": "Kopieren ging nicht. Kopier die markierten Zeilen, wechsel zurück zu {name} und füg sie dort ein.",
+  "stuckLabel": "Zeilen für deinen Tutor",
+  "tutorTitle": "Mit einem KI-Tutor lernen",
+  "tutorAbout": "Ein KI-Tutor ist ein KI-Assistent deiner Wahl, der dich beim Lernen mit dieser App begleitet. Er erklärt dir den Stoff mit den Beispielen der Seiten, gibt dir Aufgaben aus der App und hilft dir, wenn du nicht weiterkommst. Gelöst wird in der App: Sie prüft deine Antworten.",
+  "tutorAboutStart": "Wähl hier deinen Assistenten. Dann steht er auf jeder Seite unter dem Titel bereit, und jede Übung hat den Knopf „Hilfe“. Du kannst ihn auch auf einer Seite unter dem Titel einschalten.",
+  "tutorAboutPrivacy": "Deine Wahl bleibt auf diesem Gerät; erst dein Klick öffnet den Assistenten. Frag deine Eltern oder Lehrkraft, ob du ihn nutzen darfst.",
+  "tutorAccount": "Du nutzt dein eigenes Konto beim Anbieter. Der Assistent ist kein Angebot von lernapps.net: lernapps liefert nur Inhalte und Übungen.",
+  "tutorScope": "Die Wahl gilt für alle Seiten, nur auf diesem Gerät.",
+  "tutorChoose": "Dein KI-Assistent",
+  "tutorNone": "Keiner",
+  "needsTitle": "Was dir beim Lernen hilft",
+  "needsOpen": "Einstellungen",
+  "needsDone": "Fertig",
+  "needsAbout": "Hier kannst du deinem Tutor sagen, wie er mit dir sprechen soll. Kreuz an, was dir hilft; du kannst mehreres wählen.",
+  "needKurzeSchritte": "Kurze Schritte",
+  "needKurzeSchritteAbout": "Der Tutor erklärt in kleinen Schritten, immer nur eine Sache auf einmal. Du weißt immer, wie weit es noch ist.",
+  "needWenigLesen": "Wenig lesen",
+  "needWenigLesenAbout": "Der Tutor schreibt sehr kurz und einfach und erklärt jedes Fachwort. Tipp: Lass dir seine Antworten vorlesen und sprich deine Antwort ein.",
+  "needMehrTiefe": "Mehr Tiefe",
+  "needMehrTiefeAbout": "Der Tutor überspringt, was du schon kannst, und stellt dir knifflige Warum- und Was-wäre-wenn-Fragen.",
+  "needAndereMuttersprache": "Andere Muttersprache",
+  "needAndereMutterspracheAbout": "Der Tutor erklärt auf Deutsch in einfachen Sätzen und übersetzt neue Fachwörter in deine Sprache. Du darfst auch in deiner Sprache schreiben.",
+  "needKlarUndWoertlich": "Klar und wörtlich",
+  "needKlarUndWoertlichAbout": "Der Tutor schreibt genau das, was er meint: ohne Witze, versteckte Bedeutungen oder Redewendungen. Er sagt dir immer, wo ihr gerade seid.",
+  "needRechnenAnschaulich": "Rechnen anschaulich",
+  "needRechnenAnschaulichAbout": "Der Tutor zeigt dir, wie viel eine Zahl ist, und erklärt in kleinen Schritten. Du rechnest selbst und hast so viel Zeit, wie du brauchst.",
+  "needsLanguage": "Deine Muttersprache",
+  "needsLanguageNone": "Bitte wählen",
+  "needsScopeTitle": "Das gilt",
+  "needsScopeAll": "für alle Erklär-Apps auf lernapps.net",
+  "needsScopeApp": "nur für diese App",
+  "needsPrivacy": "Deine Wahl bleibt auf diesem Gerät. Der Tutor bekommt nur die Namen der Einstellungen, die du ankreuzt, und erst, wenn du ihn öffnest.",
+  "tutorOther": "Ein anderer: Text kopieren",
+  "tutorOn": "Einschalten",
+  "tutorSomeone": "deinen KI-Tutor",
+  "help": "Hilfe",
+  "helpWhy": "Warum?",
+  "helpBack": "Zurück",
+  "helpLabel": "{name} um Hilfe bitten",
+  "helpWhyLabel": "{name} fragen, warum",
+  "helpBackLabel": "Zurück zu {name}",
+  "tutorCopy": "Text kopieren",
+  "tutorOpenWith": "Mit {name} öffnen",
+  "tutorGo": "Mit {name} lernen",
+  "tutorWay": "Assistent",
+  "tutorPageIntro": "Ein KI-Tutor erklärt dir diese Seite und hilft dir bei den Übungen. Wähl deinen Assistenten:",
+  "tutorPageLink": "Ansehen, was dein Tutor zu dieser Seite bekommt",
+  "tutorPasteHint": "{name} lädt keine Webseiten, wenn der Link aus einem Knopf kommt. Darum kopieren wir den Satz mit dem Link für dich. Ein Klick auf „Mit {name} lernen“ öffnet {name} mit einer kurzen Nachricht. Füg danach den kopierten Satz ein (Strg+V, am Mac ⌘+V) und schick ihn ab.",
+  "tutorDone": "✓ Kopiert – jetzt in {name} einfügen",
+  "tutorCopied": "Der Prompt ist kopiert. Füg ihn in den Chat deines KI-Assistenten ein.",
+  "tutorCopyFailed": "Kopieren ging nicht. Versuch es noch einmal.",
+  "exerciseLabel": "Übung",
+  "videoChannel": "{channel} · YouTube",
+  "videoNote": "Beim Abspielen gehen Daten an YouTube/Google, darunter deine IP-Adresse.",
+  "videoPlay": "Video abspielen",
+  "videoAlways": "Videos immer direkt laden",
+  "assessmentTitle": "Selbsteinschätzung",
+  "assessmentOfferTitle": "Was kannst du schon?",
+  "assessmentOfferApp": "Freiwillig: Bevor du anfängst, kannst du {count} Aufgaben aus dieser App lösen. Am Ende siehst du für jede Seite, ob du sie dir genauer ansehen solltest.",
+  "assessmentOfferChapter": "Freiwillig: Bevor du anfängst, kannst du {count} Aufgaben aus diesem Kapitel lösen. Am Ende siehst du für jede Seite, ob du sie dir genauer ansehen solltest.",
+  "assessmentOfferStart": "Selbsteinschätzung starten",
+  "assessmentOfferLast": "Dein letztes Ergebnis ansehen",
+  "assessmentIntro": "Mit dieser Selbsteinschätzung bekommst du mit {count} Aufgaben einen Überblick, was du schon kannst.",
+  "assessmentAllAsked": "Sie fragt jede Seite ab.",
+  "assessmentLeftOut": "{n} Seiten fragt sie nicht ab. Es lohnt sich also, sie einmal anzuschauen:",
+  "assessmentLeftOutOne": "Eine Seite fragt sie nicht ab. Es lohnt sich also, sie einmal anzuschauen:",
+  "assessmentHow": "Die App sagt dir nicht bei jeder Aufgabe, ob sie stimmt. Erst am Ende siehst du für jede abgefragte Seite, ob du sie schon kannst. Was du leer lässt, zählt als nicht gekonnt.",
+  "assessmentPrivacy": "Dein Ergebnis bleibt nur auf diesem Gerät. Ein neuer Start ersetzt es.",
+  "assessmentBegin": "Los geht's",
+  "assessmentStep": "Seite {n} von {count}",
+  "assessmentTask": "Aufgabe {n}",
+  "assessmentBack": "Zurück",
+  "assessmentNext": "Weiter",
+  "assessmentFinish": "Auswerten",
+  "assessmentResultTitle": "Dein Ergebnis",
+  "assessmentScore": "Du hast {right} von {total} Aufgaben richtig gelöst.",
+  "assessmentScorePartly": "Du hast {right} von {total} Aufgaben richtig gelöst und {partly} teilweise.",
+  "assessmentAdvice": "Fang mit den Seiten an, die du genau lesen solltest.",
+  "assessmentAllKnown": "Die abgefragten Seiten kannst du wahrscheinlich schon. Üb trotzdem auf den Seiten, damit es sicher sitzt.",
+  "assessmentKnown": "Kannst du wahrscheinlich schon",
+  "assessmentPartly": "Schau sie dir noch einmal an",
+  "assessmentRead": "Lies sie genau",
+  "assessmentUnasked": "Nicht abgefragt",
+  "assessmentPageScore": "{right} von {total} richtig",
+  "assessmentPageScorePartly": "{right} von {total} richtig, {partly} teilweise",
+  "assessmentRestart": "Neu starten",
+  "assessmentDelete": "Ergebnis löschen",
+  "assessmentDeleted": "Das Ergebnis ist gelöscht.",
+  "assessmentTutorTitle": "Mit einem KI-Tutor weiterlernen",
+  "assessmentTutorIntro": "Ein KI-Tutor kann mit deinem Ergebnis die Seiten mit dir durchgehen, die noch nicht sitzen. Dein Klick gibt ihm das Ergebnis und deine Eingaben; sonst schickt die App nichts weg.",
+  "assessmentTutorGo": "Mit {name} besprechen",
+  "assessmentTutorPage": "Ansehen, was dein Tutor bekommt",
+  "assessmentNojs": "Die Selbsteinschätzung braucht JavaScript.",
+  "assessmentAsk": "Lade {url} und sei mein Tutor. Ich habe die Selbsteinschätzung gemacht. Mein Ergebnis je Seite:",
+  "assessmentLine": "{key} ({page}, Übung {exercise}{number}): {state}.",
+  "assessmentRight": "richtig",
+  "assessmentPartlyRight": "teilweise richtig",
+  "assessmentWrong": "falsch",
+  "assessmentOpen": "nicht beantwortet",
+  "assessmentInput": "Eingabe: {input}",
+  "assessmentMissed": "Nicht erreicht: {points}.",
+  "assessmentPageLine": "„{page}“: {band} ({right} von {total} richtig).",
+  "assessmentPageLinePartly": "„{page}“: {band} ({right} von {total} richtig, {partly} teilweise).",
+  "assessmentPageUnasked": "„{page}“: nicht abgefragt.",
+  "assessmentTasks": "Meine Aufgaben:",
+  "assessmentBackIntro": "Drück „Zurück zum Tutor“. Das kopiert dein Ergebnis. Füg es im Chat mit deinem Tutor ein.",
+  "assessmentBackLine": "Ich habe die Selbsteinschätzung gemacht. Mein Ergebnis je Seite:",
+  "assessmentTutorRun": "Diese Runde ist für deinen Tutor: Die App speichert nichts davon.",
+  "sessionIntro": "Ich habe auf {url} geübt:",
+  "sessionNone": "Ich habe auf {url} noch keine Aufgabe gelöst.",
+  "sessionTask": "{exercise}{number}: {status}.",
+  "assessmentNextRound": "Link für eine neue Runde: {url}",
+  "assessmentLinks": "Links für meinen Tutor, genau diese nehmen:",
+  "assessmentLinkChapter": "Kapitel „{chapter}“, Selbsteinschätzung: {url}",
+  "assessmentLinkChapterNone": "Kapitel „{chapter}“ (keine Selbsteinschätzung):",
+  "assessmentLinkPage": "„{page}“: {url}",
+  "assessmentLinkWhole": "Selbsteinschätzung der ganzen App: {url}",
+  "backToTutorDone": "✓ Kopiert",
+  "tutorSomeoneTo": "deinem KI-Tutor",
+  "openTaskLabel": "Offene Aufgabe",
+  "openTaskPoints": "Eine gute Antwort enthält:",
+  "openTaskForm": "Form",
+  "openTaskSource": "Nachlesen",
+  "openTaskChoice": "Deine Lösung",
+  "openTaskType": "Hier tippen",
+  "openTaskPaper": "Auf Papier, dann Foto",
+  "openTaskAnswer": "Deine Antwort",
+  "openTaskPaperHow": "Schreib deine Antwort auf ein Blatt. Dann fotografiere es.",
+  "openTaskPhoto": "Blatt fotografieren",
+  "openTaskPhotoAgain": "Neues Foto",
+  "openTaskPhotoAlt": "Foto deines Blatts",
+  "openTaskPhotoLocal": "Das Foto bleibt auf diesem Gerät: Die App speichert und sendet es nicht.",
+  "openTaskCompare": "Vergleichen",
+  "openTaskWriteFirst": "Schreib zuerst deine Antwort. Dann kannst du vergleichen.",
+  "openTaskPhotoFirst": "Fotografiere zuerst dein Blatt. Dann kannst du vergleichen.",
+  "openTaskCheck": "Was steht in deiner Antwort?",
+  "openTaskCheckHow": "Hake ab, was du wirklich geschrieben hast.",
+  "openTaskChange": "Antwort ändern",
+  "openTaskLocked": "Die Lösung öffnet sich nach deiner Antwort.",
+  "resultPartly": "teilweise richtig ({n} von {total} Punkten, es fehlen {missed})",
+  "resultPhoto": "Antwort als Foto",
+  "resultAnswer": "Antwort „{input}“"
+}