@lernapps/tooling 0.0.1 → 0.1.1

package/dist/i18n.mjs

@@ -0,0 +1,11 @@
+// archetypes/shared/i18n.ts
+/** The text of `key`, with its placeholders filled; a placeholder without a value stays as it is. */
+function translator(messages, locale = "de-DE") {
+	const numbers = new Intl.NumberFormat(locale);
+	return (key, params = {}) => (messages[key] ?? key).replace(/\{(\w+)\}/g, (placeholder, name) => {
+		const value = params[name];
+		if (value === void 0) return placeholder;
+		return typeof value === "number" ? numbers.format(value) : value;
+	});
+}
+export { translator };

package/dist/lint.mjs

@@ -0,0 +1,528 @@
+import { readFileSync } from "node:fs";
+import { dirname, join, posix, relative } from "node:path";
+// lint/ast.ts
+/** The property name of `a.b` or `a["b"]`; undefined for anything else. */
+function memberName(node) {
+	if (node.type !== "MemberExpression") return void 0;
+	const key = node.property;
+	if (key.type === "Identifier") return node.computed ? void 0 : key.name;
+	return key.type === "Literal" && typeof key.value === "string" ? key.value : void 0;
+}
+/** The static text of a string literal or a template (its expressions as `${}`); undefined for anything else. */
+function staticText(node) {
+	if (!node) return void 0;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node.type === "TemplateLiteral") return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join("${}");
+}
+// lint/component.ts
+/**
+* A component's code: a Vue single-file component, or a module next to the components in src/components/ (an
+* exercise's logic module <Name>.ts); not their tests, which run in Node and import the test runner.
+*/
+function isComponentCode(filename) {
+	const path = filename.split("\\").join("/");
+	if (path.endsWith(".vue")) return true;
+	return /(^|\/)src\/components\/[^/]+\.ts$/.test(path) && !path.endsWith(".test.ts");
+}
+/** What a component may import from besides its own folder. */
+const TOOLING_IMPORTS = [
+	"@lernapps/tooling/storage",
+	"@lernapps/tooling/i18n",
+	"@lernapps/tooling/a11y"
+];
+const IMPORTS = `vue, @lernapps/app-templates, ${TOOLING_IMPORTS.join(", ")} and its own folder`;
+/** The globals that make a request. */
+const NETWORK = /* @__PURE__ */ new Set([
+	"fetch",
+	"XMLHttpRequest",
+	"WebSocket",
+	"EventSource"
+]);
+/** The globals that exist only in a browser, not while the build renders the component. */
+const BROWSER = /* @__PURE__ */ new Set([
+	"window",
+	"document",
+	"navigator",
+	"location",
+	"history",
+	"localStorage",
+	"sessionStorage",
+	"indexedDB",
+	"matchMedia",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"getComputedStyle",
+	"alert",
+	"confirm",
+	"prompt",
+	"screen",
+	"customElements",
+	"IntersectionObserver",
+	"ResizeObserver",
+	"MutationObserver"
+]);
+/** The hooks that never run while the build renders the component: inside them, browser globals are allowed. */
+const BROWSER_HOOKS = /* @__PURE__ */ new Set([
+	"onMounted",
+	"onBeforeUnmount",
+	"onUnmounted"
+]);
+/** The objects through which a global is reached: window.fetch. */
+const GLOBAL_OBJECTS = /* @__PURE__ */ new Set([
+	"window",
+	"self",
+	"globalThis"
+]);
+/** An import's source as written, and the node to report: static imports, re-exports and dynamic imports. */
+function importSource(node) {
+	if (node.type === "ImportDeclaration") return node.importKind === "type" ? void 0 : {
+		source: node.source.value,
+		node
+	};
+	if (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
+		if (node.source === null || node.exportKind === "type") return void 0;
+		return {
+			source: node.source.value,
+			node
+		};
+	}
+	if (node.type === "ImportExpression") {
+		const source = node.source;
+		return {
+			source: source.type === "Literal" && typeof source.value === "string" ? source.value : "(an expression)",
+			node
+		};
+	}
+}
+/** A URL as an import's source: a scheme (https:, data:) or protocol-relative. */
+const isUrl = (source) => /^[a-z][a-z0-9+.-]*:|^\/\//i.test(source);
+/**
+* Whether an identifier is a reference to a global of the browser or the runtime: a name the code reads that no
+* scope of the file declares (Oxlint's isGlobalReference knows only the globals it is configured with). A property
+* name (a.fetch, { fetch: … }) is no reference.
+*/
+function isFreeReference(context, node) {
+	const parent = node.parent;
+	if (parent.type === "MemberExpression" && parent.property === node && !parent.computed) return false;
+	if ((parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") && parent.key === node && !parent.computed && !(parent.type === "Property" && parent.shorthand)) return false;
+	for (let scope = context.sourceCode.getScope(node); scope; scope = scope.upper) if (scope.type !== "global" && scope.set.has(node.name)) return false;
+	return true;
+}
+// lint/rule.ts
+const RULE_PAGE = "https://lernapps.net/tooling/rules/#";
+/** An ESLint-compatible rule with its link in `meta.docs.url` and in every message. */
+const lintRule = ({ id, description, messages, schema, create }) => ({
+	meta: {
+		type: "problem",
+		docs: {
+			description,
+			url: `${RULE_PAGE}${id}`
+		},
+		...schema === void 0 ? {} : { schema },
+		messages: Object.fromEntries(Object.entries(messages).map(([key, message]) => [key, `${message} ${RULE_PAGE}${id}`]))
+	},
+	create
+});
+// lint/rules/learner-text-german.ts
+/** Properties of an element (or the document) that put text in front of the learner. */
+const TEXT_PROPERTIES = /* @__PURE__ */ new Set([
+	"textContent",
+	"innerText",
+	"outerText",
+	"innerHTML",
+	"outerHTML",
+	"title",
+	"placeholder",
+	"alt",
+	"label",
+	"ariaLabel",
+	"ariaDescription",
+	"ariaPlaceholder",
+	"ariaRoleDescription",
+	"ariaValueText"
+]);
+/** Attributes that put text in front of the learner. */
+const TEXT_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"title",
+	"alt",
+	"placeholder",
+	"label",
+	"aria-label",
+	"aria-description",
+	"aria-placeholder",
+	"aria-roledescription",
+	"aria-valuetext"
+]);
+/** Calls that show a text, with the position of the text among their arguments. */
+const TEXT_ARGUMENTS = /* @__PURE__ */ new Map([
+	["createTextNode", 0],
+	["insertAdjacentText", 1],
+	["insertAdjacentHTML", 1],
+	["alert", 0],
+	["confirm", 0],
+	["prompt", 0]
+]);
+/** The text a learner would read: markup, entities and placeholders removed. */
+const visible = (text) => text.replace(/<[^>]*>/g, " ").replace(/&[#\w]+;/g, " ").replace(/\$\{\}/g, " ");
+const hasWords = (text) => /\p{L}{2,}/u.test(visible(text));
+function calleeName(node) {
+	const callee = node.callee;
+	if (callee.type === "Identifier") return callee.name;
+	return memberName(callee);
+}
+var learner_text_german_default = lintRule({
+	id: "learner-text-german",
+	description: "Learner texts come from the message files, not from strings in code.",
+	messages: { found: "Learner text in code (\"{{text}}\"). Put it into the app's message file (src/messages/de.json) and show it with translator from @lernapps/tooling/i18n." },
+	create(context) {
+		if (isComponentCode(context.filename)) return {};
+		const report = (node, text) => {
+			const shown = visible(text).replace(/\s+/g, " ").trim();
+			context.report({
+				node,
+				messageId: "found",
+				data: { text: shown.length > 40 ? `${shown.slice(0, 39)}…` : shown }
+			});
+		};
+		return {
+			AssignmentExpression(node) {
+				const name = memberName(node.left);
+				const text = staticText(node.right);
+				if (name !== void 0 && TEXT_PROPERTIES.has(name) && text !== void 0 && hasWords(text)) report(node.right, text);
+			},
+			CallExpression(node) {
+				const name = calleeName(node);
+				if (name === void 0) return;
+				if (name === "setAttribute") {
+					const attribute = staticText(node.arguments[0]);
+					const text = staticText(node.arguments[1]);
+					if (attribute !== void 0 && TEXT_ATTRIBUTES.has(attribute) && text !== void 0 && hasWords(text)) report(node, text);
+					return;
+				}
+				const position = TEXT_ARGUMENTS.get(name);
+				if (position === void 0) return;
+				const argument = node.arguments[position];
+				const text = staticText(argument);
+				if (argument && text !== void 0 && hasWords(text)) report(argument, text);
+			},
+			JSXText(node) {
+				if (hasWords(node.value)) report(node, node.value);
+			},
+			JSXAttribute(node) {
+				const attribute = node.name.type === "JSXIdentifier" ? node.name.name : void 0;
+				const text = staticText(node.value);
+				if (attribute !== void 0 && TEXT_ATTRIBUTES.has(attribute) && text !== void 0 && hasWords(text)) report(node, text);
+			}
+		};
+	}
+});
+// lint/rules/no-request-before-click.ts
+/** An absolute or protocol-relative URL and its host. */
+const URL_PATTERN = /(?:\bhttps?:)?\/\/((?:[a-z0-9-]+\.)+[a-z]{2,})(?=[/:?#"'`\s]|$)/gi;
+/** Hosts that are no request of the app: the platform (imprint, privacy notice) and XML namespaces. */
+const ALLOWED = [/(^|\.)lernapps\.net$/i, /^www\.w3\.org$/i];
+function otherHosts(text) {
+	return [...text.matchAll(URL_PATTERN)].map((match) => match[1] ?? "").filter((host) => host !== "" && !ALLOWED.some((allowed) => allowed.test(host)));
+}
+var no_request_before_click_default = lintRule({
+	id: "no-request-before-click",
+	description: "No URL of another host in code: bundle what the app needs; load other servers only after a click.",
+	messages: { found: "URL of another host in code ({{host}}). Bundle the file with the app at build time; if the learner clicks to load it, suppress here with that reason (-- loaded after a click)." },
+	create(context) {
+		const check = (node, text) => {
+			for (const host of new Set(otherHosts(text))) context.report({
+				node,
+				messageId: "found",
+				data: { host }
+			});
+		};
+		return {
+			Literal(node) {
+				if (typeof node.value === "string") check(node, node.value);
+			},
+			TemplateLiteral(node) {
+				check(node, node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join("${}"));
+			},
+			JSXText(node) {
+				check(node, node.value);
+			}
+		};
+	}
+});
+// lint/rules/storage-through-wrapper.ts
+const STORAGE = /* @__PURE__ */ new Set([
+	"localStorage",
+	"sessionStorage",
+	"indexedDB"
+]);
+const GLOBALS = /* @__PURE__ */ new Set([
+	"window",
+	"globalThis",
+	"self"
+]);
+const name = (node) => node.type === "Identifier" ? node.name : void 0;
+var storage_through_wrapper_default = lintRule({
+	id: "storage-through-wrapper",
+	description: "Store only through createStorage of @lernapps/tooling/storage, on the device; no cookies.",
+	messages: {
+		storage: "{{what}} used directly. Store through createStorage from @lernapps/tooling/storage: it keeps the data on the device, under the app's prefix, and works when storage is blocked.",
+		cookie: "Cookie set or read. Set no cookies; keep what the app must remember on the device through createStorage from @lernapps/tooling/storage."
+	},
+	create(context) {
+		return {
+			Identifier(node) {
+				if (!STORAGE.has(node.name)) return;
+				const parent = node.parent;
+				if (parent.type === "MemberExpression" && parent.property === node && !parent.computed) return;
+				if (parent.type === "Property" && parent.key === node && !parent.computed && !parent.shorthand) return;
+				context.report({
+					node,
+					messageId: "storage",
+					data: { what: node.name }
+				});
+			},
+			MemberExpression(node) {
+				const key = memberName(node);
+				if (key === void 0) return;
+				const object = name(node.object);
+				if (object !== void 0 && GLOBALS.has(object) && STORAGE.has(key)) context.report({
+					node,
+					messageId: "storage",
+					data: { what: key }
+				});
+				else if (object === "document" && key === "cookie") context.report({
+					node,
+					messageId: "cookie"
+				});
+			}
+		};
+	}
+});
+// lint/rules/suppression-reason.ts
+/** `eslint-disable`, `oxlint-disable`, `-line` and `-next-line`: the rules, then `-- reason`. */
+const DISABLE = /^\s*(?:eslint|oxlint)-disable(?:-next-line|-line)?(?=\s|$)(.*)$/s;
+const TS_DIRECTIVE = /^\s*\/?\s*@ts-(ignore|nocheck|expect-error)\b(.*)$/s;
+var suppression_reason_default = lintRule({
+	id: "suppression-reason",
+	description: "Every suppression names its rules and gives its reason.",
+	messages: {
+		rules: "Suppression without rules. Name the rules it turns off: // oxlint-disable-next-line <rule> -- <reason>.",
+		reason: "Suppression without a reason. Write why after --: // oxlint-disable-next-line <rule> -- <reason>.",
+		typescript: "@ts-{{directive}} hides every type error. Fix the type, or use // @ts-expect-error -- <reason>.",
+		expectError: "@ts-expect-error without a reason. Write why after it: // @ts-expect-error -- <reason>."
+	},
+	create(context) {
+		return { Program() {
+			for (const comment of context.sourceCode.getAllComments()) {
+				const loc = comment.loc;
+				const disable = DISABLE.exec(comment.value);
+				if (disable) {
+					const [rules = "", ...reason] = (disable[1] ?? "").split("--");
+					if (rules.trim() === "") context.report({
+						loc,
+						messageId: "rules"
+					});
+					else if (reason.join("--").trim() === "") context.report({
+						loc,
+						messageId: "reason"
+					});
+					continue;
+				}
+				const directive = TS_DIRECTIVE.exec(comment.value);
+				if (!directive) continue;
+				const [, name = "", rest = ""] = directive;
+				if (name !== "expect-error") context.report({
+					loc,
+					messageId: "typescript",
+					data: { directive: name }
+				});
+				else if (rest.replace(/^[\s:-]+/, "").trim() === "") context.report({
+					loc,
+					messageId: "expectError"
+				});
+			}
+		} };
+	}
+});
+// lint/rules/vue-component-browser-globals.ts
+var vue_component_browser_globals_default = lintRule({
+	id: "vue-component-browser-globals",
+	description: "A component uses browser globals only inside onMounted (and the unmount hooks).",
+	messages: { global: "{{name}} outside onMounted; the build renders the component where there is no {{name}}, so use it only inside onMounted." },
+	create(context) {
+		if (!isComponentCode(context.filename)) return {};
+		return { Identifier(node) {
+			if (!BROWSER.has(node.name) || !isFreeReference(context, node)) return;
+			const stack = [...context.sourceCode.getAncestors(node), node];
+			if (!stack.some((ancestor, index) => ancestor.type === "CallExpression" && ancestor.callee.type === "Identifier" && BROWSER_HOOKS.has(ancestor.callee.name) && ancestor.arguments.some((argument) => argument === stack[index + 1]))) context.report({
+				node,
+				messageId: "global",
+				data: { name: node.name }
+			});
+		} };
+	}
+});
+// lint/rules/vue-component-imports.ts
+const allowed = (source) => source === "vue" || source === "@lernapps/app-templates" || source.startsWith("@lernapps/app-templates/") || TOOLING_IMPORTS.includes(source) || source.startsWith("./") && !source.slice(2).includes("/");
+const SOURCE_IMPORTS = `${IMPORTS}, the app's own files in src/ and the libraries in the dependencies of package.json`;
+/** The libraries in the dependencies of the package.json in `cwd`. */
+function dependencies(cwd) {
+	try {
+		const manifest = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+		return Object.keys(manifest.dependencies ?? {});
+	} catch {
+		return [];
+	}
+}
+/** Whether `source`, imported in `file`, is one of the app's files in src/ or a library of its dependencies. */
+function inSourceScope(cwd, file, source, libraries) {
+	if (source.startsWith("./") || source.startsWith("../")) {
+		const from = relative(cwd, dirname(file)).split("\\").join("/");
+		return posix.normalize(posix.join(from, source)).startsWith("src/");
+	}
+	return libraries.some((name) => source === name || source.startsWith(`${name}/`));
+}
+var vue_component_imports_default = lintRule({
+	id: "vue-component-imports",
+	description: "A component imports only from vue, the runtime, @lernapps/tooling's storage, i18n and a11y, and its own folder.",
+	messages: { import: `an import from {{source}}; a component imports only from {{allowed}}.` },
+	schema: [{
+		type: "object",
+		properties: { scope: {
+			type: "string",
+			enum: ["src"]
+		} },
+		additionalProperties: false
+	}],
+	create(context) {
+		if (!isComponentCode(context.filename)) return {};
+		const sourceScope = context.options[0]?.scope === "src";
+		const cwd = context.cwd;
+		const libraries = sourceScope ? dependencies(cwd) : [];
+		const check = (node) => {
+			const found = importSource(node);
+			if (found === void 0 || isUrl(found.source) || allowed(found.source)) return;
+			if (sourceScope && inSourceScope(cwd, context.filename, found.source, libraries)) return;
+			context.report({
+				node: found.node,
+				messageId: "import",
+				data: {
+					source: found.source,
+					allowed: sourceScope ? SOURCE_IMPORTS : IMPORTS
+				}
+			});
+		};
+		return {
+			ImportDeclaration: check,
+			ExportNamedDeclaration: check,
+			ExportAllDeclaration: check,
+			ImportExpression: check
+		};
+	}
+});
+// lint/rules/vue-component-no-html-injection.ts
+const HTML = /* @__PURE__ */ new Set([
+	"innerHTML",
+	"outerHTML",
+	"insertAdjacentHTML"
+]);
+// lint/plugin.ts
+const rules = {
+	"learner-text-german": learner_text_german_default,
+	"no-request-before-click": no_request_before_click_default,
+	"storage-through-wrapper": storage_through_wrapper_default,
+	"suppression-reason": suppression_reason_default,
+	"vue-component-browser-globals": vue_component_browser_globals_default,
+	"vue-component-imports": vue_component_imports_default,
+	"vue-component-no-html-injection": lintRule({
+		id: "vue-component-no-html-injection",
+		description: "A component runs no code and writes no HTML from strings: no eval, new Function, innerHTML or v-html.",
+		messages: {
+			code: "{{name}}: a component runs no code from strings.",
+			html: "{{name}}: a component writes no HTML from strings; let the template render it."
+		},
+		create(context) {
+			if (!isComponentCode(context.filename)) return {};
+			return {
+				Identifier(node) {
+					if (node.name !== "eval" && node.name !== "Function") return;
+					if (!isFreeReference(context, node)) return;
+					const parent = node.parent;
+					const called = (parent.type === "NewExpression" || parent.type === "CallExpression") && parent.callee === node;
+					if (node.name === "eval" || called) context.report({
+						node,
+						messageId: "code",
+						data: { name: node.name }
+					});
+				},
+				MemberExpression(node) {
+					const key = memberName(node);
+					if (key !== void 0 && HTML.has(key)) context.report({
+						node,
+						messageId: "html",
+						data: { name: key }
+					});
+				},
+				Property(node) {
+					const key = node.key;
+					const name = key.type === "Identifier" ? key.name : key.type === "Literal" ? key.value : void 0;
+					if (!node.computed && name === "innerHTML") context.report({
+						node,
+						messageId: "html",
+						data: { name }
+					});
+				}
+			};
+		}
+	}),
+	"vue-component-no-network": lintRule({
+		id: "vue-component-no-network",
+		description: "A component makes no network request and imports nothing from a URL.",
+		messages: {
+			request: "{{name}}: a component makes no network request; give it what it needs through its props.",
+			beacon: "sendBeacon: a component makes no network request.",
+			import: "an import from {{source}}; a component loads nothing from the network, so bundle what it needs."
+		},
+		create(context) {
+			if (!isComponentCode(context.filename)) return {};
+			const fromUrl = (node) => {
+				const found = importSource(node);
+				if (found !== void 0 && isUrl(found.source)) context.report({
+					node: found.node,
+					messageId: "import",
+					data: { source: found.source }
+				});
+			};
+			return {
+				ImportDeclaration: fromUrl,
+				ExportNamedDeclaration: fromUrl,
+				ExportAllDeclaration: fromUrl,
+				ImportExpression: fromUrl,
+				Identifier(node) {
+					if (NETWORK.has(node.name) && isFreeReference(context, node)) context.report({
+						node,
+						messageId: "request",
+						data: { name: node.name }
+					});
+				},
+				MemberExpression(node) {
+					const key = memberName(node);
+					if (key === "sendBeacon") context.report({
+						node,
+						messageId: "beacon"
+					});
+					else if (key !== void 0 && NETWORK.has(key) && node.object.type === "Identifier" && GLOBAL_OBJECTS.has(node.object.name)) context.report({
+						node,
+						messageId: "request",
+						data: { name: key }
+					});
+				}
+			};
+		}
+	})
+};
+var plugin_default = {
+	meta: { name: "lernapps" },
+	rules
+};
+export { plugin_default as default, rules };

package/dist/plan-DWKayEnY.mjs

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "yaml";
+// src/plan.ts
+/** The folder of the plans, relative to the app's root. */
+const PLANS = ".vibe/plans";
+/** The one plan of an app made before the plans had a folder. */
+const LEGACY_PLAN = ".vibe/plan.md";
+/** Where `lernapps update` moves the legacy plan. */
+const MIGRATED_PLAN = `${PLANS}/01-first-version.md`;
+/** A plan's file name: two digits, a hyphen, a short name. */
+const PLAN_NAME = /^(\d{2})-[^/\\]+\.md$/;
+/** The plans in .vibe/plans/ (regular files named <NN>-<short name>.md), relative to `root`, by number. */
+function plans(root = ".") {
+	const folder = join(root, PLANS);
+	if (!existsSync(folder) || !statSync(folder).isDirectory()) return [];
+	return readdirSync(folder).filter((name) => PLAN_NAME.test(name) && statSync(join(folder, name)).isFile()).sort((a, b) => Number(a.slice(0, 2)) - Number(b.slice(0, 2)) || a.localeCompare(b)).map((name) => `${PLANS}/${name}`);
+}
+/** The current plan, relative to `root`: the highest number in .vibe/plans/, else .vibe/plan.md; undefined if none. */
+function currentPlan(root = ".") {
+	const numbered = plans(root).at(-1);
+	if (numbered !== void 0) return numbered;
+	const legacy = join(root, LEGACY_PLAN);
+	return existsSync(legacy) && statSync(legacy).isFile() ? LEGACY_PLAN : void 0;
+}
+/**
+* The front matter of a plan file, as an object: empty when it has none or it is not YAML. The hooks read it as the
+* schema guidance/plan-front-matter.v1.schema.json describes it.
+*/
+function planFrontMatter(file) {
+	const match = /^---\n([\s\S]*?)\n---\n/.exec(readFileSync(file, "utf8"));
+	if (!match) return {};
+	try {
+		const front = parse(match[1] ?? "");
+		return typeof front === "object" && front !== null ? front : {};
+	} catch {
+		return {};
+	}
+}
+/** Increments prePushFailures in the front matter of the current plan below `root`, when it has the key. */
+function countPrePushFailure(root = ".") {
+	const plan = currentPlan(root);
+	if (plan === void 0) return;
+	const file = join(root, plan);
+	const text = readFileSync(file, "utf8");
+	const counted = text.replace(/^(---\n(?:(?!---\n)[^\n]*\n)*?prePushFailures:[ \t]*)(\d+)/, (_match, head, count) => `${head}${Number(count) + 1}`);
+	if (counted !== text) writeFileSync(file, counted);
+}
+/**
+* Counts a failed check in failedChecks of the current plan's front matter below `root`, when it has the key: one run
+* more for each of `rules`, the rules with an error in that run. A flow map on one line, the rule ids sorted, so the
+* front matter stays one key per line: `failedChecks: { checks-pass: 2, quiz-bank-valid: 1 }`.
+*/
+function countFailedChecks(rules, root = ".") {
+	const plan = currentPlan(root);
+	if (plan === void 0 || rules.length === 0) return;
+	const file = join(root, plan);
+	const text = readFileSync(file, "utf8");
+	const line = /^(---\n(?:(?!---\n)[^\n]*\n)*?failedChecks:[ \t]*)([^\n]*)/.exec(text);
+	if (line === null) return;
+	let counts = {};
+	try {
+		const value = parse(line[2] ?? "");
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			for (const [rule, runs] of Object.entries(value)) if (typeof runs === "number") counts[rule] = runs;
+		}
+	} catch {
+		counts = {};
+	}
+	for (const rule of new Set(rules)) counts[rule] = (counts[rule] ?? 0) + 1;
+	const entries = Object.keys(counts).sort().map((rule) => `${rule}: ${counts[rule]}`);
+	const head = line[1] ?? "";
+	writeFileSync(file, `${head}{ ${entries.join(", ")} }${text.slice(head.length + (line[2] ?? "").length)}`);
+}
+export { countFailedChecks as a, planFrontMatter as c, PLAN_NAME as i, plans as l, MIGRATED_PLAN as n, countPrePushFailure as o, PLANS as r, currentPlan as s, LEGACY_PLAN as t };

package/dist/playwright.mjs

@@ -0,0 +1,47 @@
+import { createServer } from "node:net";
+import { defineConfig, devices } from "playwright/test";
+// archetypes/shared/playwright.ts
+/** A port nobody listens on now, so that several apps (or test runs) can check at the same time. */
+const freePort = () => new Promise((resolve, reject) => {
+	const server = createServer();
+	server.on("error", reject);
+	server.listen(0, "127.0.0.1", () => {
+		const address = server.address();
+		server.close(() => resolve(typeof address === "object" && address !== null ? address.port : 4317));
+	});
+});
+const PORT = process.env["LERNAPPS_PREVIEW_PORT"] ??= String(await freePort());
+const URL = `http://127.0.0.1:${PORT}/`;
+const base = {
+	testDir: "e2e",
+	testMatch: "*.e2e.ts",
+	forbidOnly: true,
+	fullyParallel: true,
+	workers: Number(process.env["LERNAPPS_PLAYWRIGHT_WORKERS"]) || "75%",
+	reporter: [["line"]],
+	use: {
+		baseURL: URL,
+		...process.env["LERNAPPS_CHROMIUM"] ? { launchOptions: { executablePath: process.env["LERNAPPS_CHROMIUM"] } } : {}
+	},
+	projects: [{
+		name: "desktop",
+		use: { ...devices["Desktop Chrome"] }
+	}, {
+		name: "360px",
+		use: {
+			...devices["Desktop Chrome"],
+			viewport: {
+				width: 360,
+				height: 740
+			}
+		}
+	}],
+	webServer: {
+		command: `vp preview --host 127.0.0.1 --port ${PORT} --strictPort`,
+		url: URL
+	}
+};
+/** The configuration, with the app's own settings over it. */
+const playwright = (config = {}) => defineConfig(base, config);
+var playwright_default = playwright();
+export { playwright_default as default, playwright };