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

package/dist/adapter/runtime/root.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Описание корня — что у компонентов база раскладывает по-разному. Нет его —
+ * корень как у всех: сам элемент, стиль только от плагина раскладки,
+ * видимость прячет корень. AGENTS.md (Web Components), «Корень».
+ *
+ * - `'host'` — корень — сам элемент потребителя (`<button is="so-button">`);
+ * - `'wrapped'` — элемент — обёртка, корень — узел шаблона в ней: окно
+ *   таблицы вокруг `table`, где корень и поле; с `teleport` корень уезжает в
+ *   слой, а обёртка без коробки остаётся местом (регион тостов).
+ */
+import type { TStateSnapshot } from '@soxa-ui/setup';
+import type { TTeleportPlace } from './teleport';
+export type TRootSet = 'attrs' | 'aria' | 'dataset';
+/** Имена выходов состояния: селектор цели и «на месте». Без `contained` корень всегда в цели. */
+export type TRootTeleport = {
+    readonly target: string;
+    readonly contained?: string;
+};
+export type TRootSpec = {
+    readonly strategy: 'host';
+    /** Выход со стилем, который считает ядро (`fractionStyle` у ProgressSpinner). */
+    readonly style?: string;
+    /** Прячут ли `visible` и `rendered` корень; нет у Skeleton. По умолчанию да. */
+    readonly hides?: boolean;
+    /** Корень встаёт по месту в коллекции: `order` фасада — в стиль (Tabs, Accordion). */
+    readonly order?: boolean;
+    /** Выход, без которого корня нет, как `v-if` (`active` панели таба). */
+    readonly shownBy?: string;
+    readonly teleport?: TRootTeleport;
+    /** Наборы ядра на корне; у поля `aria` стоит на `<input>`. По умолчанию все три. */
+    readonly sets?: readonly TRootSet[];
+    /** Выход слоя `aria` корня (`rootAria` у Slider). По умолчанию `aria`. */
+    readonly aria?: string;
+    /** Статика разметки элемента, кроме класса и стиля, — узлу `control` шаблона. */
+    readonly control?: boolean;
+    /** `id` — проп поля, хотя статика остаётся корню (Rating). */
+    readonly fieldId?: boolean;
+} | {
+    readonly strategy: 'wrapped';
+    readonly teleport?: TRootTeleport;
+};
+/** Что база берёт из описания корня — один раз, на класс элемента. */
+export type TRootPlan = {
+    readonly wrapped: boolean;
+    /** Статика разметки уходит полю, и набор владельца ждёт его построения. */
+    readonly control: boolean;
+    readonly fieldId: boolean;
+    /** Что из статики остаётся на элементе при переносе, сверх входов и своих атрибутов. */
+    readonly keep: ReadonlySet<string>;
+    /** Внешний узел — корень: обёртка в слое только место. */
+    readonly outerIsRoot: boolean;
+    readonly layer?: TRootTeleport;
+    readonly style?: string;
+    readonly order: boolean;
+    readonly shownBy?: string;
+    readonly hides: boolean;
+    /** Снимает ли `rendered=false` поддерево: у Skeleton и обёртки в слое нет. */
+    readonly unrenders: boolean;
+    /** Слой раскладчика и выход состояния, из которого он берётся. */
+    readonly sets: readonly (readonly [TRootSet, string])[];
+};
+export declare function planOf(spec?: TRootSpec): TRootPlan;
+/** Куда корню слоя: селектор цели — непустая строка, остальное — цели нет. */
+export declare function placeOf(state: TStateSnapshot, layer: TRootTeleport): TTeleportPlace;
+/** Скрыт ли внешний узел, есть ли корень у плагинов и есть ли своё поддерево. */
+export type TPresence = {
+    readonly hidden: boolean;
+    readonly present: boolean;
+    readonly subtree: boolean;
+};
+/**
+ * Корня нет там, где его снял бы `v-if` у Vue: без поддерева у предка, при
+ * `rendered=false` и без выхода `shownBy`. `visible` — это `v-show`, а слой без
+ * цели только спрятан: узел у плагинов у обоих остаётся. Слой прячется и без
+ * поддерева у предка — `display: none` предка до увезённого корня не доходит.
+ */
+export declare function presenceOf(plan: TRootPlan, state: TStateSnapshot, above: boolean, placed: boolean): TPresence;

package/dist/adapter/runtime/root.js

@@ -0,0 +1,77 @@
+//#region src/adapter/runtime/root.ts
+var ROOT_SETS = [
+	"attrs",
+	"aria",
+	"dataset"
+];
+/** Класс и стиль — корню; `is` — имя элемента, `slot` — его место в свете родителя. */
+var ROOT_ONLY = /* @__PURE__ */ new Set([
+	"class",
+	"style",
+	"is",
+	"slot"
+]);
+/** Обёртка в слое — только место: класс и стиль уходят корню. */
+var PLACE_ONLY = /* @__PURE__ */ new Set(["is", "slot"]);
+var HOST = { strategy: "host" };
+function planOf(spec = HOST) {
+	if (spec.strategy === "wrapped") {
+		const layered = spec.teleport !== void 0;
+		return {
+			wrapped: true,
+			control: !layered,
+			fieldId: false,
+			keep: layered ? PLACE_ONLY : ROOT_ONLY,
+			outerIsRoot: layered,
+			layer: spec.teleport,
+			order: false,
+			hides: true,
+			unrenders: !layered,
+			sets: setsOf(ROOT_SETS, "aria")
+		};
+	}
+	const hides = spec.hides ?? true;
+	return {
+		wrapped: false,
+		control: spec.control === true,
+		fieldId: spec.fieldId === true,
+		keep: ROOT_ONLY,
+		outerIsRoot: false,
+		layer: spec.teleport,
+		style: spec.style,
+		order: spec.order === true,
+		shownBy: spec.shownBy,
+		hides,
+		unrenders: hides,
+		sets: setsOf(spec.sets ?? ROOT_SETS, spec.aria ?? "aria")
+	};
+}
+function setsOf(sets, aria) {
+	return sets.map((set) => [set, set === "aria" ? aria : set]);
+}
+/** Куда корню слоя: селектор цели — непустая строка, остальное — цели нет. */
+function placeOf(state, layer) {
+	const target = state[layer.target];
+	return {
+		target: typeof target === "string" && target !== "" ? target : null,
+		contained: layer.contained !== void 0 && state[layer.contained] === true
+	};
+}
+/**
+* Корня нет там, где его снял бы `v-if` у Vue: без поддерева у предка, при
+* `rendered=false` и без выхода `shownBy`. `visible` — это `v-show`, а слой без
+* цели только спрятан: узел у плагинов у обоих остаётся. Слой прячется и без
+* поддерева у предка — `display: none` предка до увезённого корня не доходит.
+*/
+function presenceOf(plan, state, above, placed) {
+	const unrendered = state["rendered"] === false;
+	const unseen = plan.hides && (unrendered || state["visible"] === false);
+	const absent = plan.shownBy !== void 0 && state[plan.shownBy] !== true;
+	return {
+		hidden: unseen || absent || !placed || plan.layer !== void 0 && !above,
+		present: above && !(plan.hides && unrendered) && !absent,
+		subtree: above && !(plan.unrenders && unrendered) && !absent
+	};
+}
+//#endregion
+export { placeOf, planOf, presenceOf };

package/dist/adapter/runtime/subtree.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Признак «поддерево есть» в контексте места. У Vue `v-if` снимает и панели
+ * вложенных слоёв, увезённые в `body`, а `display: none` элемента до них не
+ * доходит, поэтому снятое поддерево элемент отдаёт месту признаком. Смена
+ * доходит до подписчиков тем же вызовом. AGENTS.md (Web Components),
+ * «Поддерево».
+ */
+export declare class TSubtree {
+    private _present;
+    private readonly _listeners;
+    get present(): boolean;
+    set present(value: boolean);
+    subscribe(listener: () => void): () => void;
+}
+/** Признак предка по месту на одну сборку; предка нет — поддерево есть. */
+export type TAbove = {
+    readonly present: boolean;
+    stop(): void;
+};
+export declare function provideSubtree(element: Element, subtree: TSubtree): void;
+/** Ближайший признак выше по месту — от якоря у увезённого корня — и подписка на него. */
+export declare function followAbove(node: Node, listener: () => void): TAbove;

package/dist/adapter/runtime/subtree.js

@@ -0,0 +1,44 @@
+import { TPlaceContext } from "../context/place-context.class.js";
+//#region src/adapter/runtime/subtree.ts
+/**
+* Признак «поддерево есть» в контексте места. У Vue `v-if` снимает и панели
+* вложенных слоёв, увезённые в `body`, а `display: none` элемента до них не
+* доходит, поэтому снятое поддерево элемент отдаёт месту признаком. Смена
+* доходит до подписчиков тем же вызовом. AGENTS.md (Web Components),
+* «Поддерево».
+*/
+var TSubtree = class {
+	_present = true;
+	_listeners = /* @__PURE__ */ new Set();
+	get present() {
+		return this._present;
+	}
+	set present(value) {
+		if (value === this._present) return;
+		this._present = value;
+		for (const listener of [...this._listeners]) listener();
+	}
+	subscribe(listener) {
+		this._listeners.add(listener);
+		return () => {
+			this._listeners.delete(listener);
+		};
+	}
+};
+var SUBTREE = new TPlaceContext();
+function provideSubtree(element, subtree) {
+	SUBTREE.provide(element, subtree);
+}
+/** Ближайший признак выше по месту — от якоря у увезённого корня — и подписка на него. */
+function followAbove(node, listener) {
+	const above = SUBTREE.nearest(node);
+	const unsubscribe = above?.subscribe(listener);
+	return {
+		get present() {
+			return above?.present ?? true;
+		},
+		stop: () => unsubscribe?.()
+	};
+}
+//#endregion
+export { TSubtree, followAbove, provideSubtree };

package/dist/adapter/runtime/teleport.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Телепорт корня слоя — аналог `<teleport :to>`: уводит корень со спутником
+ * (подложкой) в цель по селектору, на месте оставляет якорь-комментарий, и
+ * поиск по месту от корня идёт к якорю. Панель ходит с местом: место
+ * пересобрано или снято — корень возвращается к якорю переносом с
+ * пересборкой. Путей к этому два: колбэки хозяина места (`recall`) и
+ * наблюдатель документа для мест без хозяина. AGENTS.md (Web Components),
+ * «Телепорт слоя» и «Панель ходит с местом».
+ */
+/** Текст якоря, который стоит на месте корня, пока корень в цели. */
+export declare const TELEPORT_ANCHOR = "so-teleport";
+export type TTeleportPlace = {
+    /** Селектор цели; `null` — цели нет. */
+    readonly target: string | null;
+    readonly contained: boolean;
+};
+export declare class TTeleport {
+    private readonly _host;
+    private readonly _root;
+    private readonly _companion;
+    private static readonly _watches;
+    /** Узел → корень, за который он стоит в свете контейнера: якорь и спутник. */
+    private static readonly _roots;
+    static rootAt(node: Node): Element | undefined;
+    /** Панели места хозяина — к якорям: он пересобран или снят со страницы. */
+    static recall(owner: Element): void;
+    private _anchor;
+    constructor(_host: Element, _root?: Element, _companion?: Element | null);
+    /** В цель или на место; отдаёт, на своём ли месте корень (цели нет — `false`). */
+    place({ target, contained }: TTeleportPlace): boolean;
+    /**
+     * Настоящее отключение корня-элемента: якорь и спутник уходят, а элементам
+     * в корне — долг, их отключение от той же операции настоящее.
+     */
+    release(): void;
+    private _nodes;
+    private _moveTo;
+    private _home;
+    /** Спутник — прямо перед корнем, где бы тот ни стоял. */
+    private _escort;
+    /** Хозяин места — ближайший элемент базы вверх от якоря, в момент вопроса. */
+    private _owner;
+    /** Якорь ушёл, или узел на пути до хозяина снят в этой пачке — и не базой. */
+    private _displaced;
+    /**
+     * К якорю с пересборкой: признак прежнего переноса базы, который ещё держится
+     * над панелью, настоящего отключения не глушит.
+     */
+    private _follow;
+    /** Одним подключением: корни собираются, когда браузер довёл колбэки всех панелей. */
+    private static _followAll;
+    private _return;
+    private _forget;
+    /** Якорь в теневом дереве — наблюдать и его корень: документ его состава не видит. */
+    private static _watch;
+    private static _unwatch;
+}

package/dist/adapter/runtime/teleport.js

@@ -0,0 +1,190 @@
+import { TPlaceContext } from "../context/place-context.class.js";
+import { isPlaceOwner } from "./marks.js";
+import { isRelocating, owe, rebuild, relocate } from "./relocation.js";
+import { connecting } from "./waiting.js";
+//#region src/adapter/runtime/teleport.ts
+/**
+* Телепорт корня слоя — аналог `<teleport :to>`: уводит корень со спутником
+* (подложкой) в цель по селектору, на месте оставляет якорь-комментарий, и
+* поиск по месту от корня идёт к якорю. Панель ходит с местом: место
+* пересобрано или снято — корень возвращается к якорю переносом с
+* пересборкой. Путей к этому два: колбэки хозяина места (`recall`) и
+* наблюдатель документа для мест без хозяина. AGENTS.md (Web Components),
+* «Телепорт слоя» и «Панель ходит с местом».
+*/
+/** Текст якоря, который стоит на месте корня, пока корень в цели. */
+var TELEPORT_ANCHOR = "so-teleport";
+var WATCHED = {
+	childList: true,
+	subtree: true
+};
+function removedIn(records) {
+	const removed = /* @__PURE__ */ new Set();
+	for (const record of records) for (const node of record.removedNodes) removed.add(node);
+	return removed;
+}
+/** Хозяева мест внутри узла — в свете и в открытых теневых корнях. */
+function ownersWithin(scope) {
+	const found = [];
+	for (const element of scope.querySelectorAll("*")) {
+		if (isPlaceOwner(element)) found.push(element);
+		if (element.shadowRoot) found.push(...ownersWithin(element.shadowRoot));
+	}
+	return found;
+}
+var TTeleport = class TTeleport {
+	_host;
+	_root;
+	_companion;
+	static _watches = /* @__PURE__ */ new WeakMap();
+	/** Узел → корень, за который он стоит в свете контейнера: якорь и спутник. */
+	static _roots = /* @__PURE__ */ new WeakMap();
+	static rootAt(node) {
+		return TTeleport._roots.get(node);
+	}
+	/** Панели места хозяина — к якорям: он пересобран или снят со страницы. */
+	static recall(owner) {
+		const watch = TTeleport._watches.get(owner.ownerDocument);
+		if (watch === void 0) return;
+		TTeleport._followAll([...watch.teleports].filter((each) => each._owner() === owner));
+	}
+	_anchor = null;
+	constructor(_host, _root = _host, _companion = null) {
+		this._host = _host;
+		this._root = _root;
+		this._companion = _companion;
+		if (_companion !== null) TTeleport._roots.set(_companion, _root);
+	}
+	/** В цель или на место; отдаёт, на своём ли месте корень (цели нет — `false`). */
+	place({ target, contained }) {
+		const root = this._root;
+		const wanted = contained || target === null ? null : root.ownerDocument.querySelector(target);
+		if (wanted === null) this._home();
+		else if (root.parentNode !== wanted) this._moveTo(wanted);
+		this._escort();
+		return contained || wanted !== null;
+	}
+	/**
+	* Настоящее отключение корня-элемента: якорь и спутник уходят, а элементам
+	* в корне — долг, их отключение от той же операции настоящее.
+	*/
+	release() {
+		if (this._root !== this._host) return;
+		owe(ownersWithin(this._root));
+		const anchor = this._anchor;
+		if (anchor !== null) {
+			this._forget(anchor);
+			anchor.remove();
+		}
+		this._companion?.remove();
+	}
+	_nodes() {
+		return this._companion === null ? [this._root] : [this._companion, this._root];
+	}
+	_moveTo(target) {
+		const root = this._root;
+		if (this._anchor === null) {
+			const anchor = root.ownerDocument.createComment(TELEPORT_ANCHOR);
+			root.before(anchor);
+			TPlaceContext.anchor(root, anchor);
+			TTeleport._roots.set(anchor, root);
+			TTeleport._watch(this, anchor);
+			this._anchor = anchor;
+		}
+		const nodes = this._nodes();
+		relocate(nodes, () => {
+			for (const node of nodes) target.appendChild(node);
+		});
+	}
+	_home() {
+		const anchor = this._anchor;
+		if (anchor === null) return;
+		this._forget(anchor);
+		relocate(this._nodes(), () => this._return(anchor));
+	}
+	/** Спутник — прямо перед корнем, где бы тот ни стоял. */
+	_escort() {
+		const companion = this._companion;
+		const root = this._root;
+		const parent = root.parentNode;
+		if (companion === null || parent === null || companion.nextSibling === root) return;
+		relocate([companion], () => parent.insertBefore(companion, root));
+	}
+	/** Хозяин места — ближайший элемент базы вверх от якоря, в момент вопроса. */
+	_owner() {
+		if (this._anchor === null) return null;
+		for (const node of TPlaceContext.ancestors(this._anchor)) if (isPlaceOwner(node)) return node;
+		return null;
+	}
+	/** Якорь ушёл, или узел на пути до хозяина снят в этой пачке — и не базой. */
+	_displaced(removed) {
+		const anchor = this._anchor;
+		if (anchor === null) return false;
+		if (!anchor.isConnected) return true;
+		if (removed.size === 0) return false;
+		for (let node = anchor; node !== null && !isPlaceOwner(node); node = TPlaceContext.above(node)) if (removed.has(node) && !isRelocating(node)) return true;
+		return false;
+	}
+	/**
+	* К якорю с пересборкой: признак прежнего переноса базы, который ещё держится
+	* над панелью, настоящего отключения не глушит.
+	*/
+	_follow() {
+		const anchor = this._anchor;
+		if (anchor === null) return;
+		this._forget(anchor);
+		rebuild(this._nodes(), () => this._return(anchor));
+	}
+	/** Одним подключением: корни собираются, когда браузер довёл колбэки всех панелей. */
+	static _followAll(teleports) {
+		if (teleports.length === 0) return;
+		connecting(() => {
+			for (const each of teleports) each._follow();
+		});
+	}
+	_return(anchor) {
+		const nodes = this._nodes();
+		if (!anchor.parentNode) {
+			for (const node of nodes) node.remove();
+			return;
+		}
+		for (const node of nodes) anchor.before(node);
+		anchor.remove();
+	}
+	_forget(anchor) {
+		this._anchor = null;
+		TPlaceContext.unanchor(this._root);
+		TTeleport._roots.delete(anchor);
+		TTeleport._unwatch(this, anchor.ownerDocument);
+	}
+	/** Якорь в теневом дереве — наблюдать и его корень: документ его состава не видит. */
+	static _watch(teleport, anchor) {
+		const owner = anchor.ownerDocument;
+		let watch = TTeleport._watches.get(owner);
+		if (watch === void 0) {
+			const teleports = /* @__PURE__ */ new Set();
+			const observer = new MutationObserver((records) => {
+				const removed = removedIn(records);
+				TTeleport._followAll([...teleports].filter((each) => each._displaced(removed)));
+			});
+			observer.observe(owner, WATCHED);
+			watch = {
+				observer,
+				teleports
+			};
+			TTeleport._watches.set(owner, watch);
+		}
+		watch.teleports.add(teleport);
+		for (let scope = anchor.getRootNode(); scope instanceof ShadowRoot; scope = scope.host.getRootNode()) watch.observer.observe(scope, WATCHED);
+	}
+	static _unwatch(teleport, owner) {
+		const watch = TTeleport._watches.get(owner);
+		if (watch === void 0) return;
+		watch.teleports.delete(teleport);
+		if (watch.teleports.size > 0) return;
+		watch.observer.disconnect();
+		TTeleport._watches.delete(owner);
+	}
+};
+//#endregion
+export { TELEPORT_ANCHOR, TTeleport };

package/dist/adapter/runtime/useAdapter.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The Web Components binding over an assembled adapter context. The platform
+ * has no reactivity: state is a plain object, `onUpdate` reports a change,
+ * and the element base schedules the render. Core events are `CustomEvent`s
+ * on the element; from the owner's markup they do not bubble. AGENTS.md (Web
+ * Components), «Связка».
+ */
+import type { IAdapterContext, IComponentContract, TInstanceState } from '@soxa-ui/setup';
+/**
+ * Instance properties with plugin outputs, and facade properties. Outputs go
+ * in one view with the instance, the owner's facade with the facade: from an
+ * intersection of three views TypeScript does not infer the instance from the
+ * expected type of the template context.
+ */
+export type TBindingState<TInstance, TFacade = unknown, TOutputs = unknown, TOwnerFacade = unknown> = TInstanceState<TInstance & TOutputs> & TInstanceState<TFacade & TOwnerFacade>;
+/** `TFacade` is the collection facade; the template calls collection commands via its context. */
+export type TBinding<TInstance = object, TFacade = unknown, TOutputs = unknown, TOwnerFacade = unknown> = {
+    readonly state: TBindingState<TInstance, TFacade, TOutputs, TOwnerFacade>;
+    readonly ctrl: TInstance;
+    readonly facade: TFacade;
+    syncProps(props: object): void;
+    bindElement(el: Element | null): void;
+    /** The teardown began: the consumer hears nothing from then on. */
+    detach(): void;
+    destroy(): void;
+};
+/** A facade's binding: `ctrl` and the node belong to the component, not the facade. */
+export type TCollectionBinding<TFacade = object> = {
+    readonly state: TInstanceState<TFacade>;
+    readonly facade: TFacade;
+    syncProps(props: object): void;
+    /** The teardown began: the consumer hears nothing from then on. */
+    detach(): void;
+    destroy(): void;
+};
+export type TUpdateListener = (name: string, value: unknown) => void;
+export declare function useAdapter<C extends IComponentContract>(adapter: IAdapterContext<C>, host: HTMLElement, onUpdate: TUpdateListener): TBinding<C['instance'], unknown, C['plugins']['outputs']>;
+export declare function useCollectionAdapter<C extends IComponentContract>(adapter: IAdapterContext<C>, host: HTMLElement, onUpdate: TUpdateListener): TCollectionBinding<C['instance']>;
+/**
+ * One binding from two or three contexts: the own, the item's facade and, for
+ * an item with a submenu, the facade of its own collection. The node is the
+ * own only; `detach` goes to all; facades are destroyed before the component,
+ * while its plugin bundle is intact.
+ */
+export declare function joinBindings<TInstance, TFacade, TOutputs, TOwnerFacade = unknown>(owner: TBinding<TInstance, unknown, TOutputs>, facade: TCollectionBinding<TFacade>, ownerFacade?: TCollectionBinding<TOwnerFacade>): TBinding<TInstance, TFacade, TOutputs, TOwnerFacade>;

package/dist/adapter/runtime/useAdapter.js

@@ -0,0 +1,151 @@
+import { WebcProfile } from "../common/profile.js";
+import "../common/index.js";
+import { isOwnerMarkup } from "./marks.js";
+import { toInstanceState } from "@soxa-ui/setup";
+import { TActionEvent } from "@soxa-ui/core";
+//#region src/adapter/runtime/useAdapter.ts
+/**
+* The Web Components binding over an assembled adapter context. The platform
+* has no reactivity: state is a plain object, `onUpdate` reports a change,
+* and the element base schedules the render. Core events are `CustomEvent`s
+* on the element; from the owner's markup they do not bubble. AGENTS.md (Web
+* Components), «Связка».
+*/
+/**
+* An event "before" (a `TActionEvent` argument) is cancelable: cancelling it
+* cancels the core event.
+*
+* A removed element sends nothing: the consumer took it down, and what its
+* teardown stirs (the blur of the removed node, the markup items leaving the
+* collection) is news to no one, as in the other adapters
+* (benchmarks/parity/README.md). An element moved elsewhere is assembled anew
+* on connecting (`ElementBase`), so its state starts over there too.
+*/
+function dispatch(host, name, args, bubbles) {
+	if (!host.isConnected) return;
+	const detail = args.length > 1 ? args : args[0];
+	const action = detail instanceof TActionEvent ? detail : void 0;
+	const event = new CustomEvent(name, {
+		detail,
+		bubbles,
+		composed: true,
+		cancelable: action !== void 0
+	});
+	if (!host.dispatchEvent(event)) action?.preventDefault();
+}
+function useExchange(adapter, host, onUpdate) {
+	const binding = adapter.connect(WebcProfile);
+	const bubbles = !isOwnerMarkup(host);
+	const state = {};
+	const unsubscribe = binding.state.subscribe((name, value) => {
+		state[name] = value;
+		onUpdate(name, value);
+	});
+	adapter.attach();
+	const unbindEvents = binding.events.listen((exportName, args) => {
+		dispatch(host, exportName, args, bubbles);
+	});
+	adapter.events.on("detach", unbindEvents);
+	return {
+		state: toInstanceState(state),
+		syncProps(props) {
+			binding.inputs.delta(props);
+		},
+		detach() {
+			adapter.detach();
+		},
+		destroy() {
+			unsubscribe();
+			unbindEvents();
+			adapter.destroy();
+		}
+	};
+}
+function useAdapter(adapter, host, onUpdate) {
+	return {
+		...useExchange(adapter, host, onUpdate),
+		ctrl: adapter.instance,
+		facade: void 0,
+		bindElement(el) {
+			adapter.bindElement(el);
+		}
+	};
+}
+function useCollectionAdapter(adapter, host, onUpdate) {
+	return {
+		...useExchange(adapter, host, onUpdate),
+		facade: adapter.instance
+	};
+}
+/** The first state in order that has the name. */
+function stateOf({ states }, name) {
+	return typeof name === "string" ? states.find((state) => Object.hasOwn(state, name)) : void 0;
+}
+/**
+* One handler for all views: a getter per name of every view (a closure, its
+* scope and a pair of accessors) cost a table row kilobytes.
+*/
+var JOINED = {
+	get(target, name) {
+		return typeof name === "string" ? stateOf(target, name)?.[name] : void 0;
+	},
+	has(target, name) {
+		return stateOf(target, name) !== void 0;
+	},
+	ownKeys({ states }) {
+		return [...new Set(states.flatMap((state) => Object.keys(state)))];
+	},
+	getOwnPropertyDescriptor(target, name) {
+		const state = stateOf(target, name);
+		return state && typeof name === "string" ? {
+			value: state[name],
+			enumerable: true,
+			configurable: true,
+			writable: false
+		} : void 0;
+	}
+};
+/**
+* A live view of several states: a property comes from the first that has it.
+* The subscription filled the keys at assembly and no new ones appear; values
+* are read at access time.
+*/
+function joinStates(states) {
+	return new Proxy({ states }, JOINED);
+}
+/** The runtime/type boundary, as `toInstanceState`: the descriptors hold the name link. */
+function toBindingState(view) {
+	return view;
+}
+/**
+* One binding from two or three contexts: the own, the item's facade and, for
+* an item with a submenu, the facade of its own collection. The node is the
+* own only; `detach` goes to all; facades are destroyed before the component,
+* while its plugin bundle is intact.
+*/
+function joinBindings(owner, facade, ownerFacade) {
+	const facades = ownerFacade ? [facade, ownerFacade] : [facade];
+	const ownerState = owner.state;
+	return {
+		state: toBindingState(joinStates([ownerState, ...facades.map((each) => each.state)])),
+		ctrl: owner.ctrl,
+		facade: facade.facade,
+		syncProps(props) {
+			owner.syncProps(props);
+			for (const each of facades) each.syncProps(props);
+		},
+		bindElement(el) {
+			owner.bindElement(el);
+		},
+		detach() {
+			owner.detach();
+			for (const each of facades) each.detach();
+		},
+		destroy() {
+			for (const each of facades) each.destroy();
+			owner.destroy();
+		}
+	};
+}
+//#endregion
+export { joinBindings, useAdapter, useCollectionAdapter };

package/dist/adapter/runtime/waiting.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Ожидание: подключение, пришедшее, пока подключается другой элемент, идёт
+ * сразу после него, в порядке прихода. AGENTS.md (Web Components), «Ожидание».
+ */
+export declare function isConnecting(): boolean;
+/** Подключение: пришедшее во время него ждёт конца внешнего подключения. */
+export declare function connecting(run: () => void): void;
+export declare function wait(resume: () => void): void;
+/** Выполнить всё: упавшая задача остальных не держит, первая ошибка уходит дальше. */
+export declare function runAll(tasks: Iterable<() => void>): void;