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

package/dist/adapter/runtime/light.js

@@ -0,0 +1,131 @@
+import { assignSlot, isSlotMark, takeAssignedSlot } from "./marks.js";
+import { relocate } from "./relocation.js";
+import { TTeleport } from "./teleport.js";
+import { isContent } from "./content.js";
+import { DEFAULT_SLOT } from "@soxa-ui/setup";
+//#region src/adapter/runtime/light.ts
+/**
+* Свет элемента — его содержимое из разметки, разложенное по точкам шаблона.
+* Shadow DOM нет: тема — глобальные классы, и через теневую границу они не
+* проходят. Слот — по атрибуту `slot` (назначенный шаблоном владельца
+* главнее), слот без содержимого не задан, слот, которого шаблон не объявил,
+* не выводится. Раскладывается один раз, переносом силами базы. AGENTS.md
+* (Web Components), «Свет и слоты».
+*/
+/** У якоря увезённого корня и у спутника слот — корня: в свет они встают вместо него. */
+function slotOf(node) {
+	const assigned = takeAssignedSlot(node);
+	if (assigned !== void 0) return assigned;
+	return (TTeleport.rootAt(node) ?? (node instanceof Element ? node : void 0))?.getAttribute("slot") ?? DEFAULT_SLOT;
+}
+function groupBySlot(nodes) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const name = slotOf(node);
+		const group = groups.get(name);
+		if (group) group.push(node);
+		else groups.set(name, [node]);
+	}
+	return groups;
+}
+/** Только свои ключи: `slot="toString"` не найдёт метод объекта. */
+function targetOf(targets, name) {
+	return Object.hasOwn(targets, name) ? targets[name] : void 0;
+}
+function place(node, target) {
+	if (target.slot !== void 0) assignSlot(node, target.slot);
+	if (target.mode === "append") target.node.appendChild(node);
+	else target.node.parentNode?.insertBefore(node, target.node);
+}
+/** Копия узла образца: у `<template>` — его содержимого; без `slot` — место назначает шаблон. */
+function copyOf(node, owner) {
+	if (node instanceof HTMLTemplateElement) return owner.importNode(node.content, true);
+	const copy = node.cloneNode(true);
+	if (copy instanceof Element) copy.removeAttribute("slot");
+	return copy;
+}
+var TLight = class {
+	_host;
+	/** Заданные слоты; `null` — структура ещё не построена. */
+	_slots = null;
+	_targets = {};
+	/** Слоты, которые привязка сняла: их содержимое вне документа. */
+	_hidden = /* @__PURE__ */ new Set();
+	_content;
+	constructor(_host) {
+		this._host = _host;
+		this._content = _host;
+	}
+	get built() {
+		return this._slots !== null;
+	}
+	/** Узел слота по умолчанию; его нет (ProgressSpinner) — сам элемент. */
+	get content() {
+		return this._content;
+	}
+	has(name) {
+		return this._slots?.has(name) ?? false;
+	}
+	/** Свет по слотам — до построения шаблона: обёртку слота он строит, только когда она нужна. */
+	gather() {
+		const groups = groupBySlot(Array.from(this._host.childNodes));
+		const slots = /* @__PURE__ */ new Map();
+		for (const [name, nodes] of groups) if (nodes.some((node) => isContent(node) || isSlotMark(node))) slots.set(name, nodes);
+		this._slots = slots;
+		return groups;
+	}
+	/** По точкам в порядке их объявления; образец уходит из документа, лишнее снимается. */
+	distribute(groups, targets) {
+		const fallback = targetOf(targets, DEFAULT_SLOT);
+		this._content = fallback?.mode === "append" ? fallback.node : this._host;
+		this._targets = targets;
+		for (const [name, target] of Object.entries(targets)) {
+			const nodes = this._slots?.get(name);
+			if (!nodes) continue;
+			if (target.mode === "sample") {
+				for (const node of nodes) node.remove();
+				continue;
+			}
+			relocate(nodes, () => {
+				for (const node of nodes) place(node, target);
+			});
+		}
+		for (const [name, nodes] of groups) {
+			if (this._slots?.has(name) && targetOf(targets, name)) continue;
+			for (const node of nodes) node.remove();
+		}
+	}
+	/** Слот, который выводит привязка (`showSlot`): снятое уходит из документа. */
+	show(name, shown) {
+		const nodes = this._slots?.get(name);
+		const target = targetOf(this._targets, name);
+		if (!nodes || !target || target.mode === "sample" || this._hidden.has(name) !== shown) return;
+		if (shown) {
+			this._hidden.delete(name);
+			relocate(nodes, () => {
+				for (const node of nodes) place(node, target);
+			});
+		} else {
+			this._hidden.add(name);
+			for (const node of nodes) node.remove();
+		}
+	}
+	/** Узлы слота в его точке — копией списка; образец — пусто. */
+	slotted(name) {
+		const nodes = this._slots?.get(name);
+		const target = targetOf(this._targets, name);
+		if (!nodes || !target || target.mode === "sample") return [];
+		return [...nodes];
+	}
+	/** Новая копия образца на каждый вызов. */
+	sample(name) {
+		const nodes = this._slots?.get(name);
+		if (!nodes || targetOf(this._targets, name)?.mode !== "sample") return null;
+		const owner = this._host.ownerDocument;
+		const copy = owner.createDocumentFragment();
+		for (const node of nodes) copy.append(copyOf(node, owner));
+		return copy;
+	}
+};
+//#endregion
+export { TLight };

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

@@ -0,0 +1,19 @@
+/**
+ * Метки узлов — по самому узлу, в слабых коллекциях, а не атрибутом: атрибут
+ * оставил бы след в DOM и уехал бы с копией `cloneNode`. AGENTS.md (Web
+ * Components), «Метки узлов».
+ */
+/** Элемент собирает база: он хозяин места панелей, чей якорь стоит в нём. */
+export declare function markPlaceOwner(element: Element): void;
+export declare function isPlaceOwner(node: Node): boolean;
+/** Элемент построил шаблон библиотеки: его события не всплывают. */
+export declare function markOwnerMarkup(element: Element): void;
+export declare function isOwnerMarkup(element: Element): boolean;
+/** Комментарий задаёт слот детали и пустым (`lendMark`). */
+export declare function markSlot(mark: Comment, slot: string): void;
+export declare function isSlotMark(node: Node): boolean;
+export declare function slotOfMark(node: Node): string | undefined;
+/** Слот в свете детали, назначенный шаблоном владельца, — главнее атрибута `slot`. */
+export declare function assignSlot(node: Node, slot: string): void;
+/** Назначение — на одну раскладку света: дальше узел живёт по своему атрибуту. */
+export declare function takeAssignedSlot(node: Node): string | undefined;

package/dist/adapter/runtime/marks.js

@@ -0,0 +1,46 @@
+//#region src/adapter/runtime/marks.ts
+/**
+* Метки узлов — по самому узлу, в слабых коллекциях, а не атрибутом: атрибут
+* оставил бы след в DOM и уехал бы с копией `cloneNode`. AGENTS.md (Web
+* Components), «Метки узлов».
+*/
+var owners = /* @__PURE__ */ new WeakSet();
+var ownerMarkup = /* @__PURE__ */ new WeakSet();
+var slotMarks = /* @__PURE__ */ new WeakMap();
+var assigned = /* @__PURE__ */ new WeakMap();
+/** Элемент собирает база: он хозяин места панелей, чей якорь стоит в нём. */
+function markPlaceOwner(element) {
+	owners.add(element);
+}
+function isPlaceOwner(node) {
+	return owners.has(node);
+}
+/** Элемент построил шаблон библиотеки: его события не всплывают. */
+function markOwnerMarkup(element) {
+	ownerMarkup.add(element);
+}
+function isOwnerMarkup(element) {
+	return ownerMarkup.has(element);
+}
+/** Комментарий задаёт слот детали и пустым (`lendMark`). */
+function markSlot(mark, slot) {
+	slotMarks.set(mark, slot);
+}
+function isSlotMark(node) {
+	return slotMarks.has(node);
+}
+function slotOfMark(node) {
+	return slotMarks.get(node);
+}
+/** Слот в свете детали, назначенный шаблоном владельца, — главнее атрибута `slot`. */
+function assignSlot(node, slot) {
+	assigned.set(node, slot);
+}
+/** Назначение — на одну раскладку света: дальше узел живёт по своему атрибуту. */
+function takeAssignedSlot(node) {
+	const slot = assigned.get(node);
+	if (slot !== void 0) assigned.delete(node);
+	return slot;
+}
+//#endregion
+export { assignSlot, isOwnerMarkup, isPlaceOwner, isSlotMark, markOwnerMarkup, markPlaceOwner, markSlot, slotOfMark, takeAssignedSlot };

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

@@ -0,0 +1,91 @@
+/**
+ * Раскладка того, что библиотека пишет на узел: атрибуты наборов, классы,
+ * стиль и скрытие. Написанное потребителем главнее: по каждому имени память
+ * помнит своё значение, своё пишет и снимает, чужое не трогает, — кроме
+ * атрибутов-входов пропов (`disabled`), их значение ядра верно всегда. Память —
+ * у узла, а не у связки: связка новая на каждое подключение. AGENTS.md (Web
+ * Components), «Раскладка на узел».
+ */
+/**
+ * Атрибуты, которые раскладка пишет или записала: имя → значение и, среди
+ * них, входы пропов. Значения — объектом, а не `Map`: узлы с одним набором
+ * имён (ячейки таблицы) делят одну форму объекта, и память на узел — десятки
+ * байт, а не таблица `Map` на каждый.
+ */
+export type TAppliedAttributes = {
+    readonly values: Readonly<Record<string, string>>;
+    readonly inputs: ReadonlySet<string>;
+};
+export type TAppliedClasses = ReadonlySet<string>;
+/** Имя свойства, как в CSS (`z-index`, `--*`), → значение. */
+export type TRootStyles = ReadonlyMap<string, string>;
+/** Узел нормализует значение: чужое ли свойство — по прочитанному, нужна ли запись — по своему. */
+type TAppliedStyle = {
+    readonly value: string;
+    readonly written: string;
+};
+export type TAppliedStyles = ReadonlyMap<string, TAppliedStyle>;
+/** `display` до скрытия; `undefined` — узел базой не скрыт. */
+export type THiddenDisplay = string | undefined;
+/**
+ * Стиль из слоёв снизу вверх. Число — строкой, пустая строка и не строки
+ * свойства не задают. Слои читаются из состояния по имени, вид не на веру.
+ */
+export declare function stylesOf(...layers: readonly unknown[]): TRootStyles;
+/** Место элемента в ряду коллекции, как `:style="{ order }"` у Vue. */
+export declare function orderOf(value: unknown): object | undefined;
+export declare function setOf(value: unknown): object;
+export declare function classesOf(value: unknown): readonly string[];
+export declare function applyAttributes(element: Element, wanted: TAppliedAttributes, applied: TAppliedAttributes): TAppliedAttributes;
+export declare function applyClasses(element: Element, classes: readonly string[], applied: TAppliedClasses): TAppliedClasses;
+export declare function applyStyles(element: ElementCSSInlineStyle, styles: TRootStyles, applied: TAppliedStyles): TAppliedStyles;
+/** Как `v-show`: `display: none` поверх `display` потребителя, показ возвращает прежнее. */
+export declare function applyHidden(element: ElementCSSInlineStyle, hidden: boolean, saved: THiddenDisplay): THiddenDisplay;
+/**
+ * Слои атрибутов снизу вверх: наборы ядра компонента, чей это корень; набор
+ * разметки владельца (`ownerAttributes`); набор, который владелец положил на
+ * деталь с полем, — он уходит на её поле.
+ */
+export declare const ATTRIBUTE_LAYERS: readonly ["attrs", "aria", "dataset", "owner", "detail"];
+export type TAttributeLayer = (typeof ATTRIBUTE_LAYERS)[number];
+/**
+ * Атрибуты узла от всех, кто их пишет, — слоями, одной суммой и одной памятью:
+ * две раскладки со своей памятью спорили бы за общее имя.
+ */
+export declare class TElementAttributes {
+    private readonly _element;
+    static of(element: Element): TElementAttributes;
+    private readonly _layers;
+    private _applied;
+    /** Раскладчик поля; `null` — поле ещё не построено; `undefined` — поля нет. */
+    private _field;
+    private _held;
+    private constructor();
+    set(layer: TAttributeLayer, set: object, inputs?: ReadonlySet<string>): void;
+    /**
+     * Значение атрибута, которое ставит раскладка, — сумма слоёв; `undefined` —
+     * имени она не называет. Слои новые ещё до записи в узел, поэтому колбэк
+     * атрибута, пришедший посреди раскладки, видит уже то, что она пишет.
+     */
+    wanted(name: string): string | undefined;
+    /** У узла есть поле: слой владельца ждёт его построения. */
+    awaitField(): void;
+    bindField(field: Element): void;
+    /** Имя называет только строка: `null` нижний слой не перекрывает. */
+    private _sum;
+}
+/** Кто пишет классы и стиль узла: его база или разметка владельца. */
+export type TPaintLayer = 'own' | 'owner';
+/** Память классов, стиля и скрытия узла — по слоям, у самого узла. */
+export declare class TPaint {
+    private readonly _element;
+    static of(element: HTMLElement): TPaint;
+    private readonly _classes;
+    private readonly _styles;
+    private _display;
+    private constructor();
+    classes(layer: TPaintLayer, names: readonly string[]): void;
+    styles(layer: TPaintLayer, styles: TRootStyles): void;
+    hidden(hidden: boolean): void;
+}
+export {};

package/dist/adapter/runtime/paint.js

@@ -0,0 +1,208 @@
+//#region src/adapter/runtime/paint.ts
+var NO_INPUTS = /* @__PURE__ */ new Set();
+var NO_SET = Object.freeze({});
+var NO_ATTRIBUTES = Object.freeze({
+	values: Object.freeze({}),
+	inputs: NO_INPUTS
+});
+var NO_CLASSES = Object.freeze([]);
+/**
+* Стиль из слоёв снизу вверх. Число — строкой, пустая строка и не строки
+* свойства не задают. Слои читаются из состояния по имени, вид не на веру.
+*/
+function stylesOf(...layers) {
+	const styles = /* @__PURE__ */ new Map();
+	for (const layer of layers) {
+		if (typeof layer !== "object" || layer === null) continue;
+		for (const [name, value] of Object.entries(layer)) if (typeof value === "number") styles.set(name, String(value));
+		else if (typeof value === "string" && value !== "") styles.set(name, value);
+	}
+	return styles;
+}
+/** Место элемента в ряду коллекции, как `:style="{ order }"` у Vue. */
+function orderOf(value) {
+	return typeof value === "number" ? { order: value } : void 0;
+}
+function setOf(value) {
+	return typeof value === "object" && value !== null ? value : NO_SET;
+}
+function classesOf(value) {
+	return Array.isArray(value) && value.every((name) => typeof name === "string") ? value : NO_CLASSES;
+}
+function applyAttributes(element, wanted, applied) {
+	const values = {};
+	for (const [name, value] of Object.entries(wanted.values)) {
+		const current = element.getAttribute(name);
+		if (current !== null && current !== valueOf(applied, name) && !wanted.inputs.has(name)) continue;
+		if (current !== value) element.setAttribute(name, value);
+		values[name] = value;
+	}
+	for (const [name, value] of Object.entries(applied.values)) {
+		if (Object.hasOwn(values, name)) continue;
+		if (applied.inputs.has(name) || element.getAttribute(name) === value) element.removeAttribute(name);
+	}
+	return {
+		values,
+		inputs: wanted.inputs
+	};
+}
+function valueOf(attributes, name) {
+	return Object.hasOwn(attributes.values, name) ? attributes.values[name] : void 0;
+}
+function applyClasses(element, classes, applied) {
+	const next = /* @__PURE__ */ new Set();
+	for (const name of classes) {
+		if (element.classList.contains(name) && !applied.has(name)) continue;
+		element.classList.add(name);
+		next.add(name);
+	}
+	for (const name of applied) if (!next.has(name)) element.classList.remove(name);
+	return next;
+}
+function applyStyles(element, styles, applied) {
+	const { style } = element;
+	const next = /* @__PURE__ */ new Map();
+	for (const [name, value] of styles) {
+		const own = applied.get(name);
+		const current = style.getPropertyValue(name);
+		if (current !== "") {
+			if (own === void 0 || current !== own.written) continue;
+			if (own.value === value) {
+				next.set(name, own);
+				continue;
+			}
+		}
+		style.setProperty(name, value);
+		const written = style.getPropertyValue(name);
+		if (written !== "") next.set(name, {
+			value,
+			written
+		});
+	}
+	for (const [name, { written }] of applied) if (!next.has(name) && style.getPropertyValue(name) === written) style.removeProperty(name);
+	return next;
+}
+/** Как `v-show`: `display: none` поверх `display` потребителя, показ возвращает прежнее. */
+function applyHidden(element, hidden, saved) {
+	if (hidden) {
+		if (saved !== void 0) return saved;
+		const display = element.style.display;
+		element.style.display = "none";
+		return display;
+	}
+	if (saved !== void 0 && element.style.display === "none") element.style.display = saved;
+}
+/**
+* Слои атрибутов снизу вверх: наборы ядра компонента, чей это корень; набор
+* разметки владельца (`ownerAttributes`); набор, который владелец положил на
+* деталь с полем, — он уходит на её поле.
+*/
+var ATTRIBUTE_LAYERS = [
+	"attrs",
+	"aria",
+	"dataset",
+	"owner",
+	"detail"
+];
+var LAID_OUT = /* @__PURE__ */ new WeakMap();
+/**
+* Атрибуты узла от всех, кто их пишет, — слоями, одной суммой и одной памятью:
+* две раскладки со своей памятью спорили бы за общее имя.
+*/
+var TElementAttributes = class TElementAttributes {
+	_element;
+	static of(element) {
+		let attributes = LAID_OUT.get(element);
+		if (!attributes) {
+			attributes = new TElementAttributes(element);
+			LAID_OUT.set(element, attributes);
+		}
+		return attributes;
+	}
+	_layers = {};
+	_applied = NO_ATTRIBUTES;
+	/** Раскладчик поля; `null` — поле ещё не построено; `undefined` — поля нет. */
+	_field = void 0;
+	_held = NO_SET;
+	constructor(_element) {
+		this._element = _element;
+	}
+	set(layer, set, inputs = NO_INPUTS) {
+		if (layer === "owner" && this._field !== void 0) {
+			this._held = set;
+			this._field?.set("detail", set);
+			return;
+		}
+		this._layers[layer] = {
+			set,
+			inputs
+		};
+		this._applied = applyAttributes(this._element, this._sum(), this._applied);
+	}
+	/**
+	* Значение атрибута, которое ставит раскладка, — сумма слоёв; `undefined` —
+	* имени она не называет. Слои новые ещё до записи в узел, поэтому колбэк
+	* атрибута, пришедший посреди раскладки, видит уже то, что она пишет.
+	*/
+	wanted(name) {
+		return valueOf(this._sum(), name);
+	}
+	/** У узла есть поле: слой владельца ждёт его построения. */
+	awaitField() {
+		if (this._field === void 0) this._field = null;
+	}
+	bindField(field) {
+		const target = TElementAttributes.of(field);
+		this._field = target;
+		target.set("detail", this._held);
+	}
+	/** Имя называет только строка: `null` нижний слой не перекрывает. */
+	_sum() {
+		const values = {};
+		let inputs;
+		for (const name of ATTRIBUTE_LAYERS) {
+			const layer = this._layers[name];
+			if (!layer) continue;
+			for (const [attribute, value] of Object.entries(layer.set)) {
+				if (typeof value !== "string") continue;
+				values[attribute] = value;
+				if (layer.inputs.has(attribute)) (inputs ??= /* @__PURE__ */ new Set()).add(attribute);
+				else inputs?.delete(attribute);
+			}
+		}
+		return {
+			values,
+			inputs: inputs ?? NO_INPUTS
+		};
+	}
+};
+var PAINTED = /* @__PURE__ */ new WeakMap();
+/** Память классов, стиля и скрытия узла — по слоям, у самого узла. */
+var TPaint = class TPaint {
+	_element;
+	static of(element) {
+		let paint = PAINTED.get(element);
+		if (!paint) {
+			paint = new TPaint(element);
+			PAINTED.set(element, paint);
+		}
+		return paint;
+	}
+	_classes = /* @__PURE__ */ new Map();
+	_styles = /* @__PURE__ */ new Map();
+	_display = void 0;
+	constructor(_element) {
+		this._element = _element;
+	}
+	classes(layer, names) {
+		this._classes.set(layer, applyClasses(this._element, names, this._classes.get(layer) ?? /* @__PURE__ */ new Set()));
+	}
+	styles(layer, styles) {
+		this._styles.set(layer, applyStyles(this._element, styles, this._styles.get(layer) ?? /* @__PURE__ */ new Map()));
+	}
+	hidden(hidden) {
+		this._display = applyHidden(this._element, hidden, this._display);
+	}
+};
+//#endregion
+export { ATTRIBUTE_LAYERS, TElementAttributes, TPaint, applyAttributes, applyClasses, applyHidden, applyStyles, classesOf, orderOf, setOf, stylesOf };

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

@@ -0,0 +1,36 @@
+/**
+ * Пропсы элемента между сборками. Связка новая на каждое подключение, а
+ * пропсы — то, что задал потребитель атрибутом или свойством, в последнем
+ * значении, какое видел элемент: перестановка не откатывает то, что с тех пор
+ * поменяло ядро. Записанное без связки — до подключения, вне DOM или во время
+ * сборки — ложится поверх. AGENTS.md (Web Components), «Пропсы между
+ * сборками».
+ */
+/** Связка, какой её видит хранилище. */
+export type TPropTarget = {
+    readonly state: object;
+    syncProps(props: object): void;
+};
+export declare class TPropStore {
+    /** Последнее значение пропа: от потребителя или из ядра. */
+    private readonly _values;
+    /** Пропы, которые задавал потребитель. */
+    private readonly _given;
+    /** Записанное без связки. При живой связке пусто. */
+    private _offline;
+    /** Снятое без связки до сборки: сборка `undefined` пропускает, снятие идёт следом. */
+    private _unset;
+    isGiven(name: string): boolean;
+    read(name: string, binding: TPropTarget | undefined): unknown;
+    write(name: string, value: unknown, binding: TPropTarget | undefined): void;
+    /** Значение пришло из ядра. */
+    remember(name: string, value: unknown): void;
+    /** Пропсы сборки: заданное потребителем, поверх — записанное без связки, и тег корня. */
+    open(tag: string): Record<string, unknown>;
+    /**
+     * The assembly is over: what was unset before it, then what was written
+     * during it. Its place is this binding, not the next one: otherwise the next
+     * assembly would roll the component back to it.
+     */
+    close(binding: TPropTarget): void;
+}

package/dist/adapter/runtime/props.js

@@ -0,0 +1,58 @@
+//#region src/adapter/runtime/props.ts
+var TPropStore = class {
+	/** Последнее значение пропа: от потребителя или из ядра. */
+	_values = /* @__PURE__ */ new Map();
+	/** Пропы, которые задавал потребитель. */
+	_given = /* @__PURE__ */ new Set();
+	/** Записанное без связки. При живой связке пусто. */
+	_offline = /* @__PURE__ */ new Map();
+	/** Снятое без связки до сборки: сборка `undefined` пропускает, снятие идёт следом. */
+	_unset = /* @__PURE__ */ new Map();
+	isGiven(name) {
+		return this._given.has(name);
+	}
+	read(name, binding) {
+		if (this._offline.has(name)) return this._offline.get(name);
+		if (binding && Object.hasOwn(binding.state, name)) return Reflect.get(binding.state, name);
+		return this._values.get(name);
+	}
+	write(name, value, binding) {
+		this._given.add(name);
+		if (!binding) {
+			this._offline.set(name, value);
+			return;
+		}
+		if (!Object.hasOwn(binding.state, name)) this._values.set(name, value);
+		binding.syncProps({ [name]: value });
+	}
+	/** Значение пришло из ядра. */
+	remember(name, value) {
+		this._values.set(name, value);
+	}
+	/** Пропсы сборки: заданное потребителем, поверх — записанное без связки, и тег корня. */
+	open(tag) {
+		const offline = this._offline;
+		const props = {};
+		for (const name of this._given) props[name] = this._values.get(name);
+		for (const [name, value] of offline) if (value !== void 0) props[name] = value;
+		props["tag"] = tag;
+		for (const [name, value] of offline) this._values.set(name, value);
+		this._offline = /* @__PURE__ */ new Map();
+		this._unset = new Map([...offline].filter(([, value]) => value === void 0));
+		return props;
+	}
+	/**
+	* The assembly is over: what was unset before it, then what was written
+	* during it. Its place is this binding, not the next one: otherwise the next
+	* assembly would roll the component back to it.
+	*/
+	close(binding) {
+		const late = this._unset;
+		for (const [name, value] of this._offline) late.set(name, value);
+		this._offline = /* @__PURE__ */ new Map();
+		this._unset = /* @__PURE__ */ new Map();
+		for (const [name, value] of late) this.write(name, value, binding);
+	}
+};
+//#endregion
+export { TPropStore };

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

@@ -0,0 +1,16 @@
+/**
+ * Перенос силами базы — не отключение. Телепорт и раскладка света переносят
+ * узлы, не выводя из документа, и колбэки, которые это вызвало, связку не
+ * трогают. Признак держится до микрозадачи после переноса: с полифилом
+ * колбэки приходят позже. AGENTS.md (Web Components), «Перенос силами базы».
+ */
+/** `move` — операции DOM, после которых узлы остаются в документе. */
+export declare function relocate(nodes: readonly Node[], move: () => void): void;
+/** Перенос, чьи колбэки — настоящие, какой бы перенос базы ни держался над узлами. */
+export declare function rebuild(nodes: readonly Node[], move: () => void): void;
+/** Узел снова в документе, и последний перенос на пути вверх — силами базы. */
+export declare function isRelocating(node: Node): boolean;
+/** Элементы, которые переставила операция потребителя: их отключение — настоящее. */
+export declare function owe(elements: Iterable<Element>): void;
+/** Решает колбэк отключения, один раз на отключение: долг гасится. */
+export declare function keepsBinding(element: Element): boolean;

package/dist/adapter/runtime/relocation.js

@@ -0,0 +1,58 @@
+//#region src/adapter/runtime/relocation.ts
+/** Набор, а не флаг: узел могли перенести снова, пока держится прошлый признак. */
+var moving = /* @__PURE__ */ new Map();
+var last = 0;
+/** Элементы с долгом: следующее отключение — настоящее. */
+var owing = /* @__PURE__ */ new WeakSet();
+function above(node) {
+	const parent = node.parentNode;
+	return parent instanceof ShadowRoot ? parent.host : parent;
+}
+function transfer(nodes, rebuilds, move) {
+	const current = {
+		order: ++last,
+		rebuilds
+	};
+	for (const node of nodes) {
+		const transfers = moving.get(node) ?? /* @__PURE__ */ new Set();
+		transfers.add(current);
+		moving.set(node, transfers);
+	}
+	try {
+		move();
+	} finally {
+		queueMicrotask(() => {
+			for (const node of nodes) {
+				const transfers = moving.get(node);
+				transfers?.delete(current);
+				if (transfers?.size === 0) moving.delete(node);
+			}
+		});
+	}
+}
+/** `move` — операции DOM, после которых узлы остаются в документе. */
+function relocate(nodes, move) {
+	transfer(nodes, false, move);
+}
+/** Перенос, чьи колбэки — настоящие, какой бы перенос базы ни держался над узлами. */
+function rebuild(nodes, move) {
+	transfer(nodes, true, move);
+}
+/** Узел снова в документе, и последний перенос на пути вверх — силами базы. */
+function isRelocating(node) {
+	if (moving.size === 0 || !node.isConnected) return false;
+	let latest;
+	for (let each = node; each !== null; each = above(each)) for (const transfer of moving.get(each) ?? []) if (latest === void 0 || transfer.order > latest.order) latest = transfer;
+	return latest !== void 0 && !latest.rebuilds;
+}
+/** Элементы, которые переставила операция потребителя: их отключение — настоящее. */
+function owe(elements) {
+	for (const element of elements) owing.add(element);
+}
+/** Решает колбэк отключения, один раз на отключение: долг гасится. */
+function keepsBinding(element) {
+	if (owing.delete(element)) return false;
+	return isRelocating(element);
+}
+//#endregion
+export { isRelocating, keepsBinding, owe, rebuild, relocate };