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

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

@@ -0,0 +1,184 @@
+/**
+ * Contracts of the adapter context, its options and extension constructors.
+ */
+import type { TEvented } from '@soxa-ui/core';
+import type { ILocaleSource, IPluginBundle } from '@soxa-ui/plugins';
+import type { IComponentContract, IComponentDescriptor, IPluginsContract } from '../../define';
+import type { IAdapterProfile } from '../../naming';
+import type { TExchange } from '../exchange/exchange.class';
+import type { TMember } from '../exchange/member.class';
+/**
+ * The context's life: `attach` — the framework accepted the assembled
+ * component, `detach` — it began removing it, `destroy` — it let it go. Each
+ * comes once and in this order. The adapter's runtime sends all three;
+ * `detach` may also come earlier from the collection the component is a
+ * member of (`TCollectionMembers`).
+ */
+export type TAdapterEvents = {
+    attach: () => void;
+    detach: () => void;
+    destroy: () => void;
+};
+/**
+ * A context contract with the instance and the plugins named, the rest as for
+ * any component. By it `createAdapterContext` resolves the instance from two
+ * sources: the descriptor's `ctor` and the given `ctrl`.
+ */
+export type TContextContract<TInstance extends object, TPlugins extends IPluginsContract = IPluginsContract> = IComponentContract & {
+    instance: TInstance;
+    plugins: TPlugins;
+};
+/**
+ * A context of which only the instance is known. This is how an extension
+ * declares what it works with: `TInstanceContext<TCollectionOwner>` — any
+ * component whose instance has an `engine`.
+ */
+export type TInstanceContext<TInstance extends object> = IAdapterContext<TContextContract<TInstance>>;
+/**
+ * An extension constructor with options. `TInstance` is the instance the
+ * extension needs (`TCollectionExtension` — a facade with `engine`);
+ * `IAdapterContext.use()` checks it against the context's instance at compile
+ * time, so an extension cannot go on a component that lacks what it works
+ * with.
+ */
+export interface IAdapterExtensionCtor<T = unknown, TOpts = unknown, TInstance extends object = object> {
+    new (context: TInstanceContext<TInstance>, options: TOpts): T;
+}
+/** An extension constructor without options. */
+export interface IAdapterExtensionCtorNoOpts<T = unknown, TInstance extends object = object> {
+    new (context: TInstanceContext<TInstance>): T;
+}
+/** Any extension constructor: a registry key and an item of the starting set. */
+export type TAnyExtensionCtor = new (...args: any[]) => unknown;
+/** Options of creating an adapter context: a ready instance (`ctrl`) or the constructor's props and options. */
+export interface IAdapterContextOptions<TInstance extends object = object> {
+    ctrl?: TInstance;
+    /**
+     * The framework's props. `object`, not `Record<string, unknown>`: adapters
+     * declare props as interfaces without an index signature. They are read by
+     * the descriptor's names through `Reflect.get`.
+     */
+    props?: object;
+    options?: object;
+    /**
+     * The place's name if the component is a detail of another component's
+     * markup (a tag's row and close button). It goes into the mount's
+     * composition (`resolveComposition`): registry plugins with `scope: 'own'`
+     * are not installed on an embedded component.
+     */
+    embedded?: string;
+    /**
+     * The mount id — from the framework's `useId`, the same on the server and
+     * in the browser. It goes to the own plugin bundle, from which plugins build
+     * the parts' `id`s (`IPluginBundle.createId`); the instance does not get it —
+     * ids are the document's business, not the core's. With a bundle not its
+     * own (`config.bundle`) the mount id is of whoever assembled the bundle.
+     */
+    mountId?: string;
+    /**
+     * The subtree's locale — from the framework's nearest locale provider above:
+     * the Intl tag and the library's strings, with a change event. It goes to
+     * the own plugin bundle, as the mount id does (`IPluginBundle.locale`), and
+     * the language and names plugins write the tag and the button names from it,
+     * on assembly and on every change. The instance does not get it: the
+     * language is known by the component's place in the tree, not by the
+     * instance. Not given — the bundle has its own English one. With a bundle
+     * not its own (`config.bundle`) the locale is of whoever assembled it.
+     */
+    locale?: ILocaleSource;
+}
+/** What the own bundle takes from the mount: the mount id and the subtree's locale. */
+export type TBundleMount = Pick<IAdapterContextOptions, 'mountId' | 'locale'>;
+export interface IAdapterContextConfig {
+    /**
+     * A ready plugin bundle, passed by whoever assembled it (a collection
+     * adapter shares the component's bundle with the facade). Without it the
+     * bundle is assembled by the composition: the descriptor's plugins plus the
+     * application's registrations.
+     */
+    bundle?: IPluginBundle | null;
+}
+/**
+ * The adapter context: the assembled component and its extensions.
+ *
+ * The parameter is the descriptor contract the context was assembled by
+ * (`IComponentContract`). `createAdapterContext` infers it, and the adapters'
+ * `useAdapter` takes from it the instance type and the plugins' outputs for
+ * the state type (`TAdapterState`), so components write no generics.
+ */
+export interface IAdapterContext<C extends IComponentContract = IComponentContract> {
+    /** A phantom field: absent at runtime, it only carries the contract in the type. */
+    readonly __contract?: C;
+    readonly instance: C['instance'];
+    readonly bundle: IPluginBundle | null;
+    readonly descriptor: IComponentDescriptor;
+    /**
+     * The assembly props, until the first `connect()`: extensions read them in
+     * their constructors and the exchange starts its input memory from them.
+     * After `connect()` — `undefined`: the input memory lives in its own cells
+     * and the context lets the props go.
+     */
+    readonly props: object | undefined;
+    /** The place's name if the component is a detail of another's markup (`IAdapterContextOptions.embedded`). */
+    readonly embedded: string | undefined;
+    readonly events: TEvented<TAdapterEvents>;
+    /** Install an extension WITHOUT options. */
+    use<T>(ExtensionCtor: IAdapterExtensionCtorNoOpts<T, C['instance']>): this;
+    /** Install an extension WITH required options. */
+    use<T, TOpts>(ExtensionCtor: IAdapterExtensionCtor<T, TOpts, C['instance']>, options: TOpts): this;
+    /** The installed extension of the given class. */
+    get<T>(ctor: new (...args: any[]) => T): T | undefined;
+    /**
+     * Bind the markup's root node to the bundle's `TElementPlugin`; `null`
+     * unbinds. Without that plugin the call does nothing.
+     */
+    bindElement(element: Element | null): void;
+    /**
+     * The value exchange with the framework, in its profile's names: state,
+     * inputs, events. The input memory starts from the assembly props; the
+     * assembly has already applied the initial values.
+     *
+     * One exchange per mount: the first call creates it and releases the
+     * assembly props, a repeat with the same profile returns it, another
+     * profile is an error.
+     */
+    connect(profile: IAdapterProfile): TExchange;
+    /**
+     * The framework accepted the assembled component: from now on it is part of
+     * the live tree, not an assembly draft. Whatever writes into someone else's
+     * storage (an item entering its owner's collection) waits for `attach`.
+     * Called once, between assembly and `destroy()`, by the adapter's runtime,
+     * not by the component.
+     */
+    attach(): void;
+    /**
+     * The framework began removing the component: the first moment of its
+     * teardown, before its children go. The context only reports it (the
+     * `detach` event); the adapter stops the consumer on it. A collection
+     * detaches its members too (`TCollectionMembers`): siblings leave one by
+     * one, and a member still heard would hear them go. Once: a repeat does
+     * nothing.
+     */
+    detach(): void;
+    /** Destroy the context; detached first, if it was not. */
+    destroy(): void;
+}
+/**
+ * Ownership of the plugin bundle: own (`TOwnBundle`) or shared
+ * (`TSharedBundle`). Not a flag every user of the bundle checks: everything
+ * that depends on it is done by one of the two objects.
+ */
+export interface IBundleTenancy {
+    readonly bundle: IPluginBundle | null;
+    /**
+     * The exchange members from the bundle: the descriptor's plugins and, for
+     * an own bundle, the binding too. Built per call: the assembly and the
+     * exchange need them, the bundle does not keep them.
+     */
+    members(): readonly TMember[];
+    /** Which of the bundle's members (`members()`) this assembly writes initial values to. */
+    seeded(members: readonly TMember[]): readonly TMember[];
+    /** Finish the assembly after the initial values: registry plugins and announcing the bundle. */
+    complete(): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Абстрактный класс TElevator — база для всех фреймворк-специфичных элеваторов.
+ *
+ * Кэширует строковые/symbol ключи в уникальные символы, чтобы
+ * гарантировать одинаковый InjectionKey во всех вызовах provide/inject
+ * (или их аналогах в React/Solid/Angular).
+ *
+ * Конкретные реализации:
+ *   - TVueElevator extends TElevator (provide/inject)
+ *   - TReactElevator extends TElevator (React.Context)
+ *   - TSolidElevator extends TElevator (Solid Context)
+ *   - TSvelteElevator extends TElevator (setContext/getContext)
+ *   - TAngularElevator extends TElevator (DI: InjectionToken)
+ */
+import type { IContextElevator } from './types';
+export declare abstract class TElevator<T = any> implements IContextElevator<T> {
+    protected readonly _key: symbol;
+    constructor(key: string | symbol);
+    abstract down(value: T): void;
+    abstract up(): T | undefined;
+}

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

@@ -0,0 +1,19 @@
+//#region protected/adapter/elevator/elevator.class.ts
+/** Кэш: строковый ключ → уникальный символ */
+var KEY_MAP = /* @__PURE__ */ new Map();
+function resolveKey(key) {
+	let k = KEY_MAP.get(key);
+	if (!k) {
+		k = Symbol(key.toString());
+		KEY_MAP.set(key, k);
+	}
+	return k;
+}
+var TElevator = class {
+	_key;
+	constructor(key) {
+		this._key = resolveKey(key);
+	}
+};
+//#endregion
+export { TElevator };

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

@@ -0,0 +1,3 @@
+export { TElevator } from './elevator.class';
+export { COLLECTION_ENGINE_ELEVATOR, ITEM_CONTEXT_ELEVATOR } from './keys';
+export type { IContextElevator, IElevatorKey, TCollectionItemRegister, TElevatorFactory, } from './types';

package/dist/protected/adapter/elevator/keys.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Ключи элеваторов — единое пространство имён для всех фреймворков.
+ *
+ * Конкретная реализация IContextElevator (TVueElevator, React.Context, ...)
+ * живёт в своём UI-пакете и передаётся сюда через TElevatorFactory.
+ */
+import type { TCollectionEngine } from '@soxa-ui/core';
+import type { IElevatorKey, TCollectionItemRegister } from './types';
+/** Родительская коллекция. Ребёнок толкает { instance, bundle } наверх. */
+export declare const COLLECTION_ENGINE_ELEVATOR: IElevatorKey<TCollectionItemRegister>;
+/** Контекст коллекции для дочернего элемента. Родитель → дочерний элемент. */
+export declare const ITEM_CONTEXT_ELEVATOR: IElevatorKey<TCollectionEngine<any, any>>;

package/dist/protected/adapter/elevator/keys.js

@@ -0,0 +1,7 @@
+//#region protected/adapter/elevator/keys.ts
+/** Родительская коллекция. Ребёнок толкает { instance, bundle } наверх. */
+var COLLECTION_ENGINE_ELEVATOR = { name: "soxa:collection-engine" };
+/** Контекст коллекции для дочернего элемента. Родитель → дочерний элемент. */
+var ITEM_CONTEXT_ELEVATOR = { name: "soxa:item-context" };
+//#endregion
+export { COLLECTION_ENGINE_ELEVATOR, ITEM_CONTEXT_ELEVATOR };

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

@@ -0,0 +1,31 @@
+/**
+ * Контракт лифта: типизированный ключ, фабрика фреймворка и регистрация элемента коллекции.
+ */
+import type { IPluginBundle } from '@soxa-ui/plugins';
+/** Лифт: значения от родителя к детям поверх механизма фреймворка (`provide`/`inject`, React Context, DI Angular). */
+export interface IContextElevator<T = any> {
+    down(value: T): void;
+    up(): T | undefined;
+}
+/**
+ * Ключ elevator'а вместе с типом значения — как `InjectionKey<T>` во Vue.
+ *
+ * Фабрика выводит `T` из ключа, поэтому `up()` отдаёт значение нужного типа без
+ * приведения, а `down()` не примет чужое.
+ */
+export interface IElevatorKey<T> {
+    readonly name: string;
+    /** Фантом: только несёт тип значения, в рантайме не заполняется. */
+    readonly __value?: T;
+}
+/**
+ * Фабрика, которую предоставляет конкретный фреймворк (Vue, React и т.д.).
+ *
+ * Пример для Vue:
+ * ```ts
+ * const VueElevatorFactory: TElevatorFactory = (key) => new TVueElevator(key.name)
+ * ```
+ */
+export type TElevatorFactory = <T>(key: IElevatorKey<T>) => IContextElevator<T>;
+/** Регистрация элемента в родительской коллекции; возвращает снятие регистрации. */
+export type TCollectionItemRegister = (item: object, bundle: IPluginBundle | null) => () => void;

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

@@ -0,0 +1,39 @@
+/**
+ * TAssembling — сборка над инстансом атомарна для остальных его монтирований.
+ *
+ * Над одним инстансом бывает больше одного монтирования: `ctrl` снаружи
+ * переехал в другое место дерева, и фреймворк собирает новый компонент, пока
+ * прежний ещё не снят. Сборка пишет в инстанс — начальные значения внешнему
+ * `ctrl`, `id` плагинов связок от нового монтирования, — и прежнее
+ * монтирование слышит каждую запись, пока сборка ещё идёт. Фреймворк, который
+ * собирает компонент на рендере, получил бы обновление чужого компонента
+ * посреди этого рендера, а повтор рендера (`Suspense`) — новую запись и новое
+ * обновление на каждый повтор.
+ *
+ * Поэтому, пока над инстансом идёт сборка (`run`), обмены остальных
+ * монтирований копят его состояние и уведомления и выпускают их одной
+ * микрозадачей после сборки (`defer`, правило выпуска — `TExchange`): итог, а
+ * не каждый шаг. Микрозадача не вклинивается в тело рендера, а граница тишины
+ * — сама сборка, синхронно: от того, примет ли сборку фреймворк, тишина не
+ * зависит, и сборка, которую он выбросил, её не держит.
+ *
+ * Отменяемые события (`*:before`) тишина не задерживает: это вопрос, ответ на
+ * который нужен сейчас, и `preventDefault` приёмника прежнего монтирования
+ * отменяет запись сборки, как вне её.
+ *
+ * Механика одна на все адаптеры и включена всегда: у инстанса с одним
+ * монтированием копить в тишине некому, и стоит она одну проверку `WeakMap`
+ * на событие.
+ */
+export declare class TAssembling {
+    /** Сколько сборок идёт над инстансом: сборка вправе собрать вложенную над тем же. */
+    private readonly _depth;
+    /** Собрать над инстансом: на время `build` состояние остальных монтирований молчит. */
+    run<T>(instance: object, build: () => T): T;
+    /** Над кем-то из владельцев идёт сборка. */
+    covers(owners: readonly object[]): boolean;
+    /** Перечитать после сборки: одной микрозадачей, вне тела, которое сейчас выполняется. */
+    defer(reread: () => void): void;
+}
+/** Сборки процесса — общие для всех адаптеров, как и инстансы, над которыми они идут. */
+export declare const assembling: TAssembling;

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

@@ -0,0 +1,55 @@
+//#region protected/adapter/exchange/assembling.class.ts
+/**
+* TAssembling — сборка над инстансом атомарна для остальных его монтирований.
+*
+* Над одним инстансом бывает больше одного монтирования: `ctrl` снаружи
+* переехал в другое место дерева, и фреймворк собирает новый компонент, пока
+* прежний ещё не снят. Сборка пишет в инстанс — начальные значения внешнему
+* `ctrl`, `id` плагинов связок от нового монтирования, — и прежнее
+* монтирование слышит каждую запись, пока сборка ещё идёт. Фреймворк, который
+* собирает компонент на рендере, получил бы обновление чужого компонента
+* посреди этого рендера, а повтор рендера (`Suspense`) — новую запись и новое
+* обновление на каждый повтор.
+*
+* Поэтому, пока над инстансом идёт сборка (`run`), обмены остальных
+* монтирований копят его состояние и уведомления и выпускают их одной
+* микрозадачей после сборки (`defer`, правило выпуска — `TExchange`): итог, а
+* не каждый шаг. Микрозадача не вклинивается в тело рендера, а граница тишины
+* — сама сборка, синхронно: от того, примет ли сборку фреймворк, тишина не
+* зависит, и сборка, которую он выбросил, её не держит.
+*
+* Отменяемые события (`*:before`) тишина не задерживает: это вопрос, ответ на
+* который нужен сейчас, и `preventDefault` приёмника прежнего монтирования
+* отменяет запись сборки, как вне её.
+*
+* Механика одна на все адаптеры и включена всегда: у инстанса с одним
+* монтированием копить в тишине некому, и стоит она одну проверку `WeakMap`
+* на событие.
+*/
+var TAssembling = class {
+	/** Сколько сборок идёт над инстансом: сборка вправе собрать вложенную над тем же. */
+	_depth = /* @__PURE__ */ new WeakMap();
+	/** Собрать над инстансом: на время `build` состояние остальных монтирований молчит. */
+	run(instance, build) {
+		this._depth.set(instance, (this._depth.get(instance) ?? 0) + 1);
+		try {
+			return build();
+		} finally {
+			const depth = (this._depth.get(instance) ?? 1) - 1;
+			if (depth > 0) this._depth.set(instance, depth);
+			else this._depth.delete(instance);
+		}
+	}
+	/** Над кем-то из владельцев идёт сборка. */
+	covers(owners) {
+		return owners.some((owner) => this._depth.has(owner));
+	}
+	/** Перечитать после сборки: одной микрозадачей, вне тела, которое сейчас выполняется. */
+	defer(reread) {
+		queueMicrotask(reread);
+	}
+};
+/** Сборки процесса — общие для всех адаптеров, как и инстансы, над которыми они идут. */
+var assembling = new TAssembling();
+//#endregion
+export { TAssembling, assembling };

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

@@ -0,0 +1,31 @@
+/**
+ * TCell — ячейка: значение, правило «то же самое» и подписчики.
+ *
+ * Единственная изменяемая память слоя. Всё, что слой обязан помнить между
+ * вызовами, лежит в ячейках: последнее отданное значение свойства, последнее
+ * значение, которое задал фреймворк, мешок `pluginProps`. Отдельных «памятей»
+ * с ручными флагами «задан / не задан» нет — их роль играет само значение
+ * ячейки и её правило равенства.
+ *
+ * Контракт подписки — как у стора Svelte и атома nanostores: `subscribe` сразу
+ * отдаёт текущее значение («инициализация — это и есть подписка»), `listen` —
+ * только изменения.
+ *
+ * Набор подписчиков заводится с первым `listen`: состояние и входы обмена на
+ * свои ячейки не подписываются, а действуют по ответу `set()`, и ячеек без
+ * подписчиков у монтирования — по одной на свойство.
+ */
+import type { TCellListener, TSame } from './types';
+export declare class TCell<T> {
+    private _value;
+    private readonly _same;
+    private _listeners?;
+    constructor(_value: T, _same?: TSame<T>);
+    get value(): T;
+    /** Положить значение. «То же самое» не кладётся и подписчиков не будит — ответ `false`. */
+    set(next: T): boolean;
+    /** Слушать только изменения. */
+    listen(listener: TCellListener<T>): () => void;
+    /** Слушать изменения и сразу получить текущее значение. */
+    subscribe(listener: TCellListener<T>): () => void;
+}

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

@@ -0,0 +1,37 @@
+//#region protected/adapter/exchange/cell.class.ts
+var TCell = class {
+	_value;
+	_same;
+	_listeners;
+	constructor(_value, _same = Object.is) {
+		this._value = _value;
+		this._same = _same;
+	}
+	get value() {
+		return this._value;
+	}
+	/** Положить значение. «То же самое» не кладётся и подписчиков не будит — ответ `false`. */
+	set(next) {
+		if (this._same(this._value, next)) return false;
+		this._value = next;
+		if (this._listeners) for (const listener of [...this._listeners]) listener(next);
+		return true;
+	}
+	/** Слушать только изменения. */
+	listen(listener) {
+		this._listeners ??= /* @__PURE__ */ new Set();
+		this._listeners.add(listener);
+		return () => {
+			this._listeners?.delete(listener);
+			if (this._listeners?.size === 0) this._listeners = void 0;
+		};
+	}
+	/** Слушать изменения и сразу получить текущее значение. */
+	subscribe(listener) {
+		const off = this.listen(listener);
+		listener(this._value);
+		return off;
+	}
+};
+//#endregion
+export { TCell };

package/dist/protected/adapter/exchange/event-relay.class.d.ts

@@ -0,0 +1,29 @@
+/**
+ * TEventRelay delivers explicit public events and model updates after state refresh.
+ * Models are delivered even when their source trigger is internal.
+ */
+import type { TTap } from './tap.class';
+import type { IRoute, TEventSink } from './types';
+export declare class TEventRelay {
+    private readonly _owners;
+    private readonly _tap;
+    /** Приёмники — пока есть хоть один. Список не правится на месте: событие обходит тот, что застало. */
+    private _sinks?;
+    /**
+     * @param _owners владельцы участников монтирования — у них модели читают новое значение
+     * @param _tap слушатель участников, общий с состоянием обмена
+     */
+    constructor(_owners: readonly object[], _tap: TTap);
+    listen(sink: TEventSink): () => void;
+    /** Deliver an explicit public event and model updates independently, after refreshing state. */
+    publish(route: IRoute, args: readonly unknown[]): void;
+    /**
+     * Событие случилось, а отдать его обмен должен позже (`TExchange`, чужая
+     * сборка): доставка — тем приёмникам, что слушали в момент события. Приёмник,
+     * снятый до доставки, событие получает — оно случилось при нём; пришедший
+     * после — нет: для него это начальное состояние. Список не правится на
+     * месте, поэтому запомнить его — запомнить ссылку.
+     */
+    later(route: IRoute, args: readonly unknown[]): () => void;
+    private _deliver;
+}

package/dist/protected/adapter/exchange/event-relay.class.js

@@ -0,0 +1,53 @@
+//#region protected/adapter/exchange/event-relay.class.ts
+var TEventRelay = class {
+	_owners;
+	_tap;
+	/** Приёмники — пока есть хоть один. Список не правится на месте: событие обходит тот, что застало. */
+	_sinks;
+	/**
+	* @param _owners владельцы участников монтирования — у них модели читают новое значение
+	* @param _tap слушатель участников, общий с состоянием обмена
+	*/
+	constructor(_owners, _tap) {
+		this._owners = _owners;
+		this._tap = _tap;
+	}
+	listen(sink) {
+		if (this._sinks === void 0) this._tap.hold();
+		this._sinks = this._sinks ? [...this._sinks, sink] : [sink];
+		let listening = true;
+		return () => {
+			const sinks = this._sinks;
+			const index = sinks?.indexOf(sink) ?? -1;
+			if (!listening || sinks === void 0 || index === -1) return;
+			listening = false;
+			this._sinks = sinks.length === 1 ? void 0 : [...sinks.slice(0, index), ...sinks.slice(index + 1)];
+			if (this._sinks === void 0) this._tap.release();
+		};
+	}
+	/** Deliver an explicit public event and model updates independently, after refreshing state. */
+	publish(route, args) {
+		this._deliver(route, args, this._sinks);
+	}
+	/**
+	* Событие случилось, а отдать его обмен должен позже (`TExchange`, чужая
+	* сборка): доставка — тем приёмникам, что слушали в момент события. Приёмник,
+	* снятый до доставки, событие получает — оно случилось при нём; пришедший
+	* после — нет: для него это начальное состояние. Список не правится на
+	* месте, поэтому запомнить его — запомнить ссылку.
+	*/
+	later(route, args) {
+		const sinks = this._sinks;
+		return () => this._deliver(route, args, sinks);
+	}
+	_deliver(route, args, sinks) {
+		const { event, models } = route;
+		if (sinks === void 0) return;
+		for (const sink of sinks) {
+			if (event !== void 0) sink(event, args);
+			for (const model of models) sink(model.name, [model.line.read(this._owners)]);
+		}
+	}
+};
+//#endregion
+export { TEventRelay };

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

@@ -0,0 +1,78 @@
+/**
+ * TExchange — values exchanged for the time of a mount: the participants' owners and four ports over them.
+ *
+ * This is all the adapter sees: `state` (where to put a value is its call),
+ * `inputs` (which way of delivery to use is its call), `events` (how to
+ * hand an event over is its call) and `updates` (what to do at the bounds
+ * of an update is its call). When and in what order is decided here and below.
+ *
+ * One class serves both a component (the framework's profile, the
+ * framework's props) and a plugin installed from outside (the common
+ * profile, the `pluginProps` bag): there is no second implementation of the
+ * same rules for external plugins.
+ *
+ * What to do with a participant's event is decided by the type's routing
+ * table (`TRouting`), and the participants' buses are listened to by one
+ * listener per bus (`TTap`), shared by the state and the events. The
+ * properties' lines are rows of the table too. Per mount the exchange holds
+ * the participants' owners, the values of the state and of the inputs and
+ * these listeners; there are no objects per property, no routes,
+ * subscriptions or closures per event. The exchange does not keep the
+ * participants (`TMember`): they are needed to find the table and the owners.
+ *
+ * **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 (below). The exchange reports
+ * where each update begins and ends (`updates`, `TUpdatePort`), and nothing
+ * more: what a framework does at the bounds is decided in its adapter.
+ *
+ * While an assembly of another mount runs over one of the participants
+ * (`TAssembling`), the exchange gives the framework the outcome of the
+ * assembly rather than each of its steps: the state and the notifications
+ * pile up and go in one microtask after it — the whole state first, then the
+ * notifications in the order they came. A cancelable event (`TActionEvent`)
+ * is a question whose answer is needed now: it goes at once, and the sink's
+ * `preventDefault` cancels the assembly's write, as outside it. Until the
+ * queue is released, the notifications that come after the assembly join it
+ * too — otherwise they would overtake those piled up. A notification reaches
+ * the sinks that listened at the moment of the event, even if they stopped
+ * before the release: the previous mount is taken down by the same pass of
+ * the framework, and the event happened while it was there
+ * (`TEventRelay.later`).
+ *
+ * A property with no participant gets no line: the description of a plugin
+ * missing from a foreign bundle is skipped silently.
+ */
+import type { TSurface } from '../surface';
+import { TEventRelay } from './event-relay.class';
+import { TInputPort } from './input-port.class';
+import type { TLine } from './line.class';
+import type { TMember } from './member.class';
+import { TStateStore } from './state-store.class';
+import { TUpdatePort } from './update-port.class';
+export declare class TExchange {
+    readonly surface: TSurface;
+    /** Линии состава — общие у всех монтирований типа, владельцев берут из `owners`. */
+    readonly lines: readonly TLine[];
+    /** Владельцы участников по порядку состава: инстанс, плагины, связка. */
+    readonly owners: readonly object[];
+    readonly state: TStateStore;
+    readonly inputs: TInputPort;
+    readonly events: TEventRelay;
+    readonly updates: TUpdatePort;
+    /** Доставки уведомлений, отложенных до конца чужой сборки, — пока очередь не выпущена. */
+    private _queue?;
+    constructor(members: readonly TMember[], surface: TSurface, buildProps?: object);
+    /** Пропсы, которые компонент не съел: уходят атрибутами в корневой узел. */
+    forward<TProps extends object>(props: TProps): Partial<TProps>;
+    /** Очередь до конца чужой сборки: первая запись планирует её выпуск. */
+    private _defer;
+    /**
+     * A participant's event outside another mount's assembly: the state first,
+     * then the event and its models. The order is the exchange's rule, not the
+     * order of subscriptions.
+     */
+    private _receive;
+    /** The release after the assembly is one update: the whole state first, then the notifications in order. */
+    private _release;
+}