@reformer/core 9.1.1 → 10.0.0-beta.2

package/llms.txt

@@ -48,11 +48,12 @@
 | What                                                                                                   | Where                       |
 | ------------------------------------------------------------------------------------------------------ | --------------------------- |
 | `createModel`, `createForm`                                                                            | `@reformer/core`            |
-| `validateModel`, `validateModelSync`, `validateFormModel`                                              | `@reformer/core`            |
+| `validateModel`, `defineValidationSchema`, `validate`, `validateAsync`, `validateWhen`, `cross`, `each`, `apply` | `@reformer/core/validation` |
+| `Rule`, `AsyncRule`, `ValidationSchema` (типы)                                                         | `@reformer/core/validation` |
 | `useFormControl`, `useFormControlValue`, `useArrayLength`                                              | `@reformer/core`            |
 | `FormModel`, `FormProxy`, `FieldNode`, `GroupNode`, `ArrayNode`, `ModelArrayNode`                     | `@reformer/core`            |
 | `ModelSignals`, `ModelArray`, `ModelValue`, `ModelObject`, `PathAwareSignal`                          | `@reformer/core`            |
-| `ModelValidator`, `ValidationError`, `FieldConfig`, `FormSchema`, `FieldControlState`                 | `@reformer/core`            |
+| `ValidationError`, `FieldConfig`, `FormSchema`, `FieldControlState`                                    | `@reformer/core`            |
 | `computeFrom`, `copyFrom`, `watchField`, `enableWhen`, `disableWhen`                                   | `@reformer/core` (примитивы) |
 | `transformValue`, `resetWhen`, `syncFields`, `revalidateWhen`                                          | `@reformer/core` (примитивы) |
 | `required`, `min`, `max`, `minLength`, `maxLength`, `email`, `pattern`, `url`, `phone`                | `@reformer/core/validators` |
@@ -68,9 +69,12 @@
 > (`defineFormBehavior` + операторы) экспортируется из `@reformer/core/behaviors`, регистрирует cleanup
 > сам и передаётся в `createForm({ behavior })`. См. `20-compute-vs-watch.md`.
 
-> **Валидаторы — чистые фабрики.** `required()`, `min(50000)`, `email()` возвращают функцию
-> `(value) => ValidationError | null` и кладутся в поле схемы как `validators: [required(), min(50000)]`.
-> Валидация запускается через `validateFormModel(model, schema)` / `validateModel(model, schema)`.
+> **Валидация — отдельный слой.** Layout-схема `createForm` НЕ несёт валидаторов. Правила живут в
+> `defineValidationSchema<T>(({ model }) => { validate(model.$.x, [required(), min(50000)]); ... })`
+> из `@reformer/core/validation`; фабрики `required()`, `min(50000)`, `email()` возвращают
+> `Rule<T> = (value) => ValidationError | null` и передаются массивом в `validate(sig, [...])`.
+> Запуск — только внешним раннером `await validateModel(model, schema)` (`Promise<boolean>`, ошибки
+> сам роутит в ноды; `form.validate()`/`form.submit()` schema-валидацию НЕ гоняют).
 
 ### Type Values
 
@@ -110,11 +114,13 @@ const { value, errors, disabled } = useFormControl(control.loanType);
 
 Архитектура M1: сначала создаётся **модель данных** (`createModel`), затем **форма**
 (`createForm({ model, schema })`), где схема привязывает поля к сигналам модели
-(`model.$.field`). Валидаторы — чистые фабрики из `@reformer/core/validators`, лежат
-прямо в поле схемы (`validators: [...]`).
+(`model.$.field`). Layout-схема НЕ несёт валидаторов — валидация живёт в отдельной
+схеме `defineValidationSchema` из `@reformer/core/validation` и запускается внешним
+раннером `validateModel(model, schema)`.
 
 ```typescript
-import { createModel, createForm, validateFormModel, type FormProxy } from '@reformer/core';
+import { createModel, createForm, type FormProxy } from '@reformer/core';
+import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
 import { required, email } from '@reformer/core/validators';
 import { FormField, Input, Button } from '@reformer/ui-kit';
 
@@ -127,31 +133,37 @@ type ContactForm = {
 // 2. Model (источник истины значений)
 const model = createModel<ContactForm>({ name: '', email: '' });
 
-// 3. Schema: привязка поля к сигналу (model.$.field) + component/componentProps + validators
+// 3. Layout-schema: привязка поля к сигналу (model.$.field) + component/componentProps.
+//    БЕЗ validators — валидация в отдельной схеме (шаг 4).
 const schema = {
   name: {
     value: model.$.name,
     component: Input,
     componentProps: { label: 'Name', placeholder: 'Your name' },
-    validators: [required({ message: 'Name is required' })],
   },
   email: {
     value: model.$.email,
     component: Input,
     componentProps: { label: 'Email', type: 'email' },
-    validators: [required({ message: 'Email is required' }), email({ message: 'Invalid email' })],
   },
 };
 
-// 4. Form — ноды поверх сигналов модели
+// 4. Validation-schema — отдельный слой (@reformer/core/validation)
+const contactValidation = defineValidationSchema<ContactForm>(({ model }) => {
+  validate(model.$.name, [required({ message: 'Name is required' })]);
+  validate(model.$.email, [required({ message: 'Email is required' }), email({ message: 'Invalid email' })]);
+});
+
+// 5. Form — ноды поверх сигналов модели
 const form = createForm<ContactForm>({ model, schema });
 
-// 5. Use in React component — thin JSX, FormField does ALL heavy lifting
+// 6. Use in React component — thin JSX, FormField does ALL heavy lifting
 function ContactFormComponent() {
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
-    const result = await validateFormModel(model, schema);
-    if (result.valid) {
+    // form.submit()/validate() НЕ гоняют schema-валидацию — только внешний validateModel
+    const ok = await validateModel(model, contactValidation); // Promise<boolean>, ошибки сам роутит в ноды
+    if (ok) {
       console.log('Form submitted:', model.get());
     }
   };
@@ -165,7 +177,7 @@ function ContactFormComponent() {
   );
 }
 
-// 6. Pass form to child components via props (NOT context!)
+// 7. Pass form to child components via props (NOT context!)
 type FormStepProps = {
   form: FormProxy<ContactForm>;
 };
@@ -254,16 +266,19 @@ createForm<T>({ model, schema, behavior? }): FormProxy<T>
 // form.<field>.enable() / .disable() / .reset() / .markAsTouched() / .setErrors([...])
 // form.<field>.updateComponentProps({ ... })
 
-// Валидация данных (headless). schema — то же дерево, что в createForm.
-validateFormModel<T>(model, schema): Promise<{ valid: boolean; errors: Record<string, ValidationError[]> }>
-validateModel<T>(model, schema): Promise<{ valid; errors }>       // без роутинга ошибок в ноды
-validateModelSync<T>(model, schema): { valid; errors }             // async-валидаторы пропускаются
+// Валидация данных — ОТДЕЛЬНЫЙ контракт `@reformer/core/validation` (НЕ дерево createForm: то несёт
+// только layout, без validators). Схема — функция над моделью; внешний раннер разносит ошибки по нодам
+// формы (setErrors), warning не блокирует submit, устаревший прогон отменяется.
+validateModel<T>(model: FormModel<T>, schema: ValidationSchema<T>): Promise<boolean>   // из @reformer/core/validation
+// schema = defineValidationSchema<T>(({ model }) => { validate(...); ... })
+// ⚠️ form.submit() / form.validate() БОЛЬШЕ НЕ прогоняют schema-валидацию — гоняйте validateModel(model, schema) снаружи.
 ```
 
 ### Validators
 
-Валидаторы — **чистые фабрики**: возвращают функцию `(value) => ValidationError | null`.
-Кладутся в поле схемы как массив `validators: [required(), min(50000)]`.
+Валидаторы — **чистые фабрики** из `@reformer/core/validators`: возвращают правило `Rule<T>` =
+`(value) => ValidationError | null` (принимают nullable value). Передаются оператору
+`validate(sig, [required(), min(50000)])` внутри схемы валидации, а **не** в layout-дерево `createForm`.
 
 ```typescript
 required(options?: { message?: string })
@@ -291,89 +306,164 @@ minAge(years: number, options?: { message?: string })
 maxAge(years: number, options?: { message?: string })
 ```
 
-Использование в схеме:
+Использование: layout-дерево `createForm` привязывает поля к сигналам, правила живут отдельной
+`ValidationSchema` и гоняются раннером `validateModel` по требованию.
 
 ```typescript
 import { createModel, createForm } from '@reformer/core';
+import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
 import { required, min, max, email } from '@reformer/core/validators';
 
-const model = createModel<{ email: string; age: number; amount: number }>({
-  email: '', age: 0, amount: 0,
+type Loan = { email: string; age: number; amount: number };
+const model = createModel<Loan>({ email: '', age: 0, amount: 0 });
+
+// layout-схема createForm НЕ несёт validators — только привязка поля к сигналу + компонент
+const form = createForm({
+  model,
+  schema: {
+    email:  { value: model.$.email,  component: Input },
+    age:    { value: model.$.age,    component: Input },
+    amount: { value: model.$.amount, component: Input },
+  },
 });
 
-const schema = {
-  email:  { value: model.$.email,  component: Input, validators: [required(), email()] },
-  age:    { value: model.$.age,    component: Input, validators: [required(), min(18)] },
-  amount: { value: model.$.amount, component: Input, validators: [min(0), max(1000)] },
-};
+// правила — в ОТДЕЛЬНОЙ схеме валидации (не в layout)
+const loanValidation = defineValidationSchema<Loan>(({ model }) => {
+  validate(model.$.email,  [required(), email()]);
+  validate(model.$.age,    [required(), min(18)]);
+  validate(model.$.amount, [min(0), max(1000)]);
+});
 
-const form = createForm({ model, schema });
+const ok = await validateModel(model, loanValidation);   // Promise<boolean>; ошибки сами доедут до form.<field>.errors
 ```
 
 ### Custom & cross-field validators
 
-Кастомный валидатор — функция `(value, scope, root) => ValidationError | null | Promise<...>`
-(тип `ModelValidator`). `scope` — ближайшая под-модель (элемент массива или корень), `root` —
-корневая модель. Cross-field правило читает соседние поля через `root` и вешается на
-поле-носитель ошибки:
+Контракт валидации — `@reformer/core/validation`. Схема (`ValidationSchema<T>`) — обычная функция над
+(под)моделью; внутри вызываются свободные операторы, которые сами пишут ошибки в ноды текущего прогона
+(`getNodeForSignal(sig).setErrors(...)` — автор коллектора не видит).
+
+```typescript
+type Rule<T>      = (value: T, scope: never, root: never) => ValidationError | null;   // scope/root = never (см. ниже)
+type AsyncRule<T> = (value: T, ctx: { signal: AbortSignal }) => Promise<ValidationError | null>;
+type ValidationSchema<T> = (ctx: { model: FormModel<T> }) => void;
+```
+
+Операторы (ambient — валидны только внутри прогона `validateModel`):
+
+| Оператор | Назначение |
+|---|---|
+| `validate(sig, rules: Rule<T>[])` | синхронные правила поля |
+| `validateAsync(sig, rules: AsyncRule<T>[])` | асинхронные правила (раннер дожидается, прокидывает `AbortSignal`) |
+| `validateWhen(cond: () => boolean, cb: () => void)` | условная ветка: правила внутри активны/гасятся по `cond` (не трогает enable — это поведение) |
+| `cross(sig, fn: (form) => err \| null)` | cross-field; `fn` получает снапшот модели текущего scope (`model.get()`) |
+| `each(arr, itemFn: (im: FormModel<U>) => void)` | per-item по элементам массива модели |
+| `apply(...schemas: ValidationSchema<T>[])` | композиция под-схем над той же моделью |
+| `defineValidationSchema<T>(fn): ValidationSchema<T>` | тонкая identity-обёртка (типизация/discoverability) |
+| `validateModel<T>(model, schema): Promise<boolean>` | внешний раннер (warning не блокирует, устаревший прогон отменяется) |
+
+> `Rule<T>` намеренно несёт `scope: never, root: never` — так value-only фабрики (`required()` = `(value, model, root)`)
+> и inline `(value) => err` ОБА присваиваются в `Rule<T>[]`, сохраняя проверку типа поля
+> (`validate(model.$.age, [email()])` подсветится). Ментальная модель автора — `(value) => error`.
+
+Кастомные правила, cross-field и async — в схеме:
 
 ```typescript
-import type { ModelValidator } from '@reformer/core';
+import { type ValidationError } from '@reformer/core';
+import {
+  defineValidationSchema, validate, validateAsync, cross,
+  type Rule, type AsyncRule,
+} from '@reformer/core/validation';
+import { required } from '@reformer/core/validators';
 
-// Value-only
-const strongPassword: ModelValidator<string> = (value) =>
+type Signup = { password: string; confirm: string; email: string };
+
+// Value-only правило (Rule<T>)
+const strongPassword: Rule<string> = (value) =>
   !value || value.length < 8 ? { code: 'too-short', message: 'Минимум 8 символов' } : null;
 
-// Cross-field: сравниваем с другим полем через root
-const passwordsMatch: ModelValidator<string, unknown, { password: string }> = (value, _scope, root) =>
-  value && root.password && value !== root.password
+// Cross-field: обычная функция над снапшотом модели (model.get()), вешается через cross(sig, fn)
+const passwordsMatch = (f: Signup): ValidationError | null =>
+  f.confirm && f.password && f.confirm !== f.password
     ? { code: 'mismatch', message: 'Пароли не совпадают' }
     : null;
 
-// Async (проверка уникальности)
-const emailUnique: ModelValidator<string> = async (value) => {
+// Async (AsyncRule<T>): получает { signal }; сетевой сбой → null (submit не блокируется)
+const emailUnique: AsyncRule<string> = async (value, { signal }) => {
   if (!value) return null;
-  const res = await fetch(`/api/check-email?email=${encodeURIComponent(value)}`);
-  const { available } = await res.json();
-  return available ? null : { code: 'taken', message: 'Email уже зарегистрирован' };
+  try {
+    const res = await fetch(`/api/check-email?email=${encodeURIComponent(value)}`, { signal });
+    return (await res.json()).available ? null : { code: 'taken', message: 'Email уже зарегистрирован' };
+  } catch {
+    return null;
+  }
 };
 
-// в схеме
-const schema = {
-  password: { value: model.$.password, component: Input, validators: [strongPassword] },
-  confirm:  { value: model.$.confirm,  component: Input, validators: [passwordsMatch] },
-  email:    { value: model.$.email,    component: Input, validators: [emailUnique] },
-};
+const signupValidation = defineValidationSchema<Signup>(({ model }) => {
+  validate(model.$.password, [required(), strongPassword]);
+  validate(model.$.confirm, [required()]);
+  cross(model.$.confirm, passwordsMatch);        // ошибка вешается на confirm
+  validateAsync(model.$.email, [emailUnique]);
+});
 ```
 
-### Conditional & array validation (schema tree)
+### Conditional & array validation
 
-`validateFormModel` обходит дерево схемы. Кроме field-узлов (`{ value, validators }`) движок понимает:
+Условные ветки и массивы — операторы `validateWhen` / `each` / `apply` внутри схемы (не узлы дерева):
 
-- **условную ветку** `{ when: (scope, root) => boolean, children: [...] }` — поддерево валидируется
-  только при истинном `when`; при ложном ошибки полей ветки очищаются;
-- **секцию массива** — узел с `componentProps.itemComponent` (`(item) => subSchema`) и `componentProps.control`
-  (модель-массив с `at`/`length`) — валидируется per-item со scope = под-модель элемента.
+- **условная ветка** `validateWhen(() => cond, () => { validate(...) })` — правила внутри активны только
+  при истинном условии; при ложном ошибки полей ветки гасятся (`setErrors([])`). Enable/сброс поля — дело поведения;
+- **массив** `each(model.arr, (im) => { validate(im.$.field, [...]) })` — правила применяются к каждому
+  элементу; `im` — под-модель элемента. Для cross-field над элементом захватывайте снапшот в замыкание (`const item = im.get()`);
+- **композиция** `apply(...schemas)` — объединяет под-схемы над той же моделью (напр. полную схему из per-step).
 
 ```typescript
-// Условная валидация (branch node)
-const schema = {
-  children: [
-    { value: model.$.loanType, validators: [required()] },
-    {
-      when: (form) => form.loanType === 'mortgage',
-      children: [
-        { value: model.$.propertyValue, validators: [required(), min(1_000_000)] },
-        { value: model.$.initialPayment, validators: [required()] },
-      ],
+import {
+  defineValidationSchema, validate, validateWhen, cross, each, apply, validateModel,
+} from '@reformer/core/validation';
+import { required, min } from '@reformer/core/validators';
+
+// Условная валидация — ипотечная ветка активна только при loanType === 'mortgage'
+const step1 = defineValidationSchema<LoanForm>(({ model }) => {
+  validate(model.$.loanType, [required()]);
+  validateWhen(
+    () => model.loanType === 'mortgage',
+    () => {
+      validate(model.$.propertyValue, [required(), min(1_000_000)]);
+      validate(model.$.initialPayment, [required()]);
     },
-  ],
-};
+  );
+});
+
+// Per-item валидация элементов массива (each над ModelArray)
+const step5 = defineValidationSchema<LoanForm>(({ model }) => {
+  each(model.coBorrowers, (im) => {
+    const item = im.get();                          // снапшот элемента для cross
+    validate(im.$.income, [required(), min(10_000)]);
+    cross(im.$.income, () =>
+      item.income < item.loanShare ? { code: 'tooLow', message: 'Доход ниже доли' } : null);
+  });
+});
+
+// Полная схема формы = композиция шагов (apply над той же моделью)
+const formValidation = defineValidationSchema<LoanForm>(() => apply(step1, step5));
+```
+
+Wizard-конфиг (per-step + полная валидация) — поверх того же раннера `validateModel`:
+
+```typescript
+const STEP_SCHEMAS = [step1, /* step2, … */ step5] as const;
+
+function makeValidationConfig(model: FormModel<LoanForm>) {
+  return {
+    validateStep: (n: number) => validateModel(model, STEP_SCHEMAS[n - 1]),
+    validateAll: () => validateModel(model, formValidation),   // formValidation = apply(...STEP_SCHEMAS, extras)
+  };
+}
 ```
 
-> В примерах монорепо эти узлы собираются авторскими хелперами (`field`/`when`/`applyWhen`/`arraySection`)
-> — это **локальный typed-сахар в самом примере**, а не экспорт `@reformer/core`. Публичный API — сам
-> `validateFormModel(model, schema)` и форма узлов выше.
+Операторы `validate`/`validateAsync`/`validateWhen`/`cross`/`each`/`apply` экспортируются напрямую из
+`@reformer/core/validation` — это публичный API, а не локальный сахар примера.
 
 ### Behaviors
 
@@ -424,10 +514,18 @@ DSL-операторы: `compute` (auto-tracking, без явного списк
 `apply` (под-схема для группы), `applyEach` (per-item для массива), `exclusiveFlag`, `aggregateInto`.
 См. `20-compute-vs-watch.md`.
 
+Поведение **не владеет** валидацией — это отдельный слой. Мост «поведение инициирует валидацию» — через
+`revalidateWhen`, который просто вызывает внешний раннер валидации:
+
+```typescript
+revalidateWhen([model.$.dep], () => void validateModel(model, schema));
+```
+
 ## 4. 3. COMMON PATTERNS
 
-Все паттерны — на архитектуре M1: значения в модели (`model.$.field`), behaviors на сигналах,
-валидация через `validateFormModel`.
+Все паттерны — на архитектуре M1: значения в модели (`model.$.field`), поведение (`defineFormBehavior`)
+на живых сигналах, валидация — отдельной ambient-схемой (`defineValidationSchema`, прогон по требованию
+через `validateModel`). Слои раздельны: layout НЕ несёт validators.
 
 ### Conditional Fields with Auto-Reset
 
@@ -521,64 +619,104 @@ model.get();             // весь объект-снимок
 
 ### Submit + validation
 
+Валидация — отдельная `ValidationSchema<T>` (`defineValidationSchema`), а не часть layout. Раннер
+`validateModel(model, schema)` сам роутит ошибки в ноды формы и возвращает `Promise<boolean>`
+(`false` = есть блокирующая ошибка; `severity: 'warning'` не блокирует).
+
 ```typescript
-import { validateFormModel } from '@reformer/core';
+import { validateModel } from '@reformer/core/validation';
 
 async function handleSubmit(e: React.FormEvent) {
   e.preventDefault();
-  const result = await validateFormModel(model, schema); // ошибки роутятся в ноды формы
-  if (!result.valid) return;                             // result.errors — { path: ValidationError[] }
+  const ok = await validateModel(model, schema); // ошибки сами доезжают до нод формы (UI подсветит)
+  if (!ok) return;                               // false → есть блокирующая ошибка
   await api.send(model.get());
   model.reset(); // к initial-снимку
 }
 ```
 
-Multi-step: держи отдельные под-схемы на шаг и вызывай `validateFormModel(model, stepSchema)`.
-См. `13-multi-step.md`, `28-submit-and-reset.md`.
+Multi-step: держи отдельные под-схемы на шаг и вызывай `validateModel(model, stepSchema)`. Для wizard'а —
+`makeValidationConfig(model)` → `{ validateStep, validateAll }` (`validateAll` прогоняет полную
+`apply(...STEP_SCHEMAS, extras)`). См. `13-multi-step.md`, `28-submit-and-reset.md`.
 
-### Cross-field validation — через `root`
+### Cross-field validation — через `cross`
 
-Cross-field правило — `ModelValidator`, читает соседние поля через `root`, вешается на
-поле-носитель ошибки:
+Cross-field правило — обычная функция над **снапшотом** модели (`fn` получает `model.get()`),
+навешивается оператором `cross(sig, fn)` на поле-носитель ошибки внутри схемы:
 
 ```typescript
-import type { ModelValidator } from '@reformer/core';
+import { defineValidationSchema, validate, cross } from '@reformer/core/validation';
+import { required, min } from '@reformer/core/validators';
+import type { ValidationError } from '@reformer/core';
 
-const initialPaymentVsProperty: ModelValidator<number, unknown, MyForm> = (_value, _scope, root) =>
-  root.initialPayment && root.propertyValue && root.initialPayment > root.propertyValue
+// снапшот формы читается напрямую — без каста, соседние поля доступны как поля объекта
+const initialPaymentVsProperty = (f: MyForm): ValidationError | null =>
+  f.initialPayment && f.propertyValue && f.initialPayment > f.propertyValue
     ? { code: 'tooHigh', message: 'Взнос не может превышать стоимость' }
     : null;
 
-const schema = {
-  initialPayment: { value: model.$.initialPayment, component: Input, validators: [initialPaymentVsProperty] },
-};
+const schema = defineValidationSchema<MyForm>(({ model }) => {
+  validate(model.$.initialPayment, [required(), min(0)]);
+  cross(model.$.initialPayment, initialPaymentVsProperty); // ошибка сядет на initialPayment
+});
 ```
 
-Чтобы правило перезапускалось при изменении зависимости — добавь `revalidateWhen`:
+> Для элемента массива / под-модели захвати нужный снапшот в замыкание (`const item = im.get();
+> cross(im.$.x, () => rule(item))`) — `fn` всегда получает модель ТЕКУЩЕГО scope, а не под-модель.
+
+### Conditional validation — `validateWhen`
+
+Условная валидация — `validateWhen(() => cond, () => { … })`: правила внутри активны, только пока
+условие истинно; при `false` ранее тронутые поля гасятся. Это не `enable` (то — поведение), а
+включение/выключение самих проверок:
 
 ```typescript
-import { revalidateWhen } from '@reformer/core';
-revalidateWhen([model.$.propertyValue], () => validateFormModel(model, schema));
+import { validateWhen, validate, cross } from '@reformer/core/validation';
+
+validateWhen(
+  () => model.loanType === 'mortgage',
+  () => {
+    validate(model.$.propertyValue, [required(), min(1000000)]);
+    cross(model.$.initialPayment, initialPaymentVsProperty);
+  }
+);
+```
+
+### Перезапуск прогона — `revalidateWhen` (мост поведение → валидация)
+
+Схема прогоняется по требованию (submit/шаг). Чтобы перезапустить её при изменении зависимости —
+`revalidateWhen` из **поведения** (единственный мост поведение → валидация):
+
+```typescript
+import { defineFormBehavior, revalidateWhen } from '@reformer/core/behaviors';
+import { validateModel } from '@reformer/core/validation';
+
+const behavior = defineFormBehavior<MyForm>(({ model }) => {
+  revalidateWhen([model.$.propertyValue], () => void validateModel(model, schema));
+});
 ```
 
 ### Extracting named rules
 
-Когда тело кастомного валидатора или behavior-оператора растёт — выноси в именованную
-функцию, типизированную `ModelValidator<TField, TScope, TRoot>`. Схема остаётся плоской и
-читается как оглавление:
+Когда тело правила растёт — выноси в именованную функцию. Field-правило типизируй `Rule<T>`
+(`(value) => ValidationError | null`), cross-field — обычной `(f: Root) => ValidationError | null`.
+Схема остаётся плоской и читается как оглавление:
 
 ```typescript
-import type { ModelValidator } from '@reformer/core';
+import { defineValidationSchema, validate } from '@reformer/core/validation';
+import { required } from '@reformer/core/validators';
+import type { Rule } from '@reformer/core/validation';
 
-const validateAdultAge: ModelValidator<string> = (value) => {
+// field-правило: (value) => error
+const validateAdultAge: Rule<string> = (value) => {
   if (!value) return null;
   const age = new Date().getFullYear() - new Date(value).getFullYear();
   return age < 18 ? { code: 'tooYoung', message: 'Минимум 18 лет' } : null;
 };
 
-const schema = {
-  birthDate: { value: model.$.birthDate, component: Input, validators: [validateAdultAge] },
-};
+const schema = defineValidationSchema<MyForm>(({ model }) => {
+  validate(model.$.birthDate, [required(), validateAdultAge]);
+});
 ```
 
 **Naming convention** (camelCase, семантика, не эхо оператора):
@@ -590,26 +728,41 @@ const schema = {
 
 ### Imports rule (#1 cause of cascading errors — read first)
 
-- Модель/форма/валидация/хуки/типы/**примитивы behaviors** — из `@reformer/core`.
-- Чистые фабрики валидаторов — из `@reformer/core/validators`.
-- Декларативный DSL (`defineFormBehavior` + операторы) — из `@reformer/core/behaviors`.
+- Модель/форма/хуки/типы (`FormModel`, `ValidationError`)/**примитивы behaviors** — из `@reformer/core`.
+- Схема валидации (`defineValidationSchema` + операторы `validate`/`validateAsync`/`validateWhen`/`cross`/`each`/`apply`) и раннер `validateModel` — из `@reformer/core/validation`.
+- Чистые фабрики валидаторов (`required`/`min`/`email`/…) — из `@reformer/core/validators`.
+- Декларативный DSL поведения (`defineFormBehavior` + операторы) — из `@reformer/core/behaviors`.
 
 ```typescript
 // ✅ CORRECT
 import {
   createModel,
   createForm,
-  validateFormModel,
   useFormControl,
   useFormControlValue,
   type FormProxy,
   type FieldConfig,
-  type ModelValidator,
+  type FormModel,
+  type ValidationError,
 } from '@reformer/core';
+// схема валидации + раннер — отдельный слой:
+import {
+  defineValidationSchema,
+  validate,
+  validateAsync,
+  validateWhen,
+  cross,
+  each,
+  apply,
+  validateModel,
+  type Rule,
+  type AsyncRule,
+  type ValidationSchema,
+} from '@reformer/core/validation';
 import { required, min, max, email } from '@reformer/core/validators';
 // либо примитивы behaviors из основного пакета:
 import { computeFrom, enableWhen, copyFrom } from '@reformer/core';
-// либо декларативный DSL:
+// либо декларативный DSL поведения:
 import { defineFormBehavior, compute, onChange } from '@reformer/core/behaviors';
 ```
 
@@ -656,38 +809,56 @@ enableWhen(model.$.city, () => Boolean(model.country), { resetOnDisable: true })
 computeFrom([model.$.price, model.$.quantity], model.$.total, (price, qty) => price * qty);
 ```
 
-### Валидаторы — фабрики в массиве `validators`
+### Валидаторы — оператор `validate`, а не layout-нода
 
-```typescript
-// ❌ WRONG - нет операторов validate()/applyWhen(); строка вместо options
-validate(path.email, required(), 'Email is required');
+Валидация — **отдельный слой** (`@reformer/core/validation`), а не поле layout-ноды. Layout
+(схема `createForm` / JSON-DSL) больше **не несёт** `validators`: правила живут в `ValidationSchema`,
+а прогоняет их внешний раннер `validateModel`. ⚠️ `form.validate()`/`submit()` schema-валидацию
+**НЕ запускают** — прогон только через `validateModel(model, schema)`.
 
-// ✅ CORRECT - фабрика с options, в поле схемы
+```typescript
+// ❌ WRONG - дерево { value, validators } и позиционная строка удалены
 const schema = {
-  email: {
-    value: model.$.email,
-    component: Input,
-    validators: [required({ message: 'Email is required' }), email()],
-  },
+  email: { value: model.$.email, component: Input, validators: [required(), email()] },
 };
+validate(path.email, required(), 'Email is required'); // старая сигнатура validate() — удалена
+
+// ✅ CORRECT - операторы validate/validateAsync внутри defineValidationSchema; фабрики с options
+const emailSchema = defineValidationSchema<MyForm>(({ model }) => {
+  validate(model.$.email, [required({ message: 'Email is required' }), email()]);
+  validateAsync(model.$.email, [
+    async (value, { signal }) => {
+      const res = await fetch(`/api/free?email=${value}`, { signal });
+      return (await res.json()).free ? null : { code: 'taken', message: 'Email занят' };
+    },
+  ]);
+});
+
+// прогон по требованию (submit/шаг): ошибки сами доезжают до нод формы, warnings не блокируют
+const ok = await validateModel(model, emailSchema);
 ```
 
-### Cross-field — через `root`, а не `ctx.form`
+### Cross-field — оператор `cross`, а не `ctx.form`
 
 ```typescript
-// ❌ WRONG - ctx.form / ctx.setFieldValue / value.value — старый API, не существует
+// ❌ WRONG - ctx.form / ctx.setFieldValue / value.value — старый API; ModelValidator(value,scope,root) удалён
 watchField(path.amount, (amount, ctx) => {
   const rate = ctx.form.rate.value.value;
   ctx.setFieldValue('total', amount * rate);
 });
 
-// ✅ CORRECT - compute на сигналах; cross-field validator читает root
+// ✅ CORRECT - compute (поведение) на сигналах; cross-field (валидация) через оператор cross
 compute(model.$.total, () => (model.amount ?? 0) * (model.rate ?? 0));
 
-const amountVsMax: ModelValidator<number, unknown, MyForm> = (value, _s, root) =>
-  value != null && root.maxAmount != null && value > root.maxAmount
+// cross-field правило — обычная функция над снапшотом Root (`model.get()`), навешивается через cross(sig, fn):
+const amountVsMax = (f: MyForm): ValidationError | null =>
+  f.amount != null && f.maxAmount != null && f.amount > f.maxAmount
     ? { code: 'tooBig', message: 'Превышает лимит' }
     : null;
+
+const amountSchema = defineValidationSchema<MyForm>(({ model }) => {
+  cross(model.$.amount, amountVsMax); // fn получает model.get(), вешает ошибку на model.$.amount
+});
 ```
 
 ### Form-shape types — `type` over `interface`
@@ -731,20 +902,16 @@ if (isFieldNode(node)) { ... }
 | `enableWhen`/`disableWhen` не срабатывает              | Поле не материализовано в форме (элемент массива)        | Убедись, что поле есть в схеме `createForm`; для per-item — `applyEach` |
 | `Cycle detected`                                       | Взаимные `compute`/`computeFrom` без стабилизации        | Разорви цикл через условие `when` или `peek`; см. 22-cycle-detection.md |
 | Значение поля не пишется                               | Пишем в форму вместо модели                              | Значения принадлежат модели: `model.field = ...` / `model.$.field.value = ...` |
-| Ошибки не появляются после submit                      | Не вызвали `validateFormModel`                           | `await validateFormModel(model, schema)` — он роутит ошибки в ноды |
+| Ошибки не появляются после submit                      | Не вызвали `validateModel` (`form.submit()` НЕ гоняет schema-валидацию) | `await validateModel(model, schema)` из `@reformer/core/validation` — он роутит ошибки в ноды |
 
 ## 7. Import Patterns
 
 ```typescript
-// Модель, форма, валидация, хуки, типы, примитивы behaviors — из @reformer/core
+// Модель, форма, хуки, типы, примитивы behaviors — из @reformer/core
 import {
   // фабрики
   createModel,
   createForm,
-  // валидация данных (headless)
-  validateModel,
-  validateModelSync,
-  validateFormModel,
   // хуки
   useFormControl,
   useFormControlValue,
@@ -771,14 +938,30 @@ import type {
   ModelArray,       // реактивный массив модели (push/removeAt/at/map/length)
   ModelSignals,     // дерево сигналов ($)
   PathAwareSignal,  // сигнал, знающий свой путь
-  ModelValidator,   // (value, scope, root) => ValidationError | null
   ValidationError,
-  FieldConfig,      // { value, component, componentProps?, validators?, ... }
+  FieldConfig,      // { value, component, componentProps?, ... } — layout, БЕЗ валидаторов
   FormSchema,
   FieldControlState,
 } from '@reformer/core';
 
-// Валидаторы — чистые фабрики из /validators
+// Схема валидации: операторы + раннер — из /validation
+import {
+  defineValidationSchema,
+  validate,
+  validateAsync,
+  validateWhen,
+  cross,
+  each,
+  apply,
+  validateModel, // раннер: validateModel(model, schema) => Promise<boolean>
+} from '@reformer/core/validation';
+import type {
+  Rule,             // (value) => ValidationError | null
+  AsyncRule,        // (value, { signal }) => Promise<ValidationError | null>
+  ValidationSchema,
+} from '@reformer/core/validation';
+
+// Валидаторы — чистые фабрики из /validators (кладутся в validate(sig, [...]))
 import { required, min, max, email, minLength, pattern } from '@reformer/core/validators';
 
 // Декларативный DSL behaviors — из /behaviors
@@ -872,7 +1055,9 @@ const model = createModel<MyForm>({
 ## 9. 8. SCHEMA FORMAT (CRITICALLY IMPORTANT)
 
 Под M1 схема **привязывает поле к сигналу модели** (`value: model.$.field`) и держит
-UI-конфиг (`component`/`componentProps`) + валидаторы. Значения принадлежат модели.
+UI-конфиг (`component`/`componentProps`). Значения принадлежат модели. Валидаторов в
+layout-схеме НЕТ — правила живут в отдельной схеме `defineValidationSchema` из
+`@reformer/core/validation` и запускаются раннером `validateModel(model, schema)`.
 
 ### Field node
 
@@ -881,8 +1066,6 @@ UI-конфиг (`component`/`componentProps`) + валидаторы. Знач
   value: model.$.fieldName,   // сигнал модели (PathAwareSignal) — обязателен
   component: Input,           // React-компонент
   componentProps?: object,    // пропсы (label, placeholder, options, type, ...)
-  validators?: [...],         // чистые фабрики / ModelValidator
-  asyncValidators?: [...],    // async ModelValidator
   disabled?: boolean,
   updateOn?: 'change' | 'blur' | 'submit',
   debounce?: number,
@@ -897,17 +1080,22 @@ UI-конфиг (`component`/`componentProps`) + валидаторы. Знач
 
 ```typescript
 import { createModel, createForm } from '@reformer/core';
+import { defineValidationSchema, validate } from '@reformer/core/validation';
 import { required } from '@reformer/core/validators';
 import { Input, Select, Checkbox } from '@reformer/ui-kit';
 
 const model = createModel<MyForm>({ name: '', age: null, agree: false, status: 'active' });
 
+// Валидация — отдельным слоем (запуск: await validateModel(model, myValidation))
+const myValidation = defineValidationSchema<MyForm>(({ model }) => {
+  validate(model.$.name, [required()]);
+});
+
 const schema = {
   name: {
     value: model.$.name,
     component: Input,
     componentProps: { label: 'Name', placeholder: 'Enter name' },
-    validators: [required()],
   },
   age: {
     value: model.$.age,
@@ -1057,13 +1245,16 @@ const form = createForm<MyForm>({ model, schema });
    properties: { array: model.properties, item: propertyItem },
    ```
 
-2. **Validation-схема `validateFormModel`** — секция массива описывается через `componentProps`:
-   `{ componentProps: { control: model.<array>, itemComponent: (item) => subSchema } }`. Движок
-   узнаёт секцию по `componentProps.itemComponent` + `control` и обходит её per-item.
+2. **Validation-схема (`@reformer/core/validation`)** — per-item правила пишутся оператором
+   `each(arr, (im) => {...})` внутри `defineValidationSchema`; `im` — под-модель элемента
+   (`im.$.field` — его сигналы). Запуск — внешним `validateModel(model, schema)`.
 
    ```typescript
-   // узел схемы для validateFormModel(model, schema)
-   { componentProps: { control: model.properties, itemComponent: propertyRules } }
+   // внутри defineValidationSchema<MyForm>(({ model }) => { ... })
+   each(model.properties, (im) => {
+     validate(im.$.description, [required()]);
+     validate(im.$.estimatedValue, [required(), min(1)]);
+   });
    ```
 
 3. **CDK / render** — работают с уже **материализованной** нодой `form.<array>` (`ModelArrayNode`),
@@ -1071,9 +1262,9 @@ const form = createForm<MyForm>({ model, schema });
    `@reformer/ui-kit` (`control={form.properties}`, `itemComponent`).
 
 > **Не путай форму по движку.** `createForm` принимает **только** `{ array, item }`;
-> `componentProps.{ control, itemComponent }` — это форма validation-схемы; `FormArray.Root
-> control={form.x}` (или `FormArraySection`) — рендер. `control`/`itemComponent` в layout-схеме
-> `createForm` не подхватятся, а `{ array, item }` схема валидации не обходит.
+> per-item валидация — это `each(model.<array>, (im) => ...)` в validation-схеме; `FormArray.Root
+> control={form.x}` (или `FormArraySection`) — рендер. `each` в layout-схеме `createForm`
+> не подхватится, а `{ array, item }` в validation-схеме не обходится.
 
 ### Array operations — на модели
 
@@ -1141,25 +1332,30 @@ function ItemsList({ form }: { form: FormProxy<MyForm> }) {
 
 ### Array Cross-Validation
 
-Cross-field правило по массиву пишется как `ModelValidator`, читает элементы через `root`,
-вешается на поле-носитель ошибки (или на первый элемент). Секции массива в схеме валидации
-обходятся per-item движком `validateFormModel` (см. `03-api-signatures.md`).
+Whole-array правило пишется оператором `cross(sig, (f) => ...)`: `f` — снапшот `model.get()`
+(плоские значения), ошибка вешается на поле-носитель `sig`. Per-item правила — `each`
+(см. выше, оба — из `@reformer/core/validation`).
+
+Носитель — любое **скалярное** поле формы (флаг `hasItems`, итоговая сумма и т.п.), у которого
+есть сигнал `model.$.<field>` и нода в форме:
 
 ```typescript
-import type { ModelValidator } from '@reformer/core';
+import { cross } from '@reformer/core/validation';
 
-// уникальность имён по массиву
-const uniqueNames: ModelValidator<unknown, unknown, MyForm> = (_value, _scope, root) => {
-  const names = root.items.map((i) => i.name);
+type MyForm = { hasItems: boolean; items: Item[] };
+
+// внутри defineValidationSchema<MyForm>(({ model }) => { ... })
+cross(model.$.hasItems, (f: MyForm) => {
+  const names = f.items.map((i) => i.name);
   return names.length !== new Set(names).size
     ? { code: 'duplicate', message: 'Item names must be unique' }
     : null;
-};
+});
 ```
 
 ## 11. See also
 
-- [03-api-signatures.md](./03-api-signatures.md) — сигнатуры нод `form.<array>` / `ModelArray`, per-item обход `validateFormModel`
+- [03-api-signatures.md](./03-api-signatures.md) — сигнатуры нод `form.<array>` / `ModelArray`, per-item валидация `each`
 - CDK / ui-kit form-array (`FormArray.Root`, `FormArraySection`) — `find_recipe(topic="form-array")`
 
 ## 12. 10. ASYNC REACTION — onChange (CRITICALLY IMPORTANT)
@@ -1250,54 +1446,69 @@ clearWhenOff(model.$.hasProperty, model.properties);
 
 ## 14. 12. MULTI-STEP FORM VALIDATION
 
-Каждый шаг — своя под-схема валидации (дерево узлов `{ children: [...] }`). Переход к
-следующему шагу проверяется `validateFormModel(model, stepSchema)`; полный submit — по
-общей схеме (объединение шагов). `validateFormModel` роутит ошибки в ноды формы, поэтому
-UI подсветит проблемные поля текущего шага автоматически.
+Каждый шаг — своя `ValidationSchema<Form>` (обычная функция `({ model }) => void`, обёрнутая
+`defineValidationSchema`). Переход к следующему шагу проверяется `validateModel(model, stepSchema)`;
+полный submit — по общей схеме (композиция шагов через `apply(...)`). `validateModel` сам разносит
+ошибки по нодам формы (`getNodeForSignal(sig).setErrors(...)`), поэтому UI подсветит проблемные поля
+текущего шага автоматически. Валидация живёт ОТДЕЛЬНО от layout: сам `RenderNode`/JSON-узел валидаторов
+не несёт — схема инъектируется в рантайме и роутит ошибки по тем же нодам.
 
 ```typescript
-import { validateFormModel, type FormModel } from '@reformer/core';
+import { type FormModel } from '@reformer/core';
+import {
+  validate,
+  apply,
+  defineValidationSchema,
+  validateModel,
+  type ValidationSchema,
+} from '@reformer/core/validation';
 import { required, min } from '@reformer/core/validators';
 
-// Под-схема шага: дерево field-узлов { value, validators }
-const step1Schema = (m: FormModel<Form>) => ({
-  children: [
-    { value: m.$.loanType, validators: [required()] },
-    { value: m.$.loanAmount, validators: [required(), min(50000)] },
-  ],
+// Под-схема шага — обычная функция ({ model }) => void. Значения проверяет оператор validate(sig, [rules]).
+const step1Schema = defineValidationSchema<Form>(({ model }) => {
+  validate(model.$.loanType, [required()]);
+  validate(model.$.loanAmount, [required(), min(50000)]);
 });
 
-const step2Schema = (m: FormModel<Form>) => ({
-  children: [
-    { value: m.$.personalData.firstName, validators: [required()] },
-    { value: m.$.personalData.lastName, validators: [required()] },
-  ],
+const step2Schema = defineValidationSchema<Form>(({ model }) => {
+  validate(model.$.personalData.firstName, [required()]);
+  validate(model.$.personalData.lastName, [required()]);
 });
 
-// Карта шагов + полная схема (объединение)
-const STEP_SCHEMAS = [step1Schema, step2Schema];
-const fullSchema = (m: FormModel<Form>) => ({
-  children: STEP_SCHEMAS.map((build) => build(m)),
-});
+// Карта шагов + полная схема (композиция под-схем через apply — заменяет пошаговую группировку деревом)
+const STEP_SCHEMAS: readonly ValidationSchema<Form>[] = [step1Schema, step2Schema];
+const fullSchema = defineValidationSchema<Form>(() => apply(...STEP_SCHEMAS));
 ```
 
 ```typescript
-// Переход к следующему шагу
+// Переход к следующему шагу. validateModel возвращает Promise<boolean> (true = нет блокирующих ошибок;
+// severity:'warning' не блокирует). Устаревшие прогоны той же (model, schema) отменяются автоматически.
 const goToNextStep = async () => {
-  const result = await validateFormModel(model, STEP_SCHEMAS[currentStep - 1](model));
-  if (!result.valid) return; // ошибки уже проставлены в ноды текущего шага
+  const ok = await validateModel(model, STEP_SCHEMAS[currentStep - 1]);
+  if (!ok) return; // ошибки уже проставлены в ноды текущего шага
   setCurrentStep(currentStep + 1);
 };
 
-// Полный submit
+// Полный submit — по общей схеме
 const handleSubmit = async () => {
-  const result = await validateFormModel(model, fullSchema(model));
-  if (result.valid) {
+  const ok = await validateModel(model, fullSchema);
+  if (ok) {
     await onSubmit(model.get());
   }
 };
 ```
 
+Слой-потребитель (`FormWizard`) обычно оборачивает это в конфиг с per-step и полной валидацией:
+
+```typescript
+function makeValidationConfig(model: FormModel<Form>) {
+  return {
+    validateStep: (n: number): Promise<boolean> => validateModel(model, STEP_SCHEMAS[n - 1]),
+    validateAll: (): Promise<boolean> => validateModel(model, fullSchema),
+  };
+}
+```
+
 ### Multi-Step Component Example
 
 ```tsx
@@ -1305,8 +1516,8 @@ function MultiStepForm() {
   const [step, setStep] = useState(1);
 
   const nextStep = async () => {
-    const result = await validateFormModel(model, STEP_SCHEMAS[step - 1](model));
-    if (result.valid) setStep(step + 1);
+    const ok = await validateModel(model, STEP_SCHEMAS[step - 1]);
+    if (ok) setStep(step + 1);
   };
 
   return (
@@ -1385,27 +1596,44 @@ compute(model.$.b, () => model.a + 1); // расходится → Cycle detecte
 compute(model.$.total, () => model.price * model.qty); // одно направление
 ```
 
-### Cross-field валидация — через `root`
+### Cross-field валидация — через `cross(sig, fn)`
+
+Cross-field живёт в схеме валидации (`@reformer/core/validation`), а не в layout: правило вешается на
+ПОЛЕ-НОСИТЕЛЬ ошибки оператором `cross(sig, fn)`, а `fn` читает снапшот текущего scope (`model.get()`).
 
 ```typescript
-import type { ModelValidator } from '@reformer/core';
+import { defineValidationSchema, validate, cross, validateModel } from '@reformer/core/validation';
+import { required } from '@reformer/core/validators';
+import { revalidateWhen, type ValidationError } from '@reformer/core';
 
-// Правило вешается на ПОЛЕ-НОСИТЕЛЬ ошибки. Соседние поля читаются через root.
-const field1LessThanField2: ModelValidator<number, unknown, Form> = (_value, _scope, root) =>
+// ❌ старое (УДАЛЕНО): дерево { value, validators }, ModelValidator (value, scope, root), validateFormModel
+const legacyRule: ModelValidator<number, unknown, Form> = (_value, _scope, root) =>
   root.field1 > root.field2 ? { code: 'error', message: 'Invalid' } : null;
+const legacySchema = { field1: { value: model.$.field1, component: Input, validators: [legacyRule] } };
+validateFormModel(model, legacySchema);
 
-const schema = {
-  field1: { value: model.$.field1, component: Input, validators: [field1LessThanField2] },
-};
+// ✅ новое: cross-правило — обычная функция над снапшотом (model.get()), не читает scope/root
+const field1LessThanField2 = (f: Form): ValidationError | null =>
+  f.field1 > f.field2 ? { code: 'error', message: 'Invalid' } : null;
 
-// Чтобы правило перезапускалось при изменении field2:
-import { revalidateWhen } from '@reformer/core';
-revalidateWhen([model.$.field2], () => validateFormModel(model, schema));
+const schema = defineValidationSchema<Form>(({ model }) => {
+  validate(model.$.field1, [required()]);
+  cross(model.$.field1, field1LessThanField2); // правило на поле-носителе ошибки
+});
+
+// Прогон — ТОЛЬКО внешним раннером; ошибки сами доезжают до нод формы.
+// ⚠️ form.validate()/submit() схему валидации больше НЕ прогоняют.
+await validateModel(model, schema);
+
+// Перезапуск правила при изменении соседнего поля — мост «поведение → валидация»:
+revalidateWhen([model.$.field2], () => void validateModel(model, schema));
 ```
 
-> **Удалённый API.** Операторы `validate`/`validateAsync`/`applyWhen`/`apply` (валидации),
-> `validateGroup`/`validateTree`/`validateForm`, типы `FieldPath`/`ValidationSchemaFn`/`BehaviorSchemaFn`
-> и `ctx.form.*`/`ctx.setFieldValue` — из старой path-based архитектуры и УДАЛЕНЫ. См. `17-nonexistent-api.md`.
+> **Актуальный vs удалённый API.** Операторы валидации `validate`/`validateAsync`/`validateWhen`/`cross`/`each`/`apply`
+> ТЕПЕРЬ существуют — в `@reformer/core/validation` с новыми сигнатурами (ambient, активны только внутри прогона
+> `validateModel`). УДАЛЕНЫ: `applyWhen`, `validateGroup`/`validateTree`/`validateForm`/`validateFormModel`,
+> типы `FieldPath`/`ValidationSchemaFn`/`BehaviorSchemaFn` и `ctx.form.*`/`ctx.setFieldValue` (наследие
+> path-based архитектуры). См. `17-nonexistent-api.md`.
 
 ## 16. 14. PROJECT STRUCTURE (COLOCATION)
 
@@ -1500,7 +1728,7 @@ forms/
     ├── schema/                   # The form definition
     │   ├── model.ts             # createModel factory + initial values + array-element factories
     │   ├── schema.ts            # createForm schema tree ({ value: model.$.x, component })
-    │   ├── validation.ts        # validation schema + validateFormModel config
+    │   ├── validation.ts        # defineValidationSchema + validateModel config ({ validateStep, validateAll })
     │   ├── behavior.ts          # defineFormBehavior(...)
     │   └── create-form.ts       # Assembly: createForm({ model, schema, behavior })
     │
@@ -1692,6 +1920,11 @@ function MyFormField<T>({ control }: MyFormFieldProps<T>) {
 
 ### Integration with UI libraries (shadcn etc.)
 
+> **Через рендерер — без обёртки.** Если ты рендеришь форму через `@reformer/renderer-react` /
+> `@reformer/renderer-json`, вместо ручной обёртки на каждый контрол можно зарегистрировать сырой
+> компонент и передать `settings.resolveFieldAdapter` — рендерер сам сведёт value-seam к диалекту
+> контрола. Ручная обёртка на `useFormControl` (ниже) нужна для прямого JSX без рендерера.
+
 Если есть существующая design system — оборачивай её компоненты в один
 `MyFormField` (как выше) и используй один прop `control`. Не множь обёртки на
 тип input'а — пусть `componentProps.type` диспатчит внутри.
@@ -1720,22 +1953,28 @@ function ShadcnFormField({ control }: { control: FieldNode<string> }) {
 
 ## 18. 15. NON-EXISTENT API (DO NOT USE)
 
-**Следующего API НЕТ в @reformer/core** (частично — наследие старой path-based архитектуры,
-удалено при переходе на M1):
+**Следующего API НЕТ в @reformer/core** (наследие старой path-based архитектуры,
+удалено при переходе на M1 и при разделении валидации/поведения):
+
+> ⚠️ Операторы валидации `validate`/`validateAsync`/`validateWhen`/`cross`/`each`/`apply`
+> **существуют** — но живут в сабпути `@reformer/core/validation` (ambient-схема
+> `defineValidationSchema(({ model }) => …)`, раннер `validateModel`), а НЕ в корне и НЕ
+> в `@reformer/core/validators`. Ниже перечислено то, чего действительно нет.
 
 | Wrong                            | Correct                                          | Notes                                          |
 | -------------------------------- | ------------------------------------------------ | ---------------------------------------------- |
 | `useForm`                        | `createModel` + `createForm`                     | Хука useForm нет                               |
-| `validate`, `validateAsync`      | `validators: [...]` в схеме + `validateFormModel`| Операторов валидации нет; валидаторы — фабрики |
-| `applyWhen`, `apply` (валидация) | branch-узел `{ when, children }` в схеме         | Условная валидация — узлом дерева схемы         |
-| `validateItems`, `validateGroup`, `validateTree` | секция массива в схеме + `ModelValidator` | Удалены                                  |
-| `validateForm`                   | `validateFormModel(model, schema)`               | Legacy-движок удалён                            |
-| `ValidationSchemaFn`, `BehaviorSchemaFn` | `defineFormBehavior` / `ModelValidator`  | Типы path-схем удалены                          |
+| `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-схему валидации |
 | `FieldPath`, `FieldPathNode`     | `model.$.field` (`PathAwareSignal`)              | Пути заменены сигналами                         |
 | `ctx.form.x.value.value`         | `model.x` / `model.$.x.value`                    | В behaviors читаем модель напрямую              |
 | `ctx.setFieldValue(name, value)` | `model.x = value` / `compute(...)`               | Не существует                                   |
 | `transformers`, `createTransformer` | `transformValue(signal, fn)`                  | Готового набора трансформеров нет               |
-| `equalTo`, `custom`, `notEmpty`, `date` (validators) | кастомный `ModelValidator`   | Таких фабрик нет; пиши функцию `(value, scope, root)` |
 | `useHiddenCondition`             | `useFormControlValue` + условный рендер в JSX    | Хука нет                                        |
 | `FormProvider`, `control` prop, `register()` | `<Component form={form} />`, `useFormControl(form.field)` | Форма передаётся через props |
 | `getFieldValue()`                | `model.field` / `useFormControlValue(form.field)`| Не существует                                   |
@@ -1743,33 +1982,49 @@ function ShadcnFormField({ control }: { control: FieldNode<string> }) {
 ### Common Import Errors
 
 ```typescript
-// WRONG - эти символы НЕ существуют
-import { useForm, validateForm } from '@reformer/core';           // NO!
-import { validate, applyWhen, equalTo } from '@reformer/core/validators'; // NO!
-import { transformers } from '@reformer/core/behaviors';          // NO!
-import type { FieldPath, ValidationSchemaFn } from '@reformer/core'; // NO!
+// WRONG - этих символов / путей НЕ существует
+import { useForm, validateForm, validateFormModel } from '@reformer/core';        // NO!
+import { validate, applyWhen, equalTo } from '@reformer/core/validators';         // NO! операторов тут нет
+import { transformers } from '@reformer/core/behaviors';                          // NO!
+import type { FieldPath, ValidationSchemaFn } from '@reformer/core';              // NO!
 
 // CORRECT
-import { createModel, createForm, validateFormModel, useFormControl } from '@reformer/core';
-import { required, email, min } from '@reformer/core/validators';
-import { defineFormBehavior, compute, onChange } from '@reformer/core/behaviors';
-import type { FieldConfig, FieldNode, ModelValidator } from '@reformer/core';
+import { createModel, createForm, useFormControl } from '@reformer/core';
+import type { FormModel, ValidationError, FieldConfig } from '@reformer/core';
+// Операторы валидации + раннер + defineValidationSchema — отдельный сабпуть:
+import {
+  validate, validateAsync, validateWhen, cross, each, apply,
+  defineValidationSchema, validateModel,
+  type Rule, type AsyncRule, type ValidationSchema,
+} from '@reformer/core/validation';
+// Фабрики-валидаторы (value-only, принимают nullable):
+import { required, email, min, minLength, pattern } from '@reformer/core/validators';
+// Поведение (отдельный слой, контракт не менялся):
+import { defineFormBehavior, compute, onChange, revalidateWhen } from '@reformer/core/behaviors';
 ```
 
 ### Schema Common Mistakes
 
+Валидация и layout — **разные** контракты. Layout-узел привязывает поле к сигналу и
+НЕ несёт `validators`; правила живут в отдельной `defineValidationSchema`.
+
 ```typescript
-// WRONG - примитивные значения / value-литерал не работают под M1
+// WRONG - примитив/литерал вместо сигнала, и validators прямо в layout-узле
 const schema = {
-  name: '',                       // нет привязки к сигналу
-  email: { value: '', ... },      // value должен быть model.$.email, а не литерал
+  name:  '',                                       // нет привязки к сигналу
+  email: { value: '', validators: [required()] },  // value — литерал, а validators в layout больше нет
 };
 
-// CORRECT - каждое поле привязано к сигналу модели
-const schema = {
+// CORRECT - layout только связывает поле с сигналом модели...
+const layout = {
   name:  { value: model.$.name,  component: Input, componentProps: { label: 'Name' } },
   email: { value: model.$.email, component: Input, componentProps: { label: 'Email' } },
 };
+
+// ...а правила — отдельная ambient-схема (прогоняется раннером validateModel):
+const validation = defineValidationSchema<Form>(({ model }) => {
+  validate(model.$.email, [required({ message: 'Email обязателен' }), email()]);
+});
 ```
 
 ### Behaviors Common Mistakes
@@ -1782,6 +2037,14 @@ enableWhen(path.city, (form) => Boolean(form.country));
 enableWhen(model.$.city, () => Boolean(model.country), { resetOnDisable: true });
 ```
 
+Поведение **не владеет** валидацией. Чтобы поведение инициировало прогон схемы — мост
+`revalidateWhen` (validate/submit сами схему не запускают):
+
+```typescript
+// CORRECT - поведение дёргает внешний раннер валидации при изменении зависимости
+revalidateWhen([model.$.password], () => void validateModel(model, validation));
+```
+
 ## 19. Purpose
 
 «Показать поле X только если Y» под M1 решается тремя независимыми механизмами — выбирай по
@@ -1789,12 +2052,13 @@ enableWhen(model.$.city, () => Boolean(model.country), { resetOnDisable: true })
 
 1. **Видимость / доступность** (поле остаётся в модели, но выключается/включается и не валидируется)
    — behaviors: `enableWhen`, а для условной записи значения — `compute` / `copyFrom` с опцией `{ when }`.
-2. **Условная валидация** (правила применяются только в истинной ветке) — нативный branch-узел
-   схемы `{ when, children }`, исполняется `validateFormModel`.
+2. **Условная валидация** (правила применяются только в истинной ветке) — оператор
+   `validateWhen(() => cond, () => {…})` внутри схемы `defineValidationSchema`, прогоняется раннером `validateModel`.
 3. **Скрытие из разметки** (узел вообще не рендерится) — `useFormControlValue` + условный рендер в JSX.
 
-> Ни `applyWhen`, ни `ValidationSchemaFn` **не экспортируются** из `@reformer/core` — см. раздел
-> [Не экспорт (частая ошибка)](#не-экспорт-частая-ошибка) и `17-nonexistent-api.md`.
+> Условная **валидация** — оператор `validateWhen` из `@reformer/core/validation`; старого branch-узла
+> `{ when, children }` и хелпера `applyWhen` больше нет — см.
+> [Anti-patterns удалённого контракта валидации](#anti-patterns-удалённого-контракта-валидации) и `17-nonexistent-api.md`.
 
 ## 20. Видимость и доступность
 
@@ -1850,35 +2114,42 @@ export const creditBehavior = defineFormBehavior<CreditForm>(({ model }) => {
 
 ## 21. Условная валидация
 
-Правила, действующие только при выполнении условия, задаются **нативным branch-узлом**
-`{ when: (scope, root) => boolean, children: [...] }` прямо в дереве схемы. `validateFormModel`
-обходит дерево: при истинном `when` валидирует `children`, при ложном — **поддерево пропускается,
-а ошибки его полей очищаются** (движок вызывает `setErrors([])`). `scope` — ближайшая под-модель
-(элемент массива или корень), `root` — корневая модель формы.
+Правила, действующие только при выполнении условия, оборачиваются оператором
+`validateWhen(() => cond, () => {…})` внутри схемы `defineValidationSchema<T>(({ model }) => …)`.
+Условие `cond` читает модель напрямую (`model.field` — снимок на момент прогона): при истинном условии
+раннер применяет вложенные `validate`/`cross`/…, при ложном — правила ветки **гасятся** (поля,
+затронутые ранее, получают `setErrors([])`). Прогон — внешним раннером
+`validateModel(model, schema): Promise<boolean>` (ошибки сами роутятся в ноды формы).
 
 ```typescript
-import { validateFormModel } from '@reformer/core';
+import {
+  validate,
+  validateWhen,
+  defineValidationSchema,
+  validateModel,
+} from '@reformer/core/validation';
 import { required, min } from '@reformer/core/validators';
 
-const schema = {
-  children: [
-    { value: model.$.loanType, validators: [required()] },
-    {
-      // ветка применяется только для ипотеки
-      when: (_scope, root) => root.loanType === 'mortgage',
-      children: [
-        { value: model.$.propertyValue, validators: [required(), min(1_000_000)] },
-        { value: model.$.initialPayment, validators: [required()] },
-      ],
+const schema = defineValidationSchema<CreditForm>(({ model }) => {
+  validate(model.$.loanType, [required()]);
+
+  // ветка применяется только для ипотеки
+  validateWhen(
+    () => model.loanType === 'mortgage',
+    () => {
+      validate(model.$.propertyValue, [required(), min(1_000_000)]);
+      validate(model.$.initialPayment, [required()]);
     },
-  ],
-};
+  );
+});
 
-const { valid, errors } = await validateFormModel(model, schema);
+const ok: boolean = await validateModel(model, schema);
 ```
 
 Переключение `loanType` с `mortgage` на другой тип автоматически снимает ошибки `required` с
-`propertyValue`/`initialPayment` — их держать enabled и не валидировать помогает `enableWhen` выше.
+`propertyValue`/`initialPayment` — при ложном условии ветка `validateWhen` гасит их (`setErrors([])`).
+`validateWhen` управляет только **валидацией**; чтобы поля ещё и выпадали из состояния (сброс
+значения), держи их под `enableWhen` из раздела выше — слои независимы.
 
 ## 22. Скрытие в JSX
 
@@ -1902,42 +2173,57 @@ function MortgageFields({ form }: { form: CreditForm }) {
 ```
 
 Скрытие в JSX — чисто визуальное: если поле должно ещё и **выпадать из валидации/состояния**,
-сочетай его с `enableWhen({ resetOnDisable: true })` (доступность) или branch-узлом (валидация).
+сочетай его с `enableWhen({ resetOnDisable: true })` (доступность) или `validateWhen` (валидация).
 
-## 23. Не экспорт (частая ошибка)
+## 23. Anti-patterns удалённого контракта валидации
 
-- **`applyWhen` — это ЛОКАЛЬНЫЙ typed-хелпер примера, а не экспорт `@reformer/core`.** Он лишь
-  эмитит нативный branch-узел `{ when, children }`. Каноничное определение (см.
-  `complex-multy-step-form/schemas/validation.ts`):
+Условную валидацию раньше собирали иначе; эти формы удалены при переходе на `@reformer/core/validation`.
+Ниже — **как НЕ надо** (чтобы не регрессировать); рабочий вариант — `validateWhen` из раздела выше.
+
+- **Нет branch-узла `{ when, children }` в дереве схемы.** Старая схема была деревом
+  `{ value, validators: [...] }` с ветками `{ when: (scope, root) => boolean, children: [...] }`,
+  которое обходил `validateFormModel`. Теперь схема — функция `({ model }) => void`, а условие —
+  оператор `validateWhen(() => cond, () => {…})`; отдельного объекта-узла нет.
 
   ```typescript
-  // локальный сахар в самом примере — НЕ импорт из библиотеки
-  const applyWhen = (cond: (form: Root) => boolean, children: SchemaNode[]): SchemaNode => ({
-    when: (_scope: unknown, root: unknown) => cond(root as Root),
-    children,
-  });
+  // УДАЛЕНО — так больше нельзя
+  const schema = {
+    children: [
+      { value: model.$.loanType, validators: [required()] },
+      { when: (_s, root) => root.loanType === 'mortgage', children: [ /* … */ ] },
+    ],
+  };
+  await validateFormModel(model, schema); // символа нет
   ```
 
-  Публичный API — сам `validateFormModel(model, schema)` и форма узла `{ when, children }`.
-  Не пиши `import { applyWhen } from '@reformer/core'` — такого символа нет.
+- **`applyWhen` не существует** — ни как экспорт, ни как локальный сахар: он эмитил branch-узел,
+  которого больше нет. Оборачивай условные правила оператором `validateWhen`.
+
+- **`ValidationSchemaFn` удалён** (тип старой path-схемы). Тип схемы — `ValidationSchema<T>`
+  (`(ctx: { model: FormModel<T> }) => void`), фабрика-обёртка — `defineValidationSchema<T>(fn)`.
 
-- **`ValidationSchemaFn` не существует** (тип старой path-схемы удалён при переходе на M1). Тип
-  кастомного/cross-field валидатора — **`ModelValidator<TValue, TModel, TRoot>`**:
+- **Cross-field — обычная функция над снапшотом, а не `ModelValidator (value, scope, root)`.**
+  Соседние поля читаются из снимка модели (`f: Root`, эквивалент `model.get()`), а правило навешивается
+  оператором `cross(sig, fn)`. Каноничное использование — `complex-multy-step-form/schemas/validation.ts`.
 
   ```typescript
-  import type { ModelValidator } from '@reformer/core';
+  import { cross } from '@reformer/core/validation';
+  import type { ValidationError } from '@reformer/core';
 
-  // (value, scope, root) — cross-field читает соседей через root
-  const passwordsMatch: ModelValidator<string, unknown, { password: string }> = (value, _scope, root) =>
-    value && root.password && value !== root.password
+  // (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: 'Пароли не совпадают' }
       : null;
+
+  // внутри defineValidationSchema — fn получает снапшот текущего scope (model.get()):
+  cross(model.$.confirmPassword, passwordsMatch);
   ```
 
 ## 24. See also
 
-- [03-api-signatures.md](./03-api-signatures.md) — сигнатуры `enableWhen`/`compute`/`copyFrom`, branch-узел, `ModelValidator`
-- [17-nonexistent-api.md](./17-nonexistent-api.md) — полный список удалённого API (`applyWhen`, `ValidationSchemaFn`, …)
+- [03-api-signatures.md](./03-api-signatures.md) — сигнатуры `enableWhen`/`compute`/`copyFrom` (поведение) и `validate`/`validateWhen`/`cross`/`validateModel` (валидация)
+- [17-nonexistent-api.md](./17-nonexistent-api.md) — полный список удалённого API (`applyWhen`, `ValidationSchemaFn`, `validateFormModel`, …)
 - [25-reset-when.md](./25-reset-when.md) — `resetWhen` как альтернатива, когда поле остаётся enabled
 - [19-reading-values.md](./19-reading-values.md) — `useFormControlValue` и чтение значений в React
 
@@ -2235,17 +2521,23 @@ aggregateInto(model.$.rows, (rows) => {
 
 ### Array Cross-Validation
 
-Cross-field правило по массиву — `ModelValidator`, читает элементы через `root`:
+Whole-array правило — оператор `cross(sig, (f) => ...)` из `@reformer/core/validation`:
+`f` — снапшот `model.get()`, ошибка вешается на скалярное поле-носитель `sig`. Per-item
+правила — `each(model.<array>, (im) => ...)`.
 
 ```typescript
-import type { ModelValidator } from '@reformer/core';
+import { cross } from '@reformer/core/validation';
+import type { ValidationError } from '@reformer/core';
 
-const percentagesSumTo100: ModelValidator<unknown, unknown, MyForm> = (_v, _s, root) => {
-  const total = root.items.reduce((sum, i) => sum + (i.percentage || 0), 0);
+const percentagesSumTo100 = (f: MyForm): ValidationError | null => {
+  const total = f.items.reduce((sum, i) => sum + (i.percentage || 0), 0);
   return Math.abs(total - 100) > 0.01
     ? { code: 'invalid_total', message: 'Percentages must sum to 100%' }
     : null;
 };
+
+// внутри defineValidationSchema<MyForm>(({ model }) => { ... })
+cross(model.$.totalPercent, percentagesSumTo100); // носитель — скалярное поле формы
 ```
 
 ## 28. Как устроено под M1
@@ -2840,12 +3132,14 @@ A: Симптом частых записей. Форматирование с
 `revalidateWhen` вызывает переданный колбэк ревалидации, когда изменяется любая из
 зависимостей. Применяется, когда правило зависит от значений других полей
 (`amount <= maxAmount`, `confirmPassword === password`, `initialPayment >= propertyValue * 0.2`).
-Под M1 валидация on-demand (`validateFormModel`), поэтому ревалидация выражается явным
-колбэком, а не автоматической привязкой к полю.
+Валидация — отдельная функция-схема (`@reformer/core/validation`), прогоняемая по требованию через
+`validateModel(model, schema)`. Поэтому ревалидация выражается явным колбэком, а не автоматической
+привязкой к полю: поведение (`revalidateWhen`) лишь _инициирует_ прогон схемы валидации при изменении зависимости.
 
 ## 57. API
 
-Одинаково в примитиве (`@reformer/core`) и DSL (`@reformer/core/behaviors`):
+`revalidateWhen` — оператор поведения (`@reformer/core/behaviors`, либо примитив `@reformer/core`).
+Его сигнатура НЕ зависит от контракта валидации:
 
 ```typescript
 // примитив: возвращает cleanup
@@ -2856,8 +3150,8 @@ function revalidateWhen(deps: ReadonlySignal<unknown>[], revalidate: () => void)
 ```
 
 `deps` — массив сигналов-триггеров (`model.$.field`). `revalidate` — колбэк (обычно
-`() => validateFormModel(model, schema)`). Вызывается при изменении любой зависимости
-(НЕ на инициализации), вне effect-контекста.
+`() => void validateModel(model, schema)`, где `schema` — `defineValidationSchema<T>(({ model }) => …)`).
+Вызывается при изменении любой зависимости (НЕ на инициализации), вне effect-контекста.
 
 ## 58. Examples
 
@@ -2865,27 +3159,29 @@ function revalidateWhen(deps: ReadonlySignal<unknown>[], revalidate: () => void)
 
 ```typescript
 import { defineFormBehavior, revalidateWhen } from '@reformer/core/behaviors';
-import { validateFormModel } from '@reformer/core';
+import { validateModel } from '@reformer/core/validation';
 
 export const paymentBehavior = defineFormBehavior<PaymentForm>(({ model }) => {
   revalidateWhen([model.$.maxAmount], () => {
-    void validateFormModel(model, paymentSchema);
+    void validateModel(model, paymentSchema);
   });
 });
 ```
 
-Пример: `revalidateWhen([model.$.maxAmount], () => validateFormModel(model, schema))`.
+Пример: `revalidateWhen([model.$.maxAmount], () => void validateModel(model, paymentSchema))`.
+Схема `paymentSchema` — стабильный module-level `const` (важно для отмены устаревших прогонов
+в `validateModel`), где правило amount навешано через `cross(model.$.amount, amountVsMax)`.
 
 ### Несколько триггеров
 
 ```typescript
 import { defineFormBehavior, revalidateWhen } from '@reformer/core/behaviors';
-import { validateFormModel } from '@reformer/core';
+import { validateModel } from '@reformer/core/validation';
 
 export const mortgageBehavior = defineFormBehavior<MortgageForm>(({ model }) => {
   // initialPayment зависит и от propertyValue, и от loanAmount
   revalidateWhen([model.$.propertyValue, model.$.loanAmount], () => {
-    void validateFormModel(model, mortgageSchema);
+    void validateModel(model, mortgageSchema);
   });
 });
 ```
@@ -2894,13 +3190,14 @@ export const mortgageBehavior = defineFormBehavior<MortgageForm>(({ model }) =>
 
 ```typescript
 import { defineFormBehavior, revalidateWhen } from '@reformer/core/behaviors';
-import { validateFormModel } from '@reformer/core';
+import { validateModel } from '@reformer/core/validation';
 
-// правило совпадения — cross-field ModelValidator на confirmPassword (см. 03-api-signatures.md)
+// правило совпадения — cross-field в схеме: cross(model.$.confirmPassword, passwordsMatch),
+// где passwordsMatch читает снапшот формы (см. 03-api-signatures.md)
 export const registrationBehavior = defineFormBehavior<RegistrationForm>(({ model }) => {
   // при смене password перевалидируем схему (confirm перепроверится)
   revalidateWhen([model.$.password], () => {
-    void validateFormModel(model, registrationSchema);
+    void validateModel(model, registrationSchema);
   });
 });
 ```
@@ -2908,55 +3205,68 @@ export const registrationBehavior = defineFormBehavior<RegistrationForm>(({ mode
 ### Как примитив (вне defineFormBehavior)
 
 ```typescript
-import { revalidateWhen, validateFormModel } from '@reformer/core';
-const stop = revalidateWhen([model.$.maxAmount], () => void validateFormModel(model, schema));
+import { revalidateWhen } from '@reformer/core';
+import { validateModel } from '@reformer/core/validation';
+
+const stop = revalidateWhen([model.$.maxAmount], () => void validateModel(model, schema));
 ```
 
 ## 59. Anti-patterns
 
 ```typescript
 // ❌ Триггер == поле, которое и так меняется само
-revalidateWhen([model.$.amount], () => validateFormModel(model, schema));
+revalidateWhen([model.$.amount], () => validateModel(model, schema));
 // amount и так валидируется при собственном изменении в общем прогоне
 
 // ✅ Триггеры — ДРУГИЕ поля, от которых зависит правило amount
-revalidateWhen([model.$.maxAmount, model.$.discount], () => validateFormModel(model, schema));
+revalidateWhen([model.$.maxAmount, model.$.discount], () => validateModel(model, schema));
 ```
 
 ```typescript
 // ❌ Правило только через revalidateWhen, но в схеме нет зависимости от триггера
-revalidateWhen([model.$.maxAmount], () => validateFormModel(model, schema));
+revalidateWhen([model.$.maxAmount], () => validateModel(model, schema));
 // а валидатор amount — статичный max(1000), не читает maxAmount
 
-// ✅ Сначала cross-field ModelValidator, читающий root, потом revalidateWhen
-const amountVsMax: ModelValidator<number, unknown, Form> = (v, _s, root) =>
-  v != null && root.maxAmount != null && v > root.maxAmount ? { code: 'tooBig', message: '...' } : null;
-// amount: { value: model.$.amount, validators: [amountVsMax] }
-revalidateWhen([model.$.maxAmount], () => validateFormModel(model, schema));
+// ✅ Сначала cross-field правило (читает снапшот формы) в схеме валидации, потом revalidateWhen
+const amountVsMax = (f: Form): ValidationError | null =>
+  f.amount != null && f.maxAmount != null && f.amount > f.maxAmount
+    ? { code: 'tooBig', message: '...' }
+    : null;
+
+const schema = defineValidationSchema<Form>(({ model }) => {
+  cross(model.$.amount, amountVsMax); // навешиваем правило на поле amount
+});
+revalidateWhen([model.$.maxAmount], () => void validateModel(model, schema));
 ```
 
 ## 60. Troubleshooting
 
 **Q: Ошибка target не пропадает после изменения триггера.**
-A: Проверьте, что (1) правило реально читает значение триггера через `root` (cross-field
-`ModelValidator`); (2) в `deps` передан именно сигнал (`model.$.trigger`); (3) колбэк вызывает
-`validateFormModel` (роутит ошибки в ноды).
+A: Проверьте, что (1) правило реально читает значение триггера — cross-field `cross(sig, fn)`,
+где `fn` берёт снапшот формы (`model.get()` / `f`); (2) в `deps` передан именно сигнал (`model.$.trigger`);
+(3) колбэк вызывает `validateModel` (роутит ошибки в ноды через `getNodeForSignal(sig).setErrors`).
 
 **Q: Как перевалидировать только одно поле, а не всю схему?**
-A: Передай в колбэк под-схему только этого поля: `validateFormModel(model, { children: [fieldNode] })`.
+A: Схема — обычная функция, поэтому опиши стабильную под-схему только для этого поля и прогони её:
+`validateModel(model, oneFieldSchema)`, где
+`const oneFieldSchema = defineValidationSchema<Form>(({ model }) => cross(model.$.amount, amountVsMax))`.
+Раннер выставит/погасит ошибки только затронутых полей (гашение накапливается на пару `(model, schema)`).
 
 ## 61. See also
 
-- [03-api-signatures.md](./03-api-signatures.md) — cross-field `ModelValidator` и `validateFormModel`
+- [03-api-signatures.md](./03-api-signatures.md) — cross-field `cross(sig, fn)` и раннер `validateModel`
 - [28-submit-and-reset.md](./28-submit-and-reset.md) — полная валидация формы
 - [20-compute-vs-watch.md](./20-compute-vs-watch.md) — реактивные производные значения
 
 ## 62. Purpose
 
-Канонический submit-флоу под M1: «запустить полную валидацию данных (`validateFormModel`) →
-проверить `result.valid` → достать снимок (`model.get()`) → сделать запрос → `model.reset()`».
-Валидация — чистая функция ДАННЫХ (модели), она же роутит ошибки в ноды формы, поэтому UI
-подсветит проблемные поля. `model.reset()` возвращает значения к initial-снимку.
+Канонический submit-флоу под M1: «запустить полную валидацию данных (`validateModel`) →
+проверить `boolean`-результат → достать снимок (`model.get()`) → сделать запрос → `model.reset()`».
+Валидация — **отдельный слой** (`@reformer/core/validation`, схема через `defineValidationSchema`), она
+НЕ входит в layout-дерево, которое получает `createForm`. Раннер `validateModel(model, schema)` сам роутит
+ошибки в ноды формы, поэтому UI подсветит проблемные поля, а наружу вернёт лишь `boolean`
+(false = есть блокирующая ошибка; `severity:'warning'` показывается, но submit не блокирует).
+`model.reset()` возвращает значения к initial-снимку.
 
 ## 63. API
 
@@ -2971,13 +3281,23 @@ interface ModelApi<T> {
   captureInitial(): void;           // зафиксировать текущие как новый initial
 }
 
-// Валидация данных (headless, роутит ошибки в ноды формы):
-validateFormModel<T>(model, schema): Promise<{ valid: boolean; errors: Record<string, ValidationError[]> }>
+// Валидация данных — headless-раннер: находит ноды по сигналам модели, роутит в них ошибки,
+// отменяет устаревшие прогоны той же (model, schema). Возвращает ТОЛЬКО boolean:
+validateModel<T>(model: FormModel<T>, schema: ValidationSchema<T>): Promise<boolean>
+// true  = нет блокирующих ошибок (severity:'warning' не блокирует, но показывается).
+// false = есть блокирующая ошибка; она уже проставлена в ноду → UI подсветит поле.
 
-// Нода поля (для точечной работы с UI-состоянием):
-form.<field>.setErrors([{ code, message }]);
-form.<field>.markAsTouched();
-form.<field>.reset();
+// Схема валидации — отдельный слой над моделью (не смешивается с layout):
+defineValidationSchema<T>(({ model }) => {
+  validate(model.$.field, [rules]);          // синхронные правила поля
+  // validateAsync / validateWhen / cross / each / apply — см. contract-spec
+}): ValidationSchema<T>
+
+// Нода поля/формы (для точечной работы с UI-состоянием):
+form.markAsTouched();                         // тронуть все поля (показать ошибки)
+form.clearErrors();                           // снять ошибки со всех нод
+form.<field>.setErrors([{ code, message }]);  // серверная/бизнес-ошибка в конкретное поле
+form.<field>.clearErrors();
 ```
 
 ## 64. Examples
@@ -2986,23 +3306,34 @@ form.<field>.reset();
 
 ```tsx
 import { useMemo } from 'react';
-import { createModel, createForm, validateFormModel } from '@reformer/core';
+import { createModel, createForm } from '@reformer/core';
+import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
+import { required, email, minLength } from '@reformer/core/validators';
 
 type RegistrationFormData = { username: string; email: string; password: string };
 
+// Валидация — отдельная схема над моделью. НЕ входит в layout, который получает createForm.
+// Стабильная module-level `const`-ссылка — чтобы validateModel мог отменять устаревшие прогоны.
+const registrationSchema = defineValidationSchema<RegistrationFormData>(({ model }) => {
+  validate(model.$.username, [required({ message: 'Имя обязательно' }), minLength(3)]);
+  validate(model.$.email, [required({ message: 'Email обязателен' }), email()]);
+  validate(model.$.password, [required({ message: 'Пароль обязателен' }), minLength(8)]);
+});
+
 function RegistrationForm() {
-  const { model, form, schema } = useMemo(() => {
+  const { model, form } = useMemo(() => {
     const m = createModel<RegistrationFormData>({ username: '', email: '', password: '' });
-    const s = buildSchema(m);
-    return { model: m, form: createForm({ model: m, schema: s }), schema: s };
+    // schema здесь — layout-дерево нод (компоненты/раскладка), без валидаторов.
+    return { model: m, form: createForm({ model: m, schema: buildLayout(m) }) };
   }, []);
 
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
+    form.markAsTouched(); // показать ошибки на всех полях
 
-    // Шаг 1: валидация данных (ошибки автоматически проставятся в ноды → UI подсветит)
-    const result = await validateFormModel(model, schema);
-    if (!result.valid) return;
+    // Шаг 1: прогон валидации данных. Ошибки автоматически проставятся в ноды → UI подсветит.
+    const valid = await validateModel(model, registrationSchema);
+    if (!valid) return;
 
     // Шаг 2: достать чистые данные и отправить
     const payload = model.get();
@@ -3032,9 +3363,10 @@ function RegistrationForm() {
 ```tsx
 async function handleSubmit(e: React.FormEvent) {
   e.preventDefault();
+  form.markAsTouched();
 
-  const result = await validateFormModel(model, schema);
-  if (!result.valid) return;
+  const valid = await validateModel(model, registrationSchema);
+  if (!valid) return;
 
   try {
     const response = await api.register(model.get());
@@ -3078,39 +3410,61 @@ function ActionButtons({ model }: { model: FormModel<RegistrationFormData> }) {
 
 ### Использование вне React (server action / Node)
 
-Валидация headless — работает без UI/нод:
+Раннер headless — работает без UI-компонентов, только с моделью и схемой:
 
 ```typescript
-import { createModel, validateModel } from '@reformer/core';
+import { createModel } from '@reformer/core';
+import { validateModel } from '@reformer/core/validation';
 
 async function processFormPayload(rawData: Partial<MyForm>) {
   const model = createModel<MyForm>(initialValues);
   model.patch(rawData); // частичный load данных
 
-  const result = await validateModel(model, schema); // без нод — просто данные
-  if (!result.valid) return { ok: false, errors: result.errors };
-  return { ok: true, data: model.get() };
+  // validateModel находит ноды по сигналам модели и роутит в них ошибки, возвращая boolean.
+  const valid = await validateModel(model, myFormSchema);
+  if (!valid) return { ok: false as const };
+  return { ok: true as const, data: model.get() };
 }
 ```
 
 ## 65. Anti-patterns
 
 ```typescript
-// ❌ Чтение результата валидации без await
+// ❌ Обращение к .valid: раннер возвращает boolean, а не { valid, errors }
+const result = await validateModel(model, schema);
+if (!result.valid) return; // result — boolean, .valid === undefined → guard никогда не сработает
+
+// ✅ Результат — сам boolean
+const valid = await validateModel(model, schema);
+if (!valid) return;
+```
+
+```typescript
+// ❌ Чтение результата валидации без await — сабмитим по неполному вердикту
 const handleSubmit = (e) => {
   e.preventDefault();
-  validateFormModel(model, schema); // не дождались async-валидаторов
+  validateModel(model, schema); // Promise проигнорирован, async-валидаторы не дождались
   submit(model.get());
 };
 
-// ✅ Дождаться и проверить result.valid
+// ✅ Дождаться и проверить boolean
 const handleSubmit = async (e) => {
   e.preventDefault();
-  const result = await validateFormModel(model, schema);
-  if (result.valid) submit(model.get());
+  if (await validateModel(model, schema)) submit(model.get());
 };
 ```
 
+```typescript
+// ❌ Валидаторы в layout-дереве, отдаваемом в createForm — layout не несёт правил
+createForm({ model, schema: { username: { value: '', validators: [required()] } } });
+
+// ✅ Валидация — отдельная схема, прогоняется раннером
+const schema = defineValidationSchema<T>(({ model }) => {
+  validate(model.$.username, [required()]);
+});
+await validateModel(model, schema);
+```
+
 ```typescript
 // ❌ model.reset() до ответа сервера — потеря данных при ошибке
 await api.send(model.get());
@@ -3137,7 +3491,13 @@ model.reset();
 
 **Q: После `reset()` в UI остались старые ошибки.**
 A: `model.reset()` меняет значения; ошибки в нодах чистит валидация. Перезапусти
-`validateFormModel(model, schema)` после reset, либо очисти точечно `form.field.setErrors([])`.
+`validateModel(model, schema)` после reset (валидные поля погаснут сами), либо очисти напрямую —
+`form.clearErrors()` / `form.<field>.clearErrors()`.
+
+**Q: `validateModel` вернул `true`, но в поле висит ошибка.**
+A: Это правило с `severity: 'warning'` — оно показывается, но submit не блокирует, поэтому раннер
+и вернул `true`. Блокируют только ошибки без `severity` (default). Чтобы не пускать submit при
+warning — проверяй его отдельно, вне `validateModel`.
 
 **Q: `reset()` не возвращает данные, загруженные с сервера.**
 A: `reset()` возвращает к initial-снимку (значения на момент `createModel`). `set/patch` НЕ
@@ -3151,8 +3511,9 @@ A: `model.get()` возвращает значения всех полей. Фи
 ## 67. See also
 
 - [29-async-preload.md](./29-async-preload.md) — initial values и preload через `set`/`patch`
-- [13-multi-step.md](./13-multi-step.md) — пошаговая валидация через `validateFormModel`
-- [03-api-signatures.md](./03-api-signatures.md) — сигнатуры модели и `validateFormModel`
+- [13-multi-step.md](./13-multi-step.md) — пошаговая валидация через `validateModel` (`validateStep`/`validateAll`)
+- [27-revalidate-when.md](./27-revalidate-when.md) — мост «поведение → валидация»: `revalidateWhen([deps], () => void validateModel(model, schema))`
+- [03-api-signatures.md](./03-api-signatures.md) — сигнатуры модели и `validateModel`
 - [05-common-mistakes.md](./05-common-mistakes.md) — типичные ошибки
 
 ## 68. Purpose
@@ -3330,7 +3691,7 @@ useEffect(() => {
 ## 72. Troubleshooting
 
 **Q: После `set`/`patch` не показываются ошибки.**
-A: `set`/`patch` не запускают валидацию. После загрузки вызови `await validateFormModel(model, schema)`.
+A: `set`/`patch` не запускают валидацию. После загрузки вызови `await validateModel(model, schema)` (внешний раннер из `@reformer/core/validation`).
 
 **Q: Опции в `<Select>` не появляются после `updateComponentProps`.**
 A: (1) Оберни вызов в `queueMicrotask`; (2) убедись, что компонент подписан через `useFormControl`;
@@ -3353,7 +3714,8 @@ A: `reset()` возвращает к initial-снимку из `createModel`, н
 
 ### Recipe 1 — Imports (root cause prevention)
 
-- Модель/форма/валидация/хуки/типы/**примитивы behaviors** — из `@reformer/core`.
+- Модель/форма/хуки/типы/**примитивы behaviors** — из `@reformer/core`.
+- Схема валидации (операторы + раннер `validateModel`) — из `@reformer/core/validation`.
 - Чистые фабрики валидаторов — из `@reformer/core/validators`.
 - Декларативный DSL (`defineFormBehavior` + операторы) — из `@reformer/core/behaviors`.
 
@@ -3361,12 +3723,17 @@ A: `reset()` возвращает к initial-снимку из `createModel`, н
 import {
   createModel,
   createForm,
-  validateFormModel,
   type FormModel,
   type FormProxy,
   type ModelSignals,
-  type ModelValidator,
 } from '@reformer/core';
+import {
+  defineValidationSchema,
+  validate,
+  cross,
+  validateModel,
+  type Rule,
+} from '@reformer/core/validation';
 import { required, min, max, email } from '@reformer/core/validators';
 import { defineFormBehavior, compute, enableWhen, onChange } from '@reformer/core/behaviors';
 ```
@@ -3396,38 +3763,40 @@ export type CreditApplicationForm = {
 ### Recipe 3 — Схема привязана к сигналам модели
 
 `value` поля — это сигнал модели (`model.$.field`), а не литерал. Тип поля выводится из сигнала.
+Layout-схема БЕЗ валидаторов — правила живут в отдельной validation-схеме.
 
 ```typescript
 const model = createModel<CreditApplicationForm>(initial);
 
 const schema = {
-  loanAmount: { value: model.$.loanAmount, component: Input, validators: [required(), min(50000)] },
+  loanAmount: { value: model.$.loanAmount, component: Input },
   // вложенная группа — builder, принимающий ModelSignals<Sub>
   personalData: personalDataNodes(model.$.personalData),
   // массив — { array, item }
   properties: { array: model.properties, item: propertyItem },
 };
+
+// правила — отдельно; типы полей выводятся из сигналов
+const validation = defineValidationSchema<CreditApplicationForm>(({ model }) => {
+  validate(model.$.loanAmount, [required(), min(50000)]);
+});
 ```
 
-### Recipe 4 — Cross-field валидаторы: типизированный `ModelValidator`
+### Recipe 4 — Cross-field валидаторы: `cross` над типизированным снапшотом
 
-Правило — `ModelValidator<TField, TScope, TRoot>`. `root` типизирован формой, соседние поля
-читаются без `as`:
+Правило — обычная функция `(f: Root) => ValidationError | null` над снапшотом `model.get()`.
+Соседние поля читаются без `as`; ошибка вешается на поле-носитель `sig`:
 
 ```typescript
-import type { ModelValidator } from '@reformer/core';
+import type { ValidationError } from '@reformer/core';
 
-const initialPaymentVsProperty: ModelValidator<number, unknown, CreditApplicationForm> = (
-  _value,
-  _scope,
-  root
-) =>
-  root.initialPayment && root.propertyValue && root.initialPayment > root.propertyValue
+const initialPaymentVsProperty = (f: CreditApplicationForm): ValidationError | null =>
+  f.initialPayment && f.propertyValue && f.initialPayment > f.propertyValue
     ? { code: 'tooHigh', message: 'Взнос не может превышать стоимость' }
     : null;
 
-// в схеме:
-initialPayment: { value: model.$.initialPayment, component: Input, validators: [initialPaymentVsProperty] };
+// внутри defineValidationSchema<CreditApplicationForm>(({ model }) => { ... }):
+cross(model.$.initialPayment, initialPaymentVsProperty);
 ```
 
 ### Recipe 5 — `compute` читает модель напрямую (без аннотаций)
@@ -3476,18 +3845,19 @@ function MyField<T>({ control }: MyFieldProps<T>) {
 
 ### Recipe 8 — Вынос правил в именованные функции
 
-Cross-field и field-правила — именованные `ModelValidator`, схема остаётся плоской:
+Field-правила — именованные `Rule<T>`, validation-схема остаётся плоской:
 
 ```typescript
-const validateAdultAge: ModelValidator<string> = (value) => {
+import type { Rule } from '@reformer/core/validation';
+
+const validateAdultAge: Rule<string | null> = (value) => {
   if (!value) return null;
   const age = new Date().getFullYear() - new Date(value).getFullYear();
   return age < 18 ? { code: 'tooYoung', message: 'Минимум 18 лет' } : null;
 };
 
-const schema = {
-  birthDate: { value: model.$.birthDate, component: Input, validators: [validateAdultAge] },
-};
+// внутри defineValidationSchema<MyForm>(({ model }) => { ... }):
+validate(model.$.birthDate, [validateAdultAge]);
 ```
 
 ### Anti-patterns to avoid
@@ -3501,76 +3871,138 @@ const schema = {
 ## 75. 31. ASYNC VALIDATOR
 
 Для проверок типа «уникальность email», «валидация ИНН через API», «проверка адреса» —
-async-валидатор это `ModelValidator`, возвращающий `Promise<ValidationError | null>`. Он
-исполняется движком `validateFormModel`/`validateModel` (async-задачи прогоняются параллельно
-через `Promise.all`).
+async-правило это `AsyncRule<T>` = `(value, { signal }) => Promise<ValidationError | null>`.
+Оно регистрируется оператором `validateAsync(sig, [asyncRules])` внутри схемы валидации
+(`@reformer/core/validation`) и исполняется внешним раннером `validateModel` (async-правила
+прогоняются параллельно через `Promise.all`, раннер их дожидается).
+
+Слои разделены: layout (`createForm`-схема / JSON) НЕ несёт валидаторов — правила живут в
+отдельной функции-схеме `defineValidationSchema<T>(({ model }) => …)`.
 
 ```ts
-import { createModel, createForm, validateFormModel, type ModelValidator } from '@reformer/core';
+import { createModel } from '@reformer/core';
+import {
+  validate,
+  validateAsync,
+  defineValidationSchema,
+  validateModel,
+  type AsyncRule,
+} from '@reformer/core/validation';
 import { required, email } from '@reformer/core/validators';
-import { Input } from '@reformer/ui-kit';
 
-// async-валидатор: (value, scope, root) => Promise<ValidationError | null>
-const checkEmailUnique: ModelValidator<string> = async (value) => {
+// async-правило: (value, { signal }) => Promise<ValidationError | null>.
+// `signal` — AbortSignal устаревшего прогона: прокинь его в fetch, чтобы отменить in-flight.
+const checkEmailUnique: AsyncRule<string> = async (value, { signal }) => {
   if (!value) return null; // пусто = валидно (sync `required` отдельно)
   try {
-    const res = await fetch(`/api/check-email?email=${encodeURIComponent(value)}`);
+    const res = await fetch(`/api/check-email?email=${encodeURIComponent(value)}`, { signal });
     const { available } = (await res.json()) as { available: boolean };
     return available ? null : { code: 'email-taken', message: 'Email уже зарегистрирован' };
   } catch {
-    return { code: 'check-failed', message: 'Не удалось проверить email' };
+    return null; // сетевой сбой/отмена НЕ блокирует submit — возвращаем null, а не ошибку
   }
 };
 
 const model = createModel<{ email: string }>({ email: '' });
-const schema = {
-  email: {
-    value: model.$.email,
-    component: Input,
-    // sync-фабрики и async-валидатор в одном массиве validators
-    validators: [required(), email(), checkEmailUnique],
-  },
-};
-const form = createForm({ model, schema });
+
+// Схема — обычная функция над моделью; sync и async — разными операторами на одном сигнале.
+const schema = defineValidationSchema<{ email: string }>(({ model }) => {
+  validate(model.$.email, [required(), email()]); // sync-фабрики
+  validateAsync(model.$.email, [checkEmailUnique]); // async-правило
+});
+
+// Прогон по требованию (submit / шаг):
+const ok = await validateModel(model, schema); // Promise<boolean>
 ```
 
 ### Как это исполняется
 
-1. `validateFormModel(model, schema)` собирает field-задачи и прогоняет их валидаторы.
-2. Для каждого поля валидаторы выполняются по порядку; async-валидаторы `await`-ятся.
-3. `validateModelSync(model, schema)` — синхронный вариант: async-валидаторы **пропускаются**
-   (для мгновенных проверок без сети).
-4. Ошибки роутятся в ноды формы (`form.field.errors`), UI подсвечивает поле.
+1. `validateModel(model, schema)` открывает ambient-окно и **синхронно** прогоняет схему:
+   `validate`/`validateAsync`/`cross` регистрируют правила своих полей.
+2. Sync-правила выполняются сразу; async-правила из `validateAsync` собираются и после закрытия
+   ambient-окна дожидаются параллельно (`Promise.all`) с прокинутым `AbortSignal`.
+3. Ошибки роутятся в ноды формы (`getNodeForSignal(sig).setErrors(...)`), UI подсвечивает поле;
+   поля, ставшие валидными, гасятся (`setErrors([])`).
+4. Возвращает `Promise<boolean>` — `true`, если нет блокирующих ошибок (`severity:'warning'`
+   не блокирует). Устаревший (отменённый) прогон возвращает `false` — ему нельзя доверять для submit.
+
+Синхронного варианта у нового контракта нет: раннер один — `validateModel`, и он всегда `async`.
 
-### Отдельное поле `asyncValidators`
+### Sync и async — два оператора
 
-В схеме можно разделить sync и async: `validators: [...]` и `asyncValidators: [...]`. Оба типа
-поддерживаются `FieldConfig`. На практике удобнее держать всё в `validators` — движок сам
-различает sync/async по возвращаемому `Promise`.
+Разделение sync/async делается не полем схемы, а разными операторами на одном сигнале:
+`validate(sig, [syncRules])` и `validateAsync(sig, [asyncRules])`. Раннер прогоняет sync-правила
+инлайн, а async — дожидается. Держи async-правило дешёвым: ранний `if (!value) return null`
+пропускает сетевой вызов, пока `required()`/формат ещё не пройдены.
+
+```ts
+validate(model.$.inn, [required(), pattern(/^\d{12}$/)]); // формат — sync, мгновенно
+validateAsync(model.$.inn, [checkInnInRegistry]); // обращение к API — отдельным оператором
+```
 
 ### UI integration
 
-`FormField` из `@reformer/ui-kit` показывает индикатор проверки, пока идёт async-валидация
-(`useFormControl(...).pending === true`):
+`validateModel(...)` возвращает `Promise<boolean>` — индикатор проверки держи вокруг этого
+`await`. Раннер схемы **не** выставляет per-field `pending` на ноде (он роутит только ошибки через
+`setErrors`), поэтому спиннер async-валидации — это собственный флаг (обычно form-level, как
+`ui.pending` в submit-флоу, или локальный state компонента):
 
 ```tsx
-const { pending, errors } = useFormControl(form.email);
-return pending ? <Spinner /> : errors.length ? <Error errors={errors} /> : null;
+const [checking, setChecking] = useState(false);
+
+const runValidation = async (): Promise<boolean> => {
+  setChecking(true);
+  try {
+    return await validateModel(model, schema);
+  } finally {
+    setChecking(false);
+  }
+};
+
+return checking ? <Spinner /> : errors.length ? <Error errors={errors} /> : null;
 ```
 
 ### Debounce и отмена
 
-- Валидация запускается on-demand (на submit / шаг / через `revalidateWhen`), а не на каждый
-  keystroke — отдельный `debounce` в валидаторе обычно не нужен.
-- Если нужно дебаунсить дорогой async-валидатор относительно частых изменений, вешай его через
-  `revalidateWhen([...], () => validateFormModel(...))` и оборачивай запуск в собственный debounce.
-- Cross-field async — обычный `ModelValidator`, читающий соседние поля через `root`.
+- **Отмена устаревших — раннером, бесплатно.** Быстрый повторный `validateModel(model, schema)`
+  той же пары `(model, schema)` отменяет предыдущий in-flight прогон через `AbortController`;
+  его `AbortSignal` прокинут в `validateAsync`-правила, поэтому `fetch(url, { signal })` рвётся
+  сам. Ручной debounce для КОРРЕКТНОСТИ не нужен — держи схему стабильным `const`
+  (`defineValidationSchema`), иначе отмена не сматчит прогоны по идентичности.
+- Валидация запускается on-demand (submit / шаг / через `revalidateWhen`), а не на каждый
+  keystroke — отдельный `debounce` в правиле обычно не нужен.
+- Если нужно дебаунсить дорогой async-валидатор относительно частых изменений — триггерь прогон
+  из поведения через `onChange`, который даёт debounce из коробки:
+
+  ```ts
+  import { defineFormBehavior, onChange } from '@reformer/core/behaviors';
+  import { validateModel } from '@reformer/core/validation';
+
+  export const behavior = defineFormBehavior<{ username: string }>(({ model }) => {
+    onChange(model.$.username, () => void validateModel(model, schema), { debounce: 300 });
+  });
+  ```
+
+  Либо оборачивай в свой debounce колбэк `revalidateWhen([...], () => void validateModel(...))`.
+- **Async cross-field** — инлайн `validateAsync`-правило, замыкающее `model` и читающее снапшот
+  соседей `model.get()` до первого `await` (у `AsyncRule` нет `root`, только `value` + `signal`;
+  `cross(...)` — синхронный):
+
+  ```ts
+  validateAsync(model.$.email, [
+    async (email, { signal }) => {
+      const { username } = model.get(); // снапшот соседних полей до await
+      const res = await fetch(`/api/check?email=${email}&user=${username}`, { signal });
+      return (await res.json()).ok ? null : { code: 'conflict', message: 'Пара занята' };
+    },
+  ]);
+  ```
 
 ### See also
 
-- [27-revalidate-when.md](27-revalidate-when.md) — перезапуск валидации по триггерам
+- [27-revalidate-when.md](27-revalidate-when.md) — перезапуск `validateModel` по триггерам
 - [29-async-preload.md](29-async-preload.md) — async preload данных при init формы
-- [03-api-signatures.md](03-api-signatures.md) — `ModelValidator` и `validateFormModel`
+- [32-async-options-loading.md](32-async-options-loading.md) — `onChange` с debounce + AbortSignal
 
 ## 76. 32. ASYNC OPTIONS LOADING
 
@@ -4134,15 +4566,16 @@ export function createForm<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>;
 ```
 
 **Parameters:**
-- `args` — - Модель данных, единая схема (component/componentProps/validators) и (опционально) поведение
+- `args` — - Модель данных, layout-схема (component/componentProps) и (опционально) поведение
 
 **Returns:** Типизированная форма с Proxy-доступом к полям
 
 **Examples:**
 
-Архитектура M1: `createModel` + единая схема + `createForm({ model, schema })`
+Архитектура M1: `createModel` + layout-схема + `createForm({ model, schema })`
 ```typescript
-import { createModel, createForm, validateFormModel } from '@reformer/core';
+import { createModel, createForm } from '@reformer/core';
+import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
 import { required, email, minLength } from '@reformer/core/validators';
 
 interface UserForm {
@@ -4152,28 +4585,23 @@ password: string;
 
 const model = createModel<UserForm>({ email: '', password: '' });
 
+// Layout-схема НЕ несёт validators — только component/componentProps.
 const schema = {
 children: [
-{
-value: model.$.email,
-component: Input,
-validators: [required(), email()],
-},
-{
-value: model.$.password,
-component: Input,
-validators: [required(), minLength(8)],
-},
+{ value: model.$.email, component: Input },
+{ value: model.$.password, component: Input },
 ],
 };
 
 const form = createForm<UserForm>({ model, schema });
-
-// TypeScript знает о полях (нода привязана к сигналу модели):
 form.email.setValue('test@mail.com');
 
-// Валидация всей модели по схеме (sync + async):
-const { valid } = await validateFormModel(model, schema);
+// Валидация — ОТДЕЛЬНАЯ схема, прогон внешним раннером (ошибки сами доезжают до нод):
+const validation = defineValidationSchema<UserForm>(({ model }) => {
+validate(model.$.email, [required(), email()]);
+validate(model.$.password, [required(), minLength(8)]);
+});
+const ok = await validateModel(model, validation);
 ```
 
 _Source: src/form/create-form.ts_
@@ -4342,7 +4770,7 @@ _Source: src/form/behaviors-node.ts_
 
 **Signature:**
 ```typescript
-export function email<TForm = unknown, TField extends string | undefined = string>(
+export function email<TForm = unknown, TField extends string | null | undefined = string>(
   options?: ValidateOptions
 ): Validator<TForm, TField>
 ```
@@ -4792,6 +5220,70 @@ export type FieldStatus = 'valid' | 'invalid' | 'pending' | 'disabled';
 
 _Source: src/form/types/contracts.ts_
 
+### FileLike
+
+**Kind:** `interface`
+
+Минимальный файлоподобный контракт, с которым работают file-валидаторы:
+нативный `File`, сериализуемый дескриптор загруженного файла и т.п.
+
+**Signature:**
+```typescript
+export interface FileLike {
+  name: string;
+  size?: number;
+  type?: string;
+}
+```
+
+_Source: src/form/validation/validators/file-utils.ts_
+
+### fileType
+
+**Kind:** `function`
+
+Фабрика валидатора типа файла.
+
+Проверяет каждый файл против accept-строки в синтаксисе нативного атрибута
+`<input type="file" accept>`: расширения (`.pdf`), точные MIME (`image/png`),
+wildcard-категории (`image/*`), список через запятую. Матчинг регистронезависимый,
+по `type` и/или расширению из `name` ({@link matchesFileAccept}).
+
+Нужен потому, что нативный `accept` — только подсказка пикеру: на drag-and-drop
+и «All files» он не действует. Пустые значения (`null`/`undefined`/`''`/`[]`)
+пропускаются (используйте {@link required} для обязательности).
+
+**Signature:**
+```typescript
+export function fileType<TForm = unknown, TField = unknown>(
+  accept: string,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `accept` — - Accept-строка допустимых типов, например `'image/*,.pdf'`
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `accept` и `fileName` (первый нарушивший файл).
+
+**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+
+**Examples:**
+
+Только изображения и PDF
+```typescript
+import { fileType } from '@reformer/core/validators';
+
+// Внутри FieldConfig схемы формы:
+documents: {
+value: model.$.documents,
+component: FileUploadField,
+validators: [fileType('image/*,.pdf', { message: 'Только изображения или PDF' })],
+},
+```
+
+_Source: src/form/validation/validators/file-type.ts_
+
 ### FormArrayProxy
 
 **Kind:** `type`
@@ -5143,8 +5635,8 @@ _Source: src/form/types/deep-schema.ts_
 
 **Kind:** `interface`
 
-Узел единой схемы M1 — дерево, обходимое `createForm({ model, schema })`,
-`validateModel`/`validateFormModel` и рендерерами.
+Узел единой схемы M1 — layout-дерево, обходимое `createForm({ model, schema })`
+и рендерерами (schema-валидация живёт отдельно — `@reformer/core/validation`).
 
 Узел совмещает несколько ролей (различаются рантаймом по форме):
  - **поле** — несёт `value: Signal` (сигнал модели `model.$.x`) + `component`/`validators`;
@@ -5164,8 +5656,12 @@ export interface FormSchemaNode {
    * `Signal`). Движок разбирает узел как поле рантаймом по `value instanceof Signal`.
    */
   value?: unknown;
-  /** UI-компонент. Опционален: core-часть работает без UI (значение/валидация). */
-  component?: ComponentType<any>;
+  /**
+   * UI-компонент либо нативный HTML-тег (`'div'`, `'p'`, `'h3'`) для презентационной вёрстки
+   * прямо в схеме. Опционален: core-часть работает без UI (значение/валидация) и `component`
+   * не интерпретирует — он доезжает до рендерера как есть.
+   */
+  component?: ElementType;
   /** Props компонента. Также «клапан» для вложенности под-узлов (напр. steps визарда). */
   componentProps?: Record<string, unknown>;
   validators?: SchemaValidator[];
@@ -5301,7 +5797,7 @@ _Source: src/form/types/contracts.ts_
 ```typescript
 export function futureDate<
   TForm = unknown,
-  TField extends string | Date | undefined = string | Date,
+  TField extends string | Date | null | undefined = string | Date,
 >(options?: ValidateOptions): Validator<TForm, TField>
 ```
 
@@ -5394,8 +5890,8 @@ _Source: src/form/type-guards.ts_
 GroupNode - узел для группы полей
 
 Создаётся из {@link FormSchema} (дерево field-конфигов). Обычно строится через `createForm`
-(M1: `createForm({ model, schema })`); валидация/behavior живут на слое модели
-(`validateFormModel`, `computeFrom`/`enableWhen`/…), а не на ноде.
+(M1: `createForm({ model, schema })`); schema-валидация/behavior живут на слое модели
+(`validateModel` из `@reformer/core/validation`, `computeFrom`/`enableWhen`/…), а не на ноде.
 
 **Signature:**
 ```typescript
@@ -5519,9 +6015,10 @@ _Source: src/form/type-guards.ts_
 
 **Signature:**
 ```typescript
-export function isDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(
-  options?: ValidateOptions
-): Validator<TForm, TField>
+export function isDate<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(options?: ValidateOptions): Validator<TForm, TField>
 ```
 
 **Parameters:**
@@ -5610,6 +6107,25 @@ if (isFieldNode(node)) {
 
 _Source: src/form/type-guards.ts_
 
+### isFileLike
+
+**Kind:** `function`
+
+Проверяет, что значение файлоподобно: объект со строковым `name` и опциональными
+числовым `size` / строковым `type`.
+
+**Signature:**
+```typescript
+export function isFileLike(value: unknown): value is FileLike
+```
+
+**Parameters:**
+- `value` — - Проверяемое значение
+
+**Returns:** `true`, если значение соответствует {@link FileLike}
+
+_Source: src/form/validation/validators/file-utils.ts_
+
 ### isFormNode
 
 **Kind:** `function`
@@ -5742,6 +6258,30 @@ markDerived(model.$.total);
 
 _Source: src/state/derived-registry.ts_
 
+### matchesFileAccept
+
+**Kind:** `function`
+
+Проверяет файл против accept-паттерна в синтаксисе нативного атрибута
+`<input type="file" accept>`: список через запятую из расширений (`.pdf`),
+точных MIME (`image/png`) и wildcard-категорий (`image/*`). Регистронезависимо.
+
+Нужен собственный матчер, потому что `accept` у нативного input — только подсказка
+пикеру: на drag-and-drop и на программное значение он не действует.
+
+**Signature:**
+```typescript
+export function matchesFileAccept(file: Pick<FileLike, 'name' | 'type'>, accept: string): boolean
+```
+
+**Parameters:**
+- `file` — - Файлоподобное значение (`name` + опциональный `type`)
+- `accept` — - Accept-строка; пустая/пробельная строка матчит всё
+
+**Returns:** `true`, если файл подходит хотя бы под один паттерн
+
+_Source: src/form/validation/validators/file-utils.ts_
+
 ### max
 
 **Kind:** `function`
@@ -5862,6 +6402,90 @@ validators: [maxDate(new Date(), { message: 'Дата не может быть
 
 _Source: src/form/validation/validators/max-date.ts_
 
+### maxFiles
+
+**Kind:** `function`
+
+Фабрика валидатора максимального количества файлов.
+
+Работает с массивом файлов (одиночный файл считается как 1). Пустые значения
+(`null`/`undefined`/`''`/`[]`) пропускаются (используйте {@link required}
+для обязательности).
+
+**Signature:**
+```typescript
+export function maxFiles<TForm = unknown, TField = unknown>(
+  max: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `max` — - Максимально допустимое количество файлов (включительно)
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `maxFiles` и `actualCount`.
+
+**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+
+**Examples:**
+
+Не более трёх вложений
+```typescript
+import { maxFiles } from '@reformer/core/validators';
+
+// Внутри FieldConfig схемы формы:
+documents: {
+value: model.$.documents,
+component: FileUploadField,
+validators: [maxFiles(3, { message: 'Максимум 3 файла' })],
+},
+```
+
+_Source: src/form/validation/validators/max-files.ts_
+
+### maxFileSize
+
+**Kind:** `function`
+
+Фабрика валидатора максимального размера файла.
+
+Работает с одиночным файлом или массивом (`File` либо файлоподобный дескриптор с
+`name`/`size`). Проверяется каждый файл; в ошибку попадает первый нарушивший.
+Пустые значения (`null`/`undefined`/`''`/`[]`) и элементы без числового `size`
+(например, дескриптор загруженного файла без размера) пропускаются
+(используйте {@link required} для обязательности).
+
+**Signature:**
+```typescript
+export function maxFileSize<TForm = unknown, TField = unknown>(
+  maxSize: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `maxSize` — - Максимально допустимый размер файла в байтах (включительно)
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `maxFileSize`, `fileName` и `actualSize`.
+
+**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+
+**Examples:**
+
+Ограничение размера вложений
+```typescript
+import { maxFileSize } from '@reformer/core/validators';
+
+// Внутри FieldConfig схемы формы:
+documents: {
+value: model.$.documents,
+component: FileUploadField,
+validators: [maxFileSize(5 * 1024 * 1024, { message: 'Файл больше 5 МБ' })],
+},
+```
+
+_Source: src/form/validation/validators/max-file-size.ts_
+
 ### maxLength
 
 **Kind:** `function`
@@ -5904,6 +6528,47 @@ validators: [maxLength(500, { message: 'Максимум 500 символов' }
 
 _Source: src/form/validation/validators/max-length.ts_
 
+### maxTotalFileSize
+
+**Kind:** `function`
+
+Фабрика валидатора суммарного размера всех файлов.
+
+Складывает `size` всех файлов значения (элементы без числового `size` в сумму
+не входят). Пустые значения (`null`/`undefined`/`''`/`[]`) пропускаются
+(используйте {@link required} для обязательности).
+
+**Signature:**
+```typescript
+export function maxTotalFileSize<TForm = unknown, TField = unknown>(
+  maxTotal: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `maxTotal` — - Максимально допустимый суммарный размер в байтах (включительно)
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `maxTotalFileSize` и `actualTotal`.
+
+**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+
+**Examples:**
+
+Суммарно не более 20 МБ
+```typescript
+import { maxTotalFileSize } from '@reformer/core/validators';
+
+// Внутри FieldConfig схемы формы:
+documents: {
+value: model.$.documents,
+component: FileUploadField,
+validators: [maxTotalFileSize(20 * 1024 * 1024, { message: 'Суммарно не более 20 МБ' })],
+},
+```
+
+_Source: src/form/validation/validators/max-total-file-size.ts_
+
 ### min
 
 **Kind:** `function`
@@ -6024,6 +6689,90 @@ validators: [required(), minDate(new Date(), { message: 'Дата не рань
 
 _Source: src/form/validation/validators/min-date.ts_
 
+### minFiles
+
+**Kind:** `function`
+
+Фабрика валидатора минимального количества файлов.
+
+Работает с массивом файлов (одиночный файл считается как 1). Пустые значения
+(`null`/`undefined`/`''`/`[]`) пропускаются — «нужен хотя бы один файл» выражается
+связкой `required()` + `minFiles(n)`, как и у {@link minLength}.
+
+**Signature:**
+```typescript
+export function minFiles<TForm = unknown, TField = unknown>(
+  min: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `min` — - Минимально допустимое количество файлов (включительно)
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `minFiles` и `actualCount`.
+
+**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+
+**Examples:**
+
+Не менее двух документов
+```typescript
+import { required, minFiles } from '@reformer/core/validators';
+
+// Внутри FieldConfig схемы формы:
+documents: {
+value: model.$.documents,
+component: FileUploadField,
+validators: [required(), minFiles(2, { message: 'Приложите минимум 2 документа' })],
+},
+```
+
+_Source: src/form/validation/validators/min-files.ts_
+
+### minFileSize
+
+**Kind:** `function`
+
+Фабрика валидатора минимального размера файла.
+
+Работает с одиночным файлом или массивом (`File` либо файлоподобный дескриптор с
+`name`/`size`). Проверяется каждый файл; в ошибку попадает первый нарушивший.
+Типовой сценарий — отсев пустых (0-байтовых) файлов: `minFileSize(1)`.
+Пустые значения (`null`/`undefined`/`''`/`[]`) и элементы без числового `size`
+пропускаются (используйте {@link required} для обязательности).
+
+**Signature:**
+```typescript
+export function minFileSize<TForm = unknown, TField = unknown>(
+  minSize: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `minSize` — - Минимально допустимый размер файла в байтах (включительно)
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `minFileSize`, `fileName` и `actualSize`.
+
+**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+
+**Examples:**
+
+Отсев пустых файлов
+```typescript
+import { minFileSize } from '@reformer/core/validators';
+
+// Внутри FieldConfig схемы формы:
+documents: {
+value: model.$.documents,
+component: FileUploadField,
+validators: [minFileSize(1, { message: 'Файл пустой' })],
+},
+```
+
+_Source: src/form/validation/validators/min-file-size.ts_
+
 ### minLength
 
 **Kind:** `function`
@@ -6256,44 +7005,6 @@ export type ModelSignals<T> = {
 
 _Source: src/state/types.ts_
 
-### ModelValidationResult
-
-**Kind:** `interface`
-
-Результат валидации: ошибки по пути поля.
-
-**Signature:**
-```typescript
-export interface ModelValidationResult {
-  valid: boolean;
-  /** Ключ — путь поля (`'coBorrowers.0.relationship'`). Только поля с ошибками. */
-  errors: Record<string, ValidationError[]>;
-}
-```
-
-_Source: src/form/validate-model-core.ts_
-
-### ModelValidator
-
-**Kind:** `type`
-
-Валидатор слоя **данных**. `value` — значение поля; `model` — ближайший scope (под-модель элемента
-массива или корень); `root` — корневая модель.
-
-Отличие от {@link Validator}: 2-й/3-й аргументы — сами данные ({@link FormModel}/scope), а не
-`FormProxy`-узлы формы. Оба совместимы с полем `validators` узла схемы (см. {@link SchemaValidator}).
-
-**Signature:**
-```typescript
-export type ModelValidator<TValue = unknown, TModel = unknown, TRoot = unknown> = (
-  value: TValue,
-  model: TModel,
-  root: TRoot
-) => ValidationError | null | Promise<ValidationError | null>;
-```
-
-_Source: src/form/validate-model-core.ts_
-
 ### ModelValue
 
 **Kind:** `type`
@@ -6511,9 +7222,10 @@ _Source: src/form/validation/validators/non-zero.ts_
 
 **Signature:**
 ```typescript
-export function pastDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(
-  options?: ValidateOptions
-): Validator<TForm, TField>
+export function pastDate<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(options?: ValidateOptions): Validator<TForm, TField>
 ```
 
 **Parameters:**
@@ -6565,7 +7277,7 @@ _Source: src/state/types.ts_
 
 **Signature:**
 ```typescript
-export function pattern<TForm = unknown, TField extends string | undefined = string>(
+export function pattern<TForm = unknown, TField extends string | null | undefined = string>(
   regex: RegExp,
   options?: ValidateOptions
 ): Validator<TForm, TField>
@@ -6613,7 +7325,7 @@ _Source: src/form/validation/validators/pattern.ts_
 
 **Signature:**
 ```typescript
-export function phone<TForm = unknown, TField extends string | undefined = string>(
+export function phone<TForm = unknown, TField extends string | null | undefined = string>(
   options?: PhoneValidatorOptions
 ): Validator<TForm, TField>
 ```
@@ -6778,8 +7490,8 @@ _Source: src/form/types/index.ts_
 
 **Kind:** `function`
 
-Вызывает `revalidate()` при изменении зависимостей (не на инициализации). Под M1 валидация
-on-demand (`validateFormModel`), поэтому ревалидация выражается явным колбэком.
+Вызывает `revalidate()` при изменении зависимостей (не на инициализации). Валидация on-demand
+(`validateModel` из `@reformer/core/validation`), поэтому ревалидация выражается явным колбэком.
 
 **Signature:**
 ```typescript
@@ -6792,7 +7504,7 @@ export function revalidateWhen(
 **Examples:**
 
 ```typescript
-revalidateWhen([model.$.maxAmount], () => validateFormModel(model, schema));
+revalidateWhen([model.$.maxAmount], () => void validateModel(model, schema));
 ```
 
 _Source: src/state/behaviors-value.ts_
@@ -6935,10 +7647,10 @@ _Source: src/form/types/schema-node.ts_
 
 **Kind:** `type`
 
-Валидатор поля схемы. Узел хранит validators гетерогенно: движок `validate*` вызывает их как
-`(value, scope, root)`, но сюда кладут любой контракт — `ValidatorFn` (value),
-`Validator` (value, control, root) или `ModelValidator` (value, model, root). Поэтому тип
-намеренно широкий по параметрам.
+Валидатор поля схемы (legacy). Дерево-движок, вызывавший `validators` узла как
+`(value, scope, root)`, удалён — живые правила это `Rule<T>` в `validate(sig, [...])`
+(`@reformer/core/validation`). Тип остаётся широким по параметрам для совместимости
+узлов, всё ещё несущих `validators` (гетерогенные контракты `ValidatorFn`/`Validator`).
 
 **Signature:**
 ```typescript
@@ -7113,6 +7825,27 @@ syncFields(model.$.field1, model.$.field2);
 
 _Source: src/state/behaviors-value.ts_
 
+### toFileArray
+
+**Kind:** `function`
+
+Нормализует значение file-поля в массив файлоподобных элементов.
+
+Одиночный {@link FileLike} оборачивается в массив; из массива отбираются только
+файлоподобные элементы. Для прочих значений — `null` (валидатор пропускает).
+
+**Signature:**
+```typescript
+export function toFileArray(value: unknown): FileLike[] | null
+```
+
+**Parameters:**
+- `value` — - Значение поля (`FileLike`, `FileLike[]` или что-то ещё)
+
+**Returns:** Массив файлоподобных элементов или `null`
+
+_Source: src/form/validation/validators/file-utils.ts_
+
 ### transformValue
 
 **Kind:** `function`
@@ -7253,7 +7986,7 @@ _Source: src/state/derived-registry.ts_
 
 **Signature:**
 ```typescript
-export function url<TForm = unknown, TField extends string | undefined = string>(
+export function url<TForm = unknown, TField extends string | null | undefined = string>(
   options?: UrlValidatorOptions
 ): Validator<TForm, TField>
 ```
@@ -7756,94 +8489,6 @@ export interface ValidateAsyncOptions extends ValidateOptions {
 
 _Source: src/form/types/validation-schema.ts_
 
-### validateFormModel
-
-**Kind:** `function`
-
-In-form валидация: прогоняет {@link validateModel} и роутит ошибки в ноды формы
-(через реестр сигнал→нода): `node.setErrors(errors[path] ?? [])` — заодно очищает прошедшие поля
-И поля выключенных веток (`{ when, children }` с ложным условием). Дерево обходится ОДИН раз.
-
-**Signature:**
-```typescript
-export async function validateFormModel<T>(
-  model: FormModel<T>,
-  schema: FormSchemaNode
-): Promise<ModelValidationResult>
-```
-
-**Parameters:**
-- `model` — - Модель данных ({@link FormModel}) — источник значений полей.
-- `schema` — - Единая схема формы (та же, что передавалась в `createForm`).
-
-**Returns:** 
-
-**Examples:**
-
-Валидация перед submit (ошибки показываются в UI автоматически)
-```typescript
-const form = createForm({ model, schema });
-form.touchAll();
-const res = await validateFormModel(model, schema);
-if (res.valid) await api.save(model.get());
-```
-
-_Source: src/form/validate-model.ts_
-
-### validateModel
-
-**Kind:** `function`
-
-Headless-валидация данных (sync + async). Работает без UI/нод.
-
-**Signature:**
-```typescript
-export async function validateModel<T>(
-  model: FormModel<T>,
-  schema: FormSchemaNode
-): Promise<ModelValidationResult>
-```
-
-**Examples:**
-
-```typescript
-const res = await validateModel(model, schema);
-if (!res.valid) console.log(res.errors); // { 'email': [{ code, message }], ... }
-```
-
-_Source: src/form/validate-model-core.ts_
-
-### validateModelSync
-
-**Kind:** `function`
-
-Синхронная headless-валидация данных. Асинхронные валидаторы пропускаются.
-
-**Signature:**
-```typescript
-export function validateModelSync<T>(
-  model: FormModel<T>,
-  schema: FormSchemaNode
-): ModelValidationResult
-```
-
-**Parameters:**
-- `model` — - Модель данных ({@link FormModel}), из сигналов которой читаются значения полей.
-- `schema` — - Единая схема формы (дерево узлов с `value`/`validators`, `{ when, children }`,
-секциями массивов). Обходится один раз для сбора активных полей.
-
-**Returns:** 
-
-**Examples:**
-
-Быстрая синхронная проверка (например, для gate «можно ли перейти на след. шаг»)
-```typescript
-const res = validateModelSync(model, schema);
-if (!res.valid) console.log(res.errors); // { 'email': [{ code, message }], ... }
-```
-
-_Source: src/form/validate-model-core.ts_
-
 ### ValidateOptions
 
 **Kind:** `interface`
@@ -7887,20 +8532,7 @@ _Source: src/form/types/contracts.ts_
 
 **Kind:** `type`
 
-Чистый синхронный валидатор поля.
-
-Сигнатура зеркалит то, что реально вызывает движок M1
-(`validateModel`/`validateFormModel`/`validateModelSync`): `validator(value, scope, root)`.
-- `value` — значение поля (`TField`);
-- `scope` — ближайшая scope-**модель** (под-модель элемента массива или корень). Из `TForm`/`TField`
-  её тип не выводится, поэтому `unknown` — потребитель сужает сам (для типизированного scope
-  используйте {@link ModelValidator}`<TField, TScope, TForm>`);
-- `root` — корневая модель формы `FormModel<TForm>` (реактивный value-proxy: `root.field` читает
-  значение). Возвращает `ValidationError` либо `null`. Не знает про реестр валидации.
-
-Совместим с полем `validators` узла схемы (см. `SchemaValidator`) — там же лежат `ModelValidator`
-и `ValidatorFn`. Встроенные фабрики (`required()`/`email()`/…) возвращают `(value) => …` и
-дополнительные аргументы игнорируют.
+Чистый синхронный валидатор поля (legacy-сигнатура `(value, scope, root)`).
 
 **Signature:**
 ```typescript
@@ -7911,23 +8543,12 @@ export type Validator<TForm, TField> = (
 ) => ValidationError | null;
 ```
 
-**Examples:**
-
-Кастомный валидатор в массиве `validators` поля схемы
-```typescript
-const isAdult: Validator<MyForm, number> = (value, _scope, root) => {
-if (value < 18) return { code: 'tooYoung', message: '18+' };
-// root — FormModel<MyForm>: root.someOtherField читается как значение
-return null;
-};
-
-// Фабрики и кастомные валидаторы кладутся в `validators: [...]` поля:
-const schema = {
-children: [
-{ value: model.$.age, component: Input, validators: [required(), isAdult] },
-],
-};
-```
+**Deprecated:** Осиротевший остаток удалённого дерево-движка (`validateFormModel`). Живой контракт —
+`Rule<T> = (value) => ValidationError | null` из `@reformer/core/validation`: правила
+передаются в `validate(sig, [rules])` внутри `defineValidationSchema` и запускаются
+`validateModel(model, schema)`. Cross-field — оператор `cross(sig, (f) => …)` над снапшотом
+`model.get()` (третий аргумент `root` больше не нужен). Тип экспортируется только ради
+обратной совместимости (`SchemaValidator`-union).
 
 _Source: src/form/types/validation-schema.ts_