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

package/dist/protected/adapter/context/adapter-context.class.d.ts

@@ -0,0 +1,68 @@
+/**
+ * TAdapterContext — a component for the time of its mount: instance, bundle,
+ * exchange and extensions. Extensions are keyed by their class, as
+ * `TPluginBundle` keys plugins.
+ *
+ * `bindElement` is a method of the context, not an extension: all six adapters
+ * bind the root to `TElementPlugin`, and an extension each of them would have
+ * to remember to install.
+ *
+ * The context's life is four phases: assembled, accepted by the framework
+ * (`attach`), being removed (`detach`), destroyed. When the second and the
+ * third come only the adapter's runtime knows: acceptance is the assembly
+ * itself for Vue, Solid, Svelte, Angular and Web Components and the commit for
+ * React; removal begins before the children go. So a phase is a method of the
+ * context, as `bindElement` is, not a step every component remembers. The
+ * context reports a phase and does nothing on it: what follows is up to those
+ * who listen.
+ *
+ * The exchange members and the assembly props are held until the first
+ * `connect()`: extensions read the props in their constructors (a collection
+ * item's `meta`), the exchange starts its input memory from them and finds
+ * its routes and owners by the members. From then on the exchange lives on
+ * its own values, and the context lets both go: the props may be a snapshot
+ * of one framework pass, and held until unmount they would keep stale values —
+ * a table's previous row list with all its records.
+ *
+ * One exchange per mount: the first `connect()` creates it, a repeat with the
+ * same profile returns it — a framework may call the binding's initializer
+ * twice, and there are no assembly props left to start a second one. Another
+ * profile is an error: one mount, one framework.
+ *
+ * The event bus and the extension list are created on first access: a
+ * collection facade and a component without extensions have none.
+ */
+import { TEvented } from '@soxa-ui/core';
+import type { IPluginBundle } from '@soxa-ui/plugins';
+import type { IComponentContract, IComponentDescriptor } from '../../define';
+import type { IAdapterProfile } from '../../naming';
+import { TExchange } from '../exchange/exchange.class';
+import type { TMember } from '../exchange/member.class';
+import type { IAdapterContext, IBundleTenancy, TAdapterEvents, TAnyExtensionCtor } from './types';
+export declare class TAdapterContext<C extends IComponentContract> implements IAdapterContext<C> {
+    readonly descriptor: IComponentDescriptor;
+    readonly instance: C['instance'];
+    private readonly _tenancy;
+    readonly embedded: string | undefined;
+    private _events?;
+    /**
+     * Extensions, from the first one. A list, not a map by class: a context
+     * usually has one extension, and a map would cost three times as much.
+     */
+    private _extensions?;
+    /** Before the first `connect()` — the members and assembly props, after it — the mount's exchange. */
+    private _link;
+    /** `detach` came: it comes once, from the runtime or from the collection. */
+    private _detached;
+    constructor(descriptor: IComponentDescriptor, instance: C['instance'], _tenancy: IBundleTenancy, members: readonly TMember[], props: object, embedded: string | undefined);
+    get events(): TEvented<TAdapterEvents>;
+    get bundle(): IPluginBundle | null;
+    get props(): object | undefined;
+    connect(profile: IAdapterProfile): TExchange;
+    use(ExtensionCtor: TAnyExtensionCtor, options?: unknown): this;
+    get<T>(ExtensionCtor: new (...args: any[]) => T): T | undefined;
+    bindElement(element: Element | null): void;
+    attach(): void;
+    detach(): void;
+    destroy(): void;
+}

package/dist/protected/adapter/context/adapter-context.class.js

@@ -0,0 +1,118 @@
+import { TSurface } from "../surface/surface.class.js";
+import { TExchange } from "../exchange/exchange.class.js";
+import { TEvented } from "@soxa-ui/core";
+import { TElementPlugin } from "@soxa-ui/plugins";
+//#region protected/adapter/context/adapter-context.class.ts
+/**
+* TAdapterContext — a component for the time of its mount: instance, bundle,
+* exchange and extensions. Extensions are keyed by their class, as
+* `TPluginBundle` keys plugins.
+*
+* `bindElement` is a method of the context, not an extension: all six adapters
+* bind the root to `TElementPlugin`, and an extension each of them would have
+* to remember to install.
+*
+* The context's life is four phases: assembled, accepted by the framework
+* (`attach`), being removed (`detach`), destroyed. When the second and the
+* third come only the adapter's runtime knows: acceptance is the assembly
+* itself for Vue, Solid, Svelte, Angular and Web Components and the commit for
+* React; removal begins before the children go. So a phase is a method of the
+* context, as `bindElement` is, not a step every component remembers. The
+* context reports a phase and does nothing on it: what follows is up to those
+* who listen.
+*
+* The exchange members and the assembly props are held until the first
+* `connect()`: extensions read the props in their constructors (a collection
+* item's `meta`), the exchange starts its input memory from them and finds
+* its routes and owners by the members. From then on the exchange lives on
+* its own values, and the context lets both go: the props may be a snapshot
+* of one framework pass, and held until unmount they would keep stale values —
+* a table's previous row list with all its records.
+*
+* One exchange per mount: the first `connect()` creates it, a repeat with the
+* same profile returns it — a framework may call the binding's initializer
+* twice, and there are no assembly props left to start a second one. Another
+* profile is an error: one mount, one framework.
+*
+* The event bus and the extension list are created on first access: a
+* collection facade and a component without extensions have none.
+*/
+/** The extension was created by this very class, not by a subclass or a base. */
+function isExact(extension, ExtensionCtor) {
+	return typeof extension === "object" && extension !== null && Object.getPrototypeOf(extension) === ExtensionCtor.prototype;
+}
+var TAdapterContext = class {
+	descriptor;
+	instance;
+	_tenancy;
+	embedded;
+	_events;
+	/**
+	* Extensions, from the first one. A list, not a map by class: a context
+	* usually has one extension, and a map would cost three times as much.
+	*/
+	_extensions;
+	/** Before the first `connect()` — the members and assembly props, after it — the mount's exchange. */
+	_link;
+	/** `detach` came: it comes once, from the runtime or from the collection. */
+	_detached = false;
+	constructor(descriptor, instance, _tenancy, members, props, embedded) {
+		this.descriptor = descriptor;
+		this.instance = instance;
+		this._tenancy = _tenancy;
+		this.embedded = embedded;
+		this._link = {
+			members,
+			props
+		};
+	}
+	get events() {
+		return this._events ??= new TEvented();
+	}
+	get bundle() {
+		return this._tenancy.bundle;
+	}
+	get props() {
+		return this._link instanceof TExchange ? void 0 : this._link.props;
+	}
+	connect(profile) {
+		const surface = TSurface.of(this.descriptor, profile);
+		const link = this._link;
+		const exchange = link instanceof TExchange ? link : new TExchange(link.members, surface, link.props);
+		if (exchange.surface !== surface) throw new Error(`Обмен ${this.descriptor.ctor.name} уже заведён в другом профиле: одно монтирование — один фреймворк`);
+		this._link = exchange;
+		return exchange;
+	}
+	use(ExtensionCtor, options) {
+		const extension = new ExtensionCtor(this, options);
+		const extensions = this._extensions ??= [];
+		const index = extensions.findIndex((current) => isExact(current, ExtensionCtor));
+		if (index === -1) extensions.push(extension);
+		else extensions[index] = extension;
+		return this;
+	}
+	get(ExtensionCtor) {
+		const extension = this._extensions?.find((current) => isExact(current, ExtensionCtor));
+		return extension instanceof ExtensionCtor ? extension : void 0;
+	}
+	bindElement(element) {
+		const plugin = this.bundle?.get(TElementPlugin);
+		if (plugin) plugin.element = element;
+	}
+	attach() {
+		this._events?.emit("attach");
+	}
+	detach() {
+		if (this._detached) return;
+		this._detached = true;
+		this._events?.emit("detach");
+	}
+	destroy() {
+		this.detach();
+		this._events?.emit("destroy");
+		this._extensions = void 0;
+		this._tenancy.destroy();
+	}
+};
+//#endregion
+export { TAdapterContext };

package/dist/protected/adapter/context/create-adapter-context.d.ts

@@ -0,0 +1,34 @@
+/**
+ * createAdapterContext — сборка компонента на монтирование: шесть шагов, сверху вниз.
+ *
+ * 1. Инстанс — `ctrl` или конструктор дескриптора.
+ * 2–3. Набор плагинов: свой (`TOwnBundle`, с id монтирования `mountId` и
+ *    локалью поддерева `locale`) или не свой (`TSharedBundle`).
+ * 4. Участники обмена: инстанс, затем то, что даёт набор.
+ * 5. Начальные значения — здесь и только здесь, одинаково для всех адаптеров:
+ *    свой инстанс получил пропсы конструктором, и второй раз они не пишутся
+ *    (сеттер `items` фасада пересоздал бы элементы); внешнему `ctrl` пишутся
+ *    сеттерами; участникам набора — если набор свой. Порядок: инстанс, плагины
+ *    дескриптора, связка — а плагины снаружи получают своё, когда встают.
+ *    Обмен для этого не заводится: записи нужны только линии участников и
+ *    пропсы сборки, а состояние, входы и события соберёт `connect()`.
+ * 6. Завершение набора: плагины реестра и объявление наружу на микрозадаче.
+ *
+ * Шаги 2–6 идут над инстансом атомарно для остальных его монтирований
+ * (`TAssembling`): их состояние перечитается после сборки, а не посреди неё.
+ *
+ * Имя пропа одно во всех фреймворках, поэтому профиль адаптера сборке не нужен:
+ * начальные значения идут в общем формате имён (`CommonProfile`).
+ */
+import type { IComponentDescriptor, IPluginsContract } from '../../define';
+import type { IAdapterContext, IAdapterContextConfig, IAdapterContextOptions, TContextContract } from './types';
+/**
+ * Тип контекста выводится из дескриптора, дженерики адаптер не пишет.
+ *
+ * Инстанс сводится из двух источников — `ctor` дескриптора и `ctrl`. Адаптер
+ * объявляет `ctrl` интерфейсом ядра (`IButton`), класс дескриптора
+ * (`TButton`) его реализует, и контекст обещает интерфейс: под `ctrl` приходит
+ * любая его реализация. `ctrl` чужого компонента не компилируется — класс
+ * дескриптора его тип не реализует.
+ */
+export declare function createAdapterContext<TInstance extends object, TPlugins extends IPluginsContract>(descriptor: IComponentDescriptor<TContextContract<TInstance, TPlugins>>, options: IAdapterContextOptions<TInstance>, config?: IAdapterContextConfig): IAdapterContext<TContextContract<TInstance, TPlugins>>;

package/dist/protected/adapter/context/create-adapter-context.js

@@ -0,0 +1,91 @@
+import { PLUGIN_PROPS } from "../../naming/naming.js";
+import { CommonProfile } from "../../naming/common-profile.js";
+import { assembling } from "../exchange/assembling.class.js";
+import { TInputPort } from "../exchange/input-port.class.js";
+import { TMember } from "../exchange/member.class.js";
+import { TSurface } from "../surface/surface.class.js";
+import { TAdapterContext } from "./adapter-context.class.js";
+import { TOwnBundle } from "./own-bundle.class.js";
+import { TSharedBundle } from "./shared-bundle.class.js";
+//#region protected/adapter/context/create-adapter-context.ts
+/**
+* createAdapterContext — сборка компонента на монтирование: шесть шагов, сверху вниз.
+*
+* 1. Инстанс — `ctrl` или конструктор дескриптора.
+* 2–3. Набор плагинов: свой (`TOwnBundle`, с id монтирования `mountId` и
+*    локалью поддерева `locale`) или не свой (`TSharedBundle`).
+* 4. Участники обмена: инстанс, затем то, что даёт набор.
+* 5. Начальные значения — здесь и только здесь, одинаково для всех адаптеров:
+*    свой инстанс получил пропсы конструктором, и второй раз они не пишутся
+*    (сеттер `items` фасада пересоздал бы элементы); внешнему `ctrl` пишутся
+*    сеттерами; участникам набора — если набор свой. Порядок: инстанс, плагины
+*    дескриптора, связка — а плагины снаружи получают своё, когда встают.
+*    Обмен для этого не заводится: записи нужны только линии участников и
+*    пропсы сборки, а состояние, входы и события соберёт `connect()`.
+* 6. Завершение набора: плагины реестра и объявление наружу на микрозадаче.
+*
+* Шаги 2–6 идут над инстансом атомарно для остальных его монтирований
+* (`TAssembling`): их состояние перечитается после сборки, а не посреди неё.
+*
+* Имя пропа одно во всех фреймворках, поэтому профиль адаптера сборке не нужен:
+* начальные значения идут в общем формате имён (`CommonProfile`).
+*/
+/**
+* Пропсы связки, а не инстанса: `ctrl` и `embedded` читаются один раз при
+* сборке и в обмене не участвуют, `pluginProps` принимает связка
+* (`TExternalPlugins`). Это имена опций самого `createAdapterContext`.
+*/
+var MOUNT_PROPS = /* @__PURE__ */ new Set([
+	"ctrl",
+	"embedded",
+	PLUGIN_PROPS
+]);
+var instanceSpecs = /* @__PURE__ */ new WeakMap();
+/**
+* Описание участника-инстанса: пропсы и события дескриптора без пропсов
+* связки. Одно на дескриптор, а не фильтр на каждое монтирование: по нему
+* обмен находит таблицу маршрутов своего типа (`TRouting`).
+*/
+function instanceSpecOf(descriptor) {
+	let spec = instanceSpecs.get(descriptor);
+	if (!spec) {
+		spec = Object.freeze({
+			props: Object.freeze(descriptor.props.filter((prop) => !MOUNT_PROPS.has(prop.name.name))),
+			events: descriptor.events
+		});
+		instanceSpecs.set(descriptor, spec);
+	}
+	return spec;
+}
+/** Не задан опцией — читается из пропсов: проп объявлен у всех компонентов, и помнить отдельный шаг не обязан ни один адаптер. */
+function embeddedOf(options) {
+	if (options.embedded !== void 0) return options.embedded;
+	const value = options.props ? Reflect.get(options.props, "embedded") : void 0;
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Тип контекста выводится из дескриптора, дженерики адаптер не пишет.
+*
+* Инстанс сводится из двух источников — `ctor` дескриптора и `ctrl`. Адаптер
+* объявляет `ctrl` интерфейсом ядра (`IButton`), класс дескриптора
+* (`TButton`) его реализует, и контекст обещает интерфейс: под `ctrl` приходит
+* любая его реализация. `ctrl` чужого компонента не компилируется — класс
+* дескриптора его тип не реализует.
+*/
+function createAdapterContext(descriptor, options, config = {}) {
+	const props = options.props ?? {};
+	const embedded = embeddedOf(options);
+	const instance = options.ctrl ?? new descriptor.ctor(props, options.options ?? {});
+	return assembling.run(instance, () => {
+		const tenancy = config.bundle === void 0 && descriptor.plugins.length > 0 ? new TOwnBundle(descriptor, instance, { embedded }, options) : new TSharedBundle(descriptor, config.bundle ?? null);
+		const owner = new TMember(instance, instanceSpecOf(descriptor));
+		const own = tenancy.members();
+		const members = [owner, ...own];
+		const seeded = options.ctrl ? [owner, ...tenancy.seeded(own)] : tenancy.seeded(own);
+		if (seeded.length > 0) TInputPort.seed(seeded, TSurface.of(descriptor, CommonProfile), props);
+		tenancy.complete();
+		return new TAdapterContext(descriptor, instance, tenancy, members, props, embedded);
+	});
+}
+//#endregion
+export { createAdapterContext };

package/dist/protected/adapter/context/external-plugins.class.d.ts

@@ -0,0 +1,51 @@
+/**
+ * TExternalPlugins — плагины, поставленные снаружи: владелец пропа `pluginProps` и источник `plugin:event`.
+ *
+ * Поверхность компонента объявляет только дескриптор, и внешний плагин в неё
+ * не попадает: статический слой объявляет её раньше регистрации, а поставить
+ * плагин можно и после монтирования. Поэтому на все внешние плагины у
+ * компонента один проп (`pluginProps`) и одно событие (`plugin:event`).
+ *
+ * Своих правил записи, сброса и проброса у класса нет. На каждый пришедший
+ * плагин с контрактом он заводит тот же `TExchange`, что обслуживает компонент,
+ * — только «фреймворком» для него служит мешок `pluginProps` (общий профиль
+ * имён), а приёмником событий — конверт на шине инстанса. Поэтому «правила
+ * записи — те же, что у пропсов компонента» выполняется не дисциплиной, а тем,
+ * что код один: «ключ пропал из мешка — проп вернулся к умолчанию» — обычное
+ * поведение полного набора.
+ *
+ * Путь один, когда бы плагин ни встал: реестр ставит плагины через
+ * `bundle.use` уже после того, как этот класс подписался на набор, и они
+ * приходят тем же событием `use`, что и плагин из обработчика `bundle:create`.
+ *
+ * Для обмена компонента этот объект — обычный участник: у него есть свойство
+ * `pluginProps`, и линия пишет в него обычным сеттером. Ветки «а если это
+ * pluginProps» в порту входов нет.
+ */
+import type { IPluginBundle } from '@soxa-ui/plugins';
+import type { TPluginCtor } from '../../define';
+export declare class TExternalPlugins {
+    private readonly _bundle;
+    private readonly _instance;
+    private readonly _own;
+    /** Умолчание `pluginProps`: снятый проп возвращает плагины к их умолчаниям. */
+    static readonly defaultValues: {
+        pluginProps: {};
+    };
+    private readonly _bag;
+    /** Отвязки плагинов, поставленных снаружи, — с первого такого плагина. */
+    private _detach?;
+    /**
+     * @param _bundle набор компонента: слушатель снимается с его шины по ссылке
+     * @param _own плагины дескриптора: через `pluginProps` они не пишутся — их пропсы уже в поверхности
+     */
+    constructor(_bundle: IPluginBundle, _instance: object, _own: ReadonlySet<TPluginCtor>);
+    get pluginProps(): object;
+    set pluginProps(bag: object);
+    destroy(): void;
+    private readonly _onBundle;
+    private _use;
+    private _remove;
+    /** Конверт — на шину инстанса: его видят и адаптер, и тот, у кого на руках только `ctrl`. */
+    private _announce;
+}

package/dist/protected/adapter/context/external-plugins.class.js

@@ -0,0 +1,80 @@
+import { pluginContractOf } from "../../define/plugin.js";
+import { CommonProfile } from "../../naming/common-profile.js";
+import { sameValue } from "../exchange/value.js";
+import { TInputPort } from "../exchange/input-port.class.js";
+import { TMember } from "../exchange/member.class.js";
+import { TSurface } from "../surface/surface.class.js";
+import { TExchange } from "../exchange/exchange.class.js";
+import { TCell } from "../exchange/cell.class.js";
+//#region protected/adapter/context/external-plugins.class.ts
+function hasEmit(value) {
+	return typeof value === "object" && value !== null && "emit" in value && typeof value.emit === "function";
+}
+var TExternalPlugins = class {
+	_bundle;
+	_instance;
+	_own;
+	/** Умолчание `pluginProps`: снятый проп возвращает плагины к их умолчаниям. */
+	static defaultValues = { pluginProps: {} };
+	_bag = new TCell({}, sameValue);
+	/** Отвязки плагинов, поставленных снаружи, — с первого такого плагина. */
+	_detach;
+	/**
+	* @param _bundle набор компонента: слушатель снимается с его шины по ссылке
+	* @param _own плагины дескриптора: через `pluginProps` они не пишутся — их пропсы уже в поверхности
+	*/
+	constructor(_bundle, _instance, _own) {
+		this._bundle = _bundle;
+		this._instance = _instance;
+		this._own = _own;
+		_bundle.events.listen(this._onBundle);
+	}
+	get pluginProps() {
+		return this._bag.value;
+	}
+	set pluginProps(bag) {
+		this._bag.set(bag);
+	}
+	destroy() {
+		this._bundle.events.unlisten(this._onBundle);
+		const detach = this._detach;
+		this._detach = void 0;
+		for (const off of detach?.values() ?? []) off();
+	}
+	_onBundle = (event, [ctor, plugin]) => {
+		if (event === "use") this._use(ctor, plugin);
+		else this._remove(ctor);
+	};
+	_use(ctor, plugin) {
+		if (this._own.has(ctor)) return;
+		this._detach?.get(ctor)?.();
+		const contract = pluginContractOf(ctor);
+		if (!contract) return;
+		const member = new TMember(plugin, contract);
+		const bag = this._bag.value;
+		const surface = TSurface.of(contract, CommonProfile);
+		const exchange = new TExchange([member], surface, bag);
+		TInputPort.seed([member], surface, bag);
+		const offBag = this._bag.listen((bag) => exchange.inputs.full(bag));
+		const offEvents = exchange.events.listen((name, args) => this._announce({
+			name,
+			args
+		}));
+		this._detach ??= /* @__PURE__ */ new Map();
+		this._detach.set(ctor, () => {
+			offBag();
+			offEvents();
+		});
+	}
+	_remove(ctor) {
+		this._detach?.get(ctor)?.();
+		this._detach?.delete(ctor);
+	}
+	/** Конверт — на шину инстанса: его видят и адаптер, и тот, у кого на руках только `ctrl`. */
+	_announce(event) {
+		const bus = Reflect.get(this._instance, "events");
+		if (hasEmit(bus)) bus.emit("plugin:event", event);
+	}
+};
+//#endregion
+export { TExternalPlugins };

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

@@ -0,0 +1,2 @@
+export { createAdapterContext } from './create-adapter-context';
+export type { IAdapterContext, IAdapterContextConfig, IAdapterContextOptions, TAdapterEvents, TContextContract, TInstanceContext, IAdapterExtensionCtor, IAdapterExtensionCtorNoOpts, TAnyExtensionCtor, } from './types';

package/dist/protected/adapter/context/own-bundle.class.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Owns the descriptor and registered plugins for one mount.
+ * Announces bundle:create on a microtask before running plugin created() hooks.
+ * A destroyed bundle is never announced; nodes are detached before destruction.
+ */
+import type { IPluginBundle } from '@soxa-ui/plugins';
+import type { IBundleContext, IComponentDescriptor } from '../../define';
+import { TMember } from '../exchange/member.class';
+import type { IBundleTenancy, TBundleMount } from './types';
+type TBundleDescriptor = Pick<IComponentDescriptor, 'ctor' | 'plugins' | 'props'>;
+export declare class TOwnBundle implements IBundleTenancy {
+    private readonly _descriptor;
+    private readonly _instance;
+    private readonly _context;
+    readonly bundle: IPluginBundle;
+    private readonly _external;
+    constructor(_descriptor: TBundleDescriptor, _instance: object, _context: IBundleContext, mount?: TBundleMount);
+    members(): readonly TMember[];
+    /** Своим плагинам и связке начальные значения пишет эта сборка. */
+    seeded(members: readonly TMember[]): readonly TMember[];
+    complete(): void;
+    destroy(): void;
+    private _announce;
+}
+export {};

package/dist/protected/adapter/context/own-bundle.class.js

@@ -0,0 +1,86 @@
+import { PLUGIN_PROPS } from "../../naming/naming.js";
+import { resolveRegisteredPlugins } from "../../registry/plugins.js";
+import { TMember } from "../exchange/member.class.js";
+import { TExternalPlugins } from "./external-plugins.class.js";
+import { TElementPlugin, TPluginBundle } from "@soxa-ui/plugins";
+//#region protected/adapter/context/own-bundle.class.ts
+function hasEmit(value) {
+	return typeof value === "object" && value !== null && "emit" in value && typeof value.emit === "function";
+}
+var externalSpecs = /* @__PURE__ */ new WeakMap();
+var ownPlugins = /* @__PURE__ */ new WeakMap();
+/**
+* Описание участника-связки: `pluginProps` — с умолчанием от класса его
+* владельца, как у любого другого пропа. Одно на дескриптор, а не пересчёт на
+* каждое монтирование: по нему обмен находит таблицу маршрутов своего типа.
+*/
+function externalSpecOf(descriptor) {
+	let spec = externalSpecs.get(descriptor);
+	if (!spec) {
+		spec = Object.freeze({
+			props: Object.freeze(descriptor.props.filter((prop) => prop.name.name === PLUGIN_PROPS).map((prop) => prop.rebase(TExternalPlugins.defaultValues))),
+			events: []
+		});
+		externalSpecs.set(descriptor, spec);
+	}
+	return spec;
+}
+/** Классы плагинов дескриптора — один набор на дескриптор, а не на монтирование. */
+function ownPluginsOf(descriptor) {
+	let own = ownPlugins.get(descriptor);
+	if (!own) {
+		own = new Set(descriptor.plugins.map((plugin) => plugin.ctor));
+		ownPlugins.set(descriptor, own);
+	}
+	return own;
+}
+var TOwnBundle = class {
+	_descriptor;
+	_instance;
+	_context;
+	bundle;
+	_external;
+	constructor(_descriptor, _instance, _context, mount = {}) {
+		this._descriptor = _descriptor;
+		this._instance = _instance;
+		this._context = _context;
+		const bundle = new TPluginBundle(_instance, mount.mountId, mount.locale);
+		for (const plugin of _descriptor.plugins) bundle.use(plugin.ctor, plugin.options ?? {});
+		this.bundle = bundle;
+		this._external = new TExternalPlugins(bundle, _instance, ownPluginsOf(_descriptor));
+	}
+	members() {
+		return [...this._descriptor.plugins.flatMap((plugin) => {
+			const owner = this.bundle.get(plugin.ctor);
+			return owner ? [new TMember(owner, plugin)] : [];
+		}), new TMember(this._external, externalSpecOf(this._descriptor))];
+	}
+	/** Своим плагинам и связке начальные значения пишет эта сборка. */
+	seeded(members) {
+		return members;
+	}
+	complete() {
+		for (const plugin of resolveRegisteredPlugins(this._instance, this._context)) {
+			if (this._descriptor.plugins.some((own) => own.ctor === plugin.ctor)) throw new Error(`${plugin.ctor.name} уже входит в состав ${this._descriptor.ctor.name}: плагин реестра только добавляет`);
+			this.bundle.use(plugin.ctor, plugin.options ?? {});
+		}
+		this._announce();
+	}
+	destroy() {
+		this._external.destroy();
+		const element = this.bundle.get(TElementPlugin);
+		if (element) element.element = null;
+		this.bundle.destroy();
+	}
+	_announce() {
+		const { bundle } = this;
+		Promise.resolve().then(() => {
+			if (bundle.destroyed) return;
+			const events = Reflect.get(this._instance, "events");
+			if (hasEmit(events)) events.emit("bundle:create", bundle);
+			bundle.created();
+		});
+	}
+};
+//#endregion
+export { TOwnBundle };

package/dist/protected/adapter/context/shared-bundle.class.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TSharedBundle — набор не наш: чужой (фасад коллекции делит набор с компонентом) или никакого.
+ *
+ * Участники — только плагины дескриптора, которые в наборе нашлись; плагин,
+ * которого там нет, молча пропускается. Регистрации приложения не
+ * пересматриваются — иначе фасад получил бы плагин реестра второй раз.
+ * Начальные значения плагинам не пишутся, плагины снаружи не ведутся, набор и
+ * узел при `destroy()` не трогаются: всё это делает владелец набора.
+ *
+ * Компонент без плагинов сюда же: набора у него нет, и вести нечего.
+ */
+import type { IPluginBundle } from '@soxa-ui/plugins';
+import type { IComponentDescriptor } from '../../define';
+import { TMember } from '../exchange/member.class';
+import type { IBundleTenancy } from './types';
+export declare class TSharedBundle implements IBundleTenancy {
+    private readonly _descriptor;
+    readonly bundle: IPluginBundle | null;
+    constructor(_descriptor: Pick<IComponentDescriptor, 'plugins'>, bundle: IPluginBundle | null);
+    members(): readonly TMember[];
+    /** Чужим плагинам начальные значения пишет владелец набора. */
+    seeded(): readonly TMember[];
+    complete(): void;
+    destroy(): void;
+}

package/dist/protected/adapter/context/shared-bundle.class.js

@@ -0,0 +1,24 @@
+import { TMember } from "../exchange/member.class.js";
+//#region protected/adapter/context/shared-bundle.class.ts
+var TSharedBundle = class {
+	_descriptor;
+	bundle;
+	constructor(_descriptor, bundle) {
+		this._descriptor = _descriptor;
+		this.bundle = bundle;
+	}
+	members() {
+		return this._descriptor.plugins.flatMap((plugin) => {
+			const owner = this.bundle?.get(plugin.ctor);
+			return owner ? [new TMember(owner, plugin)] : [];
+		});
+	}
+	/** Чужим плагинам начальные значения пишет владелец набора. */
+	seeded() {
+		return [];
+	}
+	complete() {}
+	destroy() {}
+};
+//#endregion
+export { TSharedBundle };