@lernapps/tooling 0.0.1 → 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,3118 @@
+#!/usr/bin/env node
+import { r as measure, t as FOREIGN_KEY } from "./check-cv4I6CCH.mjs";
+import { n as linkStatus } from "./status-CXoQBgfU.mjs";
+import { a as countFailedChecks, c as planFrontMatter, i as PLAN_NAME, l as plans, n as MIGRATED_PLAN, o as countPrePushFailure, r as PLANS, s as currentPlan, t as LEGACY_PLAN } from "./plan-DWKayEnY.mjs";
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import { appendFileSync, closeSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, delimiter, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { parseArgs } from "node:util";
+import { parse, stringify } from "yaml";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createServer } from "node:http";
+import { chromium } from "playwright";
+import { createHash } from "node:crypto";
+// check/run.ts
+const RULE_PAGE = "https://lernapps.net/tooling/rules/#";
+const finding = (rule, severity, problem) => ({
+	rule,
+	severity,
+	where: problem.where,
+	found: problem.found,
+	fix: problem.fix,
+	link: `${RULE_PAGE}${rule}`
+});
+/** The checks next to the CLI: check/rules/*.ts in the source, dist/check/rules/*.mjs in the package. */
+async function loadChecks() {
+	const source = import.meta.url.endsWith(".ts");
+	const dir = fileURLToPath(new URL(source ? "./rules/" : "./check/rules/", import.meta.url));
+	const files = readdirSync(dir).filter((file) => file.endsWith(source ? ".ts" : ".mjs")).sort();
+	const checks = [];
+	for (const file of files) {
+		const check = (await import(pathToFileURL(join(dir, file)).href)).default;
+		if (typeof check?.id !== "string" || typeof check.run !== "function") continue;
+		checks.push({
+			id: check.id,
+			severity: check.severity ?? "error",
+			description: check.description ?? "",
+			run: check.run
+		});
+	}
+	return checks;
+}
+/** Every check with its rule id, severity and what it checks, for the help of `lernapps check`. */
+async function describeChecks() {
+	const checks = await loadChecks();
+	const width = Math.max(...checks.map((check) => check.id.length));
+	const lines = checks.map((check) => `  ${check.id.padEnd(width)}  ${check.severity.padEnd(7)}  ${check.description}`);
+	return `Checks (rule id, severity, what it checks; each rule at ${RULE_PAGE}<id>):\n${lines.join("\n")}\n`;
+}
+/**
+* Runs every check; a check that returns undefined found nothing to check and is left out of the rules. A problem
+* has its check's severity, or the lower one it names.
+*/
+async function runChecks(context) {
+	const rules = [];
+	const findings = [];
+	for (const check of await loadChecks()) {
+		const problems = await check.run(context);
+		if (problems === void 0) continue;
+		rules.push(check.id);
+		findings.push(...problems.map((problem) => finding(check.id, problem.severity ?? check.severity, problem)));
+	}
+	return {
+		rules,
+		findings
+	};
+}
+const byPlace = (a, b) => a.rule.localeCompare(b.rule) || a.where.localeCompare(b.where) || a.found.localeCompare(b.found);
+function toYaml(report) {
+	const sorted = {
+		...report,
+		rules: [...new Set(report.rules)].sort(),
+		findings: [...report.findings].sort(byPlace)
+	};
+	return stringify(sorted, { lineWidth: 0 });
+}
+const failed = (report) => report.findings.some((finding) => finding.severity === "error");
+// check/visit.ts
+const require = createRequire(import.meta.url);
+const WIDTH = 360;
+/** Where the page keeps what its scripts did with stored data (recordStorageAccess). */
+const ACCESS_LOG = "__lernappsStorageAccess";
+/**
+* Runs in the page before its own scripts (an init script, serialized: it uses nothing from outside): puts the data
+* of another app into the browser, and records every access by name to localStorage, sessionStorage, IndexedDB and
+* the Cache API in window[log]. Listing the keys is not recorded; the app's own storage needs it to keep its quota.
+*/
+function recordStorageAccess({ foreign, log }) {
+	const accesses = [];
+	Object.defineProperty(window, log, { value: accesses });
+	const record = (area, action, name) => {
+		accesses.push({
+			area,
+			action,
+			name: String(name)
+		});
+	};
+	for (const area of ["localStorage", "sessionStorage"]) {
+		let target;
+		try {
+			target = window[area];
+			if (target.getItem(foreign) === null) target.setItem(foreign, "3");
+		} catch {
+			continue;
+		}
+		const methods = {
+			getItem: (key) => (record(area, "read", key), target.getItem(key)),
+			setItem: (key, value) => (record(area, "write", key), target.setItem(key, value)),
+			removeItem: (key) => (record(area, "remove", key), target.removeItem(key)),
+			clear: () => (record(area, "clear", ""), target.clear()),
+			key: (index) => target.key(index)
+		};
+		const own = (property) => typeof property === "string" && !(property in Storage.prototype);
+		const proxy = new Proxy(target, {
+			get(_, property) {
+				if (property === "length") return target.length;
+				if (typeof property === "string" && Object.hasOwn(methods, property)) return methods[property];
+				if (!own(property)) return Reflect.get(target, property);
+				record(area, "read", property);
+				return target.getItem(property) ?? void 0;
+			},
+			set(_, property, value) {
+				if (!own(property)) return Reflect.set(target, property, value);
+				record(area, "write", property);
+				target.setItem(property, String(value));
+				return true;
+			},
+			deleteProperty(_, property) {
+				if (!own(property)) return Reflect.deleteProperty(target, property);
+				record(area, "remove", property);
+				target.removeItem(property);
+				return true;
+			}
+		});
+		Object.defineProperty(window, area, {
+			get: () => proxy,
+			configurable: true
+		});
+	}
+	/** Calls `before` with the arguments of every call of `method` of `target`, before it runs. */
+	const wrap = (target, method, before) => {
+		const original = Reflect.get(target, method);
+		Reflect.set(target, method, function(...args) {
+			before(args);
+			return Reflect.apply(original, this, args);
+		});
+	};
+	wrap(IDBFactory.prototype, "open", ([name]) => record("IndexedDB", "open", name));
+	wrap(IDBFactory.prototype, "deleteDatabase", ([name]) => record("IndexedDB", "delete", name));
+	if (typeof CacheStorage === "undefined") return;
+	wrap(CacheStorage.prototype, "open", ([name]) => record("Cache", "open", name));
+	wrap(CacheStorage.prototype, "delete", ([name]) => record("Cache", "delete", name));
+	wrap(CacheStorage.prototype, "has", ([name]) => record("Cache", "read", name));
+	wrap(CacheStorage.prototype, "match", ([, options]) => {
+		const name = options?.cacheName;
+		if (name === void 0) record("Cache", "match", "");
+		else record("Cache", "read", name);
+	});
+}
+const WCAG_21_AA = [
+	"wcag2a",
+	"wcag2aa",
+	"wcag21a",
+	"wcag21aa"
+];
+/** A browser cannot start here; the message says how to make it run. */
+var BrowserError = class extends Error {};
+const TYPES = {
+	".html": "text/html; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".json": "application/json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".gif": "image/gif",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2",
+	".woff": "font/woff",
+	".txt": "text/plain; charset=utf-8",
+	".webmanifest": "application/manifest+json"
+};
+/** Serves a bundle at http://127.0.0.1:<port><path>, as a static host does; nothing outside the path. */
+async function serve(bundle, path) {
+	const root = resolve(bundle);
+	const server = createServer((request, response) => {
+		const url = new URL(request.url ?? "/", "http://localhost");
+		const pathname = decodeURIComponent(url.pathname);
+		const file = pathname.startsWith(path) ? join(root, pathname.slice(path.length)) : "";
+		if (file === "" || file !== root && !file.startsWith(root + sep) || !existsSync(file)) response.writeHead(404, { "content-type": "text/plain" }).end("not found");
+		else if (statSync(file).isDirectory()) {
+			if (!pathname.endsWith("/")) response.writeHead(301, { location: `${pathname}/${url.search}` }).end();
+			else if (existsSync(join(file, "index.html"))) response.writeHead(200, { "content-type": TYPES[".html"] }).end(readFileSync(join(file, "index.html")));
+			else response.writeHead(404, { "content-type": "text/plain" }).end("not found");
+		} else {
+			const type = TYPES[extname(file).toLowerCase()] ?? "application/octet-stream";
+			response.writeHead(200, { "content-type": type }).end(readFileSync(file));
+		}
+	});
+	await new Promise((done) => server.listen(0, "127.0.0.1", done));
+	return {
+		server,
+		base: `http://127.0.0.1:${server.address().port}${path}`
+	};
+}
+/**
+* The pages of a bundle: its .html files, sorted. Left out, as no pages: the 404 page at the root, which a static host
+* serves at any address that does not exist, so its links work only from there (a link that leads to it makes it a
+* page like any other); and a file without <!doctype html>, which is no document (a fragment, a host's verification
+* file). Not navigable: a page the app marks with <meta name="robots" content="noindex">, reached another way on
+* purpose; it is checked like any page, but no link needs to reach it.
+*/
+function bundlePages(bundle) {
+	const root = resolve(bundle);
+	const files = (dir) => readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) return files(path);
+		return entry.isFile() && entry.name.toLowerCase().endsWith(".html") ? [path] : [];
+	});
+	const doctype = /^\uFEFF?\s*<!doctype html\b/i;
+	const noindex = /<meta\b(?=[^>]*\bname\s*=\s*["']?robots\b)(?=[^>]*\bcontent\s*=\s*["'][^"']*\bnoindex\b)[^>]*>/i;
+	return files(root).map((file) => ({
+		name: relative(root, file).split(sep).join("/"),
+		html: readFileSync(file, "utf8")
+	})).filter(({ name, html }) => name !== "404.html" && doctype.test(html)).map(({ name, html }) => ({
+		name,
+		navigable: !noindex.test(html)
+	})).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+/**
+* Where Playwright's own Chromium is missing: another Chromium installed in the browser folder, where the environment
+* asks for no downloads (PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD, as a sandbox with a preinstalled browser sets it), the
+* newest first; else a download of Playwright's own. CI sets no such variable, so it downloads (and caches) as before.
+*/
+function chooseBrowsers(env, installed) {
+	const skip = (env["PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD"] ?? "").toLowerCase();
+	return [...skip !== "" && skip !== "0" && skip !== "false" ? installed.map((executablePath) => ({
+		use: "installed",
+		executablePath
+	})) : [], { use: "download" }];
+}
+/** Playwright's browser folder: PLAYWRIGHT_BROWSERS_PATH, else its cache; undefined where it is node_modules ("0"). */
+function browsersFolder(env) {
+	const path = env["PLAYWRIGHT_BROWSERS_PATH"];
+	if (path === "0") return void 0;
+	if (path !== void 0 && path !== "") return path;
+	if (process.platform === "win32") return join(env["LOCALAPPDATA"] ?? homedir(), "ms-playwright");
+	if (process.platform === "darwin") return join(homedir(), "Library", "Caches", "ms-playwright");
+	return join(env["XDG_CACHE_HOME"] ?? join(homedir(), ".cache"), "ms-playwright");
+}
+/** The Chromium executables of any version in a browser folder, newest first; the headless shell before the full one. */
+function installedChromiums(folder) {
+	if (folder === void 0 || !existsSync(folder)) return [];
+	const names = [
+		"chrome-headless-shell",
+		"headless_shell",
+		"chrome",
+		"chrome.exe",
+		"chrome-headless-shell.exe"
+	];
+	return readdirSync(folder).flatMap((name) => {
+		const match = /^chromium(_headless_shell)?-(\d+)$/.exec(name);
+		if (match === null) return [];
+		const rank = Number(match[2]) * 2 + (match[1] === void 0 ? 0 : 1);
+		return readdirSync(join(folder, name), { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => names.map((file) => join(folder, name, entry.name, file))).filter((file) => existsSync(file)).map((file) => ({
+			file,
+			rank
+		}));
+	}).sort((a, b) => b.rank - a.rank).map(({ file }) => file);
+}
+/** The browser that started last in this run: Playwright's own (undefined path) or another installed Chromium. */
+let started;
+/**
+* Starts Chromium: Playwright's own build; where that is missing, another one that is installed (chooseBrowsers), or
+* Playwright's own, installed once (Playwright caches it). Each says so in one line.
+*/
+async function launch() {
+	const missing = (error) => /Executable doesn't exist|playwright install/i.test(String(error));
+	try {
+		const browser = await chromium.launch(started?.executablePath ? { executablePath: started.executablePath } : {});
+		started ??= {};
+		return browser;
+	} catch (error) {
+		if (!missing(error)) throw cannotRun(error);
+	}
+	for (const choice of chooseBrowsers(process.env, installedChromiums(browsersFolder(process.env)))) if (choice.use === "installed") try {
+		const browser = await chromium.launch({ executablePath: choice.executablePath });
+		process.stderr.write(`lernapps check: Playwright's Chromium is not installed, using the installed ${choice.executablePath}\n`);
+		started = { executablePath: choice.executablePath };
+		return browser;
+	} catch {
+		continue;
+	}
+	const cli = join(dirname(require.resolve("playwright/package.json")), "cli.js");
+	process.stderr.write("lernapps check: no usable Chromium installed, downloading Playwright's (once; it is cached)\n");
+	if (spawnSync(process.execPath, [
+		cli,
+		"install",
+		"chromium"
+	], { stdio: [
+		"ignore",
+		2,
+		2
+	] }).status !== 0) throw cannotRun(/* @__PURE__ */ new Error("npx playwright install chromium failed"));
+	try {
+		const browser = await chromium.launch();
+		started = {};
+		return browser;
+	} catch (error) {
+		throw cannotRun(error);
+	}
+}
+/**
+* The environment of the end-to-end tests, once a browser has started in this run (else it starts one): the
+* executable of an installed Chromium in LERNAPPS_CHROMIUM, which the Playwright preset launches
+* (archetypes/shared/playwright.ts); nothing for Playwright's own.
+*/
+async function browserForTests() {
+	if (started === void 0) await (await launch()).close();
+	return started?.executablePath ? { LERNAPPS_CHROMIUM: started.executablePath } : {};
+}
+function cannotRun(error) {
+	return new BrowserError(`no browser can run here: ${((error instanceof Error ? error.message : String(error)).split("\n")[0] ?? "").trim()}`);
+}
+/** The status of every link, fetched once per URL (a rate-limited one with a short, bounded backoff). */
+var Links = class {
+	known = /* @__PURE__ */ new Map();
+	get(url) {
+		let result = this.known.get(url);
+		if (result === void 0) {
+			result = linkStatus(url);
+			this.known.set(url, result);
+		}
+		return result;
+	}
+};
+const withoutHash = (url) => url.replace(/#.*$/, "");
+/**
+* The page a link leads to: without query and fragment. A static host serves the same file for any query, so a link
+* that only changes it (a quiz's "start again" with a random seed) is the same page, and the report stays the same.
+*/
+const pageOf = (url) => url.replace(/[?#].*$/, "");
+/**
+* For the tooling's own tests only, not for users: LERNAPPS_TEST_URL_PAGE_LIMIT lowers the limit, so a test reaches it
+* with a few pages (test/check-pages.e2e.test.ts). Not in the help; any other value keeps URL_PAGE_LIMIT.
+*/
+function urlPageLimit(env = process.env) {
+	const value = Number(env["LERNAPPS_TEST_URL_PAGE_LIMIT"]);
+	return Number.isInteger(value) && value > 0 ? value : 100;
+}
+/** Pages visited at the same time, each in its own browser context. */
+const PARALLEL = 4;
+/**
+* Visits the start page and every page of the app reachable from it by links below `base`, breadth first, in a fixed
+* order, a few at a time; the result does not depend on how long a page takes. `name` turns a page's URL into what
+* the messages call it. For a bundle, `pages` are its pages (bundlePages): those the links do not reach, nor a page
+* embeds (an iframe), are visited afterwards, and unreachable unless they are not navigable. Without `pages` (an app
+* on a URL), it stops after `limit` pages and says so.
+*/
+async function visitApp(browser, base, name, options = {}) {
+	const { start = base, pages, limit = Infinity } = options;
+	const axe = readFileSync(require.resolve("axe-core/axe.min.js"), "utf8");
+	const links = new Links();
+	const queue = [withoutHash(start)];
+	const seen = /* @__PURE__ */ new Set([pageOf(start)]);
+	const visits = [];
+	let withoutJs;
+	const noJs = () => withoutJs ??= newContext(browser, new URL(base).origin, [], false);
+	const visitAll = async (urls) => {
+		return (await Promise.all(urls.map((url) => visitPage(browser, url, base, axe, links, noJs)))).map((visit, index) => ({
+			...visit,
+			page: name(urls[index] ?? "")
+		}));
+	};
+	try {
+		while (queue.length > 0 && visits.length < limit) for (const visit of await visitAll(queue.splice(0, Math.min(PARALLEL, limit - visits.length)))) {
+			const { anchors, ...rest } = visit;
+			visits.push(rest);
+			for (const link of anchors) {
+				const next = pageOf(link);
+				if (seen.has(next) || !next.startsWith(base)) continue;
+				seen.add(next);
+				const { status, html } = await links.get(next);
+				if (status > 0 && status < 400 && html) queue.push(next);
+			}
+		}
+		const reached = new Set(visits.flatMap((visit) => [visit.page, ...visit.links.map((link) => name(pageOf(link.url)))]));
+		const rest = (pages ?? []).filter((page) => !reached.has(page.name));
+		for (let index = 0; index < rest.length; index += PARALLEL) {
+			const urls = rest.slice(index, index + PARALLEL).map((page) => base + encodeURI(page.name));
+			visits.push(...(await visitAll(urls)).map(({ anchors: _anchors, ...visit }) => visit));
+		}
+		return {
+			pages: visits.sort((a, b) => a.page.localeCompare(b.page)),
+			unreachable: rest.filter((page) => page.navigable).map((page) => page.name),
+			...queue.length > 0 ? { stopped: {
+				limit,
+				more: queue.length
+			} } : {}
+		};
+	} finally {
+		if (withoutJs !== void 0) await (await withoutJs).close();
+	}
+}
+async function newContext(browser, origin, requests, javaScriptEnabled = true) {
+	const context = await browser.newContext({
+		viewport: {
+			width: WIDTH,
+			height: 800
+		},
+		javaScriptEnabled
+	});
+	if (javaScriptEnabled) await context.addInitScript(recordStorageAccess, {
+		foreign: FOREIGN_KEY,
+		log: ACCESS_LOG
+	});
+	await context.route("**/*", async (route) => {
+		const request = route.request();
+		requests.push({
+			url: request.url(),
+			method: request.method()
+		});
+		if (new URL(request.url()).origin === origin) await route.continue();
+		else await route.abort("blockedbyclient");
+	});
+	return context;
+}
+async function settle(context, url) {
+	const page = await context.newPage();
+	await page.goto(url, { waitUntil: "load" });
+	await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => void 0);
+	return page;
+}
+async function visitPage(browser, url, base, axe, links, noJs) {
+	const origin = new URL(base).origin;
+	const requests = [];
+	const context = await newContext(browser, origin, requests);
+	try {
+		const page = await settle(context, url);
+		const withoutJavaScript = await page.locator(EXPLAINER_MARKER).count() > 0 ? noJs().then((noJsContext) => readWithoutJavaScript(noJsContext, url)) : void 0;
+		withoutJavaScript?.catch(() => void 0);
+		const marker = page.locator(ARCHETYPE_MARKER).first();
+		const archetype = await marker.count() > 0 ? await marker.getAttribute("content") ?? void 0 : void 0;
+		const loaded = [...requests];
+		const cookies = (await context.cookies()).map((cookie) => cookie.name).sort();
+		const { storage, access } = await page.evaluate(async ({ foreign, log }) => {
+			const databases = typeof indexedDB.databases === "function" ? await indexedDB.databases() : [];
+			const cacheNames = typeof caches === "undefined" ? [] : await caches.keys();
+			const own = (key) => key !== foreign;
+			const accesses = (window[log] ?? []).map((entry) => JSON.stringify([
+				entry.area,
+				entry.action,
+				entry.name
+			]));
+			return {
+				storage: [
+					...Object.keys(localStorage).filter(own).map((key) => `localStorage ${key}`),
+					...Object.keys(sessionStorage).filter(own).map((key) => `sessionStorage ${key}`),
+					...databases.map((database) => `IndexedDB ${database.name ?? ""}`),
+					...cacheNames.map((name) => `Cache ${name}`)
+				].sort(),
+				access: [...new Set(accesses)].sort((a, b) => a.localeCompare(b))
+			};
+		}, {
+			foreign: FOREIGN_KEY,
+			log: ACCESS_LOG
+		});
+		const overflow = await page.evaluate((width) => {
+			const selector = (element) => {
+				const id = element.id === "" ? "" : `#${element.id}`;
+				const classes = [...element.classList].map((name) => `.${name}`).join("");
+				return `${element.tagName.toLowerCase()}${id}${classes}`;
+			};
+			const wide = (element) => element.getBoundingClientRect().right > width + 1;
+			const elements = [...document.body.querySelectorAll("*")].filter((element) => wide(element) && !(element.parentElement && wide(element.parentElement))).slice(0, 5).map(selector);
+			return {
+				width: document.documentElement.scrollWidth,
+				elements
+			};
+		}, WIDTH);
+		const anchors = await page.evaluate(() => [...document.querySelectorAll("a[href]")].map((element) => element.href));
+		const resources = await page.evaluate(() => [...document.querySelectorAll("[src], link[href]")].map((element) => element.src || element.href).filter((value) => typeof value === "string" && value !== ""));
+		await page.addScriptTag({ content: axe });
+		const violations = await page.evaluate(async (tags) => {
+			return (await window.axe.run(document, {
+				runOnly: {
+					type: "tag",
+					values: tags
+				},
+				resultTypes: ["violations"]
+			})).violations.map((violation) => ({
+				id: violation.id,
+				help: violation.help,
+				helpUrl: violation.helpUrl,
+				targets: violation.nodes.map((node) => node.target.map(String).join(" "))
+			}));
+		}, [...WCAG_21_AA]);
+		const own = [...new Set([...anchors, ...resources].map(withoutHash))].filter((link) => link.startsWith(base)).sort();
+		const statuses = await Promise.all(own.map(async (link) => ({
+			url: link,
+			status: (await links.get(link)).status
+		})));
+		return {
+			requests: loaded,
+			cookies,
+			storage,
+			access: access.map((entry) => {
+				const [area, action, name] = JSON.parse(entry);
+				return {
+					area,
+					action,
+					name
+				};
+			}),
+			overflow,
+			axe: violations.sort((a, b) => a.id.localeCompare(b.id)),
+			links: statuses,
+			...archetype ? { archetype } : {},
+			...withoutJavaScript ? { withoutJavaScript: await withoutJavaScript } : {},
+			anchors
+		};
+	} finally {
+		await context.close();
+	}
+}
+/** The marker of a page the explainer runtime renders; only such a page is visited again without JavaScript. */
+const EXPLAINER_MARKER = "meta[name=\"lernapps-archetype\"][content=\"explainer\"]";
+/** The marker of the archetype whose runtime renders a page; its settings are the page's to read (own-data-only). */
+const ARCHETYPE_MARKER = "meta[name=\"lernapps-archetype\"]";
+/**
+* The parts of an explainer page that only JavaScript shows, hidden without it: a component's island, a generated
+* exercise's live task, a question's controls and its reveal after "Prüfen". What is inside is not read.
+*/
+const ONLY_WITH_JAVASCRIPT = [
+	".explainer-island",
+	".explainer-live",
+	".question-reveal",
+	".question-actions"
+];
+/**
+* What an explainer page shows with JavaScript off (in `context`, made with JavaScript disabled): its h1, headings,
+* formulas and figures, each exercise's "Lösung" and each component's nojs text, with every <details> opened, as a
+* learner opens a "Lösung". Visible means rendered, not hidden by an attribute or a style.
+*/
+async function readWithoutJavaScript(context, url) {
+	const page = await context.newPage();
+	try {
+		await page.goto(url, { waitUntil: "load" });
+		return await page.evaluate((skip) => {
+			const fold = (text) => (text ?? "").replace(/\s+/g, " ").trim();
+			for (const details of document.querySelectorAll("details")) details.open = true;
+			const read = (selector, root = document) => [...root.querySelectorAll(selector)].filter((element) => element.closest(skip) === null);
+			const visible = (element) => element.checkVisibility({
+				opacityProperty: true,
+				visibilityProperty: true
+			});
+			const shown = (element) => visible(element) ? fold(element instanceof HTMLElement ? element.innerText : element.textContent) : "";
+			const section = (element) => {
+				const heading = document.evaluate("preceding::*[self::h2 or self::h3 or self::h4][@id][1]", element, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+				return heading instanceof Element ? ` in #${heading.id}` : "";
+			};
+			const labelledBy = (element) => (element.getAttribute("aria-labelledby") ?? "").split(/\s+/).map((id) => fold(id === "" ? "" : document.getElementById(id)?.textContent)).join(" ").trim();
+			const own = (element) => element.localName === "img" ? element.getAttribute("alt") : element.localName === "figure" ? element.querySelector(":scope > figcaption")?.textContent : element.querySelector(":scope > title")?.textContent;
+			const accessibleName = (element) => fold(element.getAttribute("aria-label")) || labelledBy(element) || fold(own(element)) || fold(element.getAttribute("title"));
+			const headings = read("h1, h2, h3, h4, h5, h6").map((element) => ({
+				kind: "heading",
+				where: `${element.localName}${element.id === "" ? ` "${fold(element.textContent).slice(0, 40)}"` : `#${element.id}`}`,
+				visible: visible(element),
+				text: shown(element)
+			}));
+			const formulas = read("math").map((element, index) => ({
+				kind: "formula",
+				where: `formula ${index + 1}${section(element)}`,
+				visible: visible(element),
+				text: shown(element)
+			}));
+			const figures = read("figure, img, [role=\"img\"]").map((element, index) => ({
+				kind: "figure",
+				where: `figure ${index + 1} (${element.localName})${section(element)}`,
+				visible: visible(element),
+				text: accessibleName(element)
+			}));
+			return {
+				h1: headings.find((heading) => heading.where.startsWith("h1") && heading.text !== "")?.text ?? "",
+				parts: [
+					...headings,
+					...formulas,
+					...figures
+				],
+				exercises: read(".explainer-exercise").map((element, index) => ({
+					where: `exercise ${element.id === "" ? String(index + 1) : `#${element.id}`}`,
+					solutions: read("details.explainer-solution", element).map((details) => visible(details) ? fold([...details.childNodes].filter((node) => !(node instanceof Element && node.localName === "summary")).map((node) => node instanceof HTMLElement ? node.innerText : node.textContent).join(" ")) : "")
+				})),
+				components: read(".explainer-component").map((element) => {
+					const nojs = element.querySelector(":scope > .explainer-nojs");
+					return {
+						where: `component ${element.getAttribute("data-component") ?? ""}${section(element)}`,
+						...nojs === null ? {} : { nojs: shown(nojs) }
+					};
+				})
+			};
+		}, ONLY_WITH_JAVASCRIPT.join(", "));
+	} finally {
+		await page.close();
+	}
+}
+// src/usage.ts
+/** A command was called wrongly: the CLI prints the message and the usage, and exits 2. */
+var UsageError = class extends Error {};
+const USAGE = `Usage: lernapps <command> [options]
+
+Commands:
+  changes [--staged | --pushed | --ci]            what a change can affect: none, docs or all
+  check [--pre-commit] [--pre-push] [<dir|url>]   run the checks of a repo, a built app or an app on a URL
+  create --archetype <name> [<dir>]               write a new app from the archetype's template
+  hooks                                           install the app's git hooks (the app's prepare script)
+  init <short name> [--addon <package>]           start an app: plan template and skills from the registry
+  screenshots [--out <dir>] [<dir>]               an image of every page and every figure of a built explainer or quiz
+  skills --archetype <name>                       add the skills of the archetype the plan chose
+  update                                          move the app to the runtime and tooling this tooling depends on
+
+Options:
+  -h, --help      print this help
+  -v, --version   print the version
+
+Run "lernapps <command> --help" for the options of a command. Exit codes: 0 on success, 1 when a check fails or
+the app cannot be created, 2 on a usage error.
+
+The package @lernapps/tooling comes from the npm registry. Before an app exists, run a command with
+  npx --yes @lernapps/tooling <command> ...
+In an app, it is a development dependency: npx lernapps <command> ...
+`;
+/** The options of `lernapps check`, as node:util parseArgs takes them. */
+const CHECK_OPTIONS = {
+	"pre-commit": {
+		type: "boolean",
+		default: false
+	},
+	"pre-push": {
+		type: "boolean",
+		default: false
+	},
+	entry: { type: "string" },
+	report: { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h",
+		default: false
+	}
+};
+const CHECK_USAGE = `Usage: lernapps check [--pre-commit] [--pre-push] [<dir|url>] [--entry <file>] [--report <file>]
+
+Runs every check that has something to check. Passing, it prints one line; otherwise the validation report in
+YAML (schema: https://lernapps.net/tooling/schemas/validation-report.v1.schema.json). Every finding names its
+rule id and severity, where, what was found and how to fix it, and links its rule.
+
+Exit codes: 0 when no rule of severity error fails, 1 when one does, 2 on a usage error.
+
+In a repo (no <dir|url>):
+  --pre-commit     the fast part: format, lint, type check (the pre-commit hook); where the project has
+                   Vue components (.vue files), also their type check with vue-tsc --noEmit; in an app with
+                   an architecture (docs/arc42/ from lernapps create, an interactive app), when the commit
+                   stages a file of it, .arc42ignore or src/, arc42 diff --staged (also when the commit is only
+                   docs): a block and its prose not changed together fail, and new code no block claims that
+                   .arc42ignore does not list; a hint to review an element under whose path code changed is a
+                   warning. Before the first commit arc42 validate --strict
+  --pre-push       the heavy part: in an app with an architecture arc42 validate --strict, unit tests, build (vp build for an app with index.html, else vp pack),
+                   checks of the built app in dist/, the Playwright tests when playwright.config.* exists,
+                   dependency licences, the lock file (the pre-push hook); a failure increments prePushFailures in the front
+                   matter of the current plan (the highest number in .vibe/plans/, else .vibe/plan.md). A
+                   failing generic test of the archetype's runtime (@lernapps/app-templates) is named as a test
+                   of the template, with where to report it
+  Without a flag, or with both, it runs both parts (CI): the hooks together run exactly what CI runs.
+  Each hook part first asks lernapps changes what the change can affect (the staged files before a commit, the
+  pushed commits before a push): a change of only the plan (.vibe/**) checks nothing; a change of only docs
+  (docs/**/*.md) and the plan checks nothing in an app, whose bundle has no docs, and before a push builds and
+  checks the site in a repo with one (npm run build, then npm run check:site in the tooling, npm run check in a
+  site). Then it prints one line and writes no report. Anything else, or changed files it cannot know, runs the
+  part. CI decides the same in the app check action (lernapps changes --help).
+  Every run in a repo also writes the full report to node_modules/.cache/lernapps/validation-report.yaml,
+  passing or not; the app check action keeps it. A failed run counts each rule with an error in failedChecks
+  of the current plan's front matter, when it has the key.
+
+On a built app, without its repo:
+  <dir>            a bundle (a directory with index.html), served on 127.0.0.1
+  <url>            an app on the web
+
+The checks of a built app open its pages in Chromium, as a learner would, without a click; a link that only
+changes the query string is the same page. Requests to other hosts are blocked and recorded.
+  On a bundle   every page: first those reachable by links from the start page, then every other .html file,
+                which is a finding of pages-reachable (unreachable from the start page). Not pages: 404.html at
+                the root (the host's page for missing addresses) and a file without <!doctype html>. A page with
+                <meta name="robots" content="noindex"> is checked, but no link needs to reach it.
+  On a URL      the pages reachable by links, at most 100: a check of a deployed app stays within minutes and
+                asks its host a bounded number of times. When it stops there, a hint of pages-reachable says how
+                many pages it checked and that further pages were not visited; check the bundle for all of them.
+  Explainer     a page the explainer runtime marks as its own, <meta name="lernapps-archetype" content="explainer">,
+                is opened once more with JavaScript off, for explainer-readable-without-js: its h1, every heading,
+                formula (<math>) and figure visible, a figure with its accessible name, every exercise's "Lösung"
+                and every component's nojs text not empty. Pages without the marker get no second visit.
+A page takes about a second; four are visited at a time, about 0.3 s per page: 120 pages in about 40 s.
+Chromium is downloaded on the first run and cached; where no browser can run, the report says so.
+A link whose server answers 429 (rate limited) is asked again after a short wait, at most a few seconds; still
+limited, it is a finding of severity hint that names the link: not checked, nothing failed.
+
+Options:
+  --entry <file>   check a catalog entry (YAML) against the app: its URL and topic links resolve, a topic's
+                   #<section> (or #<section>/<sub>) is an element id of its page as the server sends it, the
+                   fitness values match; without <dir|url> the app at the entry's url is checked
+  --report <file>  also write the full report to <file>, passing or not
+  -h, --help       print this help
+
+`;
+/** The options of `lernapps changes`, as node:util parseArgs takes them. */
+const CHANGES_OPTIONS = {
+	staged: {
+		type: "boolean",
+		default: false
+	},
+	pushed: {
+		type: "boolean",
+		default: false
+	},
+	ci: {
+		type: "boolean",
+		default: false
+	},
+	base: { type: "string" },
+	head: { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h",
+		default: false
+	}
+};
+const CHANGES_USAGE = `Usage: lernapps changes [--staged | --pushed | --ci | --base <rev> [--head <rev>] | <path>...]
+
+Prints the change scope of a change: what it can affect, and so what the hooks and CI run for it.
+  none   every changed file is a plan: .vibe/**. Nothing runs
+  docs   every changed file is docs, docs/**/*.md, or the plan. Only the site's checks and deployment run; an
+         app has no site (its bundle holds no docs), so nothing runs
+  all    anything else, also when the changed files are not known, or none are. Everything runs
+
+"Docs" are only Markdown files below docs/ (docs/**/*.md). README.md, AGENTS.md and every other path are not
+docs. The lists of none and docs are allowlists: every other path is all, so a new folder never causes a skip.
+
+Where the changed files come from (one source):
+  --staged         the staged files (the pre-commit hook)
+  --pushed         the pushed commits, from git's lines on standard input (the pre-push hook): each ref against
+                   the remote's commit; a new branch against its merge base with origin/main; no lines (run by
+                   hand) or an unknown commit is all
+  --ci             the GitHub Actions event: a pull request against the merge base with its base, a push to a
+                   branch before..after; a new branch, workflow_dispatch and any other event is all. A shallow
+                   clone is deepened once when a commit is missing. Also writes the step outputs scope, kind, code
+                   (true when the code's build and tests run: scope all) and site (true when the site's checks and
+                   deployment run) to GITHUB_OUTPUT, and a notice when something is skipped
+  --base <rev>     what --head (default HEAD) adds to its merge base with <rev>
+  <path>...        these paths, relative to the repo root
+Without a source the changed files are not known: all.
+
+The kind of repo decides what docs runs: app (index.html at the root), tooling (the package @lernapps/tooling),
+site (any other: a site or the catalog). A repo may name its kind and declare exceptions in package.json, each
+key optional, each list of path patterns relative to the repo root (** any folders, * any characters but /, a
+pattern ending in / a folder):
+  "lernapps": { "changes": { "kind": "site", "none": ["notes/**"], "docs": ["handbook/**/*.md"],
+                             "all": ["docs/generated/**"] } }
+  kind   app, tooling or site, instead of the detected one
+  none   more patterns that are plan: nothing runs for them
+  docs   more patterns that are docs
+  all    patterns that are all, also where they match none or docs
+Any other key, or a malformed value, is an error.
+
+Prints the scope (none, docs or all) on standard output and why on standard error.
+Exit codes: 0 when the scope is printed, 1 when package.json lernapps.changes is malformed, 2 on a usage error.
+
+Options:
+  -h, --help   print this help
+`;
+/** The options of `lernapps hooks`, as node:util parseArgs takes them. */
+const HOOKS_OPTIONS = { help: {
+	type: "boolean",
+	short: "h",
+	default: false
+} };
+const HOOKS_USAGE = `Usage: lernapps hooks
+
+Installs the git hooks of @lernapps/tooling (the fast part of lernapps check before a commit, the heavy part
+before a push) into the repository of the app in the current folder. Every app runs it as its prepare script, so
+npm install installs the hooks.
+
+It installs them only where the current folder is the root of its git repository. In a folder inside another
+repository, such as a template folder of lernapps/app-templates, it changes nothing and says so: that
+repository keeps its own hooks. Outside a repository it says so too: git init, then npm install again.
+
+Exit codes: 0 when the hooks are installed or deliberately not, 1 when they cannot be, 2 on a usage error.
+
+Options:
+  -h, --help   print this help
+`;
+/** The options of `lernapps screenshots`. */
+const SCREENSHOTS_OPTIONS = {
+	out: {
+		type: "string",
+		default: "screenshots"
+	},
+	width: {
+		type: "string",
+		default: "390"
+	},
+	desktop: {
+		type: "boolean",
+		default: false
+	},
+	help: {
+		type: "boolean",
+		short: "h",
+		default: false
+	}
+};
+const SCREENSHOTS_USAGE = `Usage: lernapps screenshots [--out <dir>] [--width <px>] [--desktop] [<dir>]
+
+Writes a full-page image of every page of a built explainer or quiz, and an image of every figure on it, so that a
+creator sees what a learner sees before the app goes out. A page image is scaled down to be shown whole; check the
+details of a figure, such as where a line of a drawing points, in its own image. It works where an assistant can only
+send images: the images are PNG files, and an index.html shows them all in page order with each page's title and path
+(one file, images relative, no network).
+
+The built app is <dir>, default dist/ (build it first). Its pages are those lernapps check visits; the start page
+comes first. Each is opened in Chromium, as a learner first sees it: nothing answered, no hover, animations off,
+fonts and images loaded; requests to other hosts are blocked. A figure is a block figure or labelled-figure, or any
+other figure with an image or a drawing. It is cut out with its caption, at twice its size on screen, from the page
+as the build writes it, without JavaScript, so that the figures of every question of a quiz are there too; a figure
+that takes no space, such as one in a closed details element, is left out. Another archetype, such as an interactive
+app, is not supported. Prints the folder and the number of pages and figures.
+
+Exit codes: 0 when the images are written, 1 when they cannot be (an archetype not supported, no browser can run),
+2 on a usage error, such as no build in <dir>. Then no folder is written or emptied.
+
+Output: one PNG per page, named by its order and path (01-index.png, 02-plan-selbsteinschaetzung.png), one PNG per
+figure, named by its page and its place on the page (02-plan-selbsteinschaetzung-figure-1.png), and the index.html,
+which shows the figures with their page, in the folder --out. The folder is emptied first. It is not part of the app: do not commit it.
+
+Options:
+  --out <dir>    the folder of the images (default screenshots)
+  --width <px>   the width of the images in pixels (default 390, a phone)
+  --desktop      also images 1280 px wide; every image is then named with its width (01-index-390.png,
+                 01-index-1280.png, 01-index-figure-1-1280.png)
+  -h, --help     print this help
+`;
+// archetypes/shared/install-hooks.ts
+/** The hooks, as the app's folder sees them once @lernapps/tooling is installed. */
+const HOOKS_DIR = "node_modules/@lernapps/tooling/archetypes/shared/hooks";
+/** Where git runs them from: a folder npm leaves alone when it replaces the package. */
+const GIT_HOOKS_DIR = "node_modules/.cache/lernapps/hooks";
+const HOOKS = ["pre-commit", "pre-push"];
+function installHooks(args) {
+	const { values } = parseArgs({
+		args,
+		options: HOOKS_OPTIONS,
+		strict: true,
+		allowPositionals: false
+	});
+	if (values.help) {
+		process.stdout.write(HOOKS_USAGE);
+		return 0;
+	}
+	const say = (message) => process.stdout.write(`lernapps hooks: ${message}\n`);
+	const prefix = spawnSync("git", ["rev-parse", "--show-prefix"], { encoding: "utf8" });
+	if (prefix.error || prefix.status !== 0) {
+		say("not in a git repository, no hooks installed (git init, then npm install again)");
+		return 0;
+	}
+	const inside = prefix.stdout.trim();
+	if (inside !== "") {
+		say(`this folder is ${inside} inside another git repository; its hooks stay as they are`);
+		return 0;
+	}
+	mkdirSync(GIT_HOOKS_DIR, { recursive: true });
+	for (const hook of HOOKS) writeFileSync(join(GIT_HOOKS_DIR, hook), `# Written by lernapps hooks: runs the ${hook} hook of the installed @lernapps/tooling.\n. ./${HOOKS_DIR}/${hook}\n`);
+	if (spawnSync("git", [
+		"config",
+		"--local",
+		"core.hooksPath"
+	], { encoding: "utf8" }).stdout.trim() === `node_modules/@lernapps/tooling/archetypes/shared/hooks/_`) spawnSync("git", [
+		"config",
+		"--local",
+		"core.hooksPath",
+		`${GIT_HOOKS_DIR}/_`
+	]);
+	const env = {
+		...process.env,
+		PATH: [join(process.cwd(), "node_modules", ".bin"), process.env["PATH"] ?? ""].join(delimiter)
+	};
+	const result = spawnSync("vp", [
+		"config",
+		"--no-agent",
+		"--hooks-dir",
+		GIT_HOOKS_DIR
+	], {
+		stdio: "inherit",
+		env
+	});
+	if (result.error) {
+		process.stderr.write(`lernapps hooks: cannot run vp: ${result.error.message}. Install the dependencies (npm ci)\n`);
+		return 1;
+	}
+	return result.status ?? 1;
+}
+// changes/changes.ts
+const KINDS = [
+	"app",
+	"tooling",
+	"site"
+];
+/**
+* The default map per kind of repo. The allowlists are the same for every kind; the kind decides what `docs` runs:
+* nothing in an app (docs are not part of its bundle), the site's checks and deployment in the tooling and in a site
+* or catalog repo.
+*/
+const DEFAULTS = {
+	app: {
+		kind: "app",
+		none: [".vibe/**"],
+		docs: ["docs/**/*.md"],
+		all: []
+	},
+	tooling: {
+		kind: "tooling",
+		none: [".vibe/**"],
+		docs: ["docs/**/*.md"],
+		all: []
+	},
+	site: {
+		kind: "site",
+		none: [".vibe/**"],
+		docs: ["docs/**/*.md"],
+		all: []
+	}
+};
+/** The npm script that checks the built site of a kind of repo, after `npm run build`; an app has no site. */
+const SITE_CHECK = {
+	app: void 0,
+	tooling: "check:site",
+	site: "check"
+};
+/** The repo's configuration in package.json is wrong; the message says what to fix. */
+var ChangesConfigError = class extends Error {};
+/**
+* A glob as a regular expression: `**` any number of folders, `*` any characters but "/", `?` one of them. A pattern
+* that ends with "/" is a folder and matches everything below it.
+*/
+function globToRegExp(pattern) {
+	const glob = pattern.endsWith("/") ? `${pattern}**` : pattern;
+	let source = "";
+	for (let i = 0; i < glob.length; i++) {
+		const char = glob[i] ?? "";
+		if (char === "*" && glob[i + 1] === "*") {
+			i++;
+			if (glob[i + 1] === "/") {
+				i++;
+				source += "(?:.*/)?";
+			} else source += ".*";
+		} else if (char === "*") source += "[^/]*";
+		else if (char === "?") source += "[^/]";
+		else source += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+	}
+	return new RegExp(`^${source}$`);
+}
+const compiled = /* @__PURE__ */ new Map();
+/** Whether a path (relative to the repo root, with "/") matches one of the patterns. */
+function matchesAny(path, patterns) {
+	return patterns.some((pattern) => {
+		let regexp = compiled.get(pattern);
+		if (regexp === void 0) {
+			regexp = globToRegExp(pattern);
+			compiled.set(pattern, regexp);
+		}
+		return regexp.test(path);
+	});
+}
+/**
+* The scope of the changed files. Undefined (not known) or empty is `all`: a change whose files are not known could
+* affect anything, and nothing staged means a run by hand.
+*/
+function classify(files, rules) {
+	if (files === void 0) return {
+		scope: "all",
+		reason: "the changed files are not known"
+	};
+	if (files.length === 0) return {
+		scope: "all",
+		reason: "no changed files are known"
+	};
+	let docs = 0;
+	for (const file of files) {
+		if (matchesAny(file, rules.all)) return {
+			scope: "all",
+			reason: `${file} is an exception of this repo (lernapps.changes.all)`
+		};
+		if (matchesAny(file, rules.none)) continue;
+		if (!matchesAny(file, rules.docs)) return {
+			scope: "all",
+			reason: `${file} is neither plan nor docs`
+		};
+		docs++;
+	}
+	const count = (n) => `${n} changed file${n === 1 ? "" : "s"}`;
+	return docs === 0 ? {
+		scope: "none",
+		reason: `${count(files.length)}, only the plan (${rules.none.join(", ")})`
+	} : {
+		scope: "docs",
+		reason: `${count(files.length)}, only docs (${rules.docs.join(", ")}) and the plan`
+	};
+}
+/**
+* The scope of a push: as classify, except that a push which changes no file (an empty start commit) is `none`. The
+* pushed commits are known, so there is nothing to check.
+*/
+function classifyPush(files, rules) {
+	return files?.length === 0 ? {
+		scope: "none",
+		reason: "the push changes no file"
+	} : classify(files, rules);
+}
+/** What runs for a scope in a kind of repo: the code (build, tests), the site's checks and deployment. */
+function runs(scope, kind) {
+	return {
+		code: scope === "all",
+		site: scope === "all" || scope === "docs" && SITE_CHECK[kind] !== void 0
+	};
+}
+const CONFIG_KEYS = [
+	"kind",
+	"none",
+	"docs",
+	"all"
+];
+function patterns(value, key) {
+	const where = `package.json lernapps.changes.${key}`;
+	if (!Array.isArray(value)) throw new ChangesConfigError(`${where}: a list of path patterns, not ${JSON.stringify(value)}`);
+	return value.map((item) => {
+		if (typeof item !== "string" || item === "") throw new ChangesConfigError(`${where}: every pattern is a non-empty string, not ${JSON.stringify(item)}`);
+		if (item.startsWith("/") || item.startsWith("!") || item.split("/").includes("..") || item.includes("\\")) throw new ChangesConfigError(`${where}: "${item}" must be relative to the repo root, with "/", without "..", and not negated with "!"`);
+		return item;
+	});
+}
+/** The kind of the repo in `dir` when its package.json names none: the tooling, an app (index.html), else a site. */
+function detectKind(dir, manifest) {
+	if (manifest["name"] === "@lernapps/tooling") return "tooling";
+	if (existsSync(join(dir, "index.html"))) return "app";
+	return "site";
+}
+/**
+* The rules of the repo in `dir`: the default map of its kind, with the exceptions its package.json declares in
+* `lernapps.changes` ({ kind?, none?, docs?, all? }: `none` and `docs` add patterns to the allowlists, `all` makes
+* paths `all` regardless). Throws ChangesConfigError when that configuration is malformed.
+*/
+function loadRules(dir) {
+	const file = join(dir, "package.json");
+	let manifest = {};
+	if (existsSync(file)) try {
+		const value = JSON.parse(readFileSync(file, "utf8"));
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) manifest = value;
+	} catch (error) {
+		throw new ChangesConfigError(`package.json: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const lernapps = manifest["lernapps"];
+	let config = {};
+	if (lernapps !== void 0) {
+		if (typeof lernapps !== "object" || lernapps === null || Array.isArray(lernapps)) throw new ChangesConfigError("package.json lernapps: an object");
+		const changes = lernapps["changes"];
+		if (changes !== void 0) {
+			if (typeof changes !== "object" || changes === null || Array.isArray(changes)) throw new ChangesConfigError("package.json lernapps.changes: an object with kind, none, docs, all");
+			config = changes;
+		}
+	}
+	const unknown = Object.keys(config).filter((key) => !CONFIG_KEYS.includes(key));
+	if (unknown.length > 0) throw new ChangesConfigError(`package.json lernapps.changes: unknown ${unknown.length === 1 ? "key" : "keys"} ${unknown.join(", ")} (known: ${CONFIG_KEYS.join(", ")})`);
+	let kind = detectKind(dir, manifest);
+	if (config["kind"] !== void 0) {
+		if (!KINDS.includes(config["kind"])) throw new ChangesConfigError(`package.json lernapps.changes.kind: one of ${KINDS.join(", ")}, not ${JSON.stringify(config["kind"])}`);
+		kind = config["kind"];
+	}
+	const defaults = DEFAULTS[kind];
+	const extra = (key) => config[key] === void 0 ? [] : patterns(config[key], key);
+	return {
+		kind,
+		none: [...defaults.none, ...extra("none")],
+		docs: [...defaults.docs, ...extra("docs")],
+		all: [...defaults.all, ...extra("all")]
+	};
+}
+const ZERO = /^0+$/;
+const git$1 = (cwd, ...args) => spawnSync("git", args, {
+	cwd,
+	encoding: "utf8",
+	maxBuffer: 67108864
+});
+/** The paths of `git diff --name-only -z`; renames as a deletion and an addition, so both paths count. */
+function diffNames(cwd, ...args) {
+	const diff = git$1(cwd, "diff", "--name-only", "--no-renames", "-z", ...args);
+	if (diff.error || diff.status !== 0) return void 0;
+	return diff.stdout.split("\0").filter((path) => path !== "");
+}
+const isCommit = (cwd, rev) => git$1(cwd, "cat-file", "-e", `${rev}^{commit}`).status === 0;
+/**
+* What a new branch is compared with: its merge base with origin/main; when the remote has no main yet (the first push
+* of a new repo), the empty tree, so the branch adds everything it holds (nothing, for an empty start commit).
+*/
+function newBranchBase(cwd, local) {
+	if (git$1(cwd, "rev-parse", "--verify", "--quiet", "origin/main").status !== 0) {
+		const empty = spawnSync("git", [
+			"hash-object",
+			"-t",
+			"tree",
+			"--stdin"
+		], {
+			cwd,
+			encoding: "utf8",
+			input: ""
+		});
+		return {
+			base: empty.status === 0 ? empty.stdout.trim() : "",
+			tree: true
+		};
+	}
+	return {
+		base: git$1(cwd, "merge-base", local, "origin/main").stdout.trim(),
+		tree: false
+	};
+}
+/** The staged files of the next commit (the pre-commit hook); undefined outside a repository. */
+function stagedFiles(cwd = ".") {
+	return diffNames(cwd, "--cached");
+}
+/**
+* The files a push changes (the pre-push hook), from git's lines "<local ref> <local sha> <remote ref> <remote sha>":
+* what each pushed ref adds to the remote's commit; for a new branch, what it adds to its merge base with
+* origin/main, or to the empty tree when the remote has no main yet. Undefined when that cannot be known: no lines
+* (run by hand), an unknown commit.
+*/
+function pushedFiles(lines, cwd = ".") {
+	const refs = lines.split("\n").map((line) => line.trim().split(/\s+/)).filter((fields) => fields.length === 4);
+	if (refs.length === 0) return void 0;
+	const paths = /* @__PURE__ */ new Set();
+	for (const [, local = "", , remote = ""] of refs) {
+		if (ZERO.test(local)) continue;
+		const { base, tree } = ZERO.test(remote) ? newBranchBase(cwd, local) : {
+			base: remote,
+			tree: false
+		};
+		if (base === "" || !tree && !isCommit(cwd, base)) return void 0;
+		const names = diffNames(cwd, base, local);
+		if (names === void 0) return void 0;
+		for (const path of names) paths.add(path);
+	}
+	return [...paths];
+}
+/** Fetches the whole history once, when the clone is shallow (as actions/checkout makes it by default). */
+function unshallow(cwd) {
+	if (git$1(cwd, "rev-parse", "--is-shallow-repository").stdout.trim() !== "true") return false;
+	return git$1(cwd, "fetch", "--quiet", "--no-tags", "--unshallow", "origin").status === 0;
+}
+/**
+* The files between two commits: with `mergeBase`, what `head` adds to its merge base with `base` (a pull request);
+* else the difference from `base` to `head` (a push: before..after). A shallow clone is deepened once when a commit
+* or the merge base is missing. Undefined when the commits cannot be found.
+*/
+function rangeFiles(base, head, mergeBase, cwd = ".") {
+	const attempt = () => {
+		if (!isCommit(cwd, base) || !isCommit(cwd, head)) return void 0;
+		const from = mergeBase ? git$1(cwd, "merge-base", base, head).stdout.trim() : base;
+		return from === "" ? void 0 : diffNames(cwd, from, head);
+	};
+	return attempt() ?? (unshallow(cwd) ? attempt() : void 0);
+}
+/**
+* The files of the GitHub Actions event (GITHUB_EVENT_NAME, GITHUB_EVENT_PATH): a pull request, what it adds to the
+* merge base with its base; a push, before..after. A new branch (before is zeros), workflow_dispatch and every other
+* event: undefined, so everything runs.
+*/
+function eventFiles(env = process.env, cwd = ".") {
+	const name = env["GITHUB_EVENT_NAME"];
+	const path = env["GITHUB_EVENT_PATH"];
+	if (name === void 0 || path === void 0 || !existsSync(path)) return void 0;
+	let event;
+	try {
+		event = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+	const sha = (value) => typeof value === "string" && /^[0-9a-f]{40}$/.test(value) && !ZERO.test(value) ? value : void 0;
+	if (name === "pull_request" || name === "pull_request_target") {
+		const base = sha(event.pull_request?.base?.sha);
+		const head = sha(event.pull_request?.head?.sha);
+		return base && head ? rangeFiles(base, head, true, cwd) : void 0;
+	}
+	if (name === "push") {
+		const before = sha(event.before);
+		const after = sha(event.after);
+		return before && after ? rangeFiles(before, after, false, cwd) : void 0;
+	}
+}
+/** Standard input, as git gives it to the pre-push hook; empty when it is a terminal or closed. */
+function readStdin() {
+	try {
+		return process.stdin.isTTY ? "" : readFileSync(0, "utf8");
+	} catch {
+		return "";
+	}
+}
+/** `lernapps changes`: prints the scope; with --ci also the step outputs and a notice. */
+function changes(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: CHANGES_OPTIONS,
+		strict: true,
+		allowPositionals: true
+	});
+	if (values.help) {
+		process.stdout.write(CHANGES_USAGE);
+		return 0;
+	}
+	if ([
+		values.staged,
+		values.pushed,
+		values.ci,
+		values.base !== void 0,
+		positionals.length > 0
+	].filter(Boolean).length > 1) throw new UsageError("changes takes one source: --staged, --pushed, --ci, --base <rev> or <path>...");
+	if (values.head !== void 0 && values.base === void 0) throw new UsageError("--head needs --base <rev>");
+	let rules;
+	try {
+		rules = loadRules(".");
+	} catch (error) {
+		if (!(error instanceof ChangesConfigError)) throw error;
+		process.stderr.write(`lernapps changes: ${error.message}\n`);
+		return 1;
+	}
+	const { scope, reason } = classify(values.staged ? stagedFiles() : values.pushed ? pushedFiles(readStdin()) : values.ci ? eventFiles() : values.base !== void 0 ? rangeFiles(values.base, values.head ?? "HEAD", true) : positionals.length > 0 ? positionals : void 0, rules);
+	const run = runs(scope, rules.kind);
+	process.stdout.write(`${scope}\n`);
+	process.stderr.write(`lernapps changes: ${scope} in a repo of kind ${rules.kind}: ${reason}\n`);
+	if (values.ci) {
+		const output = process.env["GITHUB_OUTPUT"];
+		const lines = [
+			`scope=${scope}`,
+			`kind=${rules.kind}`,
+			`code=${run.code}`,
+			`site=${run.site}`
+		];
+		if (output !== void 0 && output !== "") appendFileSync(output, `${lines.join("\n")}\n`);
+		if (scope !== "all") {
+			const what = run.site ? "only the site's checks and deployment run" : "nothing to build, check or publish";
+			process.stdout.write(`::notice title=lernapps changes::change scope ${scope}: ${what} (${reason})\n`);
+		}
+	}
+	return 0;
+}
+// generator/architecture.ts
+/** Where an app keeps its architecture, and where app-templates keeps the generic part. */
+const ARCHITECTURE = join("docs", "arc42");
+/** The archetypes whose apps get the architecture and its checks. */
+const ARCHITECTURE_ARCHETYPES = ["interactive"];
+/** The mark of a reference file, which `lernapps update` replaces outside its app sections. */
+const REFERENCE = "lernapps update replaces this file";
+/** A marker of an app section: `<!-- app: begin <name> -->` or `<!-- app: end <name> -->`, the name optional. */
+const APP_MARKER = /^<!-- app: (begin|end)(?: ([a-z0-9-]+))? -->$/;
+/** The app's architecture cannot be replaced; the message says why and what to do. */
+var ArchitectureError = class extends Error {};
+const TOP = "<!-- at the top of the generic chapter -->";
+const END = "<!-- end -->";
+const RUNTIME_PATH = "installed package @lernapps/app-templates (arc42 cannot resolve untracked paths, docToolchain/arc42-language#128)";
+const chapterFiles = (dir) => existsSync(dir) ? readdirSync(dir).filter((name) => /^\d{2}-.*\.arc42\.md$/.test(name)).sort() : [];
+/** The lines of a file, without the trailing newline. */
+const linesOf = (file) => readFileSync(file, "utf8").replace(/\n$/, "").split("\n");
+/**
+* The paths of the blocks and interfaces, for the app: `path: runtime/...` becomes an ignore directive (H014, the
+* missing path) before the element; `path: <archetype>/...` loses the prefix.
+*/
+function rewritePaths(lines, archetype) {
+	const out = [];
+	let element;
+	for (const line of lines) {
+		if (element === void 0) {
+			if (line === ":::building-block" || line === ":::interface") element = [line];
+			else out.push(line);
+			continue;
+		}
+		if (line !== ":::") {
+			element.push(line);
+			continue;
+		}
+		const path = element.find((text) => text.startsWith("path: "))?.slice(6);
+		if (path !== void 0 && (path === "runtime" || path.startsWith("runtime/"))) {
+			if (out.at(-1) === ":::" && out.at(-2)?.startsWith(":::ignore H020 ")) out.splice(-2, 2);
+			out.push(`:::ignore H014 ${RUNTIME_PATH}`, ":::", ...element.filter((text) => !text.startsWith("path: ")));
+		} else if (path?.startsWith(`${archetype}/`)) out.push(...element.map((text) => text === `path: ${path}` ? `path: ${path.slice(archetype.length + 1)}` : text));
+		else out.push(...element);
+		out.push(line);
+		element = void 0;
+	}
+	if (element !== void 0) out.push(...element);
+	return out;
+}
+/** The combined chapters of the generic part and `archetype`'s extension in a checkout of app-templates, by name. */
+function combine(templates, archetype, commit) {
+	const generic = join(templates, ARCHITECTURE);
+	const extension = join(templates, archetype, ARCHITECTURE);
+	const chapters = /* @__PURE__ */ new Map();
+	for (const name of chapterFiles(generic)) {
+		const lines = [];
+		const top = [];
+		const add = (file, own) => {
+			let atTop = false;
+			linesOf(file).forEach((text, index) => {
+				if (own && index === 0 && text.startsWith("# ")) return;
+				if (own && text === TOP) atTop = true;
+				if (atTop) {
+					if (text === END) atTop = false;
+					else if (text !== TOP) top.push(text);
+					return;
+				}
+				lines.push(text);
+			});
+		};
+		add(join(generic, name), false);
+		for (const own of chapterFiles(extension).filter((candidate) => candidate.slice(0, 3) === name.slice(0, 3))) {
+			lines.push("");
+			add(join(extension, own), true);
+		}
+		const mark = `<!-- From @lernapps/app-templates ${commit.slice(0, 7)} (the generic part and the ${archetype} extension): ${REFERENCE} except the app sections, between <!-- app: begin … --> and <!-- app: end … -->, which hold the app's own architecture. -->`;
+		lines.splice(1, 0, "", mark, ...top.length > 0 ? ["", ...top] : []);
+		chapters.set(name, `${rewritePaths(lines, archetype).join("\n")}\n`);
+	}
+	return chapters;
+}
+/** The reference files of the app's architecture: those that carry REFERENCE. */
+function referenceFiles(dir) {
+	const folder = join(dir, ARCHITECTURE);
+	if (!existsSync(folder)) return [];
+	return readdirSync(folder).filter((name) => name.endsWith(".arc42.md")).filter((name) => linesOf(join(folder, name)).slice(0, 4).join("\n").includes(REFERENCE)).sort();
+}
+/** Whether the app has the architecture from lernapps create or update, which its checks then validate. */
+const hasArchitecture = (dir = ".") => referenceFiles(dir).length > 0;
+/** The archetype whose extension the app's reference holds, as its mark names it; undefined without a reference. */
+function architectureArchetype(dir = ".") {
+	const [first] = referenceFiles(dir);
+	if (first === void 0) return void 0;
+	return /the generic part and the ([a-z-]+) extension/.exec(readFileSync(join(dir, ARCHITECTURE, first), "utf8"))?.[1];
+}
+/** The app sections of a file's lines, by name ("" for the unnamed one): the lines between their markers. */
+function appSections(lines) {
+	const sections = /* @__PURE__ */ new Map();
+	let open;
+	for (const line of lines) {
+		const marker = APP_MARKER.exec(line);
+		if (marker?.[1] === "begin") {
+			open = marker[2] ?? "";
+			sections.set(open, []);
+		} else if (marker?.[1] === "end") open = void 0;
+		else if (open !== void 0) sections.get(open)?.push(line);
+	}
+	return sections;
+}
+/** The lines with each app section's content replaced by that of `sections`, where it has one. */
+function fillSections(lines, sections) {
+	const out = [];
+	let open;
+	for (const line of lines) {
+		const marker = APP_MARKER.exec(line);
+		if (marker?.[1] === "begin") {
+			open = marker[2] ?? "";
+			out.push(line, ...sections.get(open) ?? []);
+		} else if (marker?.[1] === "end") {
+			open = void 0;
+			out.push(line);
+		} else if (open === void 0) out.push(line);
+	}
+	return out;
+}
+const sectionName = (file, name) => `${file}${name === "" ? " (at its end)" : ` (${name})`}`;
+/**
+* Replaces the app's reference files with the combination of a checkout of app-templates, keeping the content of each
+* app section. It writes nothing when an app section with content has no place in the new reference (it would be
+* lost) and says so (ArchitectureError). What it did, as lines of the output.
+*/
+function writeArchitecture(dir, templates, archetype, commit) {
+	const folder = join(dir, ARCHITECTURE);
+	const before = new Map(referenceFiles(dir).map((name) => [name, readFileSync(join(folder, name), "utf8")]));
+	const kept = new Map([...before].map(([name, text]) => [name, appSections(text.replace(/\n$/, "").split("\n"))]));
+	const chapters = new Map([...combine(templates, archetype, commit)].map(([name, text]) => {
+		const lines = text.replace(/\n$/, "").split("\n");
+		return [name, {
+			lines,
+			sections: appSections(lines)
+		}];
+	}));
+	const lost = [...kept].flatMap(([name, sections]) => [...sections].filter(([section, lines]) => lines.some((line) => line.trim() !== "") && !chapters.get(name)?.sections.has(section)).map(([section]) => sectionName(name, section)));
+	if (lost.length > 0) throw new ArchitectureError(`the reference of app-templates ${commit.slice(0, 7)} has no place for the app sections ${lost.join(", ")}: nothing was replaced. Move their content into an app section the new reference has (compare with ${archetype}/${ARCHITECTURE}/ of app-templates at that commit), then run it again`);
+	for (const name of before.keys()) rmSync(join(folder, name));
+	mkdirSync(folder, { recursive: true });
+	let changed = 0;
+	for (const [name, { lines }] of chapters) {
+		const text = `${fillSections(lines, kept.get(name) ?? /* @__PURE__ */ new Map()).join("\n")}\n`;
+		writeFileSync(join(folder, name), text);
+		if (before.get(name) !== text) changed++;
+	}
+	const removed = [...before.keys()].filter((name) => !chapters.has(name)).length;
+	return changed + removed === 0 ? [] : [`architecture: ${ARCHITECTURE}/ has the reference of app-templates ${commit.slice(0, 7)} (${chapters.size} chapters, the generic part and the ${archetype} extension), with the app's own sections as they were`];
+}
+// generator/create.ts
+/** The options of `lernapps create`, as node:util parseArgs takes them. */
+const CREATE_OPTIONS = {
+	archetype: { type: "string" },
+	plan: { type: "string" },
+	templates: { type: "string" },
+	tooling: { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h",
+		default: false
+	}
+};
+const CREATE_USAGE = `Usage: lernapps create --archetype <name> [<dir>] [--plan <file>] [--templates <repo>] [--tooling <spec>]
+
+Writes a new app from the archetype's template into <dir> (default: the current folder), which must be empty
+except for .git, the first version's plan .vibe/plans/01-<short name>.md and the skills that npx skills add
+lernapps init synced (.agents/skills/, .claude/skills/, skills-lock.json, and the package.json, package-lock.json and
+node_modules init wrote). The template is the folder <name>/ of the installed package @lernapps/app-templates, the
+version @lernapps/tooling depends on; the app depends on the runtime of the same version.
+
+It needs the plan of the first version, confirmed by the creator: started from the plan template as
+.vibe/plans/01-<short name>.md, the only plan there, worked through Explore and Plan, now in the phase code
+(phase: code in its front matter), with the same archetype as --archetype. A plan .vibe/plan.md of an earlier
+tooling is moved to .vibe/plans/01-first-version.md. Without a plan, it writes nothing and says what to do.
+
+Run it in the folder lernapps init prepared, from the tooling init installed:
+  npx lernapps create --archetype <name> [<dir>]
+It needs git, and the npm registry for the npm install that follows. The app then depends on the version of
+@lernapps/tooling that created it, and its workflows use the actions of that version's tag.
+
+It writes, besides the template: package.json named after the folder (its prepare script, lernapps hooks,
+installs the git hooks; for an explainer and an interactive app also vue-tsc and typescript, with which lernapps
+check type-checks its Vue components; for an interactive app also @doctc/arc42, which checks its architecture),
+for an interactive app its architecture docs/arc42/ (the generic part and the interactive extension of app-templates,
+which lernapps update replaces except the marked app sections, where the app's own part goes),
+AGENTS.md, the plan in .vibe/plans/ (the one already there is kept), the content guide
+.agents/skills/app-content/SKILL.md (a skeleton the assistant fills in; linked as .claude/skills/app-content for
+Claude Code where the system allows symbolic links), the workflow
+.github/workflows/pages.yml (the app check action on every pull request and push to main; on main, then the app
+publish action to the repo's GitHub Pages), an issue form for content errors, LICENSE (MIT), renovate.json (the
+Renovate preset of lernapps). The installed skills and skills-lock.json are committed with the app, like the
+content guide; lernapps update replaces the lernapps-* skills.
+
+Then: git init (if <dir> is not a repository yet), npm install (installs the git hooks), and the first commit.
+
+Exit codes: 0 when the app is written, 1 when it cannot be (the message says why), 2 on a usage error.
+
+Options:
+  --archetype <name>  the archetype chosen in the plan: {archetypes}
+  --plan <file>       the confirmed plan to carry over to .vibe/plans/01-<short name>.md, the short name from
+                      its file name <NN>-<short name>.md, else 01-plan.md (default: the one in <dir>)
+  --templates <dir>   the package @lernapps/app-templates to copy from: its folder, or a clone of its repository
+                      (default: the environment variable LERNAPPS_TEMPLATES, else the installed package)
+  --tooling <spec>    the npm spec of @lernapps/tooling the app depends on (default: ^ the version of this
+                      @lernapps/tooling)
+  -h, --help          print this help
+`;
+/** The generator cannot write the app; the message says why and what to do. */
+var CreateError = class extends Error {};
+const packageRoot = fileURLToPath(new URL("..", import.meta.url));
+const fromPackage = (...path) => join(packageRoot, ...path);
+const readJson = (file) => JSON.parse(readFileSync(file, "utf8"));
+const writeJson = (file, value) => writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+/** The runtime package, which also carries the templates. */
+const RUNTIME = "@lernapps/app-templates";
+/**
+* The package @lernapps/app-templates: the folder named (a local copy or clone), else the one installed next to this
+* package, the version it depends on.
+*/
+function templatesPackage(dir) {
+	let root;
+	if (dir !== void 0) root = resolve(dir);
+	else try {
+		root = dirname(createRequire(import.meta.url).resolve(`${RUNTIME}/package.json`));
+	} catch {
+		throw new CreateError(`the package ${RUNTIME} is not installed: it is a dependency of @lernapps/tooling, so run npm install, or name a copy with --templates <dir> or LERNAPPS_TEMPLATES`);
+	}
+	if (!existsSync(join(root, "package.json"))) throw new CreateError(`${root} is no package ${RUNTIME}: it has no package.json`);
+	const manifest = readJson(join(root, "package.json"));
+	return {
+		root,
+		version: manifest.version ?? "0.0.0",
+		archetypes: [...manifest.lernapps?.archetypes ?? []].sort()
+	};
+}
+/** The version of this package. */
+const ownVersion = () => readJson(fromPackage("package.json")).version ?? "0.0.0";
+/** The lock file of `npx skills add`, next to the skills it installed. */
+const SKILLS_LOCK = "skills-lock.json";
+/** The skills that `npx skills add` installed into the folder: the names in its lock file. */
+function installedSkills(dir) {
+	try {
+		const lock = JSON.parse(readFileSync(join(dir, SKILLS_LOCK), "utf8"));
+		return new Set(Object.keys(lock.skills ?? {}));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+/**
+* What is in the folder besides .git, the plans (src/plan.ts) and the skills as `npx skills add lernapps/tooling`
+* installs them: each skill of its lock file in .agents/skills/<skill>/ and, for Claude Code, .claude/skills/<skill>
+* (a link to it, or a copy with --copy).
+*/
+function contents(dir) {
+	if (!existsSync(dir)) return [];
+	if (!statSync(dir).isDirectory()) throw new CreateError(`${dir} is a file, not a folder`);
+	const skills = installedSkills(dir);
+	const within = (folder, keep) => readdirSync(join(dir, folder)).filter((name) => !keep(name)).map((name) => `${folder}/${name}`);
+	return readdirSync(dir).flatMap((name) => {
+		if (name === ".git" || name === "skills-lock.json" && skills.size > 0) return [];
+		if (name === "node_modules" || name === "package-lock.json") return [];
+		if (name === "package.json" && readJson(join(dir, name)).lernapps?.init === true) return [];
+		if (name === ".vibe") return within(name, (file) => file === "plan.md" || file === "plans").concat(existsSync(join(dir, ".vibe/plans")) ? within(PLANS, (file) => PLAN_NAME.test(file)) : []);
+		if ((name === ".agents" || name === ".claude") && skills.size > 0) return within(name, (folder) => folder === "skills").concat(existsSync(join(dir, name, "skills")) ? within(`${name}/skills`, (skill) => skills.has(skill)) : []);
+		return [name];
+	});
+}
+function git(args, cwd) {
+	const result = spawnSync("git", args, {
+		cwd,
+		encoding: "utf8"
+	});
+	if (result.error) throw new CreateError(`git cannot run: ${result.error.message}. Install git, then create again`);
+	return {
+		ok: result.status === 0,
+		out: `${result.stdout}${result.stderr}`.trim()
+	};
+}
+/** A package name from the folder's name: lower case, letters, digits and hyphens. */
+const packageName = (dir) => basename(dir).toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+/** This package, as an app depends on it. */
+const TOOLING = "@lernapps/tooling";
+/**
+* What the apps of an archetype need beyond its template, as development dependencies: an explainer's Vue components
+* (src/components/<Name>.vue) are type-checked by vue-tsc, which `lernapps check` runs once the app has a .vue file.
+* The same versions as in app-templates; Renovate moves them in the app.
+*/
+const ARCHETYPE_DEV_DEPENDENCIES = {
+	explainer: {
+		typescript: "6.0.3",
+		"vue-tsc": "3.3.11"
+	},
+	interactive: {
+		"@doctc/arc42": "0.38.0",
+		typescript: "6.0.3",
+		"vue-tsc": "3.3.11"
+	}
+};
+const START_THE_PLAN = "start the plan of the first version from the plan template with `npx --yes @lernapps/tooling init <short name>` in an empty folder, which writes it complete and unchanged as .vibe/plans/01-<short name>.md, and work through Explore and Plan with the creator first";
+/**
+* The first version's plan: the one given (carried over to .vibe/plans/01-<short name>.md), else the only one in
+* the folder's .vibe/plans/, numbered 01, else a .vibe/plan.md of an earlier tooling (moved to
+* .vibe/plans/01-first-version.md, as lernapps update moves it).
+*/
+function firstPlan(dir, given) {
+	const found = plans(dir).map((plan) => join(dir, plan));
+	const legacy = existsSync(join(dir, ".vibe/plan.md")) ? [join(dir, LEGACY_PLAN)] : [];
+	if (given !== void 0) {
+		if (!existsSync(given)) throw new CreateError(`there is no plan ${given}: ${START_THE_PLAN}`);
+		const others = [...found, ...legacy].filter((plan) => resolve(plan) !== resolve(given));
+		if (others.length > 0) throw new CreateError(`${others.join(", ")} is already there besides the plan ${given} (--plan): a new app has one plan, the first version's; remove the one that is not confirmed`);
+		const name = /^\d{2}-([^/\\]+\.md)$/.exec(basename(given))?.[1] ?? "plan.md";
+		return {
+			file: given,
+			target: join(dir, PLANS, `01-${name}`)
+		};
+	}
+	if (found.length + legacy.length > 1) throw new CreateError(`there is more than one plan (${[...found, ...legacy].join(", ")}): a new app has one plan, the first version's, .vibe/plans/01-<short name>.md; keep the one the creator confirmed, or name it with --plan <file>`);
+	const [plan] = found;
+	if (plan !== void 0) {
+		if (!basename(plan).startsWith("01-")) throw new CreateError(`the plan ${plan} is not numbered 01: the first version's plan is .vibe/plans/01-<short name>.md, from the plan template; rename it`);
+		return {
+			file: plan,
+			target: plan
+		};
+	}
+	const [old] = legacy;
+	if (old !== void 0) return {
+		file: old,
+		target: join(dir, MIGRATED_PLAN)
+	};
+	throw new CreateError(`there is no plan in ${join(dir, PLANS)}: ${START_THE_PLAN}`);
+}
+/**
+* The plan the app is created from, which the creator has confirmed: it is in the phase code (or later), for this
+* archetype. The front matter is read as the hooks read it (src/plan.ts).
+*/
+function confirmedPlan(dir, archetype, given) {
+	const found = firstPlan(dir, given);
+	const plan = found.file;
+	const values = planFrontMatter(plan);
+	const phase = values["phase"];
+	if (phase === "explore" || phase === "plan") throw new CreateError(`the plan ${plan} is in the phase ${phase}: the creator must confirm the plan first. Work through Explore and Plan with the creator; the Plan phase ends with phase: code, then create the app`);
+	if (phase !== "code" && phase !== "commit") throw new CreateError(`the plan ${plan} has no phase code in its front matter: ${START_THE_PLAN}`);
+	if (values["archetype"] !== archetype) throw new CreateError(`the plan ${plan} chose the archetype ${String(values["archetype"])}, not ${archetype} (--archetype): create the app with the archetype of the plan, or change the plan with the creator first`);
+	return found;
+}
+/** The plan at its place in .vibe/plans/: the one in the folder stays, a legacy one moves, one given is copied. */
+function writePlan(dir, plan) {
+	if (resolve(plan.file) === resolve(plan.target)) return;
+	mkdirSync(dirname(plan.target), { recursive: true });
+	if (resolve(plan.file) === resolve(join(dir, ".vibe/plan.md"))) renameSync(plan.file, plan.target);
+	else writeFileSync(plan.target, readFileSync(plan.file));
+}
+/**
+* The lines an earlier generator appended to .gitignore, to ignore the skills `npx skills add lernapps/tooling`
+* installed. Apps now commit them (every checkout has the skills of the tooling the app is on); `lernapps update`
+* removes these lines from an app that has them.
+*/
+const IGNORED_SKILLS_LINES = [
+	"# the skills npx skills add lernapps/tooling installed: each checkout installs them; the content guide is the app's",
+	`/${SKILLS_LOCK}`,
+	"/.agents/skills/*",
+	"!/.agents/skills/app-content/",
+	"/.claude/skills/*",
+	"!/.claude/skills/app-content"
+];
+/** The files every app has (generator/app/), with their placeholders filled. */
+function writeAppFiles(dir, values) {
+	const source = fromPackage("generator", "app");
+	const walk = (folder) => readdirSync(folder, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? walk(join(folder, entry.name)) : [join(folder, entry.name)]);
+	for (const file of walk(source)) {
+		const target = join(dir, relative(source, file));
+		mkdirSync(dirname(target), { recursive: true });
+		const text = readFileSync(file, "utf8").replace(/\{\{(\w+)\}\}/g, (match, key) => values[key] ?? match);
+		writeFileSync(target, text);
+	}
+	writeFileSync(join(dir, "AGENTS.md"), readFileSync(fromPackage("guidance", "AGENTS.md")));
+}
+/** The app's content guide, an app-local skill: written as a skeleton, filled in by the assistant. */
+const CONTENT_GUIDE = ".agents/skills/app-content/SKILL.md";
+/** Where Claude Code looks for the skills of a project: a relative symbolic link to the guide's folder. */
+const CONTENT_GUIDE_LINK = ".claude/skills/app-content";
+/**
+* Adds the content guide's skeleton and its link where they are missing; what it did, one line per file. The link is
+* relative, so it survives a move, a commit and a clone (git keeps it as a link). Where the system allows no symbolic
+* link (Windows without Developer Mode) it is left out: AGENTS.md names the guide's path, which every harness reads.
+*/
+function addContentGuide(dir) {
+	const done = [];
+	const guide = join(dir, CONTENT_GUIDE);
+	if (!existsSync(guide)) {
+		mkdirSync(dirname(guide), { recursive: true });
+		writeFileSync(guide, readFileSync(fromPackage("generator", "app", CONTENT_GUIDE)));
+		done.push(`added ${CONTENT_GUIDE}; fill it in from the plan, as its comments say`);
+	}
+	const link = join(dir, CONTENT_GUIDE_LINK);
+	if (!existsSync(link)) try {
+		rmSync(link, { force: true });
+		mkdirSync(dirname(link), { recursive: true });
+		symlinkSync("../../.agents/skills/app-content", link, "dir");
+		done.push(`linked ${CONTENT_GUIDE_LINK} to it for Claude Code`);
+	} catch (error) {
+		done.push(`could not link ${CONTENT_GUIDE_LINK} (${error instanceof Error ? error.message : String(error)}); AGENTS.md names ${CONTENT_GUIDE}, which is enough`);
+	}
+	return done;
+}
+function create(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: CREATE_OPTIONS,
+		strict: true,
+		allowPositionals: true
+	});
+	const templates = templatesPackage(values.templates ?? process.env["LERNAPPS_TEMPLATES"]);
+	const known = templates.archetypes;
+	if (values.help) {
+		process.stdout.write(CREATE_USAGE.replace("{archetypes}", known.join(", ")));
+		return 0;
+	}
+	const archetype = values.archetype;
+	if (archetype === void 0) throw new UsageError(`create needs --archetype <name> (${known.join(", ")})`);
+	if (!known.includes(archetype)) throw new UsageError(`unknown archetype: ${archetype} (known: ${known.join(", ")})`);
+	if (positionals.length > 1) throw new UsageError(`one <dir> at most, not ${positionals.join(" ")}`);
+	const dir = resolve(positionals[0] ?? ".");
+	const found = contents(dir);
+	if (found.length > 0) throw new CreateError(`${dir} is not empty (${found.slice(0, 5).join(", ")}${found.length > 5 ? ", ..." : ""}): create the app in an empty folder; only .git, the first version's plan .vibe/plans/01-<short name>.md and the skills that npx skills add lernapps/tooling installed may be there`);
+	const plan = confirmedPlan(dir, archetype, values.plan);
+	const architecture = ARCHITECTURE_ARCHETYPES.includes(archetype);
+	if (!existsSync(join(templates.root, archetype, "package.json"))) throw new CreateError(`${templates.root} has no template ${archetype}/ (version ${templates.version})`);
+	const initialised = existsSync(join(dir, "package.json")) ? readJson(join(dir, "package.json")) : void 0;
+	const initialLock = existsSync(join(dir, "package-lock.json")) ? readFileSync(join(dir, "package-lock.json"), "utf8") : void 0;
+	mkdirSync(dir, { recursive: true });
+	cpSync(join(templates.root, archetype), dir, { recursive: true });
+	rmSync(join(dir, "package-lock.json"), { force: true });
+	if (initialLock !== void 0) writeFileSync(join(dir, "package-lock.json"), initialLock);
+	if (existsSync(join(dir, "_gitignore"))) renameSync(join(dir, "_gitignore"), join(dir, ".gitignore"));
+	rmSync(join(dir, "README.md"), { force: true });
+	rmSync(join(dir, ARCHITECTURE), {
+		recursive: true,
+		force: true
+	});
+	if (existsSync(join(dir, "docs")) && readdirSync(join(dir, "docs")).length === 0) rmSync(join(dir, "docs"), { recursive: true });
+	if (architecture) writeArchitecture(dir, templates.root, archetype, templates.version);
+	else rmSync(join(dir, ".arc42ignore"), { force: true });
+	const app = readJson(join(dir, "package.json"));
+	const name = packageName(dir);
+	app.name = name;
+	app.scripts = {
+		...app.scripts,
+		prepare: "lernapps hooks"
+	};
+	if (app.devDependencies?.["@lernapps/app-templates"] !== void 0) {
+		app.devDependencies = {
+			...app.devDependencies,
+			[RUNTIME]: `^${templates.version}`
+		};
+		rmSync(join(dir, ".npmrc"), { force: true });
+	}
+	const tooling = values.tooling ?? `^${ownVersion()}`;
+	app.devDependencies = {
+		...app.devDependencies,
+		...ARCHETYPE_DEV_DEPENDENCIES[archetype],
+		...initialised?.devDependencies,
+		[TOOLING]: tooling
+	};
+	app.devDependencies = Object.fromEntries(Object.entries(app.devDependencies).sort(([a], [b]) => a.localeCompare(b)));
+	writeJson(join(dir, "package.json"), app);
+	const holder = git(["config", "user.name"], existsSync(dir) ? dir : process.cwd());
+	const moved = resolve(plan.file) === resolve(join(dir, LEGACY_PLAN));
+	writePlan(dir, plan);
+	writeAppFiles(dir, {
+		tooling: `v${ownVersion()}`,
+		year: String((/* @__PURE__ */ new Date()).getFullYear()),
+		holder: holder.ok && holder.out !== "" ? holder.out : "the creator of this app"
+	});
+	const guide = addContentGuide(dir).filter((line) => line.startsWith("could not"));
+	process.stdout.write([
+		`lernapps create: the ${archetype} app ${name} in ${dir} (app-templates ${templates.version})`,
+		...guide.map((line) => `Content guide: ${line}`),
+		...moved ? [`Plan: moved ${LEGACY_PLAN} to ${relative(dir, plan.target)}`] : [],
+		`Next: ${existsSync(join(dir, ".git")) ? "" : "git init, "}npm install, then follow ${relative(dir, plan.target)}`,
+		""
+	].join("\n"));
+	return 0;
+}
+// generator/init.ts
+/** The options of `lernapps init`, as node:util parseArgs takes them. */
+const INIT_OPTIONS = {
+	addon: { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h",
+		default: false
+	}
+};
+const INIT_USAGE = `Usage: lernapps init <short name> [--addon <package>]
+
+Starts an app in the current folder, which must be empty except for .git. It needs git, Node and the npm registry; nothing
+else. In order:
+  package.json                  names the folder, depends on @lernapps/tooling (this version) and the add-on
+  npm install                   installs them
+  .vibe/plans/01-<short name>.md
+                                the plan template of the add-on, else of this tooling, copied complete and unchanged
+  .agents/skills/, ...          the skills of the installed packages, for every agent \`skills\` finds, except those of
+                                the archetypes: after the plan chose one, run \`lernapps skills --archetype <name>\`
+
+Then follow the plan: it says what to do, and when to wait for the creator.
+
+Options:
+  --addon <package>  a package that extends the tooling, e.g. @lernapps/practice: its plan template and its skills
+  -h, --help         print this help
+`;
+/** The options of `lernapps skills`. */
+const SKILLS_OPTIONS = {
+	archetype: { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h",
+		default: false
+	}
+};
+const SKILLS_USAGE = `Usage: lernapps skills --archetype <name>
+
+Adds the skills of the archetype the plan chose to the agent directories (.agents/skills/ and those of the agents
+\`skills\` finds), next to those lernapps init synced. The skills of the other archetypes stay out.
+
+Options:
+  --archetype <name>  the archetype of the plan
+  -h, --help          print this help
+`;
+/** The version of the package `skills` that does the sync, as this tooling depends on it. */
+const SKILLS_BIN = () => {
+	const manifest = createRequire(import.meta.url).resolve("skills/package.json");
+	const bin = readJson(manifest)["bin"];
+	return join(dirname(manifest), bin?.["skills"] ?? "bin/cli.mjs");
+};
+/** The names of the skills of the archetypes, with the archetype each belongs to (lernapps-<archetype>[-…]). */
+function archetypeSkills() {
+	const dir = fromPackage("skills", "archetypes");
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => ({
+		name: entry.name,
+		archetype: /^lernapps-([a-z]+)(?:-|$)/.exec(entry.name)?.[1] ?? entry.name
+	}));
+}
+/** The script of a command that is run; its failure is an error of `fail`. */
+function run(command, args, fail, cwd = ".") {
+	const result = spawnSync(command, args, {
+		cwd,
+		stdio: [
+			"ignore",
+			2,
+			2
+		]
+	});
+	if (result.error) throw fail(`${command} cannot run: ${result.error.message}`);
+	if (result.status !== 0) throw fail(`${command} ${args.join(" ")} failed (exit ${result.status}); its output is above`);
+}
+/**
+* `skills experimental_sync` in `dir`, without the skills of the archetypes in `exclude`. The skills are copied, not
+* linked into node_modules: the app commits them, and a fresh clone has them before its first npm install.
+*/
+function syncSkills(dir, exclude) {
+	const filters = exclude.flatMap((name) => [`${TOOLING}#${name}`]);
+	run(process.execPath, [
+		SKILLS_BIN(),
+		"experimental_sync",
+		"-y",
+		"--no-remote",
+		"--copy",
+		...filters.length > 0 ? ["--exclude", ...filters] : []
+	], (message) => new CreateError(message), dir);
+}
+/** A package name from the folder's name: lower case, letters, digits and hyphens. */
+const slug = (dir) => basename(dir).toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+function init(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: INIT_OPTIONS,
+		strict: true,
+		allowPositionals: true
+	});
+	if (values.help) {
+		process.stdout.write(INIT_USAGE);
+		return 0;
+	}
+	if (positionals.length !== 1 || !/^[a-z0-9][a-z0-9-]*$/.test(positionals[0] ?? "")) throw new UsageError("init needs one <short name> for the plan: lower case letters, digits and hyphens");
+	const name = positionals[0] ?? "plan";
+	const dir = resolve(".");
+	const present = readdirSync(dir).filter((entry) => entry !== ".git");
+	if (present.length > 0) throw new CreateError(`${dir} is not empty (${present.slice(0, 5).join(", ")}${present.length > 5 ? ", ..." : ""}): start in a new, empty folder`);
+	const addon = values.addon;
+	writeJson(join(dir, "package.json"), {
+		name: slug(dir),
+		version: "0.0.0",
+		private: true,
+		lernapps: { init: true }
+	});
+	const fail = (message) => new CreateError(message);
+	run("npm", [
+		"install",
+		"--save-dev",
+		"--no-audit",
+		"--no-fund",
+		`${TOOLING}@${ownVersion()}`,
+		...addon ? [addon] : []
+	], fail);
+	const source = (packageName, ...path) => join(dir, "node_modules", packageName, ...path);
+	let template = source(TOOLING, "guidance", "plan-template.md");
+	if (addon !== void 0) {
+		const relative = readJson(source(addon, "package.json")).lernapps?.planTemplate;
+		if (relative !== void 0) template = source(addon, relative);
+	}
+	const target = join(dir, PLANS, `01-${name}.md`);
+	mkdirSync(dirname(target), { recursive: true });
+	writeFileSync(target, readFileSync(template));
+	syncSkills(dir, archetypeSkills().map((skill) => skill.name));
+	process.stdout.write(`lernapps init: ${relative$1(dir, target)} from ${relativeTemplate(template, dir)}; the skills of the packages are installed\nNext: read ${relative$1(dir, target)} completely and follow it\n`);
+	return 0;
+}
+const relative$1 = (from, to) => to.startsWith(from) ? to.slice(from.length + 1) : to;
+const relativeTemplate = (template, dir) => relative$1(join(dir, "node_modules"), template);
+function skills(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: SKILLS_OPTIONS,
+		strict: true,
+		allowPositionals: true
+	});
+	if (values.help) {
+		process.stdout.write(SKILLS_USAGE);
+		return 0;
+	}
+	if (positionals.length > 0) throw new UsageError(`skills takes no arguments, not ${positionals.join(" ")}`);
+	const known = [...new Set(archetypeSkills().map((skill) => skill.archetype))].sort();
+	if (values.archetype === void 0) throw new UsageError(`skills needs --archetype <name> (${known.join(", ")})`);
+	if (!known.includes(values.archetype)) throw new UsageError(`unknown archetype: ${values.archetype} (known: ${known.join(", ")})`);
+	const others = archetypeSkills().filter((skill) => skill.archetype !== values.archetype).map((skill) => skill.name);
+	syncSkills(resolve("."), others);
+	process.stdout.write(`lernapps skills: the skills of the archetype ${values.archetype} are installed\n`);
+	return 0;
+}
+// generator/update.ts
+/** The options of `lernapps update`, as node:util parseArgs takes them. */
+const UPDATE_OPTIONS = { help: {
+	type: "boolean",
+	short: "h",
+	default: false
+} };
+const LATEST = "npx --yes @lernapps/tooling@latest update";
+const UPDATE_USAGE = `Usage: lernapps update
+
+Moves the app in the current folder to the versions of this @lernapps/tooling, then runs npm install. npm update
+moves the app within its version ranges; this moves the ranges, and what npm does not know:
+  @lernapps/app-templates  to the version this tooling depends on: the runtime its tests ran with. A newer version
+                           (e.g. from Renovate) is kept. A git commit, as apps once pinned, becomes a version
+  @lernapps/tooling        to the version of this tooling (unchanged when run from the app)
+  .github/workflows/       the actions of lernapps/tooling at the tag of that version
+  .agents/skills/app-content/SKILL.md
+                           the content guide's skeleton, where the app has none yet (and its link for Claude Code)
+  .vibe/plan.md            the plan of an app made before the plans had a folder: moved to
+                           .vibe/plans/01-first-version.md, the first of its plans (one per piece of work)
+  .agents/skills/lernapps-*, .claude/skills/lernapps-*, skills-lock.json
+                           replaced with the skills of this tooling, as npx skills add lays them out: those of
+                           every phase, and of the archetypes only those of the current plan's archetype; every
+                           other lernapps-* skill is removed. The app's own skills (app-content, any other) stay. The lines of an earlier generator that had git ignore them are removed
+                           from .gitignore: the app commits its skills
+  docs/arc42/              of an interactive app: replaced with the generic part and the interactive extension of
+                           app-templates at the version of the app's runtime, except the app sections (between
+                           <!-- app: begin … --> and <!-- app: end … -->), which stay as they are
+
+Run it from the latest tooling, in the app's folder, e.g. to pick up a fixed runtime:
+  ${LATEST}
+Run as the app's own tooling (npx lernapps update), it knows only the versions the app already has.
+Then run npx lernapps check, and commit package.json, package-lock.json, .github/workflows/ and what else it names.
+
+Exit codes: 0 when the app is updated (or was up to date), 1 when it cannot be or only partly (the message says
+what was not moved and why), 2 on a usage error.
+
+Options:
+  -h, --help   print this help
+`;
+/** The app cannot be updated; the message says why and what to do. */
+var UpdateError = class extends Error {};
+/** The version a dependency range names at its lowest: `^1.2.3`, `~1.2.3`, `1.2.3`; undefined for a git spec or a tag. */
+function lowest(range) {
+	const match = /^[\^~>=\s]*(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(range);
+	return match ? [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3])
+	] : void 0;
+}
+/** Whether `a` is older than `b`. */
+const older = (a, b) => a[0] !== b[0] ? a[0] < b[0] : a[1] !== b[1] ? a[1] < b[1] : a[2] < b[2];
+/** The next range of a dependency at `version`, and what the output says about it. */
+function nextRange(name, current, version) {
+	const target = `^${version}`;
+	if (current !== void 0 && /^(file:|link:|\.{0,2}\/)/.test(current)) return {
+		spec: current,
+		line: `${name}: kept ${current}, a local copy`
+	};
+	const now = current === void 0 ? void 0 : lowest(current);
+	const next = lowest(version);
+	if (current === target) return {
+		spec: current,
+		line: `${name}: unchanged (${current})`
+	};
+	if (now !== void 0 && next !== void 0 && !older(now, next)) return {
+		spec: current ?? target,
+		line: `${name}: kept ${current}, not moved to ${target}: it is not older`
+	};
+	return {
+		spec: target,
+		line: `${name}: ${current ?? "none"} → ${target}`
+	};
+}
+/** The workflows' `uses: lernapps/tooling/actions/<name>@<ref>`, set to `ref` (a commit or a tag); the files it changed. */
+function moveActions(ref) {
+	const changed = [];
+	for (const file of workflows()) {
+		const text = readFileSync(file, "utf8");
+		const next = text.replace(/(lernapps\/tooling\/actions\/[\w-]+@)(?:[0-9a-f]{40}|v\d+\.\d+\.\d+)\b/g, `$1${ref}`);
+		if (next !== text) {
+			writeFileSync(file, next);
+			changed.push(file);
+		}
+	}
+	return changed;
+}
+/**
+* Moves the plan of an app made before the plans had a folder, .vibe/plan.md, to .vibe/plans/01-first-version.md,
+* where there is no plan 01 yet; what it did, as lines of the output. A move only: git sees the rename when the
+* change is committed.
+*/
+function migratePlan() {
+	if (!existsSync(".vibe/plan.md")) return [];
+	if (plans().some((plan) => /\/01-[^/]+$/.test(plan))) return [`plan: kept ${LEGACY_PLAN}: .vibe/plans/ already has a plan 01. Compare the two and keep one as the plan 01`];
+	mkdirSync(dirname(MIGRATED_PLAN), { recursive: true });
+	renameSync(LEGACY_PLAN, MIGRATED_PLAN);
+	return [`plan: moved ${LEGACY_PLAN} to ${MIGRATED_PLAN}, unchanged: each piece of work has its own plan in .vibe/plans/`];
+}
+/**
+* The skills of this tooling, as it ships them (skills/<group>/<name>/), and as the app keeps them (flat, by name).
+* Every app has those of the groups process, tooling and content; of the group archetypes only those of its own
+* archetype (lernapps-<archetype> and lernapps-<archetype>-<part>, e.g. lernapps-explainer-design), which the plan
+* installs in the phase that needs it.
+*/
+const SKILL_PREFIX = "lernapps-";
+const TOOLING_SOURCE = "lernapps/tooling";
+const ARCHETYPE_GROUP = "archetypes";
+const SKILLS = join(".agents", "skills");
+const SKILL_LINKS = join(".claude", "skills");
+/** The hash `npx skills` keeps in skills-lock.json (computedHash): every file of the folder, path and content. */
+function skillHash(dir) {
+	const files = [];
+	const walk = (folder) => {
+		for (const entry of readdirSync(folder, { withFileTypes: true })) if (entry.isDirectory() && entry.name !== ".git" && entry.name !== "node_modules") walk(join(folder, entry.name));
+		else if (entry.isFile()) files.push(relative(dir, join(folder, entry.name)).split("\\").join("/"));
+	};
+	walk(dir);
+	const hash = createHash("sha256");
+	for (const file of files.sort((a, b) => a.localeCompare(b))) {
+		hash.update(file);
+		hash.update(readFileSync(join(dir, file)));
+	}
+	return hash.digest("hex");
+}
+/** The lernapps-* skills below `source`: each folder with a SKILL.md, its group and its path relative to `source`. */
+function shippedSkills(source) {
+	const found = [];
+	for (const group of readdirSync(source, { withFileTypes: true })) {
+		if (!group.isDirectory()) continue;
+		for (const skill of readdirSync(join(source, group.name), { withFileTypes: true })) if (skill.isDirectory() && skill.name.startsWith(SKILL_PREFIX) && existsSync(join(source, group.name, skill.name, "SKILL.md"))) found.push({
+			name: skill.name,
+			group: group.name,
+			path: `${group.name}/${skill.name}`
+		});
+	}
+	return found;
+}
+/**
+* Replaces the app's lernapps-* skills with those of this tooling, as `npx skills add lernapps/tooling` lays them out:
+* the folder in .agents/skills/, a relative link to it in .claude/skills/ (a copy where the system allows no link), and
+* its entry in skills-lock.json with the hash of the new files. Of the archetypes' skills only those of the archetype
+* the current plan names; without one, those the app has. Removes every other lernapps-* skill, unless its entry in
+* skills-lock.json names another source than this tooling (lernapps-practice-* come from lernapps/practice).
+* Never touches another skill. What it did, as lines of the output.
+*/
+function replaceSkills(dir = ".", source = fromPackage("skills")) {
+	const skillsDir = join(dir, SKILLS);
+	const linksDir = join(dir, SKILL_LINKS);
+	const lockFile = join(dir, SKILLS_LOCK);
+	let lock = {
+		version: 1,
+		skills: {}
+	};
+	try {
+		lock = JSON.parse(readFileSync(lockFile, "utf8"));
+	} catch {}
+	const foreign = (name) => {
+		const source = lock.skills?.[name]?.["source"];
+		return source !== void 0 && source !== TOOLING_SOURCE;
+	};
+	const present = existsSync(skillsDir) ? readdirSync(skillsDir).filter((name) => name.startsWith(SKILL_PREFIX) && !foreign(name)) : [];
+	const plan = currentPlan(dir);
+	const archetype = plan === void 0 ? void 0 : planFrontMatter(join(dir, plan))["archetype"];
+	const own = (name) => typeof archetype === "string" ? name === `${SKILL_PREFIX}${archetype}` || name.startsWith(`${SKILL_PREFIX}${archetype}-`) : present.includes(name);
+	const shipped = shippedSkills(source).filter(({ name, group }) => group !== ARCHETYPE_GROUP || own(name));
+	const folder = new Map(shipped.map(({ name, path }) => [name, path]));
+	const ours = [...folder.keys()].sort();
+	const entries = { ...lock.skills };
+	const added = [];
+	const changed = [];
+	const removed = present.filter((name) => !ours.includes(name));
+	for (const name of removed) {
+		rmSync(join(skillsDir, name), {
+			recursive: true,
+			force: true
+		});
+		rmSync(join(linksDir, name), {
+			recursive: true,
+			force: true
+		});
+		delete entries[name];
+	}
+	for (const name of ours) {
+		const target = join(skillsDir, name);
+		const before = existsSync(target) ? skillHash(target) : void 0;
+		rmSync(target, {
+			recursive: true,
+			force: true
+		});
+		mkdirSync(skillsDir, { recursive: true });
+		cpSync(join(source, folder.get(name) ?? name), target, { recursive: true });
+		const hash = skillHash(target);
+		if (before === void 0) added.push(name);
+		else if (before !== hash) changed.push(name);
+		const link = join(linksDir, name);
+		const to = `../../.agents/skills/${name}`;
+		let linked = false;
+		try {
+			linked = lstatSync(link).isSymbolicLink() && readlinkSync(link) === to;
+		} catch {}
+		if (!linked) {
+			rmSync(link, {
+				recursive: true,
+				force: true
+			});
+			mkdirSync(linksDir, { recursive: true });
+			try {
+				symlinkSync(to, link, "dir");
+			} catch {
+				cpSync(target, link, { recursive: true });
+			}
+		}
+		entries[name] = {
+			source: TOOLING_SOURCE,
+			sourceType: "github",
+			...entries[name],
+			skillPath: `skills/${folder.get(name) ?? name}/SKILL.md`,
+			computedHash: hash
+		};
+	}
+	const sorted = Object.fromEntries(Object.keys(entries).sort().map((name) => [name, entries[name]]));
+	const next = `${JSON.stringify({
+		...lock,
+		version: lock.version ?? 1,
+		skills: sorted
+	}, null, 2)}\n`;
+	const lockChanged = !existsSync(lockFile) || readFileSync(lockFile, "utf8") !== next;
+	if (lockChanged) writeFileSync(lockFile, next);
+	const lines = [];
+	const list = (names) => names.join(", ");
+	if (added.length + changed.length + removed.length === 0) lines.push(lockChanged ? `skills: the ${SKILL_PREFIX}* skills are those of this tooling; their entries in ${SKILLS_LOCK} updated` : `skills: the ${SKILL_PREFIX}* skills are those of this tooling already (${ours.length})`);
+	else {
+		const parts = [
+			...changed.length > 0 ? [`replaced ${list(changed)}`] : [],
+			...added.length > 0 ? [`added ${list(added)}`] : [],
+			...removed.length > 0 ? [`removed ${list(removed)}: not of this tooling, or of another archetype`] : []
+		];
+		lines.push(`skills: ${parts.join("; ")}: the ${SKILL_PREFIX}* skills of this tooling, in ${SKILLS}/ and ${SKILL_LINKS}/`);
+	}
+	return lines;
+}
+/**
+* Removes the lines an earlier generator appended to .gitignore so that git ignored the installed skills: the app
+* commits them now. What it did, as lines of the output.
+*/
+function unignoreSkills(dir = ".") {
+	const ignore = join(dir, ".gitignore");
+	if (!existsSync(ignore)) return [];
+	const lines = readFileSync(ignore, "utf8").split("\n");
+	const kept = lines.filter((line) => !IGNORED_SKILLS_LINES.includes(line));
+	if (kept.length === lines.length) return [];
+	writeFileSync(ignore, `${kept.join("\n").replace(/\n+$/, "")}\n`);
+	return ["skills: removed the lines from .gitignore that had git ignore them: the app commits its skills"];
+}
+/**
+* Replaces the reference files of an interactive app's architecture with the generic part and the extension of
+* the installed app-templates; the app's own files stay. What it did, as lines of the output, and whether it failed.
+*/
+function updateArchitecture() {
+	const archetype = architectureArchetype();
+	if (archetype === void 0) return {
+		lines: [],
+		failed: false
+	};
+	try {
+		const templates = templatesPackage();
+		return {
+			lines: writeArchitecture(".", templates.root, archetype, templates.version),
+			failed: false
+		};
+	} catch (error) {
+		if (!(error instanceof ArchitectureError) && !(error instanceof CreateError)) throw error;
+		return {
+			lines: [`architecture: not replaced: ${error.message}`],
+			failed: true
+		};
+	}
+}
+/** The app's workflow files. */
+function workflows() {
+	const dir = join(".github", "workflows");
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir).filter((file) => /\.ya?ml$/.test(file)).map((name) => join(dir, name));
+}
+function update(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: UPDATE_OPTIONS,
+		strict: true,
+		allowPositionals: true
+	});
+	if (values.help) {
+		process.stdout.write(UPDATE_USAGE);
+		return 0;
+	}
+	if (positionals.length > 0) throw new UsageError(`update takes no arguments, not ${positionals.join(" ")}`);
+	if (!existsSync("package.json")) throw new UpdateError("no package.json here: run it in the app's folder");
+	const devDependencies = readJson("package.json").devDependencies ?? {};
+	const current = devDependencies[TOOLING];
+	if (current === void 0) throw new UpdateError(`this is not an app from lernapps create: package.json has no devDependency ${TOOLING}`);
+	const templates = templatesPackage();
+	const lines = [];
+	const specs = [];
+	const notMoved = [];
+	const runtime = devDependencies[RUNTIME];
+	if (runtime !== void 0) {
+		const next = nextRange(RUNTIME, runtime, templates.version);
+		if (next.spec !== runtime) specs.push(`${RUNTIME}@${next.spec}`);
+		lines.push(next.line);
+	}
+	const version = ownVersion();
+	const nextTooling = nextRange(TOOLING, current, version);
+	if (nextTooling.spec !== current) specs.push(`${TOOLING}@${nextTooling.spec}`);
+	lines.push(nextTooling.line);
+	if (nextTooling.spec === current && resolve(fromPackage()) === resolve("node_modules", "@lernapps/tooling")) lines.push(`this is the app's own tooling, which knows only its own version; for the latest run: ${LATEST}`);
+	if (specs.length > 0) {
+		const install = spawnSync("npm", [
+			"install",
+			"--no-audit",
+			"--no-fund",
+			"--save-dev",
+			...specs
+		], { stdio: [
+			"ignore",
+			2,
+			2
+		] });
+		if (install.error || install.status !== 0) throw new UpdateError(`npm install ${specs.join(" ")} failed${install.error ? `: ${install.error.message}` : ` (exit ${install.status})`}; its output is above. Fix the cause, then run lernapps update again`);
+		if (installHooks([]) !== 0) throw new UpdateError("lernapps hooks failed (see above); run npx lernapps hooks again");
+	}
+	const changed = moveActions(`v${version}`);
+	if (changed.length > 0) lines.push(`the actions of lernapps/tooling in ${changed.join(", ")}: v${version}`);
+	const guide = addContentGuide(".");
+	lines.push(...guide.map((line) => `content guide: ${line}`));
+	const plan = migratePlan();
+	lines.push(...plan);
+	const skills = [...replaceSkills(), ...unignoreSkills()];
+	lines.push(...skills);
+	const architecture = updateArchitecture();
+	lines.push(...architecture.lines);
+	if (architecture.failed) notMoved.push("the architecture");
+	process.stdout.write(`${lines.map((line) => `lernapps update: ${line}`).join("\n")}\n`);
+	if (notMoved.length > 0) throw new UpdateError(`partly updated: ${notMoved.join(" and ")} not moved (see above). Run it from the latest tooling, installed by npx: ${LATEST}`);
+	const files = [
+		"package.json",
+		"package-lock.json",
+		".github/workflows/"
+	];
+	const skillsMoved = skills.some((line) => !line.includes("those of this tooling already"));
+	if (guide.length > 0 || skillsMoved) files.push(".agents/", ".claude/");
+	if (skillsMoved) files.push(SKILLS_LOCK);
+	if (skills.some((line) => line.includes(".gitignore"))) files.push(".gitignore");
+	if (architecture.lines.length > 0) files.push(`${ARCHITECTURE}/`);
+	if (plan.some((line) => line.startsWith("plan: moved"))) files.push(".vibe/ (git add -A .vibe, to keep the move)");
+	process.stdout.write(`Next: npx lernapps check, then commit ${files.slice(0, -1).join(", ")} and ${files.at(-1) ?? ""}\n`);
+	return 0;
+}
+// src/screenshots.ts
+/** The archetypes whose pages are shown to a creator before a submission. */
+const SUPPORTED = ["explainer", "quiz"];
+const DESKTOP = 1280;
+const HEIGHT = 800;
+/** A figure is shot at twice its size on screen, as a phone with a sharp display shows it. */
+const FIGURE_SCALE = 2;
+/** A figure: the blocks figure and labelled-figure (an image or a drawing), and any other figure with a picture. */
+const FIGURES = "figure:has(img, svg)";
+/** The command cannot be done for the app it was given (not a usage error): printed as it is, exit code 1. */
+var ScreenshotsError = class extends Error {};
+/** No browser can run here: the finding of `lernapps check` for it, about the bundle it was to photograph. */
+var NoBrowser = class extends Error {
+	error;
+	bundle;
+	constructor(error, bundle) {
+		super(error.message);
+		this.error = error;
+		this.bundle = bundle;
+	}
+};
+/**
+* The archetype of a built app, from its start page: the explainer and interactive runtimes mark their pages with
+* <meta name="lernapps-archetype">; a quiz has no marker but is the one page with <main class="quiz">.
+*/
+function archetypeOf(startPage) {
+	const marker = /<meta\b(?=[^>]*\bname\s*=\s*["']lernapps-archetype["'])[^>]*\bcontent\s*=\s*["']([^"']*)["']/i.exec(startPage);
+	if (marker !== null) return marker[1];
+	return /<main\b[^>]*\bclass\s*=\s*["'][^"']*\bquiz\b/i.test(startPage) ? "quiz" : void 0;
+}
+/**
+* The file name of a page's image: its place in the order and its path (`02-plan-selbsteinschaetzung`); of a figure on
+* the page, also its place on the page (`02-plan-selbsteinschaetzung-figure-1`).
+*/
+function imageName(order, page, width, figure) {
+	const path = page.replace(/(^|\/)index\.html$/i, "").replace(/\.html$/i, "");
+	const slug = (path === "" ? "index" : path).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "page";
+	return `${`${String(order).padStart(2, "0")}-${slug}${figure === void 0 ? "" : `-figure-${figure}`}`}${width === void 0 ? "" : `-${width}`}.png`;
+}
+const escape = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+/** The index.html of the folder: every image in page order with the page's title and path; one file, no network. */
+function indexPage(shots) {
+	return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Screenshots</title>
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 1rem; background: #f4f4f4; color: #111; }
+    section { margin: 0 0 3rem; }
+    figure { display: inline-block; margin: 0 1rem 1rem 0; vertical-align: top; }
+    img { max-width: 100%; height: auto; border: 1px solid #888; background: #fff; }
+  </style>
+</head>
+<body>
+  <main>\n    <h1>Screenshots</h1>\n${shots.map(({ page, title, images, figures }) => `    <section>\n      <h2>${escape(title)}</h2>\n      <p><code>${escape(page)}</code></p>\n` + images.map(({ file, width }) => `      <figure><img src="${escape(file)}" width="${width}" alt="${escape(`${title} (${page}), ${width} px wide`)}"><figcaption>${width} px</figcaption></figure>\n`).join("") + (figures.length === 0 ? "" : `      <h3>Figures</h3>\n`) + figures.map(({ file, width, figure }) => `      <figure><a href="${escape(file)}"><img src="${escape(file)}" alt="${escape(`Figure ${figure} of ${title} (${page}), ${width} px wide page`)}"></a><figcaption>Figure ${figure}, ${width} px</figcaption></figure>\n`).join("") + `    </section>\n`).join("")}  </main>\n</body>\n</html>\n`;
+}
+/** Whether `out` may be emptied: not the working folder, one of its parents, the bundle, or a folder that holds it. */
+function checkOut(out, bundle) {
+	const inside = (outer, inner) => inner === outer || inner.startsWith(outer + sep);
+	const cwd = resolve(".");
+	if (inside(out, cwd) || inside(out, bundle) || inside(bundle, out) || dirname(out) === out) throw new UsageError(`--out ${relative(cwd, out) || "."}: this folder is emptied first, and it holds the working folder or the built app; choose another`);
+}
+/**
+* Opens a page in a new context, loaded, fonts and images there, no animation, nothing answered or hovered, and gives it
+* to `use`.
+*/
+async function opened(browser, base, page, options, use) {
+	const context = await browser.newContext({
+		viewport: {
+			width: options.width,
+			height: HEIGHT
+		},
+		deviceScaleFactor: options.scale ?? 1,
+		javaScriptEnabled: options.javaScript ?? true,
+		reducedMotion: "reduce",
+		serviceWorkers: "block"
+	});
+	try {
+		const origin = new URL(base).origin;
+		await context.route("**/*", (route) => new URL(route.request().url()).origin === origin ? route.continue() : route.abort("blockedbyclient"));
+		const tab = await context.newPage();
+		await tab.goto(new URL(page.replace(/(^|\/)index\.html$/i, "$1"), base).href, { waitUntil: "load" });
+		await tab.evaluate(() => {
+			for (const image of document.images) image.loading = "eager";
+		});
+		await tab.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => void 0);
+		await tab.evaluate(() => Promise.all([document.fonts.ready, ...[...document.images].map((image) => image.decode().catch(() => void 0))]));
+		return await use(tab);
+	} finally {
+		await context.close();
+	}
+}
+/** A page as a learner first sees it, whole: returns its title. */
+async function shoot(browser, base, page, width, file) {
+	return opened(browser, base, page, { width }, async (tab) => {
+		await tab.screenshot({
+			path: file,
+			fullPage: true,
+			animations: "disabled"
+		});
+		return (await tab.title()).trim();
+	});
+}
+/**
+* Every figure of a page, each with its caption, at twice its size: `file` names the image of the figure with its place
+* on the page. The page is opened without JavaScript, as the build writes it, so that the figures are there that a
+* script shows only later, such as those of a quiz's questions. A figure that takes no space, such as one in a closed
+* details element, is left out. Returns the number of figures shot.
+*/
+async function shootFigures(browser, base, page, width, file) {
+	return opened(browser, base, page, {
+		width,
+		scale: FIGURE_SCALE,
+		javaScript: false
+	}, async (tab) => {
+		let count = 0;
+		for (const figure of await tab.locator(FIGURES).all()) {
+			const box = await figure.boundingBox();
+			if (box === null || box.width === 0 || box.height === 0) continue;
+			count += 1;
+			await figure.screenshot({
+				path: file(count),
+				animations: "disabled",
+				scale: "device"
+			});
+		}
+		return count;
+	});
+}
+/**
+* Writes the images and the index.html. Everything that can fail before is checked before the folder is touched, so a
+* failed run writes nothing. Returns the line to print.
+*/
+async function screenshots(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: SCREENSHOTS_OPTIONS,
+		strict: true,
+		allowPositionals: true
+	});
+	if (positionals.length > 1) throw new UsageError(`one <dir> at most, not ${positionals.join(" ")}`);
+	if (!/^\d+$/.test(values.width) || Number(values.width) < 200 || Number(values.width) > 4e3) throw new UsageError(`--width ${values.width}: a number of pixels from 200 to 4000`);
+	const widths = [.../* @__PURE__ */ new Set([Number(values.width), ...values.desktop ? [DESKTOP] : []])];
+	const bundle = resolve(positionals[0] ?? "dist");
+	if (!existsSync(bundle) || !statSync(bundle).isDirectory() || !existsSync(join(bundle, "index.html"))) throw new UsageError(`${positionals[0] ?? "dist"}: not a directory with index.html (build the app first)`);
+	const archetype = archetypeOf(readFileSync(join(bundle, "index.html"), "utf8"));
+	if (archetype === void 0 || !SUPPORTED.includes(archetype)) throw new ScreenshotsError(`screenshots support explainer and quiz, not ${archetype === void 0 ? "this app" : `the ${archetype} archetype`}`);
+	const out = resolve(values.out);
+	checkOut(out, bundle);
+	const pages = bundlePages(bundle).map(({ name }) => name);
+	pages.sort((a, b) => Number(b === "index.html") - Number(a === "index.html"));
+	const browser = await launch().catch((error) => {
+		throw error instanceof BrowserError ? new NoBrowser(error, relative(resolve("."), bundle) || ".") : error;
+	});
+	const { server, base } = await serve(bundle, "/");
+	let figureCount = 0;
+	try {
+		rmSync(out, {
+			recursive: true,
+			force: true
+		});
+		mkdirSync(out, { recursive: true });
+		const shots = [];
+		for (const [index, page] of pages.entries()) {
+			const images = [];
+			const figures = [];
+			let title = "";
+			for (const width of widths) {
+				const named = widths.length > 1 ? width : void 0;
+				const file = imageName(index + 1, page, named);
+				title = await shoot(browser, base, page, width, join(out, file));
+				images.push({
+					file,
+					width
+				});
+				const count = await shootFigures(browser, base, page, width, (figure) => join(out, imageName(index + 1, page, named, figure)));
+				for (let figure = 1; figure <= count; figure += 1) figures.push({
+					file: imageName(index + 1, page, named, figure),
+					width,
+					figure
+				});
+			}
+			figureCount += figures.filter(({ width }) => width === widths[0]).length;
+			shots.push({
+				page,
+				title: title || page,
+				images,
+				figures
+			});
+		}
+		writeFileSync(join(out, "index.html"), indexPage(shots));
+	} finally {
+		server.close();
+		await browser.close();
+	}
+	const count = readdirSync(out).filter((file) => file.endsWith(".png")).length;
+	const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+	return `lernapps screenshots: ${plural(pages.length, "page")}, ${plural(figureCount, "figure")}, ${plural(count, "image")} in ${relative(resolve("."), out) || "."}/ (open index.html; check every figure in its own image)\n`;
+}
+// src/cli.ts
+/** In a repo, every run also writes its full report here, passing or not: the hooks and CI alike. */
+const REPORT = "node_modules/.cache/lernapps/validation-report.yaml";
+const CHECKS_PASS = "checks-pass";
+/** A built app or a URL that could not be checked at all: a platform rule, unlike the toolchain's checks-pass. */
+const APP_CHECKABLE = "app-checkable";
+/** The Playwright tests' results, as its JSON reporter writes them, to tell the runtime's tests from the app's. */
+const E2E_RESULTS = "node_modules/.cache/lernapps/playwright-results.json";
+const RUNTIME_ISSUES = "https://github.com/lernapps/app-templates/issues";
+function version() {
+	const manifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+	if (typeof manifest === "object" && manifest !== null && "version" in manifest) return String(manifest.version);
+	return "unknown";
+}
+/** The toolchain of the project being checked: its node_modules/.bin first. */
+const projectEnv = () => ({
+	...process.env,
+	PATH: [join(process.cwd(), "node_modules", ".bin"), process.env["PATH"] ?? ""].join(delimiter)
+});
+/** Folders that hold no sources of the project: what tools install or write. */
+const NOT_SOURCES = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"_site",
+	"playwright-report",
+	"test-results"
+]);
+/** Whether the project has a Vue single-file component (.vue) among its sources. */
+function hasVueFiles(dir) {
+	return readdirSync(dir, { withFileTypes: true }).some((entry) => {
+		if (entry.isDirectory()) return !entry.name.startsWith(".") && !NOT_SOURCES.has(entry.name) && hasVueFiles(join(dir, entry.name));
+		return entry.name.endsWith(".vue");
+	});
+}
+/**
+* An arc42 step on the working tree, as the rest of the check reads it (the build, the tests): a file not added to git
+* yet counts too, so a freshly created app passes before anything is added. arc42 resolves paths only from
+* `git ls-files` (docToolchain/arc42-language#128). In a repository the step therefore runs on a copy of its index
+* with every untracked, not ignored file below the app added as intent to add: no content goes into git and the
+* repository's own index stays as it is. Outside a repository arc42 lists the files below its root, which must then
+* be the app's folder (by default it would be the architecture's).
+*/
+function ofWorkingTree(step) {
+	const where = step.where ?? [step.command, ...step.args].join(" ");
+	const gitPath = spawnSync("git", [
+		"rev-parse",
+		"--git-path",
+		"index"
+	], { encoding: "utf8" });
+	if (gitPath.status !== 0) return {
+		step: {
+			...step,
+			where,
+			args: [
+				"--root",
+				".",
+				...step.args
+			]
+		},
+		done: () => {}
+	};
+	const temp = mkdtempSync(join(tmpdir(), "lernapps-index-"));
+	const index = join(temp, "index");
+	const own = resolve(gitPath.stdout.trim());
+	if (existsSync(own)) copyFileSync(own, index);
+	const env = {
+		...step.env,
+		GIT_INDEX_FILE: index
+	};
+	spawnSync("git", [
+		"add",
+		"--all",
+		"--intent-to-add",
+		"--",
+		"."
+	], { env: {
+		...process.env,
+		...env
+	} });
+	return {
+		step: {
+			...step,
+			where,
+			env
+		},
+		done: () => rmSync(temp, {
+			recursive: true,
+			force: true
+		})
+	};
+}
+/** Runs a step; its output is shown only when it fails. */
+function runStep(planned) {
+	const { step, done } = planned.workingTree ? ofWorkingTree(planned) : {
+		step: planned,
+		done: () => {}
+	};
+	let result;
+	try {
+		result = spawnSync(step.command, step.args, {
+			env: {
+				...projectEnv(),
+				...step.env
+			},
+			encoding: "utf8",
+			maxBuffer: 268435456
+		});
+	} finally {
+		done();
+	}
+	const where = step.where ?? [step.command, ...step.args].join(" ");
+	if (result.error) return finding(CHECKS_PASS, "error", {
+		where,
+		found: `${step.name}: cannot run ${step.command}: ${result.error.message}`,
+		fix: step.command === "vue-tsc" ? "The app has Vue components (.vue), which vue-tsc type-checks: add it with npm install --save-dev vue-tsc typescript, then check again" : step.command === "arc42" ? `The app has an architecture (${ARCHITECTURE}/), which the arc42 CLI checks: add it with npm install --save-dev @doctc/arc42@0.38.0, then check again` : `Install the project's dependencies (npm ci), then check again`
+	});
+	if (result.status === 0) return void 0;
+	process.stderr.write(`${result.stdout}${result.stderr}`);
+	return finding(CHECKS_PASS, "error", {
+		where,
+		found: `${step.name} failed (its output is above)`,
+		fix: step.command === "vp" && step.args[0] === "check" ? "Run vp check --fix, which fixes what it can of format and lint; fix the rest from the output, then check again" : step.command === "arc42" ? `Keep the architecture current with the code: fix each finding of ${where} in the app's own part, between the markers <!-- app: begin … --> and <!-- app: end … --> of ${ARCHITECTURE}/, or in the code; never edit outside those markers, which lernapps update replaces.${step.workingTree ? "" : " Before a commit arc42 reads what is staged: git add the new files that belong to the commit."} Then check again` : `Fix the cause from the output of ${where}, then check again`
+	});
+}
+/** No browser could start: in a repo a step of the toolchain's checks, on a built app or a URL the app could not be checked. */
+const browserFinding = (error, rule = CHECKS_PASS) => finding(rule, "error", {
+	where: "browser",
+	found: error.message,
+	fix: rule === CHECKS_PASS ? "Install Chromium and its system libraries: npx playwright install --with-deps chromium. Where no browser can run, push and let CI check" : "Install Chromium and its system libraries: npx playwright install --with-deps chromium, then check again. If no browser can start even then, open an issue at https://github.com/lernapps/tooling/issues with this message"
+});
+/**
+* The failing tests that are defined in the runtime (a file below node_modules/@lernapps/app-templates/), by their
+* titles: the suites' titles below the file, then the test's. Playwright names a spec's file relative to the test
+* folder, e.g. ../node_modules/@lernapps/app-templates/dist/quiz-e2e.mjs for the quiz's e2e/quiz.e2e.ts, which only
+* calls quizTests(). Empty when the results cannot be read.
+*/
+function failingRuntimeTests() {
+	let results;
+	try {
+		results = JSON.parse(readFileSync(E2E_RESULTS, "utf8"));
+	} catch {
+		return [];
+	}
+	const found = /* @__PURE__ */ new Set();
+	const walk = (suite, titles) => {
+		for (const spec of suite.specs ?? []) if (!spec.ok && spec.file.split(/[\\/]/).join("/").includes(`node_modules/@lernapps/app-templates/`)) found.add([...titles, spec.title].join(" › "));
+		for (const child of suite.suites ?? []) walk(child, child.title ? [...titles, child.title] : titles);
+	};
+	for (const file of results.suites ?? []) walk(file, []);
+	return [...found].sort();
+}
+/**
+* Runs the Playwright tests in the browser of this run; a failing test of the runtime is named as a test of the
+* template, with what to do.
+*/
+function runEndToEndTests(browser) {
+	rmSync(E2E_RESULTS, { force: true });
+	mkdirSync(dirname(E2E_RESULTS), { recursive: true });
+	const failure = runStep({
+		name: "end-to-end tests",
+		command: "playwright",
+		args: ["test", "--reporter=line,json"],
+		where: "playwright test",
+		env: {
+			...browser,
+			PLAYWRIGHT_JSON_OUTPUT_FILE: resolve(E2E_RESULTS)
+		}
+	});
+	if (failure === void 0) return void 0;
+	const runtime = failingRuntimeTests();
+	if (runtime.length === 0) return failure;
+	const shown = runtime.slice(0, 5).map((title) => `"${title}"`);
+	const more = runtime.length > shown.length ? ` and ${runtime.length - shown.length} more` : "";
+	return {
+		...failure,
+		found: `end-to-end tests failed (their output is above): ${runtime.length === 1 ? "a generic test" : "generic tests"} of the template's runtime ${RUNTIME}, not of this app: ${shown.join(", ")}${more}`,
+		fix: `If the content validates (the build passed), this is a bug in the template: tell the creator and open an issue at ${RUNTIME_ISSUES} with this validation report (or ask the creator to). Never change the tests or the configuration to get around it. Once it is fixed, lernapps update moves the app to the fixed runtime: npx --yes github:lernapps/tooling#main update`
+	};
+}
+/** Serves a bundle (or opens a URL), visits its pages and measures its fitness. */
+async function visit(target) {
+	const browser = await launch();
+	try {
+		if ("url" in target) {
+			const base = new URL("./", target.url).href;
+			const { pages, stopped } = await visitApp(browser, base, (url) => url, {
+				start: target.url,
+				limit: urlPageLimit()
+			});
+			return {
+				base,
+				pages,
+				fitness: measure(pages, base),
+				...stopped ? { stopped } : {}
+			};
+		}
+		const { server, base } = await serve(target.bundle, "/");
+		try {
+			const name = (url) => {
+				const path = decodeURIComponent(url.slice(base.length));
+				if (path === "" || path.endsWith("/")) return `${path}index.html`;
+				const file = join(target.bundle, path);
+				return existsSync(file) && statSync(file).isDirectory() ? `${path}/index.html` : path;
+			};
+			const { pages, unreachable } = await visitApp(browser, base, name, { pages: bundlePages(target.bundle) });
+			return {
+				base,
+				pages,
+				fitness: measure(pages, base),
+				bundle: target.bundle,
+				unreachable
+			};
+		} finally {
+			server.close();
+		}
+	} finally {
+		await browser.close();
+	}
+}
+function commitOrDirectory() {
+	const git = spawnSync("git", ["rev-parse", "HEAD"], { encoding: "utf8" });
+	const commit = git.status === 0 ? git.stdout.trim() : "";
+	return /^[0-9a-f]{40}$/.test(commit) ? { commit } : { directory: process.cwd() };
+}
+function readEntry(file) {
+	let value;
+	try {
+		value = parse(readFileSync(file, "utf8"));
+	} catch (error) {
+		throw new UsageError(`cannot read the entry ${file}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (typeof value !== "object" || value === null || typeof value.url !== "string") throw new UsageError(`the entry ${file} has no url`);
+	return {
+		file,
+		value
+	};
+}
+/** What the arc42 CLI reads in an app with an architecture: a staged change of one of these is checked before a commit. */
+const ARCHITECTURE_INPUTS = [
+	`${ARCHITECTURE}/`,
+	".arc42ignore",
+	"src/"
+];
+/**
+* The architecture's step before a commit of an app with one (generator/architecture.ts), when the commit stages a
+* file of the architecture or of the sources: `arc42 diff --staged` (a fraction of a second), whose findings
+* architectureDiffFindings judges; before the first commit, which has nothing to compare with,
+* `arc42 validate --strict`.
+*/
+function architectureBeforeCommit() {
+	if (!hasArchitecture()) return void 0;
+	const staged = stagedFiles();
+	if (staged !== void 0 && !staged.some((file) => ARCHITECTURE_INPUTS.some((input) => file.startsWith(input)))) return;
+	return spawnSync("git", [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		"HEAD"
+	], { encoding: "utf8" }).status === 0 ? {
+		name: "architecture",
+		command: "arc42",
+		args: [
+			"--dir",
+			ARCHITECTURE,
+			"diff",
+			"--staged",
+			"--format",
+			"json"
+		],
+		where: `arc42 --dir ${ARCHITECTURE} diff --staged`,
+		architectureDiff: true
+	} : {
+		name: "architecture",
+		command: "arc42",
+		args: [
+			"--dir",
+			ARCHITECTURE,
+			"validate",
+			"--strict"
+		]
+	};
+}
+/**
+* The paths of .arc42ignore, as arc42 reads them for its coverage hint H021 in `validate`: each line that is neither
+* blank nor a comment, trimmed, matched exactly. `arc42 diff` does not read the file (its coverage hint is not H021),
+* so the wrapper applies it to the diff's coverage hints: what validate accepts, the commit accepts too.
+*/
+function arc42Ignored() {
+	if (!existsSync(".arc42ignore")) return /* @__PURE__ */ new Set();
+	return new Set(readFileSync(".arc42ignore", "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#")));
+}
+/**
+* What a commit's `arc42 diff --staged` found, judged for the commit: it fails on a block changed without its prose
+* (or the other way round) and on new code that no block claims and .arc42ignore does not list, as
+* `arc42 validate --strict` before a push would. A hint "review architecture element" (code changed under an
+* interface's path) asks a person to look at that element; it is shown as a warning and does not fail the commit,
+* since nothing in it is wrong yet. ARC42_CONSISTENT (arc42's acceptance, the HEAD commit) accepts only the
+* consistency findings, which can be intended, and they stay in the report as a warning; new code no block claims has
+* a fix that is always possible (a block, or .arc42ignore for configuration), so the acceptance does not pass it.
+*/
+function architectureDiffFindings(where, stdout, stderr) {
+	let diff;
+	try {
+		diff = JSON.parse(stdout);
+	} catch {
+		process.stderr.write(`${stdout}${stderr}`);
+		return [finding(CHECKS_PASS, "error", {
+			where,
+			found: "architecture: arc42 diff failed (its output is above)",
+			fix: `Fix the cause from the output of ${where}, then check again`
+		})];
+	}
+	const ignored = arc42Ignored();
+	const all = diff.findings ?? [];
+	const consistency = all.filter((f) => f.kind !== "implementation-path" && f.kind !== "new-building-block-hint");
+	const uncovered = all.filter((f) => f.kind === "new-building-block-hint" && !ignored.has(f.file));
+	const review = all.filter((f) => f.kind === "implementation-path");
+	const line = (f) => f.kind === "new-building-block-hint" ? `${f.file} is new code that no building block claims` : `${f.file}${f.line > 0 ? `:${f.line}` : ""} ${f.message}`;
+	const findings = [];
+	const failing = diff.accepted === true ? [] : consistency;
+	if (failing.length < consistency.length) findings.push(finding(CHECKS_PASS, "warning", {
+		where,
+		found: `architecture: accepted with ARC42_CONSISTENT, not fixed: ${consistency.map(line).join("; ")}`,
+		fix: "Accept a finding only after reading it, with a note in the plan why it is intended; ARC42_CONSISTENT set without a finding shown is a bypass like --no-verify"
+	}));
+	const blocking = [...failing, ...uncovered];
+	if (blocking.length > 0) {
+		const fixes = [...uncovered.length > 0 ? [`For new code no block claims, add a building block with its path to the app's section of ${ARCHITECTURE}/05-building-blocks.arc42.md (and place it on a node in chapter 7); only a path that is configuration rather than architecture goes into .arc42ignore. ARC42_CONSISTENT does not accept new code.`] : [], ...failing.length > 0 ? ["For a block changed without its prose, or prose naming a fact of a block without the block, change both together in the same commit. Only if you read the finding and judge the change intended may you accept it with ARC42_CONSISTENT (the base commit arc42 diff --staged names) and a note in the plan why."] : []];
+		const untracked = diff.untracked ?? [];
+		findings.push(finding(CHECKS_PASS, "error", {
+			where,
+			found: `architecture: ${blocking.map(line).join("; ")}`,
+			fix: `Keep the architecture current with the code, in the app's own part between the markers <!-- app: begin … --> and <!-- app: end … --> of ${ARCHITECTURE}/ (never outside them, which lernapps update replaces). ${fixes.join(" ")} Before a commit arc42 reads what is staged: git add the files that belong to the commit${untracked.length > 0 ? ` (not compared until added: ${untracked.join(", ")})` : ""}. Then commit again`
+		}));
+	}
+	if (review.length > 0) findings.push(finding(CHECKS_PASS, "warning", {
+		where,
+		found: `architecture: code changed under an interface; review whether its element still says what the code does: ${review.map((f) => `${f.file} (${f.elementId ?? "?"})`).join(", ")}`,
+		fix: `Read each element in ${ARCHITECTURE}/; if the change alters what it describes, update the element in the same commit. This does not fail the commit, and nothing is to be accepted`
+	}));
+	return findings;
+}
+/** Runs a step and returns its findings: a diff's as architectureDiffFindings judges them, else runStep's one. */
+function stepFindings(step) {
+	if (!step.architectureDiff) {
+		const failure = runStep(step);
+		return failure ? [failure] : [];
+	}
+	const where = step.where ?? [step.command, ...step.args].join(" ");
+	const folder = mkdtempSync(join(tmpdir(), "lernapps-arc42-"));
+	const file = join(folder, "diff.json");
+	const out = openSync(file, "w");
+	try {
+		const result = spawnSync(step.command, step.args, {
+			env: {
+				...projectEnv(),
+				...step.env
+			},
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				out,
+				"pipe"
+			],
+			maxBuffer: 268435456
+		});
+		if (result.error) return [runStep(step)].filter((f) => f !== void 0);
+		return architectureDiffFindings(where, readFileSync(file, "utf8"), result.stderr);
+	} finally {
+		closeSync(out);
+		rmSync(folder, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** The checks of the toolchain in a repo, then the checks of what it built. */
+async function checkProject(fast, heavy, context) {
+	const findings = [];
+	const steps = [];
+	if (fast && !heavy) {
+		const architecture = architectureBeforeCommit();
+		if (architecture) steps.push(architecture);
+	}
+	if (heavy && hasArchitecture()) steps.push({
+		name: "architecture",
+		command: "arc42",
+		args: [
+			"--dir",
+			ARCHITECTURE,
+			"validate",
+			"--strict"
+		],
+		workingTree: true
+	});
+	if (fast) {
+		steps.push({
+			name: "format, lint, type check",
+			command: "vp",
+			args: ["check"]
+		});
+		if (hasVueFiles(".")) steps.push({
+			name: "type check of the Vue components",
+			command: "vue-tsc",
+			args: ["--noEmit"]
+		});
+	}
+	if (heavy) {
+		steps.push({
+			name: "unit tests",
+			command: "vp",
+			args: ["test", "--passWithNoTests"]
+		});
+		steps.push({
+			name: "build",
+			command: "vp",
+			args: existsSync("index.html") ? ["build"] : ["pack"]
+		});
+	}
+	let built = true;
+	for (const step of steps) {
+		const found = stepFindings(step);
+		findings.push(...found);
+		if (found.length > 0 && step.name === "build") built = false;
+	}
+	const rules = steps.length > 0 ? [CHECKS_PASS] : [];
+	if (heavy && built) {
+		context.project = process.cwd();
+		if (existsSync(join("dist", "index.html"))) try {
+			context.app = await visit({ bundle: "dist" });
+		} catch (error) {
+			if (!(error instanceof BrowserError)) throw error;
+			findings.push(browserFinding(error));
+		}
+		const checks = await runChecks(context);
+		rules.push(...checks.rules);
+		findings.push(...checks.findings);
+		if ([
+			"ts",
+			"js",
+			"mjs",
+			"cjs"
+		].map((ext) => `playwright.config.${ext}`).find((file) => existsSync(file)) !== void 0) try {
+			const failure = runEndToEndTests(await browserForTests());
+			if (failure) findings.push(failure);
+		} catch (error) {
+			if (!(error instanceof BrowserError)) throw error;
+			findings.push(browserFinding(error));
+		}
+	}
+	return {
+		checked: commitOrDirectory(),
+		parts: [...fast ? ["pre-commit"] : [], ...heavy ? ["pre-push"] : []],
+		rules,
+		findings,
+		suppressions: [],
+		...context.app ? { fitness: context.app.fitness } : {}
+	};
+}
+/**
+* Before a hook part, the change scope (changes/changes.ts) of the staged files (pre-commit) or the pushed commits
+* (pre-push): the line to print when the part has nothing to check, the site's check when the push changes only docs
+* in a repo with a site, else undefined and the part runs.
+*/
+function hookScope(part) {
+	const rules = loadRules(".");
+	const { scope, reason } = part === "pre-commit" ? classify(stagedFiles(), rules) : classifyPush(pushedFiles(readStdin()), rules);
+	if (scope === "all") return void 0;
+	const site = SITE_CHECK[rules.kind];
+	if (scope === "docs" && part === "pre-push" && site !== void 0) return { site };
+	return { skip: `lernapps check --${part}: nothing to check, the change is ${scope === "none" ? "the plan only" : rules.kind === "app" ? "docs, which an app does not bundle" : "docs"} (${scope}: ${reason})` };
+}
+/** The check of a repo's site before a push that changes only docs: build it, then its check script. */
+function checkSite(script) {
+	const findings = [];
+	for (const step of [{
+		name: "site build",
+		command: "npm",
+		args: [
+			"run",
+			"--silent",
+			"build"
+		]
+	}, {
+		name: "site check",
+		command: "npm",
+		args: [
+			"run",
+			"--silent",
+			script
+		]
+	}]) {
+		const failure = runStep(step);
+		if (failure) {
+			findings.push(failure);
+			break;
+		}
+	}
+	return {
+		checked: commitOrDirectory(),
+		parts: ["pre-push"],
+		rules: [CHECKS_PASS],
+		findings,
+		suppressions: []
+	};
+}
+/** The checks of a built app alone: a bundle directory or a URL. */
+async function checkApp(target, context) {
+	const isUrl = /^https?:\/\//.test(target);
+	if (!isUrl && !(existsSync(target) && statSync(target).isDirectory() && existsSync(join(target, "index.html")))) throw new UsageError(`${target}: not a URL, nor a directory with index.html (build the app first)`);
+	const at = (/* @__PURE__ */ new Date()).toISOString();
+	const findings = [];
+	try {
+		context.app = await visit(isUrl ? { url: target } : { bundle: target });
+	} catch (error) {
+		if (!(error instanceof BrowserError)) throw error;
+		findings.push(browserFinding(error, APP_CHECKABLE));
+	}
+	const checks = await runChecks(context);
+	return {
+		checked: isUrl ? {
+			url: target,
+			at
+		} : { bundle: target },
+		rules: [...checks.rules, ...findings.length > 0 ? [APP_CHECKABLE] : []],
+		findings: [...findings, ...checks.findings],
+		suppressions: [],
+		...context.app ? { fitness: context.app.fitness } : {}
+	};
+}
+async function check(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: CHECK_OPTIONS,
+		strict: true,
+		allowPositionals: true
+	});
+	if (values.help) {
+		process.stdout.write(`${CHECK_USAGE}${await describeChecks()}`);
+		return 0;
+	}
+	if (positionals.length > 1) throw new UsageError(`one <dir|url> at most, not ${positionals.join(" ")}`);
+	const context = {};
+	if (values.entry !== void 0) context.entry = readEntry(values.entry);
+	const target = positionals[0] ?? context.entry?.value.url;
+	let report;
+	if (target !== void 0) {
+		if (values["pre-commit"] || values["pre-push"]) throw new UsageError("--pre-commit and --pre-push check a repo; a built app is checked without them");
+		report = await checkApp(target, context);
+	} else {
+		const all = values["pre-commit"] === values["pre-push"];
+		const scope = all ? void 0 : hookScope(values["pre-commit"] ? "pre-commit" : "pre-push");
+		const architecture = scope !== void 0 && "skip" in scope && values["pre-commit"] ? architectureBeforeCommit() : void 0;
+		if (architecture !== void 0) report = {
+			checked: commitOrDirectory(),
+			parts: ["pre-commit"],
+			rules: [CHECKS_PASS],
+			findings: stepFindings(architecture),
+			suppressions: []
+		};
+		else if (scope !== void 0 && "skip" in scope) {
+			rmSync(REPORT, { force: true });
+			process.stdout.write(`${scope.skip}\n`);
+			return 0;
+		} else {
+			report = scope !== void 0 ? checkSite(scope.site) : await checkProject(all || values["pre-commit"], all || values["pre-push"], context);
+			if (values["pre-push"] && failed(report)) countPrePushFailure();
+		}
+	}
+	if (target === void 0 && failed(report)) countFailedChecks(report.findings.filter((found) => found.severity === "error").map((found) => found.rule));
+	const yaml = toYaml(report);
+	if (target === void 0) {
+		mkdirSync(dirname(REPORT), { recursive: true });
+		writeFileSync(REPORT, yaml);
+	}
+	if (values.report !== void 0) writeFileSync(values.report, yaml);
+	if (report.findings.length > 0) process.stdout.write(yaml);
+	else {
+		const what = "commit" in report.checked ? `commit ${report.checked.commit.slice(0, 7)}` : "bundle" in report.checked ? relative(process.cwd(), resolve(report.checked.bundle)) || "." : "url" in report.checked ? report.checked.url : report.checked.directory;
+		process.stdout.write(`lernapps check: ok, ${report.rules.length} rule${report.rules.length === 1 ? "" : "s"}, no findings (${what})\n`);
+	}
+	return failed(report) ? 1 : 0;
+}
+async function screenshotsCommand(args) {
+	if (args.includes("-h") || args.includes("--help")) {
+		process.stdout.write(SCREENSHOTS_USAGE);
+		return 0;
+	}
+	try {
+		process.stdout.write(await screenshots(args));
+		return 0;
+	} catch (error) {
+		if (error instanceof ScreenshotsError) {
+			process.stderr.write(`lernapps screenshots: ${error.message}\n`);
+			return 1;
+		}
+		if (!(error instanceof NoBrowser)) throw error;
+		process.stdout.write(toYaml({
+			checked: { bundle: error.bundle },
+			rules: [APP_CHECKABLE],
+			findings: [browserFinding(error.error, APP_CHECKABLE)],
+			suppressions: []
+		}));
+		return 1;
+	}
+}
+async function main(argv) {
+	const [command, ...rest] = argv;
+	switch (command) {
+		case "changes": return changes(rest);
+		case "check": return check(rest);
+		case "create": return create(rest);
+		case "hooks": return installHooks(rest);
+		case "init": return init(rest);
+		case "screenshots": return screenshotsCommand(rest);
+		case "skills": return skills(rest);
+		case "update": return update(rest);
+		case "-h":
+		case "--help":
+			process.stdout.write(USAGE);
+			return 0;
+		case "-v":
+		case "--version":
+			process.stdout.write(`${version()}\n`);
+			return 0;
+		case void 0: throw new UsageError("no command given");
+		default: throw new UsageError(`unknown command: ${command}`);
+	}
+}
+try {
+	process.exitCode = await main(process.argv.slice(2));
+} catch (error) {
+	const parseError = error instanceof TypeError && "code" in error && String(error.code).startsWith("ERR_PARSE_ARGS");
+	if (error instanceof UsageError || parseError) {
+		process.stderr.write(`lernapps: ${error.message}\n\n${USAGE}`);
+		process.exitCode = 2;
+	} else if (error instanceof ChangesConfigError) {
+		process.stderr.write(`lernapps: ${error.message}\n`);
+		process.exitCode = 1;
+	} else if (error instanceof CreateError) {
+		process.stderr.write(`lernapps create: ${error.message}\n`);
+		process.exitCode = 1;
+	} else if (error instanceof UpdateError) {
+		process.stderr.write(`lernapps update: ${error.message}\n`);
+		process.exitCode = 1;
+	} else throw error;
+}
+export {};