@dolphy-app/extension-tools 0.3.0 → 0.4.0

package/dist/cli/main.js

@@ -1,15 +1,499 @@
 #!/usr/bin/env node
 import { builtinModules } from "node:module";
 import path from "node:path";
-import { realpathSync, statSync, watch } from "node:fs";
+import { existsSync, 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 { z } from "zod";
 import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
 import { build, createLogger, parseAst } from "vite";
-import { tmpdir } from "node:os";
+import MagicString from "magic-string";
+import { homedir, tmpdir } from "node:os";
 
+//#region packages/extension-tools/src/errors.ts
+/** Extension build/check error; `subject` is the extension id or directory. */
+var BuildError = class extends Error {
+	subject;
+	constructor(message, subject) {
+		super(message);
+		this.name = "BuildError";
+		this.subject = subject;
+	}
+};
+/** Invalid command input (nonexistent directory): exit code 2. */
+var CatalogUsageError = class extends BuildError {};
+
+//#endregion
+//#region packages/extension-api/src/when.ts
+/**
+* Visibility conditions (`when`) of commands, panels and widgets. A condition
+* is a small boolean expression over a closed set of typed keys of the app
+* window (`WHEN_KEYS`). The functions are pure: the manifest check, the app
+* window and `dolphy-ext validate` share them, and so can any dispatcher that
+* can supply a `WhenContext`.
+*
+* Grammar (`!` binds tightest, then `&&`, then `||`):
+*
+* ```
+* expr    := term ('||' term)*
+* term    := factor ('&&' factor)*
+* factor  := '!' factor | '(' expr ')' | 'true' | 'false' | boolean-key | comparison
+* comparison := key ('==' | '!=') literal | key 'in' '(' literal (',' literal)* ')'
+* literal := 'text' | true | false
+* ```
+*
+* `!` stands before a boolean key, a group or another `!`; negate a
+* comparison with a group (`!(route == 'courses')`) or use `!=`.
+*/
+/** Names of the screens `route` can have: the route names of the app window. */
+const WHEN_ROUTES = [
+	"daily-plan",
+	"courses",
+	"extension-panel",
+	"placement",
+	"session",
+	"settings",
+	"settings-learning",
+	"settings-library",
+	"settings-appearance",
+	"settings-shortcuts",
+	"settings-extensions",
+	"settings-extension-details",
+	"settings-about"
+];
+/** Interface languages a `locale` condition can name. */
+const WHEN_LOCALES = ["ru", "en"];
+/**
+* Closed set of keys with their types.
+*
+* - `route`: the screen shown (a value of `WHEN_ROUTES`).
+* - `course.active`: a course is in focus (the course switcher is not on "all courses").
+* - `session.active`: the learning session screen is open.
+* - `locale`: the interface language after resolving the "system" mode.
+* - `theme.dark`: the current theme is dark.
+*/
+const WHEN_KEYS = Object.freeze({
+	route: {
+		type: "string",
+		values: WHEN_ROUTES
+	},
+	"course.active": { type: "boolean" },
+	"session.active": { type: "boolean" },
+	locale: {
+		type: "string",
+		values: WHEN_LOCALES
+	},
+	"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
+});
+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;
+};
+
+//#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})$/;
@@ -20,7 +504,9 @@ const EXTENSION_PERMISSIONS = [
 	"worker.threads",
 	"native.addons",
 	"network",
-	"learning.events"
+	"learning.events",
+	"learning.stats",
+	"notifications"
 ];
 /** Platforms the extension can run on (`process.platform`). */
 const EXTENSION_PLATFORMS = [
@@ -39,6 +525,77 @@ const EXTENSION_TAGS = [
 	"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.
+*/
+const EXTENSION_ICONS = [
+	"puzzle",
+	"book",
+	"brain",
+	"calendar",
+	"chart",
+	"check",
+	"clock",
+	"cog",
+	"fire",
+	"flag",
+	"heart",
+	"help",
+	"home",
+	"idea",
+	"list",
+	"message",
+	"pencil",
+	"play",
+	"star",
+	"target",
+	"trophy",
+	"bell",
+	"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
+});
+/** `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. */
+const EXTENSION_SCHEDULE_LIMITS = Object.freeze({
+	/** Schedules per extension. */
+	schedules: 4,
+	/** Handler budget, ms. */
+	handlerMs: 1e4,
+	/** A firing found later than this after its moment (the app was closed or asleep) is skipped, ms. */
+	lateMs: 12e4,
+	/** 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. */
+const SETTING_LIMITS = Object.freeze({
+	/** `maxLength` of `string` and `text`. */
+	stringLength: 1e4,
+	/** `maxItems` of `list`. */
+	listItems: 50,
+	/** `itemMaxLength` of `list`. */
+	listItemLength: 200,
+	groupLength: 60,
+	orderMax: 1e3
+});
+/** `#rrggbb` (any case in the manifest; 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. */
 const LEARNING_EVENT_NAMES = [
 	"session.started",
@@ -87,15 +644,24 @@ const THEME_VARIABLE_KEYS = [
 ];
 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]*\\]|[\`\\-=\\[\\]\\\\;',./+])`;
 /**
-* Command key hint: up to three modifiers (`Mod`, `Ctrl`, `Alt`,
-* `Shift`) and a key joined with `+`: a letter or digit, `F1`–`F12`, or a name
-* (`Enter`, `Space`, `Tab`, `Escape`, `Backspace`, `Delete`, arrows,
-* `Home`, `End`, `PageUp`, `PageDown`).
+* Key notation: one stroke or two strokes separated by a space
+* (`Mod+K Mod+S`). A stroke is up to three modifiers (`Mod`, `Ctrl`, `Alt`,
+* `Shift`, `Cmd`, `Meta`, `Win`, `Super`, `Option`, ...) and a key joined with
+* `+`: a letter or digit, `F1`–`F24`, a punctuation mark, a physical key
+* (`[KeyK]`) or a name (`Enter`, `Space`, `Tab`, `Escape`, `Insert`, arrows,
+* `Home`, `End`, `PageUp`, `PageDown`). A superset for the JSON Schema; the
+* host validates every string authoritatively with `@dolphy-app/keybindings`.
 */
-const KEYBINDING_PATTERN = /^(?:(?:Mod|Ctrl|Alt|Shift)\+){0,3}(?:[A-Z0-9]|F(?:[1-9]|1[0-2])|Enter|Space|Tab|Escape|Backspace|Delete|Arrow(?:Up|Down|Left|Right)|Home|End|Page(?:Up|Down))$/;
+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. */
 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). */
+	whenLength: 200,
 	/** Commands per extension. */
 	commands: 64,
 	/** Panels per extension. */
@@ -112,6 +678,33 @@ const EXTENSION_COMMAND_LIMITS = Object.freeze({
 	/** Handler budget, ms. */
 	handlerMs: 1e4
 });
+/** 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. */
+const EXTENSION_TRANSFER_LIMITS = Object.freeze({
+	/** Importers per extension. */
+	importers: 8,
+	/** Exporters per extension. */
+	exporters: 8,
+	/** Entries in `accept` of one importer. */
+	acceptExtensions: 8,
+	/** Handler budget, ms (import and export). */
+	handlerMs: 3e4,
+	/** Size of the file the user picks for an importer, bytes. */
+	inputBytes: 20971520,
+	/** Files in the directory an importer returns. */
+	files: 5e3,
+	/** One file of the returned directory, UTF-8 bytes. */
+	fileBytes: 2097152,
+	/** All files of the returned directory (and of a course snapshot), UTF-8 bytes. */
+	totalBytes: 20971520,
+	/** Size of the file an exporter returns, bytes. */
+	outputBytes: 20971520,
+	/** Length of the file name an exporter returns. */
+	filenameChars: 120,
+	/** One path of the returned directory, UTF-8 bytes. */
+	pathBytes: 1024
+});
 const DEFAULT_MAIN = "./main.mjs";
 const DEFAULT_RENDERER = "./view.mjs";
 /** Default element tag: `dolphy.sql` → `dolphy-sql-answer`. */
@@ -127,6 +720,30 @@ const EXTENSION_STORAGE_LIMITS = Object.freeze({
 	/** Sum of JSON texts of all values in UTF-8 bytes. */
 	totalBytes: 1048576
 });
+/** Secret limits; the engine enforces them (`StorageQuotaError`, kinds `key-length`, `value-size`, `key-count`). */
+const EXTENSION_SECRET_LIMITS = Object.freeze({
+	/** Key length in UTF-16 code units. */
+	keyLength: 128,
+	/** Value size in UTF-8 bytes. */
+	valueBytes: 4096,
+	/** Number of keys. */
+	keys: 32
+});
+/** Limits of `ctx.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. */
+const EXTENSION_NOTIFICATION_LIMITS = Object.freeze({
+	/** Title length in characters (code points). */
+	titleLength: 80,
+	/** Body length in characters (code points). */
+	bodyLength: 300,
+	/** Notifications per rolling minute and extension. */
+	perMinute: 3,
+	/** Notifications per rolling hour and extension. */
+	perHour: 30
+});
 
 //#endregion
 //#region packages/extension-host/src/protocol.ts
@@ -136,12 +753,30 @@ const eventParams = z.strictObject({
 	payload: z.record(z.string(), z.unknown()),
 	isolated: z.boolean()
 });
+const scheduleParams = z.strictObject({
+	extensionId: z.string(),
+	scheduleId: z.string(),
+	isolated: z.boolean()
+});
 const commandParams = z.strictObject({
 	extensionId: z.string(),
 	commandId: z.string(),
 	args: z.unknown().optional(),
 	isolated: z.boolean()
 });
+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()
+};
+const exportInput = z.discriminatedUnion("scope", [z.strictObject({
+	scope: z.literal("course"),
+	courseId: z.string(),
+	title: z.string(),
+	files: z.record(z.string(), z.string())
+}), z.strictObject({ scope: z.literal("progress") })]);
 const typed = {
 	type: z.string(),
 	exerciseId: z.string(),
@@ -191,16 +826,43 @@ const extRequestSchema = z.discriminatedUnion("method", [
 		method: z.literal("deliverEvent"),
 		params: eventParams
 	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("fireSchedule"),
+		params: scheduleParams
+	}),
 	z.strictObject({
 		id: z.string(),
 		method: z.literal("invokeCommand"),
 		params: commandParams
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("runImporter"),
+		params: z.union([z.strictObject({
+			...importParams,
+			text: z.string()
+		}), z.strictObject({
+			...importParams,
+			bytes: bytesField
+		})])
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("runExporter"),
+		params: z.strictObject({
+			extensionId: z.string(),
+			exporterId: z.string(),
+			input: exportInput,
+			isolated: z.boolean()
+		})
 	})
 ]);
 const settingValue = z.union([
 	z.boolean(),
 	z.string(),
-	z.number()
+	z.number(),
+	z.array(z.string())
 ]);
 const settingChangedSchema = z.strictObject({
 	method: z.literal("settingChanged"),
@@ -241,10 +903,82 @@ const hostRequestSchema = z.discriminatedUnion("method", [
 		method: z.literal("storage.keys"),
 		params: hostOwner
 	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("secrets.get"),
+		params: hostKey
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("secrets.set"),
+		params: z.strictObject({
+			extensionId: z.string(),
+			key: z.string(),
+			value: z.unknown()
+		})
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("secrets.delete"),
+		params: hostKey
+	}),
 	z.strictObject({
 		id: z.string(),
 		method: z.literal("settings.all"),
 		params: hostOwner
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("stats.streak"),
+		params: z.strictObject({
+			extensionId: z.string(),
+			courseId: z.string().optional()
+		})
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("stats.daily"),
+		params: z.strictObject({
+			extensionId: z.string(),
+			from: z.string(),
+			to: z.string(),
+			courseId: z.string().optional()
+		})
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("notifications.show"),
+		params: z.strictObject({
+			extensionId: z.string(),
+			title: z.string(),
+			body: z.string()
+		})
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("health.report"),
+		params: z.discriminatedUnion("kind", [
+			z.strictObject({
+				extensionId: z.string(),
+				kind: z.literal("activated"),
+				durationMs: z.number().finite().nonnegative()
+			}),
+			z.strictObject({
+				extensionId: z.string(),
+				kind: z.literal("failed"),
+				reason: z.string(),
+				message: z.string()
+			}),
+			z.strictObject({
+				extensionId: z.string(),
+				kind: z.literal("suppressed"),
+				until: z.number().finite().nonnegative()
+			}),
+			z.strictObject({
+				extensionId: z.string(),
+				kind: z.literal("reset")
+			})
+		])
 	})
 ]);
 const hostResponseSchema = z.union([z.strictObject({
@@ -263,7 +997,7 @@ const hostResponseSchema = z.union([z.strictObject({
 const isResolvedExtension = (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.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);
+	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);
 };
 /** Набор приходит от движка того же приложения, поэтому проверяется форма, а не каждое поле. */
 const replaceExtensionsSchema = z.strictObject({
@@ -293,24 +1027,24 @@ const gradeValueSchema = z.union([z.literal([
 	5
 ]), z.null()]);
 const reason = z.string().min(1).max(100);
-const text$1 = z.string().max(4e3);
+const text$2 = z.string().max(4e3);
 const gradeResultSchema = z.discriminatedUnion("outcome", [
 	z.strictObject({
 		outcome: z.literal("passed"),
-		feedback: text$1.optional(),
+		feedback: text$2.optional(),
 		data: z.unknown().optional()
 	}),
 	z.strictObject({
 		outcome: z.literal("failed"),
 		reason,
-		feedback: text$1.optional(),
-		detail: text$1.optional(),
+		feedback: text$2.optional(),
+		detail: text$2.optional(),
 		data: z.unknown().optional()
 	}),
 	z.strictObject({
 		outcome: z.literal("error"),
 		reason,
-		feedback: text$1.optional(),
+		feedback: text$2.optional(),
 		data: z.unknown().optional()
 	})
 ]);
@@ -347,6 +1081,38 @@ const commandOutcomeSchema = z.discriminatedUnion("kind", [
 	})
 ]);
 
+//#endregion
+//#region packages/extension-host/src/diagnostics.ts
+const text$1 = (data, key) => {
+	const value = data[key];
+	return Array.isArray(value) ? value.join(", ") : String(value ?? "");
+};
+const rangeSuffix = (data) => data.range === void 0 ? "" : ` ${text$1(data, "range")}`;
+const FORMATTERS = {
+	"manifest-unreadable": (data) => `extension.json is unreadable: ${text$1(data, "reason")}`,
+	"manifest-invalid": (data) => Array.isArray(data.issues) ? data.issues.join("; ") : text$1(data, "issues"),
+	"id-mismatch": (data) => `directory name '${text$1(data, "expected")}' does not match manifest id '${text$1(data, "actual")}'`,
+	"requires-app": (data) => `requires app >= ${text$1(data, "minAppVersion")}`,
+	"unavailable-platform": (data) => `not available on ${text$1(data, "platform")}`,
+	"claim-clash": (data) => `${text$1(data, "kind")} '${text$1(data, "name")}' is already provided by '${text$1(data, "by")}'`,
+	"load-failed": (data) => text$1(data, "reason"),
+	"overridden-by": (data) => `overridden by ${text$1(data, "origin")} ${text$1(data, "version")}`,
+	"safe-mode": () => "disabled in safe mode",
+	"dependency-missing": (data) => `requires extension '${text$1(data, "id")}'${rangeSuffix(data)}, which is not installed`,
+	"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")}`
+};
+/**
+* English text of a diagnostic: the single place that renders it for the CLI,
+* logs and the installer. The app window builds its own localized text from
+* the code and data.
+*/
+const formatDiagnostic = ({ code, data }) => FORMATTERS[code](data);
+
 //#endregion
 //#region packages/extension-catalog/src/assets.ts
 /**
@@ -354,8 +1120,8 @@ const commandOutcomeSchema = z.discriminatedUnion("kind", [
 * signature/geometry readers for the binary formats. Pure functions over bytes: the
 * installer, the protocol and the author tools read the same constants.
 */
-/** File extensions the first catalog format accepts (the released apps parse only these). */
-const LEGACY_FILE_EXTENSIONS = [
+/** Extensions of a version's own files: manifest, code, schemas, documentation. */
+const SOURCE_FILE_EXTENSIONS = [
 	"json",
 	"js",
 	"mjs",
@@ -372,8 +1138,8 @@ const ASSET_EXTENSIONS = [
 	"jpeg",
 	"woff2"
 ];
-/** Every extension a file of a version may have in the full index. */
-const CATALOG_FILE_EXTENSIONS = [...LEGACY_FILE_EXTENSIONS, ...ASSET_EXTENSIONS];
+/** Every extension a file of a version may have. */
+const CATALOG_FILE_EXTENSIONS = [...SOURCE_FILE_EXTENSIONS, ...ASSET_EXTENSIONS];
 const KIB = 1024;
 /** Per-file ceilings in bytes. `icon` bounds the manifest icon, which travels inside the index. */
 const ASSET_LIMITS = {
@@ -693,26 +1459,37 @@ const minAppVersionFailure = (minAppVersion, appVersion) => minAppVersion !== nu
 /** `minAppVersion` и `platforms` манифеста или записи каталога. */
 const checkCompatibility = (requirements, context) => minAppVersionFailure(requirements.minAppVersion, context.appVersion) ?? platformFailure(requirements.platforms, context.platform);
 
+//#endregion
+//#region packages/extension-catalog/src/install-meta.ts
+const httpUrl = z.url().refine((value) => /^https?:\/\//i.test(value), "catalogUrl must be an http(s) URL");
+const installMetaSchema = z.strictObject({
+	catalogUrl: httpUrl,
+	version: z.string().refine(isSemver, "version must be semver"),
+	installedAt: z.iso.datetime()
+});
+
 //#endregion
 //#region packages/extension-catalog/src/schema.ts
-/** Format of `index.json`: parsed by every released app, strictly. */
-const LEGACY_SCHEMA_VERSION = 1;
-/** Format of `index.v2.json`: asset file types, icons, up to `MAX_FILES_V2` files. */
+/** Format of `index.v2.json`, the only index: asset file types, icons, up to `MAX_FILES_V2` files. */
 const CATALOG_SCHEMA_VERSION = 2;
 const MAX_VERSIONS = 5;
-const MAX_FILES = 50;
 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`). */
+/** 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"
+	"panels",
+	"widgets",
+	"importers",
+	"exporters"
 ];
 const MAX_PATH_LENGTH = 200;
 const SHA256 = /^[0-9a-f]{64}$/;
@@ -720,23 +1497,20 @@ const SHA256 = /^[0-9a-f]{64}$/;
 const SEGMENT = /^[A-Za-z0-9_-][A-Za-z0-9._-]*$/;
 /** Имена устройств Windows: недоступны как файлы, с расширением или без. */
 const RESERVED_NAME = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;
+const describeIssues = (error, prefix = "") => error.issues.map((issue) => `${prefix}${issue.path.join(".") || "/"}: ${issue.message}`);
 const semver = z.string().refine(isSemver, "must be semver");
 const timestamp = z.iso.datetime({ offset: true });
 const httpsUrl = z.url().refine((value) => value.startsWith("https://"), "must be an https URL");
 const isSafeSegment = (segment) => SEGMENT.test(segment) && !segment.endsWith(".") && !RESERVED_NAME.test(segment);
-/** Путь файла версии: безопасные сегменты и расширение из `extensions`. */
-const isSafePathWith = (value, extensions) => {
+/** Path of a version file: safe segments, an allowed extension. */
+const isSafeCatalogPath = (value) => {
 	if (value.length > MAX_PATH_LENGTH) return false;
 	if (!value.split("/").every(isSafeSegment)) return false;
 	const extension = extensionOf(value);
-	return extension !== null && extensions.includes(extension);
+	return extension !== null && CATALOG_FILE_EXTENSIONS.includes(extension);
 };
-/** Path of a version file in the full index: safe segments, an allowed extension. */
-const isSafeCatalogPath = (value) => isSafePathWith(value, CATALOG_FILE_EXTENSIONS);
-/** Path of a version file in the first format (`index.json`). */
-const isLegacyCatalogPath = (value) => isSafePathWith(value, LEGACY_FILE_EXTENSIONS);
 /**
-* Каталог файлов версии относительно адреса `index.json` (`extensions/<id>/<version>/`).
+* Каталог файлов версии относительно адреса индекса (`extensions/<id>/<version>/`).
 * Абсолютный адрес не допускается: файлы версии по построению лежат на origin индекса,
 * а локальный каталог разработчика и e2e не требуют https.
 */
@@ -776,9 +1550,44 @@ const revokedSchema = z.strictObject({
 	versions: rangeText,
 	reason: z.string().min(1).max(300)
 });
+/** Deprecation of an entry: a warning, not a revocation. `versions: null` — every version. */
+const MAX_DEPRECATION_REASON = 200;
+const MAX_ALTERNATIVES = 3;
+const deprecatedShape = {
+	versions: rangeText.nullable(),
+	reason: z.string().min(1).max(200),
+	alternatives: z.array(extensionId$1).max(3)
+};
+const strictDeprecated = z.strictObject(deprecatedShape);
+/** The tolerant reader drops an unreadable `deprecated`; the entry stays. */
+const tolerantDeprecated = z.object(deprecatedShape).optional().catch(void 0);
+/** One item of `deprecated.json` in the catalog repository: no `versions` — every version. */
+const deprecatedItemSchema = z.strictObject({
+	id: extensionId$1,
+	versions: rangeText.optional(),
+	reason: deprecatedShape.reason,
+	alternatives: deprecatedShape.alternatives
+});
+const deprecatedListSchema = z.array(deprecatedItemSchema).superRefine((items, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	items.forEach((item, position) => {
+		if (seen.has(item.id)) ctx.addIssue({
+			code: "custom",
+			path: [position, "id"],
+			message: `duplicate id '${item.id}'`
+		});
+		seen.add(item.id);
+	});
+});
+/** Strict parse of `deprecated.json`; throws `CatalogFormatError` (also for a repeated `id`). */
+const parseDeprecatedList = (raw) => {
+	const result = deprecatedListSchema.safeParse(raw);
+	if (result.success) return result.data;
+	throw new CatalogFormatError(describeIssues(result.error));
+};
 const object = (profile, shape) => profile.strict ? z.strictObject(shape) : z.object(shape);
 const fileSchemaOf = (profile) => object(profile, {
-	path: z.string().refine((value) => isSafePathWith(value, profile.extensions), "must be a safe relative path"),
+	path: z.string().refine(isSafeCatalogPath, "must be a safe relative path"),
 	size: z.number().int().min(0).max(MAX_TOTAL_BYTES),
 	sha256: z.string().regex(SHA256, "must be lowercase hex sha256")
 }).superRefine((file, ctx) => {
@@ -788,7 +1597,7 @@ const fileSchemaOf = (profile) => object(profile, {
 		message: problem
 	});
 });
-const filesSchemaOf = (profile) => z.array(fileSchemaOf(profile)).max(profile.maxFiles).superRefine((files, ctx) => {
+const filesSchemaOf = (profile) => z.array(fileSchemaOf(profile)).max(100).superRefine((files, ctx) => {
 	const seen = /* @__PURE__ */ new Set();
 	files.forEach((file, index) => {
 		const key = file.path.toLowerCase();
@@ -832,6 +1641,24 @@ const strictTags = z.array(z.enum(EXTENSION_TAGS)).max(5).superRefine((tags, ctx
 const knownTags = EXTENSION_TAGS;
 const tolerantTags = z.array(z.string()).transform((tags) => [...new Set(tags.filter((tag) => knownTags.includes(tag)))].slice(0, 5)).catch([]);
 const tagsSchemaOf = (profile) => (profile.strict ? strictTags : tolerantTags).optional();
+const strictDependencies = z.array(z.strictObject({
+	id: extensionId$1,
+	range: rangeText.optional()
+})).max(16).superRefine((items, ctx) => {
+	items.forEach(({ id }, index) => {
+		if (items.findIndex((item) => item.id === id) !== index) ctx.addIssue({
+			code: "custom",
+			path: [index, "id"],
+			message: `duplicate dependency '${id}'`
+		});
+	});
+});
+/** The tolerant reader drops an unreadable `dependencies`; the version stays. */
+const tolerantDependencies = z.array(z.object({
+	id: extensionId$1,
+	range: rangeText.optional()
+})).max(16).catch([]);
+const dependenciesSchemaOf = (profile) => (profile.strict ? strictDependencies : tolerantDependencies).optional();
 const versionSchemaOf = (profile) => object(profile, {
 	version: semver,
 	apiVersion: z.number().int().min(1),
@@ -843,18 +1670,9 @@ const versionSchemaOf = (profile) => object(profile, {
 	/** The icon of the version as a `data:` URI; the file itself is among `files`. */
 	icon: z.string().max(MAX_ICON_URI_LENGTH).regex(ICON_URI_PATTERN).optional(),
 	/** Explicit tags of the version (a closed vocabulary); the tolerant reader drops the ones it does not know. */
-	tags: tagsSchemaOf(profile)
-}).superRefine((version, ctx) => {
-	if (!profile.tags && version.tags !== void 0) ctx.addIssue({
-		code: "custom",
-		path: ["tags"],
-		message: "tags is not part of this index format"
-	});
-	if (!profile.icon && version.icon !== void 0) ctx.addIssue({
-		code: "custom",
-		path: ["icon"],
-		message: "icon is not part of this index format"
-	});
+	tags: tagsSchemaOf(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()),
@@ -864,7 +1682,11 @@ const contributesSchemaOf = (profile) => object(profile, {
 	settings: z.array(z.string()).optional(),
 	events: z.array(z.string()).optional(),
 	commands: z.array(z.string()).optional(),
-	panels: 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. */
@@ -880,22 +1702,14 @@ const entryHeadOf = (profile) => ({
 	source: httpsUrl,
 	platforms: z.array(z.enum(EXTENSION_PLATFORMS)),
 	contributes: contributesSchemaOf(profile),
-	titles: titlesSchemaOf(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) return;
-	if (!profile.titles) {
-		ctx.addIssue({
-			code: "custom",
-			path: ["titles"],
-			message: "titles is not part of this index format"
-		});
-		return;
-	}
-	if (!profile.strict) return;
+	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({
@@ -908,122 +1722,559 @@ const entrySchemaOf = (profile) => object(profile, {
 			message: `title for '${id}', which is not in contributes.${point}`
 		});
 	}
-});
-const indexSchemaOf = (profile) => object(profile, {
-	schemaVersion: z.literal(profile.schemaVersion),
-	generatedAt: timestamp,
-	extensions: z.array(entrySchemaOf(profile)),
-	revoked: z.array(revokedSchema)
-});
-const LEGACY_PROFILE = {
-	schemaVersion: 1,
-	maxFiles: 50,
-	extensions: LEGACY_FILE_EXTENSIONS,
-	icon: false,
-	titles: false,
-	tags: false,
-	strict: true
-};
-const FULL_PROFILE = {
-	schemaVersion: 2,
-	maxFiles: 100,
-	extensions: CATALOG_FILE_EXTENSIONS,
-	icon: true,
-	titles: true,
-	tags: true,
-	strict: true
+});
+const indexSchemaOf = (profile) => object(profile, {
+	schemaVersion: z.literal(2),
+	generatedAt: timestamp,
+	extensions: z.array(entrySchemaOf(profile)),
+	revoked: z.array(revokedSchema)
+});
+const FULL_PROFILE = { strict: true };
+/** Reader of the app: the limits of the full format, unknown keys dropped. */
+const TOLERANT_PROFILE = { strict: false };
+/** `index.v2.json`: the only index format. */
+const indexSchema = indexSchemaOf(FULL_PROFILE);
+/**
+* Strict parse for the author tools: unknown keys, file types and limits fail.
+* Throws `CatalogFormatError`.
+*/
+const parseIndex = (raw) => {
+	const parsed = indexSchema.safeParse(raw);
+	if (parsed.success) return parsed.data;
+	throw new CatalogFormatError(describeIssues(parsed.error));
+};
+const tolerantHead = object(TOLERANT_PROFILE, {
+	schemaVersion: z.literal(2),
+	generatedAt: timestamp,
+	extensions: z.array(z.unknown()),
+	revoked: z.array(revokedSchema)
+});
+const tolerantEntry = object(TOLERANT_PROFILE, {
+	...entryHeadOf(TOLERANT_PROFILE),
+	versions: z.array(z.unknown())
+});
+const tolerantVersion = versionSchemaOf(TOLERANT_PROFILE);
+
+//#endregion
+//#region packages/extension-catalog/src/urls.ts
+/** File name of the catalog index, the only one. */
+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;
+	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
+			}
+		});
+	}
+	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 }
+	});
+	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
+	};
+	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;
+	}
 };
-/** Reader of the app: the limits of the full format, unknown keys dropped. */
-const TOLERANT_PROFILE = {
-	...FULL_PROFILE,
-	strict: false
+/** Текст условия → выражение; ошибка — `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;
 };
-/** `index.json`: the first format. */
-const legacyIndexSchema = indexSchemaOf(LEGACY_PROFILE);
-/** `index.v2.json`: the full format. */
-const indexSchema = indexSchemaOf(FULL_PROFILE);
-const describeIssues = (error, prefix = "") => error.issues.map((issue) => `${prefix}${issue.path.join(".") || "/"}: ${issue.message}`);
-const isLegacyIndex = (raw) => typeof raw === "object" && raw !== null && "schemaVersion" in raw && raw.schemaVersion === 1;
 /**
-* Strict parse for the author tools: unknown keys, file types and limits fail.
-* Both formats are accepted; `schemaVersion` chooses the rules.
-* Throws `CatalogFormatError`.
+* Могут ли оба условия быть истинными одновременно. `null` — нет условия.
+* Сверх 64 термов в нормальной форме ответ «да» (лучше лишнее предупреждение,
+* чем молчание).
 */
-const parseIndex = (raw) => {
-	const parsed = (isLegacyIndex(raw) ? legacyIndexSchema : indexSchema).safeParse(raw);
-	if (parsed.success) return parsed.data;
-	throw new CatalogFormatError(describeIssues(parsed.error));
+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])));
 };
-const tolerantHead = object(TOLERANT_PROFILE, {
-	schemaVersion: z.union([z.literal(1), z.literal(2)]),
-	generatedAt: timestamp,
-	extensions: z.array(z.unknown()),
-	revoked: z.array(revokedSchema)
-});
-const tolerantEntry = object(TOLERANT_PROFILE, {
-	...entryHeadOf(TOLERANT_PROFILE),
-	versions: z.array(z.unknown())
-});
-const tolerantVersion = versionSchemaOf(TOLERANT_PROFILE);
 
 //#endregion
-//#region packages/extension-catalog/src/legacy.ts
-/** Permissions the released apps know: a catalog with any other value is rejected whole by them. */
-const LEGACY_PERMISSIONS = [
-	"library.read",
-	"process.spawn",
-	"worker.threads",
-	"native.addons",
-	"network"
-];
-/** Contribution lists the released apps do not know (`contributes.settings` and later). */
-const NEWER_CONTRIBUTION_KEYS = [
-	"settings",
-	"events",
-	"commands",
-	"panels"
-];
-/** Whether a released app can parse the entry's summary of contributions. */
-const isLegacyEntry = (entry) => NEWER_CONTRIBUTION_KEYS.every((key) => entry.contributes[key] === void 0);
-/**
-* Whether a released app can parse the version: only first-format file types,
-* at most `MAX_FILES` files, no `icon` and no `tags`, only permissions it knows.
-*/
-const isLegacyVersion = (version) => version.icon === void 0 && version.tags === void 0 && version.files.length <= 50 && version.files.every((file) => isLegacyCatalogPath(file.path)) && version.permissions.every((permission) => LEGACY_PERMISSIONS.includes(permission));
+//#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"
+};
 /**
-* The part of the full index that every released app parses: versions and entries
-* they cannot read are left out, an extension left without versions is skipped,
-* `titles` (unknown to them) is dropped from the entries that stay.
-* The revocation list is kept whole.
+* Проверка привязки: клавиши (на каждой из `platforms`: `Mod` раскрывается по
+* платформе, и запись вроде `Mod+Ctrl+K` верна не везде), условие и правило
+* «сочетание без Ctrl и Meta, которое печатает или правит текст, должно быть
+* неактивно, пока фокус в поле ввода». `null` — привязка верна.
 */
-const legacySubset = (index) => ({
-	...index,
-	schemaVersion: 1,
-	extensions: index.extensions.filter(isLegacyEntry).map((entry) => {
-		const legacy = {
-			...entry,
-			versions: entry.versions.filter(isLegacyVersion)
+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
 		};
-		delete legacy.titles;
-		return legacy;
-	}).filter((entry) => entry.versions.length > 0)
-});
-
-//#endregion
-//#region packages/extension-catalog/src/install-meta.ts
-const httpUrl = z.url().refine((value) => /^https?:\/\//i.test(value), "catalogUrl must be an http(s) URL");
-const installMetaSchema = z.strictObject({
-	catalogUrl: httpUrl,
-	version: z.string().refine(isSemver, "version must be semver"),
-	installedAt: z.iso.datetime()
-});
-
-//#endregion
-//#region packages/extension-catalog/src/urls.ts
-/** File name of the first-format index: the catalog identity (`catalogUrl`) points at it. */
-const INDEX_FILE = "index.json";
-/** File name of the full index, published next to `index.json`. */
-const FULL_INDEX_FILE = "index.v2.json";
+		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
@@ -1031,6 +2282,19 @@ const FULL_INDEX_FILE = "index.v2.json";
 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` — имя поля записи). */
@@ -1085,7 +2349,62 @@ const resolveSchema = async (ajv, dir, source, label) => {
 
 //#endregion
 //#region packages/extension-host/src/points/commands.ts
-const { commands: MAX_COMMANDS } = EXTENSION_COMMAND_LIMITS;
+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,
@@ -1095,18 +2414,30 @@ const commands = {
 		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(),
-		palette: z.boolean().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
+		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)
+			...duplicateIssues("contributes.commands", "id", ids),
+			...entries.flatMap(bindingIssues),
+			...entries.flatMap((entry, index) => whenIssues("commands", index, entry.when))
 		];
 	},
 	resolve: async (entries) => entries.map((entry) => ({
@@ -1115,7 +2446,16 @@ const commands = {
 		description: entry.description ?? null,
 		category: entry.category ?? null,
 		keybinding: entry.keybinding ?? null,
-		palette: entry.palette
+		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}`)
 };
@@ -1128,6 +2468,7 @@ const 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(),
@@ -1135,6 +2476,7 @@ const exerciseTypes = {
 	}),
 	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),
@@ -1147,6 +2489,7 @@ const exerciseTypes = {
 			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,
@@ -1170,6 +2513,34 @@ const events = {
 	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";
@@ -1189,6 +2560,40 @@ const gradePolicies = {
 	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 = {
@@ -1196,10 +2601,12 @@ const 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: () => [],
@@ -1207,6 +2614,7 @@ const markdownRenderers = {
 		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;
@@ -1223,19 +2631,24 @@ const panels = {
 	schema: z.strictObject({
 		id: extensionId,
 		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength),
-		module: safePath([".js", ".mjs"]).optional()
+		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"
+		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)
+			...duplicateIssues("contributes.panels", "id", ids),
+			...entries.flatMap((entry, index) => whenIssues("panels", index, entry.when))
 		];
 	},
 	resolve: async (entries, { dir, extensionId: owner, verifyFiles }) => {
@@ -1243,6 +2656,8 @@ const panels = {
 		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;
@@ -1250,15 +2665,63 @@ const panels = {
 	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 = 1e4;
+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()
+	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),
@@ -1276,6 +2739,24 @@ const schema = z.discriminatedUnion("type", [
 		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"),
@@ -1295,7 +2776,14 @@ const schema = z.discriminatedUnion("type", [
 const constraintIssues = (setting, at) => {
 	const issue = (field, message) => `${at}.${field}: ${message}`;
 	switch (setting.type) {
-		case "boolean": return [];
+		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`)] : [];
@@ -1315,11 +2803,30 @@ const constraintIssues = (setting, at) => {
 		}
 	}
 };
+/** Нарушения `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
+		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 {
@@ -1327,6 +2834,24 @@ const resolveSetting = (setting) => {
 			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",
@@ -1360,7 +2885,8 @@ const settings = {
 	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}`))
+		...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}`)
@@ -1404,6 +2930,57 @@ const themes = {
 	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
 /** Реестр точек вклада: порядок значим для диагностики и разбора. */
@@ -1415,7 +2992,11 @@ const CONTRIBUTION_POINTS = [
 	settings,
 	events,
 	commands,
-	panels
+	panels,
+	widgets,
+	schedules,
+	importers,
+	exporters
 ];
 const POINT_KEYS = CONTRIBUTION_POINTS.map(({ key }) => key);
 
@@ -1424,7 +3005,20 @@ const POINT_KEYS = CONTRIBUTION_POINTS.map(({ key }) => key);
 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),
@@ -1437,6 +3031,10 @@ const manifestSchema = z.strictObject({
 	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;
@@ -1462,11 +3060,44 @@ const manifestSchema = z.strictObject({
 			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"],
@@ -1490,25 +3121,31 @@ const normalizeManifest = (input) => {
 		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 formatIssues = (error) => error.issues.map((issue) => `${issue.path.join(".") || "/"}: ${issue.message}`).join("; ");
+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 {
-		ok: false,
-		message: formatIssues(parsed.error)
-	};
+	if (!parsed.success) return invalid(zodIssues(parsed.error));
 	const manifest = normalizeManifest(parsed.data);
 	const issues = normalizedIssues(manifest);
-	if (issues.length > 0) return {
-		ok: false,
-		message: issues.join("; ")
-	};
+	if (issues.length > 0) return invalid(issues);
 	return {
 		ok: true,
 		manifest
@@ -1517,10 +3154,20 @@ const parseManifest = (raw) => {
 
 //#endregion
 //#region packages/extension-host/src/discover.ts
-const compatibilityIssue = (manifest, appVersion, platform) => checkCompatibility(manifest, {
-	appVersion,
-	platform
-})?.detail ?? null;
+const compatibilityIssue = (manifest, appVersion, platform) => {
+	const failure = checkCompatibility(manifest, {
+		appVersion,
+		platform
+	});
+	if (failure === null) return null;
+	return failure.reason === "app" ? {
+		code: "requires-app",
+		data: { minAppVersion: manifest.minAppVersion ?? "" }
+	} : {
+		code: "unavailable-platform",
+		data: { platform }
+	};
+};
 const resolveMain = async (dir, main, verifyFiles) => {
 	if (main === null) return null;
 	const mainPath = inside(dir, main);
@@ -1556,26 +3203,35 @@ const inspectExtensionDir = async (directory, options = {}) => {
 		return {
 			ok: false,
 			id: dirName,
-			message: `extension.json is unreadable: ${error instanceof Error ? error.message : String(error)}`
+			diagnostic: {
+				code: "manifest-unreadable",
+				data: { reason: error instanceof Error ? error.message : String(error) }
+			}
 		};
 	}
 	const parsed = parseManifest(raw);
 	if (!parsed.ok) return {
 		ok: false,
 		id: dirName,
-		message: parsed.message
+		diagnostic: parsed.diagnostic
 	};
 	const { manifest } = parsed;
 	if (expectedId !== null && manifest.id !== expectedId) return {
 		ok: false,
 		id: dirName,
-		message: `directory name '${expectedId}' does not match manifest id '${manifest.id}'`
+		diagnostic: {
+			code: "id-mismatch",
+			data: {
+				expected: expectedId,
+				actual: manifest.id
+			}
+		}
 	};
 	const incompatible = compatibilityIssue(manifest, appVersion, platform);
 	if (incompatible !== null) return {
 		ok: false,
 		id: manifest.id,
-		message: incompatible
+		diagnostic: incompatible
 	};
 	try {
 		const mainPath = await resolveMain(dir, manifest.main, verifyFiles);
@@ -1587,6 +3243,10 @@ const inspectExtensionDir = async (directory, options = {}) => {
 		};
 		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: {
@@ -1601,7 +3261,10 @@ const inspectExtensionDir = async (directory, options = {}) => {
 				platforms: manifest.platforms,
 				minAppVersion: manifest.minAppVersion,
 				icon: await resolveIcon(dir, manifest.icon, verifyFiles),
+				messages: locales.messages,
+				warnings: locales.warnings,
 				tags: manifest.tags,
+				dependencies: manifest.dependencies,
 				...resolved
 			}
 		};
@@ -1609,15 +3272,37 @@ const inspectExtensionDir = async (directory, options = {}) => {
 		return {
 			ok: false,
 			id: manifest.id,
-			message: error instanceof Error ? error.message : String(error)
+			diagnostic: {
+				code: "load-failed",
+				data: { reason: error instanceof Error ? error.message : String(error) }
+			}
 		};
 	}
 };
 
 //#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;
+
+//#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
+});
+
+//#endregion
+//#region packages/extension-host/src/restricted-runner.ts
+/** Раннер ждёт обработчик импорта или экспорта дольше его срока (30 с), но короче клиента движка (34 с). */
+const TRANSFER_DEADLINE_MS = EXTENSION_TRANSFER_LIMITS.handlerMs + 2e3;
 
 //#endregion
 //#region packages/extension-tools/src/catalog/assets.ts
@@ -2084,15 +3769,122 @@ const assetFindings = async (root, files) => {
 			});
 			continue;
 		}
-		if (assetExtensionOf(file) === null) continue;
-		const message = assetProblem(file, await readFile(path.join(root, file)));
-		if (message !== null) findings.push({
-			path: file,
-			message
-		});
+		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`));
+	}
+	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
@@ -2160,26 +3952,13 @@ const assetsPlugin = (state) => ({
 	}
 });
 
-//#endregion
-//#region packages/extension-tools/src/errors.ts
-/** Extension build/check error; `subject` is the extension id or directory. */
-var BuildError = class extends Error {
-	subject;
-	constructor(message, subject) {
-		super(message);
-		this.name = "BuildError";
-		this.subject = subject;
-	}
-};
-/** Invalid command input (nonexistent directory): exit code 2. */
-var CatalogUsageError = class extends BuildError {};
-
 //#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"
 ];
 const SOURCE_EXTENSIONS = [
@@ -2235,7 +4014,7 @@ const propertyKeys = (literal) => {
 };
 /**
 * Static analysis of `src/index.ts` without executing author code: whether the
-* `host` export exists and which keys the `views`, `panels` and `markdown`
+* `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.
 */
@@ -2373,7 +4152,7 @@ const analyzeIndex = async (indexFile) => {
 			}
 		};
 	};
-	const [views, panels, markdown] = await Promise.all(RECORDS.map(recordOf));
+	const [views, panels, widgets, markdown] = await Promise.all(RECORDS.map(recordOf));
 	const hasHost = await walk.export(indexFile, "host", 0) !== null;
 	return {
 		files: [...cache.keys()],
@@ -2381,6 +4160,7 @@ const analyzeIndex = async (indexFile) => {
 		records: {
 			views,
 			panels,
+			widgets,
 			markdown
 		}
 	};
@@ -2388,15 +4168,26 @@ const analyzeIndex = async (indexFile) => {
 /**
 * 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) => {
-	let result = source;
-	const ordered = [...sites].sort((a, b) => b.site.start - a.site.start);
-	for (const { site, keep } of ordered) {
-		const kept = site.keys.filter((key) => keep.has(key.name)).map((key) => source.slice(key.start, key.end));
-		result = `${result.slice(0, site.start)}{ ${kept.join(", ")} }${result.slice(site.end)}`;
+	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 result;
+	return {
+		code: edit.toString(),
+		map: edit.generateMap({ hires: "boundary" })
+	};
 };
 const isRecord$1 = (value) => typeof value === "object" && value !== null;
 const collectImports = (node, found) => {
@@ -2443,10 +4234,12 @@ const quote = (text) => JSON.stringify(text);
 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). */
@@ -2471,6 +4264,10 @@ const shimSource = (output, indexFile) => {
 		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)})`);
@@ -2490,16 +4287,19 @@ const findMismatches = (project, analysis, indexSource, root) => {
 	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) {
@@ -2550,7 +4350,7 @@ const shimPlugin = ({ project, output, state }) => {
 				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 and markdown renderers use`);
+				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`);
 			}
 		},
 		async buildStart() {
@@ -2676,7 +4476,15 @@ const HEADER = "// Generated by `dolphy-ext types` from extension.json. Do not e
 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) => setting.type === "enum" ? union(setting.options.map((option) => option.value)) : setting.type;
+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
@@ -2690,6 +4498,10 @@ const renderIds = ({ contributes }) => {
 		["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)]
 	];
@@ -2779,18 +4591,20 @@ const browserOutputsOf = (manifest) => {
 			output,
 			views: [],
 			panels: [],
+			widgets: [],
 			languages: []
 		};
 		outputs.set(output, created);
 		return created;
 	};
-	const { exerciseTypes, markdownRenderers, panels } = manifest.contributes;
+	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()];
 };
 /**
@@ -2813,7 +4627,7 @@ const loadProject = async (rootDir) => {
 	}
 	const raw = await readJson(manifestFile, root);
 	const parsed = parseManifest(raw);
-	if (!parsed.ok) throw new BuildError(parsed.message, root);
+	if (!parsed.ok) throw new BuildError(formatDiagnostic(parsed.diagnostic), root);
 	const { manifest } = parsed;
 	const config = await readConfig(root);
 	const host = manifest.main === null ? null : {
@@ -2890,12 +4704,19 @@ const createReporter = (onReport, settleMs = SETTLE_MS) => {
 		}
 	};
 };
+/**
+* Watch output is for development: inline source maps let DevTools show the
+* author's TypeScript for browser bundles. A normal build and a catalog build
+* never write them (`bundleConfig` leaves `sourcemap` unset; `catalog check`
+* rejects them in a submission, CHECK-025).
+*/
 const watchJob = async (job, reporter, isFailFast, failedFirst) => {
 	const started = await build({
 		...job.config,
 		build: {
 			...job.config.build,
-			watch: {}
+			watch: {},
+			sourcemap: "inline"
 		}
 	});
 	if (!isWatcher(started)) throw new Error(`watch mode is not available for '${job.output}'`);
@@ -2961,7 +4782,11 @@ const watchAll = async (project, outDir, reporter, isFailFast) => {
 
 //#endregion
 //#region packages/extension-tools/src/index.ts
-const STATIC_DIRS = ["schema", "assets"];
+const STATIC_DIRS = [
+	"schema",
+	"assets",
+	"locales"
+];
 /** 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;
@@ -3025,16 +4850,27 @@ const validateExtension = async (dir) => {
 	});
 	if (!result.ok) return {
 		ok: false,
-		problems: [result.message]
+		problems: [formatDiagnostic(result.diagnostic)],
+		warnings: []
 	};
-	const problems = (await assetFindings(root, await listFiles(root))).map(({ path: file, message }) => `${file}: ${message}`);
+	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
+		problems,
+		warnings: locales.filter(({ severity }) => severity === "warning").map(describe)
 	};
 };
-const assertValid = async (project, dir) => {
-	const { ok, problems } = await validateExtension(dir);
+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}`);
 	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. */
@@ -3063,7 +4899,7 @@ const buildExtension = async (options) => {
 	const { project, dir } = await prepare(options);
 	await bundleAll(project, dir);
 	await copyStatic(project, dir);
-	await assertValid(project, dir);
+	await assertValid(project, dir, options.logger);
 	return resultOf$1(project, dir);
 };
 const reportTo = (id, logger) => (report) => {
@@ -3085,7 +4921,7 @@ const watchExtension = async (options) => {
 	let current = await watchAll(project, dir, reporter, true);
 	try {
 		await copyStatic(project, dir);
-		await assertValid(project, dir);
+		await assertValid(project, dir, options.logger);
 	} catch (error) {
 		await current.close();
 		reporter.close();
@@ -3117,7 +4953,7 @@ const watchExtension = async (options) => {
 			current = await watchAll(project, dir, reporter, false);
 			await copyStatic(project, dir);
 			if (current.isHealthy) {
-				await assertValid(project, dir);
+				await assertValid(project, dir, options.logger);
 				logger?.info(`rebuilt ${(await resultOf$1(project, dir)).files.join(", ")}`);
 			}
 		} catch (error) {
@@ -3179,6 +5015,118 @@ const createGithubChecker = (options = {}) => {
 	};
 };
 
+//#endregion
+//#region packages/extension-tools/src/lint/bundle.ts
+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*\()/;
+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) => {
+		const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+		if (entry.isDirectory()) return listCodeFiles(dir, relative);
+		return entry.isFile() && CODE_FILE.test(entry.name) ? [relative] : [];
+	}))).flat().sort();
+};
+/** Code files (`.mjs`, `.js`, `.cjs`) of a built extension directory. */
+const readBundleFiles = async (dir) => Promise.all((await listCodeFiles(dir)).map(async (file) => ({
+	path: file,
+	text: await readFile(path.join(dir, file), "utf8")
+})));
+const isObfuscated = (text) => {
+	const size = Buffer.byteLength(text);
+	if (size >= OBFUSCATION_MIN_BYTES) {
+		const average = size / text.split("\n").length;
+		if (average > OBFUSCATION_LINE_LENGTH) return `average line length is ${Math.round(average)} characters`;
+	}
+	const identifiers = new Set(text.match(HEX_IDENTIFIER) ?? []);
+	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.
+*/
+const bundleFindings = (files, permissions) => {
+	const findings = [];
+	const mayUseNetwork = permissions.includes("network");
+	for (const { path: field, text } of files) {
+		if (DYNAMIC_EXECUTION.test(text)) findings.push({
+			ruleId: "CHECK-022",
+			severity: "warning",
+			field,
+			message: "dynamic code execution (eval or new Function)"
+		});
+		const obfuscation = isObfuscated(text);
+		if (obfuscation !== null) findings.push({
+			ruleId: "CHECK-023",
+			severity: "warning",
+			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",
+			field,
+			message: "embedded source map: the catalog builds without maps"
+		});
+	}
+	return findings;
+};
+
+//#endregion
+//#region packages/extension-tools/src/lint/manifest.ts
+const MIN_DESCRIPTION_LENGTH = 20;
+/** `CHECK-019`: a description is present but too short to tell what the extension does. */
+const shortDescription = (description) => description !== null && description.trim() !== "" && description.trim().length < 20 ? [{
+	severity: "warning",
+	field: "description",
+	message: `description is shorter than ${20} characters: say what the extension does`
+}] : [];
+const missing$1 = (value) => value === null || value.trim() === "";
+/** Publication metadata of a project: every problem is a warning. */
+const manifestFindings = (fields) => {
+	const findings = [];
+	for (const field of ["name", "author"]) if (missing$1(fields[field])) findings.push({
+		ruleId: "CHECK-003",
+		severity: "warning",
+		field,
+		message: `'${field}' is not set: the catalog requires it`
+	});
+	if (missing$1(fields.description)) findings.push({
+		ruleId: "CHECK-003",
+		severity: "warning",
+		field: "description",
+		message: "'description' is not set: the catalog requires it"
+	});
+	for (const finding of shortDescription(fields.description)) findings.push({
+		ruleId: "CHECK-019",
+		...finding
+	});
+	if (fields.tags === null || fields.tags.length === 0) findings.push({
+		ruleId: "LINT-001",
+		severity: "warning",
+		field: "tags",
+		message: "'tags' is not set: without it the catalog derives tags from contributions"
+	});
+	return findings;
+};
+
 //#endregion
 //#region packages/extension-tools/src/catalog/rules.ts
 const MAX_SOURCE_FILES = 200;
@@ -3388,6 +5336,80 @@ const iconFile = {
 		return problem === null ? [] : [error("icon", problem)];
 	}
 };
+const shortDescriptionRule = {
+	id: "CHECK-019",
+	title: "description is at least 20 characters",
+	run: ({ declared }) => shortDescription(declared?.description ?? null).map((finding) => warning(finding.field, finding.message))
+};
+const MAX_CHANGELOG_BYTES = 65536;
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Why the bytes are no acceptable `CHANGELOG.md` (over 64 KiB, not UTF-8, NUL); `null` — fine. */
+const changelogProblem = (bytes) => {
+	if (bytes.length > 65536) return `${bytes.length} bytes exceed the limit of ${MAX_CHANGELOG_BYTES}`;
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(bytes).includes("\0") ? "contains NUL characters" : null;
+	} catch {
+		return "is not valid UTF-8";
+	}
+};
+/** CHANGELOG.md: up to 64 KiB, UTF-8 without NUL; a missing section of the manifest version is a warning. */
+const changelog = {
+	id: "CHECK-030",
+	title: "CHANGELOG.md is up to 64 KiB of UTF-8 text and has a section of the current version",
+	run: async ({ readBytes, manifest }) => {
+		const bytes = await readBytes("CHANGELOG.md");
+		if (bytes === null) return [];
+		const problem = changelogProblem(bytes);
+		if (problem !== null) return [error("CHANGELOG.md", problem)];
+		const text = new TextDecoder().decode(bytes);
+		if (manifest === null) return [];
+		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",
+	run: ({ declared, published }) => {
+		const author = declared?.author;
+		if (!author || published === void 0) return [];
+		return published.author.toLowerCase() === author.toLowerCase() ? [] : [error("author", `id '${published.id}' is published by '${published.author}': the first publisher owns the id`)];
+	}
+};
+const NO_BUNDLE = "built version is not found: the bundle heuristics are skipped";
+/** `CHECK-022`…`CHECK-025`: heuristics over the built version; silent without `--built`. */
+const bundleRule = (id, title, missingBundle = false) => ({
+	id,
+	title,
+	run: async ({ bundleDir, manifest }) => {
+		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 }) => ({
+			severity,
+			field,
+			message
+		}));
+	}
+});
 const RULES = [
 	manifestValid,
 	directoryName,
@@ -3406,9 +5428,63 @@ const RULES = [
 	noExecutables,
 	appVersionBound,
 	assetFiles,
-	iconFile
+	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,
+	changelog
 ];
 
+//#endregion
+//#region packages/extension-tools/src/catalog/deprecated.ts
+/** Reads `deprecated.json`; every problem is a `BuildError` (nothing is written by the caller). */
+const loadDeprecated = async (file) => {
+	let raw;
+	try {
+		raw = JSON.parse(await readFile(file, "utf8"));
+	} catch (error) {
+		throw new BuildError(`deprecated list is unreadable: ${error instanceof Error ? error.message : String(error)}`, file);
+	}
+	try {
+		return parseDeprecatedList(raw);
+	} catch (error) {
+		if (!(error instanceof CatalogFormatError)) throw error;
+		throw new BuildError(`deprecated list is invalid: ${error.issues.join("; ")}`, file);
+	}
+};
+/** Problems of the list against the ids known to the index: unknown `id`, alternative missing from the index. */
+const deprecatedProblems = (items, known, { checkIds = true } = {}) => items.flatMap((item) => [...checkIds && !known.has(item.id) ? [{
+	id: item.id,
+	field: "id",
+	message: `'${item.id}' is not in the index`
+}] : [], ...item.alternatives.filter((alternative) => !known.has(alternative)).map((alternative) => ({
+	id: item.id,
+	field: "alternatives",
+	message: `alternative '${alternative}' is not in the index`
+}))]);
+/** Sets `deprecated` of the entries from the list and removes it from entries no longer listed. */
+const applyDeprecated = (entries, items, file) => {
+	const problems = deprecatedProblems(items, new Set(entries.map(({ id }) => id)));
+	if (problems.length > 0) throw new BuildError(problems.map(({ id, message }) => `${id}: ${message}`).join("; "), file);
+	const byId = new Map(items.map((item) => [item.id, item]));
+	return entries.map((entry) => {
+		const next = { ...entry };
+		delete next.deprecated;
+		const item = byId.get(entry.id);
+		if (item !== void 0) next.deprecated = {
+			versions: item.versions ?? null,
+			reason: item.reason,
+			alternatives: [...item.alternatives]
+		};
+		return next;
+	});
+};
+
 //#endregion
 //#region packages/extension-tools/src/catalog/tree.ts
 const compareText = (a, b) => {
@@ -3502,35 +5578,54 @@ const inspectManifest = async (dir) => {
 		problem: null
 	} : {
 		manifest: null,
-		problem: result.message
+		problem: formatDiagnostic(result.diagnostic)
 	};
 };
-const stringOrNull = (value) => typeof value === "string" ? value : null;
+const stringOrNull$1 = (value) => typeof value === "string" ? value : null;
+/** The extension manifest as written, with name and description in English (`%key%` → `locales/en.json`). */
 const readDeclared = async (dir) => {
+	let raw;
 	try {
-		const raw = JSON.parse(await readFile(path.join(dir, "extension.json"), "utf8"));
-		if (typeof raw !== "object" || raw === null) return null;
-		const fields = raw;
+		raw = JSON.parse(await readFile(path.join(dir, "extension.json"), "utf8"));
+	} catch {
 		return {
-			name: stringOrNull(fields.name),
-			description: stringOrNull(fields.description),
-			author: stringOrNull(fields.author),
-			icon: stringOrNull(fields.icon)
+			raw: null,
+			declared: null
 		};
-	} catch {
-		return null;
 	}
+	if (typeof raw !== "object" || raw === null) return {
+		raw,
+		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),
+			author: stringOrNull$1(fields.author),
+			icon: stringOrNull$1(fields.icon)
+		}
+	};
 };
 const contextFor = async (options, dirName, published, checkGithubUser) => {
 	const dir = path.resolve(options.extensionsDir, dirName);
 	const { manifest, problem } = await inspectManifest(dir);
+	const { raw, declared } = await readDeclared(dir);
 	return {
 		dirName,
 		dir,
 		manifest,
-		declared: await readDeclared(dir),
+		declared,
+		rawManifest: raw,
 		manifestProblem: problem,
 		tree: await readTree(dir, SKIPPED_SOURCE_DIRS),
+		bundleDir: options.builtDir === void 0 || manifest === null ? null : path.join(path.resolve(options.builtDir), "extensions", manifest.id, manifest.version),
 		readText: (file) => readTextOrNull(path.join(dir, file)),
 		readBytes: (file) => readBytesInside(dir, file),
 		published: published?.extensions.find((entry) => entry.id === (manifest?.id ?? dirName)),
@@ -3539,6 +5634,32 @@ const contextFor = async (options, dirName, published, checkGithubUser) => {
 		checkGithubUser
 	};
 };
+const DEPRECATED_RULE = "deprecated";
+/** The form of `deprecated.json` and (with an index) the existence of the alternatives; unknown ids are a build matter. */
+const deprecatedFindings = async (file, published) => {
+	let items;
+	try {
+		items = await loadDeprecated(file);
+	} catch (error) {
+		if (!(error instanceof BuildError)) throw error;
+		return [{
+			severity: "error",
+			extensionId: path.basename(file),
+			ruleId: DEPRECATED_RULE,
+			field: "/",
+			message: error.message
+		}];
+	}
+	if (published === null) return [];
+	const known = new Set(published.extensions.map(({ id }) => id));
+	return deprecatedProblems(items, known, { checkIds: false }).map(({ id, field, message }) => ({
+		severity: "error",
+		extensionId: id,
+		ruleId: DEPRECATED_RULE,
+		field,
+		message
+	}));
+};
 const checkCatalog = async (options) => {
 	const dirs = await selectDirs(options);
 	const published = options.publishedIndex === void 0 ? null : await loadIndexFile(options.publishedIndex);
@@ -3546,7 +5667,7 @@ const checkCatalog = async (options) => {
 		...options.fetch === void 0 ? {} : { fetch: options.fetch },
 		token: options.githubToken
 	});
-	const findings = [];
+	const findings = [...options.deprecated === void 0 ? [] : await deprecatedFindings(options.deprecated, published)];
 	for (const dirName of dirs) {
 		const context = await contextFor(options, dirName, published, checkGithubUser);
 		for (const rule of RULES) for (const finding of await rule.run(context)) findings.push({
@@ -3577,7 +5698,11 @@ const orderVersion = (version) => ({
 	baseUrl: version.baseUrl,
 	files: [...version.files].sort(byPath).map(orderFile),
 	...version.icon === void 0 ? {} : { icon: version.icon },
-	...version.tags === void 0 || version.tags.length === 0 ? {} : { tags: [...version.tags] }
+	...version.tags === void 0 || version.tags.length === 0 ? {} : { tags: [...version.tags] },
+	...version.dependencies === void 0 || version.dependencies.length === 0 ? {} : { dependencies: version.dependencies.map(({ id, range }) => ({
+		id,
+		...range === void 0 ? {} : { range }
+	})) }
 });
 const optionalIds = (key, ids) => ids === void 0 || ids.length === 0 ? {} : { [key]: [...ids] };
 const orderTitles = (titles) => {
@@ -3603,22 +5728,31 @@ const orderEntry = (entry) => ({
 		...optionalIds("settings", entry.contributes.settings),
 		...optionalIds("events", entry.contributes.events),
 		...optionalIds("commands", entry.contributes.commands),
-		...optionalIds("panels", entry.contributes.panels)
+		...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,
+		alternatives: [...entry.deprecated.alternatives]
+	} },
 	versions: entry.versions.map(orderVersion)
 });
 const byId = (a, b) => compareText(a.id, b.id);
 const newestFirst = (versions) => [...versions].sort((a, b) => compareSemver(b.version, a.version)).slice(0, 5);
-const checked = (candidate, file) => {
+const checked = (candidate) => {
 	try {
 		parseIndex(candidate);
 		return candidate;
 	} catch (error) {
-		throw new BuildError(`resulting index is invalid: ${error instanceof Error ? error.message : String(error)}`, file);
+		throw new BuildError(`resulting index is invalid: ${error instanceof Error ? error.message : String(error)}`, FULL_INDEX_FILE);
 	}
 };
-/** Builds the full index with a stable key order; throws `BuildError` if it fails `parseIndex`. */
+/** Builds the index with a stable key order; throws `BuildError` if it fails `parseIndex`. */
 const assembleIndex = (parts) => {
 	const candidate = {
 		schemaVersion: 2,
@@ -3630,15 +5764,7 @@ const assembleIndex = (parts) => {
 			reason: item.reason
 		}))
 	};
-	return checked(candidate, FULL_INDEX_FILE);
-};
-/** `index.v2.json` and `index.json` of the same content and `generatedAt`. */
-const assembleIndexes = (parts) => {
-	const full = assembleIndex(parts);
-	return {
-		full,
-		legacy: checked(legacySubset(full), INDEX_FILE)
-	};
+	return checked(candidate);
 };
 const writeIndexAtomically = async (file, index) => {
 	const temporary = `${file}.${process.pid}.tmp`;
@@ -3664,11 +5790,20 @@ const hasSameContent = (current, next) => current !== null && contentOf(current)
 const DEFAULT_SOURCE_BASE = "https://github.com/dolphy-app/dolphy-extensions/tree/main/extensions";
 const errorText = (error) => error instanceof Error ? error.message : String(error);
 const README = "README.md";
+const CHANGELOG = "CHANGELOG.md";
 const copyReadme = async (srcDir, dir, id) => {
 	const text = await readFile(path.join(srcDir, README), "utf8").catch(() => "");
 	if (text.trim() === "") throw new BuildError(`${README} is missing or empty`, id);
 	await writeFile(path.join(dir, README), text);
 };
+/** `CHANGELOG.md` is optional; its limits are checked by the file-size rules and `CHECK-030`. */
+const copyChangelog = async (srcDir, dir, id) => {
+	const bytes = await readFile(path.join(srcDir, CHANGELOG)).catch(() => null);
+	if (bytes === null) return;
+	const problem = changelogProblem(bytes);
+	if (problem !== null) throw new BuildError(`${CHANGELOG} ${problem}`, id);
+	await writeFile(path.join(dir, CHANGELOG), bytes);
+};
 const fileProblems = (files) => {
 	const problems = files.filter((file) => !isSafeCatalogPath(file.path)).map((file) => `'${file.path}' is not allowed (extensions ${CATALOG_FILE_EXTENSIONS.join("|")}, safe path segments)`);
 	if (files.length > 100) problems.push(`${files.length} files exceed the limit of ${100}`);
@@ -3682,7 +5817,7 @@ const fileProblems = (files) => {
 };
 const readBuiltManifest = async (dir) => {
 	const parsed = parseManifest(JSON.parse(await readFile(path.join(dir, "extension.json"), "utf8")));
-	if (!parsed.ok) throw new BuildError(parsed.message, dir);
+	if (!parsed.ok) throw new BuildError(formatDiagnostic(parsed.diagnostic), dir);
 	return parsed.manifest;
 };
 /** The icon declared in the manifest, read from the built directory; its checks ran in `buildExtension`. */
@@ -3701,11 +5836,12 @@ const stage = async (options, id, scratch) => {
 	});
 	if (built.id !== id) throw new BuildError(`directory name '${id}' does not match manifest id '${built.id}'`, id);
 	await copyReadme(srcDir, built.dir, id);
+	await copyChangelog(srcDir, built.dir, id);
 	const tree = await readTree(built.dir);
 	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 = await readBuiltManifest(built.dir);
+	const manifest = localizeManifest(await readBuiltManifest(built.dir), { en: await readEnglishTable(built.dir) ?? {} }, "en");
 	return {
 		id,
 		dir: built.dir,
@@ -3744,6 +5880,14 @@ const immutabilityError = (staged) => new BuildError(`version ${staged.manifest.
 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
@@ -3763,6 +5907,18 @@ const titlesOf = (manifest) => {
 		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]))]));
@@ -3776,7 +5932,11 @@ const newRecord = (staged, publishedAt) => ({
 	baseUrl: baseUrlOf(staged),
 	files: staged.files,
 	...staged.icon === null ? {} : { icon: staged.icon },
-	...staged.manifest.tags.length === 0 ? {} : { tags: [...staged.manifest.tags] }
+	...staged.manifest.tags.length === 0 ? {} : { tags: [...staged.manifest.tags] },
+	...staged.manifest.dependencies.length === 0 ? {} : { dependencies: staged.manifest.dependencies.map(({ id, range }) => ({
+		id,
+		...range === null ? {} : { range }
+	})) }
 });
 const plan = async (staged, out, previous, publishedAt) => {
 	const onDisk = await existingFiles(versionDir(out, staged));
@@ -3799,6 +5959,10 @@ const entryOf = (item, previous, sourceBase) => {
 	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,
@@ -3815,9 +5979,14 @@ const entryOf = (item, previous, sourceBase) => {
 			...settings.length > 0 ? { settings } : {},
 			...events.length > 0 ? { events } : {},
 			...commands.length > 0 ? { commands } : {},
-			...panels.length > 0 ? { panels } : {}
+			...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])
 	};
 };
@@ -3832,6 +6001,7 @@ const loadRevoked = async (file, previous) => {
 	if (!Array.isArray(raw)) throw new BuildError("revoked list must be a JSON array", file);
 	return raw;
 };
+const withDeprecations = async (entries, file) => file === void 0 ? entries : applyDeprecated(entries, await loadDeprecated(file), file);
 const writeVersion = async (item, out) => {
 	const target = versionDir(out, item.staged);
 	const parent = path.dirname(target);
@@ -3844,38 +6014,25 @@ const writeVersion = async (item, out) => {
 	await cp(item.staged.dir, temporary, { recursive: true });
 	await rename(temporary, target);
 };
-const resultOf = (item, entry) => ({
+const resultOf = (item) => ({
 	id: item.staged.id,
 	version: item.staged.manifest.version,
 	status: item.status,
 	files: item.staged.files.length,
-	bytes: item.staged.files.reduce((sum, file) => sum + file.size, 0),
-	inLegacyIndex: isLegacyEntry(entry) && isLegacyVersion(item.record)
+	bytes: item.staged.files.reduce((sum, file) => sum + file.size, 0)
 });
-const formatPublishResult = (result) => {
-	const legacy = result.inLegacyIndex ? "" : ` — only in ${FULL_INDEX_FILE}: released apps cannot read it`;
-	return result.status === "unchanged" ? `unchanged ${result.id}@${result.version}${legacy}` : `published ${result.id}@${result.version} (${result.files} files, ${result.bytes} bytes)${legacy}`;
-};
-/** The index to start from: the explicit file, else the full index of the site, else its `index.json`. */
-const previousIndexFile = async (out, explicit) => {
-	if (explicit !== void 0) return path.resolve(explicit);
-	const full = path.join(out, FULL_INDEX_FILE);
-	return await stat(full).catch(() => null) === null ? path.join(out, INDEX_FILE) : full;
-};
-/**
-* Writes `index.v2.json` and `index.json` when either differs from the disk (ignoring
-* `generatedAt`); both get the same `generatedAt`, so the app can compare them with each other.
-*/
-const writeIndexes = async (out, { full, legacy }) => {
-	const fullFile = path.join(out, FULL_INDEX_FILE);
-	const legacyFile = path.join(out, INDEX_FILE);
-	if (hasSameContent(await loadIndexFile(fullFile), full) && hasSameContent(await loadIndexFile(legacyFile), legacy)) return false;
+const formatPublishResult = (result) => result.status === "unchanged" ? `unchanged ${result.id}@${result.version}` : `published ${result.id}@${result.version} (${result.files} files, ${result.bytes} bytes)`;
+/** The index to start from: the explicit file, else the index of the site. */
+const previousIndexFile = async (out, explicit) => explicit === void 0 ? path.join(out, FULL_INDEX_FILE) : path.resolve(explicit);
+/** Writes `index.v2.json` when it differs from the disk (ignoring `generatedAt`). */
+const writeIndex = async (out, index) => {
+	const file = path.join(out, FULL_INDEX_FILE);
+	if (hasSameContent(await loadIndexFile(file), index)) return false;
 	await mkdir(out, { recursive: true });
-	await writeIndexAtomically(fullFile, full);
-	await writeIndexAtomically(legacyFile, legacy);
+	await writeIndexAtomically(file, index);
 	return true;
 };
-/** Builds extension versions and updates `index.v2.json` and `index.json`; on error nothing is written to disk. */
+/** Builds extension versions and updates `index.v2.json`; on error nothing is written to disk. */
 const buildCatalog = async (options) => {
 	const out = path.resolve(options.out);
 	const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
@@ -3896,15 +6053,15 @@ const buildCatalog = async (options) => {
 			plans.push(item);
 			const entry = entryOf(item, before, sourceBase);
 			entries.set(id, entry);
-			results.push(resultOf(item, entry));
+			results.push(resultOf(item));
 		}
-		const indexes = assembleIndexes({
+		const index = assembleIndex({
 			generatedAt: now,
-			extensions: [...entries.values()],
+			extensions: await withDeprecations([...entries.values()], options.deprecated),
 			revoked
 		});
 		for (const item of plans) if (item.shouldWrite) await writeVersion(item, out);
-		await writeIndexes(out, indexes);
+		await writeIndex(out, index);
 		return results;
 	} finally {
 		await rm(scratch, {
@@ -3914,21 +6071,21 @@ const buildCatalog = async (options) => {
 	}
 };
 const formatReindexResult = (result) => `reindexed (${result.extensions} extensions, ${result.revoked} revoked)${result.changed ? "" : " — no changes"}`;
-/** Rewrites `revoked` and `generatedAt` of both indexes; extension entries are unchanged. */
+/** Rewrites `revoked` and `generatedAt` of the index; extension entries are unchanged. */
 const reindexCatalog = async (options) => {
 	const out = path.resolve(options.out);
 	const source = await previousIndexFile(out, options.previousIndex);
 	const previous = await loadIndexFile(source);
 	if (previous === null) throw new CatalogUsageError(`nothing to reindex: ${source} does not exist`, source);
-	const indexes = assembleIndexes({
+	const index = assembleIndex({
 		generatedAt: options.publishedAt ?? (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
-		extensions: previous.extensions,
+		extensions: await withDeprecations(previous.extensions, options.deprecated),
 		revoked: await loadRevoked(options.revoked, previous)
 	});
-	const changed = await writeIndexes(out, indexes);
+	const changed = await writeIndex(out, index);
 	return {
-		extensions: indexes.full.extensions.length,
-		revoked: indexes.full.revoked.length,
+		extensions: index.extensions.length,
+		revoked: index.revoked.length,
 		changed
 	};
 };
@@ -3936,36 +6093,45 @@ const reindexCatalog = async (options) => {
 //#endregion
 //#region packages/extension-tools/src/catalog/cli.ts
 const CATALOG_SYNOPSIS = `       dolphy-ext catalog check <extensionsDir> [--ids a,b]
-                   [--published-index <path>] [--max-app-version <x.y.z>]
-                   [--skip-github-check] [--list-rules]
+                   [--published-index <path>] [--deprecated <path>]
+                   [--max-app-version <x.y.z>]
+                   [--built <siteDir>] [--skip-github-check] [--list-rules]
        dolphy-ext catalog build --src <extensionsDir> --ids a,b --out <siteDir>
                    [--previous-index <path>] [--revoked <path>]
-                   [--source-base <url>] [--published-at <iso>]
+                   [--deprecated <path>] [--source-base <url>]
+                   [--published-at <iso>]
        dolphy-ext catalog build --reindex --out <siteDir>
                    [--previous-index <path>] [--revoked <path>]
-                   [--published-at <iso>]
+                   [--deprecated <path>] [--published-at <iso>]
 `;
 const CATALOG_HELP = `  catalog check    check the catalog's extension sources; lines
                    «error|warning <id> <RULE-ID> <field>: <message>»,
                    exit code 1 if any error
   catalog build    build versions into <siteDir>/extensions/<id>/<version>/ and
-                   update <siteDir>/index.json (published versions are
+                   update <siteDir>/index.v2.json (published versions are
                    immutable)
   catalog build --reindex
-                   only replace revoked and generatedAt in the existing
-                   <siteDir>/index.json (--src and --ids are not needed)
+                   only replace revoked, deprecated and generatedAt in the
+                   existing <siteDir>/index.v2.json (--src and --ids are not needed)
 
   --ids a,b              only these extensions (check: all by default)
-  --published-index <p>  index.json of the published catalog (no file —
+  --published-index <p>  index.v2.json of the published catalog (no file —
                          nothing is published)
   --max-app-version <v>  minAppVersion must not be newer
+  --built <siteDir>      also check the built versions in
+                         <siteDir>/extensions/<id>/<version>/ (eval, obfuscation,
+                         URLs, source maps); without it these rules are silent
   --skip-github-check    do not verify the author via api.github.com
                          (token — the GITHUB_TOKEN variable)
   --list-rules           print the check rules
   --src <dir>            directory of projects <dir>/<id>
   --out <dir>            site root
-  --previous-index <p>   source index (default <out>/index.json)
+  --previous-index <p>   source index (default <out>/index.v2.json)
   --revoked <p>          JSON array {id, versions, reason}
+  --deprecated <p>       JSON array {id, versions?, reason, alternatives}
+                         (check: validate the form and, with
+                         --published-index, the alternatives; build: write
+                         "deprecated" to entries, unset — keep the index's)
   --source-base <url>    base for the index entry's source field
   --published-at <iso>   publishedAt of new versions (default now);
                          with --reindex — generatedAt
@@ -3974,7 +6140,9 @@ const VALUE_FLAGS = {
 	check: [
 		"--ids",
 		"--published-index",
-		"--max-app-version"
+		"--deprecated",
+		"--max-app-version",
+		"--built"
 	],
 	build: [
 		"--src",
@@ -3982,6 +6150,7 @@ const VALUE_FLAGS = {
 		"--out",
 		"--previous-index",
 		"--revoked",
+		"--deprecated",
 		"--source-base",
 		"--published-at"
 	]
@@ -4033,7 +6202,9 @@ const parseCheck = (args) => {
 		dir: positional[0] ?? null,
 		ids: idsOf(flags),
 		publishedIndex: text(flags, "--published-index"),
+		deprecated: text(flags, "--deprecated"),
 		maxAppVersion,
+		built: text(flags, "--built"),
 		skipGithubCheck: flags["--skip-github-check"] === true,
 		listRules: listRulesFlag
 	};
@@ -4053,6 +6224,7 @@ const parseReindex = (flags) => {
 		out,
 		previousIndex: text(flags, "--previous-index"),
 		revoked: text(flags, "--revoked"),
+		deprecated: text(flags, "--deprecated"),
 		publishedAt: text(flags, "--published-at")
 	};
 };
@@ -4075,6 +6247,7 @@ const parseBuild$1 = (args) => {
 		out,
 		previousIndex: text(flags, "--previous-index"),
 		revoked: text(flags, "--revoked"),
+		deprecated: text(flags, "--deprecated"),
 		sourceBase: text(flags, "--source-base"),
 		publishedAt: text(flags, "--published-at")
 	};
@@ -4094,7 +6267,9 @@ const runCheck = async (parsed, io, deps) => {
 		extensionsDir: path.resolve(parsed.dir),
 		...parsed.ids === void 0 ? {} : { ids: parsed.ids },
 		...parsed.publishedIndex === void 0 ? {} : { publishedIndex: path.resolve(parsed.publishedIndex) },
+		...parsed.deprecated === void 0 ? {} : { deprecated: path.resolve(parsed.deprecated) },
 		...parsed.maxAppVersion === void 0 ? {} : { maxAppVersion: parsed.maxAppVersion },
+		...parsed.built === void 0 ? {} : { builtDir: path.resolve(parsed.built) },
 		skipGithubCheck: parsed.skipGithubCheck,
 		githubToken: deps.env?.GITHUB_TOKEN,
 		...deps.fetch === void 0 ? {} : { fetch: deps.fetch }
@@ -4107,6 +6282,7 @@ const runReindex = async (parsed, io, deps) => {
 		out: parsed.out,
 		...parsed.previousIndex === void 0 ? {} : { previousIndex: parsed.previousIndex },
 		...parsed.revoked === void 0 ? {} : { revoked: parsed.revoked },
+		...parsed.deprecated === void 0 ? {} : { deprecated: parsed.deprecated },
 		...parsed.publishedAt === void 0 ? {} : { publishedAt: parsed.publishedAt },
 		...deps.now === void 0 ? {} : { now: deps.now }
 	});
@@ -4120,6 +6296,7 @@ const runBuild$1 = async (parsed, io, deps) => {
 		out: parsed.out,
 		...parsed.previousIndex === void 0 ? {} : { previousIndex: parsed.previousIndex },
 		...parsed.revoked === void 0 ? {} : { revoked: parsed.revoked },
+		...parsed.deprecated === void 0 ? {} : { deprecated: parsed.deprecated },
 		...parsed.sourceBase === void 0 ? {} : { sourceBase: parsed.sourceBase },
 		...parsed.publishedAt === void 0 ? {} : { publishedAt: parsed.publishedAt },
 		...deps.now === void 0 ? {} : { now: deps.now }
@@ -4140,6 +6317,205 @@ const runCatalog = async (parsed, io, deps = {}) => {
 	}
 };
 
+//#endregion
+//#region packages/extension-tools/src/dev.ts
+/** An app that quits sooner than this did not start for us: see `QUICK_EXIT_HINT`. */
+const QUICK_EXIT_MS = 5e3;
+const QUICK_EXIT_HINT = "Dolphy is probably already running: quit it and run again (the app has a single instance, a second launch exits at once and the extension directory is lost)";
+const flavor = (platform) => platform === "win32" ? path.win32 : path.posix;
+/** `Dolphy-Linux-1.12.0.AppImage` → `[1, 12, 0]`; other names have no version. */
+const versionOf = (name) => {
+	const match = /^Dolphy-Linux-(\d+(?:\.\d+)*)\.AppImage$/.exec(name);
+	return match === null ? null : match[1].split(".").map(Number);
+};
+const compareVersions = (a, b) => {
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		const diff = (a[i] ?? 0) - (b[i] ?? 0);
+		if (diff !== 0) return diff;
+	}
+	return 0;
+};
+/** Places the installer puts the app (`electron-builder.json`); Linux has no fixed place. */
+const standardPlaces = (where) => {
+	const p = flavor(where.platform);
+	if (where.platform === "darwin") return ["/Applications/Dolphy.app", p.join(where.home, "Applications", "Dolphy.app")];
+	if (where.platform === "win32") {
+		const base = where.env.LOCALAPPDATA ?? p.join(where.home, "AppData", "Local");
+		return [p.join(base, "Programs", "Dolphy", "Dolphy.exe")];
+	}
+	const dir = p.join(where.home, "Applications");
+	return where.list(dir).flatMap((name) => {
+		const version = versionOf(name);
+		return version === null ? [] : [{
+			name,
+			version
+		}];
+	}).sort((a, b) => compareVersions(b.version, a.version)).map(({ name }) => p.join(dir, name));
+};
+const lookedAt = (where) => where.platform === "linux" ? flavor(where.platform).join(where.home, "Applications", "Dolphy-Linux-*.AppImage") : standardPlaces(where).join(", ");
+const missing = (where, what) => new CatalogUsageError(`${what}; looked at: ${lookedAt(where)}; point to the app with --app <path> or the DOLPHY_APP environment variable`, "dolphy-ext dev");
+/**
+* The app to launch: `--app`, then `DOLPHY_APP`, then the standard places of the
+* platform. A macOS bundle (`Dolphy.app`) is started by its executable, so that
+* the environment reaches the app and the process lives as long as the app does.
+*/
+const findApp = (explicit, where) => {
+	const p = flavor(where.platform);
+	const given = explicit ?? where.env.DOLPHY_APP;
+	const chosen = given === void 0 || given === "" ? null : given;
+	const found = (chosen === null ? standardPlaces(where) : [chosen]).find((place) => where.exists(place)) ?? null;
+	if (found === null) throw missing(where, chosen === null ? "the Dolphy app is not found" : `${explicit === void 0 ? "DOLPHY_APP" : "--app"} points to '${chosen}', which does not exist`);
+	return found.endsWith(".app") ? p.join(found, "Contents", "MacOS", p.basename(found, ".app")) : found;
+};
+const systemDeps = (env) => ({
+	platform: process.platform,
+	env,
+	home: homedir(),
+	exists: existsSync,
+	list: (dir) => {
+		try {
+			return readdirSync(dir);
+		} catch {
+			return [];
+		}
+	},
+	launch: (command, childEnv) => {
+		const child = spawn(command, [], {
+			env: childEnv,
+			stdio: "inherit"
+		});
+		return {
+			exited: new Promise((resolve, reject) => {
+				child.once("error", reject);
+				child.once("exit", (code, signal) => resolve({
+					code,
+					signal
+				}));
+			}),
+			kill: () => {
+				child.kill("SIGTERM");
+			}
+		};
+	},
+	now: Date.now
+});
+/**
+* `dolphy-ext dev`: a watch build of the project and the installed app that
+* reads the output through `DOLPHY_DEV_EXTENSIONS`. Resolves with the exit code
+* when the user stops it (0) or the app quits (0 after a normal session, 1 when
+* it quit at once).
+*/
+const runDev = async (options, io, deps, startBuild, waitForExit) => {
+	const command = findApp(options.app, deps);
+	const build = await startBuild();
+	io.stdout(`${build.summary}\n`);
+	try {
+		io.stdout(`launching ${command} with DOLPHY_DEV_EXTENSIONS=${build.outDir}\n`);
+		const startedAt = deps.now();
+		const app = deps.launch(command, {
+			...deps.env,
+			DOLPHY_DEV_EXTENSIONS: build.outDir
+		});
+		io.stdout("watching for changes, Ctrl+C stops the build and the app\n");
+		const ending = await Promise.race([waitForExit().then(() => ({ by: "user" })), app.exited.then((exit) => ({
+			by: "app",
+			exit
+		}))]);
+		if (ending.by === "user") {
+			app.kill();
+			await app.exited.catch(() => void 0);
+			return 0;
+		}
+		const { code } = ending.exit;
+		if (code !== null && deps.now() - startedAt < 5e3) {
+			io.stderr(`${QUICK_EXIT_HINT}\n`);
+			return 1;
+		}
+		return 0;
+	} catch (error) {
+		io.stderr(`error dolphy-ext dev: cannot run ${command}: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 1;
+	} finally {
+		await build.close();
+	}
+};
+
+//#endregion
+//#region packages/extension-tools/src/lint/index.ts
+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 {
+		raw = JSON.parse(await readFile(path.join(root, MANIFEST_FILE), "utf8"));
+	} catch (error) {
+		throw new CatalogUsageError(`${MANIFEST_FILE} is unreadable: ${error instanceof Error ? error.message : String(error)}`, root);
+	}
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new CatalogUsageError(`${MANIFEST_FILE} is not an object`, root);
+	return raw;
+};
+const isDirectory = async (dir) => (await stat(dir).catch(() => null))?.isDirectory() === true;
+/** Code files of the build the author is going to publish. */
+const builtFiles = async (options) => {
+	if (options.built !== void 0) return readBundleFiles(options.built);
+	const temp = await mkdtemp(path.join(tmpdir(), "dolphy-lint-"));
+	try {
+		const { dir } = await buildExtension({
+			root: options.root,
+			outDir: temp
+		});
+		return await readBundleFiles(dir);
+	} finally {
+		await rm(temp, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+/**
+* Checks a project the way `catalog check` checks it, before a pull request:
+* manifest metadata, README and the built code. Everything is a warning
+* except a missing README and an embedded source map.
+*/
+const lintProject = async (options) => {
+	const root = path.resolve(options.root);
+	if (!await isDirectory(root)) throw new CatalogUsageError("not a directory", root);
+	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),
+		author: stringOrNull(manifest.author),
+		tags: Array.isArray(manifest.tags) ? manifest.tags : null
+	});
+	const readme = await readFile(path.join(root, "README.md"), "utf8").catch(() => null);
+	if (readme === null || readme.trim() === "") findings.push({
+		ruleId: "CHECK-004",
+		severity: "error",
+		field: "README.md",
+		message: "README.md is missing or empty"
+	});
+	const files = await builtFiles(options.built === void 0 ? { root } : {
+		root,
+		built: path.resolve(options.built)
+	});
+	findings.push(...bundleFindings(files, stringsOf(manifest.permissions)));
+	return findings.map((finding) => ({
+		...finding,
+		severity: finding.ruleId === "CHECK-004" ? "error" : "warning",
+		extensionId
+	}));
+};
+
 //#endregion
 //#region packages/extension-tools/src/cli/run.ts
 const EXIT_OK = 0;
@@ -4148,6 +6524,8 @@ 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
@@ -4155,8 +6533,23 @@ ${CATALOG_SYNOPSIS}
   types [dir]      write <dir>/.dolphy/ids.d.ts: the ids declared in
                    extension.json as types for the SDK (no code is run)
   validate <dir>   check the directory of a built extension (extension.json,
-                   schemas, main and renderer)
+                   schemas, main and renderer, locales/*.json)
+  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
+  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
+                   standard place of the platform (macOS /Applications/Dolphy.app
+                   and ~/Applications/Dolphy.app; Windows
+                   %LOCALAPPDATA%\\Programs\\Dolphy\\Dolphy.exe; Linux the newest
+                   ~/Applications/Dolphy-Linux-*.AppImage); exit code 2 if none
 ${CATALOG_HELP}
+  --app <path>     dev: the Dolphy app (macOS .app bundle or an executable)
+  --built <dir>    lint: check this built extension instead of building the
+                   project into a temporary directory
   --out <dir>      output root (the extension goes to <dir>/<id>)
   --watch          rebuild the bundles when the sources change
   --help           this help
@@ -4202,12 +6595,50 @@ const parseValidate = (args) => {
 		dir
 	};
 };
+const parseLint = (args) => {
+	const positional = [];
+	let built;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--built") {
+			built = args[++i];
+			if (built === void 0) return { usageError: "--built needs a path" };
+		} else if (arg.startsWith("-")) return { usageError: `unknown flag: ${arg}` };
+		else positional.push(arg);
+	}
+	if (positional.length > 1) return { usageError: `extra arguments: ${positional.slice(1).join(" ")}` };
+	return {
+		command: "lint",
+		dir: positional[0] ?? ".",
+		built
+	};
+};
+const parseDev = (args) => {
+	const positional = [];
+	let app;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--app") {
+			app = args[++i];
+			if (app === void 0) return { usageError: "--app needs a path" };
+		} else if (arg.startsWith("-")) return { usageError: `unknown flag: ${arg}` };
+		else positional.push(arg);
+	}
+	if (positional.length > 1) return { usageError: `extra arguments: ${positional.slice(1).join(" ")}` };
+	return {
+		command: "dev",
+		dir: positional[0] ?? ".",
+		app
+	};
+};
 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);
 	if (command === "catalog") return {
 		command: "catalog",
 		args: rest
@@ -4253,7 +6684,8 @@ const runBuild = async (parsed, io, deps) => {
 };
 const runValidate = async (dir, io) => {
 	const root = path.resolve(dir);
-	const { ok, problems } = await validateExtension(root);
+	const { ok, problems, warnings } = await validateExtension(root);
+	for (const warning of warnings) io.stdout(`warning ${root}: ${warning}\n`);
 	if (ok) {
 		io.stdout(`${root}: ok\n`);
 		return 0;
@@ -4261,6 +6693,50 @@ const runValidate = async (dir, io) => {
 	for (const problem of problems) io.stderr(`error ${root}: ${problem}\n`);
 	return 1;
 };
+const runLint = async (parsed, io) => {
+	try {
+		const findings = await lintProject({
+			root: parsed.dir,
+			...parsed.built === void 0 ? {} : { built: parsed.built }
+		});
+		for (const finding of findings) io.stdout(`${formatLintFinding(finding)}\n`);
+		return lintHasErrors(findings) ? 1 : 0;
+	} catch (error) {
+		if (error instanceof CatalogUsageError) {
+			io.stderr(`error ${error.subject}: ${error.message}\n`);
+			return 2;
+		}
+		return reportBuildError(io, error);
+	}
+};
+const runDevCommand = async (parsed, io, deps) => {
+	const root = path.resolve(parsed.dir);
+	try {
+		return await runDev({
+			root,
+			...parsed.app === void 0 ? {} : { app: parsed.app }
+		}, io, deps.dev ?? systemDeps(deps.env ?? process.env), async () => {
+			const handle = await watchExtension({
+				root,
+				logger: {
+					info: (message) => io.stdout(`${message}\n`),
+					error: (message) => io.stderr(`${message}\n`)
+				}
+			});
+			return {
+				outDir: path.join(root, DEFAULT_OUT_DIR),
+				summary: summary(handle.result).trimEnd(),
+				close: handle.close
+			};
+		}, deps.waitForExit ?? waitForSignal);
+	} catch (error) {
+		if (error instanceof CatalogUsageError) {
+			io.stderr(`error ${error.subject}: ${error.message}\n`);
+			return 2;
+		}
+		return reportBuildError(io, error);
+	}
+};
 const runTypes = async (dir, io) => {
 	try {
 		const root = path.resolve(dir);
@@ -4272,7 +6748,7 @@ const runTypes = async (dir, io) => {
 		return reportBuildError(io, error);
 	}
 };
-/** `dolphy-ext build|types|validate|catalog`; `argv` is without `node` and the script name. */
+/** `dolphy-ext build|types|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) {
@@ -4292,6 +6768,8 @@ const runCli = async (argv, io, deps = {}) => {
 		return runCatalog(catalog, 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);
 };