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

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

@@ -0,0 +1,20 @@
+/**
+ * Корень компонента по `tag` — то, что делал `Dynamic`, без его прокси и
+ * лишних вычислений: тег — одно мемо, атрибуты — один эффект `assign`, `ref`
+ * зовётся под мемо, а не своим эффектом. На сервере и для компонента в `tag`
+ * — `createDynamic`, без вызова компонента над ним: ключи гидратации у
+ * сервера и браузера те же, что были у `Dynamic`. AGENTS.md (Solid), «Корень и
+ * узлы частей».
+ */
+import { type Accessor, type JSX } from 'solid-js';
+import type { TRootProps } from '../common/root';
+export type TRootComponentProps = {
+    /** `tag` ядра: строка или компонент Solid, иначе корня нет. */
+    tag: unknown;
+    /** Атрибуты корня — мемо раскладки (`createRootProps`). */
+    attributes: Accessor<TRootProps>;
+    /** `ref` адаптера: привязка к `TElementPlugin` и `ref` потребителя. */
+    ref: (element: Element) => void;
+    children?: JSX.Element;
+};
+export declare function Root(props: TRootComponentProps): JSX.Element;

package/dist/adapter/runtime/Root.js

@@ -0,0 +1,43 @@
+import { rootTag } from "./tag.js";
+import { createMemo, createRenderEffect, mergeProps, untrack } from "solid-js";
+import { SVGElements, assign, createDynamic, getNextElement, insert, isServer, use } from "solid-js/web";
+//#region src/adapter/runtime/Root.tsx
+/**
+* Корень компонента по `tag` — то, что делал `Dynamic`, без его прокси и
+* лишних вычислений: тег — одно мемо, атрибуты — один эффект `assign`, `ref`
+* зовётся под мемо, а не своим эффектом. На сервере и для компонента в `tag`
+* — `createDynamic`, без вызова компонента над ним: ключи гидратации у
+* сервера и браузера те же, что были у `Dynamic`. AGENTS.md (Solid), «Корень и
+* узлы частей».
+*/
+var SVG = "http://www.w3.org/2000/svg";
+/** Корень через `createDynamic`: атрибуты, `ref` и содержимое — одними пропсами. */
+function dynamicRoot(tag, props) {
+	return createDynamic(tag, mergeProps(props.attributes, {
+		ref: props.ref,
+		get children() {
+			return props.children;
+		}
+	}));
+}
+/** Узел тега: в окне гидратации — узел сервера, иначе — новый. */
+function nodeOf(tag, is) {
+	return getNextElement(() => SVGElements.has(tag) ? document.createElementNS(SVG, tag) : document.createElement(tag, typeof is === "string" ? { is } : void 0));
+}
+function Root(props) {
+	if (isServer) return dynamicRoot(() => rootTag(props.tag), props);
+	return createMemo(() => {
+		const tag = rootTag(props.tag);
+		if (tag === void 0) return void 0;
+		if (typeof tag === "function") return untrack(() => dynamicRoot(() => tag, props));
+		const node = nodeOf(tag, untrack(() => props.attributes().is));
+		const svg = SVGElements.has(tag);
+		const assigned = {};
+		insert(node, () => props.children);
+		use(props.ref, node);
+		createRenderEffect(() => assign(node, props.attributes(), svg, true, assigned, true));
+		return node;
+	});
+}
+//#endregion
+export { Root };

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

@@ -0,0 +1,14 @@
+/**
+ * Teleport — аналог `<teleport :to>` Vue поверх `Portal`: цели нет — нет и
+ * содержимого, `disabled` рисует на месте. Смена цели или `disabled` переносит
+ * те же узлы. AGENTS.md (Solid), «Teleport».
+ */
+import { type JSX } from 'solid-js';
+export type TTeleportProps = {
+    /** Селектор цели: `body`, `#layers`. */
+    to: string | undefined;
+    /** Рисовать на месте, без портала. */
+    disabled?: boolean;
+    children?: JSX.Element;
+};
+export declare function Teleport(props: TTeleportProps): JSX.Element;

package/dist/adapter/runtime/Teleport.js

@@ -0,0 +1,45 @@
+import { Show, children, getOwner, runWithOwner } from "solid-js";
+import { Portal, createComponent, isServer } from "solid-js/web";
+//#region src/adapter/runtime/Teleport.tsx
+/**
+* Teleport — аналог `<teleport :to>` Vue поверх `Portal`: цели нет — нет и
+* содержимого, `disabled` рисует на месте. Смена цели или `disabled` переносит
+* те же узлы. AGENTS.md (Solid), «Teleport».
+*/
+function targetOf(selector) {
+	if (isServer || !selector) return null;
+	return document.querySelector(selector);
+}
+function Teleport(props) {
+	const owner = getOwner();
+	let resolved;
+	const content = () => {
+		resolved ??= runWithOwner(owner, () => children(() => props.children));
+		return resolved?.();
+	};
+	return createComponent(Show, {
+		get when() {
+			return !props.disabled;
+		},
+		get fallback() {
+			return content();
+		},
+		get children() {
+			return createComponent(Show, {
+				get when() {
+					return targetOf(props.to);
+				},
+				children: (target) => createComponent(Portal, {
+					get mount() {
+						return target();
+					},
+					get children() {
+						return content();
+					}
+				})
+			});
+		}
+	});
+}
+//#endregion
+export { Teleport };

package/dist/adapter/runtime/field-text.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Текст поля на узле — только когда он разошёлся с узлом, как `:value` у Vue.
+ * Привязку `value` Solid пишет на каждую смену, и запись узлу его же текста
+ * снимала бы с поля пометку «изменено пользователем» (`minlength` перестаёт
+ * проверяться). Атрибуты ложатся на поле последними.
+ * AGENTS.md (Solid), «Текст поля».
+ */
+/** Атрибуты `<input>`: в браузере `ref` поля, на сервере — `value`. */
+export type TFieldText = {
+    readonly ref: (node: HTMLInputElement) => void;
+} | {
+    readonly value: string | undefined;
+};
+/** Атрибуты `<textarea>`: в браузере `ref` поля, на сервере — `textContent`. */
+export type TTextareaText = {
+    readonly ref: (node: HTMLTextAreaElement) => void;
+} | {
+    readonly textContent: string | undefined;
+};
+export declare function fieldText(getText: () => string | undefined): TFieldText;
+/** У `<textarea>` атрибута `value` нет: на сервере текст — её содержимое. */
+export declare function textareaText(getText: () => string | undefined): TTextareaText;

package/dist/adapter/runtime/field-text.js

@@ -0,0 +1,38 @@
+import { createEffect } from "solid-js";
+import { isServer } from "solid-js/web";
+//#region src/adapter/runtime/field-text.ts
+/**
+* Текст поля на узле — только когда он разошёлся с узлом, как `:value` у Vue.
+* Привязку `value` Solid пишет на каждую смену, и запись узлу его же текста
+* снимала бы с поля пометку «изменено пользователем» (`minlength` перестаёт
+* проверяться). Атрибуты ложатся на поле последними.
+* AGENTS.md (Solid), «Текст поля».
+*/
+/**
+* `ref` поля, который ведёт его текст. Эффект — пользовательский: Solid
+* выполняет его после атрибутов узла, а `range` прижимает значение к `min` и
+* `max`.
+*/
+function textRef(getText) {
+	return (node) => {
+		createEffect(() => {
+			const text = getText() ?? "";
+			if (node.value !== text) node.value = text;
+		});
+	};
+}
+function fieldText(getText) {
+	if (isServer) return { get value() {
+		return getText();
+	} };
+	return { ref: textRef(getText) };
+}
+/** У `<textarea>` атрибута `value` нет: на сервере текст — её содержимое. */
+function textareaText(getText) {
+	if (isServer) return { get textContent() {
+		return getText();
+	} };
+	return { ref: textRef(getText) };
+}
+//#endregion
+export { fieldText, textareaText };

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

@@ -0,0 +1,34 @@
+/**
+ * `Show`, `For` и `Index` — как у Solid 1.9, но переживают окна гидратации:
+ * пересчёт в окне до конца окна отдаёт прежнюю структуру. На сервере — сами
+ * примитивы Solid. В бочку адаптера модуль не входит: имена столкнулись бы с
+ * `solid-js`. AGENTS.md (Solid), «Ветки и петли».
+ */
+import { type Accessor, type JSX } from 'solid-js';
+/** Функция-ребёнок с параметром, а не без него — как у Solid (`flow.d.ts`). */
+type RequiredParameter<T> = T extends () => unknown ? never : T;
+export declare function Show<T, TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    fallback?: JSX.Element;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
+}): JSX.Element;
+export declare function Show<T, TRenderFunction extends (item: NonNullable<T>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: JSX.Element;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
+}): JSX.Element;
+/** Петля по записям: запись с той же ссылкой — та же строка. */
+export declare function For<T extends readonly unknown[], U extends JSX.Element>(props: {
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    children: (item: T[number], index: Accessor<number>) => U;
+}): JSX.Element;
+/** Петля по местам: запись на месте сменилась — строка та же. */
+export declare function Index<T extends readonly unknown[], U extends JSX.Element>(props: {
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    children: (item: Accessor<T[number]>, index: number) => U;
+}): JSX.Element;
+export {};

package/dist/adapter/runtime/flow.js

@@ -0,0 +1,70 @@
+import { createHeldMemo } from "../common/hydration.js";
+import { $TRACK, For, Index, Show, createMemo, indexArray, mapArray, untrack } from "solid-js";
+import { isServer } from "solid-js/web";
+//#region src/adapter/runtime/flow.ts
+/**
+* `Show`, `For` и `Index` — как у Solid 1.9, но переживают окна гидратации:
+* пересчёт в окне до конца окна отдаёт прежнюю структуру. На сервере — сами
+* примитивы Solid. В бочку адаптера модуль не входит: имена столкнулись бы с
+* `solid-js`. AGENTS.md (Solid), «Ветки и петли».
+*/
+/** Без `keyed` ветка сменяется только с истинностью условия. */
+var SAME_TRUTHINESS = { equals: (a, b) => !a === !b };
+var NO_ITEMS = [];
+/** Функция-ребёнок — с параметром: ленивое мемо компилятора параметров не имеет. */
+function isRenderFunction(child) {
+	return typeof child === "function" && child.length > 0;
+}
+function conditionOf(props) {
+	return props.when;
+}
+function Show$1(props) {
+	if (isServer) return props.keyed ? Show(props) : Show(props);
+	const value = createHeldMemo(props, conditionOf);
+	return props.keyed ? keyedBranch(props, value) : unkeyedBranch(props, value);
+}
+/** `keyed`: на каждое новое значение условия — функция-ребёнок заново. */
+function keyedBranch(props, value) {
+	return createMemo(() => {
+		const current = value();
+		if (!current) return props.fallback;
+		const child = props.children;
+		return isRenderFunction(child) ? untrack(() => child(current)) : child;
+	});
+}
+/** Без `keyed`: значение функция-ребёнок читает аксессором. */
+function unkeyedBranch(props, value) {
+	const condition = createMemo(value, void 0, SAME_TRUTHINESS);
+	return createMemo(() => {
+		if (!condition()) return props.fallback;
+		const child = props.children;
+		return isRenderFunction(child) ? untrack(() => child(() => present(value))) : child;
+	});
+}
+/** Аксессор снятой ветки значения уже не найдёт — ошибка, как у Solid. */
+function present(value) {
+	const current = value();
+	if (!current) throw new Error("<Show>: значение прочитано у снятой ветки — условие уже ложно");
+	return current;
+}
+function For$1(props) {
+	if (isServer) return For(props);
+	return createLoopMemo(props, mapArray(() => props.each, props.children, fallbackOf(props)));
+}
+function Index$1(props) {
+	if (isServer) return Index(props);
+	return createLoopMemo(props, indexArray(() => props.each, props.children, fallbackOf(props)));
+}
+/** `fallback` петли — как у Solid: только когда проп задан. */
+function fallbackOf(props) {
+	return "fallback" in props ? { fallback: () => props.fallback } : void 0;
+}
+/**
+* Мемо отображения петли (`mapArray`, `indexArray`): в окне оно читает список
+* и элементы стора (`$TRACK`), но строк не строит.
+*/
+function createLoopMemo(props, map) {
+	return createHeldMemo(map, (live) => live(), () => Reflect.get(props.each || NO_ITEMS, $TRACK));
+}
+//#endregion
+export { For$1 as For, Index$1 as Index, Show$1 as Show };

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

@@ -0,0 +1,8 @@
+export { useAdapter, useCollectionAdapter, joinBindings, type TBinding, type TCollectionBinding, type TConsumerRef, type TJoinedBinding, } from './useAdapter';
+export { createShallowState, joinState, type TJoinedState } from './state';
+export { KeyedFor, type TKeyedForProps } from './KeyedFor';
+export { createPartNode, createPartNodes, type TPartNodeAttributes, type TPartNodesSource, } from './part-node';
+export { Root, type TRootComponentProps } from './Root';
+export { Teleport, type TTeleportProps } from './Teleport';
+export { isTagComponent, rootTag, type TTagComponent } from './tag';
+export { fieldText, textareaText, type TFieldText, type TTextareaText } from './field-text';

package/dist/adapter/runtime/part-node.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Узлы частей без экземпляра, которых тысячи, — ячейки таблицы, поле флажка в
+ * каждой её строке. Без спреда: спред на узле давал прокси `mergeProps`,
+ * эффект `ref` и эффект атрибутов. На сервере — `createDynamic`, в
+ * гидратации — узлы сервера. AGENTS.md (Solid), «Корень и узлы частей».
+ *
+ * - `createPartNode` — узел: атрибуты — один эффект, содержимое — вставкой;
+ * - `createPartNodes` — узлы записей списка с текстом: одно мемо на весь
+ *   список, без вычислений на узел.
+ */
+import { type JSX } from 'solid-js';
+/** Атрибуты узла: класс, наборы ядра — всё одним объектом. */
+export type TPartNodeAttributes = Readonly<Record<string, unknown>>;
+/**
+ * Узел `tag` с атрибутами `read` и содержимым `children` (без него — пустой,
+ * как `input`). Зовётся там, где узел рисуется, — в теле или в функции петли:
+ * эффекты узла уходят с его владельцем. Атрибуты в окне гидратации держит
+ * `createPartProps`, как набор части.
+ */
+export declare function createPartNode(tag: string, read: () => TPartNodeAttributes, children?: () => JSX.Element): JSX.Element;
+/** Узлы записей списка: узел на ключ, тег, атрибуты и текст — от записи. */
+export type TPartNodesSource<TEntry, TKey> = {
+    readonly each: () => readonly TEntry[] | undefined;
+    /** Ключ записи: у записей одного узла он один и тот же. */
+    readonly by: (entry: TEntry) => TKey;
+    /** Тег узла — читается, когда узел создаётся: сменился — сменился и ключ. */
+    readonly tag: (entry: TEntry) => string;
+    readonly attributes: (entry: TEntry) => TPartNodeAttributes;
+    readonly text: (entry: TEntry) => string;
+};
+/**
+ * Узлы записей списка с текстом — одно мемо на список: узел живёт, пока в
+ * списке есть запись с его ключом, а проход по записям пишет каждому узлу
+ * атрибуты и текст — разницу с записанным. Корня, сигнала и эффекта на узел,
+ * как у `KeyedFor`, нет. Узлы на место ставит вставка родителя. Окна
+ * гидратации мемо переживает, как петли адаптера (`createHeldMemo`).
+ */
+export declare function createPartNodes<TEntry, TKey>(source: TPartNodesSource<TEntry, TKey>): JSX.Element;

package/dist/adapter/runtime/part-node.js

@@ -0,0 +1,76 @@
+import { createHeldMemo } from "../common/hydration.js";
+import { createPartProps } from "../common/root.js";
+import { createRenderEffect } from "solid-js";
+import { assign, createDynamic, getNextElement, insert, isServer } from "solid-js/web";
+//#region src/adapter/runtime/part-node.ts
+/**
+* Узлы частей без экземпляра, которых тысячи, — ячейки таблицы, поле флажка в
+* каждой её строке. Без спреда: спред на узле давал прокси `mergeProps`,
+* эффект `ref` и эффект атрибутов. На сервере — `createDynamic`, в
+* гидратации — узлы сервера. AGENTS.md (Solid), «Корень и узлы частей».
+*
+* - `createPartNode` — узел: атрибуты — один эффект, содержимое — вставкой;
+* - `createPartNodes` — узлы записей списка с текстом: одно мемо на весь
+*   список, без вычислений на узел.
+*/
+/** Создатель узла на тег — один на модуль: узлов тысячи, тегов два. */
+var creators = /* @__PURE__ */ new Map();
+function creatorOf(tag) {
+	let creator = creators.get(tag);
+	if (!creator) creators.set(tag, creator = () => document.createElement(tag));
+	return creator;
+}
+/** Узел на сервере: содержимое — геттером, после метки гидратации узла, как у разметки. */
+function serverNode(tag, attributes, children) {
+	return createDynamic(() => tag, {
+		...attributes,
+		get children() {
+			return children();
+		}
+	});
+}
+/**
+* Узел `tag` с атрибутами `read` и содержимым `children` (без него — пустой,
+* как `input`). Зовётся там, где узел рисуется, — в теле или в функции петли:
+* эффекты узла уходят с его владельцем. Атрибуты в окне гидратации держит
+* `createPartProps`, как набор части.
+*/
+function createPartNode(tag, read, children) {
+	if (isServer) return serverNode(tag, read(), () => children?.());
+	const node = getNextElement(creatorOf(tag));
+	const attributes = createPartProps(read);
+	const assigned = {};
+	createRenderEffect(() => assign(node, attributes(), false, true, assigned, true));
+	if (children) insert(node, children);
+	return node;
+}
+function createPartNodes(source) {
+	if (isServer) return source.each()?.map((entry) => serverNode(source.tag(entry), source.attributes(entry), () => source.text(entry)));
+	const records = /* @__PURE__ */ new Map();
+	let shown = [];
+	const draw = (entries) => {
+		const seen = /* @__PURE__ */ new Set();
+		const nodes = entries.map((entry) => {
+			const key = source.by(entry);
+			let record = records.get(key);
+			if (!record) {
+				const node = getNextElement(creatorOf(source.tag(entry)));
+				records.set(key, record = {
+					node,
+					assigned: {},
+					text: void 0
+				});
+			}
+			assign(record.node, source.attributes(entry), false, true, record.assigned, true);
+			record.text = insert(record.node, source.text(entry), void 0, record.text);
+			seen.add(key);
+			return record.node;
+		});
+		for (const key of records.keys()) if (!seen.has(key)) records.delete(key);
+		if (nodes.length !== shown.length || nodes.some((node, index) => node !== shown[index])) shown = nodes;
+		return shown;
+	};
+	return createHeldMemo(source, (current) => draw(current.each() ?? []), (current) => current.each());
+}
+//#endregion
+export { createPartNode, createPartNodes };

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

@@ -0,0 +1,43 @@
+/**
+ * The binding's state and the view of two states. AGENTS.md (Solid), «Связка».
+ *
+ * - The state is a signal per property, and a value is handed over as it is:
+ *   the core hands out values, and a changed one comes as a new object
+ *   (AGENTS.md, «Контракт границы core → ui»). Solid's store wrapped every
+ *   nested object — a row's cells, their `aria` and `dataset` — in a proxy
+ *   with a signal per read property that never changes. Like `shallowRef` in
+ *   Vue.
+ * - A signal is made by the first read of a property: the markup reads less
+ *   than half of the binding's properties, and the subscription hands over the
+ *   value of each.
+ * - Writes of an update of the exchange are applied at its end, in one
+ *   `batch` (`IUpdateListener`): Solid renders on a signal write, and a write
+ *   applied in the middle of the update rendered before the update's event
+ *   reached the consumer — the panel opened by `change:open` mounted, and its
+ *   items joined the menu first. A read in the middle of the update sees the
+ *   written value already: only the signal's notification waits.
+ * - The view of two contexts is a proxy that reads a property from the state
+ *   on every read: a spread would read it once, in the component's body, and
+ *   getters by keys would lose the properties not set by the assembly. The
+ *   component and the facade have no properties of the same name — the
+ *   facade's names are prefixed.
+ */
+import type { IUpdateListener } from '@soxa-ui/setup';
+/**
+ * A property with the value `undefined` is unset: `in` does not see it. The
+ * listener of the exchange's updates holds the writes of an update back to
+ * its end.
+ */
+export declare function createShallowState(): [
+    state: Readonly<Record<string, unknown>>,
+    write: (name: string, value: unknown) => void,
+    updates: IUpdateListener
+];
+/** Одноимённое свойство берётся из верхнего состояния. */
+export type TJoinedState<TBelow extends object, TAbove extends object> = Omit<TBelow, keyof TAbove> & TAbove;
+/**
+ * Свойство, которого у верхнего состояния связки нет вовсе, читается снизу и
+ * сигнала наверху не заводит: фасад строки таблицы не держит сигналов под
+ * свойства компонента.
+ */
+export declare function joinState<TBelow extends object, TAbove extends object>(below: TBelow, above: TAbove): TJoinedState<TBelow, TAbove>;

package/dist/adapter/runtime/state.js

@@ -0,0 +1,116 @@
+import { batch, createSignal } from "solid-js";
+//#region src/adapter/runtime/state.ts
+/**
+* The binding's state and the view of two states. AGENTS.md (Solid), «Связка».
+*
+* - The state is a signal per property, and a value is handed over as it is:
+*   the core hands out values, and a changed one comes as a new object
+*   (AGENTS.md, «Контракт границы core → ui»). Solid's store wrapped every
+*   nested object — a row's cells, their `aria` and `dataset` — in a proxy
+*   with a signal per read property that never changes. Like `shallowRef` in
+*   Vue.
+* - A signal is made by the first read of a property: the markup reads less
+*   than half of the binding's properties, and the subscription hands over the
+*   value of each.
+* - Writes of an update of the exchange are applied at its end, in one
+*   `batch` (`IUpdateListener`): Solid renders on a signal write, and a write
+*   applied in the middle of the update rendered before the update's event
+*   reached the consumer — the panel opened by `change:open` mounted, and its
+*   items joined the menu first. A read in the middle of the update sees the
+*   written value already: only the signal's notification waits.
+* - The view of two contexts is a proxy that reads a property from the state
+*   on every read: a spread would read it once, in the component's body, and
+*   getters by keys would lose the properties not set by the assembly. The
+*   component and the facade have no properties of the same name — the
+*   facade's names are prefixed.
+*/
+/** Значения и сигналы свойств — за прокси состояния. */
+var TShallowState = class {
+	/** Записанные, но ещё не прочитанные — без сигнала. */
+	_values = /* @__PURE__ */ new Map();
+	/** Прочитанные записанные. */
+	_signals = /* @__PURE__ */ new Map();
+	/** Прочитанные до записи: подписка связки отдаёт каждое свойство сразу, и здесь — чужие. */
+	_unwritten = /* @__PURE__ */ new Map();
+	/** Writes of the update in progress — applied at its end. */
+	_pending;
+	/** Updates of the exchange in progress: a sink's write to a participant nests one. */
+	_depth = 0;
+	/** The property was written: for the binding, one of its properties, from the subscription. */
+	written(key) {
+		return this._values.has(key) || this._signals.has(key) || this._pending?.has(key) === true;
+	}
+	read(key) {
+		const value = this._signalOf(key)[0]();
+		const pending = this._pending;
+		return pending?.has(key) ? pending.get(key) : value;
+	}
+	write(name, value) {
+		if (this._depth > 0) (this._pending ??= /* @__PURE__ */ new Map()).set(name, value);
+		else this._apply(name, value);
+	}
+	begin() {
+		this._depth++;
+	}
+	/** The outermost update ended: its writes go to the signals, and Solid renders once. */
+	end() {
+		if (this._depth === 0 || --this._depth > 0) return;
+		const pending = this._pending;
+		if (pending === void 0) return;
+		this._pending = void 0;
+		batch(() => pending.forEach((value, name) => this._apply(name, value)));
+	}
+	_apply(name, value) {
+		const signal = this._signals.get(name) ?? this._adopt(name);
+		if (signal) signal[1](() => value);
+		else this._values.set(name, value);
+	}
+	_signalOf(key) {
+		const signal = this._signals.get(key) ?? this._unwritten.get(key);
+		if (signal) return signal;
+		const values = this._values;
+		const created = createSignal(values.get(key), { internal: true });
+		if (values.delete(key)) this._signals.set(key, created);
+		else this._unwritten.set(key, created);
+		return created;
+	}
+	/** Свойство, прочитанное до записи, записано: его сигнал — к записанным. */
+	_adopt(name) {
+		const signal = this._unwritten.get(name);
+		if (!signal) return void 0;
+		this._unwritten.delete(name);
+		this._signals.set(name, signal);
+		return signal;
+	}
+};
+/** Состояния связок по их прокси — виду двух состояний. */
+var shallowStates = /* @__PURE__ */ new WeakMap();
+/**
+* A property with the value `undefined` is unset: `in` does not see it. The
+* listener of the exchange's updates holds the writes of an update back to
+* its end.
+*/
+function createShallowState() {
+	const values = new TShallowState();
+	const state = new Proxy({}, {
+		get: (_target, key) => values.read(key),
+		has: (_target, key) => values.read(key) !== void 0
+	});
+	shallowStates.set(state, values);
+	return [
+		state,
+		(name, value) => values.write(name, value),
+		values
+	];
+}
+/**
+* Свойство, которого у верхнего состояния связки нет вовсе, читается снизу и
+* сигнала наверху не заводит: фасад строки таблицы не держит сигналов под
+* свойства компонента.
+*/
+function joinState(below, above) {
+	const lines = shallowStates.get(above);
+	return new Proxy({}, { get: (_target, key) => (!lines || lines.written(key)) && Reflect.has(above, key) ? Reflect.get(above, key) : Reflect.get(below, key) });
+}
+//#endregion
+export { createShallowState, joinState };

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

@@ -0,0 +1,11 @@
+import type { Component, JSX } from 'solid-js';
+import type { TRootProps } from '../common/root';
+/** Компонент в `tag`: атрибуты корня и `ref` адаптера он кладёт на свой корень. */
+export type TTagComponent = Component<TRootProps & {
+    ref: (element: Element) => void;
+    children?: JSX.Element;
+}>;
+/** Компонент Solid — функция; других функций в `tag` ядро не ждёт. */
+export declare function isTagComponent(tag: unknown): tag is TTagComponent;
+/** Корень по `tag` для `Root`: строка или компонент Solid, иначе корня нет. */
+export declare function rootTag(tag: unknown): string | TTagComponent | undefined;

package/dist/adapter/runtime/tag.js

@@ -0,0 +1,11 @@
+//#region src/adapter/runtime/tag.ts
+/** Компонент Solid — функция; других функций в `tag` ядро не ждёт. */
+function isTagComponent(tag) {
+	return typeof tag === "function";
+}
+/** Корень по `tag` для `Root`: строка или компонент Solid, иначе корня нет. */
+function rootTag(tag) {
+	if (typeof tag === "string" || isTagComponent(tag)) return tag;
+}
+//#endregion
+export { isTagComponent, rootTag };