@reformer/core 11.0.0-beta.7 → 11.0.0-beta.8

package/dist/form/behaviors/schema-operators.d.ts

@@ -0,0 +1,76 @@
+import { SchemaNodeControl, SchemaScope } from '../schema-controller';
+/**
+ * Скрывать узел, пока условие истинно.
+ *
+ * Условие реактивно: пересчитывается при изменении любого сигнала, прочитанного внутри него.
+ * Принудительное `schema.node(selector).setHidden(...)` главнее условия.
+ *
+ * @example
+ * ```typescript
+ * hideWhen(schema.node('mortgage'), () => model.loanType !== 'mortgage');
+ * ```
+ */
+export declare function hideWhen(node: SchemaNodeControl, condition: () => boolean): void;
+/**
+ * Повесить обработчик на проп-событие компонента узла (`onSubmit`, `onChange`, …).
+ *
+ * Обработчик получает те же аргументы, что и исходный проп компонента, и перекрывает одноимённый
+ * проп из `componentProps`.
+ *
+ * @example
+ * ```typescript
+ * onComponentEvent(schema.node('wizard'), 'onSubmit', async () => {
+ *   await submitApplication(model.get());
+ * });
+ * ```
+ */
+export declare function onComponentEvent(node: SchemaNodeControl, event: string, handler: (...args: any[]) => any): void;
+/**
+ * Реактивный эффект, живущий, пока схема области смонтирована рендерером.
+ *
+ * В отличие от `effect` поведения, запускается после монтирования — внутри доступны ref узлов
+ * (`schema.node(selector).getRef().current`). Может вернуть функцию очистки.
+ *
+ * @example
+ * ```typescript
+ * const wizard = schema.node('wizard').getRef<FormWizardHandle>();
+ * renderEffect(schema, () => {
+ *   if (model.loanType === 'mortgage') wizard.current?.goToStep(1);
+ * });
+ * ```
+ */
+export declare function renderEffect(schema: SchemaScope, effectFn: () => void | (() => void)): void;
+/**
+ * Синхронный хук времени сборки: `fn` вызывается сразу, до первого рендера узла. Единственный
+ * хук, способный повлиять на первый рендер, — внутри можно править пропсы через
+ * `schema.node(selector).patchProps({ … })`.
+ *
+ * К монтированию узла не привязан; аргумент `node` принимается ради симметрии с
+ * {@link onMount} / {@link onUnmount}.
+ *
+ * @example
+ * ```typescript
+ * onInit(schema.node('summary'), () => {
+ *   schema.node('summary').patchProps({ currency: detectCurrency() });
+ * });
+ * ```
+ */
+export declare function onInit(_node: SchemaNodeControl, fn: () => void): void;
+/**
+ * Хук после первого монтирования узла. Может вернуть очистку — она выполнится при размонтировании.
+ *
+ * @example
+ * ```typescript
+ * onMount(schema.node('data-boundary'), () => void loadApplication());
+ * ```
+ */
+export declare function onMount(node: SchemaNodeControl, fn: () => void | (() => void)): void;
+/**
+ * Хук перед размонтированием узла.
+ *
+ * @example
+ * ```typescript
+ * onUnmount(schema.node('wizard'), () => saveDraft(model.get()));
+ * ```
+ */
+export declare function onUnmount(node: SchemaNodeControl, fn: () => void): void;

package/dist/form/behaviors/types.d.ts

@@ -1,14 +1,26 @@
 import { Signal, ReadonlySignal } from '@preact/signals-core';
 import { BehaviorCleanup, FormModel, FormProxy } from '../../index';
-/** Контекст схемы поведения: модель (значения/сигналы) + форма (ноды). */
+import { SchemaController, SchemaScope } from '../schema-controller';
+/**
+ * Область схемы поведения: модель (значения и сигналы), форма (ноды) и схема (узлы разметки).
+ *
+ * `schema` адресует узлы СВОЕЙ области: в корневом поведении — корневое дерево, в поведении
+ * подформы (`apply`) и строки массива (`applyEach`) — поддерево этой части. Правила узлов
+ * (`hideWhen`, `onComponentEvent`, `onMount`) исполняет рендерер; без него они ничего не делают.
+ */
 export type BehaviorScope<T> = {
     model: FormModel<T>;
     form: FormProxy<T>;
+    schema: SchemaScope;
 };
 /** Результат {@link defineFormBehavior}; передаётся в `createForm({ behavior })`. */
 export interface FormBehavior<T> {
-    /** @internal Запускается `createForm` после построения нод и заполнения реестра сигнал→нода. */
-    __run(model: FormModel<T>, form: FormProxy<T>): BehaviorCleanup;
+    /**
+     * @internal Запускается сборкой формы после построения нод и заполнения реестра сигнал→нода.
+     * `controller` — схема-контроллер сборки; без него поведение получает собственный, который
+     * никто не читает (модель без рендерера).
+     */
+    __run(model: FormModel<T>, form: FormProxy<T>, controller?: SchemaController): BehaviorCleanup;
 }
 export type { Signal, ReadonlySignal, BehaviorCleanup };
 /** Контекст async-реакции: `signal` аннулируется, когда поле меняется снова до завершения колбэка. */

package/dist/form/create-core-form.d.ts

@@ -27,7 +27,7 @@ export interface CreateFormConfigBase<T, B> {
     seed?: (model: FormModel<T>) => void;
     /**
      * Донастройка ПОСЛЕ сборки. Единственное место для правок, которые обязаны идти следом за
-     * `createForm`: поле, чьё значение уже массив, ноды не получает (см. `buildModelConfig`),
+     * сборкой формы: поле, чьё значение уже массив, ноды не получает (см. `buildModelConfig`),
      * поэтому такой префилл выполняется здесь.
      */
     setup?: (bundle: B) => void;
@@ -41,14 +41,16 @@ export interface CoreForm<T> {
 /** Конфиг {@link createCoreForm}. */
 export interface CreateCoreFormConfig<T> extends CreateFormConfigBase<T, CoreForm<T>> {
     /**
-     * Билдер схемы формы. Именно функция, а не готовое дерево: листья схемы держат сами сигналы
-     * модели (`value: model.$.email`), поэтому построить дерево до модели нечем.
+     * Билдер схемы формы. Именно функция, а не готовое дерево: узлы схемы держат ручки модели
+     * (`model: model.$.email`), поэтому построить дерево до модели нечем.
      */
     schema?: (model: FormModel<T>) => FormSchemaNode;
 }
 /**
  * Собрать модель, форму и валидацию за один проход.
  *
+ * @deprecated Пишите `createForm` — та же сборка, в бандле вдобавок дерево для рендерера.
+ *
  * @typeParam T - Форма данных модели.
  * @param config - {@link CreateCoreFormConfig}: (`initial` | `model`) + опц. `schema`, `behavior`,
  *   `validation`, `seed`, `setup`.

package/dist/form/create-form.d.ts

@@ -2,6 +2,7 @@ import { FormProxy, GroupNodeConfig, FormSchema } from './types/index';
 import { FormSchemaNode } from './types/schema-node';
 import { FormModel } from '../model/types';
 import { FormBehavior } from './behaviors';
+import { SchemaController } from './schema-controller';
 /**
  * Аргументы createForm под архитектуру M1: данные приходят из {@link FormModel},
  * конфиг полей (component/componentProps) — из единой схемы.
@@ -21,24 +22,32 @@ export interface CreateFormFromModelArgs<T> {
      * заполнения реестра сигнал→нода; cleanup живёт на форме и вызывается в `form.dispose()`.
      */
     behavior?: FormBehavior<T>;
+    /**
+     * Схема-контроллер сборки: через него поведение получает `schema` своей области. Его передаёт
+     * сборка одним вызовом, чтобы правила узлов (`hideWhen`, `onComponentEvent`) дошли до рендерера.
+     * Без него поведение пишет правила в собственный контроллер, который никто не читает.
+     */
+    schemaController?: SchemaController;
 }
 /**
  * Собрать форму из {@link FormModel} и единой схемы (низкоуровневая фабрика архитектуры M1).
  *
  * Значения принадлежат модели (источник истины), ноды формы держат UI/валидационное состояние и
  * ссылаются на сигналы модели по идентичности (`node.value === model.$.path`). Обходит структуру
- * модели, привязывает конфиг поля (component/componentProps) из схемы, материализует
- * top-level массивы как {@link ModelArrayNode}, заполняет реестр сигнал→нода (для `enableWhen`/
- * роутинга ошибок) и, при наличии, запускает декларативное поведение (cleanup живёт на форме).
+ * модели, привязывает конфиг поля (component/componentProps) из схемы, материализует массивы
+ * под-форм как {@link ModelArrayNode} (на любой глубине), заполняет реестр ручка→нода (для
+ * `enableWhen`, `apply`/`applyEach` и роутинга ошибок) и, при наличии, запускает декларативное
+ * поведение (cleanup живёт на форме).
  *
- * Обычно вызывается неявно через {@link createForm} с аргументом `{ model, schema }` — прямой вызов
- * нужен редко (например, для построения формы элемента массива).
+ * Обычно вызывается сборкой одним вызовом (`createForm`): она строит дерево схемы, зовёт эту
+ * фабрику и собирает валидацию. Прямой вызов нужен там, где бандл не нужен, — форма элемента
+ * массива, тесты, свой слой сборки.
  *
  * @typeParam T - Тип модели данных формы
  * @param args - Модель, единая схема и (опционально) декларативное поведение {@link CreateFormFromModelArgs}
  * @returns Типизированная форма с Proxy-доступом к полям {@link FormProxy}
  *
- * @example Форма из модели + схемы (эквивалент `createForm({ model, schema })`)
+ * @example Форма из модели + схемы (эквивалент `createFormFromModel({ model, schema })`)
  * ```typescript
  * import { createModel, createFormFromModel } from '@reformer/core';
  *
@@ -65,69 +74,35 @@ export interface CreateFormFromModelArgs<T> {
  * console.log(model.email); // 'user@mail.com'
  * ```
  *
- * @see {@link createForm} - основная фабрика (диспетчеризует сюда при аргументе `{ model, schema }`)
+ * @see `createForm` — сборка одним вызовом: модель, форма, валидация и дерево для рендера
  * @group Utilities
  */
 export declare function createFormFromModel<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>;
 /**
- * Создать форму из {@link FormModel} + единой схемы (архитектура M1, рекомендуемый путь).
- *
- * @group Utilities
+ * Создать форму из готового конфига группы.
  *
- * @param args - Модель данных, layout-схема (component/componentProps) и (опционально) поведение
+ * @param config - Конфиг {@link GroupNode}
  * @returns Типизированная форма с Proxy-доступом к полям
- *
- * @example Архитектура M1: `createModel` + layout-схема + `createForm({ model, schema })`
- * ```typescript
- * import { createModel, createForm } from '@reformer/core';
- * import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
- * import { required, email, minLength } from '@reformer/core/validators';
- *
- * interface UserForm {
- *   email: string;
- *   password: string;
- * }
- *
- * const model = createModel<UserForm>({ email: '', password: '' });
- *
- * // Layout-схема НЕ несёт validators — только component/componentProps.
- * const schema = {
- *   children: [
- *     { value: model.$.email, component: Input },
- *     { value: model.$.password, component: Input },
- *   ],
- * };
- *
- * const form = createForm<UserForm>({ model, schema });
- * form.email.setValue('test@mail.com');
- *
- * // Валидация — ОТДЕЛЬНАЯ схема, прогон внешним раннером (ошибки сами доезжают до нод):
- * const validation = defineValidationSchema<UserForm>(({ model }) => {
- *   validate(model.$.email, [required(), email()]);
- *   validate(model.$.password, [required(), minLength(8)]);
- * });
- * const ok = await validateModel(model, validation);
- * ```
+ * @group Utilities
  */
-export declare function createForm<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>;
-export declare function createForm<T>(config: GroupNodeConfig<T>): FormProxy<T>;
+export declare function createLegacyForm<T>(config: GroupNodeConfig<T>): FormProxy<T>;
 /**
- * Создать форму только со схемой полей.
+ * Создать форму из плоской схемы полей с инлайн-значениями (`value: ''`) — путь ДО архитектуры M1.
  *
- * @deprecated Legacy / back-compat: плоская `FormSchema` с инлайн-значениями (`value: ''`) — путь
- *   ДО архитектуры M1. Для нового кода используйте перегрузку `createForm({ model, schema })`
- *   (значения принадлежат {@link FormModel}, а правила — отдельной схеме `defineValidationSchema`,
- *   которую прогоняет `validateModel`; поля `validators` у узла layout-схемы нет).
+ * Значения живут в нодах, модели нет: поведение (`defineFormBehavior`) и внешняя валидация
+ * (`validateModel`) к такой форме не подключаются. Для нового кода — {@link createFormFromModel}
+ * либо сборка одним вызовом.
  *
  * @param schema - Схема полей формы
  * @returns Типизированная форма с Proxy-доступом к полям
+ * @group Utilities
  *
- * @example Legacy (back-compat) — плоская схема без модели
+ * @example
  * ```typescript
- * const form = createForm<UserForm>({
+ * const form = createLegacyForm<UserForm>({
  *   email: { value: '', component: Input },
  *   password: { value: '', component: Input },
  * });
  * ```
  */
-export declare function createForm<T>(schema: FormSchema<T>): FormProxy<T>;
+export declare function createLegacyForm<T>(schema: FormSchema<T>): FormProxy<T>;

package/dist/form/form-bundle.d.ts

@@ -0,0 +1,136 @@
+import { FormModel } from '../model/types';
+import { FormBehavior } from './behaviors';
+import { SchemaController, SchemaNodeControl } from './schema-controller';
+import { FormSchemaNode } from './types/schema-node';
+import { FormProxy } from './types/index';
+import { FormValidation, FormValidationBundle } from './validation/config';
+import { ValidationSchema } from './validation';
+/**
+ * Дерево, собранное реестром из документа схемы (JSON), и то, что реестр хочет донести до
+ * рендерера вместе с ним.
+ *
+ * @group Utilities
+ */
+export interface ResolvedSchema {
+    /** Корневой узел дерева. */
+    tree: FormSchemaNode;
+    /** Обёртка поля — компонент, которым рендерер оборачивает каждое поле. */
+    fieldWrapper?: unknown;
+    /** Граница ошибок — компонент, которым рендерер оборачивает дерево. */
+    errorBoundary?: unknown;
+}
+/**
+ * Реестр, умеющий превратить документ схемы в дерево. Метод необязателен: у интерфейса реестра
+ * есть сторонние реализации, и ядро документ само не разбирает.
+ *
+ * @group Utilities
+ */
+export interface SchemaResolver {
+    resolveSchema?(document: unknown, model: FormModel<never>): ResolvedSchema;
+}
+/**
+ * Часть бандла для рендерера: готовое дерево и схема-контроллер сборки.
+ *
+ * @group Utilities
+ */
+export interface FormRender {
+    /** Корневой узел дерева схемы; `undefined`, если схема не задана. */
+    readonly tree: FormSchemaNode | undefined;
+    /** Схема-контроллер сборки: области корня, строк массивов и подформ. */
+    readonly controller: SchemaController;
+    /** Управление узлом КОРНЕВОЙ области по его `selector`. */
+    node(selector: string): SchemaNodeControl;
+    /** Обёртка поля из реестра (JSON-вариант). */
+    readonly fieldWrapper?: unknown;
+    /** Граница ошибок из реестра (JSON-вариант). */
+    readonly errorBoundary?: unknown;
+}
+/**
+ * Результат {@link createForm}.
+ *
+ * @typeParam T - Форма данных модели.
+ * @group Utilities
+ */
+export interface FormBundle<T> {
+    model: FormModel<T>;
+    form: FormProxy<T>;
+    /** Собранная валидация; есть, если в конфиге заданы правила. */
+    validation?: FormValidationBundle<T>;
+    render: FormRender;
+}
+/**
+ * Конфиг {@link createForm}.
+ *
+ * @typeParam T - Форма данных модели.
+ * @group Utilities
+ */
+export interface CreateFormConfig<T> {
+    /** Начальные значения — из них создаётся модель. Взаимоисключимо с `model`. */
+    initial?: T;
+    /** Готовая модель (если создана отдельной фабрикой). Приоритетнее `initial`. */
+    model?: FormModel<T>;
+    /**
+     * Схема формы: билдер дерева `(model) => узел` либо документ (JSON) — тогда нужен `registry`.
+     * Билдер, а не готовое дерево: узлы держат ручки модели (`model: model.$.email`), и построить
+     * дерево до модели нечем.
+     */
+    schema?: ((model: FormModel<T>) => FormSchemaNode) | object;
+    /** Реестр JSON-варианта: превращает документ схемы в дерево. */
+    registry?: SchemaResolver;
+    /** Поведение формы: значения, состояние нод и правила узлов схемы. */
+    behavior?: FormBehavior<T>;
+    /** Правила валидации: готовая схема либо {@link FormValidation} со стратегией и шагами. */
+    validation?: FormValidation<T> | ValidationSchema<T>;
+    /**
+     * Правка модели ДО сборки формы. Нужна там, где значение обязано существовать к моменту
+     * построения нод — например, массив, наполняемый из вычислений (реактивные `onChange` на
+     * инициализации не срабатывают).
+     */
+    seed?: (model: FormModel<T>) => void;
+    /** Донастройка ПОСЛЕ сборки: получает готовый бандл. */
+    setup?: (bundle: FormBundle<T>) => void;
+}
+/** Бандл формы, у которой заданы правила: `validation` в нём есть всегда. */
+type ValidatedFormBundle<T> = FormBundle<T> & {
+    validation: FormValidationBundle<T>;
+};
+/**
+ * Собрать модель, форму, валидацию и дерево для рендера за один проход.
+ *
+ * @typeParam T - Форма данных модели.
+ * @param config - {@link CreateFormConfig}: (`initial` | `model`) + опц. `schema`, `registry`,
+ *   `behavior`, `validation`, `seed`, `setup`.
+ * @returns {@link FormBundle} — `{ model, form, validation?, render }`.
+ *
+ * @example Рендерер по TS-схеме
+ * ```tsx
+ * const credit = useFormBundle(() =>
+ *   createForm<CreditForm>({
+ *     model: createCreditModel(),
+ *     schema: creditSchema, // (model) => узел
+ *     behavior: creditBehavior,
+ *     validation: { steps: { loan: loanRules }, extras: crossRules },
+ *   })
+ * );
+ * return <FormRenderer form={credit} settings={{ fieldWrapper: FormField }} />;
+ * ```
+ *
+ * @example React-руками — та же сборка, разметка в JSX
+ * ```tsx
+ * const credit = useFormBundle(() => createForm<CreditForm>({ initial, schema: creditSchema }));
+ * return <FormField control={credit.form.loanType} />;
+ * ```
+ *
+ * @example JSON — документ схемы и реестр
+ * ```tsx
+ * const credit = useFormBundle(() =>
+ *   createForm<CreditForm>({ model: createCreditModel(), schema: creditJson, registry })
+ * );
+ * return <FormRenderer form={credit} />;
+ * ```
+ */
+export declare function createForm<T extends object>(config: CreateFormConfig<T> & {
+    validation: FormValidation<T> | ValidationSchema<T>;
+}): ValidatedFormBundle<T>;
+export declare function createForm<T extends object>(config: CreateFormConfig<T>): FormBundle<T>;
+export {};

package/dist/form/index.d.ts

@@ -18,8 +18,13 @@ export { GroupNode } from './nodes/group-node';
 export { ArrayNode } from './nodes/array-node';
 export { ModelArrayNode } from './nodes/model-array-node';
 export type { ModelArrayControl } from './nodes/model-array-node';
-export { createForm, createFormFromModel } from './create-form';
+export { createForm } from './form-bundle';
+export type { CreateFormConfig, FormBundle, FormRender, ResolvedSchema, SchemaResolver, } from './form-bundle';
+export { createFormFromModel, createLegacyForm } from './create-form';
 export type { CreateFormFromModelArgs } from './create-form';
+export { schemaSubtree } from './schema-subtree';
+export { createSchemaController, createSchemaScope, createSchemaOverrideMaps, unknownSchemaSelectors, } from './schema-controller';
+export type { SchemaController, SchemaScope, SchemaNodeControl, SchemaOverrideMaps, NodeLifecycleHooks, } from './schema-controller';
 export { createCoreForm } from './create-core-form';
 export type { CoreForm, CreateCoreFormConfig, CreateFormConfigBase } from './create-core-form';
 export { buildValidation } from './validation/config';

package/dist/form/nodes/field-node.d.ts

@@ -196,10 +196,10 @@ export declare class FieldNode<T> extends FormNode<T> {
      *
      * @example
      * Пример node-level: плоская схема с инлайн-значениями (back-compat путь до M1). В layout-схеме
-     * `createForm({ model, schema })` поля `validators` нет — правила живут в `defineValidationSchema`.
+     * `createFormFromModel({ model, schema })` поля `validators` нет — правила живут в `defineValidationSchema`.
      * ```typescript
      * // Сценарий 1: Instant feedback после submit
-     * const form = createForm({
+     * const form = createLegacyForm({
      *   email: {
      *     value: '',
      *     component: Input,

package/dist/form/nodes/group-node.d.ts

@@ -7,7 +7,7 @@ import { SubmitOptions, SubmitResult } from '../form-submitter';
  * GroupNode - узел для группы полей
  *
  * Создаётся из {@link FormSchema} (дерево field-конфигов). Обычно строится через `createForm`
- * (M1: `createForm({ model, schema })`); schema-валидация/behavior живут на слое модели
+ * (M1: `createFormFromModel({ model, schema })`); schema-валидация/behavior живут на слое модели
  * (`validateModel` из `@reformer/core/validation`, `computeFrom`/`enableWhen`/…), а не на ноде.
  *
  * @group Nodes

package/dist/form/nodes/model-array-node.d.ts

@@ -7,8 +7,8 @@ import { FormProxy } from '../types/form-proxy';
 export interface ModelArrayControl<TItem extends object> {
     readonly length: number;
     at(index: number): FormModel<TItem> | undefined;
-    push(item: TItem): void;
-    insertAt(index: number, item: TItem): void;
+    push(item?: TItem): void;
+    insertAt(index: number, item?: TItem): void;
     removeAt(index: number): void;
     move(from: number, to: number): void;
     swap(a: number, b: number): void;
@@ -25,7 +25,7 @@ export interface ModelArrayControl<TItem extends object> {
  * reorder/повторном рендере не пересоздаются (состояние и валидация сохраняются). Реализует тот же
  * контракт, что ждут секции массива и `useFormControl` (`length`/`value`/`valid`/`errors`/`at`/`push`/…).
  *
- * Обычно создаётся не напрямую, а `createForm({ model, schema })`: когда в схеме встречается узел
+ * Обычно создаётся не напрямую, а `createFormFromModel({ model, schema })`: когда в схеме встречается узел
  * массива `{ array: model.<field>, item: (item) => itemSchema }`, форма материализует его как
  * `ModelArrayNode` и кладёт под `form.<field>` (совместим с `FormArraySection`).
  *
@@ -40,7 +40,7 @@ export interface ModelArrayControl<TItem extends object> {
  *   qty: { value: item.$.qty, component: Input },
  * });
  *
- * const form = createForm({
+ * const form = createFormFromModel({
  *   model,
  *   schema: {
  *     children: [{ array: model.rows, item: rowItem }],
@@ -79,13 +79,18 @@ export declare class ModelArrayNode<T extends object> extends FormNode<T[]> {
     /**
      * @param control Реактивный массив модели (`model.<path>`).
      * @param buildItem Строитель формы элемента по его под-модели (инъекция, чтобы избежать цикла
-     *   импорта с `create-form`). Обычно `(item) => createForm({ model: item, schema: itemSchema(item) })`.
+     *   импорта с `create-form`). Обычно `(item) => createFormFromModel({ model: item, schema: itemSchema(item) })`.
      */
     constructor(control: ModelArrayControl<T>, buildItem: (item: FormModel<T>) => FormProxy<T>);
     at(index: number): FormProxy<T> | undefined;
     map<R>(fn: (item: FormProxy<T>, index: number) => R): R[];
     forEach(fn: (item: FormProxy<T>, index: number) => void): void;
+    /**
+     * Добавить элемент. Без значения — элемент по шаблону массива модели (`arrayOf(blank)` либо
+     * `initialValue` узла-массива схемы); шаблона нет — ошибка модели.
+     */
     push(item?: Partial<T>): void;
+    /** Вставить элемент по индексу; без значения — по шаблону, как у {@link push}. */
     insert(index: number, item?: Partial<T>): void;
     removeAt(index: number): void;
     /**

package/dist/form/schema-controller.d.ts

@@ -0,0 +1,137 @@
+import { Signal } from '@preact/signals-core';
+/**
+ * Хуки жизненного цикла узла схемы. Каждый хук опционален; повторная регистрация перезаписывает
+ * предыдущее значение.
+ *
+ * @group Schema
+ */
+export interface NodeLifecycleHooks {
+    /** Срабатывает один раз при mount узла. Может вернуть cleanup-функцию. */
+    onMount?: () => void | (() => void);
+    /** Срабатывает один раз при unmount узла. */
+    onUnmount?: () => void;
+}
+/**
+ * Хранилище переопределений одной области схемы. Ключ каждой карты — `selector` узла.
+ *
+ * @group Schema
+ */
+export interface SchemaOverrideMaps {
+    hiddenOverrides: Map<string, boolean | null>;
+    propsOverrides: Map<string, Record<string, unknown> | null>;
+    refRegistry: Map<string, {
+        current: any;
+    }>;
+    /** Условия скрытия узлов: selector → реактивное условие. */
+    conditionRegistry: Map<string, () => boolean>;
+    /** Реактивные эффекты, живущие, пока область смонтирована (`renderEffect`). */
+    effectRegistry: Array<() => void | (() => void)>;
+    /** Обработчики событий компонентов: selector → { имя пропа → обработчик }. */
+    callbackRegistry: Map<string, Map<string, (...args: any[]) => any>>;
+    /** Хуки жизненного цикла узла: selector → { onMount, onUnmount }. */
+    lifecycleRegistry: Map<string, NodeLifecycleHooks>;
+    /** Общий счётчик изменений области. Узлы на него не подписываются — см. `versionFor`. */
+    version: Signal<number>;
+    /**
+     * Версия-сигнал одного селектора (создаётся лениво). Узел подписывается только на сигнал СВОЕГО
+     * селектора, поэтому `setHidden` / `patchProps` уведомляют один узел, а не всё дерево.
+     */
+    versionFor(selector: string): Signal<number>;
+}
+/**
+ * Управление одним узлом схемы. Получается через `schema.node(selector)`.
+ *
+ * @group Schema
+ */
+export interface SchemaNodeControl {
+    /** Принудительно скрыть или показать узел, минуя условие `hideWhen`. */
+    setHidden(value: boolean): this;
+    /** Убрать принудительное значение — снова действует условие `hideWhen`. */
+    resetHidden(): this;
+    /** Подмешать объект в `componentProps` узла. */
+    patchProps(partial: Record<string, unknown>): this;
+    /** Убрать подмешанные пропсы. */
+    resetProps(): this;
+    /**
+     * Ref на компонент узла. Создаётся один раз на селектор; рендерер вешает его на компонент.
+     * Компонент обязан принимать `ref`.
+     */
+    getRef<H>(): {
+        current: H | null;
+    };
+    /** @internal Селектор узла. */
+    __selector: string;
+    /** @internal Хранилище области. */
+    __overrideMaps: SchemaOverrideMaps;
+}
+/**
+ * Схема одной области: адресует узлы по `selector`.
+ *
+ * @group Schema
+ */
+export interface SchemaScope {
+    /** Управление узлом области по его `selector`. */
+    node(selector: string): SchemaNodeControl;
+    /** @internal Хранилище области — его читает рендерер. */
+    __overrideMaps: SchemaOverrideMaps;
+}
+/**
+ * Схема-контроллер сборки: области по под-моделям.
+ *
+ * @group Schema
+ */
+export interface SchemaController {
+    /**
+     * Область под-модели: корня сборки, строки массива или группы подформы. Создаётся при первом
+     * обращении; повторное обращение отдаёт ту же область.
+     */
+    scopeOf(subModel: object): SchemaScope;
+}
+/**
+ * Пустое хранилище переопределений области.
+ *
+ * @group Schema
+ */
+export declare function createSchemaOverrideMaps(): SchemaOverrideMaps;
+/**
+ * Схема области поверх хранилища: `node(selector)` → управление узлом.
+ *
+ * @param maps - Хранилище области; по умолчанию создаётся новое.
+ * @group Schema
+ */
+export declare function createSchemaScope(maps?: SchemaOverrideMaps): SchemaScope;
+/**
+ * Схема-контроллер одной сборки формы.
+ *
+ * @example
+ * ```typescript
+ * const controller = createSchemaController();
+ * const root = controller.scopeOf(model);
+ * root.node('mortgage').setHidden(true);
+ *
+ * controller.scopeOf(model.items.at(0)); // область строки — свои селекторы
+ * ```
+ *
+ * @group Schema
+ */
+export declare function createSchemaController(): SchemaController;
+/**
+ * Селекторы, на которые в области записаны правила, но которых нет в её дереве. Такое правило
+ * ничего не делает — сборка и рендерер в dev предупреждают о нём.
+ *
+ * Ref в проверку не входит: его разрешено брать по абсолютному пути модели
+ * (`phones.0.number`), а такой строки при сборке может ещё не быть.
+ *
+ * @param maps - Хранилище области.
+ * @param tree - Дерево (поддерево) области.
+ * @returns Селекторы с правилами, не найденные в дереве.
+ *
+ * @example
+ * ```typescript
+ * const scope = controller.scopeOf(model);
+ * unknownSchemaSelectors(scope.__overrideMaps, tree); // ['mortgage'] — узла с таким selector нет
+ * ```
+ *
+ * @group Schema
+ */
+export declare function unknownSchemaSelectors(maps: SchemaOverrideMaps, tree: unknown): string[];