@soxa-ui/setup 0.0.0-stage → 0.3.0-beta.1

package/dist/protected/adapter/exchange/tap.class.d.ts

@@ -0,0 +1,54 @@
+/**
+ * TTap — слушатель участников: один на шину каждого участника, общий для состояния и событий обмена.
+ *
+ * Состояние (`TStateStore`) и события (`TEventRelay`) слушают одни и те же
+ * шины и подписываются на них не порознь, а через этот объект: слушателей
+ * ставит первый из `state.subscribe` и `events.listen`, снимает последний
+ * ушедший. Слушатель — один на шину (`listen` шины, а не `on` на каждое
+ * событие и каждый триггер), а что делать с событием, он берёт из таблицы
+ * маршрутов типа (`TRouting`). Участник, с событиями которого делать нечего,
+ * и владелец без шины слушателя не получают.
+ *
+ * **Порядок — одно правило на шесть адаптеров**, и задаёт его код, а не
+ * очерёдность подписок:
+ *
+ * - шина отдаёт событие слушателю после всех своих обработчиков `on`, поэтому
+ *   фреймворк узнаёт о событии после подписчиков ядра — и тех, что пришли
+ *   после монтирования;
+ * - внутри обмена сначала перечитывается состояние, потом уходят событие и
+ *   модели: приёмник события видит уже новое состояние.
+ *
+ * Раньше порядок задавала очерёдность подписок: во Vue состояние обновлялось
+ * раньше события, в React — позже, а плагин, поставленный в `bundle:create`,
+ * слышал событие после фреймворка.
+ *
+ * Правило действует в пределах одной шины: событие, которое фасад получил
+ * пробросом `relayAll` (на перехватчике источника), фреймворк слышит раньше
+ * подписчиков самого источника.
+ */
+import type { IRoute } from './types';
+/** Что делать с событием участника: маршрут из таблицы и аргументы события. */
+type TReceiver = (route: IRoute, args: readonly unknown[]) => void;
+export declare class TTap {
+    private readonly _owners;
+    private readonly _routes;
+    private readonly _receive;
+    /** Сколько портов обмена слушают шины: состояние и события. */
+    private _holds;
+    /**
+     * Слушатели по участникам — пока шины слушают; у участника без слушателя пусто.
+     * Снимаются по ссылке (`unlisten`): функция отписки на каждую шину держала бы
+     * ещё по замыканию со своей областью.
+     */
+    private _listeners?;
+    /**
+     * @param _owners владельцы участников монтирования — по порядку состава
+     * @param _routes маршруты участников из таблицы типа — по тому же порядку
+     */
+    constructor(_owners: readonly object[], _routes: readonly (ReadonlyMap<string, IRoute> | undefined)[], _receive: TReceiver);
+    /** Порт начали слушать: первый ставит слушателей на шины участников. */
+    hold(): void;
+    /** Порт перестали слушать: последний снимает слушателей. */
+    release(): void;
+}
+export {};

package/dist/protected/adapter/exchange/tap.class.js

@@ -0,0 +1,51 @@
+import { busOf } from "./value.js";
+//#region protected/adapter/exchange/tap.class.ts
+var TTap = class {
+	_owners;
+	_routes;
+	_receive;
+	/** Сколько портов обмена слушают шины: состояние и события. */
+	_holds = 0;
+	/**
+	* Слушатели по участникам — пока шины слушают; у участника без слушателя пусто.
+	* Снимаются по ссылке (`unlisten`): функция отписки на каждую шину держала бы
+	* ещё по замыканию со своей областью.
+	*/
+	_listeners;
+	/**
+	* @param _owners владельцы участников монтирования — по порядку состава
+	* @param _routes маршруты участников из таблицы типа — по тому же порядку
+	*/
+	constructor(_owners, _routes, _receive) {
+		this._owners = _owners;
+		this._routes = _routes;
+		this._receive = _receive;
+	}
+	/** Порт начали слушать: первый ставит слушателей на шины участников. */
+	hold() {
+		if (this._holds++ > 0) return;
+		this._listeners = this._owners.map((owner, index) => {
+			const routes = this._routes[index];
+			const bus = routes && busOf(owner);
+			if (!routes || !bus) return void 0;
+			const listener = (event, args) => {
+				const route = routes.get(event);
+				if (route) this._receive(route, args);
+			};
+			bus.listen(listener);
+			return listener;
+		});
+	}
+	/** Порт перестали слушать: последний снимает слушателей. */
+	release() {
+		if (this._holds === 0 || --this._holds > 0) return;
+		const listeners = this._listeners;
+		this._listeners = void 0;
+		this._owners.forEach((owner, index) => {
+			const listener = listeners?.[index];
+			if (listener) busOf(owner)?.unlisten(listener);
+		});
+	}
+};
+//#endregion
+export { TTap };

package/dist/protected/adapter/exchange/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Типы обмена: описание участника, маршрут события, слушатели ячейки, состояния и событий.
+ */
+import type { TName, TPropSpec } from '../../define';
+import type { TLine } from './line.class';
+export type TSame<T> = (a: T, b: T) => boolean;
+export type TCellListener<T> = (value: T) => void;
+/** Слушатель состояния: имя свойства во фреймворке и его новое значение. */
+export type TStateListener = (name: string, value: unknown) => void;
+/** Снимок всего состояния: неизменяемый, тот же объект, пока ни одно значение не сменилось. */
+export type TStateSnapshot = Readonly<Record<string, unknown>>;
+/** Приёмник событий: имя во фреймворке и аргументы события ядра. */
+export type TEventSink = (name: string, args: readonly unknown[]) => void;
+/** Listener of the exchange's updates: where an update begins and where it ends (`TUpdatePort`). */
+export interface IUpdateListener {
+    begin(): void;
+    end(): void;
+}
+/**
+ * Описание участника: что владелец объявляет наружу. Свойство типа, а не
+ * монтирования — одно на дескриптор, определение плагина или контракт, и по
+ * нему таблица маршрутов строится один раз на все монтирования.
+ */
+export interface IMemberSpec {
+    readonly props: readonly TPropSpec[];
+    /** Explicit public events of this participant; property triggers stay internal. */
+    readonly events: readonly TName[];
+}
+/** Модель, которая уходит следом за событием: линия свойства и имя события привязки. */
+export interface IModelRoute {
+    /** Линия свойства, чьё новое значение уходит с моделью. */
+    readonly line: TLine;
+    /** Имя события привязки во фреймворке: `update:text`. */
+    readonly name: string;
+}
+/** Что обмен делает с событием участника. */
+export interface IRoute {
+    /** Значения состояния, для чьих свойств событие — триггер: индексы в состоянии обмена. */
+    readonly cells: readonly number[];
+    /** Имя события во фреймворке — если участник его публикует. */
+    readonly event?: string;
+    /** Model updates driven by property triggers, even when the source event is internal. */
+    readonly models: readonly IModelRoute[];
+}
+/** Слушатель всех событий шины: сырое имя и аргументы. */
+export type TBusListener = (event: string, args: readonly unknown[]) => void;
+/**
+ * Нетипизированный вид шины владельца: имена событий слой знает строками из
+ * дескриптора. Обмену хватает слушателя всех событий — подписок на имена у
+ * него нет. Снимается слушатель по ссылке, как `off` снимает `on`.
+ */
+export interface IBus {
+    listen(listener: TBusListener): void;
+    unlisten(listener: TBusListener): void;
+}

package/dist/protected/adapter/exchange/update-port.class.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TUpdatePort — the exchange tells the framework where an update begins and ends.
+ *
+ * An update is the exchange's unit of work: one event of a participant (the
+ * state rereads the event's properties, then the event and its models go to
+ * the sinks) or one release of the queue after another mount's assembly
+ * (`TExchange`). The port only reports the bounds — what the framework does
+ * with them is the adapter's call. The exchange marks every update, nested
+ * ones too: a sink that writes to a participant starts an update inside the
+ * current one, and a listener that needs only the outermost counts them
+ * itself. `end` comes even when a sink throws.
+ *
+ * No listener — nothing is called: an exchange of a plugin installed from
+ * outside has no framework to tell.
+ */
+import type { IUpdateListener } from './types';
+export declare class TUpdatePort {
+    /** Listeners — while there is at least one. The list is not edited in place: a bound goes to the one it found. */
+    private _listeners?;
+    listen(listener: IUpdateListener): () => void;
+    /** An update begins. Called by the exchange, not by the adapter. */
+    begin(): void;
+    /** The update ended — its state reread and its events handed over. Called by the exchange. */
+    end(): void;
+}

package/dist/protected/adapter/exchange/update-port.class.js

@@ -0,0 +1,26 @@
+//#region protected/adapter/exchange/update-port.class.ts
+var TUpdatePort = class {
+	/** Listeners — while there is at least one. The list is not edited in place: a bound goes to the one it found. */
+	_listeners;
+	listen(listener) {
+		this._listeners = this._listeners ? [...this._listeners, listener] : [listener];
+		return () => {
+			const listeners = this._listeners;
+			const index = listeners?.indexOf(listener) ?? -1;
+			if (listeners === void 0 || index === -1) return;
+			this._listeners = listeners.length === 1 ? void 0 : [...listeners.slice(0, index), ...listeners.slice(index + 1)];
+		};
+	}
+	/** An update begins. Called by the exchange, not by the adapter. */
+	begin() {
+		const listeners = this._listeners;
+		if (listeners) for (const listener of listeners) listener.begin();
+	}
+	/** The update ended — its state reread and its events handed over. Called by the exchange. */
+	end() {
+		const listeners = this._listeners;
+		if (listeners) for (const listener of listeners) listener.end();
+	}
+};
+//#endregion
+export { TUpdatePort };

package/dist/protected/adapter/exchange/value.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Правила о значении на границе: «то же самое» и шина владельца.
+ *
+ * Каждое правило записано один раз: `sameValue` — правило равенства ячеек
+ * входа и состояния и сверка начального значения с умолчанием (`TLine.seed`);
+ * `busOf` — единственное место, которое знает, где у владельца шина. Запись
+ * в ядро `sameValue` не сверяет: то же ли значение, решает сеттер владельца.
+ */
+import type { IBus } from './types';
+/** Шина — `owner.events`, а без поля `events` — сам владелец; без `listen` и `unlisten` источника событий нет. */
+export declare function busOf(owner: object): IBus | undefined;
+/**
+ * Составные значения дают новый объект на каждое чтение (снимок `valueOf()`),
+ * поэтому простые объекты и массивы сверяются по содержимому (поверхностно),
+ * остальное — по идентичности.
+ */
+export declare function sameValue(a: unknown, b: unknown): boolean;

package/dist/protected/adapter/exchange/value.js

@@ -0,0 +1,31 @@
+//#region protected/adapter/exchange/value.ts
+function isBus(value) {
+	return typeof value === "object" && value !== null && typeof Reflect.get(value, "listen") === "function" && typeof Reflect.get(value, "unlisten") === "function";
+}
+/** Шина — `owner.events`, а без поля `events` — сам владелец; без `listen` и `unlisten` источника событий нет. */
+function busOf(owner) {
+	const events = Reflect.get(owner, "events");
+	if (isBus(events)) return events;
+	return isBus(owner) ? owner : void 0;
+}
+function isPlain(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Составные значения дают новый объект на каждое чтение (снимок `valueOf()`),
+* поэтому простые объекты и массивы сверяются по содержимому (поверхностно),
+* остальное — по идентичности.
+*/
+function sameValue(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, index) => Object.is(item, b[index]));
+	if (isPlain(a) && isPlain(b)) {
+		const keys = Object.keys(a);
+		return keys.length === Object.keys(b).length && keys.every((key) => key in b && Object.is(Reflect.get(a, key), Reflect.get(b, key)));
+	}
+	return false;
+}
+//#endregion
+export { busOf, sameValue };

package/dist/protected/adapter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './context';
+export * from './surface';
+export * from './exchange';
+export * from './common';
+export * from './elevator';

package/dist/protected/adapter/surface/index.d.ts

@@ -0,0 +1,2 @@
+export { TSurface } from './surface.class';
+export type { ISurfaceEvent, ISurfaceProp, ISurfaceSource, TSurfacePropConfig } from './types';

package/dist/protected/adapter/surface/surface.class.d.ts

@@ -0,0 +1,34 @@
+/**
+ * TSurface describes the public component API for one descriptor and framework profile.
+ *
+ * Only explicit event declarations are public; property triggers drive state and models.
+ */
+import type { TPropSpec } from '../../define';
+import type { IAdapterProfile } from '../../naming';
+import type { ISurfaceEvent, ISurfaceProp, ISurfaceSource, TSurfacePropConfig } from './types';
+export declare class TSurface {
+    /** Все свойства, в порядке объявления: свои, затем плагинов. */
+    readonly props: readonly ISurfaceProp[];
+    /** Only explicitly declared component and plugin events are public. */
+    readonly events: readonly ISurfaceEvent[];
+    /** Статический слой: пропсы, записываемые снаружи, с типом и умолчанием. */
+    readonly exportProps: Readonly<Record<string, TSurfacePropConfig>>;
+    /** Статический слой: имена событий и событий привязки, без повторов. */
+    readonly exportEvents: readonly string[];
+    /** Имена, которые компонент «съедает»: остальное React, Solid и Svelte отдают в корневой узел. */
+    readonly consumed: ReadonlySet<string>;
+    private readonly _byName;
+    /** Поверхность описания в профиле фреймворка; строится один раз на пару. */
+    static of(source: ISurfaceSource, profile: IAdapterProfile): TSurface;
+    private constructor();
+    /**
+     * Запись поверхности по описанию — так обмен получает имя для своей линии.
+     *
+     * Ключ — объект имени (`TName`), а не строка и не само описание: имя создаётся
+     * один раз на объявление и переживает пересчёт умолчаний (`rebase`), поэтому
+     * описание наследника и описание с умолчанием владельца находят ту же запись.
+     */
+    entryOf(spec: TPropSpec): ISurfaceProp | undefined;
+    /** Пропсы, которые компонент не съел: уходят атрибутами в корневой узел. */
+    forward<TProps extends object>(props: TProps): Partial<TProps>;
+}

package/dist/protected/adapter/surface/surface.class.js

@@ -0,0 +1,87 @@
+import { resolveSlotName } from "../common/slots.js";
+//#region protected/adapter/surface/surface.class.ts
+var surfaces = /* @__PURE__ */ new WeakMap();
+function exportConfig(spec) {
+	return {
+		...spec.type !== void 0 ? { type: spec.type } : {},
+		...spec.hasDefault ? { default: spec.default } : {}
+	};
+}
+var TSurface = class TSurface {
+	/** Все свойства, в порядке объявления: свои, затем плагинов. */
+	props;
+	/** Only explicitly declared component and plugin events are public. */
+	events;
+	/** Статический слой: пропсы, записываемые снаружи, с типом и умолчанием. */
+	exportProps;
+	/** Статический слой: имена событий и событий привязки, без повторов. */
+	exportEvents;
+	/** Имена, которые компонент «съедает»: остальное React, Solid и Svelte отдают в корневой узел. */
+	consumed;
+	_byName;
+	/** Поверхность описания в профиле фреймворка; строится один раз на пару. */
+	static of(source, profile) {
+		let byProfile = surfaces.get(source);
+		if (!byProfile) {
+			byProfile = /* @__PURE__ */ new WeakMap();
+			surfaces.set(source, byProfile);
+		}
+		let surface = byProfile.get(profile);
+		if (!surface) {
+			surface = new TSurface(source, profile);
+			byProfile.set(profile, surface);
+		}
+		return surface;
+	}
+	constructor(source, profile) {
+		const { naming, defaultSlot, model } = profile;
+		this.props = source.getProps().map((spec) => {
+			const exportName = naming.prop(spec.name);
+			return model && !spec.protected && spec.triggers.length > 0 ? {
+				spec,
+				exportName,
+				model: model(exportName)
+			} : {
+				spec,
+				exportName
+			};
+		});
+		this._byName = new Map(this.props.map((prop) => [prop.spec.name, prop]));
+		const published = /* @__PURE__ */ new Map();
+		for (const name of source.getEvents()) if (!published.has(name.getName())) published.set(name.getName(), name);
+		this.events = [...published.values()].map((name) => ({
+			name,
+			exportName: naming.event(name)
+		}));
+		this.exportProps = Object.fromEntries(this.props.filter((prop) => !prop.spec.protected).map((prop) => [prop.exportName, exportConfig(prop.spec)]));
+		this.exportEvents = [.../* @__PURE__ */ new Set([...this.events.map((event) => event.exportName), ...this.props.flatMap((prop) => prop.model === void 0 ? [] : [prop.model])])];
+		const consumed = /* @__PURE__ */ new Set(["ctrl", "embedded"]);
+		for (const prop of this.props) {
+			consumed.add(prop.exportName);
+			consumed.add(prop.spec.name.name);
+		}
+		for (const event of this.events) consumed.add(event.exportName);
+		for (const slot of source.slots ?? []) consumed.add(defaultSlot ? resolveSlotName(slot.name, defaultSlot) : slot.name);
+		if (defaultSlot) consumed.add(defaultSlot);
+		this.consumed = consumed;
+		Object.freeze(this);
+	}
+	/**
+	* Запись поверхности по описанию — так обмен получает имя для своей линии.
+	*
+	* Ключ — объект имени (`TName`), а не строка и не само описание: имя создаётся
+	* один раз на объявление и переживает пересчёт умолчаний (`rebase`), поэтому
+	* описание наследника и описание с умолчанием владельца находят ту же запись.
+	*/
+	entryOf(spec) {
+		return this._byName.get(spec.name);
+	}
+	/** Пропсы, которые компонент не съел: уходят атрибутами в корневой узел. */
+	forward(props) {
+		const rest = {};
+		for (const key of Object.keys(props)) if (!this.consumed.has(key)) Reflect.set(rest, key, Reflect.get(props, key));
+		return rest;
+	}
+};
+//#endregion
+export { TSurface };

package/dist/protected/adapter/surface/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Записи поверхности: проп и событие в именах фреймворка — по ссылке на описание, без его копий.
+ */
+import type { ISlotDeclaration, TName, TPropSpec } from '../../define';
+/** То, по чему строится поверхность: дескриптор компонента или объявление плагина. */
+export interface ISurfaceSource {
+    getProps(): readonly TPropSpec[];
+    getEvents(): readonly TName[];
+    readonly slots?: readonly ISlotDeclaration[];
+}
+export interface ISurfaceProp {
+    /** Описание свойства: тип, `protected`, триггеры и умолчание читаются у него, копий здесь нет. */
+    readonly spec: TPropSpec;
+    /** Имя пропа во фреймворке: `text`, `aria_label`. */
+    readonly exportName: string;
+    /** Событие двусторонней привязки (`update:text`) — у записываемого пропа с триггерами, если привязку знает профиль. */
+    readonly model?: string;
+}
+export interface ISurfaceEvent {
+    /** Имя у владельца: `name.name` — на что подписываться, `name.namespace` — у кого. */
+    readonly name: TName;
+    /** Имя события во фреймворке: `change:text`, `so:change:text`, `onChangeText`, `soChangeText`. */
+    readonly exportName: string;
+}
+/** Объявление пропа для статического слоя: ключ `default` есть, только если умолчание объявлено. */
+export type TSurfacePropConfig = {
+    type?: unknown;
+    default?: unknown;
+};

package/dist/protected/define/component-descriptor.class.d.ts

@@ -0,0 +1,55 @@
+/**
+ * TComponentDescriptor — дескриптор компонента: своё объявление поверх родительского.
+ *
+ * Наследник получает пропсы, события и плагины `extends` и добавляет своё.
+ * Правило у пропсов и плагинов одно: своё с тем же ключом ложится на
+ * родительское и остаётся на его месте (`inheritDeclarations`). Что значит
+ * «поверх», дескриптор не решает — это знает само объявление
+ * (`IDeclaration`): плагин того же класса встаёт целиком, а проп
+ * переобъявляет ровно те факты, которые наследник написал. Так `size` у
+ * элемента коллекции становится защищённым — входом он быть перестаёт, — а
+ * тип и триггеры остаются объявленными один раз, у того, кто проп завёл.
+ *
+ * Слоты не наследуются: дескриптор объявляет ровно те, что рисует разметка
+ * его компонента. Пропсы, события и плагины описывают экземпляр ядра, а класс
+ * потомка наследует класс родителя (`ctor`), поэтому унаследованное
+ * объявление правдиво. Слоты описывают шаблон, а шаблон не наследуется: у
+ * каждого компонента в каждом адаптере своя разметка. Унаследованный слот —
+ * обещание о разметке от того, кто её не рисует: так `default` ComponentView
+ * доставался Icon, Input и CheckBox, и содержимое, которое тип пропускал,
+ * молча пропадало.
+ *
+ * События — не объявления, а имена: фактов, которые можно переобъявить, у них
+ * нет, и повтор имени — дубль, а не уточнение. Поэтому они копятся списком, и
+ * о повторе дескриптор сообщает (`reportDuplicateNames`).
+ *
+ * Умолчание пропа — от итогового `ctor` и пересчётом, а не копией
+ * родительского: наследник вправе поменять значение (у Frame
+ * `visible: false`, у ComponentView — `true`). Плагинов это не касается:
+ * умолчания их пропсов знает определение плагина.
+ *
+ * Описания заморожены: дескриптор строится один раз на тип
+ * (`defineDescriptor`) и один на все монтирования, а родительские описания
+ * делят все наследники. Правка массива у одного потребителя молча сломала бы
+ * остальных.
+ *
+ * Контракта в типе у класса нет: `ctor` без своего и без родителя — `Object`, и
+ * связать его с выведенным инстансом можно только в типах. Контракт
+ * приписывает сигнатура `defineComponent`.
+ */
+import type { TName } from './name.class';
+import type { TPropSpec } from './prop-spec.class';
+import type { TSlotDeclaration } from './slot-declaration.class';
+import type { IComponentDescriptor, IComponentOptions, IPluginDefinition, TComponentCtor } from './types';
+export declare class TComponentDescriptor implements IComponentDescriptor {
+    readonly ctor: TComponentCtor;
+    readonly props: readonly TPropSpec[];
+    readonly events: readonly TName[];
+    readonly slots: readonly TSlotDeclaration[];
+    readonly plugins: readonly IPluginDefinition[];
+    private readonly _allProps;
+    private readonly _allEvents;
+    constructor(options: IComponentOptions);
+    getProps(): readonly TPropSpec[];
+    getEvents(): readonly TName[];
+}

package/dist/protected/define/component-descriptor.class.js

@@ -0,0 +1,112 @@
+import { normalizeContribution } from "./contribution.js";
+import { inheritDeclarations } from "./inherit.js";
+//#region protected/define/component-descriptor.class.ts
+/**
+* TComponentDescriptor — дескриптор компонента: своё объявление поверх родительского.
+*
+* Наследник получает пропсы, события и плагины `extends` и добавляет своё.
+* Правило у пропсов и плагинов одно: своё с тем же ключом ложится на
+* родительское и остаётся на его месте (`inheritDeclarations`). Что значит
+* «поверх», дескриптор не решает — это знает само объявление
+* (`IDeclaration`): плагин того же класса встаёт целиком, а проп
+* переобъявляет ровно те факты, которые наследник написал. Так `size` у
+* элемента коллекции становится защищённым — входом он быть перестаёт, — а
+* тип и триггеры остаются объявленными один раз, у того, кто проп завёл.
+*
+* Слоты не наследуются: дескриптор объявляет ровно те, что рисует разметка
+* его компонента. Пропсы, события и плагины описывают экземпляр ядра, а класс
+* потомка наследует класс родителя (`ctor`), поэтому унаследованное
+* объявление правдиво. Слоты описывают шаблон, а шаблон не наследуется: у
+* каждого компонента в каждом адаптере своя разметка. Унаследованный слот —
+* обещание о разметке от того, кто её не рисует: так `default` ComponentView
+* доставался Icon, Input и CheckBox, и содержимое, которое тип пропускал,
+* молча пропадало.
+*
+* События — не объявления, а имена: фактов, которые можно переобъявить, у них
+* нет, и повтор имени — дубль, а не уточнение. Поэтому они копятся списком, и
+* о повторе дескриптор сообщает (`reportDuplicateNames`).
+*
+* Умолчание пропа — от итогового `ctor` и пересчётом, а не копией
+* родительского: наследник вправе поменять значение (у Frame
+* `visible: false`, у ComponentView — `true`). Плагинов это не касается:
+* умолчания их пропсов знает определение плагина.
+*
+* Описания заморожены: дескриптор строится один раз на тип
+* (`defineDescriptor`) и один на все монтирования, а родительские описания
+* делят все наследники. Правка массива у одного потребителя молча сломала бы
+* остальных.
+*
+* Контракта в типе у класса нет: `ctor` без своего и без родителя — `Object`, и
+* связать его с выведенным инстансом можно только в типах. Контракт
+* приписывает сигнатура `defineComponent`.
+*/
+/**
+* Корень цепочки наследования: дескриптор без объявлений.
+*
+* Пустой родитель отвечает на те же вопросы, что настоящий, поэтому «родителя
+* нет» — не развилка в сборке: без него `parent?.x ?? []` стояло бы у каждой
+* категории, и следующая добавила бы ещё одно. Наружу не выходит: у
+* дескриптора без `extends` родителем остаётся он.
+*/
+var ROOT = Object.freeze({
+	ctor: Object,
+	props: [],
+	events: [],
+	slots: [],
+	plugins: [],
+	getProps: () => [],
+	getEvents: () => []
+});
+/**
+* Полное имя уникально в составе компонента: по нему проп и событие находят и
+* во фреймворке, и в ядре. Это свойство типа, поэтому сверяется один раз, при
+* построении дескриптора, а не на каждом монтировании.
+*
+* Дубль — ошибка автора дескриптора, и отвечает за неё он: слой сообщает в
+* консоль и работает дальше, а не роняет приложение. Развести имена плагинов
+* помогает неймспейс; проконтролировать автора полностью слой не может и не
+* пытается.
+*
+* Триггеры пропсов сюда не входят: одно событие — законный триггер нескольких
+* свойств (`change:visible` у `visible` и `present`), и наружу оно уходит один
+* раз — это держит поверхность.
+*/
+function reportDuplicateNames(ctor, kind, names) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of names) {
+		const name = item.getName();
+		if (seen.has(name)) console.error(`${ctor.name}: ${kind} «${name}» объявлено дважды — полное имя обязано быть одно`);
+		seen.add(name);
+	}
+}
+var TComponentDescriptor = class {
+	ctor;
+	props;
+	events;
+	slots;
+	plugins;
+	_allProps;
+	_allEvents;
+	constructor(options) {
+		const parent = options.extends ?? ROOT;
+		const own = normalizeContribution(options.contribution);
+		const ctor = options.ctor ?? parent.ctor;
+		this.ctor = ctor;
+		this.props = Object.freeze(inheritDeclarations(parent.props, own.props).map((prop) => prop.rebase(ctor.defaultValues)));
+		this.events = Object.freeze([...parent.events, ...own.events]);
+		this.slots = Object.freeze(own.slots);
+		this.plugins = Object.freeze(inheritDeclarations(parent.plugins, options.plugins ?? []));
+		this._allProps = Object.freeze([...this.props, ...this.plugins.flatMap((plugin) => plugin.props)]);
+		this._allEvents = Object.freeze([...this.events, ...this.plugins.flatMap((plugin) => plugin.events)]);
+		reportDuplicateNames(ctor, "свойство", this._allProps.map((prop) => prop.name));
+		reportDuplicateNames(ctor, "событие", this._allEvents);
+	}
+	getProps() {
+		return this._allProps;
+	}
+	getEvents() {
+		return this._allEvents;
+	}
+};
+//#endregion
+export { TComponentDescriptor };

package/dist/protected/define/component.d.ts

@@ -0,0 +1,14 @@
+/**
+ * defineComponent infers a component contract from its class and declarations.
+ * Public events come only from explicit `events`, including inherited declarations.
+ */
+import type { TCheckedEventNames, TContractFrom } from './inference.types';
+import type { IComponentDescriptor, IComponentOptions } from './types';
+/**
+ * Параметр типа один — сами опции, и явно его не передают. `const`: опции
+ * запоминаются литералом, иначе имена событий, триггеров и слотов вывелись бы
+ * `string`, а неймспейсы плагинов пропали бы из типов адаптеров.
+ *
+ * Имена событий сверяются с картой событий инстанса (`TCheckedEventNames`).
+ */
+export declare function defineComponent<const TOptions extends IComponentOptions>(options: TOptions & TCheckedEventNames<TOptions>): IComponentDescriptor<TContractFrom<TOptions>>;

package/dist/protected/define/component.js

@@ -0,0 +1,12 @@
+import { TComponentDescriptor } from "./component-descriptor.class.js";
+//#region protected/define/component.ts
+/**
+* defineComponent infers a component contract from its class and declarations.
+* Public events come only from explicit `events`, including inherited declarations.
+*/
+/** Тело — под сигнатурой без контракта: рантайму он не нужен (см. `TComponentDescriptor`). */
+function defineComponent(options) {
+	return new TComponentDescriptor(options);
+}
+//#endregion
+export { defineComponent };