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

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

@@ -1,18 +1,34 @@
 import { BehaviorCleanup } from '../../index';
+import { SchemaController } from '../schema-controller';
 import { BehaviorScope, FormBehavior } from './types';
 /** Зарегистрировать произвольную отписку в активной схеме. */
 export declare function onDispose(cleanup: BehaviorCleanup): void;
-/** Текущий scope ({ model, form }) активной схемы (escape hatch для кросс-операторов). */
+/**
+ * Зарегистрировать отписку, если оператор вызван внутри схемы поведения; вне схемы — ничего.
+ * Для операторов, которые работают и сами по себе (правила узлов схемы).
+ *
+ * @internal
+ */
+export declare function onDisposeIfActive(cleanup: BehaviorCleanup): void;
+/** Текущая область ({ model, form, schema }) активной схемы (escape hatch для кросс-операторов). */
 export declare function getScope<T>(): BehaviorScope<T>;
+/**
+ * Схема-контроллер сборки, в которой идёт активная схема: под-схемы (`apply`, `applyEach`)
+ * получают через него область своей под-модели.
+ *
+ * @internal
+ */
+export declare function getController(op?: string): SchemaController;
 /**
  * Описать поведение формы декларативно. Возвращает {@link FormBehavior} для `createForm({ behavior })`.
  *
  * @example
  * ```ts
- * export const myBehavior = defineFormBehavior<MyForm>(({ model, form }) => {
+ * export const myBehavior = defineFormBehavior<MyForm>(({ model, form, schema }) => {
  *   compute(model.$.total, () => model.price * model.qty);
  *   enableWhen([model.$.city], () => Boolean(model.country));
  *   onChange(model.$.country, async (c) => form.city.updateComponentProps({ options: await load(c) }));
+ *   hideWhen(schema.node('delivery'), () => model.country === '');
  * });
  * ```
  */

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

@@ -2,7 +2,7 @@
  * Декларативный контракт схемы поведения формы — `@reformer/core/behaviors`.
  *
  * Свободные операторы (`compute`/`copyFrom`/`enableWhen`/`onChange`/…) вызываются внутри
- * `defineFormBehavior(({ model, form }) => { … })` и САМИ регистрируют свои отписки в ambient-стоке —
+ * `defineFormBehavior(({ model, form, schema }) => { … })` и САМИ регистрируют свои отписки в ambient-стоке —
  * автор схемы не видит ни массива `cleanups`, ни `.push`, ни вызовов через точку. Жизненным циклом
  * владеет форма (`createForm({ behavior })`). Операторы — тонкие обёртки над примитивами слоя данных
  * ({@link module:model/behaviors-value}); пользовательские операторы пишутся так же и неотличимы от встроенных.
@@ -26,3 +26,5 @@ export type { Signal, ReadonlySignal, BehaviorCleanup } from './types';
 export { onDispose, getScope, defineFormBehavior, effect, defer } from './context';
 export { compute, computeFrom, copyFrom, onChange, enableWhen, disableWhen, transformValue, resetWhen, syncFields, revalidateWhen, } from './operators';
 export { applyEach, exclusiveFlag, aggregateInto, apply } from './collections';
+export { hideWhen, onComponentEvent, renderEffect, onInit, onMount, onUnmount, } from './schema-operators';
+export type { SchemaScope, SchemaNodeControl } from '../schema-controller';

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

@@ -13,6 +13,15 @@ export type GroupSignals = Record<string, unknown> & {
  * read-only агрегат вместо рекурсивного `writeGroup`.
  */
 export declare const isLeafSignal: (v: unknown) => v is Signal<unknown>;
+/**
+ * Ручка значения целиком: лист либо узел-массив дерева `$`.
+ *
+ * Массив копируется и читается ЗНАЧЕНИЕМ — заменой целиком, а не обходом по ключам: у его узла
+ * собственный ключ один (`length`), и обход, годный для группы, отдавал бы вместо массива мусор.
+ * Для `enableWhen` массив при этом остаётся НЕ листом ({@link isLeafSignal}): его нода ищется по
+ * пути, а она бывает и полем, и массивом под-форм.
+ */
+export declare const isValueHandle: (v: unknown) => v is Signal<unknown>;
 export declare const asArray: <X>(v: X | X[]) => X[];
 export declare function readGroup(g: GroupSignals): Record<string, unknown>;
 export declare function writeGroup(g: GroupSignals, val: Record<string, unknown>): void;
@@ -23,4 +32,3 @@ export declare function writeGroup(g: GroupSignals, val: Record<string, unknown>
  * синхронные мутации цикла не порождают → не затрагиваются.
  */
 export declare function makeCycleGuard(target: Signal<unknown>): (write: () => void) => void;
-export declare function getByPath(root: unknown, path: string): any;

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;
     /**