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

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

@@ -0,0 +1,129 @@
+import { assembling } from "./assembling.class.js";
+import { TRouting } from "./routing.class.js";
+import { TInputPort } from "./input-port.class.js";
+import { TEventRelay } from "./event-relay.class.js";
+import { TStateStore } from "./state-store.class.js";
+import { TTap } from "./tap.class.js";
+import { TUpdatePort } from "./update-port.class.js";
+import { TActionEvent } from "@soxa-ui/core";
+//#region protected/adapter/exchange/exchange.class.ts
+/**
+* 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.
+*/
+/** Отменяемое событие: аргумент — `TActionEvent`, приёмник отвечает на него `preventDefault`. */
+function isCancelable(args) {
+	return args[0] instanceof TActionEvent;
+}
+var TExchange = class {
+	surface;
+	/** Линии состава — общие у всех монтирований типа, владельцев берут из `owners`. */
+	lines;
+	/** Владельцы участников по порядку состава: инстанс, плагины, связка. */
+	owners;
+	state;
+	inputs;
+	events;
+	updates = new TUpdatePort();
+	/** Доставки уведомлений, отложенных до конца чужой сборки, — пока очередь не выпущена. */
+	_queue;
+	constructor(members, surface, buildProps = {}) {
+		this.surface = surface;
+		const routing = TRouting.of(surface, members);
+		const owners = members.map((member) => member.owner);
+		const tap = new TTap(owners, routing.routes, (route, args) => {
+			this.updates.begin();
+			try {
+				this._receive(route, args);
+			} finally {
+				this.updates.end();
+			}
+		});
+		this.lines = routing.lines;
+		this.owners = owners;
+		this.state = new TStateStore(routing.readable, owners, tap);
+		this.inputs = new TInputPort(routing.writable, owners, buildProps);
+		this.events = new TEventRelay(owners, tap);
+	}
+	/** Пропсы, которые компонент не съел: уходят атрибутами в корневой узел. */
+	forward(props) {
+		return this.surface.forward(props);
+	}
+	/** Очередь до конца чужой сборки: первая запись планирует её выпуск. */
+	_defer() {
+		if (this._queue === void 0) {
+			this._queue = [];
+			assembling.defer(() => this._release());
+		}
+		return this._queue;
+	}
+	/**
+	* 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.
+	*/
+	_receive(route, args) {
+		if (this._queue === void 0 && !assembling.covers(this.owners)) {
+			this.state.refresh(route.cells);
+			this.events.publish(route, args);
+		} else if (isCancelable(args)) {
+			this._defer();
+			this.events.publish(route, args);
+		} else this._defer().push(this.events.later(route, args));
+	}
+	/** The release after the assembly is one update: the whole state first, then the notifications in order. */
+	_release() {
+		const queue = this._queue ?? [];
+		this._queue = void 0;
+		this.updates.begin();
+		try {
+			this.state.refreshAll();
+			for (const deliver of queue) deliver();
+		} finally {
+			this.updates.end();
+		}
+	}
+};
+//#endregion
+export { TExchange };

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

@@ -0,0 +1,8 @@
+export { TExchange } from './exchange.class';
+export { TMember } from './member.class';
+export type { TInputPort } from './input-port.class';
+export type { TStateStore } from './state-store.class';
+export type { TEventRelay } from './event-relay.class';
+export type { TUpdatePort } from './update-port.class';
+export type { TLine } from './line.class';
+export type { IMemberSpec, IModelRoute, IRoute, IUpdateListener, TEventSink, TStateListener, TStateSnapshot, } from './types';

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

@@ -0,0 +1,64 @@
+/**
+ * TInputPort — фреймворк → ядро: память последнего значения каждого записываемого пропа.
+ *
+ * Память хранит последнее значение, которое задал фреймворк, и начинается с
+ * пропсов сборки. Отсюда правила входов получаются по построению, без флагов
+ * «задан / не задан»:
+ *
+ * - полный набор пришёл повторно — значения не сменились, в ядро ничего не
+ *   пишется. Иначе повтор откатил бы то, что с тех пор поменяли ядро или код
+ *   через инстанс: список, открытый кликом при `open={false}`, закрылся бы от
+ *   смены плейсхолдера;
+ * - составное значение с тем же содержимым — тоже повтор. Литерал массива в
+ *   разметке (`value={['a', 'b']}`) на каждом проходе родителя — новый
+ *   объект, поэтому память сверяет по содержимому (`sameValue`), тем же
+ *   правилом, что и состояние: по ссылке перерисовка родителя откатывала бы
+ *   выбор пользователя к разметке. Повтор гасится только здесь — линия
+ *   пишет всё, что до неё дошло, а сверку со своим значением делает сеттер;
+ * - проп ни разу не задавали — значение было `undefined` и осталось, слива нет;
+ * - задавали и сняли — значение сменилось на `undefined`, линия сбрасывает к умолчанию;
+ * - после сброса значение снова `undefined` — повторное снятие ничего не пишет.
+ *
+ * Значения лежат одним списком по линиям (значение `i` — линии `i`), а не
+ * объектом на проп: у входа нет ни подписчиков, ни своего поведения, и объект
+ * на проп был бы только обёрткой над значением.
+ *
+ * Два способа доставки различаются только тем, что считать изменением: в
+ * полном наборе — смену значения (`full`), в дельте — само наличие ключа
+ * (`delta`). Что делать с изменением, решает линия.
+ */
+import type { TLine } from './line.class';
+import type { TMember } from './member.class';
+import type { TSurface } from '../surface';
+export declare class TInputPort {
+    private readonly _lines;
+    private readonly _owners;
+    /** Последнее, что задал фреймворк, по линиям. */
+    private readonly _given;
+    /**
+     * Начальные значения — записываемым линиям участников из пропсов сборки, тем
+     * же чтением, с которого начинается память входов. Кому из участников
+     * писать, решает сборка. Память нужна обмену, а не начальной записи,
+     * поэтому порт для неё не заводится.
+     */
+    static seed(members: readonly TMember[], surface: TSurface, buildProps: object): void;
+    /**
+     * Память входов начинается с пропсов сборки.
+     *
+     * @param _lines записываемые линии обмена — по значению на каждую
+     * @param _owners владельцы участников монтирования — по порядку состава
+     */
+    constructor(_lines: readonly TLine[], _owners: readonly object[], buildProps: object);
+    /** Полный набор на каждом проходе: React, Solid, Svelte, Vue. В ядро уходит только то, что фреймворк сменил. */
+    full(props: object): void;
+    /**
+     * Дельта: Angular, Web Components. Чего в дельте нет, то не менялось, а
+     * наличие ключа — уже изменение: `el.open = false` у Web Components —
+     * команда, а не повтор рендера, и она обязана дойти до ядра, даже если
+     * фреймворк давал `false` и раньше. Снятие ни разу не заданного пропа
+     * командой не является.
+     */
+    delta(changes: object): void;
+    /** Запомнить значение входа: ответ — сменилось ли оно. */
+    private _take;
+}

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

@@ -0,0 +1,68 @@
+import { sameValue } from "./value.js";
+import { TRouting } from "./routing.class.js";
+//#region protected/adapter/exchange/input-port.class.ts
+/** Значение по имени во фреймворке (`aria_label`), затем по сырому (`label`) — для headless-кода и тестов. */
+function pick(props, line) {
+	return Reflect.get(props, line.name) ?? Reflect.get(props, line.spec.name.name);
+}
+function has(props, line) {
+	return line.name in props || line.spec.name.name in props;
+}
+var TInputPort = class {
+	_lines;
+	_owners;
+	/** Последнее, что задал фреймворк, по линиям. */
+	_given;
+	/**
+	* Начальные значения — записываемым линиям участников из пропсов сборки, тем
+	* же чтением, с которого начинается память входов. Кому из участников
+	* писать, решает сборка. Память нужна обмену, а не начальной записи,
+	* поэтому порт для неё не заводится.
+	*/
+	static seed(members, surface, buildProps) {
+		const owners = members.map((member) => member.owner);
+		for (const line of TRouting.of(surface, members).writable) line.seed(owners, pick(buildProps, line));
+	}
+	/**
+	* Память входов начинается с пропсов сборки.
+	*
+	* @param _lines записываемые линии обмена — по значению на каждую
+	* @param _owners владельцы участников монтирования — по порядку состава
+	*/
+	constructor(_lines, _owners, buildProps) {
+		this._lines = _lines;
+		this._owners = _owners;
+		this._given = _lines.map((line) => pick(buildProps, line));
+	}
+	/** Полный набор на каждом проходе: React, Solid, Svelte, Vue. В ядро уходит только то, что фреймворк сменил. */
+	full(props) {
+		for (let index = 0; index < this._lines.length; index++) {
+			const line = this._lines[index];
+			const value = pick(props, line);
+			if (this._take(index, value)) line.accept(this._owners, value);
+		}
+	}
+	/**
+	* Дельта: Angular, Web Components. Чего в дельте нет, то не менялось, а
+	* наличие ключа — уже изменение: `el.open = false` у Web Components —
+	* команда, а не повтор рендера, и она обязана дойти до ядра, даже если
+	* фреймворк давал `false` и раньше. Снятие ни разу не заданного пропа
+	* командой не является.
+	*/
+	delta(changes) {
+		for (let index = 0; index < this._lines.length; index++) {
+			const line = this._lines[index];
+			if (!has(changes, line)) continue;
+			const value = pick(changes, line);
+			if (this._take(index, value) || value !== void 0) line.accept(this._owners, value);
+		}
+	}
+	/** Запомнить значение входа: ответ — сменилось ли оно. */
+	_take(index, value) {
+		if (sameValue(this._given[index], value)) return false;
+		this._given[index] = value;
+		return true;
+	}
+};
+//#endregion
+export { TInputPort };

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

@@ -0,0 +1,53 @@
+/**
+ * TLine — линия: одно свойство одного участника в составе компонента.
+ *
+ * Описание (`TPropSpec`) + место участника в составе + имя во фреймворке.
+ * Это знание типа, а не монтирования: линии строит таблица маршрутов
+ * (`TRouting`) один раз на поверхность и состав, а владельцев участников
+ * монтирование отдаёт каждому вызову списком (`owners`, по порядку состава).
+ * Объекта на свойство у монтирования нет: раньше линия держала своего
+ * владельца, и у строки таблицы с чекбоксом их было около пятидесяти.
+ *
+ * Линия — единственный объект, который знает про свойство всё сразу, поэтому
+ * каждое правило записи живёт здесь один раз — и для сборки, и для обмена, и
+ * для плагинов, поставленных снаружи:
+ *
+ * - `write`  — `protected` не пишется. То же ли это значение, решает сеттер
+ *   владельца — сверкой со своим записанным значением. Геттер для этого не
+ *   годится: у свойства с резольвером он отдаёт итог (`disabled` элемента —
+ *   своё или владельца, прижатое `value` Slider), и значение, равное итогу, но
+ *   не своему, сверка с геттером теряла бы. Повтор от фреймворка сюда не
+ *   доходит: его гасит память входов (`TInputPort`);
+ * - `reset`  — к умолчанию описания; ключа умолчания нет — значение остаётся;
+ * - `accept` — что пришло от фреймворка: `undefined` значит «сняли»;
+ * - `seed`   — начальное значение: `undefined` и равное умолчанию ничего не
+ *   задают. Так внешний `ctrl` сохраняет своё состояние, даже когда фреймворк
+ *   подставил умолчание за автора (Vue делает это с каждым пропом, у которого
+ *   объявлен `default`).
+ *
+ * Памяти у линии нет: «что задал фреймворк» помнит память входов
+ * (`TInputPort`), «что отдано фреймворку» — состояние (`TStateStore`).
+ * Подписок тоже нет: за триггерами свойства следит слушатель участников
+ * (`TTap`) по таблице маршрутов типа.
+ */
+import type { TPropSpec } from '../../define';
+export declare class TLine {
+    readonly spec: TPropSpec;
+    /** Место участника в составе: владелец свойства — `owners[member]`. */
+    readonly member: number;
+    /** Имя во фреймворке: `text`, `aria_label`. */
+    readonly name: string;
+    constructor(spec: TPropSpec, 
+    /** Место участника в составе: владелец свойства — `owners[member]`. */
+    member: number, 
+    /** Имя во фреймворке: `text`, `aria_label`. */
+    name: string);
+    /** Есть триггеры — за свойством можно следить, оно входит в состояние. Без них проп сквозной. */
+    get readable(): boolean;
+    get writable(): boolean;
+    read(owners: readonly object[]): unknown;
+    write(owners: readonly object[], value: unknown): void;
+    reset(owners: readonly object[]): void;
+    accept(owners: readonly object[], value: unknown): void;
+    seed(owners: readonly object[], value: unknown): void;
+}

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

@@ -0,0 +1,39 @@
+import { sameValue } from "./value.js";
+//#region protected/adapter/exchange/line.class.ts
+var TLine = class {
+	spec;
+	member;
+	name;
+	constructor(spec, member, name) {
+		this.spec = spec;
+		this.member = member;
+		this.name = name;
+	}
+	/** Есть триггеры — за свойством можно следить, оно входит в состояние. Без них проп сквозной. */
+	get readable() {
+		return this.spec.triggers.length > 0;
+	}
+	get writable() {
+		return !this.spec.protected;
+	}
+	read(owners) {
+		return this.spec.read(owners[this.member]);
+	}
+	write(owners, value) {
+		if (this.writable) this.spec.assign(owners[this.member], value);
+	}
+	reset(owners) {
+		if (this.spec.hasDefault) this.write(owners, this.spec.default);
+	}
+	accept(owners, value) {
+		if (value === void 0) this.reset(owners);
+		else this.write(owners, value);
+	}
+	seed(owners, value) {
+		if (value === void 0) return;
+		if (this.spec.hasDefault && sameValue(value, this.spec.default)) return;
+		this.write(owners, value);
+	}
+};
+//#endregion
+export { TLine };

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

@@ -0,0 +1,20 @@
+/**
+ * TMember — участник монтирования: владелец и описание того, что он объявляет наружу.
+ *
+ * Инстанс, плагин дескриптора, плагин, поставленный снаружи, и сама связка
+ * (владелец `pluginProps`) — участники одного вида. Обмену безразлично, кто
+ * есть кто: он получает список участников и строит линии. «Плагина в чужом
+ * наборе нет» означает, что нет участника, — и ни одна проверка дальше по коду
+ * не нужна.
+ *
+ * Владелец — свой у монтирования, описание (`IMemberSpec`) — общее у типа: у
+ * плагина это его определение, у инстанса и связки — описание, одно на
+ * дескриптор. По описаниям обмен находит свою таблицу маршрутов (`TRouting`),
+ * поэтому они не строятся на монтирование.
+ */
+import type { IMemberSpec } from './types';
+export declare class TMember {
+    readonly owner: object;
+    readonly spec: IMemberSpec;
+    constructor(owner: object, spec: IMemberSpec);
+}

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

@@ -0,0 +1,11 @@
+//#region protected/adapter/exchange/member.class.ts
+var TMember = class {
+	owner;
+	spec;
+	constructor(owner, spec) {
+		this.owner = owner;
+		this.spec = spec;
+	}
+};
+//#endregion
+export { TMember };

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

@@ -0,0 +1,25 @@
+/**
+ * TRouting shares property lines and event routes across mounts of the same participant descriptions.
+ * Internal triggers refresh state and models independently of explicitly published events.
+ */
+import type { TSurface } from '../surface';
+import { TLine } from './line.class';
+import type { TMember } from './member.class';
+import type { IRoute } from './types';
+export declare class TRouting {
+    /** Линии состава: свойства участников в поверхности. */
+    readonly lines: readonly TLine[];
+    /** Линии с триггерами: значение состояния `i` — линия `readable[i]`. */
+    readonly readable: readonly TLine[];
+    /** Записываемые линии: значение входа `i` — линия `writable[i]`. */
+    readonly writable: readonly TLine[];
+    /**
+     * Маршруты участников по порядку состава: сырое имя на шине участника →
+     * маршрут. У участника, с событиями которого обмену делать нечего, —
+     * `undefined`: его шину обмен не слушает.
+     */
+    readonly routes: readonly (ReadonlyMap<string, IRoute> | undefined)[];
+    /** Таблица поверхности для состава участников монтирования; строится один раз на пару. */
+    static of(surface: TSurface, members: readonly TMember[]): TRouting;
+    private constructor();
+}

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

@@ -0,0 +1,94 @@
+import { TLine } from "./line.class.js";
+//#region protected/adapter/exchange/routing.class.ts
+var roots = /* @__PURE__ */ new WeakMap();
+var TRouting = class TRouting {
+	/** Линии состава: свойства участников в поверхности. */
+	lines;
+	/** Линии с триггерами: значение состояния `i` — линия `readable[i]`. */
+	readable;
+	/** Записываемые линии: значение входа `i` — линия `writable[i]`. */
+	writable;
+	/**
+	* Маршруты участников по порядку состава: сырое имя на шине участника →
+	* маршрут. У участника, с событиями которого обмену делать нечего, —
+	* `undefined`: его шину обмен не слушает.
+	*/
+	routes;
+	/** Таблица поверхности для состава участников монтирования; строится один раз на пару. */
+	static of(surface, members) {
+		let node = roots.get(surface);
+		if (!node) {
+			node = { next: /* @__PURE__ */ new WeakMap() };
+			roots.set(surface, node);
+		}
+		for (const { spec } of members) {
+			let next = node.next.get(spec);
+			if (!next) {
+				next = { next: /* @__PURE__ */ new WeakMap() };
+				node.next.set(spec, next);
+			}
+			node = next;
+		}
+		node.routing ??= new TRouting(surface, members.map((member) => member.spec));
+		return node.routing;
+	}
+	constructor(surface, specs) {
+		const lines = [];
+		const readable = [];
+		const writable = [];
+		const drafts = specs.map(() => /* @__PURE__ */ new Map());
+		const draftOf = (member, raw) => {
+			const routes = drafts[member];
+			let draft = routes.get(raw);
+			if (!draft) {
+				draft = {
+					cells: [],
+					models: []
+				};
+				routes.set(raw, draft);
+			}
+			return draft;
+		};
+		specs.forEach((spec, member) => {
+			for (const prop of spec.props) {
+				const entry = surface.entryOf(prop);
+				if (!entry) continue;
+				const line = new TLine(prop, member, entry.exportName);
+				lines.push(line);
+				if (!prop.protected) writable.push(line);
+				if (prop.triggers.length === 0) continue;
+				const cell = readable.length;
+				readable.push(line);
+				for (const trigger of prop.triggers) {
+					const draft = draftOf(member, trigger.name);
+					const { cells } = draft;
+					if (!cells.includes(cell)) cells.push(cell);
+					if (entry.model !== void 0 && !draft.models.some((model) => model.name === entry.model)) draft.models = [...draft.models, {
+						line,
+						name: entry.model
+					}];
+				}
+			}
+		});
+		const publishers = /* @__PURE__ */ new Map();
+		specs.forEach((spec, member) => {
+			for (const name of spec.events) if (!publishers.has(name.getName())) publishers.set(name.getName(), member);
+		});
+		for (const event of surface.events) {
+			const member = publishers.get(event.name.getName());
+			if (member === void 0) continue;
+			const draft = draftOf(member, event.name.name);
+			draft.event = event.exportName;
+		}
+		this.lines = Object.freeze(lines);
+		this.readable = Object.freeze(readable);
+		this.writable = Object.freeze(writable);
+		this.routes = Object.freeze(drafts.map((routes) => routes.size === 0 ? void 0 : new Map([...routes].map(([raw, { cells, event, models }]) => [raw, Object.freeze({
+			cells: Object.freeze(cells),
+			...event === void 0 ? {} : { event },
+			models: Object.freeze(models)
+		})]))));
+	}
+};
+//#endregion
+export { TRouting };

package/dist/protected/adapter/exchange/state-store.class.d.ts

@@ -0,0 +1,57 @@
+/**
+ * TStateStore — ядро → фреймворк: значение каждого свойства с триггерами и снимок всего состояния.
+ *
+ * Путь у значения один: сработал триггер — свойство перечитано и положено на
+ * своё место; подписался фреймворк — то же самое для каждого свойства.
+ * «Сменилось ли» решает одно правило равенства (`sameValue`), поэтому снимок
+ * остаётся тем же объектом, пока ни одно значение не сменилось, — не
+ * проверкой, а по построению.
+ *
+ * Значения лежат одним списком по линиям (значение `i` — линии `i`), а не
+ * ячейкой на свойство: подписчиков у отдельного свойства нет — уведомляет
+ * состояние целиком, — и объект на свойство был бы только обёрткой над
+ * значением. Список заводит первое чтение: обмену плагина, поставленного
+ * снаружи, состояние не нужно — ему хватает входов и событий.
+ *
+ * За триггерами следит слушатель участников обмена (`TTap`): состояние держит
+ * его, пока у него есть подписчики, а слушатель зовёт `refresh` со
+ * значениями, для чьих свойств событие — триггер.
+ *
+ * `subscribe` и `getSnapshot` — методы: фреймворк, которому они нужны без
+ * `this` (`useSyncExternalStore`), привязывает их у себя в адаптере.
+ */
+import type { TLine } from './line.class';
+import type { TTap } from './tap.class';
+import type { TStateListener, TStateSnapshot } from './types';
+export declare class TStateStore {
+    private readonly _lines;
+    private readonly _owners;
+    private readonly _tap;
+    /** Значения по линиям — с первого чтения. */
+    private _values?;
+    /** Подписчики — пока есть хоть один. Список не правится на месте: уведомление обходит тот, что застало. */
+    private _listeners?;
+    private _snapshot;
+    /**
+     * @param _lines линии с триггерами: значение `i` — линии `i`
+     * @param _owners владельцы участников монтирования — по порядку состава
+     * @param _tap слушатель участников, общий с событиями обмена
+     */
+    constructor(_lines: readonly TLine[], _owners: readonly object[], _tap: TTap);
+    subscribe(listener: TStateListener): () => void;
+    getSnapshot(): TStateSnapshot;
+    /**
+     * Сработал триггер: перечитать значения его свойств. Зовёт слушатель
+     * участников (`TTap`), а не адаптер. Пока состояние не слушают, значения не
+     * перечитываются — их перечитает подписка.
+     */
+    refresh(cells: readonly number[]): void;
+    /**
+     * Перечитать все значения: триггеры пришли во время чужой сборки, и обмен
+     * отложил их (`TExchange`). Пока состояние не слушают — как у `refresh`.
+     */
+    refreshAll(): void;
+    private _refresh;
+    /** Перечитать свойство: сменилось — снимок устарел, подписчики получают новое значение. */
+    private _read;
+}

package/dist/protected/adapter/exchange/state-store.class.js

@@ -0,0 +1,76 @@
+import { sameValue } from "./value.js";
+//#region protected/adapter/exchange/state-store.class.ts
+var TStateStore = class {
+	_lines;
+	_owners;
+	_tap;
+	/** Значения по линиям — с первого чтения. */
+	_values;
+	/** Подписчики — пока есть хоть один. Список не правится на месте: уведомление обходит тот, что застало. */
+	_listeners;
+	_snapshot = null;
+	/**
+	* @param _lines линии с триггерами: значение `i` — линии `i`
+	* @param _owners владельцы участников монтирования — по порядку состава
+	* @param _tap слушатель участников, общий с событиями обмена
+	*/
+	constructor(_lines, _owners, _tap) {
+		this._lines = _lines;
+		this._owners = _owners;
+		this._tap = _tap;
+	}
+	subscribe(listener) {
+		if (this._listeners === void 0) this._tap.hold();
+		const values = this._refresh();
+		const listeners = this._listeners;
+		if (!listeners) this._listeners = [listener];
+		else if (!listeners.includes(listener)) this._listeners = [...listeners, listener];
+		this._lines.forEach((line, index) => listener(line.name, values[index]));
+		return () => {
+			const current = this._listeners;
+			const index = current?.indexOf(listener) ?? -1;
+			if (current === void 0 || index === -1) return;
+			this._listeners = current.length === 1 ? void 0 : [...current.slice(0, index), ...current.slice(index + 1)];
+			if (this._listeners === void 0) this._tap.release();
+		};
+	}
+	getSnapshot() {
+		const values = this._values ?? this._refresh();
+		this._snapshot ??= Object.freeze(Object.fromEntries(this._lines.map((line, index) => [line.name, values[index]])));
+		return this._snapshot;
+	}
+	/**
+	* Сработал триггер: перечитать значения его свойств. Зовёт слушатель
+	* участников (`TTap`), а не адаптер. Пока состояние не слушают, значения не
+	* перечитываются — их перечитает подписка.
+	*/
+	refresh(cells) {
+		const values = this._values;
+		if (this._listeners === void 0 || values === void 0) return;
+		for (const index of cells) this._read(values, index);
+	}
+	/**
+	* Перечитать все значения: триггеры пришли во время чужой сборки, и обмен
+	* отложил их (`TExchange`). Пока состояние не слушают — как у `refresh`.
+	*/
+	refreshAll() {
+		if (this._listeners !== void 0) this._refresh();
+	}
+	_refresh() {
+		const values = this._values ??= this._lines.map(() => void 0);
+		for (let index = 0; index < this._lines.length; index++) this._read(values, index);
+		return values;
+	}
+	/** Перечитать свойство: сменилось — снимок устарел, подписчики получают новое значение. */
+	_read(values, index) {
+		const line = this._lines[index];
+		const value = line.read(this._owners);
+		if (sameValue(values[index], value)) return;
+		values[index] = value;
+		this._snapshot = null;
+		const listeners = this._listeners;
+		if (listeners) for (const listener of listeners) listener(line.name, value);
+	}
+};
+//#endregion
+export { TStateStore };