@lernapps/app-templates 0.0.1 → 0.1.0

package/docs/arc42/05-building-blocks.arc42.md

@@ -0,0 +1,307 @@
+# Building Blocks
+
+The generic part has three roots that every app shares, whatever its archetype: the shared runtime of
+`@lernapps/app-templates`, the tooling helpers of `@lernapps/tooling` and the skills the app commits. Each archetype's extension adds the rest of
+level 1 (`quiz/docs/arc42/`, `explainer/docs/arc42/`, `interactive/docs/arc42/`): its runtime `bb-archetype-runtime`
+with the parts `bb-build`, `bb-validation`, `bb-render`, `bb-shell`, `bb-e2e` and `bb-runtime-texts`, which every
+extension defines under these ids, and the parts the creator writes, one of which provides `if-archetype-content`.
+Parts that only some archetypes have (component rules, question types, tutor handoff, task numbers, exercise contract)
+are in the extensions that use them. Not built and not in the frame now: a loading indicator (`dec-no-size-limit`) and
+a settings dialog (`dec-no-settings`).
+
+Paths are relative to the root of `lernapps/app-templates`. The parts in a template folder carry their path with the
+folder as prefix (`interactive/src/core`); an app that gets this architecture as a copy has them without it
+(`src/core`). An app's architecture is this part followed by its archetype's extension, chapter by chapter; so the
+level-1 view of a whole app is in its extension.
+
+## Level 1: the generic roots
+
+```arc42
+:::diagram
+id: building-blocks-generic
+view: building-block
+notation: mermaid
+:::
+```
+
+```mermaid
+flowchart TB
+    subgraph bb-runtime["Shared runtime (runtime/shared)"]
+        bb-blocks["Content blocks (runtime/shared/blocks)"]
+    bb-questions["Questions (runtime/shared/questions)"]
+    bb-component-rules["Component rules (runtime/shared/vue-code.ts)"]
+    end
+    bb-tooling["Tooling helpers (@lernapps/tooling)"]
+    bb-skills["Skills (.agents/skills)"]
+```
+
+## Shared runtime
+
+Built. The code the archetypes' runtimes share: the page trees, German at the root and every other language below
+`/<language>/`, with alternates, a language switch of plain links and the 404 page, which leads every address the
+app does not have to its start page (`pages.ts`); learner texts by language (`languages.ts`); the examples check,
+which runs an exercise's accepted and rejected examples through the check the page uses, for the quiz and the
+explainer (`examples.ts`); the content as YAML, with its problems placed at file, line and path, the errors of a schema
+as problems and the checks of the texts (`content.ts`); restricted Markdown and formulas (`text/`); the checks of the
+code of Vue components (`vue-code.ts`); HTML escaping (`html.ts`); the frame of every page, with its colours in the light and the dark scheme, its header with the language switch and its footer (`page.css`, `pages.ts`); the content blocks (`blocks/`); the questions, their six types with checker, schema, validation, rendering, engine, end-to-end
+helpers and texts, which the quiz and the explainer's exercises both use (`questions/`); Vue at build for the archetypes with components (`vue.ts`); and the app's name, the prefix
+of what it stores (`appname.ts`). The app never edits it.
+
+```arc42
+:::building-block
+id: bb-runtime
+title: Shared runtime
+path: runtime/shared
+technology: TypeScript
+implements: concept-languages, concept-readable-without-js
+:::
+```
+
+### Shared runtime modules
+
+The archetype's runtime imports them at build and in its tests.
+
+```arc42
+:::interface
+id: if-shared-runtime
+title: Page trees, languages, examples check, Vue at build
+provider: bb-runtime
+protocol: TypeScript imports (runtime/shared)
+path: runtime/shared
+:::
+```
+
+### Content blocks
+
+Built in the shared runtime, for every archetype that shows content with its questions or on its pages: prose, a
+formula, a figure (drawn from data, or a bundled image of `src/images/`), a labelled figure, a table, a quotation and
+program code, with the credit of an image or a quotation. Their types, their schema, their checks (what the schema
+cannot say, every text complete in the declared languages), their rendering at build and their look; the quiz shows
+them as the `material` of a question, the explainer as blocks of a page.
+
+```arc42
+:::building-block
+id: bb-blocks
+title: Content blocks
+parent: bb-runtime
+path: runtime/shared/blocks
+technology: TypeScript
+:::
+```
+
+#### Content blocks interface
+
+The validation and the rendering of an archetype with content blocks use their types, checks and renderer.
+
+```arc42
+:::interface
+id: if-blocks
+title: The content blocks (checkMaterial, renderMaterial, materialIn)
+provider: bb-blocks
+protocol: TypeScript imports (runtime/shared/blocks), @lernapps/app-templates/blocks
+path: runtime/shared/blocks
+:::
+```
+
+### Questions
+
+Built in the shared runtime, for every archetype that has questions: the six question types and what counts as a right
+answer, at build, in the browser and in the tests alike, with their schema, validation, rendering, engine, end-to-end
+helpers and texts. The quiz asks them; the explainer's quiz-type exercises and the answers of its generated exercises
+use the same. Neither archetype imports the other.
+
+```arc42
+:::building-block
+id: bb-questions
+title: Questions
+parent: bb-runtime
+path: runtime/shared/questions
+technology: TypeScript
+:::
+```
+
+#### Questions interface
+
+The validation, the rendering, the client module and the tests of an archetype with questions use their types,
+rendering, engine and checker.
+
+```arc42
+:::interface
+id: if-questions
+title: The question types, rendering, engine and checker
+provider: bb-questions
+protocol: TypeScript imports (runtime/shared/questions), @lernapps/app-templates/questions
+path: runtime/shared/questions
+:::
+```
+
+### Component rules
+
+Built in the shared runtime, for every archetype that has Vue components: code checks on the SFC compiler's output of a
+component and the modules of the app it imports (no network, no `eval`, `innerHTML` or `v-html`, imports only from Vue,
+the runtime, the storage, i18n and a11y helpers and the app's own modules, never from a URL, browser globals only once
+mounted). Which modules are the app's own is the archetype's scope: the explainer's components import their own folder,
+the interactive archetype's any file of `src/` and the libraries of its `package.json`.
+
+```arc42
+:::building-block
+id: bb-component-rules
+title: Component rules
+parent: bb-runtime
+path: runtime/shared/vue-code.ts
+technology: TypeScript, Vue SFC compiler
+implements: concept-component-rules
+:::
+```
+
+#### Component rules interface
+
+The validation of an archetype with components runs the checks on its components.
+
+```arc42
+:::interface
+id: if-component-rules
+title: The code checks of a component (codeProblems, with the archetype's scope)
+provider: bb-component-rules
+protocol: TypeScript imports (runtime/shared/vue-code.ts)
+path: runtime/shared/vue-code.ts
+:::
+```
+
+## Tooling helpers
+
+Built. The parts of `@lernapps/tooling` every app uses, so that rules, helpers and guidance reach the app through
+updates without edits: the preset (`archetypes/shared/preset.ts`: lint with the lernapps rules, type check, format,
+unit tests, the pre-commit staged files, a build with relative URLs); the lint rules (`lint/rules`: learner texts
+German, no request before a click, storage through the wrapper, the Vue component rules); `lernapps check` (`check/`:
+accessible, usable at 360 px, no request before a click, no tracking, links and entry links resolve, and the
+end-to-end tests before a push); the Playwright configuration (`archetypes/shared/playwright.ts`: Chromium at desktop
+width and 360 px on a free port); the small storage (`archetypes/shared/storage.ts`); the announcer and focus helpers
+(`archetypes/shared/a11y.ts`); and i18n (`archetypes/shared/i18n.ts`). The skills are a block of their own
+(`bb-skills`), which the tooling's `skills/` folder is the source of. A large storage (IndexedDB) is left out (`dec-small-storage`).
+
+```arc42
+:::ignore H014 @lernapps/tooling is installed in node_modules (node_modules/@lernapps/tooling), which git does not track, and the validator resolves paths only among tracked files (E011)
+:::
+:::building-block
+id: bb-tooling
+title: Tooling helpers
+technology: TypeScript, vite-plus, Playwright (@lernapps/tooling, an optional peer of this package)
+implements: concept-accessibility, concept-component-rules, concept-device-storage, concept-languages, concept-readable-without-js
+:::
+```
+
+### Preset interface
+
+The app's vite.config.ts calls `lernapps({ plugins: [<archetype>()] })`; the archetype's runtime uses the preset for
+its own Vite servers.
+
+```arc42
+:::ignore H014 the interface is in @lernapps/tooling, installed in the untracked node_modules (archetypes/shared/preset.ts)
+:::
+:::interface
+id: if-preset
+title: lernapps() preset
+provider: bb-tooling
+protocol: TypeScript import, @lernapps/tooling/preset
+:::
+```
+
+### Check command
+
+The creator's assistant, the pre-push hook and CI run `lernapps check`; its report names each rule that failed.
+`arc42 validate` in the check is decided, not built.
+
+```arc42
+:::ignore H014 the interface is in @lernapps/tooling, installed in the untracked node_modules (check/)
+:::
+:::interface
+id: if-lernapps-check
+title: lernapps check command
+provider: bb-tooling
+protocol: CLI, validation report
+:::
+```
+
+### Device storage interface
+
+Load, save and remove JSON values through `createStorage`, under the app's prefix in `localStorage`; every access is
+wrapped, so the app keeps working when storage is blocked or full. The decided quota of 100 kB per app is not built.
+
+```arc42
+:::ignore H014 the interface is in @lernapps/tooling, installed in the untracked node_modules (archetypes/shared/storage.ts)
+:::
+:::interface
+id: if-device-storage
+title: createStorage(app)
+provider: bb-tooling
+protocol: TypeScript import, @lernapps/tooling/storage
+:::
+```
+
+### Accessibility helpers interface
+
+Announcements through the polite live region, focus moves and the reduced-motion query; the end-to-end tests read the
+same live region.
+
+```arc42
+:::ignore H014 the interface is in @lernapps/tooling, installed in the untracked node_modules (archetypes/shared/a11y.ts)
+:::
+:::interface
+id: if-a11y
+title: announce, moveFocus, prefersReducedMotion
+provider: bb-tooling
+protocol: TypeScript import, @lernapps/tooling/a11y
+:::
+```
+
+### Translator interface
+
+Code that shows learner texts gets them through `translator(messages)`, never as strings in code.
+
+```arc42
+:::ignore H014 the interface is in @lernapps/tooling, installed in the untracked node_modules (archetypes/shared/i18n.ts)
+:::
+:::interface
+id: if-translator
+title: translator(messages)
+provider: bb-tooling
+protocol: TypeScript import, @lernapps/tooling/i18n
+:::
+```
+
+## Skills
+
+Built in the tooling, one folder per skill. An app commits its skills under `.agents/skills/`: `lernapps-app` for
+every app; the archetype's skill (`lernapps-quiz`, `lernapps-explainer` or `lernapps-interactive`); the content
+skills (`lernapps-content-research`, `lernapps-exercise-patterns`, `lernapps-content-growth`); `lernapps-listing`;
+and the app's own content guide `app-content`. `lernapps update` installs and replaces the `lernapps-*` skills from
+the tooling's `skills/` folder and leaves the app's own alone. They hold the guidance no check can make
+(`dec-skill-interface`).
+
+```arc42
+:::ignore H014 the skills are committed in each app under .agents/skills; this repository has none
+:::
+:::building-block
+id: bb-skills
+title: Skills
+technology: Markdown skills (SKILL.md), from the skills/ folder of @lernapps/tooling
+implements: concept-low-stimulation
+:::
+```
+
+### Skills interface
+
+The creator's assistant loads `lernapps-app` when it starts work on an app, and its archetype's skill and the content
+skills before it writes what the archetype lets it write.
+
+```arc42
+:::ignore H014 the skills are committed in each app under .agents/skills; this repository has none
+:::
+:::interface
+id: if-skills
+title: Skill texts (lernapps-app, the archetype's skill, the content skills, app-content)
+provider: bb-skills
+protocol: Markdown (SKILL.md) loaded by the assistant
+:::
+```

package/docs/arc42/06-runtime-view.arc42.md

@@ -0,0 +1,98 @@
+# Runtime View
+
+Six scenarios every app shares: opening its pages, learning in the browser, an error path of the device storage,
+the assistant working with the skills, building with the checks, and the end-to-end tests before a push and in CI. Each extension adds its archetype's own
+scenarios (the explainer's include asking the tutor).
+
+## Opening the pages
+
+A learner, teacher or parent opens `lernapps.net/<app>/`. The host serves static pages the build rendered from what
+the creator wrote; what a page shows without JavaScript depends on the archetype and is in its extension (an
+interactive app's app page shows only a `<noscript>` note). The language switch and the alternates are plain links to
+the same page in the other language tree; an address the app does not have gets the 404 page, which leads to the
+start page.
+
+```arc42
+:::runtime-scenario
+id: scenario-pages
+title: Opening the pages
+trigger: A learner, teacher or parent opens the app's address
+involves: bb-render, bb-runtime
+:::
+```
+
+## Learning in the browser
+
+The page loads the app's client module; `src/main.ts` calls the archetype's start function, which takes a seed from
+the address where the archetype draws anything at random, shows the learner's progress, announces changes through the
+live region and moves the focus to the feedback. Its texts come in the page's language.
+
+```arc42
+:::runtime-scenario
+id: scenario-learn
+title: Learning in the browser
+trigger: The learner opens a page with JavaScript and answers, practises or plays
+involves: bb-shell, bb-tooling
+:::
+```
+
+## Remembering on the device, storage blocked or full
+
+An app that remembers something loads and saves JSON values through the storage wrapper, under its own prefix in
+`localStorage`. When the browser blocks storage or it is full, `load` gives nothing and `save` returns false; the app
+keeps working and remembers nothing. The decided quota of 100 kB, beyond which `save` refuses, is not built yet.
+
+```arc42
+:::runtime-scenario
+id: scenario-device-storage
+title: Remembering on the device, storage blocked or full
+trigger: The archetype's code loads or saves a value
+involves: bb-shell, bb-tooling
+:::
+```
+
+## Working with the skills
+
+The creator's assistant loads the skills the app commits under `.agents/skills/` (`lernapps-app`, the archetype's
+skill, the content skills and the app's own `app-content`), writes what the archetype lets it write and runs
+`lernapps check`. `lernapps update` replaces the `lernapps-*` skills with those of the tooling.
+
+```arc42
+:::runtime-scenario
+id: scenario-skills
+title: Working with the skills
+trigger: The creator's assistant starts work on the app
+involves: bb-skills, bb-tooling
+:::
+```
+
+## Building with the checks
+
+`vp build` (and `vp dev` on each request) runs the archetype's plugin inside the tooling preset. It validates what
+the creator wrote, runs the archetype's checks (the component rules on any Vue components, the examples through the
+checker where the archetype has them), and only then writes every page in every language, with the shared page trees
+and the runtime's texts, and the 404 page. Any problem fails the build with one line per problem.
+
+```arc42
+:::runtime-scenario
+id: scenario-build
+title: Building with the checks
+trigger: The creator, a git hook or CI runs the build
+involves: bb-tooling, bb-archetype-runtime, bb-build, bb-validation, bb-render, bb-runtime-texts, bb-runtime
+:::
+```
+
+## End-to-end tests before a push
+
+`lernapps check --pre-push`, run by the pre-push hook and by CI, serves the built app on a free port and runs the
+archetype's tests in Chromium at desktop width and at 360 px, with reduced motion, with cases derived from what the
+creator wrote. `lernapps check` adds axe, the width check and the request check on the pages it visits.
+
+```arc42
+:::runtime-scenario
+id: scenario-e2e
+title: End-to-end tests before a push
+trigger: The pre-push hook or CI runs lernapps check --pre-push
+involves: bb-tooling, bb-e2e, bb-render, bb-shell, bb-runtime-texts
+:::
+```

package/docs/arc42/07-deployment-view.arc42.md

@@ -0,0 +1,160 @@
+# Deployment View
+
+## Deployment overview
+
+Every app is static files: it is built and checked on the creator's machine and again in CI, published to its repo's
+GitHub Pages and run entirely in the learner's browser. There is no server of the app's own; what the app remembers
+stays in the browser's `localStorage`. A pull request gets a preview of the same files. Each extension adds nodes
+below these for its archetype's blocks at build and in the browser; blocks not built yet are listed where they would
+run.
+
+Every app gets the same generated Pages workflow (app check, publish, preview) in step 2 of the plan. It is built for
+the explainer and quiz archetypes; the tooling does not have the interactive archetype yet, so an interactive app has
+no generated workflow today. The templates themselves are checked by the CI of `lernapps/app-templates`. The diagram
+shows one representative block per node; each node's section lists all it hosts.
+
+```arc42
+:::diagram
+id: deployment-overview
+view: deployment
+notation: mermaid-architecture
+:::
+```
+
+```mermaid
+architecture-beta
+    group env-development(server)[Development]
+    group dn-creator-machine(server)[Creator machine] in env-development
+    group env-ci(cloud)[CI]
+    group dn-ci-runner(server)[GitHub Actions runner] in env-ci
+    group env-production(internet)[Production and preview]
+    group dn-github-pages(cloud)[GitHub Pages] in env-production
+    group dn-pr-preview(cloud)[Pull request preview] in env-production
+    group dn-learner-browser(internet)[Learner browser] in env-production
+    service bb-tooling(server)[Preset, hooks and lernapps check] in dn-creator-machine
+    service bb-build(server)[Build step] in dn-ci-runner
+    service bb-render(disk)[Rendered pages] in dn-github-pages
+    service bb-runtime(disk)[Page trees] in dn-pr-preview
+    service bb-shell(server)[Shell] in dn-learner-browser
+    bb-tooling:R --> L:bb-build
+    bb-build:R --> L:bb-render
+    bb-build:B --> T:bb-runtime
+    bb-render:R --> L:bb-shell
+```
+
+## Development
+
+The creator's machine, where the creator's AI assistant writes the app.
+
+```arc42
+:::deployment-node
+id: env-development
+title: Development
+type: environment
+:::
+```
+
+## Creator's machine
+
+`vp dev` serves the pages, rendered on each request. The git hooks the preset installs run the checks before a commit
+(format, lint, type check) and before a push (unit tests, build, checks of the built app, end-to-end tests, in
+Chromium). The assistant loads the skills here. A template folder inside `lernapps/app-templates` gets no hooks of
+its own.
+
+```arc42
+:::deployment-node
+id: dn-creator-machine
+title: Creator's machine
+type: device
+parent: env-development
+hosts: bb-tooling, bb-skills, bb-runtime, bb-questions, bb-blocks, bb-component-rules, bb-build, bb-validation, bb-render, bb-runtime-texts, bb-e2e
+:::
+```
+
+## CI
+
+GitHub Actions of the app's repo, on every push and pull request.
+
+```arc42
+:::deployment-node
+id: env-ci
+title: CI
+type: environment
+:::
+```
+
+## GitHub Actions runner
+
+The job `app` runs `lernapps check`, the same command as the hooks, and keeps the checked bundle; on `main` the job
+`deploy` publishes it, on a pull request from the repo the job `preview` publishes it as a preview. A change of only
+the plan or only docs checks and publishes nothing.
+
+```arc42
+:::deployment-node
+id: dn-ci-runner
+title: GitHub Actions runner
+type: server
+parent: env-ci
+hosts: bb-tooling, bb-runtime, bb-questions, bb-blocks, bb-component-rules, bb-build, bb-validation, bb-render, bb-runtime-texts, bb-e2e
+:::
+```
+
+## Production and preview
+
+lernapps.net as learners reach it.
+
+```arc42
+:::deployment-node
+id: env-production
+title: Production and preview
+type: environment
+:::
+```
+
+## GitHub Pages
+
+The `gh-pages` branch of the app's repo, served from its root at `lernapps.net/<repo>/` (only a repo of the lernapps
+organisation is served there; any other at its own Pages address). It serves the rendered pages in every language,
+the 404 page, the tutor pages where the tutor is built, and the bundle; the preset builds with relative URLs, so the
+app works under any path.
+
+```arc42
+:::deployment-node
+id: dn-github-pages
+title: GitHub Pages
+type: server
+parent: env-production
+hosts: bb-render, bb-runtime, bb-questions, bb-blocks, bb-component-rules
+:::
+```
+
+## Pull request preview
+
+The same files below `pr-preview/pr-<number>/` of the app's address, not indexed by search engines, removed when the
+pull request is closed.
+
+```arc42
+:::deployment-node
+id: dn-pr-preview
+title: Pull request preview
+type: server
+parent: env-production
+hosts: bb-render, bb-runtime, bb-questions, bb-blocks, bb-component-rules
+:::
+```
+
+## Learner's browser
+
+Runs the app's client module: the shell with the archetype's code and the tooling's helpers. `localStorage` of the
+one origin lernapps.net holds what the app remembers, under the app's prefix; nothing leaves the device before a
+click.
+
+```arc42
+:::deployment-node
+id: dn-learner-browser
+title: Learner's browser
+type: device
+parent: env-production
+hosts: bb-shell, bb-tooling
+:::
+```

package/docs/arc42/08-concepts.arc42.md

@@ -0,0 +1,123 @@
+# Cross-cutting Concepts
+
+The concepts every lernapps app implements, whatever its archetype. The extensions add their archetype's concepts
+(the explainer's tutor; the interactive app's core and shell, playthroughs, hash routes).
+
+## Generic architecture and extensions
+
+The archetypes stay separate but share their quality goals, so they share this architecture: the generic part defines
+the shared runtime and the tooling helpers and what every app keeps, and each archetype's extension in its template
+folder adds its runtime and the parts its creator writes, under ids the generic part names (`bb-archetype-runtime`,
+`bb-build`, `bb-render`, `bb-shell`, `bb-e2e`, `if-archetype-content`, …), with its interfaces, decisions, risks and
+terms. An app's architecture is the generic part followed by its archetype's extension, chapter by chapter; an
+interactive app adds its own blocks below its extension's parts in the same way. The building blocks reach two levels,
+roots and their parts, so that every interface can be drawn in a view.
+
+```arc42
+:::concept
+id: concept-archetype-extension
+title: Generic architecture plus one extension per archetype
+category: structure
+:::
+```
+
+## Determinism by the seed in the address
+
+Whatever an app draws at random comes from a seed in the address, so the same address gives the same order, task or
+round, and a learner, a teacher, a tutor and the tests can open it again: the quiz's order of questions, the
+explainer's tasks by their numbers, an interactive core's states. Each extension says how its archetype uses the seed.
+
+```arc42
+:::concept
+id: concept-determinism
+title: Determinism by the seed in the address
+category: testing
+:::
+```
+
+## Readable without JavaScript
+
+Every app has static pages that describe it without JavaScript: links, the language switch and the footer are plain
+links, and what needs JavaScript says so in a `<noscript>` note. How much of an app reads without JavaScript depends on
+its archetype: for the quiz and the explainer it is a quality goal of their extensions; an interactive app's start
+page reads without JavaScript, its app page does not.
+
+```arc42
+:::concept
+id: concept-readable-without-js
+title: Readable without JavaScript
+category: accessibility
+:::
+```
+
+## Languages
+
+Every page exists once per declared language, German at the root and others below `/<language>/`, and an app may
+declare only languages its runtime has texts for. Learner texts are language maps in the creator's data or message
+files by language, reached through the translator, never strings in code.
+
+```arc42
+:::concept
+id: concept-languages
+title: Languages
+category: i18n
+:::
+```
+
+## Accessibility by default
+
+Pages meet WCAG 2.1 AA and work at 360 px by default; an app that cannot declares its limits in its entry, and only
+then would its findings become warnings (not built yet: they are errors for every app today). Feedback goes through
+the polite live region and the focus moves with the a11y helpers, and `lernapps check` runs axe and the width check on
+the built pages.
+
+```arc42
+:::concept
+id: concept-accessibility
+title: Accessibility by default, deviations declared
+category: accessibility
+:::
+```
+
+## Component rules
+
+An app's own Vue components (the explainer's components, the interactive UI) and the modules they import are checked
+on the SFC compiler's output at build and by lint rules: no network, no `eval`, `new Function`, `innerHTML` or
+`v-html`, imports only from Vue, the runtime, the storage, i18n and a11y helpers and the app's own files (an
+interactive app's also from the libraries in its dependencies, never from a URL), browser globals only once mounted.
+
+```arc42
+:::concept
+id: concept-component-rules
+title: Component rules
+category: security
+:::
+```
+
+## Device storage
+
+What an app remembers goes through the storage wrapper into `localStorage`, under the prefix `lernapps:<app>:`,
+because all apps share one origin; every access is wrapped, so blocked or full storage means the app remembers
+nothing and keeps working. The quota of 100 kB per app is decided, not built.
+
+```arc42
+:::concept
+id: concept-device-storage
+title: Device storage
+category: persistence
+:::
+```
+
+## Low stimulation (advice)
+
+Advice, not a rule or check: the skills recommend no flashing, calm motion and sound off by default, and say why
+(children, attention, seizures); the creator's assistant follows them. Today the skill `lernapps-interactive` gives
+this advice. A settings dialog (less motion, sound, pause) is not in scope now (`dec-no-settings`).
+
+```arc42
+:::concept
+id: concept-low-stimulation
+title: Low stimulation (advice)
+category: accessibility
+:::
+```