@dolphy-app/extension-tools 0.4.0 → 0.6.0

package/dist/cli/main.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 import { builtinModules } from "node:module";
-import path from "node:path";
-import { existsSync, readdirSync, realpathSync, statSync, watch } from "node:fs";
+import path, { extname } from "node:path";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync, watch } from "node:fs";
 import { cp, lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { Ajv2020 } from "ajv/dist/2020.js";
+import "ajv/dist/2020.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
-import { spawn } from "node:child_process";
-import { build, createLogger, parseAst } from "vite";
+import { build, createLogger, mergeConfig, parseAst } from "vite";
 import MagicString from "magic-string";
+import vue from "@vitejs/plugin-vue";
 import { homedir, tmpdir } from "node:os";
+import { spawn } from "node:child_process";
 
 //#region packages/extension-tools/src/errors.ts
 /** Extension build/check error; `subject` is the extension id or directory. */
@@ -86,428 +87,26 @@ const WHEN_KEYS = Object.freeze({
 	},
 	"theme.dark": { type: "boolean" }
 });
-/** Longest condition, in characters. */
-const WHEN_MAX_LENGTH$1 = 200;
-/** A condition that does not parse or does not type-check. */
-var WhenError = class extends Error {
-	reason;
-	/** Character index in the text where the problem starts. */
-	position;
-	/** What is wrong, without the position. */
-	detail;
-	constructor(reason, position, detail) {
-		super(`${detail} at ${position}`);
-		this.name = "WhenError";
-		this.reason = reason;
-		this.position = position;
-		this.detail = detail;
-	}
-};
-const WORD = /[A-Za-z][A-Za-z0-9._-]*/y;
-const tokenize$1 = (text) => {
-	const tokens = [];
-	let index = 0;
-	while (index < text.length) {
-		const char = text[index];
-		if (/\s/.test(char)) {
-			index += 1;
-			continue;
-		}
-		const two = text.slice(index, index + 2);
-		if (two === "&&" || two === "||" || two === "==" || two === "!=") {
-			tokens.push({
-				kind: "punct",
-				text: two,
-				at: index
-			});
-			index += 2;
-			continue;
-		}
-		if (char === "(" || char === ")" || char === "," || char === "!") {
-			tokens.push({
-				kind: "punct",
-				text: char,
-				at: index
-			});
-			index += 1;
-			continue;
-		}
-		if (char === "'") {
-			const close = text.indexOf("'", index + 1);
-			if (close === -1) throw new WhenError("unterminated-string", index, "unterminated string");
-			tokens.push({
-				kind: "string",
-				text: text.slice(index + 1, close),
-				at: index
-			});
-			index = close + 1;
-			continue;
-		}
-		WORD.lastIndex = index;
-		const word = WORD.exec(text);
-		if (word !== null) {
-			tokens.push({
-				kind: "word",
-				text: word[0],
-				at: index
-			});
-			index += word[0].length;
-			continue;
-		}
-		throw new WhenError("unexpected-character", index, `unexpected character '${char}'`);
-	}
-	tokens.push({
-		kind: "end",
-		at: text.length
-	});
-	return tokens;
-};
-const isKey = (name) => Object.hasOwn(WHEN_KEYS, name);
-const describe = (token) => {
-	if (token.kind === "end") return "end of the condition";
-	if (token.kind === "string") return `string '${token.text}'`;
-	return `'${token.text}'`;
-};
-function fail$1(token, expected) {
-	throw new WhenError(token.kind === "end" ? "unexpected-end" : "unexpected-token", token.at, `expected ${expected}, found ${describe(token)}`);
-}
-var Parser$1 = class {
-	index = 0;
-	tokens;
-	constructor(tokens) {
-		this.tokens = tokens;
-	}
-	peek() {
-		return this.tokens[this.index];
-	}
-	next() {
-		const token = this.tokens[this.index];
-		if (token.kind !== "end") this.index += 1;
-		return token;
-	}
-	isPunct(text) {
-		const token = this.peek();
-		return token.kind === "punct" && token.text === text;
-	}
-	isWord(text) {
-		const token = this.peek();
-		return token.kind === "word" && token.text === text;
-	}
-	parse() {
-		const expr = this.or();
-		const token = this.peek();
-		if (token.kind !== "end") fail$1(token, "'&&', '||' or the end");
-		return expr;
-	}
-	or() {
-		const terms = [this.and()];
-		while (this.isPunct("||")) {
-			this.next();
-			terms.push(this.and());
-		}
-		return terms.length === 1 ? terms[0] : {
-			type: "or",
-			terms
-		};
-	}
-	and() {
-		const terms = [this.factor()];
-		while (this.isPunct("&&")) {
-			this.next();
-			terms.push(this.factor());
-		}
-		return terms.length === 1 ? terms[0] : {
-			type: "and",
-			terms
-		};
-	}
-	factor() {
-		const token = this.peek();
-		if (token.kind === "punct" && token.text === "!") {
-			this.next();
-			return {
-				type: "not",
-				expr: this.negated()
-			};
-		}
-		if (token.kind === "punct" && token.text === "(") {
-			this.next();
-			const expr = this.or();
-			const close = this.peek();
-			if (!(close.kind === "punct" && close.text === ")")) fail$1(close, "')'");
-			this.next();
-			return expr;
-		}
-		if (token.kind !== "word") fail$1(token, "a key, true, false, ! or (");
-		if (token.text === "true" || token.text === "false") {
-			this.next();
-			return {
-				type: "literal",
-				value: token.text === "true"
-			};
-		}
-		return this.keyed();
-	}
-	/** The operand of `!`: a boolean key, a group or another `!`. */
-	negated() {
-		const token = this.peek();
-		if (token.kind === "word" && isKey(token.text)) {
-			const expr = this.keyed();
-			if (expr.type !== "key") throw new WhenError("unexpected-token", token.at, "'!' applies to a key or a group; write !(…) around a comparison");
-			return expr;
-		}
-		return this.factor();
-	}
-	/** A key alone (boolean keys only), or a comparison with it. */
-	keyed() {
-		const token = this.next();
-		if (token.kind !== "word") fail$1(token, "a key");
-		if (!isKey(token.text)) throw new WhenError("unknown-key", token.at, `unknown key '${token.text}' (known: ${Object.keys(WHEN_KEYS).join(", ")})`);
-		const key = token.text;
-		const spec = WHEN_KEYS[key];
-		const op = this.peek();
-		if (op.kind === "punct" && (op.text === "==" || op.text === "!=")) {
-			this.next();
-			const literal = this.literal(key, spec);
-			return {
-				type: "compare",
-				key,
-				op: op.text,
-				value: literal
-			};
-		}
-		if (this.isWord("in")) {
-			this.next();
-			const open = this.peek();
-			if (!(open.kind === "punct" && open.text === "(")) fail$1(open, "'(' after in");
-			this.next();
-			const values = [this.literal(key, spec)];
-			while (this.isPunct(",")) {
-				this.next();
-				values.push(this.literal(key, spec));
-			}
-			const close = this.peek();
-			if (!(close.kind === "punct" && close.text === ")")) fail$1(close, "',' or ')'");
-			this.next();
-			return {
-				type: "in",
-				key,
-				values
-			};
-		}
-		if (spec.type !== "boolean") throw new WhenError("type-mismatch", token.at, `'${key}' is a text key: compare it ('${key} == …') or use 'in'`);
-		return {
-			type: "key",
-			key
-		};
-	}
-	/** A string or `true`/`false` that fits the key's type. */
-	literal(key, spec) {
-		const token = this.next();
-		if (token.kind === "string") {
-			if (spec.type === "boolean") throw new WhenError("type-mismatch", token.at, `'${key}' is a boolean: compare it with true or false, not '${token.text}'`);
-			if (!spec.values.includes(token.text)) throw new WhenError("unknown-value", token.at, `unknown value '${token.text}' for '${key}' (known: ${spec.values.join(", ")})`);
-			return token.text;
-		}
-		if (token.kind === "word" && (token.text === "true" || token.text === "false")) {
-			if (spec.type !== "boolean") throw new WhenError("type-mismatch", token.at, `'${key}' is a text key: compare it with a 'string', not ${token.text}`);
-			return token.text === "true";
-		}
-		return fail$1(token, spec.type === "boolean" ? "true or false" : "a 'string'");
-	}
-};
-/**
-* Parses and type-checks a condition. Throws `WhenError` (reason and
-* character position) for an empty or longer than `WHEN_MAX_LENGTH`
-* condition, a syntax error, an unknown key or value, and a type mismatch.
-*/
-const parseWhen$1 = (text) => {
-	if (text.trim() === "") throw new WhenError("empty", 0, "empty condition");
-	if (text.length > 200) throw new WhenError("too-long", 200, `condition longer than ${200} characters`);
-	return new Parser$1(tokenize$1(text)).parse();
-};
 
 //#endregion
-//#region packages/extension-api/src/locale.ts
-/**
-* Manifest localization. A string that is entirely `%key%` in a localizable
-* manifest field is replaced by the value of `key` from `locales/<language>.json`.
-* The functions are pure: the app window, the engine and the tools share them.
-*/
-/** Languages of `locales/<language>.json` (the app interface languages). */
-const EXTENSION_LOCALES = ["ru", "en"];
-/** The root of the fallback chain and the only language of the catalog. */
-const FALLBACK_LOCALE = "en";
-/** Directory of the translation tables inside an extension. */
-const LOCALES_DIR = "locales";
-/** `locales/<language>.json` for a language. */
-const localeFile = (locale) => `${LOCALES_DIR}/${locale}.json`;
-/** Key of a translation (without the `%` signs). */
-const LOCALE_KEY_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
-const PLACEHOLDER_PATTERN = /^%([A-Za-z0-9_.-]{1,64})%$/;
-/** Limits of a translation file; the values are checked at discovery and by the tools. */
-const LOCALE_LIMITS = Object.freeze({
-	/** Size of the file in bytes. */
-	fileBytes: 65536,
-	keys: 500,
-	/** Longest value in UTF-16 code units. */
-	valueLength: 500
+//#region packages/extension-api/src/hooks.ts
+/** Limits on hooks; the host and the engine check the same numbers. */
+const EXTENSION_HOOK_LIMITS = Object.freeze({
+	/** Budget of one handler call, ms. */
+	timeoutMs: 3e4,
+	/** Hooks registered by one extension. */
+	hooks: 8,
+	/** Exercises in a `practice.batch` response. */
+	maxExercises: 500
 });
-const isExtensionLocale = (value) => EXTENSION_LOCALES.includes(value);
-/** The key of `%key%`; `null` if the string is not a placeholder as a whole. */
-const placeholderKey = (value) => PLACEHOLDER_PATTERN.exec(value)?.[1] ?? null;
-const lookup = (table, key) => table !== void 0 && Object.hasOwn(table, key) ? table[key] : void 0;
-/**
-* Text for `locale`: a plain string is returned as is; `%key%` is taken from
-* the table of `locale`, then from `en`, then stays `%key%`.
-*/
-const resolveText = (value, tables, locale) => {
-	const key = placeholderKey(value);
-	if (key === null || tables === void 0) return value;
-	return (isExtensionLocale(locale) ? lookup(tables[locale], key) : void 0) ?? lookup(tables["en"], key) ?? value;
-};
-const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/** Checks the parsed content of a translation file; every problem is an English message. */
-const parseLocaleTable = (json) => {
-	if (!isRecord$2(json)) return {
-		ok: false,
-		issues: ["must be a flat object of strings"]
-	};
-	const entries = Object.entries(json);
-	const issues = [];
-	if (entries.length > LOCALE_LIMITS.keys) issues.push(`${entries.length} keys exceed the limit of ${LOCALE_LIMITS.keys}`);
-	const table = Object.create(null);
-	for (const [key, value] of entries) if (!LOCALE_KEY_PATTERN.test(key)) issues.push(`key '${key}' must match ${LOCALE_KEY_PATTERN}`);
-	else if (typeof value !== "string") issues.push(`'${key}' must be a string`);
-	else if (value.length > LOCALE_LIMITS.valueLength) issues.push(`'${key}' is longer than ${LOCALE_LIMITS.valueLength} characters`);
-	else table[key] = value;
-	return issues.length > 0 ? {
-		ok: false,
-		issues
-	} : {
-		ok: true,
-		table: { ...table }
-	};
-};
-/** Size of the text in UTF-8, without `TextEncoder`: the package has no DOM or Node types. */
-const utf8Length = (text) => {
-	let bytes = 0;
-	for (const char of text) {
-		const code = char.codePointAt(0) ?? 0;
-		if (code < 128) bytes += 1;
-		else if (code < 2048) bytes += 2;
-		else if (code < 65536) bytes += 3;
-		else bytes += 4;
-	}
-	return bytes;
-};
-/** Checks the text of a translation file: size, JSON syntax and content. */
-const parseLocaleText = (text) => {
-	const bytes = utf8Length(text);
-	if (bytes > LOCALE_LIMITS.fileBytes) return {
-		ok: false,
-		issues: [`${bytes} bytes exceed the limit of ${LOCALE_LIMITS.fileBytes}`]
-	};
-	let json;
-	try {
-		json = JSON.parse(text);
-	} catch (error) {
-		return {
-			ok: false,
-			issues: [`is not valid JSON: ${error instanceof Error ? error.message : String(error)}`]
-		};
-	}
-	return parseLocaleTable(json);
-};
-/** Fields of the manifest that accept `%key%`, by contribution point. */
-const LOCALIZED_FIELDS = {
-	exerciseTypes: ["title"],
-	markdownRenderers: ["title"],
-	themes: ["label"],
-	gradePolicies: ["label"],
-	settings: [
-		"label",
-		"description",
-		"group"
-	],
-	commands: [
-		"title",
-		"description",
-		"category"
-	],
-	panels: ["title"],
-	widgets: ["title"]
-};
-/** Fields of the manifest root that accept `%key%`. */
-const LOCALIZED_ROOT_FIELDS = ["name", "description"];
-const visitFields = (holder, fields, prefix, visit) => {
-	if (!isRecord$2(holder)) return;
-	for (const field of fields) if (typeof holder[field] === "string") visit(holder, field, `${prefix}.${field}`);
-};
-const visitLocalizable = (manifest, visit) => {
-	if (!isRecord$2(manifest)) return;
-	for (const field of LOCALIZED_ROOT_FIELDS) if (typeof manifest[field] === "string") visit(manifest, field, field);
-	const { contributes } = manifest;
-	if (!isRecord$2(contributes)) return;
-	for (const [point, fields] of Object.entries(LOCALIZED_FIELDS)) {
-		const entries = contributes[point];
-		if (!Array.isArray(entries)) continue;
-		entries.forEach((entry, index) => {
-			const prefix = `contributes.${point}.${index}`;
-			visitFields(entry, fields, prefix, visit);
-			if (point !== "settings" || !isRecord$2(entry)) return;
-			const { options } = entry;
-			if (!Array.isArray(options)) return;
-			options.forEach((option, optionIndex) => visitFields(option, ["label"], `${prefix}.options.${optionIndex}`, visit));
-		});
-	}
-};
-/** Every localizable string of a raw or normalized manifest, in manifest order. */
-const localizableStrings = (manifest) => {
-	const found = [];
-	visitLocalizable(manifest, (holder, field, path) => found.push({
-		path,
-		value: holder[field]
-	}));
-	return found;
-};
-/** Distinct keys of the `%key%` strings of a manifest, in manifest order. */
-const placeholderKeys = (manifest) => [...new Set(localizableStrings(manifest).flatMap(({ value }) => {
-	const key = placeholderKey(value);
-	return key === null ? [] : [key];
-}))];
-/**
-* A copy of the manifest with every placeholder replaced by its text in
-* `locale` (chain: `locale`, `en`); a key without a text stays `%key%`.
-*/
-const localizeManifest = (manifest, tables, locale) => {
-	const copy = JSON.parse(JSON.stringify(manifest));
-	visitLocalizable(copy, (holder, field) => {
-		holder[field] = resolveText(holder[field], tables, locale);
-	});
-	return copy;
-};
+/** Hooks an extension can register with `server.before`. */
+const EXTENSION_HOOK_NAMES = ["session.start", "practice.batch"];
 
 //#endregion
 //#region packages/extension-api/src/index.ts
-/**
-* Public extension API. The package depends on neither the engine nor the DOM: it is imported
-* by extension code (`main.mjs`), by the answer element (`view.mjs`), and by the engine itself.
-*/
 const EXTENSION_ID_PATTERN = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
 /** GitHub login of the extension author (`author` in the manifest and catalog). */
 const GITHUB_LOGIN_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$/;
-/** Capabilities an extension declares in its manifest; none without a declaration. */
-const EXTENSION_PERMISSIONS = [
-	"library.read",
-	"process.spawn",
-	"worker.threads",
-	"native.addons",
-	"network",
-	"learning.events",
-	"learning.stats",
-	"notifications"
-];
 /** Platforms the extension can run on (`process.platform`). */
 const EXTENSION_PLATFORMS = [
 	"darwin",
@@ -524,7 +123,6 @@ const EXTENSION_TAGS = [
 	"productivity",
 	"developer"
 ];
-const ELEMENT_NAME_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/;
 /**
 * Closed list of icon names an extension picks from (`icon` of a command or panel); the
 * app draws its own glyph for each name, so nothing from the extension is rendered as an image.
@@ -555,24 +153,13 @@ const EXTENSION_ICONS = [
 	"bookmark",
 	"tag"
 ];
-/** Icon of a command or panel without `icon`. */
-const DEFAULT_EXTENSION_ICON = "puzzle";
-/** Where on the screen a widget is shown; `dailyPlan` is the "Daily plan" page. */
-const EXTENSION_WIDGET_SLOTS = ["dailyPlan"];
-/** Limits on widgets; the manifest and the app enforce them. */
-const EXTENSION_WIDGET_LIMITS = Object.freeze({
-	/** Widgets per extension. */
-	widgets: 3,
-	/** Smallest allowed `minHeight`, px. */
-	minHeight: 80,
-	/** Largest allowed `maxHeight`, px. */
-	maxHeight: 320
-});
+/** Limits on injections; the app enforces them. */
+const INJECTION_LIMITS = Object.freeze({ 
+/** Characters in `InjectionRegistration.target`. */
+selectorLength: 200 });
 /** `at` of a `daily` schedule: `HH:MM`, 24-hour clock, local time. */
 const SCHEDULE_AT_PATTERN = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
-/** `at` of a `daily` schedule without one. */
-const DEFAULT_SCHEDULE_AT = "09:00";
-/** Limits on schedules; the manifest, the scheduler, and the runtime enforce them. */
+/** Limits on schedules; the host, the scheduler, and the runtime enforce them. */
 const EXTENSION_SCHEDULE_LIMITS = Object.freeze({
 	/** Schedules per extension. */
 	schedules: 4,
@@ -583,7 +170,7 @@ const EXTENSION_SCHEDULE_LIMITS = Object.freeze({
 	/** How often the app looks for due firings, ms. */
 	tickMs: 3e4
 });
-/** Limits of the settings types (`text`, `color`, `list`, `group`, `order`); they match those checked by the manifest and the engine. */
+/** Limits of the settings types (`text`, `color`, `list`, `enum`, `group`, `order`); they match those checked by the host and the engine. */
 const SETTING_LIMITS = Object.freeze({
 	/** `maxLength` of `string` and `text`. */
 	stringLength: 1e4,
@@ -591,60 +178,25 @@ const SETTING_LIMITS = Object.freeze({
 	listItems: 50,
 	/** `itemMaxLength` of `list`. */
 	listItemLength: 200,
+	/** Length of a label, in UTF-16 code units; also of an option's label. */
+	labelLength: 60,
+	/** Length of a help text. */
+	descriptionLength: 500,
 	groupLength: 60,
-	orderMax: 1e3
+	orderMax: 1e3,
+	/** Options of one `enum`. */
+	options: 64,
+	/** Length of an option's value. */
+	optionValueLength: 100
 });
-/** `#rrggbb` (any case in the manifest; the stored value is lower-case). */
+/** `#rrggbb` (any case in a definition; the stored value is lower-case). */
 const COLOR_SETTING_PATTERN = /^#[0-9a-fA-F]{6}$/;
-/** Learning events an extension with the `learning.events` permission can subscribe to. */
+/** Learning events an extension can subscribe to. */
 const LEARNING_EVENT_NAMES = [
 	"session.started",
 	"session.finished",
 	"attempt.closed"
 ];
-/** Identifiers of built-in themes: extensions cannot take them. */
-const BUILTIN_THEME_IDS = [
-	"system",
-	"light",
-	"dark"
-];
-/** Allowed keys of `ThemeContribution.colors`. */
-const THEME_COLOR_KEYS = [
-	"background",
-	"surface",
-	"surface-bright",
-	"surface-light",
-	"surface-variant",
-	"on-background",
-	"on-surface",
-	"on-surface-variant",
-	"primary",
-	"on-primary",
-	"secondary",
-	"on-secondary",
-	"error",
-	"on-error",
-	"warning",
-	"on-warning",
-	"success",
-	"on-success",
-	"info",
-	"on-info",
-	"hero-start",
-	"hero-end",
-	"hero-contrast"
-];
-/** Allowed keys of `ThemeContribution.variables`. */
-const THEME_VARIABLE_KEYS = [
-	"border-color",
-	"border-opacity",
-	"medium-emphasis-opacity",
-	"high-emphasis-opacity",
-	"disabled-opacity"
-];
-const DEFAULT_MARKDOWN_RENDERER = "./markdown.mjs";
-const DEFAULT_PANEL = "./panel.mjs";
-const DEFAULT_WIDGET = "./widget.mjs";
 const KEYBINDING_STROKE = `(?:(?:Mod|Ctrl|Control|Alt|Option|Shift|Cmd|Command|Meta|Win|Super)\\+){0,3}(?:[A-Z0-9]|F(?:[1-9]|1[0-9]|2[0-4])|Enter|Return|Space|Tab|Escape|Esc|Backspace|Delete|Insert|Arrow(?:Up|Down|Left|Right)|Home|End|Page(?:Up|Down)|Plus|\\[[A-Za-z][A-Za-z0-9]*\\]|[\`\\-=\\[\\]\\\\;',./+])`;
 /**
 * Key notation: one stroke or two strokes separated by a space
@@ -656,11 +208,11 @@ const KEYBINDING_STROKE = `(?:(?:Mod|Ctrl|Control|Alt|Option|Shift|Cmd|Command|M
 * host validates every string authoritatively with `@dolphy-app/keybindings`.
 */
 const KEYBINDING_PATTERN = new RegExp(`^${KEYBINDING_STROKE}(?: ${KEYBINDING_STROKE})?$`);
-/** Limits on commands and panels (R1, R3); they match those checked by the manifest, host, and engine. */
+/** Limits on commands and panels (R1, R3); they match those checked by the host and the engine. */
 const EXTENSION_COMMAND_LIMITS = Object.freeze({
 	/** Keybinding entries (`keybindings`) per command. */
 	keybindingsPerCommand: 4,
-	/** Length of a `when` condition (of a command, panel, widget or `keybindings[]` entry). */
+	/** Length of a `when` condition (of a command, panel or `keybindings[]` entry). */
 	whenLength: 200,
 	/** Commands per extension. */
 	commands: 64,
@@ -680,7 +232,7 @@ const EXTENSION_COMMAND_LIMITS = Object.freeze({
 });
 /** A file extension an importer accepts: a dot and 1–16 lower-case letters or digits. */
 const TRANSFER_ACCEPT_PATTERN = /^\.[a-z0-9]{1,16}$/;
-/** Limits on importers and exporters; the manifest, host, and engine check the same numbers. */
+/** Limits on importers and exporters; the host and the engine check the same numbers. */
 const EXTENSION_TRANSFER_LIMITS = Object.freeze({
 	/** Importers per extension. */
 	importers: 8,
@@ -705,10 +257,25 @@ const EXTENSION_TRANSFER_LIMITS = Object.freeze({
 	/** One path of the returned directory, UTF-8 bytes. */
 	pathBytes: 1024
 });
+/**
+* Name of an RPC contract: lower-case dot-separated segments, such as
+* `greeting.say-hello`, the first segment without a hyphen, at least two
+* segments, at most `EXTENSION_RPC_LIMITS.nameLength` characters.
+*/
+const RPC_NAME_PATTERN = /^[a-z][a-z0-9]*(\.[a-z][a-z0-9-]*)+$/;
+/** Limits on RPC between the client and the server part of an extension; the host and the engine check the same numbers. */
+const EXTENSION_RPC_LIMITS = Object.freeze({
+	/** Characters in the name of a contract. */
+	nameLength: 120,
+	/** Handlers (`server.handle`) per extension. */
+	rpcs: 64,
+	/** `JSON.stringify(input).length` at the engine boundary. */
+	inputChars: 2e5,
+	/** Handler budget, ms. */
+	handlerMs: 1e4
+});
 const DEFAULT_MAIN = "./main.mjs";
-const DEFAULT_RENDERER = "./view.mjs";
-/** Default element tag: `dolphy.sql` → `dolphy-sql-answer`. */
-const defaultElementName = (id) => `${id.replaceAll(".", "-")}-answer`;
+const DEFAULT_CLIENT = "./client.mjs";
 /** Extension storage limits (R2); they match the engine's limits, which enforces them. */
 const EXTENSION_STORAGE_LIMITS = Object.freeze({
 	/** Key length in UTF-16 code units. */
@@ -729,11 +296,11 @@ const EXTENSION_SECRET_LIMITS = Object.freeze({
 	/** Number of keys. */
 	keys: 32
 });
-/** Limits of `ctx.stats`; the engine enforces them. */
+/** Limits of `server.stats`; the engine enforces them. */
 const EXTENSION_STATS_LIMITS = Object.freeze({ 
 /** Most dates in one `daily` range (both ends included). */
 dailyDays: 366 });
-/** Limits of `ctx.notifications`; the engine enforces them. */
+/** Limits of `server.notifications`; the engine enforces them. */
 const EXTENSION_NOTIFICATION_LIMITS = Object.freeze({
 	/** Title length in characters (code points). */
 	titleLength: 80,
@@ -744,32 +311,46 @@ const EXTENSION_NOTIFICATION_LIMITS = Object.freeze({
 	/** Notifications per rolling hour and extension. */
 	perHour: 30
 });
+/** Registration of an extension without a server part, or before it has registered anything. */
+const EMPTY_SERVER_REGISTRATION = Object.freeze({
+	exerciseTypes: Object.freeze([]),
+	gradePolicies: Object.freeze([]),
+	settings: Object.freeze([]),
+	events: Object.freeze([]),
+	commands: Object.freeze([]),
+	schedules: Object.freeze([]),
+	importers: Object.freeze([]),
+	exporters: Object.freeze([]),
+	rpcs: Object.freeze([]),
+	hooks: Object.freeze([])
+});
 
 //#endregion
 //#region packages/extension-host/src/protocol.ts
 const eventParams = z.strictObject({
 	extensionId: z.string(),
 	name: z.enum(LEARNING_EVENT_NAMES),
-	payload: z.record(z.string(), z.unknown()),
-	isolated: z.boolean()
+	payload: z.record(z.string(), z.unknown())
 });
 const scheduleParams = z.strictObject({
 	extensionId: z.string(),
-	scheduleId: z.string(),
-	isolated: z.boolean()
+	scheduleId: z.string()
 });
 const commandParams = z.strictObject({
 	extensionId: z.string(),
 	commandId: z.string(),
-	args: z.unknown().optional(),
-	isolated: z.boolean()
+	args: z.unknown().optional()
+});
+const rpcParams = z.strictObject({
+	extensionId: z.string(),
+	name: z.string(),
+	input: z.unknown().optional()
 });
 const bytesField = z.custom((value) => value instanceof Uint8Array, "must be a Uint8Array");
 const importParams = {
 	extensionId: z.string(),
 	importerId: z.string(),
-	name: z.string(),
-	isolated: z.boolean()
+	name: z.string()
 };
 const exportInput = z.discriminatedUnion("scope", [z.strictObject({
 	scope: z.literal("course"),
@@ -780,8 +361,7 @@ const exportInput = z.discriminatedUnion("scope", [z.strictObject({
 const typed = {
 	type: z.string(),
 	exerciseId: z.string(),
-	spec: z.unknown(),
-	isolated: z.boolean()
+	spec: z.unknown()
 };
 const extRequestSchema = z.discriminatedUnion("method", [
 	z.strictObject({
@@ -817,8 +397,7 @@ const extRequestSchema = z.discriminatedUnion("method", [
 				]),
 				reason: z.string().optional()
 			})),
-			gaveUp: z.boolean(),
-			isolated: z.boolean()
+			gaveUp: z.boolean()
 		})
 	}),
 	z.strictObject({
@@ -836,6 +415,11 @@ const extRequestSchema = z.discriminatedUnion("method", [
 		method: z.literal("invokeCommand"),
 		params: commandParams
 	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("invokeRpc"),
+		params: rpcParams
+	}),
 	z.strictObject({
 		id: z.string(),
 		method: z.literal("runImporter"),
@@ -853,8 +437,16 @@ const extRequestSchema = z.discriminatedUnion("method", [
 		params: z.strictObject({
 			extensionId: z.string(),
 			exporterId: z.string(),
-			input: exportInput,
-			isolated: z.boolean()
+			input: exportInput
+		})
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("runHook"),
+		params: z.strictObject({
+			extensionId: z.string(),
+			name: z.enum(EXTENSION_HOOK_NAMES),
+			request: z.unknown()
 		})
 	})
 ]);
@@ -994,30 +586,44 @@ const hostResponseSchema = z.union([z.strictObject({
 		details: z.record(z.string(), z.unknown()).optional()
 	})
 })]);
-const isResolvedExtension = (value) => {
+const isExtensionCandidate = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	const item = value;
-	return typeof item.id === "string" && typeof item.version === "string" && typeof item.dir === "string" && typeof item.revision === "string" && (item.origin === "bundled" || item.origin === "user" || item.origin === "dev") && Array.isArray(item.permissions) && Array.isArray(item.dependencies) && typeof item.messages === "object" && item.messages !== null && Array.isArray(item.warnings) && Array.isArray(item.exerciseTypes) && Array.isArray(item.themes) && Array.isArray(item.markdownRenderers) && Array.isArray(item.gradePolicies) && Array.isArray(item.settings) && Array.isArray(item.events) && Array.isArray(item.commands) && Array.isArray(item.panels) && Array.isArray(item.widgets) && Array.isArray(item.schedules) && Array.isArray(item.importers) && Array.isArray(item.exporters);
+	return typeof item.id === "string" && typeof item.version === "string" && typeof item.dir === "string" && typeof item.revision === "string" && (item.origin === "bundled" || item.origin === "user" || item.origin === "dev") && (item.mainPath === null || typeof item.mainPath === "string") && (item.clientPath === null || typeof item.clientPath === "string") && Array.isArray(item.dependencies) && Array.isArray(item.warnings);
 };
 /** Набор приходит от движка того же приложения, поэтому проверяется форма, а не каждое поле. */
 const replaceExtensionsSchema = z.strictObject({
 	id: z.string(),
 	method: z.literal("replaceExtensions"),
-	params: z.strictObject({ extensions: z.array(z.custom(isResolvedExtension)) })
+	params: z.strictObject({ extensions: z.array(z.custom(isExtensionCandidate)) })
 });
+/** Кадры туннеля `engine-rpc`: форму кадра проверяет получатель протокола (диспетчер или клиент движка). */
+const engineTunnelSchema = z.discriminatedUnion("method", [z.strictObject({
+	method: z.literal("engineFrame"),
+	params: z.strictObject({
+		extensionId: z.string(),
+		frame: z.unknown()
+	})
+}), z.strictObject({
+	method: z.literal("engineDetach"),
+	params: z.strictObject({ extensionId: z.string() })
+})]);
 /** Всё, что хост расширений принимает по каналу. */
 const extMessageSchema = z.union([
 	extRequestSchema,
 	replaceExtensionsSchema,
 	settingChangedSchema,
+	engineTunnelSchema,
 	hostResponseSchema
 ]);
-/** Всё, что ограниченный процесс принимает от хоста (набор расширений ему не шлют). */
-const childInboundSchema = z.union([
-	extRequestSchema,
-	settingChangedSchema,
-	hostResponseSchema
-]);
+/** Ответ на `replaceExtensions`: итог по каждому расширению; форму регистрации проверил регистратор хоста. */
+const replaceExtensionsResultSchema = z.strictObject({ registrations: z.record(z.string(), z.union([z.strictObject({
+	ok: z.literal(true),
+	registration: z.custom((value) => typeof value === "object" && value !== null)
+}), z.strictObject({
+	ok: z.literal(false),
+	error: z.string()
+})])) });
 /** Результат правила оценки: целое 1–5 или `null`. */
 const gradeValueSchema = z.union([z.literal([
 	1,
@@ -1081,6 +687,80 @@ const commandOutcomeSchema = z.discriminatedUnion("kind", [
 	})
 ]);
 
+//#endregion
+//#region packages/extension-api/src/hook-schemas.ts
+/**
+* Request and response schemas of the hooks in `hooks.ts`. They live apart
+* from the names and types so that code which only registers or types a hook
+* (every browser bundle imports this package) does not pull `zod` in; the host,
+* the engine and the test server import them from
+* `@dolphy-app/extension-api/hook-schemas`.
+*/
+const itemReason = z.enum([
+	"review",
+	"new",
+	"remediation"
+]);
+/** `null` fields: the exercise has no attempts yet, so there is no memory state. */
+const exerciseMemory = z.object({
+	/** Probability of recall right now, 0..1. */
+	retrievability: z.number().nullable(),
+	/** Unix epoch milliseconds of the newest attempt. */
+	lastAttemptAt: z.number().nullable(),
+	/** Attempts that count (cancelled ones excluded). */
+	attempts: z.number(),
+	/** FSRS stability in days. */
+	stability: z.number().nullable(),
+	/** FSRS difficulty. */
+	difficulty: z.number().nullable()
+});
+/**
+* Request and response schema of every hook. The handlers of the extensions
+* that registered a hook run one after another in ascending order of the
+* extension id; each gets the response of the previous one (for a hook
+* without a response, the same request). A thrown error, an invalid
+* response or a handler exceeding `EXTENSION_HOOK_LIMITS.timeoutMs` cancels
+* the operation and the error message reaches the user.
+*/
+const EXTENSION_HOOKS = Object.freeze({
+	/**
+	* A learning session is about to start. The handler can only cancel the
+	* start by throwing.
+	*/
+	"session.start": {
+		request: z.object({ 
+		/** Unix epoch milliseconds. */
+now: z.number() }),
+		response: z.void()
+	},
+	/**
+	* A batch of exercises or a day plan is about to be handed to the learner.
+	* `exerciseIds` and `reasons` are parallel arrays; the response can
+	* reorder, remove and add exercises (every id must exist in the library;
+	* `exerciseIds` and `reasons` keep the same length, at most
+	* `EXTENSION_HOOK_LIMITS.maxExercises`).
+	*/
+	"practice.batch": {
+		request: z.object({
+			/** The open session; `null` while none has started. */
+			sessionId: z.string().nullable(),
+			/** `batch` — `practice.getBatch`, `plan` — `plan.getDay`. */
+			source: z.enum(["batch", "plan"]),
+			exerciseIds: z.array(z.string()),
+			reasons: z.array(itemReason),
+			/**
+			* Parallel to `exerciseIds`: what the engine remembers of each
+			* exercise. Read-only; the FSRS state is not changed by the hook.
+			*/
+			memory: z.array(exerciseMemory)
+		}),
+		response: z.object({
+			exerciseIds: z.array(z.string()).max(EXTENSION_HOOK_LIMITS.maxExercises),
+			reasons: z.array(itemReason).max(EXTENSION_HOOK_LIMITS.maxExercises)
+		}).refine(({ exerciseIds, reasons }) => exerciseIds.length === reasons.length, { message: "exerciseIds and reasons must have the same length" })
+	}
+});
+
 //#endregion
 //#region packages/extension-host/src/diagnostics.ts
 const text$1 = (data, key) => {
@@ -1102,9 +782,7 @@ const FORMATTERS = {
 	"dependency-disabled": (data) => `requires extension '${text$1(data, "id")}'${rangeSuffix(data)}, which is disabled`,
 	"dependency-version": (data) => `requires extension '${text$1(data, "id")}' ${text$1(data, "range")}, found ${text$1(data, "found")}`,
 	"dependency-unmet": (data) => `requires extension '${text$1(data, "id")}'${rangeSuffix(data)}, which is not loaded because its own dependencies are not met`,
-	"dependency-cycle": (data) => `extensions depend on each other: ${text$1(data, "cycle")}`,
-	"locale.missing-key": (data) => `key '${text$1(data, "key")}' is missing in locales/en.json`,
-	"locale.invalid-file": (data) => `${text$1(data, "file")} is ignored: ${text$1(data, "reason")}`
+	"dependency-cycle": (data) => `extensions depend on each other: ${text$1(data, "cycle")}`
 };
 /**
 * English text of a diagnostic: the single place that renders it for the CLI,
@@ -1474,23 +1152,8 @@ const installMetaSchema = z.strictObject({
 const CATALOG_SCHEMA_VERSION = 2;
 const MAX_VERSIONS = 5;
 const MAX_TOTAL_BYTES = 1e7;
-/** Longest contribution title in `titles` (the manifest limit of `label`/`title`). */
-const MAX_TITLE_LENGTH = 60;
 /** Most tags of a version. */
 const MAX_TAGS = 5;
-/** Contribution points whose entries carry a human title in the manifest (`label` or `title`); for exercise types and renderers the title is optional and the renderer is keyed by its language. */
-const TITLED_POINTS = [
-	"exerciseTypes",
-	"markdownRenderers",
-	"themes",
-	"gradePolicies",
-	"settings",
-	"commands",
-	"panels",
-	"widgets",
-	"importers",
-	"exporters"
-];
 const MAX_PATH_LENGTH = 200;
 const SHA256 = /^[0-9a-f]{64}$/;
 /** Допустимые символы сегмента пути: без `:` (потоки NTFS), пробелов и управляющих символов. */
@@ -1663,7 +1326,6 @@ const versionSchemaOf = (profile) => object(profile, {
 	version: semver,
 	apiVersion: z.number().int().min(1),
 	minAppVersion: semver.nullable(),
-	permissions: z.array(z.enum(EXTENSION_PERMISSIONS)),
 	publishedAt: timestamp,
 	baseUrl,
 	files: filesSchemaOf(profile),
@@ -1674,26 +1336,6 @@ const versionSchemaOf = (profile) => object(profile, {
 	/** Extensions the version needs (`dependencies` of the manifest); no key — none. */
 	dependencies: dependenciesSchemaOf(profile)
 });
-const contributesSchemaOf = (profile) => object(profile, {
-	exerciseTypes: z.array(z.string()),
-	themes: z.array(z.string()),
-	markdownRenderers: z.array(z.string()),
-	gradePolicies: z.array(z.string()),
-	settings: z.array(z.string()).optional(),
-	events: z.array(z.string()).optional(),
-	commands: z.array(z.string()).optional(),
-	panels: z.array(z.string()).optional(),
-	widgets: z.array(z.string()).optional(),
-	schedules: z.array(z.string()).optional(),
-	importers: z.array(z.string()).optional(),
-	exporters: z.array(z.string()).optional()
-});
-const titleMap = z.record(extensionId$1, z.string().min(1).max(MAX_TITLE_LENGTH));
-/** Titles of the contributions by point; an unreadable map is dropped by the tolerant reader, the entry stays. */
-const titlesSchemaOf = (profile) => {
-	const schema = object(profile, Object.fromEntries(TITLED_POINTS.map((point) => [point, titleMap.optional()]))).optional();
-	return profile.strict ? schema : schema.catch(void 0).optional();
-};
 const entryHeadOf = (profile) => ({
 	id: extensionId$1,
 	name: z.string().min(1).max(80),
@@ -1701,27 +1343,11 @@ const entryHeadOf = (profile) => ({
 	author: z.string().regex(GITHUB_LOGIN_PATTERN, "must be a GitHub login"),
 	source: httpsUrl,
 	platforms: z.array(z.enum(EXTENSION_PLATFORMS)),
-	contributes: contributesSchemaOf(profile),
-	titles: titlesSchemaOf(profile),
 	deprecated: profile.strict ? strictDeprecated.optional() : tolerantDeprecated
 });
 const entrySchemaOf = (profile) => object(profile, {
 	...entryHeadOf(profile),
 	versions: z.array(versionSchemaOf(profile)).min(1).max(5).superRefine(descendingUnique)
-}).superRefine((entry, ctx) => {
-	if (entry.titles === void 0 || !profile.strict) return;
-	for (const point of TITLED_POINTS) {
-		const known = new Set(entry.contributes[point] ?? []);
-		for (const id of Object.keys(entry.titles[point] ?? {})) if (!known.has(id)) ctx.addIssue({
-			code: "custom",
-			path: [
-				"titles",
-				point,
-				id
-			],
-			message: `title for '${id}', which is not in contributes.${point}`
-		});
-	}
 });
 const indexSchemaOf = (profile) => object(profile, {
 	schemaVersion: z.literal(2),
@@ -1761,1394 +1387,115 @@ const tolerantVersion = versionSchemaOf(TOLERANT_PROFILE);
 const FULL_INDEX_FILE = "index.v2.json";
 
 //#endregion
-//#region packages/extension-host/src/locales.ts
-const errorText$3 = (error) => error instanceof Error ? error.message : String(error);
-const readTable = async (dir, locale) => {
-	const file = path.join(dir, localeFile(locale));
-	const info = await lstat(file).catch((error) => error.code === "ENOENT" ? null : error);
-	if (info === null) return { kind: "absent" };
-	if (info instanceof Error) return {
-		kind: "invalid",
-		reason: errorText$3(info)
-	};
-	if (!info.isFile()) return {
-		kind: "invalid",
-		reason: "is not a regular file"
-	};
-	if (info.size > LOCALE_LIMITS.fileBytes) return {
-		kind: "invalid",
-		reason: `${info.size} bytes exceed the limit of ${LOCALE_LIMITS.fileBytes}`
-	};
-	let text;
+//#region packages/extension-host/src/manifest.ts
+/** Относительный путь внутри каталога расширения: без `..`, `\` и ведущего `/`. */
+const isSafeRelativePath = (value) => value.length > 0 && !value.includes("\\") && !value.startsWith("/") && !value.split("/").includes("..");
+const safePath = (extensions) => z.string().refine(isSafeRelativePath, "must be a safe relative path").refine((value) => extensions.some((ext) => value.endsWith(ext)), `must end with ${extensions.join(" or ")}`);
+const extensionId = z.string().max(64).regex(EXTENSION_ID_PATTERN, "invalid extension id");
+/** Диапазон версий в том же виде, что `versions` отзыва и устаревания в каталоге. */
+const versionRange = z.string().superRefine((value, ctx) => {
 	try {
-		text = await readFile(file, "utf8");
-	} catch (error) {
-		return {
-			kind: "invalid",
-			reason: errorText$3(error)
-		};
-	}
-	const parsed = parseLocaleText(text);
-	return parsed.ok ? {
-		kind: "table",
-		table: { ...parsed.table }
-	} : {
-		kind: "invalid",
-		reason: parsed.issues.join("; ")
-	};
-};
-/**
-* Reads `locales/<language>.json` of an extension. A broken file is ignored with
-* a warning, the extension keeps working; a `%key%` of the manifest that `en`
-* does not translate is a warning too (the window shows the raw `%key%`).
-*/
-const loadLocales = async (dir, manifest) => {
-	const messages = {};
-	const warnings = [];
-	for (const locale of EXTENSION_LOCALES) {
-		const read = await readTable(dir, locale);
-		if (read.kind === "table") messages[locale] = read.table;
-		else if (read.kind === "invalid") warnings.push({
-			code: "locale.invalid-file",
-			data: {
-				file: localeFile(locale),
-				reason: read.reason
-			}
+		parseRange(value);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "range must be space-separated comparators such as '>=1.2.0 <2.0.0'"
 		});
 	}
-	const english = messages["en"];
-	for (const key of placeholderKeys(manifest)) if (english === void 0 || !Object.hasOwn(english, key)) warnings.push({
-		code: "locale.missing-key",
-		data: { key }
+});
+const manifestSchema = z.strictObject({
+	/** Ссылка на JSON Schema для редактора; приложением и инструментами игнорируется. */
+	$schema: z.string().optional(),
+	id: extensionId,
+	version: z.string().refine(isSemver, "version must be semver"),
+	apiVersion: z.literal(1),
+	main: safePath([".mjs"]).nullable().optional(),
+	client: safePath([".mjs"]).nullable().optional(),
+	name: z.string().min(1).max(80).optional(),
+	description: z.string().min(1).max(500).optional(),
+	author: z.string().regex(GITHUB_LOGIN_PATTERN, "must be a GitHub login").optional(),
+	platforms: z.array(z.enum(EXTENSION_PLATFORMS)).optional(),
+	minAppVersion: z.string().refine(isSemver, "minAppVersion must be semver x.y.z").optional(),
+	icon: safePath([".png", ".webp"]).optional(),
+	tags: z.array(z.enum(EXTENSION_TAGS, { error: `tag must be one of: ${EXTENSION_TAGS.join(", ")}` })).max(5, "at most 5 tags").optional(),
+	dependencies: z.array(z.strictObject({
+		id: extensionId,
+		range: versionRange.optional()
+	})).max(16, `at most ${16} dependencies`).optional(),
+	/** Вклады регистрирует код (`server`, `client`): ключ отвергается с подсказкой. */
+	contributes: z.never({ error: "contributions are registered in code (src/index.ts: server, client)" }).optional()
+}).superRefine((manifest, ctx) => {
+	const { platforms = [] } = manifest;
+	platforms.forEach((platform, index) => {
+		if (platforms.indexOf(platform) !== index) ctx.addIssue({
+			code: "custom",
+			path: ["platforms", index],
+			message: `duplicate platform '${platform}'`
+		});
+	});
+	const { tags = [] } = manifest;
+	tags.forEach((tag, index) => {
+		if (tags.indexOf(tag) !== index) ctx.addIssue({
+			code: "custom",
+			path: ["tags", index],
+			message: `duplicate tag '${tag}'`
+		});
+	});
+	const { dependencies = [] } = manifest;
+	dependencies.forEach(({ id }, index) => {
+		if (id === manifest.id) ctx.addIssue({
+			code: "custom",
+			path: [
+				"dependencies",
+				index,
+				"id"
+			],
+			message: "an extension cannot depend on itself"
+		});
+		else if (dependencies.findIndex((item) => item.id === id) !== index) ctx.addIssue({
+			code: "custom",
+			path: [
+				"dependencies",
+				index,
+				"id"
+			],
+			message: `duplicate dependency '${id}'`
+		});
 	});
-	return {
-		messages,
-		warnings
-	};
-};
-
-//#endregion
-//#region packages/keybindings/src/keystroke.ts
-const MAX_CHORD_LENGTH = 2;
-var KeybindingSyntaxError = class extends Error {
-	reason;
-	text;
-	constructor(reason, text) {
-		super(`invalid keybinding "${text}": ${reason}`);
-		this.name = "KeybindingSyntaxError";
-		this.reason = reason;
-		this.text = text;
-	}
-};
-const MODIFIER_ALIASES = {
-	mod: "mod",
-	ctrl: "ctrl",
-	control: "ctrl",
-	alt: "alt",
-	option: "alt",
-	opt: "alt",
-	shift: "shift",
-	meta: "meta",
-	cmd: "meta",
-	command: "meta",
-	win: "meta",
-	super: "meta"
-};
-const NAMED_KEYS = {
-	enter: "enter",
-	return: "enter",
-	escape: "escape",
-	esc: "escape",
-	tab: "tab",
-	space: "space",
-	spacebar: "space",
-	backspace: "backspace",
-	delete: "delete",
-	del: "delete",
-	insert: "insert",
-	ins: "insert",
-	home: "home",
-	end: "end",
-	pageup: "pageup",
-	pgup: "pageup",
-	pagedown: "pagedown",
-	pgdn: "pagedown",
-	arrowup: "arrowup",
-	up: "arrowup",
-	arrowdown: "arrowdown",
-	down: "arrowdown",
-	arrowleft: "arrowleft",
-	left: "arrowleft",
-	arrowright: "arrowright",
-	right: "arrowright",
-	plus: "+"
-};
-const FUNCTION_KEY = /^f([1-9]|1\d|2[0-4])$/;
-const PHYSICAL = /^\[([A-Za-z][A-Za-z0-9]*)\]$/;
-const own = (table, key) => Object.hasOwn(table, key) ? table[key] : void 0;
-const isSingleCharacter = (text) => Array.from(text).length === 1 && !/\s/u.test(text);
-/** Имя клавиши записи в каноническую логическую форму; `null` — неизвестное имя. */
-const normalizeKeyName = (part) => {
-	const lower = part.toLowerCase();
-	const named = own(NAMED_KEYS, lower);
-	if (named !== void 0) return named;
-	if (FUNCTION_KEY.test(lower)) return lower;
-	return isSingleCharacter(part) ? lower : null;
-};
-const stroke = (flags, key, code) => ({
-	ctrl: flags.ctrl,
-	alt: flags.alt,
-	shift: flags.shift,
-	meta: flags.meta,
-	key,
-	code
 });
-/** `Mod++` — клавиша `+`; `Mod+K` — модификаторы и клавиша. */
-const splitStroke = (text) => {
-	if (text === "+") return {
-		modifiers: [],
-		key: "+"
-	};
-	const plus = text.endsWith("++");
-	const index = plus ? text.length - 2 : text.lastIndexOf("+");
-	if (index < 0) return {
-		modifiers: [],
-		key: text
+/** Применяет умолчания: части, которой нет, соответствует `null`. */
+const normalizeManifest = (input) => ({
+	id: input.id,
+	version: input.version,
+	apiVersion: input.apiVersion,
+	main: input.main ?? null,
+	client: input.client ?? null,
+	name: input.name ?? null,
+	description: input.description ?? null,
+	author: input.author ?? null,
+	platforms: [...input.platforms ?? []],
+	minAppVersion: input.minAppVersion ?? null,
+	tags: [...input.tags ?? []],
+	dependencies: (input.dependencies ?? []).map(({ id, range }) => ({
+		id,
+		range: range ?? null
+	})),
+	icon: input.icon ?? null
+});
+const zodIssues = (error) => error.issues.map((issue) => `${issue.path.join(".") || "/"}: ${issue.message}`);
+/** Разбор манифеста; ошибка — диагностика `manifest-invalid` (текст — `formatDiagnostic`). */
+const parseManifest = (raw) => {
+	const parsed = manifestSchema.safeParse(raw);
+	if (!parsed.success) return {
+		ok: false,
+		diagnostic: {
+			code: "manifest-invalid",
+			data: { issues: zodIssues(parsed.error) }
+		}
 	};
 	return {
-		modifiers: text.slice(0, index).split("+"),
-		key: plus ? "+" : text.slice(index + 1)
-	};
-};
-const parseStroke = (text, platform, whole) => {
-	const { modifiers, key: keyPart } = splitStroke(text);
-	const flags = {
-		ctrl: false,
-		alt: false,
-		shift: false,
-		meta: false
-	};
-	for (const token of modifiers) {
-		if (token === "") throw new KeybindingSyntaxError("empty-part", whole);
-		const name = own(MODIFIER_ALIASES, token.toLowerCase());
-		if (name === void 0) throw new KeybindingSyntaxError("unknown-modifier", whole);
-		const resolved = name === "mod" ? platform === "mac" ? "meta" : "ctrl" : name;
-		if (flags[resolved]) throw new KeybindingSyntaxError("repeated-modifier", whole);
-		flags[resolved] = true;
-	}
-	if (keyPart === "" || Object.hasOwn(MODIFIER_ALIASES, keyPart.toLowerCase())) throw new KeybindingSyntaxError("modifier-only", whole);
-	const physical = PHYSICAL.exec(keyPart);
-	if (physical) return stroke(flags, "", physical[1]);
-	if (keyPart.length > 1 && (keyPart.startsWith("[") || keyPart.endsWith("]"))) throw new KeybindingSyntaxError("invalid-code", whole);
-	const key = normalizeKeyName(keyPart);
-	if (key === null) throw new KeybindingSyntaxError("unknown-key", whole);
-	return stroke(flags, key, "");
-};
-/**
-* `Mod+Shift+L` или `Mod+K Mod+S` → сочетание для платформы. `Mod` — Meta на
-* macOS и Ctrl на остальных; остальные модификаторы — по имени. Ошибка
-* записи — `KeybindingSyntaxError` с причиной.
-*/
-const parseChord = (text, platform) => {
-	const trimmed = text.trim();
-	if (trimmed === "") throw new KeybindingSyntaxError("empty", text);
-	const parts = trimmed.split(/\s+/);
-	if (parts.length > 2) throw new KeybindingSyntaxError("too-long", text);
-	return parts.map((part) => parseStroke(part, platform, text));
-};
-/**
-* Первое нажатие печатает или правит текст (`K`, `Shift+K`, `,`, `Enter`,
-* стрелки): без Ctrl и Meta такое сочетание срабатывало бы при наборе. Не
-* считаются `Escape` и F1–F24.
-*/
-const isTypingChord = (chord) => {
-	const first = chord[0];
-	if (first === void 0 || first.ctrl || first.meta) return false;
-	if (first.code !== "") return true;
-	return first.key !== "escape" && !FUNCTION_KEY.test(first.key);
-};
-
-//#endregion
-//#region packages/keybindings/src/when.ts
-const WHEN_MAX_LENGTH = 256;
-const MAX_DEPTH = 16;
-const MAX_TERMS = 64;
-var WhenSyntaxError = class extends Error {
-	reason;
-	/** Позиция ошибки в тексте (индекс символа). */
-	position;
-	constructor(reason, position) {
-		super(`invalid when clause: ${reason} at ${position}`);
-		this.name = "WhenSyntaxError";
-		this.reason = reason;
-		this.position = position;
-	}
-};
-const IDENT = /[A-Za-z_][A-Za-z0-9_.-]*/y;
-const BARE = /[^\s&|()!='"]+/y;
-const matchAt = (pattern, text, index) => {
-	pattern.lastIndex = index;
-	return pattern.exec(text)?.[0] ?? null;
-};
-/** После `==`/`!=` значение — слово или строка в одинарных кавычках. */
-const tokenize = (text) => {
-	const tokens = [];
-	let index = 0;
-	let expectValue = false;
-	while (index < text.length) {
-		const char = text[index];
-		if (/\s/.test(char)) {
-			index++;
-			continue;
-		}
-		const two = text.slice(index, index + 2);
-		if (two === "&&" || two === "||" || two === "==" || two === "!=") {
-			tokens.push({
-				kind: "op",
-				text: two,
-				position: index
-			});
-			expectValue = two === "==" || two === "!=";
-			index += 2;
-			continue;
-		}
-		if (char === "(" || char === ")" || char === "!") {
-			tokens.push({
-				kind: "op",
-				text: char,
-				position: index
-			});
-			expectValue = false;
-			index++;
-			continue;
-		}
-		if (char === "'") {
-			const close = text.indexOf("'", index + 1);
-			if (close < 0) throw new WhenSyntaxError("unterminated-string", index);
-			tokens.push({
-				kind: "value",
-				text: text.slice(index + 1, close),
-				position: index
-			});
-			expectValue = false;
-			index = close + 1;
-			continue;
-		}
-		const word = matchAt(expectValue ? BARE : IDENT, text, index);
-		if (word === null) throw new WhenSyntaxError("unexpected-token", index);
-		tokens.push({
-			kind: expectValue ? "value" : "ident",
-			text: word,
-			position: index
-		});
-		expectValue = false;
-		index += word.length;
-	}
-	tokens.push({
-		kind: "end",
-		text: "",
-		position: text.length
-	});
-	return tokens;
-};
-var Parser = class {
-	index = 0;
-	tokens;
-	constructor(tokens) {
-		this.tokens = tokens;
-	}
-	parse() {
-		const result = this.parseOr(0);
-		if (this.peek().kind !== "end") this.fail();
-		return result;
-	}
-	peek() {
-		return this.tokens[this.index];
-	}
-	isOp(text) {
-		const token = this.peek();
-		return token.kind === "op" && token.text === text;
-	}
-	fail() {
-		const token = this.peek();
-		throw new WhenSyntaxError(token.kind === "end" ? "unexpected-end" : "unexpected-token", token.position);
-	}
-	parseOr(depth) {
-		if (depth > MAX_DEPTH) throw new WhenSyntaxError("too-deep", this.peek().position);
-		const terms = [this.parseAnd(depth)];
-		while (this.isOp("||")) {
-			this.index++;
-			terms.push(this.parseAnd(depth));
-		}
-		return terms.length === 1 ? terms[0] : {
-			type: "or",
-			terms
-		};
-	}
-	parseAnd(depth) {
-		const terms = [this.parseUnary(depth)];
-		while (this.isOp("&&")) {
-			this.index++;
-			terms.push(this.parseUnary(depth));
-		}
-		return terms.length === 1 ? terms[0] : {
-			type: "and",
-			terms
-		};
-	}
-	parseUnary(depth) {
-		if (this.isOp("!")) {
-			this.index++;
-			if (this.isOp("(")) return {
-				type: "not",
-				expr: this.parseGroup(depth)
-			};
-			const token = this.peek();
-			if (token.kind !== "ident") return this.fail();
-			this.index++;
-			return {
-				type: "not",
-				expr: {
-					type: "key",
-					key: token.text
-				}
-			};
-		}
-		if (this.isOp("(")) return this.parseGroup(depth);
-		const token = this.peek();
-		if (token.kind !== "ident") return this.fail();
-		this.index++;
-		if (this.isOp("==") || this.isOp("!=")) {
-			const operator = this.peek().text;
-			this.index++;
-			const value = this.peek();
-			if (value.kind !== "value") return this.fail();
-			this.index++;
-			return {
-				type: operator === "==" ? "eq" : "neq",
-				key: token.text,
-				value: value.text
-			};
-		}
-		return {
-			type: "key",
-			key: token.text
-		};
-	}
-	parseGroup(depth) {
-		this.index++;
-		const inner = this.parseOr(depth + 1);
-		if (!this.isOp(")")) return this.fail();
-		this.index++;
-		return inner;
-	}
-};
-/** Текст условия → выражение; ошибка — `WhenSyntaxError` с причиной и позицией. */
-const parseWhen = (text) => {
-	if (text.length > 256) throw new WhenSyntaxError("too-long", 0);
-	if (text.trim() === "") throw new WhenSyntaxError("empty", 0);
-	return new Parser(tokenize(text)).parse();
-};
-/** Дизъюнкция конъюнкций литералов; `null` — слишком много термов. */
-const toDnf = (expr, negated) => {
-	switch (expr.type) {
-		case "key": return [[{
-			kind: negated ? "falsy" : "truthy",
-			key: expr.key
-		}]];
-		case "eq":
-		case "neq": return [[{
-			kind: expr.type === "eq" !== negated ? "eq" : "neq",
-			key: expr.key,
-			value: expr.value
-		}]];
-		case "not": return toDnf(expr.expr, !negated);
-		default: {
-			const isConjunction = expr.type === "and" !== negated;
-			let result = isConjunction ? [[]] : [];
-			for (const part of expr.terms) {
-				const dnf = toDnf(part, negated);
-				if (dnf === null || result === null) return null;
-				const current = result;
-				result = isConjunction ? dnf.flatMap((right) => current.map((left) => [...left, ...right])) : [...current, ...dnf];
-				if (result.length > MAX_TERMS) return null;
-			}
-			return result;
-		}
-	}
-};
-/** Значение `value`, при котором `ключ == value` истинно, обязательно истинно или ложно как условие. */
-const forcedTruth = (value) => {
-	if (value === "") return false;
-	if (value === "false" || value === "0") return null;
-	return true;
-};
-const isConsistent = (term) => {
-	const states = /* @__PURE__ */ new Map();
-	for (const literal of term) {
-		let state = states.get(literal.key);
-		if (state === void 0) {
-			state = {
-				truthy: null,
-				eq: null,
-				neq: /* @__PURE__ */ new Set()
-			};
-			states.set(literal.key, state);
-		}
-		if (literal.kind === "truthy" || literal.kind === "falsy") {
-			const wanted = literal.kind === "truthy";
-			if (state.truthy !== null && state.truthy !== wanted) return false;
-			state.truthy = wanted;
-		} else if (literal.kind === "eq") {
-			if (state.eq !== null && state.eq !== literal.value) return false;
-			state.eq = literal.value;
-		} else state.neq.add(literal.value);
-	}
-	for (const state of states.values()) {
-		if (state.eq === null) continue;
-		if (state.neq.has(state.eq)) return false;
-		const forced = forcedTruth(state.eq);
-		if (forced !== null && state.truthy !== null && state.truthy !== forced) return false;
-	}
-	return true;
-};
-/**
-* Могут ли оба условия быть истинными одновременно. `null` — нет условия.
-* Сверх 64 термов в нормальной форме ответ «да» (лучше лишнее предупреждение,
-* чем молчание).
-*/
-const whenOverlaps = (left, right) => {
-	if (left === null || right === null) return true;
-	const leftDnf = toDnf(left, false);
-	const rightDnf = toDnf(right, false);
-	if (leftDnf === null || rightDnf === null) return true;
-	return leftDnf.some((a) => rightDnf.some((b) => isConsistent([...a, ...b])));
-};
-
-//#endregion
-//#region packages/keybindings/src/validate.ts
-const KEY_MAX_LENGTH = 64;
-/** Условие «фокус в поле ввода»: привязка с набором, который с ним пересекается, срабатывала бы при наборе. */
-const WHILE_TYPING = {
-	type: "key",
-	key: "inputFocus"
-};
-const TYPING = {
-	field: "when",
-	reason: "typing",
-	detail: "typing"
-};
-/**
-* Проверка привязки: клавиши (на каждой из `platforms`: `Mod` раскрывается по
-* платформе, и запись вроде `Mod+Ctrl+K` верна не везде), условие и правило
-* «сочетание без Ctrl и Meta, которое печатает или правит текст, должно быть
-* неактивно, пока фокус в поле ввода». `null` — привязка верна.
-*/
-const validateBinding = (binding, platforms) => {
-	if (binding.key.length > 64) return {
-		field: "key",
-		reason: "syntax",
-		detail: "too-long-text"
-	};
-	let typing = false;
-	for (const platform of platforms) try {
-		typing ||= isTypingChord(parseChord(binding.key, platform));
-	} catch (error) {
-		if (error instanceof KeybindingSyntaxError) return {
-			field: "key",
-			reason: "syntax",
-			detail: error.reason
-		};
-		throw error;
-	}
-	if (binding.when === null || binding.when.trim() === "") return typing ? TYPING : null;
-	try {
-		const when = parseWhen(binding.when);
-		return typing && whenOverlaps(when, WHILE_TYPING) ? TYPING : null;
-	} catch (error) {
-		if (error instanceof WhenSyntaxError) return {
-			field: "when",
-			reason: "syntax",
-			detail: error.reason,
-			position: error.position
-		};
-		throw error;
-	}
-};
-
-//#endregion
-//#region packages/extension-host/src/points/support.ts
-/** Относительный путь внутри каталога расширения: без `..`, `\` и ведущего `/`. */
-const isSafeRelativePath = (value) => value.length > 0 && !value.includes("\\") && !value.startsWith("/") && !value.split("/").includes("..");
-const safePath = (extensions) => z.string().refine(isSafeRelativePath, "must be a safe relative path").refine((value) => extensions.some((ext) => value.endsWith(ext)), `must end with ${extensions.join(" or ")}`);
-const extensionId = z.string().max(64).regex(EXTENSION_ID_PATTERN, "invalid extension id");
-/** Условие видимости `when` у команды, панели и виджета: длина здесь, разбор и типы — в `whenIssues`. */
-const whenField = z.string().min(1).max(EXTENSION_COMMAND_LIMITS.whenLength);
-/** Ошибки условия `when` записи `contributes.<key>.<index>` (с позицией в тексте условия). */
-const whenIssues = (key, index, when) => {
-	if (when === void 0) return [];
-	try {
-		parseWhen$1(when);
-		return [];
-	} catch (error) {
-		if (!(error instanceof WhenError)) throw error;
-		return [`contributes.${key}.${index}.when: invalid "when" (${error.detail} at ${error.position})`];
-	}
-};
-/** Пути с нарушением правила «`id` равен id расширения или начинается с ним». */
-const idPrefixIssues = (key, ids, owner) => ids.flatMap((id, index) => id === owner || id.startsWith(`${owner}.`) ? [] : [`contributes.${key}.${index}.id: id must be '${owner}' or start with '${owner}.'`]);
-/** Повторы значений в списке `path` (путь до массива, `field` — имя поля записи). */
-const duplicateIssues = (path, field, values) => values.flatMap((value, index) => values.indexOf(value) === index ? [] : [`${path}.${index}.${field}: duplicate ${field} '${value}'`]);
-const isFile$1 = async (file) => (await stat(file).catch(() => null))?.isFile() === true;
-/** Путь внутри каталога расширения; выход за каталог — ошибка. */
-const inside = (dir, relative) => {
-	const resolved = path.resolve(dir, relative);
-	if (!resolved.startsWith(dir + path.sep)) throw new Error(`path '${relative}' escapes the extension directory`);
-	return resolved;
-};
-const rendererUrlOf = (id, renderer) => `dolphy-ext://${id}/${renderer.replace(/^\.\//, "").split("/").map(encodeURIComponent).join("/")}`;
-const defaultNote = (value, fallback) => value === fallback ? " (default)" : "";
-/** Проверяет, что файл модуля существует (если проверка включена), и даёт адрес. */
-const resolveModuleUrl = async (extensionId, dir, file, fallback, verifyFiles, label) => {
-	const absolute = inside(dir, file);
-	if (verifyFiles && !await isFile$1(absolute)) throw new Error(`${label} '${file}'${defaultNote(file, fallback)} is not a file`);
-	return rendererUrlOf(extensionId, file);
-};
-const deepFreeze = (value) => {
-	if (typeof value === "object" && value !== null) {
-		for (const child of Object.values(value)) deepFreeze(child);
-		Object.freeze(value);
-	}
-	return value;
-};
-const compileSchema = (ajv, schema, label) => {
-	try {
-		ajv.compile(schema);
-	} catch (error) {
-		throw new Error(`schema ${label} does not compile: ${error instanceof Error ? error.message : String(error)}`);
-	}
-};
-/** Схема объектом (копия, заморожена) или файлом внутри каталога расширения. */
-const resolveSchema = async (ajv, dir, source, label) => {
-	if (typeof source !== "string") {
-		const schema = deepFreeze(structuredClone(source));
-		compileSchema(ajv, schema, `${label} (inline)`);
-		return schema;
-	}
-	const file = inside(dir, source);
-	let parsed;
-	try {
-		parsed = JSON.parse(await readFile(file, "utf8"));
-	} catch (error) {
-		throw new Error(`schema '${source}' is unreadable: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`schema '${source}' is not an object`);
-	compileSchema(ajv, parsed, `'${source}'`);
-	return parsed;
-};
-
-//#endregion
-//#region packages/extension-host/src/points/commands.ts
-const { commands: MAX_COMMANDS, keybindingsPerCommand: MAX_KEYBINDINGS } = EXTENSION_COMMAND_LIMITS;
-const PLATFORMS = [
-	"mac",
-	"windows",
-	"linux"
-];
-const keyText = z.string().min(1);
-/** Описание проблемы привязки для сообщения манифеста. */
-const problemText = (problem) => {
-	if (problem.reason === "typing") return "a key that types text needs a \"when\" inactive while inputFocus (for example \"!inputFocus\")";
-	if (problem.field === "when") return `invalid "when" (${problem.detail} at ${problem.position})`;
-	return `invalid key (${problem.detail}); it must be valid on mac, windows and linux`;
-};
-/** Проблемы одной строки клавиш: поле `field` записи, `when` — условие записи. */
-const keyIssues = (path, field, key, when, reportWhen) => {
-	const problem = validateBinding({
-		key,
-		when
-	}, PLATFORMS);
-	if (problem === null) return [];
-	if (problem.field === "when" && problem.reason === "syntax" && !reportWhen) return [];
-	return [`${path}.${problem.field === "when" && reportWhen ? "when" : field}: ${problemText(problem)}`];
-};
-const bindingIssues = (entry, index) => {
-	const base = `contributes.commands.${index}`;
-	const { keybinding, keybindings = [] } = entry;
-	const issues = [];
-	const seen = /* @__PURE__ */ new Set();
-	const remember = (path, key, when) => {
-		const id = `${key.trim()}\u0000${when?.trim() ?? ""}`;
-		if (seen.has(id)) issues.push(`${path}: duplicate binding '${key}' in one command`);
-		seen.add(id);
-	};
-	if (keybinding !== void 0) {
-		const path = `${base}.keybinding`;
-		const problem = validateBinding({
-			key: keybinding,
-			when: null
-		}, PLATFORMS);
-		if (problem !== null) issues.push(`${path}: ${problemText(problem)}`);
-		remember(path, keybinding, null);
-	}
-	keybindings.forEach((binding, position) => {
-		const path = `${base}.keybindings.${position}`;
-		const when = binding.when ?? null;
-		issues.push(...keyIssues(path, "key", binding.key, when, true));
-		for (const platform of PLATFORMS) {
-			const override = binding[platform];
-			if (override === void 0) continue;
-			issues.push(...keyIssues(path, platform, override, when, false));
-		}
-		remember(`${path}.key`, binding.key, when);
-	});
-	if ((keybinding !== void 0 || keybindings.length > 0) && entry.palette === false) issues.push(`${base}.palette: keybindings need palette: true`);
-	return issues;
-};
-const commands = {
-	key: "commands",
-	needsMain: true,
-	schema: z.strictObject({
-		id: extensionId,
-		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength),
-		description: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.descriptionLength).optional(),
-		category: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.categoryLength).optional(),
-		keybinding: z.string().regex(KEYBINDING_PATTERN, "must look like Mod+Shift+L").optional(),
-		keybindings: z.array(z.strictObject({
-			key: keyText,
-			mac: keyText.optional(),
-			windows: keyText.optional(),
-			linux: keyText.optional(),
-			when: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.whenLength).optional()
-		})).max(MAX_KEYBINDINGS).optional(),
-		palette: z.boolean().optional(),
-		when: whenField.optional(),
-		icon: z.enum(EXTENSION_ICONS).optional()
-	}),
-	normalize: (entries) => entries.map((entry) => ({
-		...entry,
-		palette: entry.palette ?? true,
-		icon: entry.icon ?? "puzzle"
-	})),
-	check: (entries, owner) => {
-		const ids = entries.map(({ id }) => id);
-		return [
-			...entries.length > MAX_COMMANDS ? [`contributes.commands: at most ${MAX_COMMANDS} commands allowed`] : [],
-			...idPrefixIssues("commands", ids, owner),
-			...duplicateIssues("contributes.commands", "id", ids),
-			...entries.flatMap(bindingIssues),
-			...entries.flatMap((entry, index) => whenIssues("commands", index, entry.when))
-		];
-	},
-	resolve: async (entries) => entries.map((entry) => ({
-		id: entry.id,
-		title: entry.title,
-		description: entry.description ?? null,
-		category: entry.category ?? null,
-		keybinding: entry.keybinding ?? null,
-		keybindings: (entry.keybindings ?? []).map((binding) => ({
-			key: binding.key,
-			mac: binding.mac ?? null,
-			windows: binding.windows ?? null,
-			linux: binding.linux ?? null,
-			when: binding.when ?? null
-		})),
-		palette: entry.palette,
-		when: entry.when ?? null,
-		icon: entry.icon
-	})),
-	claims: (resolved) => resolved.map((command) => `command:${command.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/exercise-types.ts
-const schemaField = z.union([safePath([".json"]), z.record(z.string(), z.unknown()).refine((value) => Object.keys(value).length > 0, "must not be empty")]);
-const exerciseTypes = {
-	key: "exerciseTypes",
-	needsMain: true,
-	schema: z.strictObject({
-		id: extensionId,
-		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength).optional(),
-		specSchema: schemaField,
-		answerSchema: schemaField,
-		element: z.string().optional(),
-		renderer: safePath([".js", ".mjs"]).optional()
-	}),
-	normalize: (entries) => entries.map((type) => ({
-		id: type.id,
-		...type.title === void 0 ? {} : { title: type.title },
-		specSchema: type.specSchema,
-		answerSchema: type.answerSchema,
-		element: type.element ?? defaultElementName(type.id),
-		renderer: type.renderer ?? "./view.mjs"
-	})),
-	check: (entries, owner) => [...idPrefixIssues("exerciseTypes", entries.map(({ id }) => id), owner), ...entries.flatMap((type, index) => ELEMENT_NAME_PATTERN.test(type.element) ? [] : [`contributes.exerciseTypes.${index}.element: invalid element name '${type.element}'`])],
-	resolve: async (entries, { dir, extensionId: owner, verifyFiles, ajv }) => {
-		const resolved = [];
-		for (const contribution of entries) {
-			const rendererUrl = await resolveModuleUrl(owner, dir, contribution.renderer, DEFAULT_RENDERER, verifyFiles, "renderer");
-			resolved.push({
-				id: contribution.id,
-				title: contribution.title ?? null,
-				specSchema: await resolveSchema(ajv, dir, contribution.specSchema, `specSchema of '${contribution.id}'`),
-				answerSchema: await resolveSchema(ajv, dir, contribution.answerSchema, `answerSchema of '${contribution.id}'`),
-				element: contribution.element,
-				rendererUrl
-			});
-		}
-		return resolved;
-	},
-	claims: (resolved) => resolved.flatMap((type) => [`exerciseType:${type.id}`, `element:${type.element}`])
-};
-
-//#endregion
-//#region packages/extension-host/src/points/events.ts
-const events = {
-	key: "events",
-	needsMain: true,
-	schema: z.strictObject({ event: z.enum(LEARNING_EVENT_NAMES) }),
-	normalize: (entries) => entries,
-	check: (entries) => duplicateIssues("contributes.events", "event", entries.map(({ event }) => event)),
-	resolve: async (entries) => entries.map(({ event }) => ({ event })),
-	claims: () => []
-};
-
-//#endregion
-//#region packages/extension-host/src/points/exporters.ts
-const { exporters: MAX_EXPORTERS } = EXTENSION_TRANSFER_LIMITS;
-const exporters = {
-	key: "exporters",
-	needsMain: true,
-	schema: z.strictObject({
-		id: extensionId,
-		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength),
-		scope: z.enum(["course", "progress"])
-	}),
-	normalize: (entries) => entries.map((entry) => ({ ...entry })),
-	check: (entries, owner) => {
-		const ids = entries.map(({ id }) => id);
-		return [
-			...entries.length > MAX_EXPORTERS ? [`contributes.exporters: at most ${MAX_EXPORTERS} exporters allowed`] : [],
-			...idPrefixIssues("exporters", ids, owner),
-			...duplicateIssues("contributes.exporters", "id", ids)
-		];
-	},
-	resolve: async (entries) => entries.map((entry) => ({
-		id: entry.id,
-		title: entry.title,
-		scope: entry.scope
-	})),
-	claims: (resolved) => resolved.map((exporter) => `exporter:${exporter.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/grade-policies.ts
-const BUILTIN_POLICY_ID = "passAtN";
-const gradePolicies = {
-	key: "gradePolicies",
-	needsMain: true,
-	schema: z.strictObject({
-		id: extensionId.refine((id) => id !== BUILTIN_POLICY_ID, `id '${BUILTIN_POLICY_ID}' is reserved for the built-in policy`),
-		label: z.string().min(1).max(60)
-	}),
-	normalize: (entries) => entries,
-	check: (entries, owner) => idPrefixIssues("gradePolicies", entries.map(({ id }) => id), owner),
-	resolve: async (entries) => entries.map(({ id, label }) => ({
-		id,
-		label
-	})),
-	claims: (resolved) => resolved.map((policy) => `gradePolicy:${policy.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/importers.ts
-const { importers: MAX_IMPORTERS, acceptExtensions: MAX_ACCEPT } = EXTENSION_TRANSFER_LIMITS;
-const importers = {
-	key: "importers",
-	needsMain: true,
-	schema: z.strictObject({
-		id: extensionId,
-		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength),
-		accept: z.array(z.string().regex(TRANSFER_ACCEPT_PATTERN, "must be a lower-case file extension such as '.csv'")).min(1).max(MAX_ACCEPT),
-		input: z.enum(["text", "bytes"]).optional()
-	}),
-	normalize: (entries) => entries.map((entry) => ({
-		...entry,
-		input: entry.input ?? "text"
-	})),
-	check: (entries, owner) => {
-		const ids = entries.map(({ id }) => id);
-		return [
-			...entries.length > MAX_IMPORTERS ? [`contributes.importers: at most ${MAX_IMPORTERS} importers allowed`] : [],
-			...idPrefixIssues("importers", ids, owner),
-			...duplicateIssues("contributes.importers", "id", ids),
-			...entries.flatMap((entry, index) => entry.accept.flatMap((extension, position) => entry.accept.indexOf(extension) === position ? [] : [`contributes.importers.${index}.accept.${position}: duplicate extension '${extension}'`]))
-		];
-	},
-	resolve: async (entries) => entries.map((entry) => ({
-		id: entry.id,
-		title: entry.title,
-		accept: [...entry.accept],
-		input: entry.input
-	})),
-	claims: (resolved) => resolved.map((importer) => `importer:${importer.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/markdown-renderers.ts
-const markdownRenderers = {
-	key: "markdownRenderers",
-	needsMain: false,
-	schema: z.strictObject({
-		language: z.string().regex(/^[a-z][a-z0-9-]{0,31}$/, "invalid language"),
-		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength).optional(),
-		renderer: safePath([".js", ".mjs"]).optional()
-	}),
-	normalize: (entries) => entries.map((entry) => ({
-		language: entry.language,
-		...entry.title === void 0 ? {} : { title: entry.title },
-		renderer: entry.renderer ?? "./markdown.mjs"
-	})),
-	check: () => [],
-	resolve: async (entries, { dir, extensionId, verifyFiles }) => {
-		const resolved = [];
-		for (const entry of entries) resolved.push({
-			language: entry.language,
-			title: entry.title ?? null,
-			rendererUrl: await resolveModuleUrl(extensionId, dir, entry.renderer, DEFAULT_MARKDOWN_RENDERER, verifyFiles, "markdown renderer")
-		});
-		return resolved;
-	},
-	claims: (resolved) => resolved.map((entry) => `markdown:${entry.language}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/panels.ts
-const { panels: MAX_PANELS } = EXTENSION_COMMAND_LIMITS;
-const panels = {
-	key: "panels",
-	needsMain: false,
-	schema: z.strictObject({
-		id: extensionId,
-		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength),
-		module: safePath([".js", ".mjs"]).optional(),
-		icon: z.enum(EXTENSION_ICONS).optional(),
-		when: whenField.optional()
-	}),
-	normalize: (entries) => entries.map((entry) => ({
-		id: entry.id,
-		title: entry.title,
-		module: entry.module ?? "./panel.mjs",
-		icon: entry.icon ?? "puzzle",
-		...entry.when === void 0 ? {} : { when: entry.when }
-	})),
-	check: (entries, owner) => {
-		const ids = entries.map(({ id }) => id);
-		return [
-			...entries.length > MAX_PANELS ? [`contributes.panels: at most ${MAX_PANELS} panels allowed`] : [],
-			...idPrefixIssues("panels", ids, owner),
-			...duplicateIssues("contributes.panels", "id", ids),
-			...entries.flatMap((entry, index) => whenIssues("panels", index, entry.when))
-		];
-	},
-	resolve: async (entries, { dir, extensionId: owner, verifyFiles }) => {
-		const resolved = [];
-		for (const entry of entries) resolved.push({
-			id: entry.id,
-			title: entry.title,
-			icon: entry.icon,
-			when: entry.when ?? null,
-			rendererUrl: await resolveModuleUrl(owner, dir, entry.module, DEFAULT_PANEL, verifyFiles, "panel module")
-		});
-		return resolved;
-	},
-	claims: (resolved) => resolved.map((panel) => `panel:${panel.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/schedules.ts
-const { schedules: MAX_SCHEDULES } = EXTENSION_SCHEDULE_LIMITS;
-const schedules = {
-	key: "schedules",
-	needsMain: true,
-	schema: z.discriminatedUnion("every", [z.strictObject({
-		id: extensionId,
-		every: z.literal("daily"),
-		at: z.string().regex(SCHEDULE_AT_PATTERN, "must be a time such as '09:00'").optional()
-	}), z.strictObject({
-		id: extensionId,
-		every: z.literal("hourly")
-	})]),
-	normalize: (entries) => entries.map((entry) => entry.every === "daily" ? {
-		id: entry.id,
-		every: "daily",
-		at: entry.at ?? "09:00"
-	} : {
-		id: entry.id,
-		every: "hourly"
-	}),
-	check: (entries, owner) => {
-		const ids = entries.map(({ id }) => id);
-		return [
-			...entries.length > MAX_SCHEDULES ? [`contributes.schedules: at most ${MAX_SCHEDULES} schedules allowed`] : [],
-			...idPrefixIssues("schedules", ids, owner),
-			...duplicateIssues("contributes.schedules", "id", ids)
-		];
-	},
-	resolve: async (entries) => entries.map((entry) => ({
-		id: entry.id,
-		every: entry.every,
-		at: entry.every === "daily" ? entry.at : null
-	})),
-	claims: (resolved) => resolved.map((schedule) => `schedule:${schedule.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/settings.ts
-/** Потолок длины строкового значения: даже в UTF-8 (3 байта на единицу) остаётся в пределах 64 КиБ хранилища. */
-const MAX_STRING_LENGTH = SETTING_LIMITS.stringLength;
-const MAX_OPTIONS = 64;
-const base = {
-	id: extensionId,
-	label: z.string().min(1).max(60),
-	description: z.string().min(1).max(500).optional(),
-	group: z.string().min(1).max(SETTING_LIMITS.groupLength).optional(),
-	order: z.number().int().min(0).max(SETTING_LIMITS.orderMax).optional(),
-	visibleWhen: z.strictObject({
-		setting: extensionId,
-		equals: z.union([
-			z.boolean(),
-			z.string(),
-			z.number()
-		])
-	}).optional()
-};
-const option = z.strictObject({
-	value: z.string().min(1).max(100),
-	label: z.string().min(1).max(60)
-});
-const schema = z.discriminatedUnion("type", [
-	z.strictObject({
-		...base,
-		type: z.literal("boolean"),
-		default: z.boolean()
-	}),
-	z.strictObject({
-		...base,
-		type: z.literal("string"),
-		default: z.string(),
-		maxLength: z.number().int().min(1).max(MAX_STRING_LENGTH).optional()
-	}),
-	z.strictObject({
-		...base,
-		type: z.literal("text"),
-		default: z.string(),
-		maxLength: z.number().int().min(1).max(MAX_STRING_LENGTH).optional()
-	}),
-	z.strictObject({
-		...base,
-		type: z.literal("color"),
-		default: z.string().regex(COLOR_SETTING_PATTERN, "must be #rrggbb")
-	}),
-	z.strictObject({
-		...base,
-		type: z.literal("list"),
-		default: z.array(z.string()),
-		maxItems: z.number().int().min(1).max(SETTING_LIMITS.listItems).optional(),
-		itemMaxLength: z.number().int().min(1).max(SETTING_LIMITS.listItemLength).optional()
-	}),
-	z.strictObject({
-		...base,
-		type: z.literal("number"),
-		default: z.number(),
-		min: z.number().optional(),
-		max: z.number().optional(),
-		integer: z.boolean().optional()
-	}),
-	z.strictObject({
-		...base,
-		type: z.literal("enum"),
-		default: z.string(),
-		options: z.array(option).min(1).max(MAX_OPTIONS)
-	})
-]);
-/** Нарушения `default` и границ одного определения (путь — до поля). */
-const constraintIssues = (setting, at) => {
-	const issue = (field, message) => `${at}.${field}: ${message}`;
-	switch (setting.type) {
-		case "boolean":
-		case "color": return [];
-		case "list": {
-			const maxItems = setting.maxItems ?? SETTING_LIMITS.listItems;
-			const itemMax = setting.itemMaxLength ?? SETTING_LIMITS.listItemLength;
-			return [...setting.default.length > maxItems ? [issue("default", `default has more than ${maxItems} items`)] : [], ...setting.default.some((item) => item.length > itemMax) ? [issue("default", `default has an item longer than ${itemMax} characters`)] : []];
-		}
-		case "text":
-		case "string": {
-			const limit = setting.maxLength ?? MAX_STRING_LENGTH;
-			return setting.default.length > limit ? [issue("default", `default is longer than ${limit} characters`)] : [];
-		}
-		case "number": {
-			const { min, max, integer = false } = setting;
-			const issues = [];
-			if (min !== void 0 && max !== void 0 && min > max) issues.push(issue("min", "min is greater than max"));
-			if (integer && !Number.isInteger(setting.default)) issues.push(issue("default", "default must be an integer"));
-			if (min !== void 0 && setting.default < min) issues.push(issue("default", `default is less than min ${min}`));
-			if (max !== void 0 && setting.default > max) issues.push(issue("default", `default is greater than max ${max}`));
-			return issues;
-		}
-		default: {
-			const values = setting.options.map(({ value }) => value);
-			return [...duplicateIssues(`${at}.options`, "value", values), ...values.includes(setting.default) ? [] : [issue("default", `default '${setting.default}' is not an option`)]];
-		}
-	}
-};
-/** Нарушения `visibleWhen` всех определений: цель есть, это не сама настройка, не `list`, без цепочек, тип `equals` совпадает. */
-const visibleWhenIssues = (entries) => {
-	const byId = new Map(entries.map((entry) => [entry.id, entry]));
-	return entries.flatMap((entry, index) => {
-		const { visibleWhen } = entry;
-		if (visibleWhen === void 0) return [];
-		const at = `contributes.settings.${index}.visibleWhen`;
-		const target = byId.get(visibleWhen.setting);
-		if (target === void 0) return [`${at}.setting: unknown setting '${visibleWhen.setting}'`];
-		if (target.id === entry.id) return [`${at}.setting: a setting cannot depend on itself`];
-		if (target.type === "list") return [`${at}.setting: '${target.id}' is a list and cannot be a condition`];
-		if (target.visibleWhen !== void 0) return [`${at}.setting: '${target.id}' has its own visibleWhen; chains and cycles are not allowed`];
-		const expected = target.type === "boolean" || target.type === "number" ? target.type : "string";
-		return typeof visibleWhen.equals === expected ? [] : [`${at}.equals: must be a ${expected} to match '${target.id}'`];
-	});
-};
-const resolveSetting = (setting) => {
-	const common = {
-		id: setting.id,
-		label: setting.label,
-		description: setting.description ?? null,
-		group: setting.group ?? null,
-		order: setting.order ?? 0,
-		visibleWhen: setting.visibleWhen === void 0 ? null : { ...setting.visibleWhen }
-	};
-	switch (setting.type) {
-		case "boolean": return {
-			...common,
-			type: "boolean",
-			default: setting.default
-		};
-		case "color": return {
-			...common,
-			type: "color",
-			default: setting.default.toLowerCase()
-		};
-		case "text": return {
-			...common,
-			type: "text",
-			default: setting.default,
-			maxLength: setting.maxLength ?? null
-		};
-		case "list": return {
-			...common,
-			type: "list",
-			default: [...setting.default],
-			maxItems: setting.maxItems ?? SETTING_LIMITS.listItems,
-			itemMaxLength: setting.itemMaxLength ?? SETTING_LIMITS.listItemLength
-		};
-		case "string": return {
-			...common,
-			type: "string",
-			default: setting.default,
-			maxLength: setting.maxLength ?? null
-		};
-		case "number": return {
-			...common,
-			type: "number",
-			default: setting.default,
-			min: setting.min ?? null,
-			max: setting.max ?? null,
-			integer: setting.integer ?? false
-		};
-		default: return {
-			...common,
-			type: "enum",
-			default: setting.default,
-			options: setting.options.map(({ value, label }) => ({
-				value,
-				label
-			}))
-		};
-	}
-};
-const settings = {
-	key: "settings",
-	needsMain: false,
-	schema,
-	normalize: (entries) => entries,
-	check: (entries, owner) => [
-		...idPrefixIssues("settings", entries.map(({ id }) => id), owner),
-		...duplicateIssues("contributes.settings", "id", entries.map(({ id }) => id)),
-		...entries.flatMap((entry, index) => constraintIssues(entry, `contributes.settings.${index}`)),
-		...visibleWhenIssues(entries)
-	],
-	resolve: async (entries) => entries.map(resolveSetting),
-	claims: (resolved) => resolved.map((setting) => `setting:${setting.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/themes.ts
-const HEX_COLOR = /^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/;
-const hexColor = z.string().regex(HEX_COLOR, "must be #rrggbb or #rrggbbaa");
-const unknownKeys = (record, allowed) => Object.keys(record).filter((key) => !allowed.includes(key));
-const rejectUnknownKeys = (allowed, noun) => (value, ctx) => {
-	const unknown = unknownKeys(value, allowed);
-	if (unknown.length === 0) return;
-	ctx.addIssue({
-		code: "custom",
-		message: `unknown ${noun} keys: ${unknown.join(", ")}`
-	});
-};
-const colors = z.record(z.string(), hexColor).refine((value) => Object.keys(value).length > 0, "must not be empty").superRefine(rejectUnknownKeys(THEME_COLOR_KEYS, "color"));
-const isVariableValid = (key, value) => key === "border-color" ? typeof value === "string" && HEX_COLOR.test(value) : typeof value === "number" && value >= 0 && value <= 1;
-const variables = z.record(z.string(), z.union([z.string(), z.number()])).superRefine(rejectUnknownKeys(THEME_VARIABLE_KEYS, "variable")).refine((value) => Object.entries(value).every(([key, item]) => isVariableValid(key, item)), "border-color must be a hex color, other variables numbers in [0, 1]");
-const themes = {
-	key: "themes",
-	needsMain: false,
-	schema: z.strictObject({
-		id: extensionId.refine((id) => !BUILTIN_THEME_IDS.includes(id), "id is reserved for a built-in theme"),
-		label: z.string().min(1).max(60),
-		dark: z.boolean(),
-		colors,
-		variables: variables.optional()
-	}),
-	normalize: (entries) => entries,
-	check: (entries, owner) => idPrefixIssues("themes", entries.map(({ id }) => id), owner),
-	resolve: async (entries) => entries.map((theme) => ({
-		id: theme.id,
-		label: theme.label,
-		dark: theme.dark,
-		colors: { ...theme.colors },
-		variables: { ...theme.variables }
-	})),
-	claims: (resolved) => resolved.map((theme) => `theme:${theme.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/widgets.ts
-const { widgets: MAX_WIDGETS, minHeight: MIN_HEIGHT, maxHeight: MAX_HEIGHT } = EXTENSION_WIDGET_LIMITS;
-const height = z.number().int().min(MIN_HEIGHT).max(MAX_HEIGHT);
-const widgets = {
-	key: "widgets",
-	needsMain: false,
-	schema: z.strictObject({
-		id: extensionId,
-		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength),
-		slot: z.enum(EXTENSION_WIDGET_SLOTS),
-		minHeight: height.optional(),
-		maxHeight: height.optional(),
-		module: safePath([".js", ".mjs"]).optional(),
-		when: whenField.optional()
-	}),
-	normalize: (entries) => entries.map((entry) => ({
-		id: entry.id,
-		title: entry.title,
-		slot: entry.slot,
-		minHeight: entry.minHeight ?? MIN_HEIGHT,
-		maxHeight: entry.maxHeight ?? MAX_HEIGHT,
-		module: entry.module ?? "./widget.mjs",
-		...entry.when === void 0 ? {} : { when: entry.when }
-	})),
-	check: (entries, owner) => {
-		const ids = entries.map(({ id }) => id);
-		return [
-			...entries.length > MAX_WIDGETS ? [`contributes.widgets: at most ${MAX_WIDGETS} widgets allowed`] : [],
-			...idPrefixIssues("widgets", ids, owner),
-			...duplicateIssues("contributes.widgets", "id", ids),
-			...entries.flatMap((entry, index) => whenIssues("widgets", index, entry.when)),
-			...entries.flatMap((entry, index) => entry.minHeight > entry.maxHeight ? [`contributes.widgets.${index}.minHeight: minHeight (${entry.minHeight}) must not exceed maxHeight (${entry.maxHeight})`] : [])
-		];
-	},
-	resolve: async (entries, { dir, extensionId: owner, verifyFiles }) => {
-		const resolved = [];
-		for (const entry of entries) resolved.push({
-			id: entry.id,
-			title: entry.title,
-			slot: entry.slot,
-			minHeight: entry.minHeight,
-			maxHeight: entry.maxHeight,
-			when: entry.when ?? null,
-			rendererUrl: await resolveModuleUrl(owner, dir, entry.module, DEFAULT_WIDGET, verifyFiles, "widget module")
-		});
-		return resolved;
-	},
-	claims: (resolved) => resolved.map((widget) => `widget:${widget.id}`)
-};
-
-//#endregion
-//#region packages/extension-host/src/points/index.ts
-/** Реестр точек вклада: порядок значим для диагностики и разбора. */
-const CONTRIBUTION_POINTS = [
-	exerciseTypes,
-	themes,
-	markdownRenderers,
-	gradePolicies,
-	settings,
-	events,
-	commands,
-	panels,
-	widgets,
-	schedules,
-	importers,
-	exporters
-];
-const POINT_KEYS = CONTRIBUTION_POINTS.map(({ key }) => key);
-
-//#endregion
-//#region packages/extension-host/src/manifest.ts
-const contributesSchema = z.strictObject(Object.fromEntries(CONTRIBUTION_POINTS.map((point) => [point.key, z.array(point.schema).optional()])));
-const entriesOf = (contributes, key) => contributes[key] ?? [];
-const isEmpty = (contributes) => CONTRIBUTION_POINTS.every((point) => entriesOf(contributes, point.key).length === 0);
-/** Диапазон версий в том же виде, что `versions` отзыва и устаревания в каталоге. */
-const versionRange = z.string().superRefine((value, ctx) => {
-	try {
-		parseRange(value);
-	} catch {
-		ctx.addIssue({
-			code: "custom",
-			message: "range must be space-separated comparators such as '>=1.2.0 <2.0.0'"
-		});
-	}
-});
-const manifestSchema = z.strictObject({
-	/** Ссылка на JSON Schema для редактора; приложением и инструментами игнорируется. */
-	$schema: z.string().optional(),
-	id: extensionId,
-	version: z.string().refine(isSemver, "version must be semver"),
-	apiVersion: z.literal(1),
-	main: safePath([".mjs"]).optional(),
-	permissions: z.array(z.enum(EXTENSION_PERMISSIONS)).optional(),
-	name: z.string().min(1).max(80).optional(),
-	description: z.string().min(1).max(500).optional(),
-	author: z.string().regex(GITHUB_LOGIN_PATTERN, "must be a GitHub login").optional(),
-	platforms: z.array(z.enum(EXTENSION_PLATFORMS)).optional(),
-	minAppVersion: z.string().refine(isSemver, "minAppVersion must be semver x.y.z").optional(),
-	icon: safePath([".png", ".webp"]).optional(),
-	tags: z.array(z.enum(EXTENSION_TAGS, { error: `tag must be one of: ${EXTENSION_TAGS.join(", ")}` })).max(5, "at most 5 tags").optional(),
-	dependencies: z.array(z.strictObject({
-		id: extensionId,
-		range: versionRange.optional()
-	})).max(16, `at most ${16} dependencies`).optional(),
-	contributes: contributesSchema
-}).superRefine((manifest, ctx) => {
-	const { permissions = [], platforms = [] } = manifest;
-	platforms.forEach((platform, index) => {
-		if (platforms.indexOf(platform) !== index) ctx.addIssue({
-			code: "custom",
-			path: ["platforms", index],
-			message: `duplicate platform '${platform}'`
-		});
-	});
-	permissions.forEach((permission, index) => {
-		if (permissions.indexOf(permission) !== index) ctx.addIssue({
-			code: "custom",
-			path: ["permissions", index],
-			message: `duplicate permission '${permission}'`
-		});
-	});
-	const { tags = [] } = manifest;
-	tags.forEach((tag, index) => {
-		if (tags.indexOf(tag) !== index) ctx.addIssue({
-			code: "custom",
-			path: ["tags", index],
-			message: `duplicate tag '${tag}'`
-		});
-	});
-	const { dependencies = [] } = manifest;
-	dependencies.forEach(({ id }, index) => {
-		if (id === manifest.id) ctx.addIssue({
-			code: "custom",
-			path: [
-				"dependencies",
-				index,
-				"id"
-			],
-			message: "an extension cannot depend on itself"
-		});
-		else if (dependencies.findIndex((item) => item.id === id) !== index) ctx.addIssue({
-			code: "custom",
-			path: [
-				"dependencies",
-				index,
-				"id"
-			],
-			message: `duplicate dependency '${id}'`
-		});
-	});
-	if (entriesOf(manifest.contributes, "events").length > 0 && !permissions.includes("learning.events")) ctx.addIssue({
-		code: "custom",
-		path: ["permissions"],
-		message: "contributes.events requires the 'learning.events' permission"
-	});
-	entriesOf(manifest.contributes, "exporters").forEach((entry, index) => {
-		if (entry.scope === "progress" && !permissions.includes("learning.stats")) ctx.addIssue({
-			code: "custom",
-			path: [
-				"contributes",
-				"exporters",
-				index,
-				"scope"
-			],
-			message: "scope 'progress' requires the 'learning.stats' permission"
-		});
-	});
-	if (isEmpty(manifest.contributes)) ctx.addIssue({
-		code: "custom",
-		path: ["contributes"],
-		message: "at least one contribution is required"
-	});
-});
-/** Код нужен, если есть записи в точке, которая его требует. */
-const needsMain = (contributes) => CONTRIBUTION_POINTS.some((point) => point.needsMain && entriesOf(contributes, point.key).length > 0);
-/** Применяет умолчания: `main`, `renderer`, `element`, пустые точки. */
-const normalizeManifest = (input) => {
-	const contributes = Object.fromEntries(CONTRIBUTION_POINTS.map((point) => [point.key, point.normalize(entriesOf(input.contributes, point.key))]));
-	return {
-		id: input.id,
-		version: input.version,
-		apiVersion: input.apiVersion,
-		main: input.main ?? (needsMain(input.contributes) ? "./main.mjs" : null),
-		permissions: [...input.permissions ?? []],
-		name: input.name ?? null,
-		description: input.description ?? null,
-		author: input.author ?? null,
-		platforms: [...input.platforms ?? []],
-		minAppVersion: input.minAppVersion ?? null,
-		tags: [...input.tags ?? []],
-		dependencies: (input.dependencies ?? []).map(({ id, range }) => ({
-			id,
-			range: range ?? null
-		})),
-		icon: input.icon ?? null,
-		contributes
-	};
-};
-const zodIssues = (error) => error.issues.map((issue) => `${issue.path.join(".") || "/"}: ${issue.message}`);
-/** Сообщения о нарушениях в нормализованном манифесте. */
-const normalizedIssues = (manifest) => CONTRIBUTION_POINTS.flatMap((point) => point.check(manifest.contributes[point.key], manifest.id));
-const invalid = (issues) => ({
-	ok: false,
-	diagnostic: {
-		code: "manifest-invalid",
-		data: { issues }
-	}
-});
-/** Разбор манифеста; ошибка — диагностика `manifest-invalid` (текст — `formatDiagnostic`). */
-const parseManifest = (raw) => {
-	const parsed = manifestSchema.safeParse(raw);
-	if (!parsed.success) return invalid(zodIssues(parsed.error));
-	const manifest = normalizeManifest(parsed.data);
-	const issues = normalizedIssues(manifest);
-	if (issues.length > 0) return invalid(issues);
-	return {
-		ok: true,
-		manifest
+		ok: true,
+		manifest: normalizeManifest(parsed.data)
 	};
 };
 
@@ -3168,11 +1515,19 @@ const compatibilityIssue = (manifest, appVersion, platform) => {
 		data: { platform }
 	};
 };
-const resolveMain = async (dir, main, verifyFiles) => {
-	if (main === null) return null;
-	const mainPath = inside(dir, main);
-	if (verifyFiles && !await isFile$1(mainPath)) throw new Error(`main '${main}'${defaultNote(main, DEFAULT_MAIN)} is not a file`);
-	return mainPath;
+const isFile$2 = async (file) => (await stat(file).catch(() => null))?.isFile() === true;
+/** Путь внутри каталога расширения; выход за каталог — ошибка. */
+const inside = (dir, relative) => {
+	const resolved = path.resolve(dir, relative);
+	if (!resolved.startsWith(dir + path.sep)) throw new Error(`path '${relative}' escapes the extension directory`);
+	return resolved;
+};
+/** Путь собранной части расширения (`main`, `client`) внутри каталога; `null` — части нет. */
+const resolvePart = async (dir, part, file, verifyFiles) => {
+	if (file === null) return null;
+	const target = inside(dir, file);
+	if (verifyFiles && !await isFile$2(target)) throw new Error(`${part} '${file}' is not a file`);
+	return target;
 };
 /**
 * Значок манифеста как `data:`-URI. Читается при обнаружении (≤16 КиБ), снимок
@@ -3188,14 +1543,11 @@ const resolveIcon = async (dir, icon, verifyFiles) => {
 	if (problem !== null) throw new Error(problem);
 	return iconDataUri(icon, bytes);
 };
+/** Полностью разбирает каталог одного расширения; ошибка — диагностика (английский текст — `formatDiagnostic`). */
 const inspectExtensionDir = async (directory, options = {}) => {
 	const { verifyFiles = true, expectedId = null, appVersion, platform = process.platform } = options;
 	const dir = path.resolve(directory);
 	const dirName = expectedId ?? path.basename(dir);
-	const ajv = new Ajv2020({
-		allErrors: true,
-		strict: false
-	});
 	let raw;
 	try {
 		raw = JSON.parse(await readFile(path.join(dir, "extension.json"), "utf8"));
@@ -3234,38 +1586,23 @@ const inspectExtensionDir = async (directory, options = {}) => {
 		diagnostic: incompatible
 	};
 	try {
-		const mainPath = await resolveMain(dir, manifest.main, verifyFiles);
-		const context = {
-			dir,
-			extensionId: manifest.id,
-			verifyFiles,
-			ajv
-		};
-		const resolved = {};
-		for (const point of CONTRIBUTION_POINTS) resolved[point.key] = await point.resolve(manifest.contributes[point.key], context);
-		const locales = verifyFiles ? await loadLocales(dir, manifest) : {
-			messages: {},
-			warnings: []
-		};
 		return {
 			ok: true,
 			extension: {
 				id: manifest.id,
 				version: manifest.version,
 				dir,
-				mainPath,
-				permissions: manifest.permissions,
+				mainPath: await resolvePart(dir, "main", manifest.main, verifyFiles),
+				clientPath: await resolvePart(dir, "client", manifest.client, verifyFiles),
 				name: manifest.name,
 				description: manifest.description,
 				author: manifest.author,
 				platforms: manifest.platforms,
 				minAppVersion: manifest.minAppVersion,
 				icon: await resolveIcon(dir, manifest.icon, verifyFiles),
-				messages: locales.messages,
-				warnings: locales.warnings,
+				warnings: [],
 				tags: manifest.tags,
-				dependencies: manifest.dependencies,
-				...resolved
+				dependencies: manifest.dependencies
 			}
 		};
 	} catch (error) {
@@ -3281,28 +1618,174 @@ const inspectExtensionDir = async (directory, options = {}) => {
 };
 
 //#endregion
-//#region packages/extension-host/src/runtime.ts
-/** Срок обработчика расписания (R12); раннер ограниченного процесса и клиент планировщика ждут дольше. */
-const SCHEDULE_HANDLER_MS = EXTENSION_SCHEDULE_LIMITS.handlerMs;
-/** Срок обработчика команды расширения (R3); раннер ограниченного процесса и клиент движка ждут дольше. */
-const COMMAND_HANDLER_MS = EXTENSION_COMMAND_LIMITS.handlerMs;
-/** Срок обработчика импортёра и экспортёра; раннер ограниченного процесса (32 с) и клиент движка (34 с) ждут дольше. */
-const TRANSFER_HANDLER_MS = EXTENSION_TRANSFER_LIMITS.handlerMs;
+//#region packages/extension-host/src/registrar-support.ts
+/** Идентификатор вклада: форма проверяется схемой, принадлежность расширению — `checkOwnId`. */
+const idField = z.string().max(64).regex(EXTENSION_ID_PATTERN, "invalid id");
+/** Подпись: строка или `{ en, ru? }`; каждый текст 1..`max` символов. */
+const localizedField = (max) => {
+	const text = z.string().min(1).max(max);
+	return z.union([text, z.strictObject({
+		en: text,
+		ru: text.optional()
+	})]).transform((value) => {
+		if (typeof value === "string") return value;
+		return value.ru === void 0 ? { en: value.en } : {
+			en: value.en,
+			ru: value.ru
+		};
+	});
+};
+/** Условие видимости: длина здесь, разбор — `whenProblem`. */
+const whenField = z.string().min(1).max(EXTENSION_COMMAND_LIMITS.whenLength);
+/** Значение — функция (схема не копирует её, только проверяет тип). */
+const functionField = z.custom((value) => typeof value === "function", "must be a function");
 
 //#endregion
-//#region packages/extension-host/src/transfer-wire.ts
-/** Самое большое тело каталога файлов: содержимое, пути и длины в кадрах. */
-const MAX_FILES_FRAME_BYTES = EXTENSION_TRANSFER_LIMITS.totalBytes + EXTENSION_TRANSFER_LIMITS.files * (8 + EXTENSION_TRANSFER_LIMITS.pathBytes);
-const encoder = new TextEncoder();
-const decoder = new TextDecoder("utf-8", {
-	fatal: true,
-	ignoreBOM: true
+//#region packages/extension-host/src/registrar-commands.ts
+const keyText = z.string().min(1);
+const schema = z.strictObject({
+	id: idField,
+	title: localizedField(EXTENSION_COMMAND_LIMITS.titleLength),
+	description: localizedField(EXTENSION_COMMAND_LIMITS.descriptionLength).optional(),
+	category: localizedField(EXTENSION_COMMAND_LIMITS.categoryLength).optional(),
+	keybindings: z.array(z.strictObject({
+		key: keyText,
+		mac: keyText.optional(),
+		windows: keyText.optional(),
+		linux: keyText.optional(),
+		when: whenField.optional()
+	})).max(EXTENSION_COMMAND_LIMITS.keybindingsPerCommand).optional(),
+	palette: z.boolean().optional(),
+	when: whenField.optional(),
+	icon: z.enum(EXTENSION_ICONS).optional(),
+	run: functionField
 });
 
 //#endregion
-//#region packages/extension-host/src/restricted-runner.ts
-/** Раннер ждёт обработчик импорта или экспорта дольше его срока (30 с), но короче клиента движка (34 с). */
-const TRANSFER_DEADLINE_MS = EXTENSION_TRANSFER_LIMITS.handlerMs + 2e3;
+//#region packages/extension-host/src/registrar-settings.ts
+const base = {
+	id: idField,
+	label: localizedField(SETTING_LIMITS.labelLength),
+	description: localizedField(SETTING_LIMITS.descriptionLength).optional(),
+	group: localizedField(SETTING_LIMITS.groupLength).optional(),
+	order: z.number().int().min(0).max(SETTING_LIMITS.orderMax).optional(),
+	visibleWhen: z.strictObject({
+		setting: idField,
+		equals: z.union([
+			z.boolean(),
+			z.string(),
+			z.number()
+		])
+	}).optional()
+};
+const option = z.strictObject({
+	value: z.string().min(1).max(SETTING_LIMITS.optionValueLength),
+	label: localizedField(SETTING_LIMITS.labelLength)
+});
+const maxLength = z.number().int().min(1).max(SETTING_LIMITS.stringLength).optional();
+const definitionSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		...base,
+		type: z.literal("boolean"),
+		default: z.boolean()
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("string"),
+		default: z.string(),
+		maxLength
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("text"),
+		default: z.string(),
+		maxLength
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("color"),
+		default: z.string().regex(COLOR_SETTING_PATTERN, "must be #rrggbb")
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("list"),
+		default: z.array(z.string()),
+		maxItems: z.number().int().min(1).max(SETTING_LIMITS.listItems).optional(),
+		itemMaxLength: z.number().int().min(1).max(SETTING_LIMITS.listItemLength).optional()
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("number"),
+		default: z.number().finite(),
+		min: z.number().finite().optional(),
+		max: z.number().finite().optional(),
+		integer: z.boolean().optional()
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("enum"),
+		default: z.string(),
+		options: z.array(option).min(1).max(SETTING_LIMITS.options)
+	})
+]);
+
+//#endregion
+//#region packages/extension-host/src/registrar.ts
+const BUILTIN_POLICY_ID = "passAtN";
+const { titleLength } = EXTENSION_COMMAND_LIMITS;
+const schemaField = z.record(z.string(), z.unknown()).refine((value) => Object.keys(value).length > 0, "must not be empty");
+const exerciseTypeSchema = z.strictObject({
+	id: idField,
+	title: localizedField(titleLength).optional(),
+	specSchema: schemaField,
+	answerSchema: schemaField,
+	project: functionField,
+	grade: functionField,
+	referenceAnswer: functionField.optional()
+});
+const gradePolicySchema = z.strictObject({
+	id: idField.refine((id) => id !== BUILTIN_POLICY_ID, `id '${BUILTIN_POLICY_ID}' is reserved for the built-in policy`),
+	label: localizedField(titleLength),
+	evaluate: functionField
+});
+const scheduleSchema = z.discriminatedUnion("every", [z.strictObject({
+	id: idField,
+	every: z.literal("daily"),
+	at: z.string().regex(SCHEDULE_AT_PATTERN, "must be a time such as '09:00'")
+}), z.strictObject({
+	id: idField,
+	every: z.literal("hourly")
+})]);
+const importerSchema = z.strictObject({
+	id: idField,
+	title: localizedField(titleLength),
+	accept: z.array(z.string().regex(TRANSFER_ACCEPT_PATTERN, "must be a lower-case file extension such as '.csv'")).min(1).max(EXTENSION_TRANSFER_LIMITS.acceptExtensions),
+	input: z.enum(["text", "bytes"]),
+	run: functionField
+});
+const exporterSchema = z.strictObject({
+	id: idField,
+	title: localizedField(titleLength),
+	scope: z.enum(["course", "progress"]),
+	run: functionField
+});
+const schemaLike = z.custom((value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "safeParseAsync") === "function", "must be a zod schema");
+const rpcSchema = z.object({
+	name: z.string().max(EXTENSION_RPC_LIMITS.nameLength).regex(RPC_NAME_PATTERN, "must match RPC_NAME_PATTERN"),
+	input: schemaLike,
+	output: schemaLike
+});
+
+//#endregion
+//#region packages/extension-host/src/runtime.ts
+/** Срок обработчика расписания (R12); клиент планировщика ждёт дольше. */
+const SCHEDULE_HANDLER_MS = EXTENSION_SCHEDULE_LIMITS.handlerMs;
+/** Срок обработчика команды расширения (R3); клиент движка ждёт дольше. */
+const COMMAND_HANDLER_MS = EXTENSION_COMMAND_LIMITS.handlerMs;
+/** Срок обработчика `server.handle`; клиент движка ждёт дольше. */
+const RPC_HANDLER_MS = EXTENSION_RPC_LIMITS.handlerMs;
+/** Срок обработчика импортёра и экспортёра; клиент движка (34 с) ждёт дольше. */
+const TRANSFER_HANDLER_MS = EXTENSION_TRANSFER_LIMITS.handlerMs;
 
 //#endregion
 //#region packages/extension-tools/src/catalog/assets.ts
@@ -3763,128 +2246,21 @@ const assetFindings = async (root, files) => {
 	const findings = [];
 	for (const file of files) {
 		if (hasUppercaseAssetExtension(file)) {
-			findings.push({
-				path: file,
-				message: "the file extension must be lowercase"
-			});
-			continue;
-		}
-		if (assetExtensionOf(file) === null) continue;
-		const message = assetProblem(file, await readFile(path.join(root, file)));
-		if (message !== null) findings.push({
-			path: file,
-			message
-		});
-	}
-	return findings;
-};
-
-//#endregion
-//#region packages/extension-tools/src/locales.ts
-const error$1 = (field, message) => ({
-	severity: "error",
-	field,
-	message
-});
-const warning$1 = (field, message) => ({
-	severity: "warning",
-	field,
-	message
-});
-/** Paths of the manifest strings that are `%key%` placeholders, by key (first use first). */
-const usesOf = (manifest) => {
-	const uses = /* @__PURE__ */ new Map();
-	for (const { path: where, value } of localizableStrings(manifest)) {
-		const key = placeholderKey(value);
-		if (key === null) continue;
-		uses.set(key, [...uses.get(key) ?? [], where]);
-	}
-	return uses;
-};
-const loadTables = async (input, findings) => {
-	const loaded = {};
-	for (const locale of EXTENSION_LOCALES) {
-		const file = localeFile(locale);
-		const text = await input.read(file);
-		if (text === null) {
-			loaded[locale] = { kind: "absent" };
-			continue;
-		}
-		const parsed = parseLocaleText(text);
-		if (parsed.ok) {
-			loaded[locale] = {
-				kind: "table",
-				table: parsed.table
-			};
-			continue;
-		}
-		loaded[locale] = { kind: "invalid" };
-		for (const issue of parsed.issues) findings.push(error$1(file, issue));
-	}
-	return loaded;
-};
-const tablesOf = (loaded) => Object.fromEntries(EXTENSION_LOCALES.flatMap((locale) => {
-	const entry = loaded[locale];
-	return entry.kind === "table" ? [[locale, entry.table]] : [];
-}));
-/** Errors about the text a language produces: the manifest with that text must still be valid. */
-const resultFindings = (manifest, tables, locale, uses) => {
-	const parsed = parseManifest(localizeManifest(manifest, tables, locale));
-	if (parsed.ok) return [];
-	const issues = parsed.diagnostic.data["issues"];
-	if (!Array.isArray(issues)) return [];
-	const keyAt = new Map([...uses].flatMap(([key, paths]) => paths.map((where) => [where, key])));
-	return issues.flatMap((issue) => {
-		const where = [...keyAt.keys()].find((candidate) => issue.startsWith(`${candidate}:`));
-		if (where === void 0) return [];
-		const reason = issue.slice(where.length + 1).trim();
-		return [error$1(where, `the ${locale} text of '%${keyAt.get(where)}%' is not valid for this field: ${reason}`)];
-	});
-};
-/**
-* Checks the translations of an extension: `locales/en.json` is required when
-* the manifest has a `%key%`; every key needs a text in `en`; the text of a
-* language must fit the limit of its field; files must have a valid shape.
-* A key the manifest does not use and an unsupported file are warnings.
-*/
-const localeFindings = async (input) => {
-	const findings = [];
-	const uses = usesOf(input.manifest);
-	const loaded = await loadTables(input, findings);
-	const english = loaded["en"];
-	const englishFile = localeFile("en");
-	if (uses.size > 0 && english.kind === "absent") findings.push(error$1(englishFile, `${englishFile} is required: the manifest uses %key% placeholders`));
-	if (english.kind === "table") {
-		for (const [key, paths] of uses) if (!Object.hasOwn(english.table, key)) findings.push(error$1(paths[0], `'%${key}%' has no text in ${englishFile}`));
-	}
-	const tables = tablesOf(loaded);
-	for (const locale of EXTENSION_LOCALES) {
-		if (loaded[locale].kind !== "table") continue;
-		findings.push(...resultFindings(input.manifest, tables, locale, uses));
-	}
-	for (const locale of EXTENSION_LOCALES) {
-		const entry = loaded[locale];
-		if (entry.kind !== "table") continue;
-		for (const key of Object.keys(entry.table)) if (!uses.has(key)) findings.push(warning$1(localeFile(locale), `key '${key}' is not used by extension.json`));
+			findings.push({
+				path: file,
+				message: "the file extension must be lowercase"
+			});
+			continue;
+		}
+		if (assetExtensionOf(file) === null) continue;
+		const message = assetProblem(file, await readFile(path.join(root, file)));
+		if (message !== null) findings.push({
+			path: file,
+			message
+		});
 	}
-	const supported = new Set(EXTENSION_LOCALES.map(localeFile));
-	for (const file of input.files) if (file.startsWith(`${"locales"}/`) && !supported.has(file)) findings.push(warning$1(file, `${file} is not a translation file (${[...supported].join(", ")}): the app ignores it`));
 	return findings;
 };
-/** Text of a file in `dir`, or `null` when it is not a regular file. */
-const readFileOrNull = async (dir, file) => {
-	const target = path.join(dir, file);
-	return (await stat(target).catch(() => null))?.isFile() === true ? readFile(target, "utf8") : null;
-};
-/** The `en` table of an extension directory; `null` when it is absent or broken. */
-const readEnglishTable = async (dir) => {
-	const text = await readFileOrNull(dir, localeFile("en"));
-	if (text === null) return null;
-	const parsed = parseLocaleText(text);
-	return parsed.ok ? parsed.table : null;
-};
-/** A manifest string in English: the catalog and the checks of publication metadata show this text. */
-const englishText = (value, table) => table === null ? value : resolveText(value, { en: table }, "en");
 
 //#endregion
 //#region packages/extension-tools/src/assets-plugin.ts
@@ -3909,12 +2285,26 @@ const isBig = (file) => {
 		return false;
 	}
 };
+/** A style sheet or a `<style>` block of a component (`X.vue?vue&type=style…`): the module ends up as a string in the bundle. */
+const VUE_STYLE_MODULE = /\.vue\?(?:.*&)?type=style(?:&|$)/;
+const isStyleModule = (id) => STYLE_FILE.test(cleanId(id)) || VUE_STYLE_MODULE.test(id);
+/** `<style src="./x.css">` in the component `importer`: the component plugin resolves the file once as it is, to link it to the component, and then imports it as text. */
+const isStyleSourceOf = (importer, source) => {
+	if (!importer.endsWith(".vue")) return false;
+	try {
+		const escaped = source.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		return new RegExp(`<style\\b[^>]*\\ssrc\\s*=\\s*(["'])${escaped}\\1`).test(readFileSync(importer, "utf8"));
+	} catch {
+		return false;
+	}
+};
 /**
 * Vite in library mode inlines every asset and has no place for a style sheet: the
-* plugin brings the two documented paths. An image or a font is a data URI up to
+* plugin brings the documented paths. An image or a font is a data URI up to
 * `ASSETS_INLINE_LIMIT` and a file in `assets/` above it (an import with `?url` or
-* `new URL('./x.png', import.meta.url)`); a style sheet is imported as a string with
-* `?inline`, a plain `import './x.css'` is an error with the way out in the message.
+* `new URL('./x.png', import.meta.url)`); a style sheet of the author is imported as a
+* string with `?inline`, a plain `import './x.css'` is an error with the way out in the
+* message.
 */
 const assetsPlugin = (state) => ({
 	name: "dolphy-ext:assets",
@@ -3938,13 +2328,13 @@ const assetsPlugin = (state) => ({
 		const file = cleanId(resolved.id);
 		const query = resolved.id.slice(file.length);
 		if (STYLE_FILE.test(file)) {
-			if (TEXT_IMPORT.test(query)) return null;
+			if (TEXT_IMPORT.test(query) || isStyleSourceOf(importer, source)) return null;
 			const message = `'${source}' is imported as a side-effect style sheet, which a bundle cannot carry: import it as text with import css from '${source}?inline' and add it to the page, or ship it as a file in assets/`;
 			state.problem = message;
 			return this.error(message);
 		}
 		if (!ASSET_FILE.test(file) || MARKED.test(query)) return null;
-		if (STYLE_FILE.test(cleanId(importer)) || !isBig(file)) return null;
+		if (isStyleModule(importer) || !isBig(file)) return null;
 		return {
 			...resolved,
 			id: `${resolved.id}${query === "" ? "?" : "&"}no-inline`
@@ -3953,20 +2343,393 @@ const assetsPlugin = (state) => ({
 });
 
 //#endregion
-//#region packages/extension-tools/src/analyze.ts
-/** Named entries of `src/index.ts` from which the browser files are built. */
-const RECORDS = [
-	"views",
-	"panels",
-	"widgets",
-	"markdown"
+//#region packages/extension-tools/src/host-modules.ts
+/**
+* Modules the app gives to the client code of an extension: the extension
+* imports them as usual, the bundle does not contain them, and the window
+* resolves them to its own instances (one Vue, one Vuetify, one theme).
+*/
+const HOST_MODULES = [
+	"vue",
+	"vuetify",
+	"vuetify/components",
+	"vuetify/directives"
+];
+/** Style sheets of the app: the window already has them, the import is dropped. */
+const HOST_STYLES = ["vuetify/styles"];
+/** Name of the host's loader on `globalThis`: `require(name)` returns a promise of the module. */
+const HOST_GLOBAL = "__dolphy";
+/** Modules of the window (`vue`, `vuetify`, `vuetify/…`): the host file is not a place for them, so they are not read. */
+const WINDOW_SPECIFIER = /^(?:vue|vuetify)(?:\/.*)?$/;
+const isHostModule = (specifier) => HOST_MODULES.includes(specifier);
+const isHostStyle = (specifier) => HOST_STYLES.includes(specifier);
+const child$1 = (node, key) => node[key];
+const children$1 = (node, key) => node[key];
+const nameOf$1 = (node) => node["name"] ?? node["value"];
+const newlines = (text) => "\n".repeat(text.split("\n").length - 1);
+/**
+* Replaces the imports of host modules in the generated code of an ES module
+* with reads from the host's loader. A replacement keeps the number of lines
+* of the import it replaces, so source maps stay valid line by line.
+*/
+const rewriteHostImports = (code) => {
+	const ast = parseAst(code, { lang: "js" }).body;
+	const result = new MagicString(code);
+	let index = 0;
+	for (const statement of ast) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const specifier = child$1(statement, "source")["value"];
+		const source = code.slice(statement.start, statement.end);
+		if (isHostStyle(specifier)) {
+			result.overwrite(statement.start, statement.end, newlines(source));
+			continue;
+		}
+		if (!isHostModule(specifier)) continue;
+		const holder = `${HOST_GLOBAL}_${index}`;
+		index += 1;
+		const lines = [`const ${holder} = await globalThis.${HOST_GLOBAL}.require(${JSON.stringify(specifier)});`];
+		const named = [];
+		for (const item of children$1(statement, "specifiers")) {
+			const local = nameOf$1(child$1(item, "local"));
+			if (item.type === "ImportNamespaceSpecifier") lines.push(`const ${local} = ${holder};`);
+			else if (item.type === "ImportDefaultSpecifier") lines.push(`const ${local} = ${holder}.default;`);
+			else {
+				const imported = nameOf$1(child$1(item, "imported"));
+				named.push(imported === local ? local : `${imported}: ${local}`);
+			}
+		}
+		if (named.length > 0) lines.push(`const { ${named.join(", ")} } = ${holder};`);
+		result.overwrite(statement.start, statement.end, lines.join(" ") + newlines(source));
+	}
+	return result.toString();
+};
+/**
+* Build plugin for browser files: marks the host modules external and, in
+* the generated bundle, turns their imports into reads from `globalThis.__dolphy`.
+* The result needs neither an import map nor a CSP change.
+*/
+const hostModulesPlugin = () => ({
+	name: "dolphy-ext:host-modules",
+	enforce: "pre",
+	resolveId(source) {
+		if (isHostModule(source) || isHostStyle(source)) return {
+			id: source,
+			external: true
+		};
+		if (WINDOW_SPECIFIER.test(source)) return this.error(`'${source}' is not a module the app gives to extensions (${HOST_MODULES.join(", ")}): import the components from 'vuetify/components'`);
+		return null;
+	},
+	generateBundle(_options, bundle) {
+		for (const file of Object.values(bundle)) if (file.type === "chunk") file.code = rewriteHostImports(file.code);
+	}
+});
+
+//#endregion
+//#region packages/extension-tools/src/presets/react.ts
+/**
+* React: `.tsx` and `.jsx` with the automatic JSX runtime, compiled by the
+* bundler itself (no `@vitejs/plugin-react`: a bundle needs no Fast Refresh).
+* `react` and `react-dom` are the author's dependencies and go into the bundle:
+* every extension carries its own copy.
+*/
+const reactPreset = {
+	name: "react",
+	extensions: [".tsx", ".jsx"],
+	packages: [
+		"react",
+		"react-dom",
+		"scheduler"
+	],
+	plugins: () => [],
+	options: { oxc: { jsx: {
+		runtime: "automatic",
+		development: false
+	} } }
+};
+
+//#endregion
+//#region packages/extension-tools/src/presets/vue-styles.ts
+const REGISTRY_SPECIFIER = "dolphy-ext:vue-styles";
+const REGISTRY_ID = `\0${REGISTRY_SPECIFIER}`;
+/** `<style>` blocks of components in the request form of `@vitejs/plugin-vue`: `X.vue?vue&type=style&index=0&inline&lang.css` (the file is the `src` of the block for `<style src>`). */
+const VUE_REQUEST = /[?&]vue(?:&|$)/;
+const STYLE_TYPE = /[?&]type=style(?:&|$)/;
+const INLINE = /[?&]inline(?:&|$)/;
+const DEFAULT_EXPORT = /^export default (".*");?\s*$/s;
+/**
+* Module the style blocks report to: puts all of them into one
+* `<style data-dolphy-ext="<id>">` of the page. The first block of a module
+* instance removes the tag an earlier instance of the same extension left
+* (the window imports `client.mjs` again after a reload), so there is one tag
+* per loaded module.
+*/
+const registrySource = (extensionId) => [
+	`const id = ${JSON.stringify(extensionId)};`,
+	"let tag = null;",
+	"export const addStyle = (css) => {",
+	"  if (tag === null) {",
+	"    for (const old of document.head.querySelectorAll('style[data-dolphy-ext]')) {",
+	"      if (old.getAttribute('data-dolphy-ext') === id) old.remove();",
+	"    }",
+	"    tag = document.createElement('style');",
+	"    tag.setAttribute('data-dolphy-ext', id);",
+	"    document.head.append(tag);",
+	"  }",
+	"  tag.append(css);",
+	"};",
+	""
+].join("\n");
+/**
+* Style blocks of single-file components go to the page as text: a bundle has
+* no style file, so every block, `scoped` or not, is a string the module
+* adds to the tag of the extension when it is evaluated.
+*/
+const vueStylesPlugin = (extensionId) => ({
+	name: "dolphy-ext:vue-styles",
+	enforce: "post",
+	resolveId(source) {
+		return source === REGISTRY_SPECIFIER ? REGISTRY_ID : null;
+	},
+	load(id) {
+		return id === REGISTRY_ID ? registrySource(extensionId) : null;
+	},
+	transform(code, id) {
+		if (!VUE_REQUEST.test(id) || !STYLE_TYPE.test(id) || !INLINE.test(id)) return null;
+		const exported = DEFAULT_EXPORT.exec(code)?.[1];
+		if (exported === void 0) return this.error(`'${id.split("?")[0]}': a style block of a component did not become a string`);
+		return {
+			code: `import { addStyle } from ${JSON.stringify(REGISTRY_SPECIFIER)};\nconst css = ${exported};\naddStyle(css);\nexport default css;\n`,
+			map: null
+		};
+	}
+});
+
+//#endregion
+//#region packages/extension-tools/src/presets/vuetify-template.ts
+const COMPONENTS = "vuetify/components";
+const DIRECTIVES = "vuetify/directives";
+/** Exports of `vuetify/directives`: a template names them as `v-ripple`, `v-click-outside`. */
+const DIRECTIVE_EXPORTS = [
+	"ClickOutside",
+	"Intersect",
+	"Mutate",
+	"Resize",
+	"Ripple",
+	"Scroll",
+	"Tooltip",
+	"Touch"
 ];
+const VUE_FILE$1 = /\.vue(?:\?|$)/;
+/** `_resolveComponent("v-btn")`: the call of the template compiler for a tag that is not a binding of `<script setup>`. */
+const RESOLVE_CALL = /\b_resolve(Component|Directive)\(("(?:[^"\\]|\\.)*")\)/g;
+const pascalCase = (name) => name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+/** `v-btn` and `VBtn` → `VBtn`; the other tags are not Vuetify's. */
+const vuetifyComponentOf = (tag) => {
+	if (/^v-[a-z][a-z0-9-]*$/.test(tag)) return pascalCase(tag);
+	return /^V[A-Z][A-Za-z0-9]*$/.test(tag) ? tag : null;
+};
+/** `ripple` and `click-outside` → `Ripple` and `ClickOutside`. */
+const vuetifyDirectiveOf = (name) => {
+	const exported = pascalCase(name);
+	return DIRECTIVE_EXPORTS.includes(exported) ? exported : null;
+};
+/** `import { VBtn as _dolphy_VBtn } from "vuetify/components";` (empty for no names). */
+const importLine = (names, source) => names.size === 0 ? "" : `import { ${[...names].map((name) => `${name} as _dolphy_${name}`).join(", ")} } from ${JSON.stringify(source)};`;
+/**
+* Turns the tags of Vuetify in the templates (`<v-btn>`) into imports from
+* `vuetify/components`, and the directives (`v-ripple`) into imports from
+* `vuetify/directives`. Both are host modules: the window gives its own Vuetify
+* and there is no copy in the bundle. A name the module does not export falls
+* back to Vue's own lookup, which reports the unknown component.
+*/
+const vuetifyTemplatePlugin = () => ({
+	name: "dolphy-ext:vuetify-template",
+	enforce: "post",
+	transform(code, id) {
+		if (!VUE_FILE$1.test(id) || !code.includes("_resolve")) return null;
+		const result = new MagicString(code);
+		const components = /* @__PURE__ */ new Set();
+		const directives = /* @__PURE__ */ new Set();
+		for (const match of code.matchAll(RESOLVE_CALL)) {
+			const [call, kind, literal] = match;
+			if (kind === void 0 || literal === void 0) continue;
+			const name = JSON.parse(literal);
+			const isComponent = kind === "Component";
+			const exported = isComponent ? vuetifyComponentOf(name) : vuetifyDirectiveOf(name);
+			if (exported === null) continue;
+			(isComponent ? components : directives).add(exported);
+			result.overwrite(match.index, match.index + call.length, `(_dolphy_${exported} ?? ${call})`);
+		}
+		const imports = [importLine(components, COMPONENTS), importLine(directives, DIRECTIVES)].filter((line) => line !== "");
+		if (imports.length === 0) return null;
+		result.prepend(`${imports.join(" ")} `);
+		return {
+			code: result.toString(),
+			map: result.generateMap()
+		};
+	}
+});
+
+//#endregion
+//#region packages/extension-tools/src/presets/vue.ts
+/**
+* `@vitejs/plugin-vue` takes "production" from `NODE_ENV` of the process, and a
+* build under `NODE_ENV=test` or `development` would write the development
+* form of the components (`__file` with a path on the build machine, a render
+* function that reads `$setup`). A bundle is always the production form.
+*/
+const alwaysProduction = (plugin) => {
+	const { configResolved } = plugin;
+	if (typeof configResolved !== "function") throw new Error("@vitejs/plugin-vue has no configResolved hook");
+	plugin.configResolved = function resolved(config) {
+		return configResolved.call(this, {
+			...config,
+			isProduction: true
+		});
+	};
+	return plugin;
+};
+/**
+* Vue single-file components (`.vue`): `<script setup lang="ts">`,
+* `<template>` with Vuetify components as `<v-btn>`, `<style>` and
+* `<style scoped>`. Vue and Vuetify are the window's: the bundle imports them
+* from the host, like any other client code.
+*/
+const vuePreset = {
+	name: "vue",
+	extensions: [".vue"],
+	packages: [
+		"vue",
+		"@vue",
+		"vuetify",
+		"@vuetify"
+	],
+	plugins: ({ extensionId }) => [
+		alwaysProduction(vue({ customElement: true })),
+		vuetifyTemplatePlugin(),
+		vueStylesPlugin(extensionId)
+	]
+};
+
+//#endregion
+//#region packages/extension-tools/src/presets/index.ts
+const PRESETS = [vuePreset, reactPreset];
+/** The window is a Vue application, so this preset is always on. */
+const ALWAYS_ON = vuePreset.name;
+const FRAMEWORK_NAMES = PRESETS.map((preset) => preset.name);
+const DEFAULT_FRAMEWORKS = [ALWAYS_ON];
+const isFramework = (name) => FRAMEWORK_NAMES.includes(name);
+/** `frameworks` of the config as it is used: no repeats, the always-on preset first. */
+const normalizeFrameworks = (names) => [.../* @__PURE__ */ new Set([ALWAYS_ON, ...names])];
+const presetsOf = (frameworks) => PRESETS.filter((preset) => frameworks.includes(preset.name));
+/**
+* Modules of the runtime packages of the frameworks in `frameworks`. The server
+* file shares `src/index.ts` with the client file and must not keep what it
+* imports of them (a component defined at the top level of `src/index.ts` is not
+* code of the server), so their top level does not count as code with effects
+* there: tree shaking drops the library together with the component.
+*/
+const frameworkPackagePattern = (frameworks) => new RegExp(`[\\\\/]node_modules[\\\\/](?:${presetsOf(frameworks).flatMap((preset) => preset.packages).join("|")})[\\\\/]`);
+const hasJsx = (node) => {
+	if (typeof node !== "object" || node === null) return false;
+	if (Array.isArray(node)) return node.some(hasJsx);
+	const { type } = node;
+	if (type === "JSXElement" || type === "JSXFragment") return true;
+	return Object.values(node).some(hasJsx);
+};
+const SOURCE_LANG = {
+	".tsx": "tsx",
+	".jsx": "jsx"
+};
+/**
+* A source file of a preset that is not on, with markup in it: without the
+* check the bundler would fail on an import of the runtime of a framework
+* that is not installed, with no word about the config.
+*/
+const disabledPresetGuard = (disabled) => ({
+	name: "dolphy-ext:disabled-presets",
+	enforce: "pre",
+	transform(code, id) {
+		const file = id.split("?")[0] ?? id;
+		const extension = extname(file);
+		const lang = SOURCE_LANG[extension];
+		if (lang === void 0) return null;
+		const owner = disabled.find((preset) => preset.extensions.includes(extension));
+		if (owner === void 0 || !hasJsx(parseAst(code, { lang }).body)) return null;
+		return this.error(`'${file}' contains JSX, which needs the '${owner.name}' framework: add "frameworks": ["${owner.name}"] to dolphy-ext.config.json`);
+	}
+});
+/** Plugins of the client build: those of the presets in `frameworks` and the check for the files of the others. */
+const presetPlugins = async (frameworks, context) => {
+	const enabled = presetsOf(frameworks);
+	const disabled = PRESETS.filter((preset) => !enabled.includes(preset));
+	const groups = await Promise.all(enabled.map((preset) => preset.plugins(context)));
+	return [disabledPresetGuard(disabled), ...groups.flat()];
+};
+/** Vite configuration of the client build with the additions of the presets in `frameworks`. */
+const presetConfig = (frameworks, config) => presetsOf(frameworks).reduce((merged, preset) => preset.options === void 0 ? merged : mergeConfig(merged, preset.options), config);
+
+//#endregion
+//#region packages/extension-tools/src/server-vue.ts
+const VUE_FILE = /\.vue(?:\?|$)/;
+const STUB_PREFIX = "\0dolphy-ext:server-vue:";
+const MARK = "dolphy-ext:server-vue:";
+/** The stub as it stays in the code of a chunk (a comment with the module id may precede it). */
+const STUB_LITERAL = new RegExp(`"${MARK}(?:[^"\\\\]|\\\\.)*"`);
+/**
+* Boundary of a Node bundle: a `.vue` file is a component of the client part.
+* The server file is built without the compiler of components, and
+* `src/index.ts` may import a component for `client`, so the file is replaced
+* by a stub that tree shaking drops with the rest of the client code. A stub
+* that is still in the output means the server code uses the component: that
+* is the error, with the file in the message.
+*/
+const serverVuePlugin = (root, output, state) => ({
+	name: "dolphy-ext:server-vue",
+	enforce: "pre",
+	async resolveId(source, importer, options) {
+		if (!VUE_FILE.test(source)) return null;
+		const resolved = await this.resolve(source, importer, {
+			...options,
+			skipSelf: true
+		});
+		if (resolved === null || resolved.external === true) return null;
+		return {
+			id: `${STUB_PREFIX}${resolved.id}`,
+			moduleSideEffects: false
+		};
+	},
+	load(id) {
+		return id.startsWith(STUB_PREFIX) ? `export default ${JSON.stringify(`${MARK}${id.slice(23)}`)};\n` : null;
+	},
+	generateBundle(_options, bundle) {
+		for (const chunk of Object.values(bundle)) {
+			if (chunk.type !== "chunk") continue;
+			const literal = STUB_LITERAL.exec(chunk.code)?.[0];
+			if (literal === void 0) continue;
+			const file = JSON.parse(literal).slice(22).split("?")[0] ?? "";
+			const message = `${output} uses '${path.relative(root, file)}': a .vue component belongs to the client part, keep it out of the code of 'server'`;
+			state.problem = message;
+			this.error(message);
+		}
+	}
+});
+
+//#endregion
+//#region packages/extension-tools/src/analyze.ts
 const SOURCE_EXTENSIONS = [
 	".ts",
 	".mts",
+	".tsx",
 	".js",
-	".mjs"
+	".mjs",
+	".jsx"
 ];
+const langOf = (file) => {
+	if (/\.tsx$/.test(file)) return "tsx";
+	if (/\.jsx$/.test(file)) return "jsx";
+	return /\.[mc]?ts$/.test(file) ? "ts" : "js";
+};
 const MAX_HOPS = 16;
 const child = (node, key) => node[key];
 const children = (node, key) => node[key];
@@ -3984,7 +2747,7 @@ const unwrap = (node) => {
 };
 /** Name from an identifier or string literal (`{ a: 1 }`, `{ 'a-b': 1 }`, `export { x as 'y' }`). */
 const nameOf = (node) => String(node.type === "Identifier" ? node.name : node.value);
-const isFile = async (file) => (await stat(file).catch(() => null))?.isFile() === true;
+const isFile$1 = async (file) => (await stat(file).catch(() => null))?.isFile() === true;
 /** Relative import → source file; packages and `node:*` are not analyzed. */
 const resolveRelative = async (from, specifier) => {
 	if (!specifier.startsWith(".")) return null;
@@ -3995,28 +2758,13 @@ const resolveRelative = async (from, specifier) => {
 		...SOURCE_EXTENSIONS.map((extension) => `${withoutJs}${extension}`),
 		...SOURCE_EXTENSIONS.map((extension) => path.join(base, `index${extension}`))
 	];
-	for (const candidate of candidates) if (await isFile(candidate)) return candidate;
+	for (const candidate of candidates) if (await isFile$1(candidate)) return candidate;
 	return null;
 };
-const propertyKeys = (literal) => {
-	const keys = [];
-	for (const property of children(literal, "properties")) {
-		if (property.type !== "Property") return { reason: "it uses a spread or a computed entry" };
-		const key = child(property, "key");
-		if (!(property.computed !== true || key.type === "Literal")) return { reason: "it uses a computed key" };
-		keys.push({
-			name: nameOf(key),
-			start: property.start,
-			end: property.end
-		});
-	}
-	return { keys };
-};
 /**
-* Static analysis of `src/index.ts` without executing author code: whether the
-* `host` export exists and which keys the `views`, `panels`, `widgets` and `markdown`
-* entries have. Entries are found through local constants and relative
-* re-exports; keys must be given as an object literal.
+* Static analysis of `src/index.ts` without executing author code: whether it
+* exports `server` and `client`. Exports are found through local constants
+* and relative re-exports.
 */
 const analyzeIndex = async (indexFile) => {
 	const cache = /* @__PURE__ */ new Map();
@@ -4024,7 +2772,7 @@ const analyzeIndex = async (indexFile) => {
 		let parsed = cache.get(file);
 		if (parsed === void 0) {
 			parsed = readFile(file, "utf8").then((source) => {
-				const lang = /\.[mc]?ts$/.test(file) ? "ts" : "js";
+				const lang = langOf(file);
 				return {
 					file,
 					source,
@@ -4125,68 +2873,11 @@ const analyzeIndex = async (indexFile) => {
 			return null;
 		}
 	};
-	const recordOf = async (name) => {
-		const resolved = await walk.export(indexFile, name, 0);
-		if (resolved === null) return { status: "missing" };
-		if (resolved.kind === "opaque") return {
-			status: "opaque",
-			reason: resolved.reason
-		};
-		if (resolved.node.type !== "ObjectExpression") return {
-			status: "opaque",
-			reason: "it is not an object literal"
-		};
-		const found = propertyKeys(resolved.node);
-		if ("reason" in found) return {
-			status: "opaque",
-			reason: found.reason
-		};
-		return {
-			status: "found",
-			site: {
-				file: resolved.parsed.file,
-				source: resolved.parsed.source,
-				start: resolved.node.start,
-				end: resolved.node.end,
-				keys: found.keys
-			}
-		};
-	};
-	const [views, panels, widgets, markdown] = await Promise.all(RECORDS.map(recordOf));
-	const hasHost = await walk.export(indexFile, "host", 0) !== null;
+	const [hasServer, hasClient] = await Promise.all([walk.export(indexFile, "server", 0).then((found) => found !== null), walk.export(indexFile, "client", 0).then((found) => found !== null)]);
 	return {
 		files: [...cache.keys()],
-		hasHost,
-		records: {
-			views,
-			panels,
-			widgets,
-			markdown
-		}
-	};
-};
-/**
-* Source of `site.file` with the entry literal trimmed to `keep`: the code of the
-* discarded keys does not reach the bundle, and neither do their dependencies.
-* The source map describes the edit, so inline maps of watch builds point at the
-* author's lines.
-*/
-const pruneRecords = (source, sites) => {
-	const edit = new MagicString(source);
-	for (const { site, keep } of sites) {
-		let cursor = site.start + 1;
-		let isFirst = true;
-		for (const key of site.keys) {
-			if (!keep.has(key.name)) continue;
-			if (cursor < key.start) edit.overwrite(cursor, key.start, isFirst ? " " : ", ");
-			cursor = key.end;
-			isFirst = false;
-		}
-		if (cursor < site.end - 1) edit.overwrite(cursor, site.end - 1, " ");
-	}
-	return {
-		code: edit.toString(),
-		map: edit.generateMap({ hires: "boundary" })
+		hasServer,
+		hasClient
 	};
 };
 const isRecord$1 = (value) => typeof value === "object" && value !== null;
@@ -4225,110 +2916,26 @@ const stripBareImports = (code, isDropped) => {
 
 //#endregion
 //#region packages/extension-tools/src/shim.ts
-/** SDK subpath with element registration and dispatch; resolved from the author's project. */
-const SDK_RUNTIME = "@dolphy-app/extension-sdk/runtime";
 /** Path of the virtual shim: the build's `lib.entry` and the plugin's `resolveId`; there is no file on disk. */
 const shimEntry = (project, output) => path.join(project.root, "src", `.dolphy-ext-${output.output.replaceAll(/[^\w.-]/g, "-")}.js`);
-const quote = (text) => JSON.stringify(text);
-/** Which `src/index.ts` entries the output file needs: entry name → keys. */
-const wantedRecords = (output) => output.kind === "host" ? {
-	views: [],
-	panels: [],
-	widgets: [],
-	markdown: []
-} : {
-	views: output.views.map((view) => view.id),
-	panels: output.panels,
-	widgets: output.widgets,
-	markdown: output.languages
-};
-/** Exports of `src/index.ts` the file is built from (for messages). */
-const exportsOf = (output) => output.kind === "host" ? ["host"] : RECORDS.filter((name) => wantedRecords(output)[name].length > 0);
+/** Export of `src/index.ts` the output file is built from. */
+const exportOf = (output) => output.kind;
 /**
-* Source of the output file's virtual shim: imports from `src/index.ts` only
-* what is needed and does what the app expects from this file. The
-* `export default` result is the module the app loads (`ExtensionModule`,
-* panel module, renderer module); a file of this kind registers elements.
+* Source of the output file's virtual shim: the file's only export is the
+* entry the app loads (`server` or `client`).
 */
-const shimSource = (output, indexFile) => {
-	if (output.kind === "host") return `export { host as default } from ${quote(indexFile)};\n`;
-	const runtime = [];
-	const body = [];
-	const modules = [];
-	if (output.views.length > 0) {
-		runtime.push("registerAnswerView");
-		for (const view of output.views) body.push(`registerAnswerView(${quote(view.element)}, views[${quote(view.id)}]);`);
-	}
-	const table = (name, keys) => `{ ${keys.map((key) => `${quote(key)}: ${name}[${quote(key)}]`).join(", ")} }`;
-	if (output.panels.length > 0) {
-		runtime.push("dispatchPanels");
-		modules.push(`...dispatchPanels(${table("panels", output.panels)})`);
-	}
-	if (output.widgets.length > 0) {
-		runtime.push("dispatchWidgets");
-		modules.push(`...dispatchWidgets(${table("widgets", output.widgets)})`);
-	}
-	if (output.languages.length > 0) {
-		runtime.push("dispatchMarkdown");
-		modules.push(`...dispatchMarkdown(${table("markdown", output.languages)})`);
-	}
-	const lines = [
-		`import { ${RECORDS.filter((name) => wantedRecords(output)[name].length > 0).join(", ")} } from ${quote(indexFile)};`,
-		`import { ${runtime.join(", ")} } from ${quote(SDK_RUNTIME)};`,
-		...body
-	];
-	if (modules.length > 0) lines.push(`export default { ${modules.join(", ")} };`);
-	return `${lines.join("\n")}\n`;
-};
-/** Mismatches between `src/index.ts` and the manifest; empty — everything agrees. */
-const findMismatches = (project, analysis, indexSource, root) => {
-	const problems = [];
-	if (project.host !== null && !analysis.hasHost) problems.push(`${indexSource} does not export 'host' for ${project.host.output}: add export const host = defineExtension({ … })`);
-	const declared = {
-		views: project.manifest.contributes.exerciseTypes.map((type) => type.id),
-		panels: project.manifest.contributes.panels.map((panel) => panel.id),
-		widgets: project.manifest.contributes.widgets.map((widget) => widget.id),
-		markdown: project.manifest.contributes.markdownRenderers.map((entry) => entry.language)
-	};
-	const what = {
-		views: "exercise type",
-		panels: "panel",
-		widgets: "widget",
-		markdown: "markdown renderer"
-	};
-	const fix = {
-		views: "defineAnswerView(…)",
-		panels: "defineExtensionPanel(…)",
-		widgets: "defineExtensionWidget(…)",
-		markdown: "defineMarkdownRenderer(…)"
-	};
-	for (const name of RECORDS) {
-		const result = analysis.records[name];
-		const ids = declared[name];
-		if (result.status === "opaque") problems.push(`${indexSource}: cannot read the keys of '${name}' (${result.reason}); declare it as an object literal with static keys`);
-		else if (result.status === "missing") {
-			if (ids.length > 0) problems.push(`${indexSource} does not export '${name}', but extension.json declares ${what[name]} ${ids.map((id) => `'${id}'`).join(", ")}: add export const ${name} = { ${quote(ids[0])}: ${fix[name]} }`);
-		} else {
-			const file = path.relative(root, result.site.file).split(path.sep).join("/");
-			const keys = result.site.keys.map((key) => key.name);
-			for (const id of ids) if (!keys.includes(id)) problems.push(`${file}: '${name}' has no entry '${id}', but extension.json declares ${what[name]} '${id}'`);
-			for (const key of keys) if (!ids.includes(key)) problems.push(`${file}: '${name}' has entry '${key}', but extension.json declares no ${what[name]} '${key}'`);
-		}
-	}
-	return problems;
-};
+const shimSource = (output, indexFile) => `export { ${exportOf(output)} } from ${JSON.stringify(indexFile)};\n`;
 const isNodeSpecifier = (specifier, external) => specifier.startsWith("node:") || builtinModules.includes(specifier) || external.some((name) => specifier === name || specifier.startsWith(`${name}/`));
 /**
-* Build plugin for a single output file: the virtual shim, reconciliation of
-* `src/index.ts` with the manifest on every (re)build, pruning of entries not
-* belonging to the file, and protection of browser files from `node:*`.
+* Build plugin for a single output file: the virtual shim, the check that
+* `src/index.ts` still exports what the file is built from, and the boundary
+* rules: the client file takes no Node.js modules, the server file no `vue`
+* or `vuetify`.
 */
 const shimPlugin = ({ project, output, state }) => {
-	const indexSource = project.indexSource;
 	const root = realpathSync(project.root);
-	const indexFile = path.join(root, indexSource);
+	const indexFile = path.join(root, project.indexSource);
 	const shimId = shimEntry(project, output);
-	let sites = [];
 	const fail = (context, message) => {
 		state.problem = message;
 		return context.error(message);
@@ -4338,44 +2945,35 @@ const shimPlugin = ({ project, output, state }) => {
 		enforce: "pre",
 		resolveId(specifier) {
 			if (specifier === shimId) return shimId;
-			if (output.kind === "browser" && isNodeSpecifier(specifier, project.external)) return {
+			if (output.kind === "client" && isNodeSpecifier(specifier, project.external)) return {
 				id: specifier,
 				external: true
 			};
 			return null;
 		},
 		generateBundle(_options, bundle) {
-			if (output.kind !== "browser") return;
 			for (const chunk of Object.values(bundle)) {
 				if (chunk.type !== "chunk") continue;
-				chunk.code = stripBareImports(chunk.code, (specifier) => isNodeSpecifier(specifier, project.external));
-				const leaked = [...importsOf(chunk.code)].find((specifier) => isNodeSpecifier(specifier, project.external));
-				if (leaked !== void 0) fail(this, `${output.output} imports '${leaked}': Node.js modules and the 'external' packages of dolphy-ext.config.json are for the extension host, keep them out of code that views, panels, widgets and markdown renderers use`);
+				if (output.kind === "server") {
+					chunk.code = stripBareImports(chunk.code, (specifier) => WINDOW_SPECIFIER.test(specifier));
+					const leaked = [...importsOf(chunk.code)].find((specifier) => WINDOW_SPECIFIER.test(specifier));
+					if (leaked !== void 0) fail(this, `${output.output} imports '${leaked}': vue and vuetify belong to the client part, keep them out of the code of 'server'`);
+				} else {
+					chunk.code = stripBareImports(chunk.code, (specifier) => isNodeSpecifier(specifier, project.external));
+					const leaked = [...importsOf(chunk.code)].find((specifier) => isNodeSpecifier(specifier, project.external));
+					if (leaked !== void 0) fail(this, `${output.output} imports '${leaked}': Node.js modules and the 'external' packages of dolphy-ext.config.json belong to the server part, keep them out of the code of 'client'`);
+				}
 			}
 		},
 		async buildStart() {
 			this.addWatchFile(indexFile);
-			const analysis = await analyzeIndex(indexFile).catch((error) => fail(this, `${indexSource} cannot be read: ${String(error)}`));
+			const analysis = await analyzeIndex(indexFile).catch((error) => fail(this, `${project.indexSource} cannot be read: ${String(error)}`));
 			for (const file of analysis.files) this.addWatchFile(file);
-			const problems = findMismatches(project, analysis, indexSource, root);
-			if (problems.length > 0) fail(this, problems.join("; "));
-			const wanted = wantedRecords(output);
-			sites = RECORDS.flatMap((name) => {
-				const result = analysis.records[name];
-				return result.status === "found" ? [{
-					site: result.site,
-					keep: new Set(wanted[name])
-				}] : [];
-			});
+			const name = exportOf(output);
+			if (!(output.kind === "server" ? analysis.hasServer : analysis.hasClient)) fail(this, `${project.indexSource} does not export '${name}', but ${output.output} is built from it`);
 		},
 		load(id) {
 			return id === shimId ? shimSource(output, indexFile) : null;
-		},
-		transform(code, id) {
-			const here = sites.filter(({ site }) => site.file === id);
-			const first = here[0];
-			if (first === void 0 || first.site.source !== code) return null;
-			return pruneRecords(code, here);
 		}
 	};
 };
@@ -4386,13 +2984,23 @@ const errorText$2 = (error) => error instanceof Error ? error.message : String(e
 const nodeExternal = (external) => [
 	/^node:/,
 	...builtinModules,
+	WINDOW_SPECIFIER,
 	...external
 ];
+/** Production flags for browser files: the page has no `process`, and Vue and Vuetify come from the app. */
+const BROWSER_DEFINE = {
+	"process.env.NODE_ENV": "\"production\"",
+	"process.env.VITE_LOGGER_ENABLED": "undefined",
+	__VUE_OPTIONS_API__: "false",
+	__VUE_PROD_DEVTOOLS__: "false",
+	__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false"
+};
 const bundleConfig = (project, entry, output, outDir, isNode) => ({
 	root: project.root,
 	configFile: false,
 	publicDir: false,
 	base: "./",
+	define: isNode ? {} : BROWSER_DEFINE,
 	logLevel: "warn",
 	customLogger: {
 		...createLogger("warn"),
@@ -4403,6 +3011,7 @@ const bundleConfig = (project, entry, output, outDir, isNode) => ({
 		outDir,
 		emptyOutDir: false,
 		minify: false,
+		cssMinify: true,
 		copyPublicDir: false,
 		assetsInlineLimit: ASSETS_INLINE_LIMIT,
 		lib: {
@@ -4416,19 +3025,54 @@ const bundleConfig = (project, entry, output, outDir, isNode) => ({
 		}
 	}
 });
-const outputJob = (project, output, outDir) => {
+/** Constants of the extension API are `Object.freeze({…})` calls: without this a browser bundle keeps all of them. */
+const BROWSER_PURE_CALLS = ["Object.freeze"];
+/**
+* Calls of the client part that the server file shares `src/index.ts` with: a
+* call whose result the server does not use is dropped with everything it
+* refers to (a component and the library behind it). The `__NO_SIDE_EFFECTS__`
+* mark of the SDK does not do it for the SDK as published: the bundler keeps
+* the call, and with it React, in `main.mjs`.
+*/
+const SERVER_PURE_CALLS = [
+	"defineComponent",
+	"defineAsyncComponent",
+	"defineClient",
+	"defineMountable",
+	"reactComponent"
+];
+/** `presets`: plugins of the frameworks of the client file (the server file and workers are built without them). */
+const outputJob = (project, output, outDir, presets) => {
 	const state = { problem: null };
-	const config = bundleConfig(project, shimEntry(project, output), output.output, outDir, output.kind === "host");
+	const isBrowser = output.kind === "client";
+	const base = bundleConfig(project, shimEntry(project, output), output.output, outDir, !isBrowser);
+	const config = isBrowser ? presetConfig(project.frameworks, base) : base;
+	const frameworkPackages = frameworkPackagePattern(project.frameworks);
+	config.build = {
+		...config.build,
+		rolldownOptions: {
+			...config.build?.rolldownOptions,
+			treeshake: isBrowser ? { manualPureFunctions: BROWSER_PURE_CALLS } : {
+				moduleSideEffects: (id) => !frameworkPackages.test(id),
+				manualPureFunctions: SERVER_PURE_CALLS
+			}
+		}
+	};
 	return {
 		output: output.output,
-		label: `${output.output} (${exportsOf(output).join(", ")} from ${project.indexSource})`,
+		label: `${output.output} (${exportOf(output)} from ${project.indexSource})`,
 		config: {
 			...config,
-			plugins: [shimPlugin({
-				project,
-				output,
-				state
-			}), assetsPlugin(state)]
+			plugins: [
+				shimPlugin({
+					project,
+					output,
+					state
+				}),
+				...isBrowser ? [hostModulesPlugin()] : [serverVuePlugin(realpathSync(project.root), output.output, state)],
+				...presets,
+				assetsPlugin(state)
+			]
 		},
 		state
 	};
@@ -4440,22 +3084,22 @@ const workerJob = (project, entry, outDir) => {
 		label: `${entry.output} (${entry.source})`,
 		config: {
 			...bundleConfig(project, path.resolve(project.root, entry.source), entry.output, outDir, true),
-			plugins: [assetsPlugin(state)]
+			plugins: [serverVuePlugin(realpathSync(project.root), entry.output, state), assetsPlugin(state)]
 		},
 		state
 	};
 };
-/** Project bundles: the extensions process, browser files, workers. */
-const jobsOf = (project, outDir) => [
-	...project.host === null ? [] : [outputJob(project, project.host, outDir)],
-	...project.browserOutputs.map((output) => outputJob(project, output, outDir)),
+/** Project bundles: the server part, the client part, workers. */
+const jobsOf = async (project, outDir) => [
+	...project.server === null ? [] : [outputJob(project, project.server, outDir, [])],
+	...project.client === null ? [] : [outputJob(project, project.client, outDir, await presetPlugins(project.frameworks, { extensionId: project.manifest.id }))],
 	...project.workerEntries.map((entry) => workerJob(project, entry, outDir))
 ];
 /** Failure cause: a reconciliation or guard error named by the plugin, or the bundler's text. */
 const failureDetail = (job, error) => job.state.problem ?? errorText$2(error);
 /** Builds all bundles (one at a time, no shared chunks) into `outDir`. */
 const bundleAll = async (project, outDir) => {
-	for (const job of jobsOf(project, outDir)) {
+	for (const job of await jobsOf(project, outDir)) {
 		job.state.problem = null;
 		try {
 			await build(job.config);
@@ -4465,78 +3109,6 @@ const bundleAll = async (project, outDir) => {
 	}
 };
 
-//#endregion
-//#region packages/extension-tools/src/ids.ts
-/** Directory of the generated files in a project; never part of `dist-ext` or a catalog source tree. */
-const GENERATED_DIR = ".dolphy";
-/** The declarations file, relative to the project root (posix separators, as in `tsconfig` `include`). */
-const IDS_FILE = `${GENERATED_DIR}/ids.d.ts`;
-const HEADER = "// Generated by `dolphy-ext types` from extension.json. Do not edit: the file is rewritten on every build.";
-/** A single-quoted TypeScript string literal. */
-const literal = (text) => `'${JSON.stringify(text).slice(1, -1).replaceAll("\\\"", "\"").replaceAll("'", "\\'")}'`;
-/** A union of literals; `never` when the manifest declares none. */
-const union = (values) => values.length === 0 ? "never" : values.map(literal).join(" | ");
-const settingType = (setting) => {
-	switch (setting.type) {
-		case "enum": return union(setting.options.map((option) => option.value));
-		case "text":
-		case "color": return "string";
-		case "list": return "string[]";
-		default: return setting.type;
-	}
-};
-const settingsType = (settings) => settings.length === 0 ? "{}" : `{\n${settings.map((setting) => `      ${literal(setting.id)}: ${settingType(setting)};`).join("\n")}\n    }`;
-/**
-* The declarations for a manifest: an augmentation of `ExtensionIds` in
-* `@dolphy-app/extension-sdk`. Pure function of the normalized manifest, so
-* the output is deterministic; a kind with no ids is `never`.
-*/
-const renderIds = ({ contributes }) => {
-	const entries = [
-		["exerciseTypes", union(contributes.exerciseTypes.map(({ id }) => id))],
-		["gradePolicies", union(contributes.gradePolicies.map(({ id }) => id))],
-		["commands", union(contributes.commands.map(({ id }) => id))],
-		["events", union(contributes.events.map(({ event }) => event))],
-		["panels", union(contributes.panels.map(({ id }) => id))],
-		["widgets", union(contributes.widgets.map(({ id }) => id))],
-		["schedules", union(contributes.schedules.map(({ id }) => id))],
-		["importers", union(contributes.importers.map(({ id }) => id))],
-		["exporters", union(contributes.exporters.map(({ id }) => id))],
-		["markdownLanguages", union(contributes.markdownRenderers.map(({ language }) => language))],
-		["settings", settingsType(contributes.settings)]
-	];
-	return [
-		HEADER,
-		"declare module '@dolphy-app/extension-sdk' {",
-		"  interface ExtensionIds {",
-		...entries.map(([name, type]) => `    ${name}: ${type};`),
-		"  }",
-		"}",
-		"",
-		"export {};",
-		""
-	].join("\n");
-};
-/**
-* Writes `.dolphy/ids.d.ts` for the project, from `extension.json` only (no
-* author code is run). A file with identical content is not rewritten, so a
-* watcher on the project does not see a change.
-*/
-const writeIds = async (project) => {
-	const file = path.join(project.root, IDS_FILE);
-	const content = renderIds(project.manifest);
-	if (await readFile(file, "utf8").catch(() => null) === content) return {
-		file,
-		changed: false
-	};
-	await mkdir(path.dirname(file), { recursive: true });
-	await writeFile(file, content);
-	return {
-		file,
-		changed: true
-	};
-};
-
 //#endregion
 //#region packages/extension-tools/src/project.ts
 const MANIFEST_FILE = "extension.json";
@@ -4544,9 +3116,8 @@ const CONFIG_FILE = "dolphy-ext.config.json";
 const DEFAULT_OUT_DIR = "dist-ext";
 const INDEX_SOURCE = "src/index.ts";
 const stripDot = (file) => file.replace(/^\.\//, "");
-const stripExtension = (file) => file.slice(0, file.length - path.posix.extname(file).length);
-const entrySource = (file) => `src/${path.posix.basename(stripExtension(file))}.ts`;
 const errorText$1 = (error) => error instanceof Error ? error.message : String(error);
+const isFile = async (file) => (await stat(file).catch(() => null))?.isFile() === true;
 const isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((item) => typeof item === "string");
 const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
 const readJson = async (file, subject) => {
@@ -4556,11 +3127,19 @@ const readJson = async (file, subject) => {
 		throw new BuildError(`${path.basename(file)} is unreadable: ${errorText$1(error)}`, subject);
 	}
 };
+/** `frameworks` of the config: names of known presets (an error lists the known ones); `vue` is always on. */
+const frameworksOf = (value, root) => {
+	if (!isStringArray(value)) throw new BuildError(`${CONFIG_FILE}: 'frameworks' must be an array of framework names (${FRAMEWORK_NAMES.join(", ")})`, root);
+	const unknown = value.find((name) => !isFramework(name));
+	if (unknown !== void 0) throw new BuildError(`${CONFIG_FILE}: unknown framework '${unknown}' in 'frameworks': the known frameworks are ${FRAMEWORK_NAMES.join(", ")}`, root);
+	return normalizeFrameworks(value);
+};
 const readConfig = async (root) => {
 	const file = path.join(root, CONFIG_FILE);
 	if (!((await stat(file).catch(() => null))?.isFile() === true)) return {
 		nodeEntries: {},
-		external: []
+		external: [],
+		frameworks: normalizeFrameworks(DEFAULT_FRAMEWORKS)
 	};
 	const config = await readJson(file, root);
 	const nodeEntries = config.nodeEntries ?? {};
@@ -4568,54 +3147,16 @@ const readConfig = async (root) => {
 	if (!isStringRecord(nodeEntries) || !isStringArray(external)) throw new BuildError(`${CONFIG_FILE}: 'nodeEntries' must map output files to sources and 'external' must be a string array`, root);
 	return {
 		nodeEntries,
-		external
+		external,
+		frameworks: frameworksOf(config.frameworks ?? DEFAULT_FRAMEWORKS, root)
 	};
 };
-const schemaPathsOf = (manifest) => {
-	const paths = manifest.contributes.exerciseTypes.flatMap((type) => [type.specSchema, type.answerSchema]).filter((schema) => typeof schema === "string").map(stripDot);
-	return [...new Set(paths)];
-};
-/** Workers are built only together with code: without `main` there are none. */
-const workerEntriesOf = (manifest, config) => manifest.main === null ? [] : Object.entries(config.nodeEntries).map(([output, source]) => ({
+/** Workers are built only together with a server part. */
+const workerEntriesOf = (config, hasServer) => hasServer ? Object.entries(config.nodeEntries).map(([output, source]) => ({
 	source,
 	output: stripDot(output)
-}));
-const browserOutputsOf = (manifest) => {
-	const outputs = /* @__PURE__ */ new Map();
-	const outputOf = (file) => {
-		const output = stripDot(file);
-		const existing = outputs.get(output);
-		if (existing !== void 0) return existing;
-		const created = {
-			kind: "browser",
-			output,
-			views: [],
-			panels: [],
-			widgets: [],
-			languages: []
-		};
-		outputs.set(output, created);
-		return created;
-	};
-	const { exerciseTypes, markdownRenderers, panels, widgets } = manifest.contributes;
-	for (const type of exerciseTypes) outputOf(type.renderer).views.push({
-		id: type.id,
-		element: type.element
-	});
-	for (const entry of markdownRenderers) outputOf(entry.renderer).languages.push(entry.language);
-	for (const panel of panels) outputOf(panel.module).panels.push(panel.id);
-	for (const widget of widgets) outputOf(widget.module).widgets.push(widget.id);
-	return [...outputs.values()];
-};
-/**
-* Paths where code lived before the single entry (`src/<file name>.ts`):
-* the build uses them to recognize the old layout and suggest a migration.
-*/
-const legacySources = (project) => {
-	const outputs = [...project.host === null ? [] : [project.host.output], ...project.browserOutputs.map((entry) => entry.output)];
-	return [...new Set(outputs.map(entrySource))];
-};
-/** Reads the source manifest and project config, computes the output files. */
+})) : [];
+/** Reads the source manifest, project config and exports of `src/index.ts`, computes the output files. */
 const loadProject = async (rootDir) => {
 	const root = path.resolve(rootDir);
 	const manifestFile = path.join(root, MANIFEST_FILE);
@@ -4630,22 +3171,38 @@ const loadProject = async (rootDir) => {
 	if (!parsed.ok) throw new BuildError(formatDiagnostic(parsed.diagnostic), root);
 	const { manifest } = parsed;
 	const config = await readConfig(root);
-	const host = manifest.main === null ? null : {
-		kind: "host",
-		output: stripDot(manifest.main)
-	};
-	const browserOutputs = browserOutputsOf(manifest);
+	const indexFile = path.join(root, INDEX_SOURCE);
+	if (!await isFile(indexFile)) throw new BuildError(`'${INDEX_SOURCE}' is not found: an extension is built from one entry file that exports 'server' and/or 'client'`, manifest.id);
+	const analysis = await analyzeIndex(indexFile).catch((error) => {
+		throw new BuildError(`${INDEX_SOURCE} cannot be read: ${errorText$1(error)}`, manifest.id);
+	});
+	if (!analysis.hasServer && !analysis.hasClient) throw new BuildError(`${INDEX_SOURCE} exports neither 'server' nor 'client': export const server = defineServer(…) and/or export const client = defineClient(…)`, manifest.id);
 	return {
 		root,
 		manifest,
 		manifestBytes,
-		indexSource: host !== null || browserOutputs.length > 0 ? INDEX_SOURCE : null,
-		host,
-		browserOutputs,
-		workerEntries: workerEntriesOf(manifest, config),
+		indexSource: INDEX_SOURCE,
+		server: analysis.hasServer ? {
+			kind: "server",
+			output: stripDot(DEFAULT_MAIN)
+		} : null,
+		client: analysis.hasClient ? {
+			kind: "client",
+			output: stripDot(DEFAULT_CLIENT)
+		} : null,
+		workerEntries: workerEntriesOf(config, analysis.hasServer),
 		external: config.external,
-		schemaPaths: schemaPathsOf(manifest)
+		frameworks: config.frameworks
+	};
+};
+/** Bytes of the built `extension.json`: the source manifest with `main` and `client` naming the built files (`null` — no such part). */
+const builtManifestText = (project) => {
+	const built = {
+		...JSON.parse(project.manifestBytes.toString("utf8")),
+		main: project.server === null ? null : `./${project.server.output}`,
+		client: project.client === null ? null : `./${project.client.output}`
 	};
+	return `${JSON.stringify(built, null, 2)}\n`;
 };
 
 //#endregion
@@ -4764,7 +3321,7 @@ const watchAll = async (project, outDir, reporter, isFailFast) => {
 	const failedFirst = /* @__PURE__ */ new Set();
 	try {
 		const firsts = [];
-		for (const job of jobsOf(project, outDir)) {
+		for (const job of await jobsOf(project, outDir)) {
 			const { watcher, first } = await watchJob(job, reporter, isFailFast, failedFirst);
 			watchers.push(watcher);
 			firsts.push(first);
@@ -4782,11 +3339,7 @@ const watchAll = async (project, outDir, reporter, isFailFast) => {
 
 //#endregion
 //#region packages/extension-tools/src/index.ts
-const STATIC_DIRS = [
-	"schema",
-	"assets",
-	"locales"
-];
+const STATIC_DIRS = ["assets"];
 /** Editors write a file in several events: manifest reload waits for quiet. */
 const MANIFEST_SETTLE_MS = 100;
 const isPresent = async (file) => await stat(file).catch(() => null) !== null;
@@ -4794,29 +3347,11 @@ const targetDir = (project, options) => {
 	const base = options.outDir ?? path.join(project.root, "dist-ext");
 	return path.join(path.resolve(base), project.manifest.id);
 };
-const legacyHint = (project) => {
-	const { contributes } = project.manifest;
-	return [
-		"create src/index.ts",
-		...project.host === null ? [] : [`move the default export of the main file into it as export const host = defineExtension({ … })`],
-		...contributes.exerciseTypes.length === 0 ? [] : [`replace defineAnswerElement(tag, mount) with an entry of export const views = { '<exercise type id>': defineAnswerView(mount) } (the tag now comes from extension.json)`],
-		...contributes.panels.length === 0 ? [] : [`move the default export of the panel module into export const panels = { '<panel id>': defineExtensionPanel({ … }) }`],
-		...contributes.markdownRenderers.length === 0 ? [] : [`move the default export of the renderer module into export const markdown = { '<language>': defineMarkdownRenderer(…) }`],
-		"delete the old src files and import from src/index.ts in tests"
-	].map((step, index) => `${index + 1}. ${step}`).join("; ");
-};
 const requireSources = async (project) => {
-	const { indexSource } = project;
-	if (indexSource !== null && !await isPresent(path.join(project.root, indexSource))) {
-		const legacy = legacySources(project);
-		const found = (await Promise.all(legacy.map(async (source) => await isPresent(path.join(project.root, source)) ? source : null))).filter((source) => source !== null);
-		const reason = found.length > 0 ? `found the old layout (${found.join(", ")}), which is no longer supported; migrate: ${legacyHint(project)}` : `add it: ${legacyHint(project)}`;
-		throw new BuildError(`'${indexSource}' is not found: an extension with code is built from one entry file; ${reason}`, project.manifest.id);
-	}
 	for (const entry of project.workerEntries) if (!await isPresent(path.join(project.root, entry.source))) throw new BuildError(`entry source '${entry.source}' for '${entry.output}' is not found`, project.manifest.id);
 };
 const copyStatic = async (project, dir) => {
-	await writeFile(path.join(dir, MANIFEST_FILE), project.manifestBytes);
+	await writeFile(path.join(dir, MANIFEST_FILE), builtManifestText(project));
 	for (const name of STATIC_DIRS) {
 		const from = path.join(project.root, name);
 		if (await isPresent(from)) await cp(from, path.join(dir, name), { recursive: true });
@@ -4828,12 +3363,6 @@ const copyStatic = async (project, dir) => {
 		await mkdir(path.dirname(path.join(dir, icon)), { recursive: true });
 		await cp(from, path.join(dir, icon));
 	}
-	for (const schema of project.schemaPaths) {
-		const from = path.join(project.root, schema);
-		if (!await isPresent(from)) throw new BuildError(`schema '${schema}' referenced by the manifest is not found`, project.manifest.id);
-		await mkdir(path.dirname(path.join(dir, schema)), { recursive: true });
-		await cp(from, path.join(dir, schema));
-	}
 };
 const listFiles = async (dir, prefix = "") => {
 	const entries = await readdir(path.join(dir, prefix), { withFileTypes: true });
@@ -4850,34 +3379,21 @@ const validateExtension = async (dir) => {
 	});
 	if (!result.ok) return {
 		ok: false,
-		problems: [formatDiagnostic(result.diagnostic)],
-		warnings: []
+		problems: [formatDiagnostic(result.diagnostic)]
 	};
 	const files = await listFiles(root);
 	const problems = (await assetFindings(root, files)).map(({ path: file, message }) => `${file}: ${message}`);
-	const locales = await localeFindings({
-		manifest: JSON.parse(await readFileOrNull(root, "extension.json") ?? "null"),
-		files,
-		read: (file) => readFileOrNull(root, file)
-	});
-	const describe = ({ field, message }) => `${field}: ${message}`;
-	problems.push(...locales.filter(({ severity }) => severity === "error").map(describe));
 	return {
 		ok: problems.length === 0,
-		problems,
-		warnings: locales.filter(({ severity }) => severity === "warning").map(describe)
+		problems
 	};
 };
-const assertValid = async (project, dir, logger) => {
-	const { ok, problems, warnings } = await validateExtension(dir);
-	for (const warning of warnings) logger?.info(`warning ${project.manifest.id}: ${warning}`);
+const assertValid = async (project, dir) => {
+	const { ok, problems } = await validateExtension(dir);
 	if (!ok) throw new BuildError(problems.join("; "), project.manifest.id);
 };
-/** Writes `.dolphy/ids.d.ts` for the project in `options.root` from its `extension.json`; `changed` is false when the file was already current. */
-const generateTypes = async (options) => writeIds(await loadProject(options.root));
 const prepare = async (options) => {
 	const project = await loadProject(options.root);
-	await writeIds(project);
 	await requireSources(project);
 	const dir = targetDir(project, options);
 	await rm(dir, {
@@ -4899,7 +3415,7 @@ const buildExtension = async (options) => {
 	const { project, dir } = await prepare(options);
 	await bundleAll(project, dir);
 	await copyStatic(project, dir);
-	await assertValid(project, dir, options.logger);
+	await assertValid(project, dir);
 	return resultOf$1(project, dir);
 };
 const reportTo = (id, logger) => (report) => {
@@ -4917,17 +3433,20 @@ const watchExtension = async (options) => {
 	const { logger } = options;
 	let project = first;
 	let dir = firstDir;
+	let current = null;
 	const reporter = createReporter((report) => reportTo(project.manifest.id, logger)(report));
-	let current = await watchAll(project, dir, reporter, true);
-	try {
-		await copyStatic(project, dir);
-		await assertValid(project, dir, options.logger);
-	} catch (error) {
-		await current.close();
-		reporter.close();
-		throw error;
-	}
-	const result = await resultOf$1(project, dir);
+	const start = async () => {
+		const started = await watchAll(project, dir, reporter, true);
+		current = started;
+		try {
+			await copyStatic(project, dir);
+			await assertValid(project, dir);
+		} catch (error) {
+			await started.close();
+			throw error;
+		}
+		return resultOf$1(project, dir);
+	};
 	const reload = async () => {
 		const previous = project.manifestBytes;
 		let next;
@@ -4945,7 +3464,6 @@ const watchExtension = async (options) => {
 			force: true
 		});
 		try {
-			await writeIds(next);
 			await requireSources(next);
 			project = next;
 			dir = targetDir(project, options);
@@ -4953,7 +3471,7 @@ const watchExtension = async (options) => {
 			current = await watchAll(project, dir, reporter, false);
 			await copyStatic(project, dir);
 			if (current.isHealthy) {
-				await assertValid(project, dir, options.logger);
+				await assertValid(project, dir);
 				logger?.info(`rebuilt ${(await resultOf$1(project, dir)).files.join(", ")}`);
 			}
 		} catch (error) {
@@ -4961,19 +3479,32 @@ const watchExtension = async (options) => {
 		}
 	};
 	let queue = Promise.resolve();
-	let timer = null;
-	const manifestWatcher = watch(project.root, (_event, name) => {
+	let timer;
+	const manifestWatcher = watch(first.root, (_event, name) => {
 		if (name !== "extension.json") return;
-		if (timer !== null) clearTimeout(timer);
+		clearTimeout(timer);
 		timer = setTimeout(() => {
 			queue = queue.then(reload);
 		}, MANIFEST_SETTLE_MS);
 	});
+	const stopWatching = () => {
+		manifestWatcher.close();
+		clearTimeout(timer);
+	};
+	const started = start();
+	queue = started.then(() => void 0, () => void 0);
+	let result;
+	try {
+		result = await started;
+	} catch (error) {
+		stopWatching();
+		reporter.close();
+		throw error;
+	}
 	return {
 		result,
 		close: async () => {
-			manifestWatcher.close();
-			if (timer !== null) clearTimeout(timer);
+			stopWatching();
 			await queue;
 			reporter.close();
 			await current?.close();
@@ -5021,12 +3552,14 @@ const CODE_FILE = /\.(?:mjs|js|cjs)$/;
 const OBFUSCATION_MIN_BYTES = 20480;
 const OBFUSCATION_LINE_LENGTH = 500;
 const OBFUSCATION_IDENTIFIERS = 20;
-const DYNAMIC_EXECUTION = /(?<![\w$])(?:eval\s*\(|new\s+Function\s*\()/;
+/**
+* `eval(…)` and `new Function(…)`, except `new Function("")`: its body is
+* empty, nothing runs. `zod` makes that call to find out whether code
+* generation is allowed, so every bundle that validates with `zod` has it.
+*/
+const DYNAMIC_EXECUTION = /(?<![\w$])(?:eval\s*\(|new\s+Function\s*\((?!\s*(?:""|''|``)\s*\)))/;
 const HEX_IDENTIFIER = /(?<![\w$])_0x[0-9a-f]{3,}(?![\w$])/gi;
-const URL_PATTERN = /https?:\/\/[^\s"'`<>)\\]+/g;
 const SOURCE_MAP = /\/\/[#@]\s*sourceMappingURL=/;
-/** XML namespaces (`createElementNS`) are identifiers, not network addresses. */
-const NAMESPACE_URL = /^https?:\/\/www\.w3\.org\//;
 const listCodeFiles = async (dir, prefix = "") => {
 	const entries = await readdir(path.join(dir, prefix), { withFileTypes: true });
 	return (await Promise.all(entries.map(async (entry) => {
@@ -5050,12 +3583,12 @@ const isObfuscated = (text) => {
 	return identifiers.size >= OBFUSCATION_IDENTIFIERS ? `${identifiers.size} identifiers of the form _0x1a2b` : null;
 };
 /**
-* Heuristics over the built code (`CHECK-022`…`CHECK-025`). They read the
-* whole bundle, dependencies included, so only the source map is an error.
+* Heuristics over the built code (`CHECK-022`, `CHECK-023`, `CHECK-025`). They
+* read the whole bundle, dependencies included, so only the source map is an
+* error.
 */
-const bundleFindings = (files, permissions) => {
+const bundleFindings = (files) => {
 	const findings = [];
-	const mayUseNetwork = permissions.includes("network");
 	for (const { path: field, text } of files) {
 		if (DYNAMIC_EXECUTION.test(text)) findings.push({
 			ruleId: "CHECK-022",
@@ -5070,15 +3603,6 @@ const bundleFindings = (files, permissions) => {
 			field,
 			message: `looks obfuscated: ${obfuscation}`
 		});
-		if (!mayUseNetwork) {
-			const url = (text.match(URL_PATTERN) ?? []).find((item) => !NAMESPACE_URL.test(item));
-			if (url !== void 0) findings.push({
-				ruleId: "CHECK-024",
-				severity: "warning",
-				field,
-				message: `URL ${url} in code without the 'network' permission`
-			});
-		}
 		if (SOURCE_MAP.test(text)) findings.push({
 			ruleId: "CHECK-025",
 			severity: "error",
@@ -5122,7 +3646,7 @@ const manifestFindings = (fields) => {
 		ruleId: "LINT-001",
 		severity: "warning",
 		field: "tags",
-		message: "'tags' is not set: without it the catalog derives tags from contributions"
+		message: "'tags' is not set: the catalog lists the extension without tags"
 	});
 	return findings;
 };
@@ -5366,25 +3890,6 @@ const changelog = {
 		return new RegExp(`^##[ \\t]+\\[?v?${escapeRegExp(manifest.version)}\\]?(?:[ \\t]|$)`, "m").test(text) ? [] : [warning("CHANGELOG.md", `has no '## ${manifest.version}' section for the current version`)];
 	}
 };
-const translations = {
-	id: "CHECK-026",
-	title: "locales/*.json: en is complete, texts fit their fields, files are valid",
-	run: ({ rawManifest, tree, readText }) => rawManifest === null ? [] : localeFindings({
-		manifest: rawManifest,
-		files: tree.files.map((file) => file.path),
-		read: readText
-	})
-};
-const permissionsExplained = {
-	id: "CHECK-020",
-	title: "every permission is mentioned in README.md",
-	run: async (context) => {
-		const { manifest } = context;
-		if (manifest === null || manifest.permissions.length === 0) return [];
-		const readmeText = await context.readText("README.md") ?? "";
-		return manifest.permissions.filter((permission) => !readmeText.includes(permission)).map((permission) => warning("permissions", `permission '${permission}' is not mentioned in README.md: explain why the extension needs it`));
-	}
-};
 const firstPublisherOwnsId = {
 	id: "CHECK-021",
 	title: "the id is not published under another author",
@@ -5403,13 +3908,43 @@ const bundleRule = (id, title, missingBundle = false) => ({
 		if (bundleDir === null || manifest === null) return [];
 		const files = await readBundleFiles(bundleDir).catch(() => null);
 		if (files === null) return missingBundle ? [warning("--built", `${NO_BUNDLE} (${bundleDir})`)] : [];
-		return bundleFindings(files, manifest.permissions).filter((finding) => finding.ruleId === id).map(({ severity, field, message }) => ({
+		return bundleFindings(files).filter((finding) => finding.ruleId === id).map(({ severity, field, message }) => ({
 			severity,
 			field,
 			message
 		}));
 	}
 });
+const BUILT_PARTS = [{
+	field: "main",
+	file: DEFAULT_MAIN
+}, {
+	field: "client",
+	file: DEFAULT_CLIENT
+}];
+/** `CHECK-031`: the built manifest's `main` and `client` name the files that are in the built version, and each file has its field; silent without `--built`. */
+const builtParts = {
+	id: "CHECK-031",
+	title: "main.mjs and client.mjs match the main and client fields",
+	run: async ({ bundleDir }) => {
+		if (bundleDir === null) return [];
+		let built;
+		try {
+			built = JSON.parse(await readFile(path.join(bundleDir, "extension.json"), "utf8"));
+		} catch {
+			return [];
+		}
+		if (!isRecord(built)) return [];
+		const findings = [];
+		for (const { field, file } of BUILT_PARTS) {
+			const declared = built[field];
+			const exists = (await stat(path.join(bundleDir, file)).catch(() => null))?.isFile() === true;
+			if (typeof declared === "string" && !exists) findings.push(error(field, `'${declared}' is not in the built version`));
+			else if (typeof declared !== "string" && exists) findings.push(error(field, `${file} is in the built version, but '${field}' is not set`));
+		}
+		return findings;
+	}
+};
 const RULES = [
 	manifestValid,
 	directoryName,
@@ -5430,13 +3965,11 @@ const RULES = [
 	assetFiles,
 	iconFile,
 	shortDescriptionRule,
-	permissionsExplained,
 	firstPublisherOwnsId,
 	bundleRule("CHECK-022", "built code does not execute dynamic code", true),
 	bundleRule("CHECK-023", "built code is not obfuscated"),
-	bundleRule("CHECK-024", "URLs in built code need the network permission"),
 	bundleRule("CHECK-025", "built code has no embedded source map"),
-	translations,
+	builtParts,
 	changelog
 ];
 
@@ -5527,7 +4060,6 @@ const hashTree = async (root, files) => Promise.all(files.map(async (file) => ({
 const SKIPPED_SOURCE_DIRS = /* @__PURE__ */ new Set([
 	"node_modules",
 	"dist-ext",
-	".dolphy",
 	".git"
 ]);
 const formatFinding = (finding) => `${finding.severity} ${finding.extensionId} ${finding.ruleId} ${finding.field}: ${finding.message}`;
@@ -5582,7 +4114,7 @@ const inspectManifest = async (dir) => {
 	};
 };
 const stringOrNull$1 = (value) => typeof value === "string" ? value : null;
-/** The extension manifest as written, with name and description in English (`%key%` → `locales/en.json`). */
+/** The extension manifest as written. */
 const readDeclared = async (dir) => {
 	let raw;
 	try {
@@ -5598,16 +4130,11 @@ const readDeclared = async (dir) => {
 		declared: null
 	};
 	const fields = raw;
-	const english = await readEnglishTable(dir);
-	const text = (value) => {
-		const plain = stringOrNull$1(value);
-		return plain === null ? null : englishText(plain, english);
-	};
 	return {
 		raw,
 		declared: {
-			name: text(fields.name),
-			description: text(fields.description),
+			name: stringOrNull$1(fields.name),
+			description: stringOrNull$1(fields.description),
 			author: stringOrNull$1(fields.author),
 			icon: stringOrNull$1(fields.icon)
 		}
@@ -5693,7 +4220,6 @@ const orderVersion = (version) => ({
 	version: version.version,
 	apiVersion: version.apiVersion,
 	minAppVersion: version.minAppVersion,
-	permissions: [...version.permissions],
 	publishedAt: version.publishedAt,
 	baseUrl: version.baseUrl,
 	files: [...version.files].sort(byPath).map(orderFile),
@@ -5704,15 +4230,6 @@ const orderVersion = (version) => ({
 		...range === void 0 ? {} : { range }
 	})) }
 });
-const optionalIds = (key, ids) => ids === void 0 || ids.length === 0 ? {} : { [key]: [...ids] };
-const orderTitles = (titles) => {
-	const ordered = {};
-	for (const point of TITLED_POINTS) {
-		const map = titles?.[point];
-		if (map !== void 0 && Object.keys(map).length > 0) ordered[point] = { ...map };
-	}
-	return Object.keys(ordered).length > 0 ? { titles: ordered } : {};
-};
 const orderEntry = (entry) => ({
 	id: entry.id,
 	name: entry.name,
@@ -5720,21 +4237,6 @@ const orderEntry = (entry) => ({
 	author: entry.author,
 	source: entry.source,
 	platforms: [...entry.platforms],
-	contributes: {
-		exerciseTypes: [...entry.contributes.exerciseTypes],
-		themes: [...entry.contributes.themes],
-		markdownRenderers: [...entry.contributes.markdownRenderers],
-		gradePolicies: [...entry.contributes.gradePolicies],
-		...optionalIds("settings", entry.contributes.settings),
-		...optionalIds("events", entry.contributes.events),
-		...optionalIds("commands", entry.contributes.commands),
-		...optionalIds("panels", entry.contributes.panels),
-		...optionalIds("widgets", entry.contributes.widgets),
-		...optionalIds("schedules", entry.contributes.schedules),
-		...optionalIds("importers", entry.contributes.importers),
-		...optionalIds("exporters", entry.contributes.exporters)
-	},
-	...orderTitles(entry.titles),
 	...entry.deprecated === void 0 ? {} : { deprecated: {
 		versions: entry.deprecated.versions,
 		reason: entry.deprecated.reason,
@@ -5841,7 +4343,7 @@ const stage = async (options, id, scratch) => {
 	const files = await hashTree(built.dir, tree.files);
 	const problems = [...tree.symlinks.map((link) => `'${link}' is a symbolic link`), ...fileProblems(files)];
 	if (problems.length > 0) throw new BuildError(problems.join("; "), id);
-	const manifest = localizeManifest(await readBuiltManifest(built.dir), { en: await readEnglishTable(built.dir) ?? {} }, "en");
+	const manifest = await readBuiltManifest(built.dir);
 	return {
 		id,
 		dir: built.dir,
@@ -5876,58 +4378,10 @@ const existingFiles = async (dir) => {
 	}));
 };
 const immutabilityError = (staged) => new BuildError(`version ${staged.manifest.version} is already published with different content; published versions never change`, staged.id);
-/** `label`/`title` of the manifest contributions by point; points without contributions are left out. */
-const titlesOf = (manifest) => {
-	const { contributes } = manifest;
-	const byPoint = {
-		exerciseTypes: contributes.exerciseTypes.flatMap(({ id, title }) => title === void 0 ? [] : [{
-			id,
-			title
-		}]),
-		markdownRenderers: contributes.markdownRenderers.flatMap(({ language, title }) => title === void 0 ? [] : [{
-			id: language,
-			title
-		}]),
-		themes: contributes.themes.map(({ id, label }) => ({
-			id,
-			title: label
-		})),
-		gradePolicies: contributes.gradePolicies.map(({ id, label }) => ({
-			id,
-			title: label
-		})),
-		settings: contributes.settings.map(({ id, label }) => ({
-			id,
-			title: label
-		})),
-		commands: contributes.commands.map(({ id, title }) => ({
-			id,
-			title
-		})),
-		panels: contributes.panels.map(({ id, title }) => ({
-			id,
-			title
-		})),
-		widgets: contributes.widgets.map(({ id, title }) => ({
-			id,
-			title
-		})),
-		importers: contributes.importers.map(({ id, title }) => ({
-			id,
-			title
-		})),
-		exporters: contributes.exporters.map(({ id, title }) => ({
-			id,
-			title
-		}))
-	};
-	return Object.fromEntries(TITLED_POINTS.filter((point) => byPoint[point].length > 0).map((point) => [point, Object.fromEntries(byPoint[point].map(({ id, title }) => [id, title]))]));
-};
 const newRecord = (staged, publishedAt) => ({
 	version: staged.manifest.version,
 	apiVersion: staged.manifest.apiVersion,
 	minAppVersion: staged.manifest.minAppVersion,
-	permissions: [...staged.manifest.permissions],
 	publishedAt,
 	baseUrl: baseUrlOf(staged),
 	files: staged.files,
@@ -5955,15 +4409,6 @@ const entryOf = (item, previous, sourceBase) => {
 	const { staged, record } = item;
 	const { manifest } = staged;
 	const others = (previous?.versions ?? []).filter((version) => version.version !== record.version);
-	const settings = manifest.contributes.settings.map((setting) => setting.id);
-	const events = manifest.contributes.events.map((item) => item.event);
-	const commands = manifest.contributes.commands.map(({ id }) => id);
-	const panels = manifest.contributes.panels.map(({ id }) => id);
-	const widgets = manifest.contributes.widgets.map(({ id }) => id);
-	const schedules = manifest.contributes.schedules.map(({ id }) => id);
-	const importers = manifest.contributes.importers.map(({ id }) => id);
-	const exporters = manifest.contributes.exporters.map(({ id }) => id);
-	const titles = titlesOf(manifest);
 	return {
 		id: staged.id,
 		name: manifest.name ?? "",
@@ -5971,21 +4416,6 @@ const entryOf = (item, previous, sourceBase) => {
 		author: manifest.author ?? "",
 		source: `${sourceBase.replace(/\/+$/, "")}/${staged.id}`,
 		platforms: [...manifest.platforms],
-		contributes: {
-			exerciseTypes: manifest.contributes.exerciseTypes.map((type) => type.id),
-			themes: manifest.contributes.themes.map((theme) => theme.id),
-			markdownRenderers: manifest.contributes.markdownRenderers.map((renderer) => renderer.language),
-			gradePolicies: manifest.contributes.gradePolicies.map((policy) => policy.id),
-			...settings.length > 0 ? { settings } : {},
-			...events.length > 0 ? { events } : {},
-			...commands.length > 0 ? { commands } : {},
-			...panels.length > 0 ? { panels } : {},
-			...widgets.length > 0 ? { widgets } : {},
-			...schedules.length > 0 ? { schedules } : {},
-			...importers.length > 0 ? { importers } : {},
-			...exporters.length > 0 ? { exporters } : {}
-		},
-		...Object.keys(titles).length > 0 ? { titles } : {},
 		...previous?.deprecated === void 0 ? {} : { deprecated: previous.deprecated },
 		versions: newestFirst([record, ...others])
 	};
@@ -6445,12 +4875,6 @@ const runDev = async (options, io, deps, startBuild, waitForExit) => {
 const formatLintFinding = (finding) => `${finding.severity} ${finding.extensionId} ${finding.ruleId} ${finding.field}: ${finding.message}`;
 const lintHasErrors = (findings) => findings.some((finding) => finding.severity === "error");
 const stringOrNull = (value) => typeof value === "string" ? value : null;
-/** A manifest string as the catalog shows it: a `%key%` becomes the text of `locales/en.json`. */
-const inEnglish = (value, table) => {
-	const text = stringOrNull(value);
-	return text === null ? null : englishText(text, table);
-};
-const stringsOf = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 const readManifest = async (root) => {
 	let raw;
 	try {
@@ -6490,10 +4914,9 @@ const lintProject = async (options) => {
 	if (options.built !== void 0 && !await isDirectory(options.built)) throw new CatalogUsageError("--built: not a directory", options.built);
 	const manifest = await readManifest(root);
 	const extensionId = stringOrNull(manifest.id) ?? path.basename(root);
-	const english = await readEnglishTable(root);
 	const findings = manifestFindings({
-		name: inEnglish(manifest.name, english),
-		description: inEnglish(manifest.description, english),
+		name: stringOrNull(manifest.name),
+		description: stringOrNull(manifest.description),
 		author: stringOrNull(manifest.author),
 		tags: Array.isArray(manifest.tags) ? manifest.tags : null
 	});
@@ -6508,7 +4931,7 @@ const lintProject = async (options) => {
 		root,
 		built: path.resolve(options.built)
 	});
-	findings.push(...bundleFindings(files, stringsOf(manifest.permissions)));
+	findings.push(...bundleFindings(files));
 	return findings.map((finding) => ({
 		...finding,
 		severity: finding.ruleId === "CHECK-004" ? "error" : "warning",
@@ -6522,23 +4945,20 @@ const EXIT_OK = 0;
 const EXIT_PROBLEMS = 1;
 const EXIT_USAGE = 2;
 const USAGE = `usage: dolphy-ext build [dir] [--out <dir>] [--watch]
-       dolphy-ext types [dir]
        dolphy-ext validate <dir>
        dolphy-ext lint [dir] [--built <dir>]
        dolphy-ext dev [dir] [--app <path>]
 ${CATALOG_SYNOPSIS}
   build [dir]      build the extension from a project (default: the current
-                   directory) into <dir>/dist-ext/<id>; also writes
-                   <dir>/.dolphy/ids.d.ts
-  types [dir]      write <dir>/.dolphy/ids.d.ts: the ids declared in
-                   extension.json as types for the SDK (no code is run)
+                   directory) into <dir>/dist-ext/<id>: main.mjs from the
+                   'server' export of src/index.ts, client.mjs from 'client'
   validate <dir>   check the directory of a built extension (extension.json,
-                   schemas, main and renderer, locales/*.json)
+                   main and client files, assets)
   lint [dir]       check the project before a pull request to the catalog:
                    manifest metadata, README.md and the built code (eval,
-                   obfuscation, URLs without the network permission, source
-                   maps); lines «error|warning <id> <RULE-ID> <field>:
-                   <message>», exit code 1 only if README.md is missing
+                   obfuscation, source maps); lines «error|warning <id>
+                   <RULE-ID> <field>: <message>», exit code 1 only if
+                   README.md is missing
   dev [dir]        watch-build the project and launch the installed Dolphy app
                    with DOLPHY_DEV_EXTENSIONS=<dir>/dist-ext; Ctrl+C stops both.
                    The app is --app, then the DOLPHY_APP variable, then the
@@ -6575,15 +4995,6 @@ const parseBuild = (args) => {
 		watch
 	};
 };
-const parseTypes = (args) => {
-	const flag = args.find((arg) => arg.startsWith("-"));
-	if (flag !== void 0) return { usageError: `unknown flag: ${flag}` };
-	if (args.length > 1) return { usageError: `extra arguments: ${args.slice(1).join(" ")}` };
-	return {
-		command: "types",
-		dir: args[0] ?? "."
-	};
-};
 const parseValidate = (args) => {
 	const flag = args.find((arg) => arg.startsWith("-"));
 	if (flag !== void 0) return { usageError: `unknown flag: ${flag}` };
@@ -6635,7 +5046,6 @@ const parseArgs = (argv) => {
 	if (argv.includes("--help") || argv.includes("-h")) return { help: true };
 	const [command, ...rest] = argv;
 	if (command === "build") return parseBuild(rest);
-	if (command === "types") return parseTypes(rest);
 	if (command === "validate") return parseValidate(rest);
 	if (command === "lint") return parseLint(rest);
 	if (command === "dev") return parseDev(rest);
@@ -6684,8 +5094,7 @@ const runBuild = async (parsed, io, deps) => {
 };
 const runValidate = async (dir, io) => {
 	const root = path.resolve(dir);
-	const { ok, problems, warnings } = await validateExtension(root);
-	for (const warning of warnings) io.stdout(`warning ${root}: ${warning}\n`);
+	const { ok, problems } = await validateExtension(root);
 	if (ok) {
 		io.stdout(`${root}: ok\n`);
 		return 0;
@@ -6737,18 +5146,7 @@ const runDevCommand = async (parsed, io, deps) => {
 		return reportBuildError(io, error);
 	}
 };
-const runTypes = async (dir, io) => {
-	try {
-		const root = path.resolve(dir);
-		const { file, changed } = await generateTypes({ root });
-		const shown = path.relative(root, file);
-		io.stdout(changed ? `wrote ${shown}\n` : `${shown} is up to date\n`);
-		return 0;
-	} catch (error) {
-		return reportBuildError(io, error);
-	}
-};
-/** `dolphy-ext build|types|validate|lint|dev|catalog`; `argv` is without `node` and the script name. */
+/** `dolphy-ext build|validate|lint|dev|catalog`; `argv` is without `node` and the script name. */
 const runCli = async (argv, io, deps = {}) => {
 	const parsed = parseArgs(argv);
 	if ("help" in parsed) {
@@ -6770,7 +5168,6 @@ const runCli = async (argv, io, deps = {}) => {
 	if (parsed.command === "validate") return runValidate(parsed.dir, io);
 	if (parsed.command === "lint") return runLint(parsed, io);
 	if (parsed.command === "dev") return runDevCommand(parsed, io, deps);
-	if (parsed.command === "types") return runTypes(parsed.dir, io);
 	return runBuild(parsed, io, deps);
 };