@dolphy-app/extension-tools 0.2.0 → 0.3.0

package/dist/cli/main.js

@@ -1,14 +1,147 @@
 #!/usr/bin/env node
 import { builtinModules } from "node:module";
 import path from "node:path";
+import { 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 { build } from "vite";
-import { tmpdir } from "node:os";
 import { createHash } from "node:crypto";
+import { build, createLogger, parseAst } from "vite";
+import { tmpdir } from "node:os";
 
+//#region packages/extension-api/src/index.ts
+const EXTENSION_ID_PATTERN = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
+/** GitHub login of the extension author (`author` in the manifest and catalog). */
+const GITHUB_LOGIN_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$/;
+/** Capabilities an extension declares in its manifest; none without a declaration. */
+const EXTENSION_PERMISSIONS = [
+	"library.read",
+	"process.spawn",
+	"worker.threads",
+	"native.addons",
+	"network",
+	"learning.events"
+];
+/** Platforms the extension can run on (`process.platform`). */
+const EXTENSION_PLATFORMS = [
+	"darwin",
+	"linux",
+	"win32"
+];
+/** Closed vocabulary of extension tags (`extension.json` → `tags`, up to 5 unique values). */
+const EXTENSION_TAGS = [
+	"learning",
+	"language",
+	"content",
+	"theme",
+	"interface",
+	"productivity",
+	"developer"
+];
+const ELEMENT_NAME_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/;
+/** Learning events an extension with the `learning.events` permission can subscribe to. */
+const LEARNING_EVENT_NAMES = [
+	"session.started",
+	"session.finished",
+	"attempt.closed"
+];
+/** Identifiers of built-in themes: extensions cannot take them. */
+const BUILTIN_THEME_IDS = [
+	"system",
+	"light",
+	"dark"
+];
+/** Allowed keys of `ThemeContribution.colors`. */
+const THEME_COLOR_KEYS = [
+	"background",
+	"surface",
+	"surface-bright",
+	"surface-light",
+	"surface-variant",
+	"on-background",
+	"on-surface",
+	"on-surface-variant",
+	"primary",
+	"on-primary",
+	"secondary",
+	"on-secondary",
+	"error",
+	"on-error",
+	"warning",
+	"on-warning",
+	"success",
+	"on-success",
+	"info",
+	"on-info",
+	"hero-start",
+	"hero-end",
+	"hero-contrast"
+];
+/** Allowed keys of `ThemeContribution.variables`. */
+const THEME_VARIABLE_KEYS = [
+	"border-color",
+	"border-opacity",
+	"medium-emphasis-opacity",
+	"high-emphasis-opacity",
+	"disabled-opacity"
+];
+const DEFAULT_MARKDOWN_RENDERER = "./markdown.mjs";
+const DEFAULT_PANEL = "./panel.mjs";
+/**
+* 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`).
+*/
+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))$/;
+/** Limits on commands and panels (R1, R3); they match those checked by the manifest, host, and engine. */
+const EXTENSION_COMMAND_LIMITS = Object.freeze({
+	/** Commands per extension. */
+	commands: 64,
+	/** Panels per extension. */
+	panels: 8,
+	titleLength: 60,
+	categoryLength: 40,
+	descriptionLength: 200,
+	/** `JSON.stringify(args).length` at the engine boundary. */
+	argsChars: 2e5,
+	/** JSON text of the result in UTF-8 bytes. */
+	resultBytes: 65536,
+	/** Length of `notify` in UTF-16 code units. */
+	notifyChars: 500,
+	/** Handler budget, ms. */
+	handlerMs: 1e4
+});
+const DEFAULT_MAIN = "./main.mjs";
+const DEFAULT_RENDERER = "./view.mjs";
+/** Default element tag: `dolphy.sql` → `dolphy-sql-answer`. */
+const defaultElementName = (id) => `${id.replaceAll(".", "-")}-answer`;
+/** Extension storage limits (R2); they match the engine's limits, which enforces them. */
+const EXTENSION_STORAGE_LIMITS = Object.freeze({
+	/** Key length in UTF-16 code units. */
+	keyLength: 128,
+	/** JSON text of a single value in UTF-8 bytes. */
+	valueBytes: 65536,
+	/** Number of keys. */
+	keys: 256,
+	/** Sum of JSON texts of all values in UTF-8 bytes. */
+	totalBytes: 1048576
+});
+
+//#endregion
 //#region packages/extension-host/src/protocol.ts
+const eventParams = z.strictObject({
+	extensionId: z.string(),
+	name: z.enum(LEARNING_EVENT_NAMES),
+	payload: z.record(z.string(), z.unknown()),
+	isolated: z.boolean()
+});
+const commandParams = z.strictObject({
+	extensionId: z.string(),
+	commandId: z.string(),
+	args: z.unknown().optional(),
+	isolated: z.boolean()
+});
 const typed = {
 	type: z.string(),
 	exerciseId: z.string(),
@@ -52,8 +185,105 @@ const extRequestSchema = z.discriminatedUnion("method", [
 			gaveUp: z.boolean(),
 			isolated: z.boolean()
 		})
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("deliverEvent"),
+		params: eventParams
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("invokeCommand"),
+		params: commandParams
+	})
+]);
+const settingValue = z.union([
+	z.boolean(),
+	z.string(),
+	z.number()
+]);
+const settingChangedSchema = z.strictObject({
+	method: z.literal("settingChanged"),
+	params: z.strictObject({
+		extensionId: z.string(),
+		id: z.string(),
+		value: settingValue
+	})
+});
+const hostKey = z.strictObject({
+	extensionId: z.string(),
+	key: z.string()
+});
+const hostOwner = z.strictObject({ extensionId: z.string() });
+/** Запрос хоста к движку: форму проверяет получатель, значение хранилища — сервис движка. */
+const hostRequestSchema = z.discriminatedUnion("method", [
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("storage.get"),
+		params: hostKey
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("storage.set"),
+		params: z.strictObject({
+			extensionId: z.string(),
+			key: z.string(),
+			value: z.unknown()
+		})
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("storage.delete"),
+		params: hostKey
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("storage.keys"),
+		params: hostOwner
+	}),
+	z.strictObject({
+		id: z.string(),
+		method: z.literal("settings.all"),
+		params: hostOwner
 	})
 ]);
+const hostResponseSchema = z.union([z.strictObject({
+	id: z.string(),
+	ok: z.literal(true),
+	result: z.unknown().optional()
+}), z.strictObject({
+	id: z.string(),
+	ok: z.literal(false),
+	error: z.strictObject({
+		code: z.string(),
+		message: z.string(),
+		details: z.record(z.string(), z.unknown()).optional()
+	})
+})]);
+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);
+};
+/** Набор приходит от движка того же приложения, поэтому проверяется форма, а не каждое поле. */
+const replaceExtensionsSchema = z.strictObject({
+	id: z.string(),
+	method: z.literal("replaceExtensions"),
+	params: z.strictObject({ extensions: z.array(z.custom(isResolvedExtension)) })
+});
+/** Всё, что хост расширений принимает по каналу. */
+const extMessageSchema = z.union([
+	extRequestSchema,
+	replaceExtensionsSchema,
+	settingChangedSchema,
+	hostResponseSchema
+]);
+/** Всё, что ограниченный процесс принимает от хоста (набор расширений ему не шлют). */
+const childInboundSchema = z.union([
+	extRequestSchema,
+	settingChangedSchema,
+	hostResponseSchema
+]);
 /** Результат правила оценки: целое 1–5 или `null`. */
 const gradeValueSchema = z.union([z.literal([
 	1,
@@ -84,72 +314,291 @@ const gradeResultSchema = z.discriminatedUnion("outcome", [
 		data: z.unknown().optional()
 	})
 ]);
+const isJsonValue = (value, depth = 0) => {
+	if (depth > 64) return false;
+	if (value === null || typeof value === "string") return true;
+	if (typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every((item) => isJsonValue(item, depth + 1));
+	if (typeof value !== "object") return false;
+	return Object.values(value).every((item) => isJsonValue(item, depth + 1));
+};
+const fitsResult = (value) => isJsonValue(value) && new TextEncoder().encode(JSON.stringify(value)).length <= EXTENSION_COMMAND_LIMITS.resultBytes;
+const resultJson = z.custom(fitsResult, "must be JSON up to 64 KiB");
+/**
+* Результат команды на границе хоста и движка. Ограниченный процесс не
+* доверен, поэтому форму и потолки проверяет и получатель, а не только
+* `normalizeCommandResult` в рантайме.
+*/
+const commandOutcomeSchema = z.discriminatedUnion("kind", [
+	z.strictObject({ kind: z.literal("none") }),
+	z.strictObject({
+		kind: z.literal("notify"),
+		text: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.notifyChars)
+	}),
+	z.strictObject({
+		kind: z.literal("openPanel"),
+		panelId: z.string().min(1).max(128),
+		props: resultJson.optional()
+	}),
+	z.strictObject({
+		kind: z.literal("data"),
+		value: resultJson
+	})
+]);
 
 //#endregion
-//#region packages/extension-api/src/index.ts
-const EXTENSION_ID_PATTERN = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
-/** GitHub-логин автора расширения (`author` в манифесте и каталоге). */
-const GITHUB_LOGIN_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$/;
-/** Возможности, которые расширение объявляет в манифесте; без объявления — ни одной. */
-const EXTENSION_PERMISSIONS = [
-	"library.read",
-	"process.spawn",
-	"worker.threads",
-	"native.addons",
-	"network"
-];
-/** Платформы, на которых расширение может работать (`process.platform`). */
-const EXTENSION_PLATFORMS = [
-	"darwin",
-	"linux",
-	"win32"
-];
-const ELEMENT_NAME_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/;
-/** Идентификаторы встроенных тем: расширения не могут их занять. */
-const BUILTIN_THEME_IDS = [
-	"system",
-	"light",
-	"dark"
+//#region packages/extension-catalog/src/assets.ts
+/**
+* Asset types of a catalog version: file extensions, size ceilings, MIME types, and
+* 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 = [
+	"json",
+	"js",
+	"mjs",
+	"md",
+	"txt"
 ];
-/** Допустимые ключи `ThemeContribution.colors`. */
-const THEME_COLOR_KEYS = [
-	"background",
-	"surface",
-	"surface-bright",
-	"surface-light",
-	"surface-variant",
-	"on-background",
-	"on-surface",
-	"on-surface-variant",
-	"primary",
-	"on-primary",
-	"secondary",
-	"on-secondary",
-	"error",
-	"on-error",
-	"warning",
-	"on-warning",
-	"success",
-	"on-success",
-	"info",
-	"on-info",
-	"hero-start",
-	"hero-end",
-	"hero-contrast"
+/** Style sheets, images and fonts an extension may ship. */
+const ASSET_EXTENSIONS = [
+	"css",
+	"svg",
+	"png",
+	"webp",
+	"jpg",
+	"jpeg",
+	"woff2"
 ];
-/** Допустимые ключи `ThemeContribution.variables`. */
-const THEME_VARIABLE_KEYS = [
-	"border-color",
-	"border-opacity",
-	"medium-emphasis-opacity",
-	"high-emphasis-opacity",
-	"disabled-opacity"
+/** Every extension a file of a version may have in the full index. */
+const CATALOG_FILE_EXTENSIONS = [...LEGACY_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 = {
+	css: 256 * KIB,
+	svg: 64 * KIB,
+	image: 512 * KIB,
+	woff2: 1024 * KIB,
+	icon: 16 * KIB
+};
+/** Largest side of a raster image in pixels. */
+const MAX_IMAGE_SIDE = 4096;
+/** Icon side range in pixels; the icon is square. */
+const ICON_MIN_SIDE = 64;
+const ICON_MAX_SIDE = 512;
+/** Extension of the last path segment, as written (case-sensitive); `null` — none. */
+const extensionOf = (path) => {
+	const name = path.slice(path.lastIndexOf("/") + 1);
+	const dot = name.lastIndexOf(".");
+	return dot > 0 ? name.slice(dot + 1) : null;
+};
+const isAssetExtension = (value) => ASSET_EXTENSIONS.includes(value);
+/** The asset type of a path (lowercase extension only), or `null` for a non-asset file. */
+const assetExtensionOf = (path) => {
+	const extension = extensionOf(path);
+	return extension !== null && isAssetExtension(extension) ? extension : null;
+};
+const isBinaryAsset = (extension) => extension !== "css" && extension !== "svg";
+/** Ceiling in bytes for one file of the asset type. */
+const assetSizeLimit = (extension) => {
+	if (extension === "css") return ASSET_LIMITS.css;
+	if (extension === "svg") return ASSET_LIMITS.svg;
+	return extension === "woff2" ? ASSET_LIMITS.woff2 : ASSET_LIMITS.image;
+};
+/** Problem text when a file of the given path exceeds its per-type ceiling; `null` — within limits. */
+const sizeProblem = (path, size) => {
+	const extension = assetExtensionOf(path);
+	if (extension === null) return null;
+	const limit = assetSizeLimit(extension);
+	return size > limit ? `${path}: ${size} bytes exceed the limit of ${limit} for .${extension}` : null;
+};
+const fail = (reason) => ({
+	ok: false,
+	reason
+});
+const okWith = (size) => ({
+	ok: true,
+	size
+});
+const ascii = (bytes, offset, length) => {
+	let text = "";
+	for (let i = offset; i < offset + length && i < bytes.length; i++) text += String.fromCharCode(bytes[i] ?? 0);
+	return text;
+};
+const view = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
 ];
-const DEFAULT_MARKDOWN_RENDERER = "./markdown.mjs";
-const DEFAULT_MAIN = "./main.mjs";
-const DEFAULT_RENDERER = "./view.mjs";
-/** Тег элемента по умолчанию: `dolphy.sql` → `dolphy-sql-answer`. */
-const defaultElementName = (id) => `${id.replaceAll(".", "-")}-answer`;
+let crcTable = null;
+const crc32 = (bytes, start, end) => {
+	if (crcTable === null) {
+		crcTable = /* @__PURE__ */ new Uint32Array(256);
+		for (let n = 0; n < 256; n++) {
+			let c = n;
+			for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+			crcTable[n] = c >>> 0;
+		}
+	}
+	let crc = 4294967295;
+	for (let i = start; i < end; i++) crc = (crcTable[(crc ^ (bytes[i] ?? 0)) & 255] ?? 0) ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+};
+const inspectPng = (bytes) => {
+	if (bytes.length < 8 || PNG_SIGNATURE.some((value, index) => bytes[index] !== value)) return fail("not a PNG file (signature mismatch)");
+	const data = view(bytes);
+	let offset = 8;
+	let dimensions = null;
+	let first = true;
+	let ended = false;
+	while (offset + 12 <= bytes.length) {
+		const length = data.getUint32(offset);
+		const type = ascii(bytes, offset + 4, 4);
+		const end = offset + 12 + length;
+		if (end > bytes.length) return fail("PNG chunk runs past the end of file");
+		if (first && type !== "IHDR") return fail("PNG does not start with IHDR");
+		if (type === "IHDR") {
+			if (!first || length !== 13) return fail("PNG has a malformed IHDR");
+			if (data.getUint32(end - 4) !== crc32(bytes, offset + 4, end - 4)) return fail("PNG IHDR checksum mismatch");
+			dimensions = {
+				width: data.getUint32(offset + 8),
+				height: data.getUint32(offset + 12)
+			};
+		}
+		if (type === "acTL") return fail("animated PNG is not accepted");
+		first = false;
+		offset = end;
+		if (type === "IEND") {
+			ended = true;
+			break;
+		}
+	}
+	if (!ended || dimensions === null) return fail("PNG is truncated (no IEND)");
+	if (offset !== bytes.length) return fail("PNG has data after IEND");
+	return okWith(dimensions);
+};
+const isStandaloneMarker = (marker) => marker === 1 || marker >= 208 && marker <= 216;
+const isStartOfFrame = (marker) => marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204;
+const inspectJpeg = (bytes) => {
+	if (bytes[0] !== 255 || bytes[1] !== 216 || bytes[2] !== 255) return fail("not a JPEG file (signature mismatch)");
+	const data = view(bytes);
+	let offset = 2;
+	while (offset + 4 <= bytes.length) {
+		if (bytes[offset] !== 255) return fail("JPEG segment is malformed");
+		const marker = bytes[offset + 1] ?? 0;
+		if (marker === 255) {
+			offset += 1;
+			continue;
+		}
+		if (isStandaloneMarker(marker)) {
+			offset += 2;
+			continue;
+		}
+		const length = data.getUint16(offset + 2);
+		if (length < 2 || offset + 2 + length > bytes.length) return fail("JPEG segment runs past the end of file");
+		if (isStartOfFrame(marker)) {
+			if (length < 8) return fail("JPEG frame header is malformed");
+			return okWith({
+				height: data.getUint16(offset + 5),
+				width: data.getUint16(offset + 7)
+			});
+		}
+		if (marker === 218) break;
+		offset += 2 + length;
+	}
+	return fail("JPEG has no frame header");
+};
+const littleEndian24 = (bytes, offset) => (bytes[offset] ?? 0) | (bytes[offset + 1] ?? 0) << 8 | (bytes[offset + 2] ?? 0) << 16;
+const inspectWebp = (bytes) => {
+	if (bytes.length < 21 || ascii(bytes, 0, 4) !== "RIFF" || ascii(bytes, 8, 4) !== "WEBP") return fail("not a WebP file (signature mismatch)");
+	const data = view(bytes);
+	if (data.getUint32(4, true) + 8 !== bytes.length) return fail("WebP RIFF size does not match the file size");
+	const chunk = ascii(bytes, 12, 4);
+	const needed = chunk === "VP8L" ? 25 : 30;
+	if (bytes.length < needed) return fail("WebP header is truncated");
+	if (chunk === "VP8X") {
+		if ((bytes[20] ?? 0) & 2) return fail("animated WebP is not accepted");
+		return okWith({
+			width: littleEndian24(bytes, 24) + 1,
+			height: littleEndian24(bytes, 27) + 1
+		});
+	}
+	if (chunk === "VP8L") {
+		if (bytes[20] !== 47) return fail("WebP lossless header is malformed");
+		const bits = data.getUint32(21, true);
+		return okWith({
+			width: (bits & 16383) + 1,
+			height: (bits >>> 14 & 16383) + 1
+		});
+	}
+	if (chunk === "VP8 ") {
+		if (bytes[23] !== 157 || bytes[24] !== 1 || bytes[25] !== 42) return fail("WebP lossy header is malformed");
+		return okWith({
+			width: data.getUint16(26, true) & 16383,
+			height: data.getUint16(28, true) & 16383
+		});
+	}
+	return fail("WebP has an unknown first chunk");
+};
+const WOFF2_HEADER_BYTES = 48;
+const inspectWoff2 = (bytes) => {
+	if (bytes.length < WOFF2_HEADER_BYTES || ascii(bytes, 0, 4) !== "wOF2") return fail("not a WOFF2 file (signature mismatch)");
+	return view(bytes).getUint32(8) === bytes.length ? okWith(null) : fail("WOFF2 length field does not match the file size");
+};
+/**
+* Checks the signature and structure of a binary asset and reads the pixel size of
+* images. A declared size above `MAX_IMAGE_SIDE` is a failure: the header is not trusted.
+*/
+const inspectBinaryAsset = (extension, bytes) => {
+	let result;
+	if (extension === "png") result = inspectPng(bytes);
+	else if (extension === "webp") result = inspectWebp(bytes);
+	else if (extension === "woff2") result = inspectWoff2(bytes);
+	else result = inspectJpeg(bytes);
+	if (!result.ok || result.size === null) return result;
+	const { width, height } = result.size;
+	if (width < 1 || height < 1) return fail("image has an empty size");
+	if (width > 4096 || height > 4096) return fail(`image is ${width}x${height}, the limit is ${MAX_IMAGE_SIDE}x${MAX_IMAGE_SIDE}`);
+	return result;
+};
+const isIconExtension = (value) => value === "png" || value === "webp";
+/**
+* Problem with a manifest icon: format, size in bytes, geometry. `null` — fits.
+* `path` is the icon path from the manifest, `bytes` the file contents.
+*/
+const iconProblem = (path, bytes) => {
+	const extension = extensionOf(path);
+	if (!isIconExtension(extension)) return `icon '${path}' must be a .png or .webp file`;
+	if (bytes.length > ASSET_LIMITS.icon) return `icon '${path}' is ${bytes.length} bytes, the limit is ${ASSET_LIMITS.icon}`;
+	const inspected = inspectBinaryAsset(extension, bytes);
+	if (!inspected.ok) return `icon '${path}': ${inspected.reason}`;
+	const { width, height } = inspected.size ?? {
+		width: 0,
+		height: 0
+	};
+	if (width !== height) return `icon '${path}' must be square, it is ${width}x${height}`;
+	if (width < 64 || width > 512) return `icon '${path}' must be ${64} to ${512} pixels, it is ${width}`;
+	return null;
+};
+/** `data:image/png|webp;base64,…` — the icon as the index and the window carry it. */
+const iconDataUri = (path, bytes) => {
+	const extension = extensionOf(path) === "webp" ? "webp" : "png";
+	let binary = "";
+	const chunk = 32768;
+	for (let i = 0; i < bytes.length; i += chunk) binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+	return `data:image/${extension};base64,${btoa(binary)}`;
+};
+/** Longest `iconDataUri` the schema accepts: the base64 of `ASSET_LIMITS.icon` bytes plus the prefix. */
+const MAX_ICON_URI_LENGTH = 23 + Math.ceil(ASSET_LIMITS.icon / 3) * 4;
+const ICON_URI_PATTERN = /^data:image\/(?:png|webp);base64,[A-Za-z0-9+/]+={0,2}$/;
 
 //#endregion
 //#region packages/extension-catalog/src/errors.ts
@@ -244,30 +693,28 @@ 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
-const CATALOG_SCHEMA_VERSION = 1;
+/** 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. */
+const CATALOG_SCHEMA_VERSION = 2;
 const MAX_VERSIONS = 5;
 const MAX_FILES = 50;
 const MAX_TOTAL_BYTES = 1e7;
-const MAX_PATH_LENGTH = 200;
-const CATALOG_FILE_EXTENSIONS = [
-	"json",
-	"js",
-	"mjs",
-	"md",
-	"txt"
+/** 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`). */
+const TITLED_POINTS = [
+	"themes",
+	"gradePolicies",
+	"settings",
+	"commands",
+	"panels"
 ];
-const FILE_EXTENSIONS = new Set(CATALOG_FILE_EXTENSIONS);
+const MAX_PATH_LENGTH = 200;
 const SHA256 = /^[0-9a-f]{64}$/;
 /** Допустимые символы сегмента пути: без `:` (потоки NTFS), пробелов и управляющих символов. */
 const SEGMENT = /^[A-Za-z0-9_-][A-Za-z0-9._-]*$/;
@@ -277,129 +724,306 @@ 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);
-/** Путь файла версии: безопасные сегменты и расширение из `FILE_EXTENSIONS`. */
-const isSafeCatalogPath = (value) => {
+/** Путь файла версии: безопасные сегменты и расширение из `extensions`. */
+const isSafePathWith = (value, extensions) => {
 	if (value.length > MAX_PATH_LENGTH) return false;
-	const segments = value.split("/");
-	if (!segments.every(isSafeSegment)) return false;
-	const name = segments[segments.length - 1] ?? "";
-	const dot = name.lastIndexOf(".");
-	return dot > 0 && FILE_EXTENSIONS.has(name.slice(dot + 1));
+	if (!value.split("/").every(isSafeSegment)) return false;
+	const extension = extensionOf(value);
+	return extension !== null && extensions.includes(extension);
 };
-const filePath = z.string().refine(isSafeCatalogPath, "must be a safe relative path");
+/** 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>/`).
 * Абсолютный адрес не допускается: файлы версии по построению лежат на origin индекса,
 * а локальный каталог разработчика и e2e не требуют https.
 */
 const baseUrl = z.string().max(MAX_PATH_LENGTH).refine((value) => value.endsWith("/") && value.slice(0, -1).split("/").every(isSafeSegment), "must be a relative directory path ending with /");
-const fileSchema = z.strictObject({
-	path: filePath,
+const extensionId$1 = z.string().max(64).regex(EXTENSION_ID_PATTERN, "invalid extension id");
+const descendingUnique = (versions, ctx) => {
+	for (let i = 1; i < versions.length; i++) {
+		const previous = versions[i - 1]?.version ?? "";
+		const current = versions[i]?.version ?? "";
+		if (previous === current) ctx.addIssue({
+			code: "custom",
+			path: [i, "version"],
+			message: `duplicate version '${current}'`
+		});
+		else if (isSemver(previous) && isSemver(current)) {
+			if (compareSemver(previous, current) < 0) ctx.addIssue({
+				code: "custom",
+				path: [i, "version"],
+				message: "versions must be sorted newest first"
+			});
+		}
+	}
+};
+const rangeText = z.string().superRefine((value, ctx) => {
+	try {
+		parseRange(value);
+	} catch (error) {
+		if (!(error instanceof CatalogFormatError)) throw error;
+		ctx.addIssue({
+			code: "custom",
+			message: "invalid version range"
+		});
+	}
+});
+const revokedSchema = z.strictObject({
+	id: extensionId$1,
+	versions: rangeText,
+	reason: z.string().min(1).max(300)
+});
+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"),
 	size: z.number().int().min(0).max(MAX_TOTAL_BYTES),
 	sha256: z.string().regex(SHA256, "must be lowercase hex sha256")
+}).superRefine((file, ctx) => {
+	const problem = sizeProblem(file.path, file.size);
+	if (problem !== null) ctx.addIssue({
+		code: "custom",
+		message: problem
+	});
+});
+const filesSchemaOf = (profile) => z.array(fileSchemaOf(profile)).max(profile.maxFiles).superRefine((files, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	files.forEach((file, index) => {
+		const key = file.path.toLowerCase();
+		if (seen.has(key)) ctx.addIssue({
+			code: "custom",
+			path: [index, "path"],
+			message: `duplicate path '${file.path}'`
+		});
+		seen.add(key);
+	});
+	files.forEach((file, index) => {
+		const segments = file.path.toLowerCase().split("/");
+		for (let depth = 1; depth < segments.length; depth++) if (seen.has(segments.slice(0, depth).join("/"))) {
+			ctx.addIssue({
+				code: "custom",
+				path: [index, "path"],
+				message: `'${file.path}' lies inside a file`
+			});
+			break;
+		}
+	});
+	if (!files.some((file) => file.path === "extension.json")) ctx.addIssue({
+		code: "custom",
+		message: "extension.json is required"
+	});
+	const total = files.reduce((sum, file) => sum + file.size, 0);
+	if (total > 1e7) ctx.addIssue({
+		code: "custom",
+		message: `total size ${total} exceeds ${MAX_TOTAL_BYTES}`
+	});
 });
-const extensionId$1 = z.string().max(64).regex(EXTENSION_ID_PATTERN, "invalid extension id");
-const versionSchema = z.strictObject({
+const strictTags = z.array(z.enum(EXTENSION_TAGS)).max(5).superRefine((tags, ctx) => {
+	tags.forEach((tag, index) => {
+		if (tags.indexOf(tag) !== index) ctx.addIssue({
+			code: "custom",
+			path: [index],
+			message: `duplicate tag '${tag}'`
+		});
+	});
+});
+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 versionSchemaOf = (profile) => object(profile, {
 	version: semver,
 	apiVersion: z.number().int().min(1),
 	minAppVersion: semver.nullable(),
 	permissions: z.array(z.enum(EXTENSION_PERMISSIONS)),
 	publishedAt: timestamp,
 	baseUrl,
-	files: z.array(fileSchema).max(50).superRefine((files, ctx) => {
-		const seen = /* @__PURE__ */ new Set();
-		files.forEach((file, index) => {
-			const key = file.path.toLowerCase();
-			if (seen.has(key)) ctx.addIssue({
-				code: "custom",
-				path: [index, "path"],
-				message: `duplicate path '${file.path}'`
-			});
-			seen.add(key);
-		});
-		files.forEach((file, index) => {
-			const segments = file.path.toLowerCase().split("/");
-			for (let depth = 1; depth < segments.length; depth++) if (seen.has(segments.slice(0, depth).join("/"))) {
-				ctx.addIssue({
-					code: "custom",
-					path: [index, "path"],
-					message: `'${file.path}' lies inside a file`
-				});
-				break;
-			}
-		});
-		if (!files.some((file) => file.path === "extension.json")) ctx.addIssue({
-			code: "custom",
-			message: "extension.json is required"
-		});
-		const total = files.reduce((sum, file) => sum + file.size, 0);
-		if (total > 1e7) ctx.addIssue({
-			code: "custom",
-			message: `total size ${total} exceeds ${MAX_TOTAL_BYTES}`
-		});
-	})
+	files: filesSchemaOf(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"
+	});
 });
-const contributesSchema$1 = z.strictObject({
+const contributesSchemaOf = (profile) => object(profile, {
 	exerciseTypes: z.array(z.string()),
 	themes: z.array(z.string()),
 	markdownRenderers: z.array(z.string()),
-	gradePolicies: z.array(z.string())
+	gradePolicies: z.array(z.string()),
+	settings: z.array(z.string()).optional(),
+	events: z.array(z.string()).optional(),
+	commands: z.array(z.string()).optional(),
+	panels: z.array(z.string()).optional()
 });
-const descendingUnique = (versions, ctx) => {
-	for (let i = 1; i < versions.length; i++) {
-		const previous = versions[i - 1]?.version ?? "";
-		const current = versions[i]?.version ?? "";
-		if (previous === current) ctx.addIssue({
-			code: "custom",
-			path: [i, "version"],
-			message: `duplicate version '${current}'`
-		});
-		else if (isSemver(previous) && isSemver(current)) {
-			if (compareSemver(previous, current) < 0) ctx.addIssue({
-				code: "custom",
-				path: [i, "version"],
-				message: "versions must be sorted newest first"
-			});
-		}
-	}
+const titleMap = z.record(extensionId$1, z.string().min(1).max(MAX_TITLE_LENGTH));
+/** Titles of the contributions by point; an unreadable map is dropped by the tolerant reader, the entry stays. */
+const titlesSchemaOf = (profile) => {
+	const schema = object(profile, Object.fromEntries(TITLED_POINTS.map((point) => [point, titleMap.optional()]))).optional();
+	return profile.strict ? schema : schema.catch(void 0).optional();
 };
-const entrySchema = z.strictObject({
+const entryHeadOf = (profile) => ({
 	id: extensionId$1,
 	name: z.string().min(1).max(80),
 	description: z.string().min(1).max(500),
 	author: z.string().regex(GITHUB_LOGIN_PATTERN, "must be a GitHub login"),
 	source: httpsUrl,
 	platforms: z.array(z.enum(EXTENSION_PLATFORMS)),
-	contributes: contributesSchema$1,
-	versions: z.array(versionSchema).min(1).max(5).superRefine(descendingUnique)
+	contributes: contributesSchemaOf(profile),
+	titles: titlesSchemaOf(profile)
 });
-const rangeText = z.string().superRefine((value, ctx) => {
-	try {
-		parseRange(value);
-	} catch (error) {
-		if (!(error instanceof CatalogFormatError)) throw error;
+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",
-			message: "invalid version range"
+			path: ["titles"],
+			message: "titles is not part of this index format"
+		});
+		return;
+	}
+	if (!profile.strict) return;
+	for (const point of TITLED_POINTS) {
+		const known = new Set(entry.contributes[point] ?? []);
+		for (const id of Object.keys(entry.titles[point] ?? {})) if (!known.has(id)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"titles",
+				point,
+				id
+			],
+			message: `title for '${id}', which is not in contributes.${point}`
 		});
 	}
 });
-const revokedSchema = z.strictObject({
-	id: extensionId$1,
-	versions: rangeText,
-	reason: z.string().min(1).max(300)
-});
-const indexSchema = z.strictObject({
-	schemaVersion: z.literal(1),
+const indexSchemaOf = (profile) => object(profile, {
+	schemaVersion: z.literal(profile.schemaVersion),
 	generatedAt: timestamp,
-	extensions: z.array(entrySchema),
+	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
+};
+/** Reader of the app: the limits of the full format, unknown keys dropped. */
+const TOLERANT_PROFILE = {
+	...FULL_PROFILE,
+	strict: false
+};
+/** `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`.
+*/
 const parseIndex = (raw) => {
-	const parsed = indexSchema.safeParse(raw);
+	const parsed = (isLegacyIndex(raw) ? legacyIndexSchema : indexSchema).safeParse(raw);
 	if (parsed.success) return parsed.data;
-	throw new CatalogFormatError(parsed.error.issues.map((issue) => `${issue.path.join(".") || "/"}: ${issue.message}`));
+	throw new CatalogFormatError(describeIssues(parsed.error));
 };
+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));
+/**
+* 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.
+*/
+const legacySubset = (index) => ({
+	...index,
+	schemaVersion: 1,
+	extensions: index.extensions.filter(isLegacyEntry).map((entry) => {
+		const legacy = {
+			...entry,
+			versions: entry.versions.filter(isLegacyVersion)
+		};
+		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";
 
 //#endregion
 //#region packages/extension-host/src/points/support.ts
@@ -409,7 +1033,9 @@ const safePath = (extensions) => z.string().refine(isSafeRelativePath, "must be
 const extensionId = z.string().max(64).regex(EXTENSION_ID_PATTERN, "invalid extension id");
 /** Пути с нарушением правила «`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}.'`]);
-const isFile = async (file) => (await stat(file).catch(() => null))?.isFile() === true;
+/** Повторы значений в списке `path` (путь до массива, `field` — имя поля записи). */
+const duplicateIssues = (path, field, values) => values.flatMap((value, index) => values.indexOf(value) === index ? [] : [`${path}.${index}.${field}: duplicate ${field} '${value}'`]);
+const isFile$1 = async (file) => (await stat(file).catch(() => null))?.isFile() === true;
 /** Путь внутри каталога расширения; выход за каталог — ошибка. */
 const inside = (dir, relative) => {
 	const resolved = path.resolve(dir, relative);
@@ -421,7 +1047,7 @@ const defaultNote = (value, fallback) => value === fallback ? " (default)" : "";
 /** Проверяет, что файл модуля существует (если проверка включена), и даёт адрес. */
 const resolveModuleUrl = async (extensionId, dir, file, fallback, verifyFiles, label) => {
 	const absolute = inside(dir, file);
-	if (verifyFiles && !await isFile(absolute)) throw new Error(`${label} '${file}'${defaultNote(file, fallback)} is not a file`);
+	if (verifyFiles && !await isFile$1(absolute)) throw new Error(`${label} '${file}'${defaultNote(file, fallback)} is not a file`);
 	return rendererUrlOf(extensionId, file);
 };
 const deepFreeze = (value) => {
@@ -457,6 +1083,43 @@ const resolveSchema = async (ajv, dir, source, label) => {
 	return parsed;
 };
 
+//#endregion
+//#region packages/extension-host/src/points/commands.ts
+const { commands: MAX_COMMANDS } = EXTENSION_COMMAND_LIMITS;
+const commands = {
+	key: "commands",
+	needsMain: true,
+	schema: z.strictObject({
+		id: extensionId,
+		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength),
+		description: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.descriptionLength).optional(),
+		category: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.categoryLength).optional(),
+		keybinding: z.string().regex(KEYBINDING_PATTERN, "must look like Mod+Shift+L").optional(),
+		palette: z.boolean().optional()
+	}),
+	normalize: (entries) => entries.map((entry) => ({
+		...entry,
+		palette: entry.palette ?? true
+	})),
+	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)
+		];
+	},
+	resolve: async (entries) => entries.map((entry) => ({
+		id: entry.id,
+		title: entry.title,
+		description: entry.description ?? null,
+		category: entry.category ?? null,
+		keybinding: entry.keybinding ?? null,
+		palette: entry.palette
+	})),
+	claims: (resolved) => resolved.map((command) => `command:${command.id}`)
+};
+
 //#endregion
 //#region packages/extension-host/src/points/exercise-types.ts
 const schemaField = z.union([safePath([".json"]), z.record(z.string(), z.unknown()).refine((value) => Object.keys(value).length > 0, "must not be empty")]);
@@ -495,6 +1158,18 @@ const exerciseTypes = {
 	claims: (resolved) => resolved.flatMap((type) => [`exerciseType:${type.id}`, `element:${type.element}`])
 };
 
+//#endregion
+//#region packages/extension-host/src/points/events.ts
+const events = {
+	key: "events",
+	needsMain: true,
+	schema: z.strictObject({ event: z.enum(LEARNING_EVENT_NAMES) }),
+	normalize: (entries) => entries,
+	check: (entries) => duplicateIssues("contributes.events", "event", entries.map(({ event }) => event)),
+	resolve: async (entries) => entries.map(({ event }) => ({ event })),
+	claims: () => []
+};
+
 //#endregion
 //#region packages/extension-host/src/points/grade-policies.ts
 const BUILTIN_POLICY_ID = "passAtN";
@@ -539,6 +1214,158 @@ const markdownRenderers = {
 	claims: (resolved) => resolved.map((entry) => `markdown:${entry.language}`)
 };
 
+//#endregion
+//#region packages/extension-host/src/points/panels.ts
+const { panels: MAX_PANELS } = EXTENSION_COMMAND_LIMITS;
+const panels = {
+	key: "panels",
+	needsMain: false,
+	schema: z.strictObject({
+		id: extensionId,
+		title: z.string().min(1).max(EXTENSION_COMMAND_LIMITS.titleLength),
+		module: safePath([".js", ".mjs"]).optional()
+	}),
+	normalize: (entries) => entries.map((entry) => ({
+		id: entry.id,
+		title: entry.title,
+		module: entry.module ?? "./panel.mjs"
+	})),
+	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)
+		];
+	},
+	resolve: async (entries, { dir, extensionId: owner, verifyFiles }) => {
+		const resolved = [];
+		for (const entry of entries) resolved.push({
+			id: entry.id,
+			title: entry.title,
+			rendererUrl: await resolveModuleUrl(owner, dir, entry.module, DEFAULT_PANEL, verifyFiles, "panel module")
+		});
+		return resolved;
+	},
+	claims: (resolved) => resolved.map((panel) => `panel:${panel.id}`)
+};
+
+//#endregion
+//#region packages/extension-host/src/points/settings.ts
+/** Потолок длины строкового значения: даже в UTF-8 (3 байта на единицу) остаётся в пределах 64 КиБ хранилища. */
+const MAX_STRING_LENGTH = 1e4;
+const MAX_OPTIONS = 64;
+const base = {
+	id: extensionId,
+	label: z.string().min(1).max(60),
+	description: z.string().min(1).max(500).optional()
+};
+const option = z.strictObject({
+	value: z.string().min(1).max(100),
+	label: z.string().min(1).max(60)
+});
+const schema = z.discriminatedUnion("type", [
+	z.strictObject({
+		...base,
+		type: z.literal("boolean"),
+		default: z.boolean()
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("string"),
+		default: z.string(),
+		maxLength: z.number().int().min(1).max(MAX_STRING_LENGTH).optional()
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("number"),
+		default: z.number(),
+		min: z.number().optional(),
+		max: z.number().optional(),
+		integer: z.boolean().optional()
+	}),
+	z.strictObject({
+		...base,
+		type: z.literal("enum"),
+		default: z.string(),
+		options: z.array(option).min(1).max(MAX_OPTIONS)
+	})
+]);
+/** Нарушения `default` и границ одного определения (путь — до поля). */
+const constraintIssues = (setting, at) => {
+	const issue = (field, message) => `${at}.${field}: ${message}`;
+	switch (setting.type) {
+		case "boolean": return [];
+		case "string": {
+			const limit = setting.maxLength ?? MAX_STRING_LENGTH;
+			return setting.default.length > limit ? [issue("default", `default is longer than ${limit} characters`)] : [];
+		}
+		case "number": {
+			const { min, max, integer = false } = setting;
+			const issues = [];
+			if (min !== void 0 && max !== void 0 && min > max) issues.push(issue("min", "min is greater than max"));
+			if (integer && !Number.isInteger(setting.default)) issues.push(issue("default", "default must be an integer"));
+			if (min !== void 0 && setting.default < min) issues.push(issue("default", `default is less than min ${min}`));
+			if (max !== void 0 && setting.default > max) issues.push(issue("default", `default is greater than max ${max}`));
+			return issues;
+		}
+		default: {
+			const values = setting.options.map(({ value }) => value);
+			return [...duplicateIssues(`${at}.options`, "value", values), ...values.includes(setting.default) ? [] : [issue("default", `default '${setting.default}' is not an option`)]];
+		}
+	}
+};
+const resolveSetting = (setting) => {
+	const common = {
+		id: setting.id,
+		label: setting.label,
+		description: setting.description ?? null
+	};
+	switch (setting.type) {
+		case "boolean": return {
+			...common,
+			type: "boolean",
+			default: setting.default
+		};
+		case "string": return {
+			...common,
+			type: "string",
+			default: setting.default,
+			maxLength: setting.maxLength ?? null
+		};
+		case "number": return {
+			...common,
+			type: "number",
+			default: setting.default,
+			min: setting.min ?? null,
+			max: setting.max ?? null,
+			integer: setting.integer ?? false
+		};
+		default: return {
+			...common,
+			type: "enum",
+			default: setting.default,
+			options: setting.options.map(({ value, label }) => ({
+				value,
+				label
+			}))
+		};
+	}
+};
+const settings = {
+	key: "settings",
+	needsMain: false,
+	schema,
+	normalize: (entries) => entries,
+	check: (entries, owner) => [
+		...idPrefixIssues("settings", entries.map(({ id }) => id), owner),
+		...duplicateIssues("contributes.settings", "id", entries.map(({ id }) => id)),
+		...entries.flatMap((entry, index) => constraintIssues(entry, `contributes.settings.${index}`))
+	],
+	resolve: async (entries) => entries.map(resolveSetting),
+	claims: (resolved) => resolved.map((setting) => `setting:${setting.id}`)
+};
+
 //#endregion
 //#region packages/extension-host/src/points/themes.ts
 const HEX_COLOR = /^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/;
@@ -584,7 +1411,11 @@ const CONTRIBUTION_POINTS = [
 	exerciseTypes,
 	themes,
 	markdownRenderers,
-	gradePolicies
+	gradePolicies,
+	settings,
+	events,
+	commands,
+	panels
 ];
 const POINT_KEYS = CONTRIBUTION_POINTS.map(({ key }) => key);
 
@@ -604,6 +1435,8 @@ const manifestSchema = z.strictObject({
 	author: z.string().regex(GITHUB_LOGIN_PATTERN, "must be a GitHub login").optional(),
 	platforms: z.array(z.enum(EXTENSION_PLATFORMS)).optional(),
 	minAppVersion: z.string().refine(isSemver, "minAppVersion must be semver x.y.z").optional(),
+	icon: safePath([".png", ".webp"]).optional(),
+	tags: z.array(z.enum(EXTENSION_TAGS, { error: `tag must be one of: ${EXTENSION_TAGS.join(", ")}` })).max(5, "at most 5 tags").optional(),
 	contributes: contributesSchema
 }).superRefine((manifest, ctx) => {
 	const { permissions = [], platforms = [] } = manifest;
@@ -621,6 +1454,19 @@ const manifestSchema = z.strictObject({
 			message: `duplicate permission '${permission}'`
 		});
 	});
+	const { tags = [] } = manifest;
+	tags.forEach((tag, index) => {
+		if (tags.indexOf(tag) !== index) ctx.addIssue({
+			code: "custom",
+			path: ["tags", index],
+			message: `duplicate tag '${tag}'`
+		});
+	});
+	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"
+	});
 	if (isEmpty(manifest.contributes)) ctx.addIssue({
 		code: "custom",
 		path: ["contributes"],
@@ -643,6 +1489,8 @@ const normalizeManifest = (input) => {
 		author: input.author ?? null,
 		platforms: [...input.platforms ?? []],
 		minAppVersion: input.minAppVersion ?? null,
+		tags: [...input.tags ?? []],
+		icon: input.icon ?? null,
 		contributes
 	};
 };
@@ -676,9 +1524,23 @@ const compatibilityIssue = (manifest, appVersion, platform) => checkCompatibilit
 const resolveMain = async (dir, main, verifyFiles) => {
 	if (main === null) return null;
 	const mainPath = inside(dir, main);
-	if (verifyFiles && !await isFile(mainPath)) throw new Error(`main '${main}'${defaultNote(main, DEFAULT_MAIN)} is not a file`);
+	if (verifyFiles && !await isFile$1(mainPath)) throw new Error(`main '${main}'${defaultNote(main, DEFAULT_MAIN)} is not a file`);
 	return mainPath;
 };
+/**
+* Значок манифеста как `data:`-URI. Читается при обнаружении (≤16 КиБ), снимок
+* обнаружения хранит результат до следующего обнаружения; `verifyFiles: false` файл не читает.
+* Ссылка вместо файла не допускается.
+*/
+const resolveIcon = async (dir, icon, verifyFiles) => {
+	if (icon === null || !verifyFiles) return null;
+	const target = inside(dir, icon);
+	if (!(await lstat(target).catch(() => null))?.isFile()) throw new Error(`icon '${icon}' is not a file`);
+	const bytes = await readFile(target);
+	const problem = iconProblem(icon, bytes);
+	if (problem !== null) throw new Error(problem);
+	return iconDataUri(icon, bytes);
+};
 const inspectExtensionDir = async (directory, options = {}) => {
 	const { verifyFiles = true, expectedId = null, appVersion, platform = process.platform } = options;
 	const dir = path.resolve(directory);
@@ -738,21 +1600,569 @@ const inspectExtensionDir = async (directory, options = {}) => {
 				author: manifest.author,
 				platforms: manifest.platforms,
 				minAppVersion: manifest.minAppVersion,
+				icon: await resolveIcon(dir, manifest.icon, verifyFiles),
+				tags: manifest.tags,
 				...resolved
 			}
 		};
-	} catch (error) {
+	} catch (error) {
+		return {
+			ok: false,
+			id: manifest.id,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+};
+
+//#endregion
+//#region packages/extension-host/src/runtime.ts
+/** Срок обработчика команды расширения (R3); раннер ограниченного процесса и клиент движка ждут дольше. */
+const COMMAND_HANDLER_MS = EXTENSION_COMMAND_LIMITS.handlerMs;
+
+//#endregion
+//#region packages/extension-tools/src/catalog/assets.ts
+/**
+* Content checks of the files an extension ships next to its code (style sheets, images,
+* fonts) and of its icon. One module for `catalog check`, `catalog build` and `dolphy-ext
+* build`: a file that passes here is one the protocol may serve and the installer may accept.
+* Every function returns the first problem as a message, `null` when the file is fine.
+*/
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+const XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+const MAX_SVG_DEPTH = 32;
+var AssetProblem = class extends Error {};
+const refuse = (message) => {
+	throw new AssetProblem(message);
+};
+const first = (check) => {
+	try {
+		check();
+		return null;
+	} catch (error) {
+		if (error instanceof AssetProblem) return error.message;
+		throw error;
+	}
+};
+const IDENT_START = /[A-Za-z_\u0080-\uffff]/;
+const IDENT_PART = /[A-Za-z0-9_\u0080-\uffff-]/;
+const HEX = /[0-9A-Fa-f]/;
+const WHITESPACE = /[ \t\r\n\f]/;
+/** Decodes the CSS escape starting after a backslash at `at`; returns the text and the next index. */
+const readEscape = (text, at) => {
+	let end = at;
+	while (end < text.length && end - at < 6 && HEX.test(text[end] ?? "")) end++;
+	if (end === at) return [text[at] ?? "", at + 1];
+	const code = Number.parseInt(text.slice(at, end), 16);
+	return [code === 0 || code > 1114111 || code >= 55296 && code <= 57343 ? "�" : String.fromCodePoint(code), WHITESPACE.test(text[end] ?? "") ? end + 1 : end];
+};
+const readIdent = (text, from) => {
+	let value = "";
+	let i = from;
+	while (i < text.length) {
+		const char = text[i] ?? "";
+		if (char === "\\") {
+			const [decoded, next] = readEscape(text, i + 1);
+			value += decoded;
+			i = next;
+		} else if (IDENT_PART.test(char)) {
+			value += char;
+			i++;
+		} else break;
+	}
+	return [value, i];
+};
+const readString = (text, from, quote) => {
+	let value = "";
+	let i = from + 1;
+	while (i < text.length) {
+		const char = text[i] ?? "";
+		if (char === quote) return [value, i + 1];
+		if (char === "\n") return [value, i];
+		if (char === "\\") {
+			if (text[i + 1] === "\n") {
+				i += 2;
+				continue;
+			}
+			const [decoded, next] = readEscape(text, i + 1);
+			value += decoded;
+			i = next;
+		} else {
+			value += char;
+			i++;
+		}
+	}
+	return [value, i];
+};
+const readUnquotedUrl = (text, from) => {
+	let value = "";
+	let i = from;
+	while (i < text.length) {
+		const char = text[i] ?? "";
+		if (char === ")") return [value, i + 1];
+		if (char === "\\") {
+			const [decoded, next] = readEscape(text, i + 1);
+			value += decoded;
+			i = next;
+		} else {
+			value += char;
+			i++;
+		}
+	}
+	return [value, i];
+};
+const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+const DATA_IMAGE_SVG_SCOPE = /^data:image\/(?:png|jpeg|webp)[;,]/i;
+const DATA_CSS_SCOPE = /^data:(?:image|font)\/[a-z0-9.+-]+[;,]/i;
+/** ASCII whitespace and controls removed: browsers drop them inside a URL, `java\tscript:` is `javascript:`. */
+const withoutBlanks = (value) => Array.from(value).filter((char) => char > " ").join("");
+/** `value` is the text of a `url()`; throws when it leaves what the scope allows. */
+const checkUrl = (value, scope) => {
+	const url = withoutBlanks(value);
+	if (url === "" || url.startsWith("#")) return;
+	if (scope.kind === "svg") {
+		if (!DATA_IMAGE_SVG_SCOPE.test(url)) refuse(`url(${value.slice(0, 40)}) is not allowed in SVG: only #id and data:image/png|jpeg|webp`);
+		return;
+	}
+	if (url.toLowerCase().startsWith("data:")) {
+		if (DATA_CSS_SCOPE.test(url)) return;
+		refuse("url(data:…) is allowed only for images and fonts");
+	}
+	if (SCHEME.test(url) || url.startsWith("//")) refuse(`url(${value.slice(0, 60)}) points outside the extension`);
+	if (url.startsWith("/") || url.includes("\\")) refuse(`url(${value.slice(0, 60)}) must be a relative path`);
+	const target = path.posix.normalize(path.posix.join(path.posix.dirname(scope.path), url.split(/[?#]/)[0] ?? ""));
+	if (target === ".." || target.startsWith("../")) refuse(`url(${value.slice(0, 60)}) leaves the extension directory`);
+};
+const FORBIDDEN_FUNCTIONS = /* @__PURE__ */ new Set(["expression", "src"]);
+const IMAGE_SET = /* @__PURE__ */ new Set(["image-set", "-webkit-image-set"]);
+const FORBIDDEN_IDENTS = /* @__PURE__ */ new Set(["-moz-binding", "behavior"]);
+/**
+* Walks CSS tokens, so that nothing hides in strings, comments or escapes (`\40import`,
+* `u\72l(`): `@import`, `expression(`, `src()`, `url()` outside the scope, a string
+* as a URL inside `image-set()`.
+*/
+const scanCss = (text, scope) => {
+	const functions = [];
+	let i = 0;
+	while (i < text.length) {
+		const char = text[i] ?? "";
+		if (char === "/" && text[i + 1] === "*") {
+			const end = text.indexOf("*/", i + 2);
+			i = end === -1 ? text.length : end + 2;
+		} else if (char === "\"" || char === "'") {
+			const [value, next] = readString(text, i, char);
+			if (IMAGE_SET.has(functions.at(-1) ?? "")) refuse(`a string URL in image-set() is not allowed (${value.slice(0, 40)}); use url()`);
+			i = next;
+		} else if (char === "@" && (IDENT_START.test(text[i + 1] ?? "") || text[i + 1] === "\\")) {
+			const [name, next] = readIdent(text, i + 1);
+			if (name.toLowerCase() === "import") refuse("@import is not allowed");
+			i = next;
+		} else if (IDENT_START.test(char) || char === "\\" || char === "-") {
+			const [name, next] = readIdent(text, i);
+			const lower = name.toLowerCase();
+			if (FORBIDDEN_IDENTS.has(lower)) refuse(`'${name}' is not allowed`);
+			if (text[next] === "(") {
+				if (FORBIDDEN_FUNCTIONS.has(lower)) refuse(`${lower}( is not allowed`);
+				if (lower === "url") {
+					let at = next + 1;
+					while (WHITESPACE.test(text[at] ?? "")) at++;
+					const quote = text[at] ?? "";
+					if (quote === "\"" || quote === "'") {
+						const [value, end] = readString(text, at, quote);
+						checkUrl(value, scope);
+						at = end;
+						while (WHITESPACE.test(text[at] ?? "")) at++;
+						i = text[at] === ")" ? at + 1 : at;
+					} else {
+						const [value, end] = readUnquotedUrl(text, at);
+						checkUrl(value.trim(), scope);
+						i = end;
+					}
+				} else {
+					functions.push(lower);
+					i = next + 1;
+				}
+			} else i = next === i ? i + 1 : next;
+		} else {
+			if (char === "(") functions.push("");
+			if (char === ")") functions.pop();
+			i++;
+		}
+	}
+};
+/**
+* R2: a style sheet without `@import`, `expression(`, `src()`, with `url()` only to
+* `data:image`, `data:font`, `#id` and relative paths inside the extension.
+*/
+const validateCss = (text, scope) => first(() => {
+	if (text.includes("\0")) refuse("contains a NUL character");
+	scanCss(text, scope);
+});
+const ALLOWED_ELEMENTS = /* @__PURE__ */ new Set([
+	"svg",
+	"g",
+	"defs",
+	"symbol",
+	"use",
+	"path",
+	"rect",
+	"circle",
+	"ellipse",
+	"line",
+	"polyline",
+	"polygon",
+	"text",
+	"tspan",
+	"title",
+	"desc",
+	"linearGradient",
+	"radialGradient",
+	"stop",
+	"clipPath",
+	"mask",
+	"pattern",
+	"marker",
+	"image",
+	"style",
+	"filter",
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feFuncR",
+	"feFuncG",
+	"feFuncB",
+	"feFuncA",
+	"feComposite",
+	"feFlood",
+	"feGaussianBlur",
+	"feMerge",
+	"feMergeNode",
+	"feOffset",
+	"feDropShadow"
+]);
+const ALLOWED_ATTRIBUTES = new Set([
+	"id class style lang role xml:space xmlns xmlns:xlink version",
+	"viewBox preserveAspectRatio width height x y x1 y1 x2 y2 cx cy r rx ry fx fy fr",
+	"d points transform transform-origin transform-box pathLength",
+	"gradientUnits gradientTransform spreadMethod offset",
+	"patternUnits patternContentUnits patternTransform",
+	"clipPathUnits maskUnits maskContentUnits filterUnits primitiveUnits",
+	"stop-color stop-opacity fill fill-opacity fill-rule clip-rule",
+	"stroke stroke-width stroke-linecap stroke-linejoin stroke-miterlimit",
+	"stroke-dasharray stroke-dashoffset stroke-opacity vector-effect",
+	"opacity color display visibility overflow clip-path mask filter",
+	"mix-blend-mode isolation paint-order shape-rendering text-rendering",
+	"image-rendering color-interpolation color-interpolation-filters",
+	"font-family font-size font-style font-weight font-variant font-stretch",
+	"text-anchor text-decoration dominant-baseline alignment-baseline baseline-shift",
+	"letter-spacing word-spacing textLength lengthAdjust dx dy rotate",
+	"writing-mode direction unicode-bidi",
+	"marker-start marker-mid marker-end markerWidth markerHeight markerUnits refX refY orient",
+	"href xlink:href",
+	"in in2 result stdDeviation mode type values operator k1 k2 k3 k4",
+	"flood-color flood-opacity tableValues slope intercept amplitude exponent"
+].join(" ").split(" "));
+const PLAIN_ATTRIBUTE_FAMILIES = /^(?:data|aria)-[a-z0-9-]+$/;
+const FRAGMENT = /^#[A-Za-z_][A-Za-z0-9_.:-]*$/;
+const NAME = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+const ATTRIBUTE_NAME = /^[A-Za-z_][A-Za-z0-9_.:-]*$/;
+const XML_DECLARATION = /^<\?xml\s+version\s*=\s*["']1\.\d["'](?:\s+encoding\s*=\s*["'][A-Za-z0-9._-]+["'])?(?:\s+standalone\s*=\s*["'](?:yes|no)["'])?\s*\?>$/;
+const ENTITY_REFERENCE = /&(?:(amp|lt|gt|quot|apos)|#(\d+)|#x([0-9A-Fa-f]+));/g;
+/** Resolves the five predefined and the numeric references; any other `&` is an error. */
+const decodeEntities = (value) => {
+	const decoded = value.replace(ENTITY_REFERENCE, (_match, name, dec, hex) => {
+		if (name !== void 0) return {
+			amp: "&",
+			lt: "<",
+			gt: ">",
+			quot: "\"",
+			apos: "'"
+		}[name] ?? "";
+		const code = Number.parseInt(dec ?? hex ?? "", dec === void 0 ? 16 : 10);
+		if (code === 0 || code > 1114111) refuse("invalid character reference");
+		return String.fromCodePoint(code);
+	});
+	if (value.replace(ENTITY_REFERENCE, "").includes("&")) refuse("entity references other than the predefined ones are not allowed");
+	return decoded;
+};
+const checkHref = (element, value) => {
+	if (FRAGMENT.test(value)) return;
+	if (DATA_IMAGE_SVG_SCOPE.test(withoutBlanks(value))) {
+		if (element === "use") refuse("<use> may reference only '#id'");
+		return;
+	}
+	refuse(`href '${value.slice(0, 40)}' is not allowed: only #id and data:image/png|jpeg|webp`);
+};
+const checkAttribute = (element, name, rawValue) => {
+	if (/^on/i.test(name)) refuse(`event handler attribute '${name}'`);
+	const value = decodeEntities(rawValue);
+	if (name === "xmlns") {
+		if (value !== SVG_NAMESPACE) refuse(`xmlns must be ${SVG_NAMESPACE}`);
+		return;
+	}
+	if (name === "xmlns:xlink") {
+		if (value !== XLINK_NAMESPACE) refuse(`xmlns:xlink must be ${XLINK_NAMESPACE}`);
+		return;
+	}
+	if (name.startsWith("xmlns")) refuse(`namespace declaration '${name}'`);
+	if (!ALLOWED_ATTRIBUTES.has(name) && !PLAIN_ATTRIBUTE_FAMILIES.test(name)) refuse(`attribute '${name}' of <${element}> is not allowed`);
+	if (name === "href" || name === "xlink:href") {
+		checkHref(element, value);
+		return;
+	}
+	const problem = validateCss(value, { kind: "svg" });
+	if (problem !== null) refuse(`attribute '${name}': ${problem}`);
+};
+const readStartTag = (text, from) => {
+	let i = from + 1;
+	const nameStart = i;
+	while (i < text.length && /[^\s/>]/.test(text[i] ?? "")) i++;
+	const name = text.slice(nameStart, i);
+	if (name.includes(":")) refuse(`namespaced element <${name}> is not allowed`);
+	if (!NAME.test(name)) refuse(`malformed element name '${name.slice(0, 20)}'`);
+	const attributes = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (;;) {
+		while (WHITESPACE.test(text[i] ?? "")) i++;
+		const char = text[i];
+		if (char === void 0) return refuse(`<${name}> is not closed`);
+		if (char === ">") return {
+			name,
+			attributes,
+			selfClosing: false,
+			next: i + 1
+		};
+		if (char === "/") {
+			if (text[i + 1] !== ">") refuse(`malformed <${name}> tag`);
+			return {
+				name,
+				attributes,
+				selfClosing: true,
+				next: i + 2
+			};
+		}
+		const attributeStart = i;
+		while (i < text.length && /[^\s=/>]/.test(text[i] ?? "")) i++;
+		const attribute = text.slice(attributeStart, i);
+		if (!ATTRIBUTE_NAME.test(attribute)) refuse(`malformed attribute '${attribute.slice(0, 20)}' in <${name}>`);
+		while (WHITESPACE.test(text[i] ?? "")) i++;
+		if (text[i] !== "=") refuse(`attribute '${attribute}' has no value`);
+		i++;
+		while (WHITESPACE.test(text[i] ?? "")) i++;
+		const quote = text[i];
+		if (quote !== "\"" && quote !== "'") refuse(`attribute '${attribute}' is not quoted`);
+		const end = text.indexOf(quote ?? "\"", i + 1);
+		if (end === -1) refuse(`attribute '${attribute}' is not closed`);
+		const value = text.slice(i + 1, end);
+		if (value.includes("<")) refuse(`attribute '${attribute}' contains '<'`);
+		if (seen.has(attribute)) refuse(`duplicate attribute '${attribute}'`);
+		seen.add(attribute);
+		attributes.push([attribute, value]);
+		i = end + 1;
+	}
+};
+const closeFrame = (stack) => {
+	const frame = stack.pop();
+	if (frame?.name !== "style") return;
+	const problem = validateCss(frame.text, { kind: "svg" });
+	if (problem !== null) refuse(`<style>: ${problem}`);
+};
+const walkSvg = (text) => {
+	const stack = [];
+	let roots = 0;
+	let i = 0;
+	while (i < text.length) if (text.startsWith("<!--", i)) {
+		const end = text.indexOf("-->", i + 4);
+		if (end === -1) refuse("unterminated comment");
+		i = end + 3;
+	} else if (text.startsWith("<![CDATA[", i)) {
+		const end = text.indexOf("]]>", i + 9);
+		if (end === -1) refuse("unterminated CDATA section");
+		const top = stack.at(-1);
+		if (top === void 0) refuse("CDATA outside the root element");
+		else top.text += text.slice(i + 9, end);
+		i = end + 3;
+	} else if (text.startsWith("<?", i)) {
+		const end = text.indexOf("?>", i + 2);
+		const declaration = end === -1 ? "" : text.slice(i, end + 2);
+		if (i !== 0 || !XML_DECLARATION.test(declaration)) refuse("processing instructions other than the XML declaration are not allowed");
+		i = end + 2;
+	} else if (text.startsWith("<!", i)) refuse("DOCTYPE, ENTITY and other declarations are not allowed");
+	else if (text.startsWith("</", i)) {
+		const end = text.indexOf(">", i);
+		if (end === -1) refuse("unterminated closing tag");
+		const name = text.slice(i + 2, end).trim();
+		if (stack.at(-1)?.name !== name) refuse(`unexpected </${name}>`);
+		closeFrame(stack);
+		i = end + 1;
+	} else if (text[i] === "<") {
+		const tag = readStartTag(text, i);
+		if (stack.length === 0) {
+			roots++;
+			if (roots > 1) refuse("more than one root element");
+			if (tag.name !== "svg") refuse(`root element must be <svg>, it is <${tag.name}>`);
+			if (!tag.attributes.some(([name]) => name === "xmlns")) refuse(`<svg> must declare xmlns="${SVG_NAMESPACE}"`);
+		}
+		if (!ALLOWED_ELEMENTS.has(tag.name)) refuse(`element <${tag.name}> is not allowed`);
+		if (stack.length >= MAX_SVG_DEPTH) refuse("elements are nested too deep");
+		if (tag.name === "style") {
+			const type = tag.attributes.find(([name]) => name === "type")?.[1];
+			if (type !== void 0 && type !== "text/css") refuse("<style> must be text/css");
+		}
+		for (const [name, value] of tag.attributes) checkAttribute(tag.name, name, value);
+		stack.push({
+			name: tag.name,
+			text: ""
+		});
+		if (tag.selfClosing) closeFrame(stack);
+		i = tag.next;
+	} else {
+		const end = text.indexOf("<", i);
+		const chunk = text.slice(i, end === -1 ? text.length : end);
+		const top = stack.at(-1);
+		if (top === void 0) {
+			if (chunk.trim() !== "") refuse("text outside the root element");
+		} else top.text += decodeEntities(chunk);
+		i = end === -1 ? text.length : end;
+	}
+	if (stack.length > 0) refuse(`<${stack.at(-1)?.name}> is not closed`);
+	if (roots === 0) refuse("no root element");
+};
+const decodeUtf8 = (bytes) => {
+	try {
+		return new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: false
+		}).decode(bytes).replace(/^\ufeff/, "");
+	} catch {
+		return refuse("is not valid UTF-8");
+	}
+};
+/**
+* R1/R2: an SVG is accepted as an image and only from an allow-list: a well-formed XML
+* document with the `svg` root, known elements and attributes, no scripts, `foreignObject`,
+* event handlers, DOCTYPE or entities, links other than `#id` and `data:image/png|jpeg|webp`.
+*/
+const validateSvg = (text) => first(() => {
+	if (text.includes("\0")) refuse("contains a NUL character");
+	walkSvg(text.replace(/^\ufeff/, ""));
+});
+/**
+* The type, signature, size and content of one asset file by its extension.
+* `null` for a file that is not an asset or is fine.
+*/
+const assetProblem = (file, bytes) => {
+	const extension = assetExtensionOf(file);
+	if (extension === null) return null;
+	const limit = assetSizeLimit(extension);
+	if (bytes.length > limit) return `${bytes.length} bytes exceed the limit of ${limit} for .${extension}`;
+	if (isBinaryAsset(extension)) {
+		const inspected = inspectBinaryAsset(extension, bytes);
+		return inspected.ok ? null : inspected.reason;
+	}
+	return first(() => {
+		const text = decodeUtf8(bytes);
+		const problem = extension === "svg" ? validateSvg(text) : validateCss(text, {
+			kind: "css",
+			path: file
+		});
+		if (problem !== null) refuse(problem);
+	});
+};
+/** An asset written with capital letters in the extension (`Logo.PNG`): the catalog takes lowercase only. */
+const hasUppercaseAssetExtension = (file) => {
+	const extension = extensionOf(file);
+	return extension !== null && extension !== extension.toLowerCase() && ASSET_EXTENSIONS.includes(extension.toLowerCase());
+};
+/** Checks every asset among `files` (paths relative to `root`); other files are not read. */
+const assetFindings = async (root, files) => {
+	const findings = [];
+	for (const file of files) {
+		if (hasUppercaseAssetExtension(file)) {
+			findings.push({
+				path: file,
+				message: "the file extension must be lowercase"
+			});
+			continue;
+		}
+		if (assetExtensionOf(file) === null) continue;
+		const message = assetProblem(file, await readFile(path.join(root, file)));
+		if (message !== null) findings.push({
+			path: file,
+			message
+		});
+	}
+	return findings;
+};
+
+//#endregion
+//#region packages/extension-tools/src/assets-plugin.ts
+/**
+* Assets up to this size are inlined into the bundle as data URIs; bigger ones become
+* files in `assets/` (`assets/<name>-<hash>.<ext>`: the name follows the content, so a
+* rebuild of the same sources writes the same file).
+*/
+const ASSETS_INLINE_LIMIT = 4096;
+const ASSET_FILE_NAME = "assets/[name]-[hash][extname]";
+const ASSET_FILE = /\.(?:png|webp|jpe?g|svg|woff2)$/;
+const STYLE_FILE = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)$/;
+const TEXT_IMPORT = /[?&](?:inline|url|raw)(?:&|$)/;
+const MARKED = /[?&](?:inline|no-inline|raw)(?:&|$)/;
+const cleanId = (id) => id.split("?")[0] ?? id;
+/** `new URL('./logo.png', import.meta.url)` with a relative literal to an image or a font. */
+const URL_EXPRESSION = /new\s+URL\(\s*(['"])(\.{1,2}\/[^'"?#\n]+\.(?:png|webp|jpe?g|svg|woff2))\1\s*,\s*import\.meta\.url\s*\)/g;
+const isBig = (file) => {
+	try {
+		return statSync(file).size > ASSETS_INLINE_LIMIT;
+	} catch {
+		return false;
+	}
+};
+/**
+* Vite in library mode inlines every asset and has no place for a style sheet: the
+* plugin brings the two documented paths. An image or a font is a data URI up to
+* `ASSETS_INLINE_LIMIT` and a file in `assets/` above it (an import with `?url` or
+* `new URL('./x.png', import.meta.url)`); a style sheet is imported as a string with
+* `?inline`, a plain `import './x.css'` is an error with the way out in the message.
+*/
+const assetsPlugin = (state) => ({
+	name: "dolphy-ext:assets",
+	enforce: "pre",
+	transform(code, id) {
+		const file = cleanId(id);
+		if (file.includes("\0") || !code.includes("import.meta.url")) return null;
+		const marked = code.replace(URL_EXPRESSION, (expression, quote, relative) => isBig(path.resolve(path.dirname(file), relative)) ? expression.replace(`${quote}${relative}${quote}`, `${quote}${relative}?no-inline${quote}`) : expression);
+		return marked === code ? null : {
+			code: marked,
+			map: null
+		};
+	},
+	async resolveId(source, importer, options) {
+		if (importer === void 0 || importer.startsWith("\0")) return null;
+		const resolved = await this.resolve(source, importer, {
+			...options,
+			skipSelf: true
+		});
+		if (resolved === null || resolved.external === true) return null;
+		const file = cleanId(resolved.id);
+		const query = resolved.id.slice(file.length);
+		if (STYLE_FILE.test(file)) {
+			if (TEXT_IMPORT.test(query)) return null;
+			const message = `'${source}' is imported as a side-effect style sheet, which a bundle cannot carry: import it as text with import css from '${source}?inline' and add it to the page, or ship it as a file in assets/`;
+			state.problem = message;
+			return this.error(message);
+		}
+		if (!ASSET_FILE.test(file) || MARKED.test(query)) return null;
+		if (STYLE_FILE.test(cleanId(importer)) || !isBig(file)) return null;
 		return {
-			ok: false,
-			id: manifest.id,
-			message: error instanceof Error ? error.message : String(error)
+			...resolved,
+			id: `${resolved.id}${query === "" ? "?" : "&"}no-inline`
 		};
 	}
-};
+});
 
 //#endregion
 //#region packages/extension-tools/src/errors.ts
-/** Ошибка сборки/проверки расширения; `subject` — id расширения или каталог. */
+/** Extension build/check error; `subject` is the extension id or directory. */
 var BuildError = class extends Error {
 	subject;
 	constructor(message, subject) {
@@ -761,99 +2171,558 @@ var BuildError = class extends Error {
 		this.subject = subject;
 	}
 };
-/** Неверные входные данные команды (несуществующий каталог): код выхода 2. */
+/** 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",
+	"markdown"
+];
+const SOURCE_EXTENSIONS = [
+	".ts",
+	".mts",
+	".js",
+	".mjs"
+];
+const MAX_HOPS = 16;
+const child = (node, key) => node[key];
+const children = (node, key) => node[key];
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion",
+	"ParenthesizedExpression"
+]);
+const unwrap = (node) => {
+	let current = node;
+	while (WRAPPERS.has(current.type)) current = child(current, "expression");
+	return current;
+};
+/** Name from an identifier or string literal (`{ a: 1 }`, `{ 'a-b': 1 }`, `export { x as 'y' }`). */
+const nameOf = (node) => String(node.type === "Identifier" ? node.name : node.value);
+const isFile = async (file) => (await stat(file).catch(() => null))?.isFile() === true;
+/** Relative import → source file; packages and `node:*` are not analyzed. */
+const resolveRelative = async (from, specifier) => {
+	if (!specifier.startsWith(".")) return null;
+	const base = path.resolve(path.dirname(from), specifier);
+	const withoutJs = base.replace(/\.(m?js)$/, "");
+	const candidates = [
+		base,
+		...SOURCE_EXTENSIONS.map((extension) => `${withoutJs}${extension}`),
+		...SOURCE_EXTENSIONS.map((extension) => path.join(base, `index${extension}`))
+	];
+	for (const candidate of candidates) if (await isFile(candidate)) return candidate;
+	return null;
+};
+const propertyKeys = (literal) => {
+	const keys = [];
+	for (const property of children(literal, "properties")) {
+		if (property.type !== "Property") return { reason: "it uses a spread or a computed entry" };
+		const key = child(property, "key");
+		if (!(property.computed !== true || key.type === "Literal")) return { reason: "it uses a computed key" };
+		keys.push({
+			name: nameOf(key),
+			start: property.start,
+			end: property.end
+		});
+	}
+	return { keys };
+};
+/**
+* Static analysis of `src/index.ts` without executing author code: whether the
+* `host` export exists and which keys the `views`, `panels` and `markdown`
+* entries have. Entries are found through local constants and relative
+* re-exports; keys must be given as an object literal.
+*/
+const analyzeIndex = async (indexFile) => {
+	const cache = /* @__PURE__ */ new Map();
+	const parse = (file) => {
+		let parsed = cache.get(file);
+		if (parsed === void 0) {
+			parsed = readFile(file, "utf8").then((source) => {
+				const lang = /\.[mc]?ts$/.test(file) ? "ts" : "js";
+				return {
+					file,
+					source,
+					body: parseAst(source, { lang }).body
+				};
+			});
+			cache.set(file, parsed);
+		}
+		return parsed;
+	};
+	const walk = {
+		local: async (file, name, hops) => {
+			if (hops > MAX_HOPS) return {
+				kind: "opaque",
+				reason: "it is re-exported too deeply"
+			};
+			const parsed = await parse(file);
+			for (const statement of parsed.body) {
+				const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+				if (declaration?.type === "VariableDeclaration") for (const declarator of children(declaration, "declarations")) {
+					const id = child(declarator, "id");
+					if (id.type !== "Identifier" || id.name !== name) continue;
+					const init = declarator.init;
+					if (init === null) return {
+						kind: "opaque",
+						reason: "it has no initializer"
+					};
+					const value = unwrap(init);
+					if (value.type === "Identifier") return walk.local(file, value.name, hops + 1);
+					return {
+						kind: "value",
+						parsed,
+						node: value
+					};
+				}
+				else if ((declaration?.type === "FunctionDeclaration" || declaration?.type === "ClassDeclaration") && declaration.id?.name === name) return {
+					kind: "opaque",
+					reason: "it is not an object literal"
+				};
+				else if (statement.type === "ImportDeclaration") for (const specifier of children(statement, "specifiers")) {
+					if (child(specifier, "local").name !== name) continue;
+					if (specifier.type !== "ImportSpecifier") return {
+						kind: "opaque",
+						reason: "it is imported as a default or namespace"
+					};
+					const target = await resolveRelative(file, child(statement, "source").value);
+					if (target === null) return {
+						kind: "opaque",
+						reason: "it is imported from a package"
+					};
+					return walk.export(target, nameOf(child(specifier, "imported")), hops + 1);
+				}
+			}
+			return null;
+		},
+		export: async (file, name, hops) => {
+			if (hops > MAX_HOPS) return {
+				kind: "opaque",
+				reason: "it is re-exported too deeply"
+			};
+			const parsed = await parse(file);
+			const stars = [];
+			for (const statement of parsed.body) {
+				if (statement.type === "ExportAllDeclaration") {
+					const exported = statement.exported;
+					if (exported === null) stars.push(statement);
+					else if (nameOf(exported) === name) return {
+						kind: "opaque",
+						reason: "it is a namespace re-export"
+					};
+					continue;
+				}
+				if (statement.type !== "ExportNamedDeclaration") continue;
+				const declaration = statement.declaration;
+				if (declaration !== null) {
+					if ((declaration.type === "VariableDeclaration" ? children(declaration, "declarations").map((item) => child(item, "id")) : [declaration.id]).some((id) => id?.type === "Identifier" && id.name === name)) return walk.local(file, name, hops + 1);
+					continue;
+				}
+				const source = statement.source;
+				for (const specifier of children(statement, "specifiers")) {
+					if (nameOf(child(specifier, "exported")) !== name) continue;
+					const local = nameOf(child(specifier, "local"));
+					if (source === null) return walk.local(file, local, hops + 1);
+					const target = await resolveRelative(file, source.value);
+					if (target === null) return {
+						kind: "opaque",
+						reason: "it is re-exported from a package"
+					};
+					return walk.export(target, local, hops + 1);
+				}
+			}
+			for (const star of stars) {
+				const target = await resolveRelative(file, child(star, "source").value);
+				if (target === null) continue;
+				const found = await walk.export(target, name, hops + 1);
+				if (found !== null) return found;
+			}
+			return null;
+		}
+	};
+	const recordOf = async (name) => {
+		const resolved = await walk.export(indexFile, name, 0);
+		if (resolved === null) return { status: "missing" };
+		if (resolved.kind === "opaque") return {
+			status: "opaque",
+			reason: resolved.reason
+		};
+		if (resolved.node.type !== "ObjectExpression") return {
+			status: "opaque",
+			reason: "it is not an object literal"
+		};
+		const found = propertyKeys(resolved.node);
+		if ("reason" in found) return {
+			status: "opaque",
+			reason: found.reason
+		};
+		return {
+			status: "found",
+			site: {
+				file: resolved.parsed.file,
+				source: resolved.parsed.source,
+				start: resolved.node.start,
+				end: resolved.node.end,
+				keys: found.keys
+			}
+		};
+	};
+	const [views, panels, markdown] = await Promise.all(RECORDS.map(recordOf));
+	const hasHost = await walk.export(indexFile, "host", 0) !== null;
+	return {
+		files: [...cache.keys()],
+		hasHost,
+		records: {
+			views,
+			panels,
+			markdown
+		}
+	};
+};
+/**
+* Source of `site.file` with the entry literal trimmed to `keep`: the code of the
+* discarded keys does not reach the bundle, and neither do their dependencies.
+*/
+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)}`;
+	}
+	return result;
+};
+const isRecord$1 = (value) => typeof value === "object" && value !== null;
+const collectImports = (node, found) => {
+	if (Array.isArray(node)) {
+		for (const item of node) collectImports(item, found);
+		return;
+	}
+	if (!isRecord$1(node)) return;
+	const { source } = node;
+	if ((node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ImportExpression") && isRecord$1(source) && typeof source.value === "string") found.add(source.value);
+	for (const value of Object.values(node)) collectImports(value, found);
+};
+/** Specifiers the built file still imports (statically and via `import()`). */
+const importsOf = (code) => {
+	const found = /* @__PURE__ */ new Set();
+	collectImports(parseAst(code, { lang: "js" }).body, found);
+	return found;
+};
+/**
+* Removes binding-less imports (`import "node:fs"`) from the built code that
+* `isDropped` selects. The bundler leaves such imports from the pruned host
+* code; they have no bindings, so removing them is safe.
+*/
+const stripBareImports = (code, isDropped) => {
+	const ranges = [];
+	for (const statement of parseAst(code, { lang: "js" }).body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		if (children(statement, "specifiers").length > 0) continue;
+		if (isDropped(child(statement, "source").value)) ranges.push([statement.start, statement.end]);
+	}
+	let result = code;
+	for (const [start, end] of ranges.reverse()) result = result.slice(0, start) + result.slice(end);
+	return result;
+};
+
+//#endregion
+//#region packages/extension-tools/src/shim.ts
+/** SDK subpath with element registration and dispatch; resolved from the author's project. */
+const SDK_RUNTIME = "@dolphy-app/extension-sdk/runtime";
+/** Path of the virtual shim: the build's `lib.entry` and the plugin's `resolveId`; there is no file on disk. */
+const shimEntry = (project, output) => path.join(project.root, "src", `.dolphy-ext-${output.output.replaceAll(/[^\w.-]/g, "-")}.js`);
+const quote = (text) => JSON.stringify(text);
+/** Which `src/index.ts` entries the output file needs: entry name → keys. */
+const wantedRecords = (output) => output.kind === "host" ? {
+	views: [],
+	panels: [],
+	markdown: []
+} : {
+	views: output.views.map((view) => view.id),
+	panels: output.panels,
+	markdown: output.languages
+};
+/** Exports of `src/index.ts` the file is built from (for messages). */
+const exportsOf = (output) => output.kind === "host" ? ["host"] : RECORDS.filter((name) => wantedRecords(output)[name].length > 0);
+/**
+* Source of the output file's virtual shim: imports from `src/index.ts` only
+* what is needed and does what the app expects from this file. The
+* `export default` result is the module the app loads (`ExtensionModule`,
+* panel module, renderer module); a file of this kind registers elements.
+*/
+const shimSource = (output, indexFile) => {
+	if (output.kind === "host") return `export { host as default } from ${quote(indexFile)};\n`;
+	const runtime = [];
+	const body = [];
+	const modules = [];
+	if (output.views.length > 0) {
+		runtime.push("registerAnswerView");
+		for (const view of output.views) body.push(`registerAnswerView(${quote(view.element)}, views[${quote(view.id)}]);`);
+	}
+	const table = (name, keys) => `{ ${keys.map((key) => `${quote(key)}: ${name}[${quote(key)}]`).join(", ")} }`;
+	if (output.panels.length > 0) {
+		runtime.push("dispatchPanels");
+		modules.push(`...dispatchPanels(${table("panels", output.panels)})`);
+	}
+	if (output.languages.length > 0) {
+		runtime.push("dispatchMarkdown");
+		modules.push(`...dispatchMarkdown(${table("markdown", output.languages)})`);
+	}
+	const lines = [
+		`import { ${RECORDS.filter((name) => wantedRecords(output)[name].length > 0).join(", ")} } from ${quote(indexFile)};`,
+		`import { ${runtime.join(", ")} } from ${quote(SDK_RUNTIME)};`,
+		...body
+	];
+	if (modules.length > 0) lines.push(`export default { ${modules.join(", ")} };`);
+	return `${lines.join("\n")}\n`;
+};
+/** Mismatches between `src/index.ts` and the manifest; empty — everything agrees. */
+const findMismatches = (project, analysis, indexSource, root) => {
+	const problems = [];
+	if (project.host !== null && !analysis.hasHost) problems.push(`${indexSource} does not export 'host' for ${project.host.output}: add export const host = defineExtension({ … })`);
+	const declared = {
+		views: project.manifest.contributes.exerciseTypes.map((type) => type.id),
+		panels: project.manifest.contributes.panels.map((panel) => panel.id),
+		markdown: project.manifest.contributes.markdownRenderers.map((entry) => entry.language)
+	};
+	const what = {
+		views: "exercise type",
+		panels: "panel",
+		markdown: "markdown renderer"
+	};
+	const fix = {
+		views: "defineAnswerView(…)",
+		panels: "defineExtensionPanel(…)",
+		markdown: "defineMarkdownRenderer(…)"
+	};
+	for (const name of RECORDS) {
+		const result = analysis.records[name];
+		const ids = declared[name];
+		if (result.status === "opaque") problems.push(`${indexSource}: cannot read the keys of '${name}' (${result.reason}); declare it as an object literal with static keys`);
+		else if (result.status === "missing") {
+			if (ids.length > 0) problems.push(`${indexSource} does not export '${name}', but extension.json declares ${what[name]} ${ids.map((id) => `'${id}'`).join(", ")}: add export const ${name} = { ${quote(ids[0])}: ${fix[name]} }`);
+		} else {
+			const file = path.relative(root, result.site.file).split(path.sep).join("/");
+			const keys = result.site.keys.map((key) => key.name);
+			for (const id of ids) if (!keys.includes(id)) problems.push(`${file}: '${name}' has no entry '${id}', but extension.json declares ${what[name]} '${id}'`);
+			for (const key of keys) if (!ids.includes(key)) problems.push(`${file}: '${name}' has entry '${key}', but extension.json declares no ${what[name]} '${key}'`);
+		}
+	}
+	return problems;
+};
+const isNodeSpecifier = (specifier, external) => specifier.startsWith("node:") || builtinModules.includes(specifier) || external.some((name) => specifier === name || specifier.startsWith(`${name}/`));
+/**
+* Build plugin for a single output file: the virtual shim, reconciliation of
+* `src/index.ts` with the manifest on every (re)build, pruning of entries not
+* belonging to the file, and protection of browser files from `node:*`.
+*/
+const shimPlugin = ({ project, output, state }) => {
+	const indexSource = project.indexSource;
+	const root = realpathSync(project.root);
+	const indexFile = path.join(root, indexSource);
+	const shimId = shimEntry(project, output);
+	let sites = [];
+	const fail = (context, message) => {
+		state.problem = message;
+		return context.error(message);
+	};
+	return {
+		name: "dolphy-ext:entry",
+		enforce: "pre",
+		resolveId(specifier) {
+			if (specifier === shimId) return shimId;
+			if (output.kind === "browser" && isNodeSpecifier(specifier, project.external)) return {
+				id: specifier,
+				external: true
+			};
+			return null;
+		},
+		generateBundle(_options, bundle) {
+			if (output.kind !== "browser") return;
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "chunk") continue;
+				chunk.code = stripBareImports(chunk.code, (specifier) => isNodeSpecifier(specifier, project.external));
+				const leaked = [...importsOf(chunk.code)].find((specifier) => isNodeSpecifier(specifier, project.external));
+				if (leaked !== void 0) fail(this, `${output.output} imports '${leaked}': Node.js modules and the 'external' packages of dolphy-ext.config.json are for the extension host, keep them out of code that views, panels and markdown renderers use`);
+			}
+		},
+		async buildStart() {
+			this.addWatchFile(indexFile);
+			const analysis = await analyzeIndex(indexFile).catch((error) => fail(this, `${indexSource} cannot be read: ${String(error)}`));
+			for (const file of analysis.files) this.addWatchFile(file);
+			const problems = findMismatches(project, analysis, indexSource, root);
+			if (problems.length > 0) fail(this, problems.join("; "));
+			const wanted = wantedRecords(output);
+			sites = RECORDS.flatMap((name) => {
+				const result = analysis.records[name];
+				return result.status === "found" ? [{
+					site: result.site,
+					keep: new Set(wanted[name])
+				}] : [];
+			});
+		},
+		load(id) {
+			return id === shimId ? shimSource(output, indexFile) : null;
+		},
+		transform(code, id) {
+			const here = sites.filter(({ site }) => site.file === id);
+			const first = here[0];
+			if (first === void 0 || first.site.source !== code) return null;
+			return pruneRecords(code, here);
+		}
+	};
+};
+
 //#endregion
 //#region packages/extension-tools/src/bundle.ts
-const isWatcher = (value) => typeof value === "object" && value !== null && "on" in value && "close" in value;
 const errorText$2 = (error) => error instanceof Error ? error.message : String(error);
 const nodeExternal = (external) => [
 	/^node:/,
 	...builtinModules,
 	...external
 ];
-const bundleConfig = (project, entry, outDir, isNode) => ({
+const bundleConfig = (project, entry, output, outDir, isNode) => ({
 	root: project.root,
 	configFile: false,
 	publicDir: false,
+	base: "./",
 	logLevel: "warn",
+	customLogger: {
+		...createLogger("warn"),
+		error: () => void 0
+	},
 	build: {
 		target: isNode ? "node22" : "es2022",
 		outDir,
 		emptyOutDir: false,
 		minify: false,
 		copyPublicDir: false,
+		assetsInlineLimit: ASSETS_INLINE_LIMIT,
 		lib: {
-			entry: path.resolve(project.root, entry.source),
+			entry,
 			formats: ["es"],
-			fileName: () => entry.output
+			fileName: () => output
 		},
-		rolldownOptions: { external: isNode ? nodeExternal(project.external) : [] }
+		rolldownOptions: {
+			external: isNode ? nodeExternal(project.external) : [],
+			output: { assetFileNames: ASSET_FILE_NAME }
+		}
 	}
 });
-const configsOf = (project, outDir) => [...project.nodeEntries.map((entry) => bundleConfig(project, entry, outDir, true)), ...project.browserEntries.map((entry) => bundleConfig(project, entry, outDir, false))];
-const sourcesOf = (project) => [...project.nodeEntries, ...project.browserEntries];
-const buildOne = async (config, entry, subject) => {
-	try {
-		await build(config);
-	} catch (error) {
-		throw new BuildError(`failed to bundle '${entry.source}': ${errorText$2(error)}`, subject);
-	}
+const outputJob = (project, output, outDir) => {
+	const state = { problem: null };
+	const config = bundleConfig(project, shimEntry(project, output), output.output, outDir, output.kind === "host");
+	return {
+		output: output.output,
+		label: `${output.output} (${exportsOf(output).join(", ")} from ${project.indexSource})`,
+		config: {
+			...config,
+			plugins: [shimPlugin({
+				project,
+				output,
+				state
+			}), assetsPlugin(state)]
+		},
+		state
+	};
+};
+const workerJob = (project, entry, outDir) => {
+	const state = { problem: null };
+	return {
+		output: entry.output,
+		label: `${entry.output} (${entry.source})`,
+		config: {
+			...bundleConfig(project, path.resolve(project.root, entry.source), entry.output, outDir, true),
+			plugins: [assetsPlugin(state)]
+		},
+		state
+	};
 };
-/** Собирает все бандлы (по одному, без общих чанков) в `outDir`. */
+/** Project bundles: the extensions process, browser files, workers. */
+const jobsOf = (project, outDir) => [
+	...project.host === null ? [] : [outputJob(project, project.host, outDir)],
+	...project.browserOutputs.map((output) => outputJob(project, output, outDir)),
+	...project.workerEntries.map((entry) => workerJob(project, entry, outDir))
+];
+/** Failure cause: a reconciliation or guard error named by the plugin, or the bundler's text. */
+const failureDetail = (job, error) => job.state.problem ?? errorText$2(error);
+/** Builds all bundles (one at a time, no shared chunks) into `outDir`. */
 const bundleAll = async (project, outDir) => {
-	const configs = configsOf(project, outDir);
-	const entries = sourcesOf(project);
-	for (const [index, config] of configs.entries()) await buildOne(config, entries[index], project.manifest.id);
+	for (const job of jobsOf(project, outDir)) {
+		job.state.problem = null;
+		try {
+			await build(job.config);
+		} catch (error) {
+			throw new BuildError(`failed to bundle ${job.label}: ${failureDetail(job, error)}`, project.manifest.id);
+		}
+	}
 };
-const whenFirstEnd = (watcher, entry, onRebuild) => {
-	let isFirst = true;
-	return new Promise((resolve, reject) => {
-		watcher.on("event", (event) => {
-			if (event.code === "ERROR") {
-				if (isFirst) reject(event.error);
-				else onRebuild(entry, event.error);
-			}
-			if (event.code === "END") {
-				if (isFirst) resolve();
-				else onRebuild(entry, null);
-				isFirst = false;
-			}
-		});
-	});
+
+//#endregion
+//#region packages/extension-tools/src/ids.ts
+/** Directory of the generated files in a project; never part of `dist-ext` or a catalog source tree. */
+const GENERATED_DIR = ".dolphy";
+/** The declarations file, relative to the project root (posix separators, as in `tsconfig` `include`). */
+const IDS_FILE = `${GENERATED_DIR}/ids.d.ts`;
+const HEADER = "// Generated by `dolphy-ext types` from extension.json. Do not edit: the file is rewritten on every build.";
+/** A single-quoted TypeScript string literal. */
+const literal = (text) => `'${JSON.stringify(text).slice(1, -1).replaceAll("\\\"", "\"").replaceAll("'", "\\'")}'`;
+/** A union of literals; `never` when the manifest declares none. */
+const union = (values) => values.length === 0 ? "never" : values.map(literal).join(" | ");
+const settingType = (setting) => setting.type === "enum" ? union(setting.options.map((option) => option.value)) : setting.type;
+const settingsType = (settings) => settings.length === 0 ? "{}" : `{\n${settings.map((setting) => `      ${literal(setting.id)}: ${settingType(setting)};`).join("\n")}\n    }`;
+/**
+* The declarations for a manifest: an augmentation of `ExtensionIds` in
+* `@dolphy-app/extension-sdk`. Pure function of the normalized manifest, so
+* the output is deterministic; a kind with no ids is `never`.
+*/
+const renderIds = ({ contributes }) => {
+	const entries = [
+		["exerciseTypes", union(contributes.exerciseTypes.map(({ id }) => id))],
+		["gradePolicies", union(contributes.gradePolicies.map(({ id }) => id))],
+		["commands", union(contributes.commands.map(({ id }) => id))],
+		["events", union(contributes.events.map(({ event }) => event))],
+		["panels", union(contributes.panels.map(({ id }) => id))],
+		["markdownLanguages", union(contributes.markdownRenderers.map(({ language }) => language))],
+		["settings", settingsType(contributes.settings)]
+	];
+	return [
+		HEADER,
+		"declare module '@dolphy-app/extension-sdk' {",
+		"  interface ExtensionIds {",
+		...entries.map(([name, type]) => `    ${name}: ${type};`),
+		"  }",
+		"}",
+		"",
+		"export {};",
+		""
+	].join("\n");
 };
 /**
-* Запускает вотчеры всех бандлов; резолвится после первой сборки каждого.
-* `onRebuild` вызывается после последующих пересборок (`error` — причина сбоя).
+* Writes `.dolphy/ids.d.ts` for the project, from `extension.json` only (no
+* author code is run). A file with identical content is not rewritten, so a
+* watcher on the project does not see a change.
 */
-const watchAll = async (project, outDir, onRebuild) => {
-	const watchers = [];
-	const close = async () => {
-		await Promise.all(watchers.map((watcher) => watcher.close()));
+const writeIds = async (project) => {
+	const file = path.join(project.root, IDS_FILE);
+	const content = renderIds(project.manifest);
+	if (await readFile(file, "utf8").catch(() => null) === content) return {
+		file,
+		changed: false
+	};
+	await mkdir(path.dirname(file), { recursive: true });
+	await writeFile(file, content);
+	return {
+		file,
+		changed: true
 	};
-	const entries = sourcesOf(project);
-	try {
-		const firsts = [];
-		for (const [index, config] of configsOf(project, outDir).entries()) {
-			const entry = entries[index];
-			const started = await build({
-				...config,
-				build: {
-					...config.build,
-					watch: {}
-				}
-			});
-			if (!isWatcher(started)) throw new Error(`watch mode is not available for '${entry.source}'`);
-			watchers.push(started);
-			firsts.push(whenFirstEnd(started, entry, onRebuild));
-		}
-		await Promise.all(firsts);
-	} catch (error) {
-		await close();
-		throw new BuildError(`failed to bundle: ${errorText$2(error)}`, project.manifest.id);
-	}
-	return { close };
 };
 
 //#endregion
@@ -861,6 +2730,7 @@ const watchAll = async (project, outDir, onRebuild) => {
 const MANIFEST_FILE = "extension.json";
 const CONFIG_FILE = "dolphy-ext.config.json";
 const DEFAULT_OUT_DIR = "dist-ext";
+const INDEX_SOURCE = "src/index.ts";
 const stripDot = (file) => file.replace(/^\.\//, "");
 const stripExtension = (file) => file.slice(0, file.length - path.posix.extname(file).length);
 const entrySource = (file) => `src/${path.posix.basename(stripExtension(file))}.ts`;
@@ -893,19 +2763,45 @@ const schemaPathsOf = (manifest) => {
 	const paths = manifest.contributes.exerciseTypes.flatMap((type) => [type.specSchema, type.answerSchema]).filter((schema) => typeof schema === "string").map(stripDot);
 	return [...new Set(paths)];
 };
-/** Без кода (`main: null`) node-входов нет. */
-const nodeEntriesOf = (manifest, config) => {
-	if (manifest.main === null) return [];
-	const main = stripDot(manifest.main);
-	return [{
-		source: entrySource(main),
-		output: main
-	}, ...Object.entries(config.nodeEntries).map(([output, source]) => ({
-		source,
-		output: stripDot(output)
-	}))];
-};
-/** Читает исходный манифест и конфиг проекта, вычисляет точки входа. */
+/** Workers are built only together with code: without `main` there are none. */
+const workerEntriesOf = (manifest, config) => manifest.main === null ? [] : Object.entries(config.nodeEntries).map(([output, source]) => ({
+	source,
+	output: stripDot(output)
+}));
+const browserOutputsOf = (manifest) => {
+	const outputs = /* @__PURE__ */ new Map();
+	const outputOf = (file) => {
+		const output = stripDot(file);
+		const existing = outputs.get(output);
+		if (existing !== void 0) return existing;
+		const created = {
+			kind: "browser",
+			output,
+			views: [],
+			panels: [],
+			languages: []
+		};
+		outputs.set(output, created);
+		return created;
+	};
+	const { exerciseTypes, markdownRenderers, panels } = 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);
+	return [...outputs.values()];
+};
+/**
+* Paths where code lived before the single entry (`src/<file name>.ts`):
+* the build uses them to recognize the old layout and suggest a migration.
+*/
+const legacySources = (project) => {
+	const outputs = [...project.host === null ? [] : [project.host.output], ...project.browserOutputs.map((entry) => entry.output)];
+	return [...new Set(outputs.map(entrySource))];
+};
+/** Reads the source manifest and project config, computes the output files. */
 const loadProject = async (rootDir) => {
 	const root = path.resolve(rootDir);
 	const manifestFile = path.join(root, MANIFEST_FILE);
@@ -920,36 +2816,179 @@ const loadProject = async (rootDir) => {
 	if (!parsed.ok) throw new BuildError(parsed.message, root);
 	const { manifest } = parsed;
 	const config = await readConfig(root);
-	const nodeEntries = nodeEntriesOf(manifest, config);
-	const browserEntries = [.../* @__PURE__ */ new Set([...manifest.contributes.exerciseTypes.map((type) => type.renderer), ...manifest.contributes.markdownRenderers.map((entry) => entry.renderer)])].map(stripDot).map((output) => ({
-		source: entrySource(output),
-		output
-	}));
+	const host = manifest.main === null ? null : {
+		kind: "host",
+		output: stripDot(manifest.main)
+	};
+	const browserOutputs = browserOutputsOf(manifest);
 	return {
 		root,
 		manifest,
 		manifestBytes,
-		nodeEntries,
-		browserEntries,
+		indexSource: host !== null || browserOutputs.length > 0 ? INDEX_SOURCE : null,
+		host,
+		browserOutputs,
+		workerEntries: workerEntriesOf(manifest, config),
 		external: config.external,
 		schemaPaths: schemaPathsOf(manifest)
 	};
 };
 
+//#endregion
+//#region packages/extension-tools/src/watch.ts
+const isWatcher = (value) => typeof value === "object" && value !== null && "on" in value && "close" in value;
+/**
+* Editing a source wakes the watchers of all files almost simultaneously: the
+* events of one cycle are gathered into one report, sent after quiet and once no
+* watcher is busy rebuilding.
+*/
+const SETTLE_MS = 150;
+const createReporter = (onReport, settleMs = SETTLE_MS) => {
+	const rebuilt = /* @__PURE__ */ new Set();
+	let failures = [];
+	let busy = 0;
+	let timer = null;
+	const flush = () => {
+		timer = null;
+		if (busy > 0) return;
+		const report = {
+			rebuilt: [...rebuilt],
+			failures
+		};
+		rebuilt.clear();
+		failures = [];
+		if (report.rebuilt.length > 0 || report.failures.length > 0) onReport(report);
+	};
+	const touch = () => {
+		if (timer !== null) clearTimeout(timer);
+		timer = setTimeout(flush, settleMs);
+	};
+	return {
+		begin() {
+			busy += 1;
+		},
+		end() {
+			busy = Math.max(0, busy - 1);
+			touch();
+		},
+		rebuilt(job) {
+			rebuilt.add(job.output);
+			touch();
+		},
+		failed(job, detail) {
+			const same = failures.find((failure) => failure.detail === detail);
+			if (same === void 0) failures.push({
+				labels: [job.label],
+				detail
+			});
+			else if (!same.labels.includes(job.label)) same.labels.push(job.label);
+			touch();
+		},
+		close() {
+			if (timer !== null) clearTimeout(timer);
+			timer = null;
+		}
+	};
+};
+const watchJob = async (job, reporter, isFailFast, failedFirst) => {
+	const started = await build({
+		...job.config,
+		build: {
+			...job.config.build,
+			watch: {}
+		}
+	});
+	if (!isWatcher(started)) throw new Error(`watch mode is not available for '${job.output}'`);
+	let isFirst = true;
+	let hasFailed = false;
+	return {
+		watcher: started,
+		first: new Promise((resolve, reject) => {
+			started.on("event", (event) => {
+				if (event.code === "START") {
+					reporter.begin();
+					hasFailed = false;
+					job.state.problem = null;
+				}
+				if (event.code === "ERROR") {
+					hasFailed = true;
+					const detail = failureDetail(job, event.error);
+					if (isFirst && isFailFast) reject(/* @__PURE__ */ new Error(`${job.label}: ${detail}`));
+					else reporter.failed(job, detail);
+					if (isFirst) {
+						failedFirst.add(job.output);
+						resolve();
+						isFirst = false;
+					}
+				}
+				if (event.code === "END") {
+					reporter.end();
+					if (isFirst) resolve();
+					else if (!hasFailed) reporter.rebuilt(job);
+					isFirst = false;
+				}
+			});
+		})
+	};
+};
+/**
+* Starts the watchers of all project bundles; resolves after each one's first build. A first build with an error is a failure
+* (`isFailFast`); otherwise the error goes into the report and the watcher waits for an edit.
+*/
+const watchAll = async (project, outDir, reporter, isFailFast) => {
+	const watchers = [];
+	const close = async () => {
+		await Promise.all(watchers.map((watcher) => watcher.close()));
+	};
+	const failedFirst = /* @__PURE__ */ new Set();
+	try {
+		const firsts = [];
+		for (const job of jobsOf(project, outDir)) {
+			const { watcher, first } = await watchJob(job, reporter, isFailFast, failedFirst);
+			watchers.push(watcher);
+			firsts.push(first);
+		}
+		await Promise.all(firsts);
+	} catch (error) {
+		await close();
+		throw new BuildError(`failed to bundle: ${errorText$2(error)}`, project.manifest.id);
+	}
+	return {
+		isHealthy: failedFirst.size === 0,
+		close
+	};
+};
+
 //#endregion
 //#region packages/extension-tools/src/index.ts
 const STATIC_DIRS = ["schema", "assets"];
+/** Editors write a file in several events: manifest reload waits for quiet. */
+const MANIFEST_SETTLE_MS = 100;
 const isPresent = async (file) => await stat(file).catch(() => null) !== null;
 const targetDir = (project, options) => {
 	const base = options.outDir ?? path.join(project.root, "dist-ext");
 	return path.join(path.resolve(base), project.manifest.id);
 };
+const legacyHint = (project) => {
+	const { contributes } = project.manifest;
+	return [
+		"create src/index.ts",
+		...project.host === null ? [] : [`move the default export of the main file into it as export const host = defineExtension({ … })`],
+		...contributes.exerciseTypes.length === 0 ? [] : [`replace defineAnswerElement(tag, mount) with an entry of export const views = { '<exercise type id>': defineAnswerView(mount) } (the tag now comes from extension.json)`],
+		...contributes.panels.length === 0 ? [] : [`move the default export of the panel module into export const panels = { '<panel id>': defineExtensionPanel({ … }) }`],
+		...contributes.markdownRenderers.length === 0 ? [] : [`move the default export of the renderer module into export const markdown = { '<language>': defineMarkdownRenderer(…) }`],
+		"delete the old src files and import from src/index.ts in tests"
+	].map((step, index) => `${index + 1}. ${step}`).join("; ");
+};
 const requireSources = async (project) => {
-	const entries = [...project.nodeEntries, ...project.browserEntries];
-	for (const entry of entries) {
-		const file = path.join(project.root, entry.source);
-		if (!await isPresent(file)) throw new BuildError(`entry source '${entry.source}' for '${entry.output}' is not found`, project.manifest.id);
+	const { indexSource } = project;
+	if (indexSource !== null && !await isPresent(path.join(project.root, indexSource))) {
+		const legacy = legacySources(project);
+		const found = (await Promise.all(legacy.map(async (source) => await isPresent(path.join(project.root, source)) ? source : null))).filter((source) => source !== null);
+		const reason = found.length > 0 ? `found the old layout (${found.join(", ")}), which is no longer supported; migrate: ${legacyHint(project)}` : `add it: ${legacyHint(project)}`;
+		throw new BuildError(`'${indexSource}' is not found: an extension with code is built from one entry file; ${reason}`, project.manifest.id);
 	}
+	for (const entry of project.workerEntries) if (!await isPresent(path.join(project.root, entry.source))) throw new BuildError(`entry source '${entry.source}' for '${entry.output}' is not found`, project.manifest.id);
 };
 const copyStatic = async (project, dir) => {
 	await writeFile(path.join(dir, MANIFEST_FILE), project.manifestBytes);
@@ -957,6 +2996,13 @@ const copyStatic = async (project, dir) => {
 		const from = path.join(project.root, name);
 		if (await isPresent(from)) await cp(from, path.join(dir, name), { recursive: true });
 	}
+	const { icon } = project.manifest;
+	if (icon !== null) {
+		const from = path.join(project.root, icon);
+		if (!await isPresent(from)) throw new BuildError(`icon '${icon}' referenced by the manifest is not found`, project.manifest.id);
+		await mkdir(path.dirname(path.join(dir, icon)), { recursive: true });
+		await cp(from, path.join(dir, icon));
+	}
 	for (const schema of project.schemaPaths) {
 		const from = path.join(project.root, schema);
 		if (!await isPresent(from)) throw new BuildError(`schema '${schema}' referenced by the manifest is not found`, project.manifest.id);
@@ -972,24 +3018,30 @@ const listFiles = async (dir, prefix = "") => {
 	}))).flat().sort();
 };
 const validateExtension = async (dir) => {
-	const result = await inspectExtensionDir(path.resolve(dir), {
+	const root = path.resolve(dir);
+	const result = await inspectExtensionDir(root, {
 		verifyFiles: true,
 		expectedId: null
 	});
-	return result.ok ? {
-		ok: true,
-		problems: []
-	} : {
+	if (!result.ok) return {
 		ok: false,
 		problems: [result.message]
 	};
+	const problems = (await assetFindings(root, await listFiles(root))).map(({ path: file, message }) => `${file}: ${message}`);
+	return {
+		ok: problems.length === 0,
+		problems
+	};
 };
 const assertValid = async (project, dir) => {
 	const { ok, problems } = await validateExtension(dir);
 	if (!ok) throw new BuildError(problems.join("; "), project.manifest.id);
 };
+/** Writes `.dolphy/ids.d.ts` for the project in `options.root` from its `extension.json`; `changed` is false when the file was already current. */
+const generateTypes = async (options) => writeIds(await loadProject(options.root));
 const prepare = async (options) => {
 	const project = await loadProject(options.root);
+	await writeIds(project);
 	await requireSources(project);
 	const dir = targetDir(project, options);
 	await rm(dir, {
@@ -1014,30 +3066,82 @@ const buildExtension = async (options) => {
 	await assertValid(project, dir);
 	return resultOf$1(project, dir);
 };
+const reportTo = (id, logger) => (report) => {
+	if (report.rebuilt.length > 0) logger?.info(`rebuilt ${report.rebuilt.join(", ")}`);
+	for (const failure of report.failures) logger?.error(`error ${id}: failed to bundle ${failure.labels.join(", ")}: ${failure.detail}`);
+};
 /**
-* Первая сборка + пересборка бандлов при правке исходников до `close()`.
-* Манифест, схемы и assets копируются один раз: их правка требует перезапуска.
+* First build + rebuild of affected files when `src/index.ts` or its
+* dependencies are edited, until `close()`. Editing `extension.json` rebuilds
+* everything: the shims depend on the manifest. Schemas and assets are copied on
+* the first build and after a manifest edit.
 */
 const watchExtension = async (options) => {
-	const { project, dir } = await prepare(options);
+	const { project: first, dir: firstDir } = await prepare(options);
 	const { logger } = options;
-	const watch = await watchAll(project, dir, (entry, error) => {
-		if (error === null) logger?.info(`rebuilt ${entry.output}`);
-		else {
-			const message = error instanceof Error ? error.message : String(error);
-			logger?.error(`error ${project.manifest.id}: ${message}`);
-		}
-	});
+	let project = first;
+	let dir = firstDir;
+	const reporter = createReporter((report) => reportTo(project.manifest.id, logger)(report));
+	let current = await watchAll(project, dir, reporter, true);
 	try {
 		await copyStatic(project, dir);
 		await assertValid(project, dir);
 	} catch (error) {
-		await watch.close();
+		await current.close();
+		reporter.close();
 		throw error;
 	}
+	const result = await resultOf$1(project, dir);
+	const reload = async () => {
+		const previous = project.manifestBytes;
+		let next;
+		try {
+			next = await loadProject(options.root);
+		} catch (error) {
+			logger?.error(`error ${project.manifest.id}: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		if (next.manifestBytes.equals(previous)) return;
+		await current?.close();
+		current = null;
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+		try {
+			await writeIds(next);
+			await requireSources(next);
+			project = next;
+			dir = targetDir(project, options);
+			await mkdir(dir, { recursive: true });
+			current = await watchAll(project, dir, reporter, false);
+			await copyStatic(project, dir);
+			if (current.isHealthy) {
+				await assertValid(project, dir);
+				logger?.info(`rebuilt ${(await resultOf$1(project, dir)).files.join(", ")}`);
+			}
+		} catch (error) {
+			logger?.error(`error ${project.manifest.id}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	};
+	let queue = Promise.resolve();
+	let timer = null;
+	const manifestWatcher = watch(project.root, (_event, name) => {
+		if (name !== "extension.json") return;
+		if (timer !== null) clearTimeout(timer);
+		timer = setTimeout(() => {
+			queue = queue.then(reload);
+		}, MANIFEST_SETTLE_MS);
+	});
 	return {
-		result: await resultOf$1(project, dir),
-		close: watch.close
+		result,
+		close: async () => {
+			manifestWatcher.close();
+			if (timer !== null) clearTimeout(timer);
+			await queue;
+			reporter.close();
+			await current?.close();
+		}
 	};
 };
 
@@ -1049,7 +3153,7 @@ const statusOf = (response) => {
 	if (response.status === 404) return "missing";
 	return "unknown";
 };
-/** Результат кэшируется на время жизни проверяющего: один автор — один запрос. */
+/** The result is cached for the checker's lifetime: one author — one request. */
 const createGithubChecker = (options = {}) => {
 	const fetchUser = options.fetch ?? fetch;
 	const headers = {
@@ -1138,12 +3242,12 @@ const readPackageJson = async (context) => {
 };
 const manifestValid = {
 	id: "CHECK-001",
-	title: "extension.json читается и проходит разбор манифеста",
+	title: "extension.json is readable and passes manifest parsing",
 	run: ({ manifestProblem }) => manifestProblem === null ? [] : [error("extension.json", manifestProblem)]
 };
 const directoryName = {
 	id: "CHECK-002",
-	title: "имя каталога равно id из манифеста",
+	title: "directory name equals the manifest id",
 	run: ({ manifest, dirName }) => manifest === null || manifest.id === dirName ? [] : [error("id", `directory name '${dirName}' does not match manifest id '${manifest.id}'`)]
 };
 const textFinding = (field, value, maxLength) => {
@@ -1152,7 +3256,7 @@ const textFinding = (field, value, maxLength) => {
 };
 const publicationMetadata = {
 	id: "CHECK-003",
-	title: "заданы name, description и author",
+	title: "name, description and author are set",
 	run: ({ declared }) => declared === null ? [] : [
 		...textFinding("name", declared.name, MAX_NAME_LENGTH),
 		...textFinding("description", declared.description, MAX_DESCRIPTION_LENGTH),
@@ -1161,7 +3265,7 @@ const publicationMetadata = {
 };
 const readme = {
 	id: "CHECK-004",
-	title: "README.md существует и не пуст",
+	title: "README.md exists and is not empty",
 	run: async (context) => {
 		const text = await context.readText("README.md");
 		return text === null || text.trim() === "" ? [error("README.md", "README.md is missing or empty")] : [];
@@ -1170,12 +3274,12 @@ const readme = {
 const isLogin = (author) => GITHUB_LOGIN_PATTERN.test(author);
 const authorLogin = {
 	id: "CHECK-005",
-	title: "author имеет форму GitHub-логина",
+	title: "author has the shape of a GitHub login",
 	run: ({ declared }) => declared?.author && !isLogin(declared.author) ? [error("author", `'${declared.author}' is not a GitHub login`)] : []
 };
 const authorExists = {
 	id: "CHECK-006",
-	title: "author — существующий пользователь GitHub",
+	title: "author is an existing GitHub user",
 	run: async ({ declared, skipGithubCheck, checkGithubUser }) => {
 		const author = declared?.author;
 		if (skipGithubCheck || !author || !isLogin(author)) return [];
@@ -1186,7 +3290,7 @@ const authorExists = {
 };
 const packageJson = {
 	id: "CHECK-007",
-	title: "package.json существует и разбирается",
+	title: "package.json exists and parses",
 	run: async (context) => {
 		if (await context.readText("package.json") === null) return [error("package.json", "package.json is missing")];
 		return await readPackageJson(context) === null ? [error("package.json", "package.json is not a valid JSON object")] : [];
@@ -1194,12 +3298,12 @@ const packageJson = {
 };
 const lockfile = {
 	id: "CHECK-008",
-	title: "есть lock-файл зависимостей",
+	title: "a dependency lock file exists",
 	run: ({ tree }) => LOCKFILES.some((name) => tree.files.some((file) => file.path === name)) ? [] : [error("package.json", `no lockfile (${LOCKFILES.join(", ")})`)]
 };
 const lifecycleScripts = {
 	id: "CHECK-009",
-	title: "нет lifecycle-скриптов установки и публикации",
+	title: "no install or publish lifecycle scripts",
 	run: async (context) => {
 		const scripts = (await readPackageJson(context))?.scripts;
 		if (!isRecord(scripts)) return [];
@@ -1208,7 +3312,7 @@ const lifecycleScripts = {
 };
 const registryDependencies = {
 	id: "CHECK-010",
-	title: "зависимости только из реестра (без git, http, file, link, workspace)",
+	title: "dependencies come only from the registry (no git, http, file, link, workspace)",
 	run: async (context) => {
 		const manifest = await readPackageJson(context);
 		if (manifest === null) return [];
@@ -1221,7 +3325,7 @@ const registryDependencies = {
 };
 const packageScope = {
 	id: "CHECK-011",
-	title: "name в package.json не занимает чужой scope",
+	title: "package.json name does not take another's scope",
 	run: async (context) => {
 		const name = (await readPackageJson(context))?.name;
 		if (typeof name !== "string" || !name.startsWith("@")) return [];
@@ -1230,7 +3334,7 @@ const packageScope = {
 };
 const newerThanPublished = {
 	id: "CHECK-012",
-	title: "версия строго больше опубликованной",
+	title: "version is strictly greater than the published one",
 	run: ({ manifest, published }) => {
 		if (manifest === null || published === void 0) return [];
 		const { version } = manifest;
@@ -1241,7 +3345,7 @@ const newerThanPublished = {
 };
 const sourceLimits = {
 	id: "CHECK-013",
-	title: `не более ${200} файлов и 5 МБ исходников, файл не больше 1 МБ`,
+	title: `at most ${200} files and 5 MB of sources, no file over 1 MB`,
 	run: ({ tree }) => {
 		const findings = [];
 		const total = tree.files.reduce((sum, file) => sum + file.size, 0);
@@ -1253,19 +3357,37 @@ const sourceLimits = {
 };
 const noSymlinks = {
 	id: "CHECK-014",
-	title: "нет символических ссылок",
+	title: "no symbolic links",
 	run: ({ tree }) => tree.symlinks.map((link) => error(link, "symbolic links are not allowed"))
 };
 const noExecutables = {
 	id: "CHECK-015",
-	title: `нет исполняемых файлов (${EXECUTABLE_EXTENSIONS.join(", ")})`,
+	title: `no executable files (${EXECUTABLE_EXTENSIONS.join(", ")})`,
 	run: ({ tree }) => tree.files.filter((file) => EXECUTABLE_EXTENSIONS.includes(path.posix.extname(file.path).toLowerCase())).map((file) => error(file.path, "executable files are not allowed"))
 };
 const appVersionBound = {
 	id: "CHECK-016",
-	title: "minAppVersion не новее --max-app-version",
+	title: "minAppVersion is not newer than --max-app-version",
 	run: ({ manifest, maxAppVersion }) => manifest?.minAppVersion && maxAppVersion !== null && compareSemver(manifest.minAppVersion, maxAppVersion) > 0 ? [error("minAppVersion", `minAppVersion ${manifest.minAppVersion} is newer than the released app ${maxAppVersion}`)] : []
 };
+const ASSETS_DIR = "assets/";
+const assetFiles = {
+	id: "CHECK-017",
+	title: "files in assets/ match their type: signature, size limits, pixels, safe SVG and CSS",
+	run: async ({ dir, tree }) => (await assetFindings(dir, tree.files.map((file) => file.path).filter((file) => file.startsWith(ASSETS_DIR)))).map(({ path: file, message }) => error(file, message))
+};
+const iconFile = {
+	id: "CHECK-018",
+	title: "icon is a square 64–512 px PNG or WebP file up to 16 KiB",
+	run: async ({ declared, readBytes }) => {
+		const icon = declared?.icon;
+		if (icon === null || icon === void 0) return [];
+		const bytes = await readBytes(icon);
+		if (bytes === null) return [error("icon", `icon '${icon}' is not a file`)];
+		const problem = iconProblem(icon, bytes);
+		return problem === null ? [] : [error("icon", problem)];
+	}
+};
 const RULES = [
 	manifestValid,
 	directoryName,
@@ -1282,7 +3404,9 @@ const RULES = [
 	sourceLimits,
 	noSymlinks,
 	noExecutables,
-	appVersionBound
+	appVersionBound,
+	assetFiles,
+	iconFile
 ];
 
 //#endregion
@@ -1327,6 +3451,7 @@ const hashTree = async (root, files) => Promise.all(files.map(async (file) => ({
 const SKIPPED_SOURCE_DIRS = /* @__PURE__ */ new Set([
 	"node_modules",
 	"dist-ext",
+	".dolphy",
 	".git"
 ]);
 const formatFinding = (finding) => `${finding.severity} ${finding.extensionId} ${finding.ruleId} ${finding.field}: ${finding.message}`;
@@ -1361,6 +3486,12 @@ const selectDirs = async (options) => {
 const readTextOrNull = async (file) => {
 	return (await stat(file).catch(() => null))?.isFile() === true ? readFile(file, "utf8") : null;
 };
+/** A file inside `dir`; a path that leaves it (`../x`) is no file. */
+const readBytesInside = async (dir, file) => {
+	const target = path.resolve(dir, file);
+	if (!target.startsWith(dir + path.sep)) return null;
+	return (await stat(target).catch(() => null))?.isFile() === true ? readFile(target) : null;
+};
 const inspectManifest = async (dir) => {
 	const result = await inspectExtensionDir(dir, {
 		verifyFiles: false,
@@ -1383,7 +3514,8 @@ const readDeclared = async (dir) => {
 		return {
 			name: stringOrNull(fields.name),
 			description: stringOrNull(fields.description),
-			author: stringOrNull(fields.author)
+			author: stringOrNull(fields.author),
+			icon: stringOrNull(fields.icon)
 		};
 	} catch {
 		return null;
@@ -1400,6 +3532,7 @@ const contextFor = async (options, dirName, published, checkGithubUser) => {
 		manifestProblem: problem,
 		tree: await readTree(dir, SKIPPED_SOURCE_DIRS),
 		readText: (file) => readTextOrNull(path.join(dir, file)),
+		readBytes: (file) => readBytesInside(dir, file),
 		published: published?.extensions.find((entry) => entry.id === (manifest?.id ?? dirName)),
 		maxAppVersion: options.maxAppVersion ?? null,
 		skipGithubCheck: options.skipGithubCheck === true,
@@ -1428,7 +3561,6 @@ const listRules = () => RULES.map((rule) => `${rule.id} ${rule.title}`);
 
 //#endregion
 //#region packages/extension-tools/src/catalog/index-file.ts
-const INDEX_FILE = "index.json";
 const orderFile = (file) => ({
 	path: file.path,
 	size: file.size,
@@ -1443,8 +3575,19 @@ const orderVersion = (version) => ({
 	permissions: [...version.permissions],
 	publishedAt: version.publishedAt,
 	baseUrl: version.baseUrl,
-	files: [...version.files].sort(byPath).map(orderFile)
+	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] }
 });
+const optionalIds = (key, ids) => ids === void 0 || ids.length === 0 ? {} : { [key]: [...ids] };
+const orderTitles = (titles) => {
+	const ordered = {};
+	for (const point of TITLED_POINTS) {
+		const map = titles?.[point];
+		if (map !== void 0 && Object.keys(map).length > 0) ordered[point] = { ...map };
+	}
+	return Object.keys(ordered).length > 0 ? { titles: ordered } : {};
+};
 const orderEntry = (entry) => ({
 	id: entry.id,
 	name: entry.name,
@@ -1456,16 +3599,29 @@ const orderEntry = (entry) => ({
 		exerciseTypes: [...entry.contributes.exerciseTypes],
 		themes: [...entry.contributes.themes],
 		markdownRenderers: [...entry.contributes.markdownRenderers],
-		gradePolicies: [...entry.contributes.gradePolicies]
+		gradePolicies: [...entry.contributes.gradePolicies],
+		...optionalIds("settings", entry.contributes.settings),
+		...optionalIds("events", entry.contributes.events),
+		...optionalIds("commands", entry.contributes.commands),
+		...optionalIds("panels", entry.contributes.panels)
 	},
+	...orderTitles(entry.titles),
 	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);
-/** Собирает индекс в стабильном порядке ключей; бросает `BuildError`, если он не проходит `parseIndex`. */
+const checked = (candidate, file) => {
+	try {
+		parseIndex(candidate);
+		return candidate;
+	} catch (error) {
+		throw new BuildError(`resulting index is invalid: ${error instanceof Error ? error.message : String(error)}`, file);
+	}
+};
+/** Builds the full index with a stable key order; throws `BuildError` if it fails `parseIndex`. */
 const assembleIndex = (parts) => {
 	const candidate = {
-		schemaVersion: 1,
+		schemaVersion: 2,
 		generatedAt: parts.generatedAt,
 		extensions: [...parts.extensions].sort(byId).map(orderEntry),
 		revoked: parts.revoked.map((item) => ({
@@ -1474,12 +3630,15 @@ const assembleIndex = (parts) => {
 			reason: item.reason
 		}))
 	};
-	try {
-		parseIndex(candidate);
-		return candidate;
-	} catch (error) {
-		throw new BuildError(`resulting index is invalid: ${error instanceof Error ? error.message : String(error)}`, INDEX_FILE);
-	}
+	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)
+	};
 };
 const writeIndexAtomically = async (file, index) => {
 	const temporary = `${file}.${process.pid}.tmp`;
@@ -1497,7 +3656,7 @@ const contentOf = (index) => {
 		revoked
 	});
 };
-/** Совпадают ли записи и список отзыва (без `generatedAt`). */
+/** Whether entries and the revocation list match (ignoring `generatedAt`). */
 const hasSameContent = (current, next) => current !== null && contentOf(current) === contentOf(next);
 
 //#endregion
@@ -1512,7 +3671,11 @@ const copyReadme = async (srcDir, dir, id) => {
 };
 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 > 50) problems.push(`${files.length} files exceed the limit of ${50}`);
+	if (files.length > 100) problems.push(`${files.length} files exceed the limit of ${100}`);
+	for (const file of files) {
+		const problem = sizeProblem(file.path, file.size);
+		if (problem !== null) problems.push(problem);
+	}
 	const total = files.reduce((sum, file) => sum + file.size, 0);
 	if (total > 1e7) problems.push(`${total} bytes exceed the limit of ${MAX_TOTAL_BYTES}`);
 	return problems;
@@ -1522,6 +3685,14 @@ const readBuiltManifest = async (dir) => {
 	if (!parsed.ok) throw new BuildError(parsed.message, dir);
 	return parsed.manifest;
 };
+/** The icon declared in the manifest, read from the built directory; its checks ran in `buildExtension`. */
+const readIcon = async (dir, manifest, id) => {
+	if (manifest.icon === null) return null;
+	const bytes = await readFile(path.join(dir, manifest.icon));
+	const problem = iconProblem(manifest.icon, bytes);
+	if (problem !== null) throw new BuildError(problem, id);
+	return iconDataUri(manifest.icon, bytes);
+};
 const stage = async (options, id, scratch) => {
 	const srcDir = path.resolve(options.src, id);
 	const built = await buildExtension({
@@ -1534,10 +3705,12 @@ const stage = async (options, id, scratch) => {
 	const files = await hashTree(built.dir, tree.files);
 	const problems = [...tree.symlinks.map((link) => `'${link}' is a symbolic link`), ...fileProblems(files)];
 	if (problems.length > 0) throw new BuildError(problems.join("; "), id);
+	const manifest = await readBuiltManifest(built.dir);
 	return {
 		id,
 		dir: built.dir,
-		manifest: await readBuiltManifest(built.dir),
+		manifest,
+		icon: await readIcon(built.dir, manifest, id),
 		files: files.map(({ path: file, size, sha256 }) => ({
 			path: file,
 			size,
@@ -1567,6 +3740,33 @@ const existingFiles = async (dir) => {
 	}));
 };
 const immutabilityError = (staged) => new BuildError(`version ${staged.manifest.version} is already published with different content; published versions never change`, staged.id);
+/** `label`/`title` of the manifest contributions by point; points without contributions are left out. */
+const titlesOf = (manifest) => {
+	const { contributes } = manifest;
+	const byPoint = {
+		themes: contributes.themes.map(({ id, label }) => ({
+			id,
+			title: label
+		})),
+		gradePolicies: contributes.gradePolicies.map(({ id, label }) => ({
+			id,
+			title: label
+		})),
+		settings: contributes.settings.map(({ id, label }) => ({
+			id,
+			title: label
+		})),
+		commands: contributes.commands.map(({ id, title }) => ({
+			id,
+			title
+		})),
+		panels: contributes.panels.map(({ id, title }) => ({
+			id,
+			title
+		}))
+	};
+	return Object.fromEntries(TITLED_POINTS.filter((point) => byPoint[point].length > 0).map((point) => [point, Object.fromEntries(byPoint[point].map(({ id, title }) => [id, title]))]));
+};
 const newRecord = (staged, publishedAt) => ({
 	version: staged.manifest.version,
 	apiVersion: staged.manifest.apiVersion,
@@ -1574,7 +3774,9 @@ const newRecord = (staged, publishedAt) => ({
 	permissions: [...staged.manifest.permissions],
 	publishedAt,
 	baseUrl: baseUrlOf(staged),
-	files: staged.files
+	files: staged.files,
+	...staged.icon === null ? {} : { icon: staged.icon },
+	...staged.manifest.tags.length === 0 ? {} : { tags: [...staged.manifest.tags] }
 });
 const plan = async (staged, out, previous, publishedAt) => {
 	const onDisk = await existingFiles(versionDir(out, staged));
@@ -1593,6 +3795,11 @@ const entryOf = (item, previous, sourceBase) => {
 	const { staged, record } = item;
 	const { manifest } = staged;
 	const others = (previous?.versions ?? []).filter((version) => version.version !== record.version);
+	const settings = manifest.contributes.settings.map((setting) => setting.id);
+	const events = manifest.contributes.events.map((item) => item.event);
+	const commands = manifest.contributes.commands.map(({ id }) => id);
+	const panels = manifest.contributes.panels.map(({ id }) => id);
+	const titles = titlesOf(manifest);
 	return {
 		id: staged.id,
 		name: manifest.name ?? "",
@@ -1604,8 +3811,13 @@ const entryOf = (item, previous, sourceBase) => {
 			exerciseTypes: manifest.contributes.exerciseTypes.map((type) => type.id),
 			themes: manifest.contributes.themes.map((theme) => theme.id),
 			markdownRenderers: manifest.contributes.markdownRenderers.map((renderer) => renderer.language),
-			gradePolicies: manifest.contributes.gradePolicies.map((policy) => policy.id)
+			gradePolicies: manifest.contributes.gradePolicies.map((policy) => policy.id),
+			...settings.length > 0 ? { settings } : {},
+			...events.length > 0 ? { events } : {},
+			...commands.length > 0 ? { commands } : {},
+			...panels.length > 0 ? { panels } : {}
 		},
+		...Object.keys(titles).length > 0 ? { titles } : {},
 		versions: newestFirst([record, ...others])
 	};
 };
@@ -1632,25 +3844,49 @@ const writeVersion = async (item, out) => {
 	await cp(item.staged.dir, temporary, { recursive: true });
 	await rename(temporary, target);
 };
-const resultOf = (item) => ({
+const resultOf = (item, entry) => ({
 	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)
+	bytes: item.staged.files.reduce((sum, file) => sum + file.size, 0),
+	inLegacyIndex: isLegacyEntry(entry) && isLegacyVersion(item.record)
 });
-const formatPublishResult = (result) => result.status === "unchanged" ? `unchanged ${result.id}@${result.version}` : `published ${result.id}@${result.version} (${result.files} files, ${result.bytes} bytes)`;
-/** Собирает версии расширений и обновляет `index.json`; при ошибке на диск ничего не пишется. */
+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;
+	await mkdir(out, { recursive: true });
+	await writeIndexAtomically(fullFile, full);
+	await writeIndexAtomically(legacyFile, legacy);
+	return true;
+};
+/** Builds extension versions and updates `index.v2.json` and `index.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();
 	const publishedAt = options.publishedAt ?? now;
 	const sourceBase = options.sourceBase ?? "https://github.com/dolphy-app/dolphy-extensions/tree/main/extensions";
-	const previous = await loadIndexFile(path.resolve(options.previousIndex ?? path.join(out, "index.json")));
+	const previous = await loadIndexFile(await previousIndexFile(out, options.previousIndex));
 	const revoked = await loadRevoked(options.revoked, previous);
 	const scratch = await mkdtemp(path.join(tmpdir(), "dolphy-catalog-"));
 	try {
 		const plans = [];
+		const results = [];
 		const entries = new Map((previous?.extensions ?? []).map((entry) => [entry.id, entry]));
 		for (const id of options.ids) {
 			const staged = await stage(options, id, scratch);
@@ -1658,18 +3894,18 @@ const buildCatalog = async (options) => {
 			const before = entries.get(id);
 			const item = await plan(staged, out, before, publishedAt);
 			plans.push(item);
-			entries.set(id, entryOf(item, before, sourceBase));
+			const entry = entryOf(item, before, sourceBase);
+			entries.set(id, entry);
+			results.push(resultOf(item, entry));
 		}
-		const index = assembleIndex({
+		const indexes = assembleIndexes({
 			generatedAt: now,
 			extensions: [...entries.values()],
 			revoked
 		});
 		for (const item of plans) if (item.shouldWrite) await writeVersion(item, out);
-		await mkdir(out, { recursive: true });
-		const indexFile = path.join(out, INDEX_FILE);
-		if (!hasSameContent(await loadIndexFile(indexFile), index)) await writeIndexAtomically(indexFile, index);
-		return plans.map(resultOf);
+		await writeIndexes(out, indexes);
+		return results;
 	} finally {
 		await rm(scratch, {
 			recursive: true,
@@ -1678,26 +3914,21 @@ const buildCatalog = async (options) => {
 	}
 };
 const formatReindexResult = (result) => `reindexed (${result.extensions} extensions, ${result.revoked} revoked)${result.changed ? "" : " — no changes"}`;
-/** Перезаписывает `revoked` и `generatedAt` существующего индекса; записи расширений не меняются. */
+/** Rewrites `revoked` and `generatedAt` of both indexes; extension entries are unchanged. */
 const reindexCatalog = async (options) => {
 	const out = path.resolve(options.out);
-	const source = path.resolve(options.previousIndex ?? path.join(out, "index.json"));
+	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 index = assembleIndex({
+	const indexes = assembleIndexes({
 		generatedAt: options.publishedAt ?? (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
 		extensions: previous.extensions,
 		revoked: await loadRevoked(options.revoked, previous)
 	});
-	const indexFile = path.join(out, INDEX_FILE);
-	const changed = !hasSameContent(await loadIndexFile(indexFile), index);
-	if (changed) {
-		await mkdir(out, { recursive: true });
-		await writeIndexAtomically(indexFile, index);
-	}
+	const changed = await writeIndexes(out, indexes);
 	return {
-		extensions: index.extensions.length,
-		revoked: index.revoked.length,
+		extensions: indexes.full.extensions.length,
+		revoked: indexes.full.revoked.length,
 		changed
 	};
 };
@@ -1714,30 +3945,30 @@ const CATALOG_SYNOPSIS = `       dolphy-ext catalog check <extensionsDir> [--ids
                    [--previous-index <path>] [--revoked <path>]
                    [--published-at <iso>]
 `;
-const CATALOG_HELP = `  catalog check    проверить исходники расширений каталога; строки
-                   «error|warning <id> <RULE-ID> <поле>: <сообщение>»,
-                   код 1 при наличии error
-  catalog build    собрать версии в <siteDir>/extensions/<id>/<version>/ и
-                   обновить <siteDir>/index.json (опубликованные версии
-                   неизменны)
+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
+                   immutable)
   catalog build --reindex
-                   только заменить revoked и generatedAt в существующем
-                   <siteDir>/index.json (--src и --ids не нужны)
+                   only replace revoked and generatedAt in the existing
+                   <siteDir>/index.json (--src and --ids are not needed)
 
-  --ids a,b              только эти расширения (check: по умолчанию все)
-  --published-index <p>  index.json опубликованного каталога (нет файла —
-                         ничего не опубликовано)
-  --max-app-version <v>  minAppVersion не должен быть новее
-  --skip-github-check    не проверять автора через api.github.com
-                         (токен — переменная GITHUB_TOKEN)
-  --list-rules           вывести правила check
-  --src <dir>            каталог с проектами <dir>/<id>
-  --out <dir>            корень сайта
-  --previous-index <p>   исходный индекс (по умолчанию <out>/index.json)
-  --revoked <p>          JSON-массив {id, versions, reason}
-  --source-base <url>    основа поля source записи индекса
-  --published-at <iso>   publishedAt новых версий (по умолчанию сейчас);
-                         с --reindex — generatedAt
+  --ids a,b              only these extensions (check: all by default)
+  --published-index <p>  index.json of the published catalog (no file —
+                         nothing is published)
+  --max-app-version <v>  minAppVersion must not be newer
+  --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)
+  --revoked <p>          JSON array {id, versions, reason}
+  --source-base <url>    base for the index entry's source field
+  --published-at <iso>   publishedAt of new versions (default now);
+                         with --reindex — generatedAt
 `;
 const VALUE_FLAGS = {
 	check: [
@@ -1769,9 +4000,9 @@ const readFlags = (mode, args) => {
 		if (switches.includes(arg)) flags[arg] = true;
 		else if (valued.includes(arg)) {
 			const value = args[++i];
-			if (value === void 0) return `${arg} требует значение`;
+			if (value === void 0) return `${arg} requires a value`;
 			flags[arg] = value;
-		} else if (arg.startsWith("-")) return `неизвестный флаг: ${arg}`;
+		} else if (arg.startsWith("-")) return `unknown flag: ${arg}`;
 		else positional.push(arg);
 	}
 	return {
@@ -1793,10 +4024,10 @@ const parseCheck = (args) => {
 	if (typeof read === "string") return { usageError: read };
 	const { flags, positional } = read;
 	const maxAppVersion = text(flags, "--max-app-version");
-	if (maxAppVersion !== void 0 && !isSemver(maxAppVersion)) return { usageError: "--max-app-version: нужен semver x.y.z" };
+	if (maxAppVersion !== void 0 && !isSemver(maxAppVersion)) return { usageError: "--max-app-version: expected semver x.y.z" };
 	const listRulesFlag = flags["--list-rules"] === true;
-	if (positional.length > 1) return { usageError: `лишние аргументы: ${positional.slice(1).join(" ")}` };
-	if (positional[0] === void 0 && !listRulesFlag) return { usageError: "catalog check: не указан каталог расширений" };
+	if (positional.length > 1) return { usageError: `extra arguments: ${positional.slice(1).join(" ")}` };
+	if (positional[0] === void 0 && !listRulesFlag) return { usageError: "catalog check: no extensions directory given" };
 	return {
 		command: "check",
 		dir: positional[0] ?? null,
@@ -1814,9 +4045,9 @@ const REINDEX_FORBIDDEN = [
 ];
 const parseReindex = (flags) => {
 	const forbidden = REINDEX_FORBIDDEN.find((name) => name in flags);
-	if (forbidden !== void 0) return { usageError: `catalog build --reindex: ${forbidden} не нужен` };
+	if (forbidden !== void 0) return { usageError: `catalog build --reindex: ${forbidden} is not needed` };
 	const out = text(flags, "--out");
-	if (out === void 0) return { usageError: "catalog build: нужен --out" };
+	if (out === void 0) return { usageError: "catalog build: --out is required" };
 	return {
 		command: "reindex",
 		out,
@@ -1829,14 +4060,14 @@ const parseBuild$1 = (args) => {
 	const read = readFlags("build", args);
 	if (typeof read === "string") return { usageError: read };
 	const { flags, positional } = read;
-	if (positional.length > 0) return { usageError: `лишние аргументы: ${positional.join(" ")}` };
+	if (positional.length > 0) return { usageError: `extra arguments: ${positional.join(" ")}` };
 	if (flags["--reindex"] === true) return parseReindex(flags);
 	const src = text(flags, "--src");
 	const out = text(flags, "--out");
 	const ids = idsOf(flags);
-	if (src === void 0) return { usageError: "catalog build: нужен --src" };
-	if (out === void 0) return { usageError: "catalog build: нужен --out" };
-	if (ids === void 0 || ids.length === 0) return { usageError: "catalog build: нужен --ids" };
+	if (src === void 0) return { usageError: "catalog build: --src is required" };
+	if (out === void 0) return { usageError: "catalog build: --out is required" };
+	if (ids === void 0 || ids.length === 0) return { usageError: "catalog build: --ids is required" };
 	return {
 		command: "build",
 		src,
@@ -1852,7 +4083,7 @@ const parseCatalogArgs = (args) => {
 	const [sub, ...rest] = args;
 	if (sub === "check") return parseCheck(rest);
 	if (sub === "build") return parseBuild$1(rest);
-	return { usageError: sub === void 0 ? "catalog: не указана подкоманда (check|build)" : `catalog: неизвестная подкоманда: ${sub}` };
+	return { usageError: sub === void 0 ? "catalog: no subcommand given (check|build)" : `catalog: unknown subcommand: ${sub}` };
 };
 const runCheck = async (parsed, io, deps) => {
 	if (parsed.listRules) {
@@ -1896,7 +4127,7 @@ const runBuild$1 = async (parsed, io, deps) => {
 	for (const result of results) io.stdout(`${formatPublishResult(result)}\n`);
 	return 0;
 };
-/** Код выхода: 0, 1 (проблемы), 2 (аргументы/окружение). */
+/** Exit code: 0, 1 (problems), 2 (arguments/environment). */
 const runCatalog = async (parsed, io, deps = {}) => {
 	try {
 		if (parsed.command === "check") return await runCheck(parsed, io, deps);
@@ -1915,16 +4146,20 @@ const EXIT_OK = 0;
 const EXIT_PROBLEMS = 1;
 const EXIT_USAGE = 2;
 const USAGE = `usage: dolphy-ext build [dir] [--out <dir>] [--watch]
+       dolphy-ext types [dir]
        dolphy-ext validate <dir>
 ${CATALOG_SYNOPSIS}
-  build [dir]      собрать расширение из проекта (по умолчанию — текущий каталог)
-                   в <dir>/dist-ext/<id>
-  validate <dir>   проверить каталог собранного расширения (extension.json,
-                   схемы, main и renderer)
+  build [dir]      build the extension from a project (default: the current
+                   directory) into <dir>/dist-ext/<id>; also writes
+                   <dir>/.dolphy/ids.d.ts
+  types [dir]      write <dir>/.dolphy/ids.d.ts: the ids declared in
+                   extension.json as types for the SDK (no code is run)
+  validate <dir>   check the directory of a built extension (extension.json,
+                   schemas, main and renderer)
 ${CATALOG_HELP}
-  --out <dir>      корень вывода (расширение кладётся в <dir>/<id>)
-  --watch          пересобирать бандлы при изменении исходников
-  --help           эта справка
+  --out <dir>      output root (the extension goes to <dir>/<id>)
+  --watch          rebuild the bundles when the sources change
+  --help           this help
 `;
 const parseBuild = (args) => {
 	const positional = [];
@@ -1935,11 +4170,11 @@ const parseBuild = (args) => {
 		if (arg === "--watch") watch = true;
 		else if (arg === "--out") {
 			out = args[++i];
-			if (out === void 0) return { usageError: "--out требует путь" };
-		} else if (arg.startsWith("-")) return { usageError: `неизвестный флаг: ${arg}` };
+			if (out === void 0) return { usageError: "--out needs a path" };
+		} else if (arg.startsWith("-")) return { usageError: `unknown flag: ${arg}` };
 		else positional.push(arg);
 	}
-	if (positional.length > 1) return { usageError: `лишние аргументы: ${positional.slice(1).join(" ")}` };
+	if (positional.length > 1) return { usageError: `extra arguments: ${positional.slice(1).join(" ")}` };
 	return {
 		command: "build",
 		dir: positional[0] ?? ".",
@@ -1947,12 +4182,21 @@ const parseBuild = (args) => {
 		watch
 	};
 };
+const parseTypes = (args) => {
+	const flag = args.find((arg) => arg.startsWith("-"));
+	if (flag !== void 0) return { usageError: `unknown flag: ${flag}` };
+	if (args.length > 1) return { usageError: `extra arguments: ${args.slice(1).join(" ")}` };
+	return {
+		command: "types",
+		dir: args[0] ?? "."
+	};
+};
 const parseValidate = (args) => {
 	const flag = args.find((arg) => arg.startsWith("-"));
-	if (flag !== void 0) return { usageError: `неизвестный флаг: ${flag}` };
+	if (flag !== void 0) return { usageError: `unknown flag: ${flag}` };
 	const [dir, ...extra] = args;
-	if (dir === void 0) return { usageError: "validate: не указан каталог" };
-	if (extra.length > 0) return { usageError: `лишние аргументы: ${extra.join(" ")}` };
+	if (dir === void 0) return { usageError: "validate: no directory given" };
+	if (extra.length > 0) return { usageError: `extra arguments: ${extra.join(" ")}` };
 	return {
 		command: "validate",
 		dir
@@ -1962,12 +4206,13 @@ 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 === "catalog") return {
 		command: "catalog",
 		args: rest
 	};
-	return { usageError: command === void 0 ? "не указана команда" : `неизвестная команда: ${command}` };
+	return { usageError: command === void 0 ? "no command given" : `unknown command: ${command}` };
 };
 const waitForSignal = () => new Promise((resolve) => {
 	process.once("SIGINT", resolve);
@@ -2016,7 +4261,18 @@ const runValidate = async (dir, io) => {
 	for (const problem of problems) io.stderr(`error ${root}: ${problem}\n`);
 	return 1;
 };
-/** `dolphy-ext build|validate|catalog`; `argv` без `node` и имени скрипта. */
+const runTypes = async (dir, io) => {
+	try {
+		const root = path.resolve(dir);
+		const { file, changed } = await generateTypes({ root });
+		const shown = path.relative(root, file);
+		io.stdout(changed ? `wrote ${shown}\n` : `${shown} is up to date\n`);
+		return 0;
+	} catch (error) {
+		return reportBuildError(io, error);
+	}
+};
+/** `dolphy-ext build|types|validate|catalog`; `argv` is without `node` and the script name. */
 const runCli = async (argv, io, deps = {}) => {
 	const parsed = parseArgs(argv);
 	if ("help" in parsed) {
@@ -2036,6 +4292,7 @@ const runCli = async (argv, io, deps = {}) => {
 		return runCatalog(catalog, io, deps);
 	}
 	if (parsed.command === "validate") return runValidate(parsed.dir, io);
+	if (parsed.command === "types") return runTypes(parsed.dir, io);
 	return runBuild(parsed, io, deps);
 };