@reformer/core 11.0.0-beta.1 → 11.0.0-beta.10

package/docs/llms/17-nonexistent-api.md

@@ -1,23 +1,27 @@
 ## 15. NON-EXISTENT API (DO NOT USE)
 
-**Следующего API НЕТ в @reformer/core** (наследие старой path-based архитектуры,
-удалено при переходе на M1 и при разделении валидации/поведения):
+**Следующего API НЕТ в @reformer/core** (наследие старой path-based архитектуры и прежних
+контрактов модели, валидации, схемы, визарда и нод):
 
-> ⚠️ Операторы валидации `validate`/`validateAsync`/`validateWhen`/`cross`/`each`/`apply`
-> **существуют** — но живут в сабпути `@reformer/core/validation` (ambient-схема
-> `defineValidationSchema(({ model }) => …)`, раннер `validateModel`), а НЕ в корне и НЕ
+> ⚠️ Операторы валидации `validate`/`validateAsync`/`validateWhen`/`apply`/`applyEach`
+> **существуют** — но живут в сабпути `@reformer/core/validation` (схема
+> `defineValidation(({ model, cross }) => …)`, раннер `validateModel`), а НЕ в корне и НЕ
 > в `@reformer/core/validators`. Ниже перечислено то, чего действительно нет.
 
 | Wrong                            | Correct                                          | Notes                                          |
 | -------------------------------- | ------------------------------------------------ | ---------------------------------------------- |
-| `useForm`                        | `createModel` + `createForm`                     | Хука useForm нет                               |
+| `useForm`                        | `createForm` + `useFormBundle`                   | Хука useForm нет                               |
+| `FormValue`                      | тип значения самого поля либо `unknown`          | Тип удалён: модель обобщённая (`createModel<T>`), параметры замечания — `Record<string, unknown>` |
+| `value instanceof Signal`        | `isSignal(value)` из `@reformer/core/signals`    | Проверка по классу не узнаёт сигнал другой копии рантайма; ручку поля проверяет `isValueSignal` |
+| `import { useFormControl, useFormBundle, … } from '@reformer/core'` | те же имена из `@reformer/core/react` | Корень ядра без React: хуки (`useFormControl`, `useFormControlValue`, `useArrayLength`, `useFormValidation`, `useFormBundle`, `useFormFlow`), `FormBundleContext`, связка поля (`bindFieldProps`, `getFieldAdapter`, `FieldAdapter`, `FieldHandle`) и типы снимков (`FieldControlState`, `ArrayControlState`) отдаёт только сабпат `/react` |
+| `import { I18nProvider, useI18n, … } from '@reformer/core/i18n'` | те же имена из `@reformer/core/react` | `/i18n` — локаль, перевод и тексты замечаний без React; провайдер и хуки (`I18nProvider`, `useI18n`, `useMessages`, `useIssueMessage`) — в `/react` |
+| `ElementType` / `ComponentType` в типе узла схемы | `ComponentRef` из `@reformer/core` | Типы схемы и ноды не импортируют типы React: `component` — непрозрачная ссылка (`string | object`), к типу своего UI-слоя её приводит рендерер |
 | `validateForm`, `validateFormModel` | `validateModel(model, schema)` из `@reformer/core/validation` | Legacy-движок дерева `{ value, validators }` удалён; внешний раннер — `validateModel` |
 | `validateModelSync`              | `await validateModel(model, schema)`             | Синхронного раннера нет — прогон асинхронный (`Promise<boolean>`) |
 | `applyWhen`                      | `validateWhen(() => cond, () => { … })`          | Условная валидация — оператором `validateWhen`, не узлом `{ when, children }` |
-| `validateItems`, `validateGroup`, `validateTree` | `each(model.arr, (im) => { … })` | Per-item — оператором `each`; под-схема — прямой вызов `sub({ model: model.child })` |
-| `ValidationSchemaFn`, `BehaviorSchemaFn` | `ValidationSchema<T>` (`defineValidationSchema`) / `defineFormBehavior` | Типы path-схем удалены |
-| `equalTo`, `custom`, `notEmpty` (validators) | inline `Rule<T>` `(value) => err \| null` в `validate(sig, [...])`; сравнение полей — `cross(sig, fn)` | Таких фабрик нет; кастомное правило — обычная функция значения, cross-field — `cross` |
-| `form.submit()` / `form.validate()` прогоняют схему | `await validateModel(model, schema)` перед submit/шагом | submit/validate НЕ запускают ambient-схему валидации |
+| `validateItems`, `validateGroup`, `validateTree` | `applyEach(model.$.arr, rowRules)` / `apply(model.$.group, groupRules)` | Правила строк и подформы — отдельные схемы, подключённые привязкой |
+| `ValidationSchemaFn`, `BehaviorSchemaFn` | `ValidationDefinition<T>` (`defineValidation`) / `defineFormBehavior` | Типы path-схем удалены |
+| `equalTo`, `custom`, `notEmpty` (validators) | inline `Rule<T>` `(value) => issue \| null` в `validate(sig, [...])`; сравнение полей — `cross(sig, fn)` | Таких фабрик нет; кастомное правило — обычная функция значения, cross-field — `cross` |
 | `FieldPath`, `FieldPathNode`     | `model.$.field` (`PathAwareSignal`)              | Пути заменены сигналами                         |
 | `ctx.form.x.value.value`         | `model.x` / `model.$.x.value`                    | В behaviors читаем модель напрямую              |
 | `ctx.setFieldValue(name, value)` | `model.x = value` / `compute(...)`               | Не существует                                   |
@@ -26,51 +30,232 @@
 | `FormProvider`, `control` prop, `register()` | `<Component form={form} />`, `useFormControl(form.field)` | Форма передаётся через props |
 | `getFieldValue()`                | `model.field` / `useFormControlValue(form.field)`| Не существует                                   |
 
+### Удалено: модель (этап 1)
+
+| Wrong                                  | Correct                                              | Notes                                   |
+| -------------------------------------- | ---------------------------------------------------- | --------------------------------------- |
+| `model.set(partial)` для части полей   | `model.patch(partial)`                               | `set` — полная установка: недостающие ключи в dev дают предупреждение и не меняются; `patch` сливает переданные ключи, вложенные группы — тоже частично, массив — целиком |
+| `FormValue`, `T extends FormValue`     | `T` без ограничения / `Record<string, unknown>`       | Тип удалён                              |
+
+### Удалено: компонент массива (этап 2)
+
+Имя `FormArray` теперь занято **типом ноды** массива под-форм в `@reformer/core`; компонент массива
+в cdk и ui-kit называется `FieldArray`.
+
+| Wrong                                             | Correct                                            | Notes                                  |
+| ------------------------------------------------- | -------------------------------------------------- | -------------------------------------- |
+| компонент `FormArray` (`@reformer/cdk`, `@reformer/ui-kit`) | `FieldArray`                             | `{ model: model.$.items, component: FieldArray, item }` |
+| `FormArraySection`                                | `FieldArraySection`                                | ui-kit                                 |
+| `useFormArray`                                    | `useFieldArray`                                    | cdk                                    |
+| `@reformer/cdk/form-array`, `@reformer/ui-kit/form-array` | `@reformer/cdk/field-array`, `@reformer/ui-kit/field-array` | сабпаты                     |
+| ключи локали `kit.formArray.*`                    | `kit.fieldArray.*`                                 | ui-kit                                 |
+
+JSON-документ схемы со старыми именами `FormArray` / `FormArraySection` реестр renderer-json ещё
+принимает как псевдонимы (dev-предупреждение).
+
+### Удалено: замечание валидации без текста (этап 4)
+
+Замечание несёт код и параметры; текст по коду даёт словарь формы — см. `36-issue-messages.md`.
+
+| Wrong                                             | Correct                                            | Notes                                  |
+| ------------------------------------------------- | -------------------------------------------------- | -------------------------------------- |
+| `required({ message: '…' })`, `{ messageKey }`    | `required({ code: 'phone.required' })` + `defineIssueMessages({ 'phone.required': '…' })` | У `RuleOptions` только `code` и `params` |
+| `ValidationError` (`{ code, message, … }`)        | `ValidationIssue` (`{ code, params?, severity? }`) | Поля `message` нет — текст через резолвер |
+| `ValidateOptions`                                 | `RuleOptions`                                      | `{ code?, params? }`                    |
+| `ValidationSchema`, `defineValidationSchema`      | `ValidationDefinition`, `defineValidation`         | `@reformer/core/validation`             |
+| `resolveValidationError`                          | `resolveIssueMessage(issue, i18n, messages?)`      | `@reformer/core/i18n`                   |
+| `useValidationMessage`                            | `useIssueMessage(messages?)`                       | `@reformer/core/react`                  |
+| `node.errors`, `setErrors`, `clearErrors`          | `node.issues`, `setIssues`, `clearIssues`          | И в снимке `useFormControl` — `issues`  |
+| `result.errors` у `ValidationResult`              | `result.issues`                                    | Замечания по ручке поля                 |
+| `getErrors(filter)`, `ErrorFilterOptions`         | `node.issues.value.filter(…)`                      | Фильтр — обычный `filter`               |
+| `errors[0].message` в разметке                    | `useIssueMessage(messages)(issues[0])`             | Строку даёт резолвер при показе         |
+| cdk `createMessageResolver`, `defaultErrorResolver`, `ValidationMessageTable` | `<ValidationMessagesProvider messages={defineIssueMessages({…})}>` | Словарь формы поверх локали |
+| cdk `ValidationErrorResolver`, `useValidationErrorResolver` | `IssueMessageResolver`, `useIssueMessageResolver` | `@reformer/cdk`              |
+
+### Удалено: схема (этап 5)
+
+| Wrong                                             | Correct                                            | Notes                                  |
+| ------------------------------------------------- | -------------------------------------------------- | -------------------------------------- |
+| `bundle.render.tree` как авторское дерево         | `bundle.render.tree` — `CompiledSchema`; авторское дерево — `bundle.render.tree.root.source` | См. `37-compiled-schema.md` |
+| повтор `selector` в одной области «с предупреждением» | разные селекторы                               | Повтор — исключение при сборке          |
+| свой разбор ключей `model` / `item` / `part` у узла | `compileSchema(tree, model)` — `kind` узла       | `field \| array \| part \| container \| text` |
+
+### Удалено: уровень формы, поток шагов, визард (этап 6)
+
+| Wrong                                                                 | Correct                                                                              | Notes                                                                                                                                                                      |
+| --------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `bundle.validation.validateAll()` / `.runAll()`                       | `bundle.validate()` → `ValidationResult`                                             | Поле `bundle.validation` осталось служебным (`{ rules, controller }` для `useFormBundle`) — методов проверки на нём нет                                                    |
+| `bundle.validation.validateStep(n)` / `.runStep(n)`                   | `bundle.validateStep(id)` → `ValidationResult`                                       | Идентификатор шага — `selector`, не номер                                                                                                                                  |
+| `createForm({ validation: { steps: { loan: rules } } })`              | `createForm({ flow: { steps: [{ id: 'loan', rules }] } })`                           | Правила вне шагов — `validation: { extras }`                                                                                                                               |
+| `buildValidation`, `FormValidationBundle`                             | `createForm({ validation, flow })` / `createFormLevel`                               | Уровень формы собирает сборка                                                                                                                                              |
+| `form.submit(handler)`, `SubmitOptions`, `form.submitting`            | `bundle.submission.submit(handler)` → `SubmitResult`, `bundle.submission.submitting` | Один прогон правил; обработчик — только при `valid`                                                                                                                        |
+| `bundle.submit(handler)`, `bundle.submitting`                         | `bundle.submission.submit(handler)` → `SubmitResult`, `bundle.submission.submitting` | Отправка — отдельный объект сборки; псевдонимов нет. То же у `level` в `renderBehavior` и бандлов `createReactForm` / `createJsonForm`: `level.submission.submit(handler)` |
+| `form.validate()`                                                     | `bundle.validate()`                                                                  | У нод методов проверки нет                                                                                                                                                 |
+| `<FormWizard config={…}>`, `FormWizardConfig`                         | `<FormWizard flow={bundle.flow}>`                                                    | Без `flow` и сборки в контексте — позиционный поток без правил                                                                                                             |
+| `<FormWizard ref={…}>`, `FormWizardHandle`, `ref.current.goToStep(n)` | `bundle.flow.goTo(id)` / `next()` / `previous()`                                     | Навигация — методами потока                                                                                                                                                |
+| `defineSteps(model, { steps, extras, strategy })`                     | `createForm({ validation: { extras, strategy }, flow })`                             | Живая проверка — стратегия формы                                                                                                                                           |
+| `useWizardStepValidation(config)`                                     | `validation: { strategy }` сборки                                                    | Стратегию армирует `useFormBundle`                                                                                                                                         |
+| `makeValidationConfig(model)` (`validateStep(n)` / `validateAll()`)   | `flow` сборки                                                                        | Визард берёт поток, а не конфиг                                                                                                                                            |
+
+### Удалено: ноды формы — контракты вместо классов (этап 7)
+
+| Wrong                                             | Correct                                            | Notes                                  |
+| ------------------------------------------------- | -------------------------------------------------- | -------------------------------------- |
+| классы `FormNode`, `FieldNode`, `GroupNode`, `ModelArrayNode` | интерфейсы `FormNode`, `FormControl`, `FormGroup`, `FormArray` | Классы реализации внутренние; ноды строит сборка |
+| `FormProxy<T>`                                    | `FormGroup<T>`                                     | Тип группы                              |
+| `isFieldNode`, `isGroupNode`, `isArrayNode`       | `isFormControl`, `isFormGroup`, `isFormArray`       | Гарды по метке вида; `isFormNode` остался |
+| `node instanceof FieldNode`                       | `isFormControl(node)`                              | `instanceof` по интерфейсу невозможен   |
+| `node.status.value`, `FieldStatus`                | `node.valid` / `invalid` / `pending` / `disabled`  | Отдельного статуса нет                  |
+| `node.patchValue(v)`                              | `node.setValue(v)` / `model.patch(partial)`        | Частичное обновление — у модели         |
+| `markAsDirty()`, `markAsPristine()`               | `dirty` ставит `setValue(v)`, снимает `reset()`    | Изменились ли значения модели — `model.isDirty()` |
+| `node.validate()`                                 | `bundle.validate()` / `bundle.validateStep(id)`    |                                         |
+| `group.fields` (Map), `group.getProxy()`          | `form.<поле>`, `form.$` (все поля), `Object.values(form.$)` | `fields` теперь обычное поле данных |
+| `node.id`                                         | ключ строки — `array.keyAt(index)`                  | `id` теперь обычное поле данных         |
+| `array.items`                                     | `array.at(i)` / `map` / `forEach`                  |                                         |
+| `array.length.value`                              | `array.length` (число; в эффекте подписывает)      | Не сигнал                               |
+| `key={row.id}` / `key={index}` у строк массива    | `key={array.keyAt(index)}`                         | Ключ не меняется при `move` / `swap`    |
+
+Затеняют поле группы только члены `FormNode` (`value`, `issues`, `reset`, …): такое поле берут через
+`form.$.value`. Имена `id`, `status`, `fields`, `submit` — обычные поля данных.
+
+### Удалено вместе со старым путём сборки формы
+
+Форма собирается только из модели: `createForm({ initial | model, schema })`. Ноды строятся по
+виду узла модели, правила живут в схеме валидации.
+
+| Wrong                            | Correct                                          | Notes                                          |
+| -------------------------------- | ------------------------------------------------ | ---------------------------------------------- |
+| `createLegacyForm(schema)`       | `createForm({ initial, schema })`                | Формы без модели нет                            |
+| `new FormGroup({ email: { value, component } })` | `createFormFromModel({ model, schema })` | `FormGroup` — тип, ноды строит сборка   |
+| `new FormControl({ value: '' })` | `createForm({ initial: { email: '' } }).form.email` | `FormControl` — тип; значение принадлежит модели |
+| `FieldConfig.validators` / `asyncValidators` | `validate` / `validateAsync` в `defineValidation` | Собственных валидаторов у ноды нет |
+| `updateOn`, `debounce` узла поля; `field.setUpdateOn()` / `getUpdateOn()` | `validation: { strategy, debounce }` в `createForm` | Когда запускать проверку, решает стратегия валидации формы |
+| `field.setValue(value, { emitEvent: false })` | `field.setValue(value)`                | Опций у `setValue` нет                          |
+| `ArrayNode`                      | `FormArray`                                      | Нода массива одна — над массивом модели         |
+| `NodeFactory`                    | —                                                | Сборка по ключам конфига удалена                |
+| `FormErrorHandler`, `ErrorStrategy` | —                                           | Обслуживали валидаторы ноды                     |
+| `FormSchema<T>`, `GroupNodeConfig<T>` | `FormSchemaNode`                          | Схема — дерево узлов, а не запись по полям      |
+| `ValidatorFn`, `AsyncValidatorFn`, `Validator<TForm, TField>` | `Rule<T>`, `AsyncRule<T>` из `@reformer/core/validation` | Правило — функция одного аргумента |
+
+### Удалено: подписки на нодах, доступ по строковому пути, псевдонимы
+
+Реакции живут на слое модели (`defineFormBehavior`), поле берётся через форму, у каждой
+операции одно имя.
+
+| Wrong                                                                                                                           | Correct                                                                                                                         | Notes                                           |
+| ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------- |
+| `field.watch(cb)`, `form.watchField('email', cb)`, `form.watchFieldByPath(path, cb)`                                            | `onChange(model.$.email, cb)` в `defineFormBehavior`; вне поведения — `watchField(model.$.email, cb)` из `@reformer/core/model` | Подписок на ноде нет                            |
+| `field.computeFrom(sources, fn)`, `form.linkFields('a', 'b', fn)`                                                               | `compute(model.$.b, () => fn(model.a))` в `defineFormBehavior`                                                                  | Вычисляемое значение — оператор поведения       |
+| `field.dispose()`                                                                                                               | сборку — `bundle.dispose()`; форму из `createFormFromModel` — `disposeForm(form)`                                               | В контракте нод `dispose` нет                   |
+| `form.getFieldByPath('address.city')`, `form.getField('email')`                                                                 | `form.address.city`, `form.email`; имя, занятое членом ноды, — `form.$.value`                                                   | Строковых путей к нодам нет                     |
+| `form.getAllFields()`                                                                                                           | `Object.values(form.$)`                                                                                                         | `form.$` — ноды всех полей группы по имени      |
+| `form.touchAll()`                                                                                                               | `form.markAsTouched()`                                                                                                          | Отметка каскадная: уходит во все вложенные поля |
+| `form.resetToInitial()`, `field.resetToInitial()`                                                                               | `form.reset()` — к значениям создания формы; `model.reset()` — к точке отсчёта модели                                           | См. `28-submit-and-reset.md`                    |
+| `form.submitWithResult(handler)`                                                                                                | `bundle.submission.submit(handler)` → `SubmitResult`                                                                            | Проверка и отправка одним вызовом               |
+| `getNodeType(node)`                                                                                                             | `isFormControl` / `isFormGroup` / `isFormArray`                                                                                 | Вид ноды — гардами                              |
+| `each(model.items, (item) => …)`                                                                                                | `applyEach(model.$.items, itemRules)`                                                                                           | Правила строки — отдельная схема над элементом  |
+| `import { cross } from '@reformer/core/validation'`                                                                             | `defineValidation(({ model, cross }) => …)`                                                                                     | `cross` — только из аргумента схемы             |
+| `createCoreForm`, `CreateCoreFormConfig`                                                                                        | `createForm`, `CreateFormConfig`                                                                                                | Сборка одна                                     |
+| `createReactForm`, `useReactForm` (`@reformer/renderer-react`); `createJsonForm`, `useJsonForm` (`@reformer/renderer-json`) | `createForm` + `useFormBundle`; документ JSON — `createForm({ schema: document, registry })` | Фабрики слоёв удалены — сборка одна |
+| `JsonFormRenderer`, `JsonRendererProvider` | `<FormRenderer form={bundle} />` из `@reformer/renderer-react` | Реестр уходит в сборку, а не в контекст |
+| `renderBehavior`, `RenderBehaviorFn` | одно поведение `defineFormBehavior(({ model, form, schema, flow }) => …)` | Правила узлов — в поведении формы |
+| `CoreForm`, `CreateFormConfigBase` | `FormBundle`, `CreateFormConfig` | Общие типы удалённых фабрик |
+| `FormArrayProxy<T>`                                                                                                             | `FormArray<T>`                                                                                                                  | Псевдоним типа удалён                           |
+| `FormSubmitter`, `SubmittableForm`, `SubscriptionManager`, `createSchemaOverrideMaps`, `ModelArrayControl`, `FormControlsProxy` | —                                                                                                                               | Внутренние детали, из пакета не экспортируются  |
+
+### Прежние ключи узла схемы
+
+| Wrong                            | Correct                                          | Notes                                          |
+| -------------------------------- | ------------------------------------------------ | ---------------------------------------------- |
+| `{ value: model.$.email, component }` | `{ model: model.$.email, component }`     | Привязка поля — ключ `model`                   |
+| `{ array: model.items, item }`   | `{ model: model.$.items, item }`                 | Привязка массива под-форм — ручка, а не фасад   |
+| `{ email: { model, component } }` (запись «имя → узел») | `{ children: [{ model, component }] }` | Вложенные узлы читаются только из `children` |
+| узел внутри `componentProps`     | узел в `children`                                | В пропсы обход схемы не заглядывает            |
+| `testId` ключом узла             | `componentProps: { testId }`                     | Ключа узла `testId` нет                        |
+
+### Операторы над сигналами — не в корне
+
+`computeFrom`, `copyFrom`, `watchField`, `transformValue`, `resetWhen`, `syncFields`,
+`revalidateWhen`, `enableWhen`, `disableWhen` из `@reformer/core` не импортируются.
+
+| Wrong                            | Correct                                          |
+| -------------------------------- | ------------------------------------------------ |
+| `import { enableWhen, copyFrom } from '@reformer/core'` | `import { enableWhen, copyFrom } from '@reformer/core/behaviors'` — внутри `defineFormBehavior` |
+| `import { watchField } from '@reformer/core'` | `onChange` из `@reformer/core/behaviors`; сам примитив — `@reformer/core/model` |
+| `import { computeFrom } from '@reformer/core'` | `compute` / `computeFrom` из `@reformer/core/behaviors` |
+
+### UI: удалённые field-версии компонентов (`@reformer/ui-kit`)
+
+Отдельных «field-версий» у компонентов кита больше нет: в `component` поля кладётся сам
+компонент, диалект он объявляет статикой `reformerAdapter`, связывает поле обёртка
+(`FormField.Control` / рендерер).
+
+| Wrong                                          | Correct                                                   |
+| ---------------------------------------------- | --------------------------------------------------------- |
+| `InputField`, `SelectField`, `CheckboxField`, … (любой `*Field`) | `Input`, `SelectAsync`, `CheckboxWithLabel`, … — таблица в ui-kit `01-overview.md` |
+| `InputField` + `type: 'number'`                | `InputNumber`                                             |
+| `InputField` + `suggestions`                   | `InputSuggest`                                            |
+| `FileUploadField` + `variant: 'dropzone' \| 'input'` | `FileUploadDropzone` / `FileUploadInput` (без `variant`) |
+| `withFormControl(MyControl, adapter)`          | `defineFieldControl(MyControl, { adapter })` из `@reformer/ui-kit/fields` |
+
 ### Common Import Errors
 
 ```typescript
 // WRONG - этих символов / путей НЕ существует
 import { useForm, validateForm, validateFormModel } from '@reformer/core';        // NO!
+import { useFormControl, useFormBundle } from '@reformer/core';                   // NO! хуки — из /react
 import { validate, applyWhen, equalTo } from '@reformer/core/validators';         // NO! операторов тут нет
+import { defineValidationSchema, type ValidationSchema } from '@reformer/core/validation'; // NO!
+import { resolveValidationError, useValidationMessage } from '@reformer/core/i18n';       // NO!
+import { FieldNode, GroupNode, isFieldNode, type FormProxy } from '@reformer/core';      // NO!
+import { defineSteps, useWizardStepValidation } from '@reformer/cdk/form-wizard';  // NO!
+import { FormArray, useFormArray } from '@reformer/cdk/form-array';                // NO! — field-array
 import { transformers } from '@reformer/core/behaviors';                          // NO!
-import type { FieldPath, ValidationSchemaFn } from '@reformer/core';              // NO!
+import type { FieldPath, ValidationSchemaFn, ValidationError } from '@reformer/core'; // NO!
 
 // CORRECT
-import { createModel, createForm, useFormControl } from '@reformer/core';
-import type { FormModel, ValidationError, FieldConfig } from '@reformer/core';
-// Операторы валидации + раннер + defineValidationSchema — отдельный сабпуть:
+import { createModel, createForm, isFormControl } from '@reformer/core';
+import { useFormBundle, useFormControl, useIssueMessage } from '@reformer/core/react';
+import type { FormModel, FormGroup, FormSchemaNode, ValidationIssue } from '@reformer/core';
+// Операторы валидации + раннер + defineValidation — отдельный сабпуть:
 import {
-  validate, validateAsync, validateWhen, cross, each, apply,
-  defineValidationSchema, validateModel,
-  type Rule, type AsyncRule, type ValidationSchema,
+  validate, validateAsync, validateWhen, apply, applyEach,
+  defineValidation, validateModel, runValidation, applyValidationResult,
+  type Rule, type AsyncRule, type ValidationDefinition, type ValidationResult,
 } from '@reformer/core/validation';
-// Фабрики-валидаторы (value-only, принимают nullable):
+// Фабрики-валидаторы — правила значения `Rule<T>`, пустое значение пропускают:
 import { required, email, min, minLength, pattern } from '@reformer/core/validators';
-// Поведение (отдельный слой, контракт не менялся):
+// Тексты замечаний — словарь формы:
+import { defineIssueMessages } from '@reformer/core/i18n';
+// Поведение (отдельный слой):
 import { defineFormBehavior, compute, onChange, revalidateWhen } from '@reformer/core/behaviors';
+// Компонент массива — FieldArray:
+import { FieldArray, useFieldArray } from '@reformer/cdk/field-array';
 ```
 
 ### Schema Common Mistakes
 
-Валидация и layout — **разные** контракты. Layout-узел привязывает поле к сигналу и
-НЕ несёт `validators`; правила живут в отдельной `defineValidationSchema`.
+Валидация и разметка — **разные** контракты. Узел схемы привязывает поле к ручке модели и
+правил не несёт; правила живут в отдельной `defineValidation`.
 
 ```typescript
-// WRONG - примитив/литерал вместо сигнала, и validators прямо в layout-узле
+// WRONG - запись «имя → узел», литерал вместо ручки и validators прямо в узле
 const schema = {
-  name:  '',                                       // нет привязки к сигналу
-  email: { value: '', validators: [required()] },  // value — литерал, а validators в layout больше нет
+  name:  '',                                       // нет привязки к модели
+  email: { value: '', validators: [required()] },  // ни ключа value, ни validators у узла нет
 };
 
-// CORRECT - layout только связывает поле с сигналом модели...
-const layout = {
-  name:  { value: model.$.name,  component: Input, componentProps: { label: 'Name' } },
-  email: { value: model.$.email, component: Input, componentProps: { label: 'Email' } },
+// CORRECT - схема только связывает поле с ручкой модели...
+const schema: FormSchemaNode = {
+  children: [
+    { model: model.$.name, component: Input, componentProps: { label: 'Name' } },
+    { model: model.$.email, component: Input, componentProps: { label: 'Email' } },
+  ],
 };
 
-// ...а правила — отдельная ambient-схема (прогоняется раннером validateModel):
-const validation = defineValidationSchema<Form>(({ model }) => {
-  validate(model.$.email, [required({ message: 'Email обязателен' }), email()]);
+// ...а правила — отдельная схема (уходит в createForm({ validation }) либо в validateModel):
+const validation = defineValidation<Form>(({ model }) => {
+  validate(model.$.email, [required({ code: 'email.required' }), email()]);
 });
 ```
 
@@ -85,7 +270,7 @@ enableWhen(model.$.city, () => Boolean(model.country), { resetOnDisable: true })
 ```
 
 Поведение **не владеет** валидацией. Чтобы поведение инициировало прогон схемы — мост
-`revalidateWhen` (validate/submit сами схему не запускают):
+`revalidateWhen` (или живая стратегия сборки `validation: { strategy: 'change' }`):
 
 ```typescript
 // CORRECT - поведение дёргает внешний раннер валидации при изменении зависимости

package/docs/llms/18-conditional-fields.md

@@ -2,14 +2,17 @@
 
 ## Purpose
 
-«Показать поле X только если Y» под M1 решается тремя независимыми механизмами — выбирай по
-тому, что именно должно быть условным:
+«Показать поле X только если Y» решается тремя независимыми механизмами — выбирай по тому, что
+именно должно быть условным:
 
 1. **Видимость / доступность** (поле остаётся в модели, но выключается/включается и не валидируется)
    — behaviors: `enableWhen`, а для условной записи значения — `compute` / `copyFrom` с опцией `{ when }`.
 2. **Условная валидация** (правила применяются только в истинной ветке) — оператор
-   `validateWhen(() => cond, () => {…})` внутри схемы `defineValidationSchema`, прогоняется раннером `validateModel`.
-3. **Скрытие из разметки** (узел вообще не рендерится) — `useFormControlValue` + условный рендер в JSX.
+   `validateWhen(() => cond, () => {…})` внутри схемы `defineValidation`; прогон — уровнем формы
+   (`bundle.validate()` / `bundle.submission.submit`) либо раннером `validateModel`.
+3. **Скрытие из разметки** (узел вообще не рендерится) — в схеме под рендерером — оператор
+   `hideWhen(schema.node(selector), cond)`; при разметке в JSX — `useFormControlValue` + условный
+   рендер.
 
 > Условная **валидация** — оператор `validateWhen` из `@reformer/core/validation`; старого branch-узла
 > `{ when, children }` и хелпера `applyWhen` больше нет — см.
@@ -56,36 +59,56 @@ export const creditBehavior = defineFormBehavior<CreditForm>(({ model }) => {
 - **Все поля должны быть материализованы в модели** (`createModel`), даже те, что показываются
   только под условием. `enableWhen`/`compute`/`copyFrom` принимают сигналы `model.$.field`, а не
   строковые пути; сигнала для несуществующего поля нет.
-- Поведение подключается к форме через `createForm({ model, schema, behavior })` — форма владеет
-  жизненным циклом, DSL-операторы регистрируют свой cleanup сами (ручной массив cleanup'ов не нужен).
+- Поведение подключается к форме через `createForm({ …, behavior })` (или
+  `createFormFromModel({ model, schema, behavior })`) — форма владеет жизненным циклом,
+  DSL-операторы регистрируют свой cleanup сами (ручной массив cleanup'ов не нужен).
 - Таргетом может быть и **группа**: `enableWhen(model.$.residenceAddress, () => model.sameAsRegistration === false)`
   проходит по поддереву; без `resetOnDisable` значение группы сохраняется (удобно, когда оно копируется
   из другого источника).
 
-> **Групповой таргет работает только у DSL-`enableWhen` из `@reformer/core/behaviors`**, не у
-> одноимённого корневого `enableWhen` из `@reformer/core` (тот резолвит только leaf-сигналы через
-> реестр → на group-сигнале это тихий no-op). `get_symbol_docs("enableWhen")` возвращает именно
-> корневой, не group-capable вариант.
+> `enableWhen` / `disableWhen` существуют только как операторы поведения
+> (`@reformer/core/behaviors`): в корне `@reformer/core` и в `@reformer/core/model` их нет.
+
+Скрыть узел разметки, когда форму рисует рендерер, — оператор узла схемы в том же поведении:
+
+```typescript
+import { defineFormBehavior, enableWhen, hideWhen } from '@reformer/core/behaviors';
+
+export const mortgageBehavior = defineFormBehavior<CreditForm>(({ model, schema }) => {
+  const isMortgage = () => model.loanType === 'mortgage';
+  enableWhen([model.$.propertyValue, model.$.initialPayment], isMortgage, { resetOnDisable: true });
+  hideWhen(schema.node('mortgage'), () => !isMortgage()); // узел с selector: 'mortgage'
+});
+```
+
+`hideWhen` только записывает правило — исполняет его рендерер; при разметке в JSX он ничего не
+делает (см. раздел «Скрытие в JSX»).
+
+**Скрытие — только видимость.** Поля скрытого узла (`hideWhen` или
+`schema.node(sel).setHidden(true)`) остаются включёнными, и правила их проверяют: шаг с
+незаполненным скрытым полем не пройдёт, а замечаний на экране не будет. Поэтому узел с полями
+скрывают вместе с `enableWhen` по тому же условию — как в примере выше.
 
 ## Условная валидация
 
 Правила, действующие только при выполнении условия, оборачиваются оператором
-`validateWhen(() => cond, () => {…})` внутри схемы `defineValidationSchema<T>(({ model }) => …)`.
+`validateWhen(() => cond, () => {…})` внутри схемы `defineValidation<T>(({ model }) => …)`.
 Условие `cond` читает модель напрямую (`model.field` — снимок на момент прогона): при истинном условии
 раннер применяет вложенные `validate`/`cross`/…, при ложном — правила ветки **гасятся** (поля,
-затронутые ранее, получают `setErrors([])`). Прогон — внешним раннером
-`validateModel(model, schema): Promise<boolean>` (ошибки сами роутятся в ноды формы).
+затронутые ранее, получают `setIssues([])`). Прогон — уровнем формы (`createForm({ validation })`,
+затем `bundle.validate()` / `bundle.submission.submit(handler)`) либо раннером
+`validateModel(model, schema): Promise<boolean>`; замечания сами доезжают до нод формы.
 
 ```typescript
 import {
   validate,
   validateWhen,
-  defineValidationSchema,
+  defineValidation,
   validateModel,
 } from '@reformer/core/validation';
 import { required, min } from '@reformer/core/validators';
 
-const schema = defineValidationSchema<CreditForm>(({ model }) => {
+const schema = defineValidation<CreditForm>(({ model }) => {
   validate(model.$.loanType, [required()]);
 
   // ветка применяется только для ипотеки
@@ -102,19 +125,28 @@ const ok: boolean = await validateModel(model, schema);
 ```
 
 Переключение `loanType` с `mortgage` на другой тип автоматически снимает ошибки `required` с
-`propertyValue`/`initialPayment` — при ложном условии ветка `validateWhen` гасит их (`setErrors([])`).
+`propertyValue`/`initialPayment` — при ложном условии ветка `validateWhen` гасит их (`setIssues([])`).
 `validateWhen` управляет только **валидацией**; чтобы поля ещё и выпадали из состояния (сброс
 значения), держи их под `enableWhen` из раздела выше — слои независимы.
 
+Выключенное поле (`enableWhen`, `disable()`) в проверке **уровня формы** не участвует:
+`bundle.validate`, `validateStep`, `submission.submit`, `flow.next()` и живая проверка гасят его
+замечания, и статус прогона совпадает с `valid` формы. Значение выключенного поля при этом остаётся
+в модели и уходит в обработчик отправки — модель передаётся целиком; убрать его из отправки —
+забота обработчика либо `enableWhen(…, { resetOnDisable: true })`. `validateWhen` нужен, когда
+поле остаётся доступным, но правило по условию не действует, — и в независимом раннере
+`validateModel(model, rules)`, который о нодах не знает.
+
 ## Скрытие в JSX
 
 Чтобы условный блок вообще не рендерился, читай значение-триггер хуком `useFormControlValue(form.field)`
 и делай ранний `return null`. Хук возвращает **только значение** (без деструктуризации `{ value }`).
 
 ```tsx
-import { useFormControlValue } from '@reformer/core';
+import type { FormGroup } from '@reformer/core';
+import { useFormControlValue } from '@reformer/core/react';
 
-function MortgageFields({ form }: { form: CreditForm }) {
+function MortgageFields({ form }: { form: FormGroup<CreditForm> }) {
   const loanType = useFormControlValue(form.loanType);
   if (loanType !== 'mortgage') return null;
 
@@ -137,7 +169,7 @@ function MortgageFields({ form }: { form: CreditForm }) {
 
 - **Нет branch-узла `{ when, children }` в дереве схемы.** Старая схема была деревом
   `{ value, validators: [...] }` с ветками `{ when: (scope, root) => boolean, children: [...] }`,
-  которое обходил `validateFormModel`. Теперь схема — функция `({ model }) => void`, а условие —
+  которое обходил `validateFormModel`. Теперь схема — функция `({ model, cross }) => void`, а условие —
   оператор `validateWhen(() => cond, () => {…})`; отдельного объекта-узла нет.
 
   ```typescript
@@ -154,25 +186,32 @@ function MortgageFields({ form }: { form: CreditForm }) {
 - **`applyWhen` не существует** — ни как экспорт, ни как локальный сахар: он эмитил branch-узел,
   которого больше нет. Оборачивай условные правила оператором `validateWhen`.
 
-- **`ValidationSchemaFn` удалён** (тип старой path-схемы). Тип схемы — `ValidationSchema<T>`
-  (`(ctx: { model: FormModel<T> }) => void`), фабрика-обёртка — `defineValidationSchema<T>(fn)`.
+- **`ValidationSchemaFn` удалён** (тип старой path-схемы). Тип схемы — `ValidationDefinition<T>`
+  (`(scope: { model: FormModel<T>; cross }) => void`), фабрика-обёртка — `defineValidation<T>(fn)`.
 
-- **Cross-field — обычная функция над снапшотом, а не `ModelValidator (value, scope, root)`.**
-  Соседние поля читаются из снимка модели (`f: Root`, эквивалент `model.get()`), а правило навешивается
-  оператором `cross(sig, fn)`. Каноничное использование — `complex-multy-step-form/schemas/validation.ts`.
+- **Cross-field — обычная функция над снимком, а не `ModelValidator (value, scope, root)`.**
+  Правило значения — `Rule<T> = (value: T) => error | null`, параметров `scope` / `root` у него нет.
+  Соседние поля читаются из снимка модели, а правило вешается оператором `cross(sig, check)` из
+  аргумента схемы. Каноничное использование — каталог `validation/` формы `complex-multy-step-form`.
 
   ```typescript
-  import { cross } from '@reformer/core/validation';
-  import type { ValidationError } from '@reformer/core';
+  import { defineValidation } from '@reformer/core/validation';
+  import type { ValidationIssue } from '@reformer/core';
 
-  // (f: Root) => error — сравнение с соседним полем, без scope/root-параметров
-  const passwordsMatch = (f: { password: string; confirmPassword: string }): ValidationError | null =>
-    f.confirmPassword && f.password && f.confirmPassword !== f.password
-      ? { code: 'mismatch', message: 'Пароли не совпадают' }
+  type Passwords = { password: string; confirmPassword: string };
+
+  // (snapshot) => error — сравнение с соседним полем
+  const passwordsMatch = (passwords: Passwords): ValidationIssue | null =>
+    passwords.confirmPassword &&
+    passwords.password &&
+    passwords.confirmPassword !== passwords.password
+      ? { code: 'confirmPassword.mismatch' } // текст кода — в словаре формы
       : null;
 
-  // внутри defineValidationSchema — fn получает снапшот текущего scope (model.get()):
-  cross(model.$.confirmPassword, passwordsMatch);
+  // cross — из аргумента схемы; check получает снимок модели области:
+  const passwordRules = defineValidation<Passwords>(({ model, cross }) => {
+    cross(model.$.confirmPassword, passwordsMatch);
+  });
   ```
 
 ## See also

package/docs/llms/19-reading-values.md

@@ -1,12 +1,14 @@
 ## 16. READING FIELD VALUES (CRITICALLY IMPORTANT)
 
-Под M1 значения живут в модели. Есть три контекста чтения: value-доступ модели, сигналы, и React-хуки.
+Значения живут в модели. Есть три контекста чтения: value-доступ модели, сигналы, и React-хуки
+(`@reformer/core/react`).
 
 ### В React-компоненте — хуки
 
 ```typescript
-// Полное состояние поля (объект)
-const { value, errors, disabled, touched, shouldShowError } = useFormControl(control.email);
+// Полное состояние поля (объект); текст замечания — useIssueMessage(messages)(issues[0])
+// shouldShowIssues — показывать ли тексты замечаний; shouldShowError — aria-invalid
+const { value, issues, disabled, touched, shouldShowIssues } = useFormControl(control.email);
 
 // Только значение (напрямую, БЕЗ деструктуризации!)
 const email = useFormControlValue(control.email);
@@ -15,6 +17,16 @@ const email = useFormControlValue(control.email);
 const count = useArrayLength(control.items);
 ```
 
+### Вне React — нода формы
+
+```typescript
+form.email.value.value;      // сигнал значения ноды (реактивно в effect/computed)
+form.email.getValue();       // значение без подписки
+form.email.issues.value;     // замечания: ValidationIssue[] — код и параметры, без текста
+form.items.length;           // число строк массива (число; в эффекте подписывает)
+form.getValue();             // значение группы целиком
+```
+
 ### Вне React — модель
 
 ```typescript
@@ -29,9 +41,38 @@ model.$.email.peek();        // нереактивный снимок
 model.$.address.city.value;  // сигнал вложенного поля (≡ model.address.$.city у под-модели)
 
 // весь объект
-model.get();                 // снимок { email, address: { city }, ... } — для submit
+model.get();                 // НЕреактивный снимок { email, address: { city }, ... } — для submit
 ```
 
+> ⚠️ `model.get()` и `model.isDirty()` читают через `peek()` — внутри `effect`/`computed` они НЕ
+> создают зависимостей. `computed(() => model.get())` никогда не пересчитается. Для реактивного
+> чтения всего объекта — узел дерева `$` (ниже).
+
+### Подписка на группу и на модель целиком
+
+Каждый узел дерева `$` — сигнал: лист отдаёт `PathAwareSignal`, а корень, вложенные объекты-группы
+и массивы — `ReadonlySignal` агрегированного значения поддерева. Поэтому подписаться можно на любом
+уровне, а не только на конкретном поле.
+
+```typescript
+model.$.subscribe((all) => autosave(all));      // любое изменение модели; all: T целиком
+model.$.address.subscribe((addr) => ...);       // только поддерево address
+model.$.address.value;                          // реактивный снимок группы
+model.$.address.peek();                         // нереактивный снимок группы
+model.$.items.subscribe((rows) => ...);         // массив: и правка элемента, и push/removeAt/move
+
+// узел — обычный ReadonlySignal, поэтому принимается операциями слоя данных
+watchField(model.$.address, (addr) => geocode(addr));
+```
+
+Дети узла доступны как раньше — `model.$.address.city` по-прежнему сигнал поля. Подписчик вызывается
+сразу с текущим значением (семантика `Signal.subscribe`), а `model.set(...)`/`model.reset()`
+уведомляют один раз, а не по разу на поле.
+
+> ⚠️ Доступ к полю выигрывает у свойства сигнала: если в форме есть поле с именем `value`, `peek`,
+> `subscribe`, `valueOf`, `toString`, `toJSON` или `brand`, то `model.$.<группа>.<это имя>` вернёт
+> сигнал поля. `subscribe` при этом продолжает работать.
+
 ### В behaviors — читаем model напрямую
 
 `compute`/`onChange`/условия `when` читают значения из value-модели (`model.field`) —