@reformer/core 5.0.2 → 6.0.0

package/llms.txt

@@ -2,7 +2,7 @@
 # AUTO-GENERATED. Edit docs/llms/*.md or JSDoc in src/ and run npm run generate:llms.
 
 > Reactive form state management library for React with signals-based architecture
-> Package: @reformer/core  •  Version: 1.1.0
+> Package: @reformer/core  •  Version: 5.0.2
 
 ## Table of Contents
 - 01-api-reference.md — api-reference
@@ -42,18 +42,18 @@
 
 ### Imports (CRITICALLY IMPORTANT)
 
-| What                                                                            | Where                       |
-| ------------------------------------------------------------------------------- | --------------------------- |
-| `createForm`, `useFormControl`, `useFormControlValue`, `validateForm`           | `@reformer/core`            |
+| What                                                                                        | Where                       |
+| ------------------------------------------------------------------------------------------- | --------------------------- |
+| `createForm`, `useFormControl`, `useFormControlValue`, `validateForm`                       | `@reformer/core`            |
 | `ValidationSchemaFn`, `BehaviorSchemaFn`, `FieldPath`, `FormProxy`, `FieldNode` | `@reformer/core`            |
-| `FormSchema`, `FieldConfig`, `ArrayNode`                                        | `@reformer/core`            |
-| `required`, `min`, `max`, `minLength`, `maxLength`, `email`                     | `@reformer/core/validators` |
-| `pattern`, `url`, `phone`, `number`, `date`                                     | `@reformer/core/validators` |
-| `validate`, `validateAsync`, `validateTree`, `applyWhen`                        | `@reformer/core/validators` |
-| `notEmpty`, `validateItems`                                                     | `@reformer/core/validators` |
-| `computeFrom`, `enableWhen`, `disableWhen`, `watchField`, `copyFrom`            | `@reformer/core/behaviors`  |
-| `resetWhen`, `revalidateWhen`, `syncFields`                                     | `@reformer/core/behaviors`  |
-| `transformValue`, `transformers`                                                | `@reformer/core/behaviors`  |
+| `FormSchema`, `FieldConfig`, `ArrayNode`                                                    | `@reformer/core`            |
+| `required`, `min`, `max`, `minLength`, `maxLength`, `email`                                 | `@reformer/core/validators` |
+| `pattern`, `url`, `phone`, `isNumber`, `integer`, `multipleOf`, `nonNegative`, `nonZero`    | `@reformer/core/validators` |
+| `validate`, `validateAsync`, `applyWhen`, `apply`                                           | `@reformer/core/validators` |
+| `notEmpty`, `validateItems`                                                                 | `@reformer/core/validators` |
+| `computeFrom`, `enableWhen`, `disableWhen`, `watchField`, `copyFrom`                        | `@reformer/core/behaviors`  |
+| `resetWhen`, `revalidateWhen`, `syncFields`                                                 | `@reformer/core/behaviors`  |
+| `transformValue`, `transformers`                                                            | `@reformer/core/behaviors`  |
 
 ### Type Values
 
@@ -63,10 +63,10 @@
 
 ### React Hooks Comparison (CRITICALLY IMPORTANT)
 
-| Hook                         | Return Type                                 | Subscribes To     | Use Case                      |
-| ---------------------------- | ------------------------------------------- | ----------------- | ----------------------------- |
-| `useFormControl(field)`      | `{ value, errors, disabled, touched, ... }` | All signals       | Full field state, form inputs |
-| `useFormControlValue(field)` | `T` (value directly)                        | Only value signal | Conditional rendering         |
+| Hook | Return Type | Subscribes To | Use Case |
+|------|-------------|---------------|----------|
+| `useFormControl(field)` | `{ value, errors, disabled, touched, ... }` | All signals | Full field state, form inputs |
+| `useFormControlValue(field)` | `T` (value directly) | Only value signal | Conditional rendering |
 
 **CRITICAL**: Do NOT destructure `useFormControlValue`! It returns `T` directly, NOT `{ value: T }`.
 
@@ -188,26 +188,39 @@ const schema: FormSchema<{ properties: PropertyItem[] }> = {
 
 ### Validators
 
-```typescript
-// Basic validators
-required(path, options?: { message?: string })
-min(path, value: number, options?: { message?: string })
-max(path, value: number, options?: { message?: string })
-minLength(path, length: number, options?: { message?: string })
-maxLength(path, length: number, options?: { message?: string })
-email(path, options?: { message?: string })
-
-// Additional validators
-pattern(path, regex: RegExp, options?: { message?: string })
-url(path, options?: { message?: string })
-phone(path, options?: { message?: string; format?: PhoneFormat })
-number(path, options?: { message?: string })
-date(path, options?: { message?: string; minAge?: number; maxAge?: number; noFuture?: boolean; noPast?: boolean })
-
-// Custom validators
-validate(path, validator: (value, ctx) => ValidationError | null)
-validateAsync(path, validator: async (value, ctx) => ValidationError | null)
-validateTree(validator: (ctx) => ValidationError | null, options?: { targetField?: string })
+Operators register validators in the schema. Validator factories return pure
+`Validator<TForm, TField>` functions of shape `(value, control, root) => ValidationError | null`.
+
+```typescript
+// Operators (register validators in schema)
+validate(path, validator: Validator<TForm, TField>, options?: { message?: string })
+validateAsync(path, validator: AsyncValidator<TForm, TField>, options?: { message?: string; debounce?: number })
+
+// Validator factories (return Validator). Pass to validate().
+required(options?: { message?: string })
+min(value: number, options?: { message?: string })
+max(value: number, options?: { message?: string })
+minLength(length: number, options?: { message?: string })
+maxLength(length: number, options?: { message?: string })
+email(options?: { message?: string })
+pattern(regex: RegExp, options?: { message?: string })
+url(options?: { message?: string; requireProtocol?: boolean })
+phone(options?: { message?: string; format?: PhoneFormat })
+// Number validator factories (atomic — compose via several validate() calls)
+isNumber(options?: { message?: string })
+integer(options?: { message?: string })
+multipleOf(divisor: number, options?: { message?: string })
+nonNegative(options?: { message?: string })       // value >= 0
+nonZero(options?: { message?: string })           // value !== 0
+date(options?: { message?: string; minAge?: number; maxAge?: number; noFuture?: boolean; noPast?: boolean })
+notEmpty(options?: { message?: string })
+
+// Usage: pass a factory result to validate()
+validate(path.email, required());
+validate(path.age, min(18));
+validate(path.amount, integer());
+validate(path.amount, min(0));
+validate(path.amount, max(1000));
 
 // Conditional validation (3 arguments!)
 applyWhen(fieldPath, condition: (fieldValue) => boolean, validatorsFn: (path) => void)
@@ -220,8 +233,8 @@ applyWhen(
   path.loanType,                    // 1st: field to watch
   (type) => type === 'mortgage',    // 2nd: condition on field value
   (p) => {                          // 3rd: validators to apply
-    required(p.propertyValue);
-    min(p.propertyValue, 100000);
+    validate(p.propertyValue, required());
+    validate(p.propertyValue, min(100000));
   }
 );
 
@@ -230,8 +243,8 @@ applyWhen(
   path.address.country,
   (country) => country === 'US',
   (p) => {
-    required(p.address.state);
-    pattern(p.address.zip, /^\d{5}(-\d{4})?$/);
+    validate(p.address.state, required());
+    validate(p.address.zip, pattern(/^\d{5}(-\d{4})?$/));
   }
 );
 
@@ -240,19 +253,18 @@ applyWhen(
   path.hasInsurance,
   (has) => has === true,
   (p) => {
-    required(p.insuranceCompany);
-    required(p.policyNumber);
+    validate(p.insuranceCompany, required());
+    validate(p.policyNumber, required());
   }
 );
 
 // WRONG - only 2 arguments (React Hook Form pattern)
 applyWhen(
   (form) => form.loanType === 'mortgage',  // WRONG!
-  () => { required(path.propertyValue); }
+  () => { validate(path.propertyValue, required()); }
 );
 
-// Array validators
-notEmpty(path, options?: { message?: string })
+// Array item schema operator
 validateItems(arrayPath, itemValidatorsFn: (itemPath) => void)
 ```
 
@@ -426,26 +438,29 @@ const { value } = useFormControl(form.field as FieldNode<ExpectedType>);
 
 ### Validation Priority (IMPORTANT)
 
-**Always prefer built-in validators over custom ones:**
+**Operators register validators; built-in factories return validators. Pass factories to `validate()`.**
+
+Operators: `validate`, `validateAsync`, `applyWhen`, `apply`, `validateItems`.
+Factories (return `Validator<TForm, TField>`): `required`, `email`, `min`, `max`, `minLength`, `maxLength`,
+`pattern`, `url`, `phone`, `number`, `date`, `notEmpty`.
 
 ```typescript
-// 1. BEST: Use built-in validators when available
-required(path.email);
-email(path.email);
-min(path.age, 18);
-minLength(path.password, 8);
-pattern(path.phone, /^\+7\d{10}$/);
+// 1. BEST: Pass built-in factories to validate()
+validate(path.email, required());
+validate(path.email, email());
+validate(path.age, min(18));
+validate(path.password, minLength(8));
+validate(path.phone, pattern(/^\+7\d{10}$/));
 
-// 2. GOOD: Use validate() only when no built-in validator exists
-validate(path.customField, (value, ctx) => {
-  // Custom logic that can't be expressed with built-in validators
+// 2. GOOD: Custom validator when no factory fits. Signature: (value, control, root).
+validate(path.customField, (value, control, root) => {
   if (customCondition(value)) {
     return { code: 'custom', message: 'Custom error' };
   }
   return null;
 });
 
-// 3. WRONG: Don't recreate built-in validators
+// 3. WRONG: Don't recreate built-in validators inline
 validate(path.email, (value) => {
   if (!value) return { code: 'required', message: 'Required' }; // Use required() instead!
   if (!value.includes('@')) return { code: 'email', message: 'Invalid' }; // Use email() instead!
@@ -532,6 +547,68 @@ const behavior: BehaviorSchemaFn<LoanForm> = (path) => {
 
 Reference patterns: `complex-multy-step-form/schemas/credit-application-behavior.ts`.
 
+### Extracting Nested Rules
+
+When the body of `applyWhen` / `validate` grows beyond a few lines,
+extract it to a **named top-level function** typed with one of the public types from
+`@reformer/core`:
+
+- `ValidationSchemaFn<TForm>` — sub-schema passed to `applyWhen` or `apply`.
+- `Validator<TForm, TField>` / `AsyncValidator<TForm, TField>` — field validator passed to `validate` / `validateAsync`. Cross-field правила пишутся в той же сигнатуре — `(value, control, root) => …` — и навешиваются на конкретное поле-носитель ошибки.
+
+This keeps the schema body flat (reads like a table of contents) and surfaces the
+**intent** of each rule via a meaningful name.
+
+```typescript
+import type { ValidationSchemaFn, Validator } from '@reformer/core';
+
+// 1. Cross-field rule — extracted Validator (reads other fields via `root`)
+const initialPaymentVsPropertyValue: Validator<CreditApplicationForm, unknown> = (
+  _value,
+  _control,
+  root
+) => {
+  const form = root.getValue();
+  if (form.initialPayment && form.propertyValue && form.initialPayment > form.propertyValue) {
+    return { code: 'initialPaymentTooHigh', message: 'Взнос не может превышать стоимость' };
+  }
+  return null;
+};
+
+// 2. Custom field validator — extracted Validator
+const validateAdultAge: Validator<CreditApplicationForm, string | undefined> = (value) => {
+  if (!value) return null;
+  const age = new Date().getFullYear() - new Date(value).getFullYear();
+  if (age < 18) return { code: 'tooYoung', message: 'Минимум 18 лет' };
+  return null;
+};
+
+// 3. Nested schema for applyWhen — extracted ValidationSchemaFn
+const mortgageFieldsRules: ValidationSchemaFn<CreditApplicationForm> = (path) => {
+  validate(path.propertyValue, required());
+  validate(path.propertyValue, min(1000000));
+  validate(path.initialPayment, required());
+  validate(path.initialPayment, initialPaymentVsPropertyValue);
+};
+
+// 4. Main schema — flat, reads as a table of contents
+export const basicInfoValidation: ValidationSchemaFn<CreditApplicationForm> = (path) => {
+  validate(path.loanType, required());
+  validate(path.personalData.birthDate, validateAdultAge);
+  applyWhen(path.loanType, (type) => type === 'mortgage', mortgageFieldsRules);
+};
+```
+
+**Naming convention** (camelCase, semantic — not echoing the operator name):
+
+- `applyWhen` sub-schema → describes the conditional branch: `mortgageFieldsRules`, `employedFieldsRules`.
+- Cross-field `Validator` → describes the invariant: `initialPaymentVsPropertyValue`, `paymentToIncomeUnderHalf`.
+- Field-level `Validator` → describes the check: `validateAdultAge`, `validatePasswordsMatch`.
+
+**When to extract.** Inline lambdas are fine for short one-liners
+(`applyWhen(path.x, (v) => v === 'mortgage', mortgageFieldsRules)` — the condition stays inline).
+Extract whenever the body spans more than ~3 lines or contains nested rules.
+
 ## 6. 4. COMMON MISTAKES
 
 ### TSC overload-resolution error: `'form' does not exist in FormSchema<T>`
@@ -1274,19 +1351,32 @@ enableWhen(path.vehicle.vin, (form) => form.insuranceType === 'casco', { resetOn
 
 See `22-cycle-detection.md` for complete pattern.
 
-### validateTree Typing
+### Cross-field валидация — через `validate` + `root`
 
 ```typescript
-// WRONG - implicit any
-validateTree((ctx) => { ... });
+// Validator signature: (value, control, root) => ValidationError | null
+// Cross-field правило вешается на ПОЛЕ-НОСИТЕЛЬ ошибки. Соседние поля читаются через `root`.
 
-// CORRECT - explicit typing
-validateTree((ctx: { form: MyForm }) => {
-  if (ctx.form.field1 > ctx.form.field2) {
+// CORRECT — ошибка ложится на path.field1
+validate(path.field1, (_value, _control, root) => {
+  const form = root.getValue();         // typed as TForm
+  if (form.field1 > form.field2) {
     return { code: 'error', message: 'Invalid' };
   }
   return null;
 });
+
+// CORRECT — те же поля через reactive-доступ
+validate(path.address.city, (value, _control, root) => {
+  if (!value && root.address.region.value.value) {
+    return { code: 'cityRequired', message: 'City required when region is set' };
+  }
+  return null;
+});
+
+// WRONG - old API removed
+validateGroup(scopePath, (scope, root) => { ... });  // validateGroup убран
+validateTree((ctx) => { ... });                       // validateTree no longer exists
 ```
 
 ## 16. 14. PROJECT STRUCTURE (COLOCATION)
@@ -1787,18 +1877,18 @@ The "one watcher per trigger" cycle-prevention rule means **never register two w
 
 ```typescript
 // WRONG - bracket notation does NOT work!
-const first = form.items[0]; // undefined or error
-const second = form.items[1]; // undefined or error
+const first = form.items[0];        // undefined or error
+const second = form.items[1];       // undefined or error
 
 // CORRECT - use .at() method
-const first = form.items.at(0); // FormProxy<ItemType> | undefined
-const second = form.items.at(1); // FormProxy<ItemType> | undefined
+const first = form.items.at(0);     // FormProxy<ItemType> | undefined
+const second = form.items.at(1);    // FormProxy<ItemType> | undefined
 
 // CORRECT - iterate with map (most common pattern)
 form.items.map((item, index) => {
   // item is fully typed GroupNode
   item.name.setValue('New Name');
-  item.price.value.value; // read value
+  item.price.value.value;  // read value
 });
 ```
 
@@ -1841,7 +1931,9 @@ function ItemsList({ form }: { form: FormProxy<MyForm> }) {
 
       {length === 0 && <p>No items yet</p>}
 
-      <button onClick={() => form.items.push({ name: '', price: 0 })}>Add Item</button>
+      <button onClick={() => form.items.push({ name: '', price: 0 })}>
+        Add Item
+      </button>
     </div>
   );
 }
@@ -1849,35 +1941,35 @@ function ItemsList({ form }: { form: FormProxy<MyForm> }) {
 
 ### Array Cross-Validation
 
+Cross-field правила по массиву пишутся как обычный `Validator`, вешаются на сам массив
+(или на любое поле-носитель ошибки), а данные читаются через `root`.
+
 ```typescript
 // Validate uniqueness across array items
-validateTree(
-  (ctx: { form: MyForm }) => {
-    const items = ctx.form.items;
-    const names = items.map((item) => item.name.value.value);
-    const uniqueNames = new Set(names);
-
-    if (names.length !== uniqueNames.size) {
-      return { code: 'duplicate', message: 'Item names must be unique' };
-    }
-    return null;
-  },
-  { targetField: 'items' }
-);
+validate(path.items, (_value, _control, root) => {
+  const items = root.items;
+  const names = items.map((item) => item.name.value.value);
+  const uniqueNames = new Set(names);
+
+  if (names.length !== uniqueNames.size) {
+    return { code: 'duplicate', message: 'Item names must be unique' };
+  }
+  return null;
+});
 
 // Validate sum of percentages
-validateTree(
-  (ctx: { form: MyForm }) => {
-    const items = ctx.form.items;
-    const totalPercent = items.reduce((sum, item) => sum + (item.percentage.value.value || 0), 0);
+validate(path.items, (_value, _control, root) => {
+  const items = root.items;
+  const totalPercent = items.reduce(
+    (sum, item) => sum + (item.percentage.value.value || 0),
+    0
+  );
 
-    if (Math.abs(totalPercent - 100) > 0.01) {
-      return { code: 'invalid_total', message: 'Percentages must sum to 100%' };
-    }
-    return null;
-  },
-  { targetField: 'items' }
-);
+  if (Math.abs(totalPercent - 100) > 0.01) {
+    return { code: 'invalid_total', message: 'Percentages must sum to 100%' };
+  }
+  return null;
+});
 ```
 
 ## 22. Cycle Detection Prevention Checklist
@@ -3954,106 +4046,6 @@ export type AnyFunction = (...args: never[]) => unknown;
 
 _Source: src/core/types/index.ts_
 
-### apply
-
-**Kind:** `function`
-
-Применить validation схему к вложенному полю или полям
-
-Поддерживает:
-- Одно поле или массив полей
-- Одну схему или массив схем
-- Все комбинации (поле + схема, поле + схемы, поля + схема, поля + схемы)
-
-**Signature:**
-```typescript
-export function apply<TForm, TField>(
-  fields:
-    | FieldPathNode<TForm, TField>
-    | Array<FieldPathNode<TForm, TField> | undefined>
-    | undefined,
-  validationSchemas: ValidationSchemaFn<TField> | Array<ValidationSchemaFn<TField>>
-): void;
-```
-
-**Parameters:**
-- `fields` — - Одно поле или массив полей
-- `validationSchemas` — - Одна схема или массив схем
-
-**Examples:**
-
-```typescript
-// Одна схема к одному полю
-apply(path.registrationAddress, addressValidation);
-
-// Одна схема к нескольким полям
-apply([path.homeAddress, path.workAddress], addressValidation);
-
-// Несколько схем к одному полю
-apply(path.email, [emailValidation, uniqueEmailValidation]);
-
-// Несколько схем к нескольким полям
-apply(
-  [path.email, path.confirmEmail],
-  [emailValidation, matchValidation]
-);
-```
-
-_Source: src/core/validation/core/apply.ts_
-
-### applyWhen
-
-**Kind:** `function`
-
-Условное применение behavior схем (аналог applyWhen из validation API)
-
-⚠️ ВАЖНО: Эта функция НЕ создаёт новые behaviors при каждом изменении условия!
-Вместо этого behaviors регистрируются ОДИН РАЗ при первом вызове и затем
-просто не выполняются, если условие не выполнено.
-
-Это отличается от старой реализации, которая создавала утечку памяти,
-регистрируя behaviors при каждом изменении conditionField.
-
-**Signature:**
-```typescript
-export function applyWhen<TForm extends FormFields, TValue extends FormValue>(
-  conditionField: FieldPathNode<TForm, TValue> | undefined,
-  condition: (value: TValue) => boolean,
-  callback: (path: FieldPath<TForm>) => void
-): void
-```
-
-**Parameters:**
-- `conditionField` — - Поле для проверки условия
-- `condition` — - Функция проверки условия
-- `callback` — - Callback для применения behavior схем
-
-**Examples:**
-
-```typescript
-// Применить addressBehavior только когда sameAsRegistration === false
-applyWhen(
-  path.sameAsRegistration,
-  (value) => value === false,
-  (path) => {
-    apply(path.residenceAddress, addressBehavior);
-  }
-);
-
-// Или с прямым использованием path
-applyWhen(
-  path.hasProperty,
-  (value) => value === true,
-  (path) => {
-    apply(path.properties, propertyBehavior);
-    // Можно применить несколько схем
-    apply([path.properties, path.items], arrayBehavior);
-  }
-);
-```
-
-_Source: src/core/behavior/compose-behavior.ts_
-
 ### ArrayConfig
 
 **Kind:** `interface`
@@ -4227,7 +4219,7 @@ ArrayNode - массив форм с реактивным состоянием
 
 **Signature:**
 ```typescript
-export class ArrayNode<T extends FormFields> extends FormNode<T[]> {
+export class ArrayNode<T extends object> extends FormNode<T[]> {
   // ============================================================================
   // Приватные поля
   // ============================================================================ /* … */ }
@@ -4265,6 +4257,25 @@ export interface ArrayNodeLike {
 
 _Source: src/core/types/index.ts_
 
+### AsyncValidator
+
+**Kind:** `type`
+
+Чистый асинхронный валидатор поля.
+
+Регистрируется через `validateAsync(path, validator, { debounce })`.
+
+**Signature:**
+```typescript
+export type AsyncValidator<TForm, TField> = (
+  value: TField,
+  control: FormProxy<TField>,
+  root: FormProxy<TForm>
+) => Promise<ValidationError | null>;
+```
+
+_Source: src/core/types/validation-schema.ts_
+
 ### AsyncValidatorFn
 
 **Kind:** `type`
@@ -4324,697 +4335,258 @@ export interface AsyncValidatorOptions {
 
 _Source: src/core/types/index.ts_
 
-### BehaviorContext
+### BehaviorCleanup
 
 **Kind:** `type`
 
-Контекст для behavior callback функций
-Алиас для FormContext
+Функция отписки от behavior-эффекта.
 
 **Signature:**
 ```typescript
-export type BehaviorContext<TForm> = FormContext<TForm>;
-```
-
-**Examples:**
-
-```typescript
-watchField(path.country, async (country, ctx) => {
-  // Прямой типизированный доступ к полям
-  const cities = await fetchCities(country);
-  ctx.form.city.updateComponentProps({ options: cities });
-
-  // Безопасная установка значения (без циклов)
-  ctx.setFieldValue('city', null);
-});
+export type BehaviorCleanup = () => void;
 ```
 
-_Source: src/core/behavior/types.ts_
+_Source: src/core/model/behaviors.ts_
 
-### BehaviorContextImpl
+### computeFrom
 
-**Kind:** `class`
+**Kind:** `function`
 
-Реализация {@link FormContext} для behaviors. Создаётся фреймворком и передаётся
-в callback'и behaviors (`watchField`, `computeFrom`, …) — напрямую инстанцировать
-не нужно.
+Вычисляемое поле: `target = fn(...sourceValues)` при изменении источников.
 
 **Signature:**
 ```typescript
-export class BehaviorContextImpl<TForm> implements FormContext<TForm> {
-  /**
-   * Форма с типизированным Proxy-доступом к полям
-   */ /* … */ }
+export function computeFrom<R>(
+  sources: ReadonlySignal<any>[],
+  target: Signal<R>,
+  fn: (...values: any[]) => R,
+  options?: { when?: (...values: any[]) => boolean }
+): BehaviorCleanup
 ```
 
+**Parameters:**
+- `sources` — Сигналы-источники (`model.$.a`, `model.$.b`).
+- `target` — Сигнал-цель (`model.$.total`).
+- `fn` — Функция вычисления значения.
+
+**Returns:** Cleanup для отписки.
+
 **Examples:**
 
 ```typescript
-import { watchField } from '@reformer/core/behaviors/watch-field';
-
-watchField(path.country, (value, ctx) => {
-  // ctx — экземпляр BehaviorContextImpl
-  ctx.setFieldValue(path.city, '');
-});
+computeFrom([model.$.price, model.$.qty], model.$.total, (price, qty) => price * qty);
 ```
 
-_Source: src/core/behavior/behavior-context.ts_
+_Source: src/core/model/behaviors.ts_
 
-### BehaviorHandlerFn
+### ConditionFn
 
 **Kind:** `type`
 
-Функция-handler для behavior
-
-Создает effect подписку для реактивного поведения формы.
+Функция условия для applyWhen.
 
 **Signature:**
 ```typescript
-export type BehaviorHandlerFn<TForm> = (
-  form: GroupNode<TForm>,
-  context: BehaviorContext<TForm>,
-  withDebounce: (callback: () => void) => void
-) => (() => void) | null;
+export type ConditionFn<T> = (value: T) => boolean;
 ```
 
-**Parameters:**
-- `form` — - Корневой узел формы (GroupNode)
-- `context` — - Контекст для работы с формой
-- `withDebounce` — - Функция-обертка для debounce
+_Source: src/core/types/validation-schema.ts_
 
-**Returns:** Функция cleanup для отписки от effect или null
+### ConfigWithSchema
 
-**Examples:**
+**Kind:** `interface`
 
-```typescript
-const handler: BehaviorHandlerFn<MyForm> = (form, context, withDebounce) => {
-  const sourceNode = form.getFieldByPath('email');
+Конфиг с полем schema (для ArrayConfig)
 
-  return effect(() => {
-    const value = sourceNode.value.value;
-    withDebounce(() => {
-      // Логика behavior
-    });
-  });
-};
+**Signature:**
+```typescript
+export interface ConfigWithSchema {
+  schema: unknown;
+  initialItems?: unknown[];
+}
 ```
 
-_Source: src/core/behavior/types.ts_
+_Source: src/core/types/index.ts_
 
-### BehaviorOptions
+### ConfigWithValue
 
 **Kind:** `interface`
 
-Общие опции для behavior
+Конфиг с полем value (для извлечения значений)
 
 **Signature:**
 ```typescript
-export interface BehaviorOptions {
-  /** Debounce в миллисекундах */
-  debounce?: number;
+export interface ConfigWithValue {
+  value: unknown;
 }
 ```
 
-_Source: src/core/behavior/types.ts_
-
-### BehaviorRegistry
-
-**Kind:** `class`
+_Source: src/core/types/index.ts_
 
-Реестр behaviors для формы
+### copyFrom
 
-Каждый экземпляр GroupNode создает собственный реестр (композиция).
-Устраняет race conditions и изолирует формы друг от друга.
+**Kind:** `function`
 
-Наследует AbstractRegistry для унификации:
-- Управления global stack
-- Template methods begin/end registration
+Копирование значения `source → target` (опционально по условию/с трансформом).
 
 **Signature:**
 ```typescript
-export class BehaviorRegistry extends AbstractRegistry<RegisteredBehavior> {
-  /**
-   * Получить текущий активный реестр из context stack
-   *
-   * @returns Текущий активный реестр или null
-   *
-   * @example
-   * ```typescript
-   * // В schema-behaviors.ts
-   * export function copyFrom(...) {
-   *   const registry = BehaviorRegistry.getCurrent();
-   *   if (registry) {
-   *     registry.register({ ... });
-   *   }
-   * }
-   * ```
-   */ /* … */ }
+export function copyFrom<T>(
+  source: ReadonlySignal<T>,
+  target: Signal<T>,
+  options?: { when?: () => boolean; transform?: (value: T) => T }
+): BehaviorCleanup
 ```
 
 **Examples:**
 
 ```typescript
-class GroupNode {
-  private readonly behaviorRegistry = new BehaviorRegistry();
-
-  applyBehaviorSchema(schemaFn) {
-    this.behaviorRegistry.beginRegistration(); // Pushes this to stack
-    schemaFn(createBehaviorFieldPath(this));   // Uses getCurrent()
-    return this.behaviorRegistry.endRegistration(this); // Pops from stack
-  }
-}
-```
-
-_Source: src/core/behavior/behavior-registry.ts_
-
-### BehaviorSchemaFn
-
-**Kind:** `type`
-
-Тип функции behavior схемы
-Принимает FieldPath и описывает поведение формы
-
-**Signature:**
-```typescript
-export type BehaviorSchemaFn<T> = (path: FieldPath<T>) => void;
+copyFrom(model.$.email, model.$.emailAdditional, { when: () => model.sameEmail });
 ```
 
-_Source: src/core/behavior/types.ts_
+_Source: src/core/model/behaviors.ts_
 
-### computeFrom
+### createForm
 
 **Kind:** `function`
 
-Автоматически вычисляет значение поля на основе других полей
+Создать форму с полной конфигурацией (form, behavior, validation)
 
 **Signature:**
 ```typescript
-export function computeFrom<TForm, TTarget>(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  sources: FieldPathNode<TForm, any>[],
-  target: FieldPathNode<TForm, TTarget>,
-  computeFn: (values: TForm) => TTarget,
-  options?: ComputeFromOptions<TForm>
-): void
+export function createForm<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>;
 ```
 
 **Parameters:**
-- `sources` — - Массив полей-зависимостей
-- `target` — - Поле для записи результата
-- `computeFn` — - Функция вычисления (принимает объект с именами полей)
-- `options` — - Опции (`debounce`, `condition`, `trigger`)
+- `config` — - Конфигурация формы с полями, поведением и валидацией
+
+**Returns:** Типизированная форма с Proxy-доступом к полям
 
 **Examples:**
 
-Многополевой расчёт — total = price × quantity
 ```typescript
-import { computeFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface OrderForm {
-price: number;
-quantity: number;
-total: number;
-}
+const form = createForm<UserForm>({
+  form: {
+    email: { value: '', component: Input },
+    password: { value: '', component: Input },
+  },
+  validation: (path) => {
+    required(path.email);
+    email(path.email);
+    required(path.password);
+    minLength(path.password, 8);
+  },
+});
 
-export const orderBehavior: BehaviorSchemaFn<OrderForm> = (path) => {
-computeFrom(
-[path.price, path.quantity],
-path.total,
-(values) =>
-(typeof values.price === 'number' ? values.price : 0) *
-(typeof values.quantity === 'number' ? values.quantity : 0),
-);
-};
+// TypeScript знает о полях:
+form.email.setValue('test@mail.com');
 ```
 
-Edge case — async-like дорогие вычисления с `debounce` и условием
-```typescript
-import { computeFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+_Source: src/core/utils/create-form.ts_
 
-interface MortgageForm {
-loanType: 'mortgage' | 'consumer';
-loanAmount: number;
-loanTerm: number;
-interestRate: number;
-monthlyPayment: number;
-}
+### createFormFromModel
 
-function annuity(values: MortgageForm): number {
-const { loanAmount, loanTerm, interestRate } = values;
-if (!loanAmount || !loanTerm || !interestRate) return 0;
-const r = interestRate / 100 / 12;
-const n = loanTerm;
-return Math.round((loanAmount * r * Math.pow(1 + r, n)) / (Math.pow(1 + r, n) - 1));
-}
+**Kind:** `function`
 
-export const mortgageBehavior: BehaviorSchemaFn<MortgageForm> = (path) => {
-computeFrom(
-[path.loanAmount, path.loanTerm, path.interestRate],
-path.monthlyPayment,
-annuity,
-{
-debounce: 300,                                  // не пересчитываем на каждый keystroke
-condition: (form) => form.loanType === 'mortgage', // считаем только для ипотеки
-},
-);
-};
+**Signature:**
+```typescript
+export function createFormFromModel<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>
 ```
 
-**See also:**
-- [docs/llms/20-compute-vs-watch.md](../../../../docs/llms/20-compute-vs-watch.md)
-
-_Source: src/core/behavior/behaviors/compute-from.ts_
+_Source: src/core/utils/create-form.ts_
 
-### ComputeFromOptions
+### CreateFormFromModelArgs
 
 **Kind:** `interface`
 
-Опции для computeFrom
+Аргументы createForm под архитектуру M1: данные приходят из {@link FormModel},
+конфиг полей (component/componentProps/validators) — из единой схемы.
 
 **Signature:**
 ```typescript
-export interface ComputeFromOptions<TForm> {
-  /** Когда вычислять */
-  trigger?: 'change' | 'blur';
-
-  /** Debounce в мс */
-  debounce?: number;
-
-  /** Условие применения */
-  condition?: (form: TForm) => boolean;
+export interface CreateFormFromModelArgs<T> {
+  /** Реактивная модель данных (источник истины значений). */
+  model: FormModel<T>;
+  /**
+   * Единая Schema (дерево узлов). createForm обходит её и привязывает конфиг поля к ноде
+   * по идентичности сигнала (`node.value === model.$.path`). Опциональна.
+   */
+  schema?: unknown;
+  /**
+   * Декларативная схема поведения ({@link defineFormBehavior}). Запускается ПОСЛЕ построения нод и
+   * заполнения реестра сигнал→нода; cleanup живёт на форме и вызывается в `form.dispose()`.
+   */
+  behavior?: FormBehavior<T>;
 }
 ```
 
-_Source: src/core/behavior/types.ts_
+_Source: src/core/utils/create-form.ts_
 
-### ConditionFn
+### createModel
 
-**Kind:** `type`
+**Kind:** `function`
 
-Функция условия для applyWhen
+Создать реактивную модель данных формы (слой M1).
 
 **Signature:**
 ```typescript
-export type ConditionFn<T> = (value: T) => boolean;
+export function createModel<T extends object>(initial: T): FormModel<T>
 ```
 
-_Source: src/core/types/validation-schema.ts_
-
-### ConfigWithSchema
+**Parameters:**
+- `initial` — Начальные значения (объект). Определяют форму данных и initial-снимок.
 
-**Kind:** `interface`
+**Returns:** 
 
-Конфиг с полем schema (для ArrayConfig)
+**Examples:**
 
-**Signature:**
 ```typescript
-export interface ConfigWithSchema {
-  schema: unknown;
-  initialItems?: unknown[];
-}
+const model = createModel<{ email: string; tags: string[] }>({ email: '', tags: [] });
+model.email = 'a@b.c';
+model.$.email.value;        // 'a@b.c' (сигнал)
+model.tags.push('x');
+model.get();                // { email: 'a@b.c', tags: ['x'] }
 ```
 
-_Source: src/core/types/index.ts_
+_Source: src/core/model/form-model.ts_
 
-### ConfigWithValue
+### disableWhen
 
-**Kind:** `interface`
+**Kind:** `function`
 
-Конфиг с полем value (для извлечения значений)
+Условное выключение поля (инверсия {@link enableWhen}).
 
 **Signature:**
 ```typescript
-export interface ConfigWithValue {
-  value: unknown;
-}
+export function disableWhen(
+  target: ReadonlySignal<unknown>,
+  condition: () => boolean,
+  options?: { resetOnDisable?: boolean }
+): BehaviorCleanup
 ```
 
-_Source: src/core/types/index.ts_
+_Source: src/core/model/behaviors.ts_
 
-### ContextualAsyncValidatorFn
-
-**Kind:** `type`
-
-Асинхронная функция валидации поля с контекстом
-
-**Signature:**
-```typescript
-export type ContextualAsyncValidatorFn<TForm, TField> = (
-  value: TField,
-  ctx: FormContext<TForm>
-) => Promise<ValidationError | null>;
-```
-
-**Examples:**
-
-```typescript
-validateAsync(path.email, async (value, ctx) => {
-  const exists = await checkEmailExists(value);
-  if (exists) return { code: 'exists', message: 'Email already taken' };
-  return null;
-});
-```
-
-_Source: src/core/types/validation-schema.ts_
-
-### ContextualValidatorFn
-
-**Kind:** `type`
-
-Функция валидации поля с контекстом
-
-Новый паттерн: (value, ctx: FormContext) => ValidationError | null
-
-**Signature:**
-```typescript
-export type ContextualValidatorFn<TForm, TField> = (
-  value: TField,
-  ctx: FormContext<TForm>
-) => ValidationError | null;
-```
-
-**Examples:**
-
-```typescript
-validate(path.email, (value, ctx) => {
-  if (!value) return { code: 'required', message: 'Email required' };
-  const confirm = ctx.form.confirmEmail.value.value;
-  if (value !== confirm) return { code: 'mismatch', message: 'Must match' };
-  return null;
-});
-```
-
-_Source: src/core/types/validation-schema.ts_
-
-### copyFrom
-
-**Kind:** `function`
-
-Копирует значения из одного поля/группы в другое при выполнении условия
-
-**Signature:**
-```typescript
-export function copyFrom<TForm, TSource, TTarget>(
-  source: FieldPathNode<TForm, TSource>,
-  target: FieldPathNode<TForm, TTarget>,
-  options?: CopyFromOptions<TSource, TForm>
-): void
-```
-
-**Parameters:**
-- `source` — - Откуда копировать
-- `target` — - Куда копировать
-- `options` — - Опции копирования (`when`, `fields`, `transform`, `debounce`)
-
-**Examples:**
-
-Скаляр → скаляр с условием
-```typescript
-import { copyFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface ContactForm {
-sameEmail: boolean;
-email: string;
-emailAdditional: string;
-}
-
-export const contactBehavior: BehaviorSchemaFn<ContactForm> = (path) => {
-copyFrom(path.email, path.emailAdditional, {
-when: (form) => form.sameEmail === true,
-});
-};
-```
-
-Копирование группы с подмножеством полей и `transform`
-```typescript
-import { copyFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface Address { country: string; region: string; city: string; street: string }
-interface ProfileForm {
-sameAsRegistration: boolean;
-registrationAddress: Address;
-residenceAddress: Address;
-}
-
-export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
-copyFrom(path.registrationAddress, path.residenceAddress, {
-when: (form) => form.sameAsRegistration === true,
-fields: ['country', 'region', 'city'], // street НЕ копируем
-transform: (addr) => ({
-...addr,
-country: addr.country.toUpperCase(), // нормализация при копировании
-}),
-debounce: 200,
-});
-};
-```
-
-**See also:**
-- [docs/llms/23-copy-from.md](../../../../docs/llms/23-copy-from.md)
-
-_Source: src/core/behavior/behaviors/copy-from.ts_
-
-### CopyFromOptions
-
-**Kind:** `interface`
-
-Опции для copyFrom
-
-**Signature:**
-```typescript
-export interface CopyFromOptions<TSource, TForm = unknown> {
-  /** Условие копирования */
-  when?: (form: TForm) => boolean;
-
-  /** Какие поля копировать (для групп) */
-  fields?: (keyof TSource)[] | 'all';
-
-  /** Трансформация значения */
-  transform?: (value: TSource) => unknown;
-
-  /** Debounce в мс */
-  debounce?: number;
-}
-```
-
-_Source: src/core/behavior/types.ts_
-
-### createFieldPath
-
-**Kind:** `function`
-
-Создать FieldPath proxy для формы
-
-**Signature:**
-```typescript
-export function createFieldPath<T>(): FieldPath<T>
-```
-
-**Examples:**
-
-```typescript
-const path = createFieldPath<MyForm>();
-console.log(path.email.__path); // 'email'
-console.log(path.personalData.firstName.__path); // 'personalData.firstName'
-```
-
-_Source: src/core/utils/field-path.ts_
-
-### createForm
-
-**Kind:** `function`
-
-Создать форму с полной конфигурацией (form, behavior, validation)
-
-**Signature:**
-```typescript
-export function createForm<T>(config: GroupNodeConfig<T>): FormProxy<T>;
-```
-
-**Parameters:**
-- `config` — - Конфигурация формы с полями, поведением и валидацией
-
-**Returns:** Типизированная форма с Proxy-доступом к полям
-
-**Examples:**
-
-```typescript
-const form = createForm<UserForm>({
-  form: {
-    email: { value: '', component: Input },
-    password: { value: '', component: Input },
-  },
-  validation: (path) => {
-    required(path.email);
-    email(path.email);
-    required(path.password);
-    minLength(path.password, 8);
-  },
-});
-
-// TypeScript знает о полях:
-form.email.setValue('test@mail.com');
-```
-
-_Source: src/core/utils/create-form.ts_
-
-### createTransformer
+### email
 
 **Kind:** `function`
 
-Хелпер для создания переиспользуемых трансформаций
-
-**Signature:**
-```typescript
-export function createTransformer<TValue extends FormValue = FormValue>(
-  transformer: (value: TValue) => TValue,
-  defaultOptions?: TransformValueOptions
-)
-```
-
-**Parameters:**
-- `transformer` — - Идемпотентная функция преобразования значения
-- `defaultOptions` — - Опции, применяемые ко всем вызовам созданного трансформера
-
-**Examples:**
-
-Доменно-специфичные трансформеры (банковский счёт, СНИЛС)
-```typescript
-import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-// Сохраняем только цифры и форматируем СНИЛС: 000-000-000 00
-const formatSnils = createTransformer<string>((v) => {
-const d = (v ?? '').replace(/\D/g, '').slice(0, 11);
-if (d.length < 9) return d;
-return `${d.slice(0, 3)}-${d.slice(3, 6)}-${d.slice(6, 9)}${d.length > 9 ? ' ' + d.slice(9) : ''}`;
-});
-
-interface ProfileForm { snils: string }
-
-export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
-formatSnils(path.snils, { debounce: 100 });
-};
-```
-
-С `defaultOptions` — единые настройки на серию полей
-```typescript
-import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-// Все коды должны быть uppercase, но только после правки пользователем
-const upperOnUserEdit = createTransformer<string>(
-(v) => (v ?? '').toUpperCase(),
-{ onUserChangeOnly: true, debounce: 100 },
-);
-
-interface PromoForm { promoCode: string; partnerCode: string }
-
-export const promoBehavior: BehaviorSchemaFn<PromoForm> = (path) => {
-upperOnUserEdit(path.promoCode);
-upperOnUserEdit(path.partnerCode);
-};
-```
-
-_Source: src/core/behavior/behaviors/transform-value.ts_
-
-### disableWhen
-
-**Kind:** `function`
-
-Условное выключение поля (инверсия enableWhen)
-
-**Signature:**
-```typescript
-export function disableWhen<TForm>(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  field: FieldPathNode<TForm, any>,
-  condition: (form: TForm) => boolean,
-  options?: EnableWhenOptions
-): void
-```
-
-**Parameters:**
-- `field` — - Поле для выключения
-- `condition` — - Функция условия (true = disable, false = enable)
-- `options` — - Опции (`resetOnDisable`, `debounce`)
+Фабрика валидатора формата email.
 
-**Examples:**
-
-Базовый сценарий — readonly после подтверждения
-```typescript
-import { disableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface ConfirmForm {
-isConfirmed: boolean;
-editableField: string;
-}
-
-export const confirmBehavior: BehaviorSchemaFn<ConfirmForm> = (path) => {
-// Поле блокируется после установки чекбокса подтверждения
-disableWhen(path.editableField, (form) => form.isConfirmed === true);
-// resetOnDisable НЕ ставим — сохраняем введённый текст
-};
-```
-
-С `resetOnDisable` для очистки заблокированного поля
-```typescript
-import { disableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface PromoForm {
-loanType: 'mortgage' | 'consumer';
-promoCode: string;
-}
-
-export const promoBehavior: BehaviorSchemaFn<PromoForm> = (path) => {
-// Промокод недоступен для потребительских кредитов и сбрасывается
-disableWhen(path.promoCode, (form) => form.loanType === 'consumer', {
-resetOnDisable: true,
-});
-};
-```
-
-_Source: src/core/behavior/behaviors/enable-when.ts_
-
-### email
-
-**Kind:** `function`
-
-Валидатор формата email
-
-Проверяет, что значение соответствует формату email адреса.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function email<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function email<TForm = unknown, TField extends string | undefined = string>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  required(path.email),
-  email(path.email),
-]
-
-// С кастомным сообщением
-email(path.email, { message: 'Введите корректный email адрес' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'email',
-  message: 'Неверный формат email',
-  params: {}
-}
+validate(path.email, email());
+validate(path.email, email({ message: 'Введите корректный email' }));
 ```
 
 _Source: src/core/validation/validators/email.ts_
@@ -5023,107 +4595,30 @@ _Source: src/core/validation/validators/email.ts_
 
 **Kind:** `function`
 
-Условное включение поля на основе значений других полей
+Условное включение поля (state-операция). Резолвит ноду по сигналу-цели через реестр
+сигнал→нода (заполняется `createForm`) и вызывает `enable()`/`disable()` (+`reset()` при
+`resetOnDisable`). `condition` реактивен (читает свои сигналы модели).
+
+Запись состояния отложена через `runOutsideEffect` (микротаск) для защиты от «Cycle detected».
+⚠️ Поле должно быть материализовано в форме (`createForm`) — иначе ноды в реестре нет (например,
+элемент массива, который строится per-item).
 
 **Signature:**
 ```typescript
-export function enableWhen<TForm>(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  field: FieldPathNode<TForm, any>,
-  condition: (form: TForm) => boolean,
-  options?: EnableWhenOptions
-): void
+export function enableWhen(
+  target: ReadonlySignal<unknown>,
+  condition: () => boolean,
+  options?: { resetOnDisable?: boolean }
+): BehaviorCleanup
 ```
 
-**Parameters:**
-- `field` — - Поле для включения/выключения
-- `condition` — - Функция условия (true = enable, false = disable)
-- `options` — - Опции (`resetOnDisable`, `debounce`)
-
 **Examples:**
 
-Базовый сценарий с `resetOnDisable: true`
 ```typescript
-import { enableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface LoanForm {
-loanType: 'mortgage' | 'consumer' | 'car';
-propertyValue: number;
-initialPayment: number;
-}
-
-export const loanBehavior: BehaviorSchemaFn<LoanForm> = (path) => {
-// Поля ипотеки активны только для loanType === 'mortgage'.
-// resetOnDisable: true гарантирует чистые initial values при переключении.
-enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage', {
-resetOnDisable: true,
-});
-enableWhen(path.initialPayment, (form) => form.loanType === 'mortgage', {
-resetOnDisable: true,
-});
-};
+enableWhen(model.$.propertyValue, () => model.loanType === 'mortgage', { resetOnDisable: true });
 ```
 
-Множественные independent условия + cycle prevention
-```typescript
-import { enableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface ProfileForm {
-sameAsRegistration: boolean;
-employmentStatus: 'employed' | 'selfEmployed' | 'unemployed';
-residenceAddress: { city: string; street: string };
-companyName: string;
-companyInn: string;
-businessType: string;
-}
-
-export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
-// Адрес проживания: enabled, когда НЕ совпадает с регистрационным
-enableWhen(path.residenceAddress, (form) => form.sameAsRegistration === false, {
-resetOnDisable: true,
-});
-
-// Поля работодателя: только для employed
-enableWhen(path.companyName, (form) => form.employmentStatus === 'employed', {
-resetOnDisable: true,
-});
-enableWhen(path.companyInn, (form) => form.employmentStatus === 'employed', {
-resetOnDisable: true,
-});
-
-// ИП-поля: только для selfEmployed
-enableWhen(path.businessType, (form) => form.employmentStatus === 'selfEmployed', {
-resetOnDisable: true,
-});
-
-// ВАЖНО: condition не должен читать значение САМОГО поля — иначе цикл.
-// condition зависит ТОЛЬКО от независимых триггеров (loanType, employmentStatus, ...).
-};
-```
-
-**See also:**
-- [docs/llms/22-cycle-detection.md](../../../../docs/llms/22-cycle-detection.md)
-
-_Source: src/core/behavior/behaviors/enable-when.ts_
-
-### EnableWhenOptions
-
-**Kind:** `interface`
-
-Опции для enableWhen/disableWhen
-
-**Signature:**
-```typescript
-export interface EnableWhenOptions {
-  /** Сбросить значение при disable */
-  resetOnDisable?: boolean;
-
-  /** Debounce в мс */
-  debounce?: number;
-}
-```
-
-_Source: src/core/behavior/types.ts_
+_Source: src/core/model/behaviors.ts_
 
 ### ErrorFilterOptions
 
@@ -5183,58 +4678,6 @@ export enum ErrorStrategy {
 
 _Source: src/core/utils/error-handler.ts_
 
-### extractKey
-
-**Kind:** `function`
-
-Извлечь имя последнего сегмента ({@link FieldPathSegment}) пути.
-
-**Signature:**
-```typescript
-export function extractKey(node: FieldPathNode<unknown, unknown> | unknown): string
-```
-
-**Parameters:**
-- `node` — - Узел `FieldPathNode` либо строка-путь.
-
-**Returns:** Имя поля без префикса родителя (последний сегмент).
-
-**Examples:**
-
-```typescript
-import { extractKey } from '@reformer/core';
-
-extractKey(path.user.email); // → 'email'
-```
-
-_Source: src/core/utils/field-path.ts_
-
-### extractPath
-
-**Kind:** `function`
-
-Извлечь строковый путь из {@link FieldPathNode}.
-
-**Signature:**
-```typescript
-export function extractPath(node: FieldPathNode<unknown, unknown> | unknown): string
-```
-
-**Parameters:**
-- `node` — - Узел `FieldPathNode` либо строка-путь.
-
-**Returns:** Путь вида `"a.b.c"`.
-
-**Examples:**
-
-```typescript
-import { extractPath } from '@reformer/core';
-
-const path = (renderPath) => extractPath(renderPath.user.email); // → 'user.email'
-```
-
-_Source: src/core/utils/field-path.ts_
-
 ### FieldConfig
 
 **Kind:** `interface`
@@ -5244,9 +4687,22 @@ _Source: src/core/utils/field-path.ts_
 **Signature:**
 ```typescript
 export interface FieldConfig<T> {
-  value: T | null;
+  /**
+   * Начальное значение-литерал (legacy-путь). Под архитектурой M1 значение приходит из
+   * {@link FieldConfig.valueSignal} (сигнал {@link FormModel}); тогда `value` не требуется.
+   */
+  value?: T | null;
+  /**
+   * Сигнал значения из {@link FormModel} (M1). Если задан — служит источником истины значения
+   * поля (нода не владеет значением, а ссылается на этот сигнал). Имеет приоритет над `value`.
+   */
+  valueSignal?: Signal<T>;
+  /**
+   * UI-компонент поля. Опционален: core-часть можно использовать без ссылки на компонент
+   * (значение/валидация работают без UI; компонент нужен только для рендеринга).
+   */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  component: ComponentType<any>;
+  component?: ComponentType<any>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   componentProps?: any;
   validators?: ValidatorFn<T>[];
@@ -5500,133 +4956,6 @@ console.log(field.valid.value); // true
 
 _Source: src/core/nodes/field-node.ts_
 
-### FieldPath
-
-**Kind:** `type`
-
-FieldPath предоставляет типобезопасный доступ к путям полей формы
-
-Рекурсивно обрабатывает вложенные объекты для поддержки вложенных форм.
-
-Использование:
-```typescript
-const validation = (path: FieldPath<MyForm>) => {
-  required(path.email, { message: 'Email обязателен' });
-
-  // Вложенные объекты
-  required(path.registrationAddress.city);
-  minLength(path.registrationAddress.street, 3);
-
-  applyWhen(
-    path.loanType,
-    (type) => type === 'mortgage',
-    (path) => {
-      required(path.propertyValue, { message: 'Укажите стоимость' });
-    }
-  );
-};
-```
-
-**Signature:**
-```typescript
-export type FieldPath<T> = {
-  [K in keyof T]: NonNullable<T[K]> extends Array<unknown>
-    ? FieldPathNode<T, T[K], K> // Массивы - не рекурсим (обрабатываются отдельно)
-    : NonNullable<T[K]> extends Date | File | Blob | AnyFunction
-      ? FieldPathNode<T, T[K], K> // Специальные объекты - не рекурсим
-      : NonNullable<T[K]> extends object
-        ? FieldPathNode<T, T[K], K> & FieldPath<NonNullable<T[K]>> // Обычные объекты - рекурсия!
-        : FieldPathNode<T, T[K], K>; // Примитивы
-};
-```
-
-_Source: src/core/types/field-path.ts_
-
-### FieldPathNavigator
-
-**Kind:** `class`
-
-Навигация по путям к полям формы
-
-Централизует логику парсинга и навигации по путям к полям формы.
-Используется в ValidationContext, BehaviorContext, GroupNode для единообразной
-обработки путей вида "address.city" или "items[0].name".
-
-Устраняет дублирование логики парсинга путей в 4 местах кодовой базы.
-
-**Signature:**
-```typescript
-export class FieldPathNavigator {
-  /**
-   * Парсит путь в массив сегментов
-   *
-   * Поддерживаемые форматы:
-   * - Простые пути: "name", "email"
-   * - Вложенные пути: "address.city", "user.profile.avatar"
-   * - Массивы: "items[0]", "items[0].name", "tags[1][0]"
-   * - Комбинации: "orders[0].items[1].price"
-   *
-   * @param path Путь к полю (строка с точками и квадратными скобками)
-   * @returns Массив сегментов пути
-   *
-   * @example
-   * ```typescript
-   * navigator.parsePath('email');
-   * // [{ key: 'email' }]
-   *
-   * navigator.parsePath('address.city');
-   * // [{ key: 'address' }, { key: 'city' }]
-   *
-   * navigator.parsePath('items[0].name');
-   * // [{ key: 'items', index: 0 }, { key: 'name' }]
-   * ```
-   */ /* … */ }
-```
-
-**Examples:**
-
-```typescript
-const navigator = new FieldPathNavigator();
-
-// Парсинг пути
-const segments = navigator.parsePath('items[0].title');
-// [{ key: 'items', index: 0 }, { key: 'title' }]
-
-// Получение значения из объекта
-const obj = { items: [{ title: 'Item 1' }] };
-const value = navigator.getValueByPath(obj, 'items[0].title');
-// 'Item 1'
-
-// Получение узла формы
-const titleNode = navigator.getNodeByPath(form, 'items[0].title');
-titleNode?.setValue('New Title');
-```
-
-_Source: src/core/utils/field-path-navigator.ts_
-
-### FieldPathNode
-
-**Kind:** `interface`
-
-Узел в пути поля
-Содержит метаинформацию о поле для валидации
-
-**Signature:**
-```typescript
-export interface FieldPathNode<TForm, TField, TKey = unknown> {
-  /** Ключ поля */
-  readonly __key: TKey;
-  /** Путь к полю (для вложенных объектов) */
-  readonly __path: string;
-  /** Тип формы */
-  readonly __formType?: TForm;
-  /** Тип поля */
-  readonly __fieldType?: TField;
-}
-```
-
-_Source: src/core/types/field-path.ts_
-
 ### FieldPathSegment
 
 **Kind:** `type`
@@ -5667,7 +4996,7 @@ _Source: src/core/types/index.ts_
 
 **Signature:**
 ```typescript
-export type FormArrayProxy<T extends FormFields> = ArrayNode<T> & {
+export type FormArrayProxy<T extends object> = ArrayNode<T> & {
   /**
    * Безопасный доступ к элементу массива по индексу
    * Возвращает GroupNode с типизированными полями или undefined
@@ -5761,102 +5090,6 @@ export type FormChangeType = 'value' | 'status' | 'errors' | 'touched' | 'dirty'
 
 _Source: src/core/utils/form-observer.ts_
 
-### FormContext
-
-**Kind:** `interface`
-
-Единый контекст для работы с формой
-
-Предоставляет:
-- `form` - типизированный Proxy-доступ к полям формы
-- `setFieldValue` - безопасная установка значения (emitEvent: false)
-
-**Signature:**
-```typescript
-export interface FormContext<TForm> {
-  /**
-   * Форма с типизированным Proxy-доступом к полям
-   *
-   * Позволяет обращаться к полям напрямую через точечную нотацию:
-   * - `ctx.form.email` → FieldNode
-   * - `ctx.form.address.city` → FieldNode (вложенный)
-   * - `ctx.form.items` → ArrayNode
-   *
-   * @example
-   * ```typescript
-   * // Получить значение
-   * ctx.form.email.value.value
-   *
-   * // Установить значение (⚠️ может вызвать цикл в behavior!)
-   * ctx.form.email.setValue('new@mail.com')
-   *
-   * // Безопасно установить значение
-   * ctx.form.email.setValue('new@mail.com', { emitEvent: false })
-   *
-   * // Обновить пропсы компонента
-   * ctx.form.city.updateComponentProps({ options: cities })
-   *
-   * // Валидация поля
-   * await ctx.form.email.validate()
-   *
-   * // Работа с массивами
-   * ctx.form.items.push({ title: 'New' })
-   * ctx.form.items.clear()
-   * ```
-   */
-  readonly form: FormProxy<TForm>;
-
-  /**
-   * Безопасно установить значение поля по строковому пути или FieldPath
-   *
-   * Автоматически использует `emitEvent: false` для предотвращения
-   * бесконечных циклов в behavior схемах.
-   *
-   * @param path - Путь к полю (строка или FieldPath)
-   * @param value - Новое значение
-   *
-   * @example
-   * ```typescript
-   * // Сброс города при смене страны (строковый путь)
-   * watchField(path.country, (country, ctx) => {
-   *   ctx.setFieldValue('city', null);
-   * });
-   *
-   * // Использование FieldPath напрямую (более типобезопасно)
-   * watchField(path.country, (country, ctx) => {
-   *   ctx.setFieldValue(path.city, null);
-   * });
-   * ```
-   */
-  setFieldValue(path: string | FieldPathNode<TForm, unknown>, value: unknown): void;
-
-  /**
-   * Получить поле формы по строковому пути
-   *
-   * Используется для динамического доступа к вложенным полям,
-   * особенно в модульных behavior схемах, применяемых через apply().
-   *
-   * @param path - Строковый путь к полю (например "address.city")
-   * @returns FormNode или undefined если поле не найдено
-   *
-   * @example
-   * ```typescript
-   * // В модульной behavior схеме, применяемой к вложенному полю:
-   * // apply([path.registrationAddress, path.residenceAddress], addressBehavior)
-   *
-   * watchField(path.region, (region, ctx) => {
-   *   // path.city.__path = "registrationAddress.city" или "residenceAddress.city"
-   *   const cityField = ctx.getFieldByPath(path.city.__path);
-   *   cityField?.updateComponentProps({ options: cities });
-   * });
-   * ```
-   */
-  getFieldByPath(path: string): FormNode<FormValue> | undefined;
-}
-```
-
-_Source: src/core/types/form-context.ts_
-
 ### FormControlsProxy
 
 **Kind:** `type`
@@ -5874,15 +5107,16 @@ _Source: src/core/types/form-context.ts_
 **Signature:**
 ```typescript
 export type FormControlsProxy<T> = {
-  [K in keyof T]: NonNullable<T[K]> extends Array<infer U>
-    ? U extends FormFields
-      ? FormArrayProxy<U> // Массив объектов → FormArrayProxy
+  // `-?` снимает опциональность: для каждого поля схемы прокси всегда содержит узел
+  // (включая опциональные поля — у них узел существует, опционально лишь значение).
+  // Без этого `control.optionalField` имел бы тип `FieldNode<...> | undefined`.
+  [K in keyof T]-?: NonNullable<T[K]> extends ReadonlyArray<infer U>
+    ? IsGroupObject<U> extends true
+      ? FormArrayProxy<U & object> // Массив объектов → FormArrayProxy
       : FieldNode<T[K]> // Массив примитивов → FieldNode
-    : NonNullable<T[K]> extends FormFields
-      ? NonNullable<T[K]> extends Date | File | Blob
-        ? FieldNode<T[K]> // Специальные объекты → FieldNode
-        : FormProxy<NonNullable<T[K]>> // Обычный объект → FormProxy (рекурсивно!)
-      : FieldNode<T[K]>; // Примитивные типы → FieldNode
+    : IsGroupObject<NonNullable<T[K]>> extends true
+      ? FormProxy<NonNullable<T[K]>> // Обычный объект → FormProxy (рекурсивно!)
+      : FieldNode<T[K]>; // Примитивы и спец-объекты (Date/File/Blob) → FieldNode
 };
 ```
 
@@ -5986,6 +5220,19 @@ export type FormFields = Record<string, FormValue>;
 
 _Source: src/core/types/index.ts_
 
+### FormModel
+
+**Kind:** `type`
+
+FormModel — value-proxy объекта `T` + {@link ModelApi}.
+
+**Signature:**
+```typescript
+export type FormModel<T> = ModelObject<T> & ModelApi<T>;
+```
+
+_Source: src/core/model/types.ts_
+
 ### FormNode
 
 **Kind:** `class`
@@ -6276,99 +5523,40 @@ _Source: src/core/types/index.ts_
 
 **Kind:** `function`
 
-Проверяет, что дата находится в будущем (не в прошлом)
+Фабрика валидатора, проверяющего что дата не в прошлом.
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function futureDate<TForm, TField extends string | Date | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions
-): void
+export function futureDate<
+  TForm = unknown,
+  TField extends string | Date | undefined = string | Date,
+>(options?: ValidateOptions): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование - дата события должна быть в будущем
-validationSchema: (path) => [
-  futureDate(path.eventDate),
-]
-
-// С кастомным сообщением
-futureDate(path.appointmentDate, { message: 'Дата записи должна быть в будущем' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_past',
-  message: 'Дата не может быть в прошлом',
-  params: {}
-}
+validate(path.eventDate, futureDate());
+validate(path.appointmentDate, futureDate({ message: 'Дата записи должна быть в будущем' }));
 ```
 
 _Source: src/core/validation/validators/future-date.ts_
 
-### getCurrentBehaviorRegistry
-
-**Kind:** `function`
-
-Получить текущий активный BehaviorRegistry из context stack
-
-Используется внутри behavior schema функций (copyFrom, enableWhen, computeFrom и т.д.)
-для регистрации поведений в активном контексте GroupNode
-
-**Signature:**
-```typescript
-export function getCurrentBehaviorRegistry(): BehaviorRegistry
-```
-
-**Returns:** Текущий BehaviorRegistry или заглушка в production
-
-**Examples:**
-
-```typescript
-function copyFrom(target, source, options) {
-  const registry = getCurrentBehaviorRegistry();
-  const handler = createCopyBehavior(target, source, options);
-  registry.register(handler, { debounce: options?.debounce });
-}
-```
-
-_Source: src/core/utils/registry-helpers.ts_
-
-### getCurrentValidationRegistry
+### getNodeForSignal
 
 **Kind:** `function`
 
-Получить текущий активный ValidationRegistry из context stack
-
-Используется внутри validation schema функций (validate, validateAsync, required и т.д.)
-для регистрации валидаторов в активном контексте GroupNode
+Получить FieldNode по сигналу модели (или undefined, если форма не построена/поле не материализовано,
+например элемент массива в родительской форме).
 
 **Signature:**
 ```typescript
-export function getCurrentValidationRegistry(): ValidationRegistry
+export function getNodeForSignal(signal: Signal<any>): FormNode<any> | undefined
 ```
 
-**Returns:** Текущий ValidationRegistry или заглушка в production
-
-**Examples:**
-
-```typescript
-function required(fieldPath, options) {
-  const registry = getCurrentValidationRegistry();
-  registry.registerSync(path, validator, options);
-}
-```
-
-_Source: src/core/utils/registry-helpers.ts_
+_Source: src/core/utils/signal-node-registry.ts_
 
 ### getNodeType
 
@@ -6402,9 +5590,9 @@ _Source: src/core/utils/type-guards.ts_
 
 GroupNode - узел для группы полей
 
-Поддерживает два API:
-1. Старый API (только schema) - обратная совместимость
-2. Новый API (config с form, behavior, validation) - автоматическое применение схем
+Создаётся из {@link FormSchema} (дерево field-конфигов). Обычно строится через `createForm`
+(M1: `createForm({ model, schema })`); валидация/behavior живут на слое модели
+(`validateFormModel`, `computeFrom`/`enableWhen`/…), а не на ноде.
 
 **Signature:**
 ```typescript
@@ -6417,33 +5605,16 @@ export class GroupNode<T> extends FormNode<T> {
 **Examples:**
 
 ```typescript
-// 1. Старый способ (обратная совместимость)
-const simpleForm = new GroupNode({
-  email: { value: '', component: Input },
-  password: { value: '', component: Input },
-});
-
-// 2. Новый способ (с behavior и validation схемами)
-const fullForm = new GroupNode({
-  form: {
-    email: { value: '', component: Input },
-    password: { value: '', component: Input },
-  },
-  behavior: (path) => {
-    computeFrom(path.email, [path.email], (values) => values[0]?.trim());
-  },
-  validation: (path) => {
-    required(path.email, { message: 'Email обязателен' });
-    email(path.email);
-    required(path.password);
-    minLength(path.password, 8);
-  },
+const form = new GroupNode({
+  email: { valueSignal: model.$.email, component: Input },
+  password: { valueSignal: model.$.password, component: Input },
 });
 
 // Прямой доступ к полям через Proxy
-fullForm.email.setValue('test@mail.com');
-await fullForm.validate();
-console.log(fullForm.valid.value); // true
+const proxy = form.getProxy();
+proxy.email.setValue('test@mail.com');
+await proxy.validate();
+console.log(proxy.valid.value);
 ```
 
 _Source: src/core/nodes/group-node.ts_
@@ -6452,38 +5623,44 @@ _Source: src/core/nodes/group-node.ts_
 
 **Kind:** `interface`
 
-Конфигурация GroupNode с поддержкой схем
-Используется для создания форм с автоматическим применением behavior и validation схем
+Конфигурация GroupNode.
+
+Под M1 группа создаётся из плоской {@link FormSchema} (дерево field-конфигов). Обёртка
+`{ form }` сохранена для совместимости вызова, legacy behavior/validation-схемы удалены (Ф7).
 
 **Signature:**
 ```typescript
 export interface GroupNodeConfig<T> {
   /** Схема структуры формы (поля и их конфигурация) */
   form: FormSchema<T>;
+}
+```
 
-  /** Схема реактивного поведения (copyFrom, enableWhen, computeFrom и т.д.) */
-  behavior?: BehaviorSchemaFn<T>;
+_Source: src/core/types/index.ts_
 
-  /** Схема валидации (required, email, minLength и т.д.) */
-  validation?: ValidationSchemaFn<T>;
+### integer
 
-  /**
-   * Опциональный ValidationRegistry для dependency injection
-   * Используется для тестирования с mock-реестрами
-   * @internal
-   */
-  _validationRegistry?: unknown;
+**Kind:** `function`
 
-  /**
-   * Опциональный BehaviorRegistry для dependency injection
-   * Используется для тестирования с mock-реестрами
-   * @internal
-   */
-  _behaviorRegistry?: unknown;
-}
+Фабрика валидатора, проверяющего что число — целое.
+
+Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+
+**Signature:**
+```typescript
+export function integer<TForm = unknown, TField extends number | undefined = number>(
+  options?: ValidateOptions
+): Validator<TForm, TField>
 ```
 
-_Source: src/core/types/index.ts_
+**Examples:**
+
+```typescript
+validate(path.age, integer());
+validate(path.count, integer({ message: 'Должно быть целым числом' }));
+```
+
+_Source: src/core/validation/validators/integer.ts_
 
 ### isArrayNode
 
@@ -6520,45 +5697,38 @@ _Source: src/core/utils/type-guards.ts_
 
 **Kind:** `function`
 
-Проверяет, что значение является валидной датой
+Фабрика валидатора, проверяющего что значение — валидная дата.
 
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function isDate<TForm, TField extends string | Date | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function isDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  isDate(path.birthDate),
-  isDate(path.eventDate),
-]
-
-// С кастомным сообщением
-isDate(path.birthDate, { message: 'Введите корректную дату' })
+validate(path.birthDate, isDate());
+validate(path.eventDate, isDate({ message: 'Введите корректную дату' }));
 ```
 
+_Source: src/core/validation/validators/is-date.ts_
+
+### isDerived
+
+**Kind:** `function`
+
+Производный ли сигнал (читают bulk-сеттеры, чтобы не затирать вычисляемые поля).
+
+**Signature:**
 ```typescript
-// Ошибка валидации
-{
-  code: 'date_invalid',
-  message: 'Неверный формат даты',
-  params: {}
-}
+export function isDerived(signal: Signal<any>): boolean
 ```
 
-_Source: src/core/validation/validators/is-date.ts_
+_Source: src/core/utils/derived-registry.ts_
 
 ### isFieldNode
 
@@ -6626,8 +5796,8 @@ _Source: src/core/utils/type-guards.ts_
 
 Проверить, является ли значение GroupNode (объект с вложенными полями)
 
-GroupNode представляет объект с вложенными полями формы
-и имеет методы для применения validation/behavior схем
+GroupNode представляет объект с вложенными полями формы: имеет навигацию по полям
+(`getFieldByPath`/`fields`) и НЕ имеет array-методов (`items`/`push`/`removeAt`).
 
 **Signature:**
 ```typescript
@@ -6643,101 +5813,99 @@ export function isGroupNode(value: unknown): value is GroupNode<FormFields>
 
 ```typescript
 if (isGroupNode(node)) {
-  node.applyValidationSchema(schema); //  OK
   node.getFieldByPath('user.email'); //  OK
 }
 ```
 
 _Source: src/core/utils/type-guards.ts_
 
-### max
+### isNumber
 
 **Kind:** `function`
 
-Валидатор максимального числового значения
+Фабрика валидатора, проверяющего что значение — конечное число (не NaN, не строка).
 
-Проверяет, что числовое значение не превышает указанный максимум.
-Пустые значения пропускаются (используйте `required` для обязательности).
+Пустые значения (`null`/`undefined`) пропускаются (используйте `required` для обязательности).
+В отличие от других number-валидаторов, **не** пропускает не-числа — это его задача.
 
 **Signature:**
 ```typescript
-export function max<TForm, TField extends number | null | undefined = number>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  maxValue: number,
+export function isNumber<TForm = unknown, TField extends number | undefined = number>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `maxValue` — - Максимально допустимое значение
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  max(path.quantity, 100),
-  max(path.discount, 50),
-]
-
-// С кастомным сообщением
-max(path.quantity, 100, { message: 'Максимум 100 единиц' })
+validate(path.amount, isNumber());
+validate(path.amount, isNumber({ message: 'Введите число' }));
 ```
 
+_Source: src/core/validation/validators/is-number.ts_
+
+### markDerived
+
+**Kind:** `function`
+
+Пометить сигнал производным (вызывают compute/computeFrom).
+
+**Signature:**
 ```typescript
-// Ошибка валидации
-{
-  code: 'max',
-  message: 'Максимальное значение: 100',
-  params: { max: 100, actual: 150 }
-}
+export function markDerived(signal: Signal<any>): void
 ```
 
-_Source: src/core/validation/validators/max.ts_
+_Source: src/core/utils/derived-registry.ts_
 
-### maxAge
+### max
 
 **Kind:** `function`
 
-Проверяет, что возраст (вычисленный из даты рождения) не больше указанного
+Фабрика валидатора максимального числового значения.
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function maxAge<TForm, TField extends string | Date | null | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  maxAgeValue: number,
+export function max<TForm = unknown, TField extends number | undefined = number>(
+  maxValue: number,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации (дата рождения)
-- `maxAgeValue` — - Максимально допустимый возраст в годах
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование - максимум 65 лет
-validationSchema: (path) => [
-  maxAge(path.birthDate, 65),
-]
+import { validate } from '@reformer/core';
+import { max } from '@reformer/core/validators';
 
-// С кастомным сообщением
-maxAge(path.birthDate, 100, { message: 'Проверьте правильность даты рождения' })
+validate(path.quantity, max(100));
+validate(path.discount, max(50, { message: 'Не более 50%' }));
 ```
 
+_Source: src/core/validation/validators/max.ts_
+
+### maxAge
+
+**Kind:** `function`
+
+Фабрика валидатора максимального возраста (по дате рождения).
+
+Пустые и невалидные даты пропускаются.
+
+**Signature:**
 ```typescript
-// Ошибка валидации
-{
-  code: 'date_max_age',
-  message: 'Максимальный возраст: 65 лет',
-  params: { maxAge: 65, currentAge: 70 }
-}
+export function maxAge<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(maxAgeValue: number, options?: ValidateOptions): Validator<TForm, TField>
+```
+
+**Examples:**
+
+```typescript
+validate(path.birthDate, maxAge(65));
+validate(path.birthDate, maxAge(100, { message: 'Проверьте дату рождения' }));
 ```
 
 _Source: src/core/validation/validators/max-age.ts_
@@ -6746,43 +5914,23 @@ _Source: src/core/validation/validators/max-age.ts_
 
 **Kind:** `function`
 
-Проверяет, что дата не позже указанной максимальной
+Фабрика валидатора максимальной даты (включительно).
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function maxDate<TForm, TField extends string | Date | null | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  maxDateValue: Date,
-  options?: ValidateOptions
-): void
+export function maxDate<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(maxDateValue: Date, options?: ValidateOptions): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `maxDateValue` — - Максимально допустимая дата (включительно)
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  maxDate(path.birthDate, new Date()), // Не позже сегодня
-]
-
-// С кастомным сообщением
-maxDate(path.endDate, new Date('2025-12-31'), { message: 'Дата не может быть позже конца года' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_max',
-  message: 'Дата должна быть не позднее 31.12.2025',
-  params: { maxDate: Date }
-}
+validate(path.birthDate, maxDate(new Date())); // не позже сегодня
+validate(path.endDate, maxDate(new Date('2025-12-31')));
 ```
 
 _Source: src/core/validation/validators/max-date.ts_
@@ -6791,45 +5939,23 @@ _Source: src/core/validation/validators/max-date.ts_
 
 **Kind:** `function`
 
-Валидатор максимальной длины строки
+Фабрика валидатора максимальной длины строки или массива.
 
-Проверяет, что длина строки не превышает указанный максимум.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function maxLength<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function maxLength<TForm = unknown, TField = unknown>(
   maxLen: number,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `maxLen` — - Максимальная допустимая длина строки
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  maxLength(path.name, 50),
-  maxLength(path.bio, 500),
-]
-
-// С кастомным сообщением
-maxLength(path.bio, 500, { message: 'Максимум 500 символов' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'maxLength',
-  message: 'Максимальная длина: 500 символов',
-  params: { maxLength: 500, actualLength: 512 }
-}
+validate(path.name, maxLength(50));
+validate(path.bio, maxLength(500, { message: 'Max 500 символов' }));
 ```
 
 _Source: src/core/validation/validators/max-length.ts_
@@ -6838,45 +5964,26 @@ _Source: src/core/validation/validators/max-length.ts_
 
 **Kind:** `function`
 
-Валидатор минимального числового значения
+Фабрика валидатора минимального числового значения.
 
-Проверяет, что числовое значение не меньше указанного минимума.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function min<TForm, TField extends number | null | undefined = number>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function min<TForm = unknown, TField extends number | undefined = number>(
   minValue: number,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `minValue` — - Минимально допустимое значение
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  min(path.age, 18),
-  min(path.quantity, 1),
-]
-
-// С кастомным сообщением
-min(path.age, 18, { message: 'Вам должно быть не менее 18 лет' })
-```
+import { validate } from '@reformer/core';
+import { min } from '@reformer/core/validators';
 
-```typescript
-// Ошибка валидации
-{
-  code: 'min',
-  message: 'Минимальное значение: 18',
-  params: { min: 18, actual: 16 }
-}
+validate(path.age, min(18));
+validate(path.quantity, min(1, { message: 'Минимум 1' }));
 ```
 
 _Source: src/core/validation/validators/min.ts_
@@ -6885,138 +5992,304 @@ _Source: src/core/validation/validators/min.ts_
 
 **Kind:** `function`
 
-Проверяет, что возраст (вычисленный из даты рождения) не меньше указанного
+Фабрика валидатора минимального возраста (по дате рождения).
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function minAge<TForm, TField extends string | Date | null | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  minAgeValue: number,
-  options?: ValidateOptions
-): void
+export function minAge<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(minAgeValue: number, options?: ValidateOptions): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации (дата рождения)
-- `minAgeValue` — - Минимально допустимый возраст в годах
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование - минимум 18 лет
-validationSchema: (path) => [
-  minAge(path.birthDate, 18),
-]
+validate(path.birthDate, minAge(18));
+validate(path.birthDate, minAge(21, { message: 'Вам должно быть не менее 21 года' }));
+```
+
+_Source: src/core/validation/validators/min-age.ts_
+
+### minDate
+
+**Kind:** `function`
+
+Фабрика валидатора минимальной даты (включительно).
 
-// С кастомным сообщением
-minAge(path.birthDate, 21, { message: 'Вам должно быть не менее 21 года' })
+Пустые и невалидные даты пропускаются (используйте `required` и `isDate`).
+
+**Signature:**
+```typescript
+export function minDate<
+  TForm = unknown,
+  TField extends string | Date | null | undefined = string | Date,
+>(minDateValue: Date, options?: ValidateOptions): Validator<TForm, TField>
 ```
 
+**Examples:**
+
 ```typescript
-// Ошибка валидации
-{
-  code: 'date_min_age',
-  message: 'Минимальный возраст: 18 лет',
-  params: { minAge: 18, currentAge: 16 }
-}
+validate(path.eventDate, minDate(new Date('2024-01-01')));
+validate(path.startDate, minDate(new Date(), { message: 'Дата должна быть не раньше сегодня' }));
 ```
 
-_Source: src/core/validation/validators/min-age.ts_
+_Source: src/core/validation/validators/min-date.ts_
 
-### minDate
+### minLength
 
 **Kind:** `function`
 
-Проверяет, что дата не раньше указанной минимальной
+Фабрика валидатора минимальной длины строки или массива.
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function minDate<TForm, TField extends string | Date | null | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  minDateValue: Date,
+export function minLength<TForm = unknown, TField = unknown>(
+  minLen: number,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `minDateValue` — - Минимально допустимая дата (включительно)
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  minDate(path.eventDate, new Date('2024-01-01')),
-]
+validate(path.name, minLength(2));
+validate(path.password, minLength(8, { message: 'Min 8 символов' }));
+```
+
+_Source: src/core/validation/validators/min-length.ts_
+
+### ModelApi
+
+**Kind:** `interface`
 
-// С кастомным сообщением
-minDate(path.startDate, new Date(), { message: 'Дата должна быть не раньше сегодня' })
+API уровня модели (доступно на корне и под-моделях элементов массива).
+
+⚠️ Имена методов (`$`/`get`/`set`/`patch`/`isDirty`/`reset`/`signalAt`/`captureInitial`)
+зарезервированы: одноимённое поле формы их затеняет (редкий краевой случай).
+
+**Signature:**
+```typescript
+export interface ModelApi<T> {
+  /** Escape-hatch к сигналам: `model.$.loanType` → `PathAwareSignal<LoanType>`. */
+  readonly $: ModelSignals<T>;
+  /** Снимок значений (без подписки) — для submit. */
+  get(): T;
+  /** Массовая замена значений (load с сервера). Не меняет initial-снимок. */
+  set(value: Partial<T>): void;
+  /** Частичное слияние значений. */
+  patch(value: Partial<T>): void;
+  /** Отличаются ли текущие значения от initial-снимка (value-diff). */
+  isDirty(): boolean;
+  /** Сбросить значения к initial-снимку. */
+  reset(): void;
+  /** Зафиксировать текущие значения как новый initial-снимок («точка отсчёта»). */
+  captureInitial(): void;
+  /** Резолв строкового пути в сигнал (для error-routing/мостов). */
+  signalAt(path: string): PathAwareSignal<unknown> | undefined;
+}
 ```
 
+_Source: src/core/model/types.ts_
+
+### ModelArray
+
+**Kind:** `interface`
+
+Реактивный массив модели. Мутации (`push`/`removeAt`/…) меняют длину реактивно;
+`map`/`forEach`/`at` отдают под-модель элемента ({@link FormModel}) для объектных элементов.
+
+**Signature:**
 ```typescript
-// Ошибка валидации
-{
-  code: 'date_min',
-  message: 'Дата должна быть не ранее 01.01.2024',
-  params: { minDate: Date }
+export interface ModelArray<U> {
+  /** Реактивная длина. */
+  readonly length: number;
+  /** Добавить элемент в конец (значение элемента целиком). */
+  push(item: U): void;
+  /** Вставить элемент по индексу. */
+  insertAt(index: number, item: U): void;
+  /** Удалить элемент по индексу. */
+  removeAt(index: number): void;
+  /** Переместить элемент. */
+  move(from: number, to: number): void;
+  /** Поменять местами два элемента. */
+  swap(a: number, b: number): void;
+  /** Очистить массив. */
+  clear(): void;
+  /** Под-модель элемента по индексу (для объектных элементов) или значение (для примитивных). */
+  at(index: number): U extends object ? FormModel<U> : U | undefined;
+  /** Map по элементам: объектные → {@link FormModel}, примитивные → значение. */
+  map<R>(fn: (item: U extends object ? FormModel<U> : U, index: number) => R): R[];
+  /** Итерация по элементам. */
+  forEach(fn: (item: U extends object ? FormModel<U> : U, index: number) => void): void;
+  /** Снимок массива значений (без подписки). */
+  toArray(): U[];
+  /** Индексный value-доступ. */
+  [index: number]: ModelValue<U>;
 }
 ```
 
-_Source: src/core/validation/validators/min-date.ts_
+_Source: src/core/model/types.ts_
 
-### minLength
+### ModelArrayControl
 
-**Kind:** `function`
+**Kind:** `interface`
 
-Валидатор минимальной длины строки
+Минимальный контракт реактивного массива модели, используемый узлом.
 
-Проверяет, что длина строки не меньше указанного минимума.
-Пустые значения пропускаются (используйте `required` для обязательности).
+**Signature:**
+```typescript
+export interface ModelArrayControl<TItem extends object> {
+  readonly length: number;
+  at(index: number): FormModel<TItem> | undefined;
+  push(item: TItem): void;
+  insertAt(index: number, item: TItem): void;
+  removeAt(index: number): void;
+  move(from: number, to: number): void;
+  swap(a: number, b: number): void;
+  clear(): void;
+  toArray(): TItem[];
+}
+```
+
+_Source: src/core/nodes/model-array-node.ts_
+
+### ModelArrayNode
+
+**Kind:** `class`
 
 **Signature:**
 ```typescript
-export function minLength<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  minLen: number,
-  options?: ValidateOptions
-): void
+export class ModelArrayNode<T extends object> extends FormNode<T[]> { /* … */ }
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `minLen` — - Минимальная допустимая длина строки
-- `options` — - Опции валидации (message, params)
+_Source: src/core/nodes/model-array-node.ts_
 
-**Examples:**
+### ModelObject
+
+**Kind:** `type`
+
+value-proxy объекта: поля доступны как обычные свойства (чтение реактивно
+внутри `effect`/`computed`, запись — присваиванием).
 
+**Signature:**
 ```typescript
-// Базовое использование
-validationSchema: (path) => [
-  minLength(path.name, 2),
-  minLength(path.password, 8),
-]
+export type ModelObject<T> = {
+  [K in keyof T]: ModelValue<T[K]>;
+};
+```
+
+_Source: src/core/model/types.ts_
+
+### ModelSignals
+
+**Kind:** `type`
+
+Дерево сигналов (escape-hatch `model.$`): листья → {@link PathAwareSignal},
+объекты → вложенное дерево, массивы → индексируемое дерево под-сигналов.
 
-// С кастомным сообщением
-minLength(path.password, 8, { message: 'Пароль должен быть не менее 8 символов' })
+**Signature:**
+```typescript
+export type ModelSignals<T> = {
+  [K in keyof T]: NonNullable<T[K]> extends ReadonlyArray<infer U>
+    ? { readonly length: number; readonly [index: number]: ModelSignals<U & object> }
+    : NonNullable<T[K]> extends Opaque
+      ? PathAwareSignal<T[K]>
+      : NonNullable<T[K]> extends object
+        ? ModelSignals<NonNullable<T[K]>>
+        : PathAwareSignal<T[K]>;
+};
 ```
 
+_Source: src/core/model/types.ts_
+
+### ModelValidationResult
+
+**Kind:** `interface`
+
+Результат валидации: ошибки по пути поля.
+
+**Signature:**
 ```typescript
-// Ошибка валидации
-{
-  code: 'minLength',
-  message: 'Минимальная длина: 8 символов',
-  params: { minLength: 8, actualLength: 3 }
+export interface ModelValidationResult {
+  valid: boolean;
+  /** Ключ — путь поля (`'coBorrowers.0.relationship'`). Только поля с ошибками. */
+  errors: Record<string, ValidationError[]>;
 }
 ```
 
-_Source: src/core/validation/validators/min-length.ts_
+_Source: src/core/model/validate-model.ts_
+
+### ModelValidator
+
+**Kind:** `type`
+
+Валидатор слоя данных. `value` — значение поля; `model` — ближайший scope (под-модель элемента
+массива или корень); `root` — корневая модель.
+
+**Signature:**
+```typescript
+export type ModelValidator<TValue = unknown, TModel = unknown, TRoot = unknown> = (
+  value: TValue,
+  model: TModel,
+  root: TRoot
+) => ValidationError | null | Promise<ValidationError | null>;
+```
+
+_Source: src/core/model/validate-model.ts_
+
+### ModelValue
+
+**Kind:** `type`
+
+Значение поля в value-доступе модели:
+- массив → {@link ModelArray}
+- спец-объект (Date/File/Blob) → как есть
+- объект → вложенный value-proxy
+- примитив → значение
+
+**Signature:**
+```typescript
+export type ModelValue<V> =
+  NonNullable<V> extends ReadonlyArray<infer U>
+    ? ModelArray<U>
+    : NonNullable<V> extends Opaque
+      ? V
+      : NonNullable<V> extends object
+        ? ModelObject<NonNullable<V>>
+        : V;
+```
+
+_Source: src/core/model/types.ts_
+
+### multipleOf
+
+**Kind:** `function`
+
+Фабрика валидатора, проверяющего что число кратно заданному.
+
+Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+
+**Signature:**
+```typescript
+export function multipleOf<TForm = unknown, TField extends number | undefined = number>(
+  divisor: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Examples:**
+
+```typescript
+validate(path.price, multipleOf(0.01));
+validate(path.rating, multipleOf(0.5, { message: 'Только шаг 0.5' }));
+```
+
+_Source: src/core/validation/validators/multiple-of.ts_
 
 ### NodeFactory
 
@@ -7087,79 +6360,53 @@ const node = NodeFactory.create({ value: '' }); // → FieldNode<string>
 
 _Source: src/core/factories/node-factory.ts_
 
-### notEmpty
+### nonNegative
 
 **Kind:** `function`
 
-Проверить что массив содержит хотя бы один элемент
+Фабрика валидатора, проверяющего что число неотрицательное (`≥ 0`).
 
-Это удобный алиас для `minLength(field, 1)`, оптимизированный для массивов.
+Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
 
 **Signature:**
 ```typescript
-export function notEmpty<TForm, TItem>(
-  fieldPath: FieldPathNode<TForm, TItem[] | undefined> | undefined,
+export function nonNegative<TForm = unknown, TField extends number | undefined = number>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Поле-массив для валидации
-- `options` — - Опции валидации (message, params и т.д.)
-
 **Examples:**
 
 ```typescript
-// Простая проверка
-notEmpty(path.properties, { message: 'Добавьте хотя бы один объект имущества' });
-
-// С дополнительными параметрами
-notEmpty(path.coBorrowers, {
-  message: 'Требуется хотя бы один созаемщик',
-  params: { minItems: 1 }
-});
+validate(path.quantity, nonNegative());
+validate(path.balance, nonNegative({ message: 'Баланс не может быть отрицательным' }));
 ```
 
-_Source: src/core/validation/validators/array-validators.ts_
+_Source: src/core/validation/validators/non-negative.ts_
 
-### number
+### nonZero
 
 **Kind:** `function`
 
-Адаптер для number валидатора
-Проверяет, что значение является числом и соответствует заданным ограничениям
+Фабрика валидатора, проверяющего что число не равно нулю.
+
+Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
 
 **Signature:**
 ```typescript
-export function number<TForm, TField extends number | undefined = number>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions & {
-    /** Минимальное значение (включительно) */
-    min?: number;
-    /** Максимальное значение (включительно) */
-    max?: number;
-    /** Требовать целое число */
-    integer?: boolean;
-    /** Значение должно быть кратно этому числу */
-    multipleOf?: number;
-    /** Разрешить отрицательные числа (по умолчанию true) */
-    allowNegative?: boolean;
-    /** Разрешить ноль (по умолчанию true) */
-    allowZero?: boolean;
-  }
-): void
+export function nonZero<TForm = unknown, TField extends number | undefined = number>(
+  options?: ValidateOptions
+): Validator<TForm, TField>
 ```
 
 **Examples:**
 
 ```typescript
-number(path.age);
-number(path.price, { min: 0, max: 1000000 });
-number(path.percentage, { min: 0, max: 100, integer: true });
-number(path.rating, { min: 0, max: 5, multipleOf: 0.5 });
+validate(path.quantity, nonZero());
+validate(path.divisor, nonZero({ message: 'Не может быть нулём' }));
 ```
 
-_Source: src/core/validation/validators/number.ts_
+_Source: src/core/validation/validators/non-zero.ts_
 
 ### ObservableForm
 
@@ -7204,128 +6451,63 @@ _Source: src/core/utils/form-observer.ts_
 
 **Kind:** `function`
 
-Проверяет, что дата находится в прошлом (не в будущем)
+Фабрика валидатора, проверяющего что дата не в будущем.
 
-Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+Пустые и невалидные даты пропускаются.
 
 **Signature:**
 ```typescript
-export function pastDate<TForm, TField extends string | Date | undefined = string | Date>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function pastDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Базовое использование - дата рождения не может быть в будущем
-validationSchema: (path) => [
-  pastDate(path.birthDate),
-]
-
-// С кастомным сообщением
-pastDate(path.birthDate, { message: 'Дата рождения не может быть в будущем' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'date_future',
-  message: 'Дата не может быть в будущем',
-  params: {}
-}
+validate(path.birthDate, pastDate({ message: 'Дата рождения не может быть в будущем' }));
 ```
 
 _Source: src/core/validation/validators/past-date.ts_
 
-### PathSegment
+### PathAwareSignal
 
-**Kind:** `interface`
-
-Сегмент пути к полю формы
+**Kind:** `type`
 
-Представляет один сегмент в пути к полю, например:
-- `"email" → { key: 'email' }`
-- `"items[0]" → { key: 'items', index: 0 }`
+Сигнал, который знает свой путь в модели (`'personalData.lastName'`).
+Используется как «ручка поля»: и привязка value в схеме, и идентичность для testId/devtools.
 
 **Signature:**
 ```typescript
-export interface PathSegment {
-  /**
-   * Ключ поля
-   */
-  key: string;
-
-  /**
-   * Индекс в массиве (опционально)
-   * Присутствует только для сегментов вида "items[0]"
-   */
-  index?: number;
-}
-```
-
-**Examples:**
-
-```typescript
-// Путь "items[0].name" разбивается на:
-[
-  { key: 'items', index: 0 },
-  { key: 'name' }
-]
+export type PathAwareSignal<T> = Signal<T> & {
+  /** Путь поля в модели (dot-нотация). На элементах массива включает индекс. */
+  readonly __path: string;
+};
 ```
 
-_Source: src/core/utils/field-path-navigator.ts_
+_Source: src/core/model/types.ts_
 
 ### pattern
 
 **Kind:** `function`
 
-Валидатор паттерна (регулярного выражения)
+Фабрика валидатора регулярного выражения.
 
-Проверяет, что значение соответствует указанному регулярному выражению.
 Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function pattern<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
+export function pattern<TForm = unknown, TField extends string | undefined = string>(
   regex: RegExp,
   options?: ValidateOptions
-): void
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `regex` — - Регулярное выражение для проверки
-- `options` — - Опции валидации (message, params)
-
 **Examples:**
 
 ```typescript
-// Только буквы
-pattern(path.name, /^[а-яА-Яa-zA-Z]+$/)
-
-// Только цифры
-pattern(path.code, /^\d+$/)
-
-// С кастомным сообщением
-pattern(path.username, /^[a-z0-9_]+$/i, {
-  message: 'Только латинские буквы, цифры и подчёркивание'
-})
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'pattern',
-  message: 'Значение не соответствует требуемому формату',
-  params: { pattern: '^[a-z]+$' }
-}
+validate(path.name, pattern(/^[а-яА-Яa-zA-Z]+$/));
+validate(path.code, pattern(/^\d+$/, { message: 'Только цифры' }));
 ```
 
 _Source: src/core/validation/validators/pattern.ts_
@@ -7334,26 +6516,22 @@ _Source: src/core/validation/validators/pattern.ts_
 
 **Kind:** `function`
 
-Адаптер для phone валидатора
-Поддерживает опциональные поля (string | undefined)
+Фабрика валидатора номера телефона.
+
+Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function phone<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions & {
-    /** Формат телефона */
-    format?: PhoneFormat;
-  }
-): void
+export function phone<TForm = unknown, TField extends string | undefined = string>(
+  options?: PhoneValidatorOptions
+): Validator<TForm, TField>
 ```
 
 **Examples:**
 
 ```typescript
-phone(path.phoneNumber);
-phone(path.phoneNumber, { format: 'ru' });
-phone(path.phoneNumber, { format: 'international', message: 'Неверный формат телефона' });
+validate(path.phone, phone());
+validate(path.phone, phone({ format: 'ru' }));
 ```
 
 _Source: src/core/validation/validators/phone.ts_
@@ -7362,8 +6540,6 @@ _Source: src/core/validation/validators/phone.ts_
 
 **Kind:** `type`
 
-Формат телефона для валидации
-
 **Signature:**
 ```typescript
 export type PhoneFormat = 'international' | 'ru' | 'us' | 'any';
@@ -7371,6 +6547,19 @@ export type PhoneFormat = 'international' | 'ru' | 'us' | 'any';
 
 _Source: src/core/validation/validators/phone.ts_
 
+### registerSignalNode
+
+**Kind:** `function`
+
+Связать сигнал модели с его FieldNode.
+
+**Signature:**
+```typescript
+export function registerSignalNode(signal: Signal<any>, node: FormNode<any>): void
+```
+
+_Source: src/core/utils/signal-node-registry.ts_
+
 ### RegistryStack
 
 **Kind:** `class`
@@ -7411,131 +6600,55 @@ _Source: src/core/utils/registry-stack.ts_
 
 **Kind:** `function`
 
-Валидатор обязательного поля
+Фабрика валидатора обязательного поля.
+
+Возвращает чистую функцию-валидатор `(value, control, root)`. Передаётся в `validate()`.
 
-Проверяет, что поле имеет непустое значение.
 Пустыми считаются: `null`, `undefined`, `''` (пустая строка).
 Для boolean полей требуется значение `true`.
 
 **Signature:**
 ```typescript
-export function required<TForm, TField>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions
-): void
-```
-
-**Parameters:**
-- `fieldPath` — - Путь к полю для валидации
-- `options` — - Опции валидации (message, params)
-
-**Examples:**
-
-```typescript
-// Базовое использование
-validationSchema: (path, { validate }) => [
-  required(path.name),
-  required(path.email),
-]
-
-// С кастомным сообщением
-required(path.phone, { message: 'Укажите номер телефона' })
-
-// Для checkbox (требует true)
-required(path.agreeToTerms, { message: 'Необходимо принять условия' })
-```
-
-```typescript
-// Ошибка валидации
-{
-  code: 'required',
-  message: 'Поле обязательно для заполнения',
-  params: {}
-}
-```
-
-_Source: src/core/validation/validators/required.ts_
-
-### resetWhen
-
-**Kind:** `function`
-
-Условный сброс поля при выполнении условия
-
-**Signature:**
-```typescript
-export function resetWhen<TForm extends FormFields>(
-  field: FieldPathNode<TForm, FormValue>,
-  condition: (form: TForm) => boolean,
-  options?: ResetWhenOptions & { debounce?: number }
-): void
+export function required<TForm = unknown, TField = unknown>(
+  options?: ValidateOptions
+): Validator<TForm, TField>
 ```
 
-**Parameters:**
-- `field` — - Поле для сброса
-- `condition` — - Функция условия (true = reset)
-- `options` — - Опции (`resetValue`, `onlyIfDirty`, `debounce`)
-
 **Examples:**
 
-Сброс зависимого поля при смене типа платежа
 ```typescript
-import { resetWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+import { validate } from '@reformer/core';
+import { required } from '@reformer/core/validators';
 
-interface CheckoutForm {
-paymentType: 'card' | 'cash';
-cardNumber: string;
-}
-
-export const checkoutBehavior: BehaviorSchemaFn<CheckoutForm> = (path) => {
-// Когда выбрано НЕ card — обнуляем номер карты в пустую строку
-resetWhen(path.cardNumber, (form) => form.paymentType !== 'card', {
-resetValue: '',
-});
-};
+validate(path.email, required());
+validate(path.phone, required({ message: 'Укажите номер телефона' }));
+validate(path.agreeToTerms, required({ message: 'Необходимо принять условия' }));
 ```
 
-`onlyIfDirty` — не трогаем нетронутые initial значения
-```typescript
-import { resetWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface CarForm {
-loanType: 'mortgage' | 'car' | 'consumer';
-carPrice: number;
-}
-
-export const carBehavior: BehaviorSchemaFn<CarForm> = (path) => {
-// Если пользователь не вводил carPrice — оставляем default из схемы.
-// Сбрасываем только если поле dirty (была пользовательская правка).
-resetWhen(path.carPrice, (form) => form.loanType !== 'car', {
-resetValue: 0,
-onlyIfDirty: true,
-});
-};
-```
+_Source: src/core/validation/validators/required.ts_
 
-**See also:**
-- [docs/llms/25-reset-when.md](../../../../docs/llms/25-reset-when.md)
+### resetWhen
 
-_Source: src/core/behavior/behaviors/reset-when.ts_
+**Kind:** `function`
 
-### ResetWhenOptions
+Сброс значения поля к `resetValue` (по умолчанию `null`), когда `condition` истинно.
 
-**Kind:** `interface`
+**Signature:**
+```typescript
+export function resetWhen<T>(
+  target: Signal<T>,
+  condition: () => boolean,
+  options?: { resetValue?: T }
+): BehaviorCleanup
+```
 
-Опции для resetWhen
+**Examples:**
 
-**Signature:**
 ```typescript
-export interface ResetWhenOptions {
-  /** Значение для сброса (по умолчанию null) */
-  resetValue?: FormValue;
-  /** Сбросить только если поле dirty */
-  onlyIfDirty?: boolean;
-}
+resetWhen(model.$.cardNumber, () => model.paymentType !== 'card', { resetValue: '' });
 ```
 
-_Source: src/core/behavior/behaviors/reset-when.ts_
+_Source: src/core/model/behaviors.ts_
 
 ### ResourceLoadResult
 
@@ -7554,82 +6667,24 @@ _Source: src/core/types/index.ts_
 
 **Kind:** `function`
 
-Перевалидирует поле при изменении других полей
+Вызывает `revalidate()` при изменении зависимостей (не на инициализации). Под M1 валидация
+on-demand (`validateFormModel`), поэтому ревалидация выражается явным колбэком.
 
 **Signature:**
 ```typescript
-export function revalidateWhen<TForm>(
-  target: FieldPathNode<TForm, FormValue>,
-  triggers: FieldPathNode<TForm, FormValue>[],
-  options?: RevalidateWhenOptions
-): void
+export function revalidateWhen(
+  deps: ReadonlySignal<unknown>[],
+  revalidate: () => void
+): BehaviorCleanup
 ```
 
-**Parameters:**
-- `target` — - Поле для перевалидации
-- `triggers` — - Поля-триггеры (НЕ должно содержать `target`)
-- `options` — - Опции (`debounce`)
-
 **Examples:**
 
-Парная перевалидация — confirmPassword при смене password
-```typescript
-import { revalidateWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-import { equalTo } from '@reformer/core/validators';
-import type { FieldPath } from '@reformer/core';
-
-interface RegistrationForm { password: string; confirmPassword: string }
-
-export const validation = (path: FieldPath<RegistrationForm>) => {
-equalTo(path.confirmPassword, path.password, { message: 'Пароли не совпадают' });
-};
-
-export const behavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
-// Если пользователь сначала ввёл confirm, потом меняет password —
-// без revalidateWhen ошибка confirmPassword останется устаревшей.
-revalidateWhen(path.confirmPassword, [path.password]);
-};
-```
-
-Несколько триггеров + `debounce` для async-валидаторов
-```typescript
-import { revalidateWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface MortgageForm {
-propertyValue: number;
-loanAmount: number;
-initialPayment: number; // правило: initialPayment >= propertyValue * 0.2 - loanAmount
-}
-
-export const mortgageBehavior: BehaviorSchemaFn<MortgageForm> = (path) => {
-revalidateWhen(
-path.initialPayment,
-[path.propertyValue, path.loanAmount],
-{ debounce: 300 }, // не дёргаем сервер на каждый keystroke
-);
-};
-```
-
-**See also:**
-- [docs/llms/27-revalidate-when.md](../../../../docs/llms/27-revalidate-when.md)
-
-_Source: src/core/behavior/behaviors/revalidate-when.ts_
-
-### RevalidateWhenOptions
-
-**Kind:** `interface`
-
-Опции для revalidateWhen
-
-**Signature:**
 ```typescript
-export interface RevalidateWhenOptions {
-  /** Debounce в мс */
-  debounce?: number;
-}
+revalidateWhen([model.$.maxAmount], () => validateFormModel(model, schema));
 ```
 
-_Source: src/core/behavior/types.ts_
+_Source: src/core/model/behaviors.ts_
 
 ### runOutsideEffect
 
@@ -7845,380 +6900,81 @@ _Source: src/core/utils/form-submitter.ts_
 - Автоматически заменять существующие подписки
 - Отслеживать количество активных подписок (для отладки)
 
-**Signature:**
-```typescript
-export class SubscriptionManager {
-  /**
-   * Хранилище подписок
-   * Ключ: уникальный идентификатор подписки
-   * Значение: функция отписки (dispose)
-   */ /* … */ }
-```
-
-**Examples:**
-
-```typescript
-class FieldNode {
-  private subscriptions = new SubscriptionManager();
-
-  watch(callback: Function) {
-    const dispose = effect(() => callback(this.value.value));
-    return this.subscriptions.add('watch', dispose);
-  }
-
-  dispose() {
-    this.subscriptions.clear();
-  }
-}
-```
-
-_Source: src/core/utils/subscription-manager.ts_
-
-### syncFields
-
-**Kind:** `function`
-
-Двусторонняя синхронизация двух полей
-
-**Signature:**
-```typescript
-export function syncFields<TForm extends FormFields, T extends FormValue>(
-  field1: FieldPathNode<TForm, T>,
-  field2: FieldPathNode<TForm, T>,
-  options?: SyncFieldsOptions<T>
-): void
-```
-
-**Parameters:**
-- `field1` — - Первое поле
-- `field2` — - Второе поле
-- `options` — - Опции (`transform` асимметричен — применяется только field1 → field2; `debounce`)
-
-**Examples:**
-
-Базовый mirror двух текстовых полей
-```typescript
-import { syncFields, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface MirrorForm {
-syncField1: string;
-syncField2: string;
-}
-
-export const mirrorBehavior: BehaviorSchemaFn<MirrorForm> = (path) => {
-syncFields(path.syncField1, path.syncField2);
-};
-```
-
-С `transform` (асимметричный) и `debounce` для защиты от частых перезаписей
-```typescript
-import { syncFields, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface CodeForm {
-internalCode: string;  // канонический формат
-displayCode: string;   // показываем пользователю
-}
-
-export const codeBehavior: BehaviorSchemaFn<CodeForm> = (path) => {
-// internalCode → displayCode: применяется toUpperCase
-// displayCode → internalCode: пишется как есть
-syncFields(path.internalCode, path.displayCode, {
-transform: (value) => (typeof value === 'string' ? value.toUpperCase() : value),
-debounce: 150, // сглаживает дёргание каретки
-});
-};
-```
-
-**See also:**
-- [docs/llms/24-sync-fields.md](../../../../docs/llms/24-sync-fields.md)
-
-_Source: src/core/behavior/behaviors/sync-fields.ts_
-
-### SyncFieldsOptions
-
-**Kind:** `interface`
-
-Опции для syncFields
-
-**Signature:**
-```typescript
-export interface SyncFieldsOptions<T> {
-  /** Трансформация значения */
-  transform?: (value: T) => T;
-
-  /** Debounce в мс */
-  debounce?: number;
-}
-```
-
-_Source: src/core/behavior/types.ts_
-
-### toBehaviorFieldPath
-
-**Kind:** `function`
-
-Преобразовать FieldPath во вложенный путь для композиции behavior схем
-
-Аналог toFieldPath из validation API.
-
-**Signature:**
-```typescript
-export function toBehaviorFieldPath<TForm, TField>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined
-): FieldPath<TField>
-```
-
-**Parameters:**
-- `fieldPath` — - Поле для преобразования
-
-**Returns:** Вложенный FieldPath
-
-**Examples:**
-
-```typescript
-// address-behavior.ts
-export const addressBehavior = (path: FieldPath<Address>) => {
-  watchField(path.country, async (country, ctx) => {
-    const regions = await fetchRegions(country);
-    ctx.updateComponentProps(path.region, { options: regions });
-  });
-};
-
-// user-behavior.ts
-export const userBehavior = (path: FieldPath<User>) => {
-  // Композиция: применяем addressBehavior к вложенному полю
-  addressBehavior(toBehaviorFieldPath(path.address));
-};
-```
-
-_Source: src/core/behavior/compose-behavior.ts_
-
-### toFieldPath
-
-**Kind:** `function`
-
-Преобразовать FieldPathNode в FieldPath для переиспользования схем
-
-Позволяет композировать validation schemas:
-
-**Signature:**
-```typescript
-export function toFieldPath<T>(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  node: FieldPathNode<unknown, T, never> | FieldPathNode<any, T, any>
-): FieldPath<T>
-```
-
-**Examples:**
-
-```typescript
-const personalDataValidation = (path: FieldPath<PersonalData>) => {
-  required(path.firstName, { message: 'Имя обязательно' });
-  required(path.lastName, { message: 'Фамилия обязательна' });
-};
-
-const mainValidation = (path: FieldPath<MyForm>) => {
-  //  Переиспользуем схему
-  personalDataValidation(toFieldPath(path.personalData));
-  required(path.email);
-};
-```
-
-_Source: src/core/utils/field-path.ts_
-
-### transformers
-
-**Kind:** `const`
-
-Готовые трансформеры для частых случаев. Все идемпотентны и безопасны для повторного применения.
-
-**Signature:**
-```typescript
-export const transformers
-```
-
-**Examples:**
-
-Готовые трансформеры в схеме формы
-```typescript
-import { transformers, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface RegistrationForm {
-username: string;
-email: string;
-promoCode: string;
-inn: string;
-amount: number;
-}
-
-export const behavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
-transformers.trim(path.username);
-transformers.toLowerCase(path.email);
-transformers.toUpperCase(path.promoCode);
-transformers.digitsOnly(path.inn);
-transformers.roundTo2(path.amount);
-};
-```
-
-Композиция готовых трансформеров через createTransformer
-```typescript
-import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-// trim + lowercase в одном трансформере (применяется как одна операция)
-const normalizeEmail = createTransformer<string>(
-(v) => (v ?? '').trim().toLowerCase(),
-);
-
-interface ContactForm { email: string }
-
-export const contactBehavior: BehaviorSchemaFn<ContactForm> = (path) => {
-normalizeEmail(path.email);
-};
-```
-
-_Source: src/core/behavior/behaviors/transform-value.ts_
-
-### transformValue
-
-**Kind:** `function`
-
-Трансформация значения поля при изменении
-Позволяет автоматически форматировать или преобразовывать значения
-
-**Signature:**
-```typescript
-export function transformValue<TForm extends FormFields, TValue extends FormValue = FormValue>(
-  field: FieldPathNode<TForm, TValue>,
-  transformer: (value: TValue) => TValue,
-  options?: TransformValueOptions & { debounce?: number }
-): void
-```
-
-**Parameters:**
-- `field` — - Поле для трансформации
-- `transformer` — - Функция трансформации (ОБЯЗАТЕЛЬНО идемпотентная: f(f(x)) === f(x))
-- `options` — - Опции (`onUserChangeOnly`, `emitEvent`, `debounce`)
-
-**Examples:**
-
-Базовая нормализация — uppercase + trim email
-```typescript
-import { transformValue, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface RegistrationForm {
-promoCode: string;
-email: string;
-}
-
-export const registrationBehavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
-// Идемпотентно: toUpperCase(toUpperCase(x)) === toUpperCase(x) ✓
-transformValue(path.promoCode, (value) => (value ?? '').toUpperCase());
-transformValue(path.email, (value) => (value ?? '').trim().toLowerCase());
-};
-```
-
-`onUserChangeOnly` + idempotent guard для не-тривиальных форматов
-```typescript
-import { transformValue, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface ProfileForm {
-inn: string; // ИНН — только цифры
-prefixedCode: string; // должен иметь префикс "ID-"
-}
-
-export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
-// Цифры из ИНН: трансформер идемпотентный естественно
-transformValue(path.inn, (v) => (v ?? '').replace(/\D/g, ''));
-
-// Префикс — ВАЖНО guard «уже преобразовано», иначе бесконечный цикл
-// f("ID-123") должно === "ID-123", а не "ID-ID-123"
-transformValue(
-path.prefixedCode,
-(v) => (v?.startsWith('ID-') ? v : `ID-${v ?? ''}`),
-{
-onUserChangeOnly: true, // не трогаем значение из patchValue/preload
-debounce: 200,
-},
-);
-};
-```
-
-**See also:**
-- [docs/llms/26-transform-value.md](../../../../docs/llms/26-transform-value.md)
-
-_Source: src/core/behavior/behaviors/transform-value.ts_
+**Signature:**
+```typescript
+export class SubscriptionManager {
+  /**
+   * Хранилище подписок
+   * Ключ: уникальный идентификатор подписки
+   * Значение: функция отписки (dispose)
+   */ /* … */ }
+```
 
-### TransformValueOptions
+**Examples:**
 
-**Kind:** `interface`
+```typescript
+class FieldNode {
+  private subscriptions = new SubscriptionManager();
 
-Опции для transformValue
+  watch(callback: Function) {
+    const dispose = effect(() => callback(this.value.value));
+    return this.subscriptions.add('watch', dispose);
+  }
 
-**Signature:**
-```typescript
-export interface TransformValueOptions {
-  /** Трансформировать только при изменении пользователем (не программно) */
-  onUserChangeOnly?: boolean;
-  /** Триггерить событие изменения после трансформации */
-  emitEvent?: boolean;
+  dispose() {
+    this.subscriptions.clear();
+  }
 }
 ```
 
-_Source: src/core/behavior/behaviors/transform-value.ts_
+_Source: src/core/utils/subscription-manager.ts_
 
-### TreeValidationContextImpl
+### syncFields
 
-**Kind:** `class`
+**Kind:** `function`
 
-Контекст cross-field валидации. Передаётся в `validateTree`/`validateForm`
-callback'и — напрямую инстанцировать не нужно.
+Двусторонняя синхронизация двух полей (опционально с трансформом `a → b`).
+Сходимость обеспечивается peek-guard'ом; флаг предотвращает лишние круги.
 
 **Signature:**
 ```typescript
-export class TreeValidationContextImpl<TForm> extends BaseValidationContext<TForm> { /* … */ }
+export function syncFields<T>(
+  a: Signal<T>,
+  b: Signal<T>,
+  options?: { transform?: (value: T) => T }
+): BehaviorCleanup
 ```
 
 **Examples:**
 
 ```typescript
-import { validateForm } from '@reformer/core';
-
-validateForm(form, (ctx) => {
-  // ctx — экземпляр TreeValidationContextImpl
-  if (ctx.form.startDate.value > ctx.form.endDate.value) {
-    return [{ code: 'date-range', message: 'Дата начала позже даты окончания' }];
-  }
-  return [];
-});
+syncFields(model.$.field1, model.$.field2);
 ```
 
-_Source: src/core/validation/validation-context.ts_
+_Source: src/core/model/behaviors.ts_
 
-### TreeValidatorFn
+### transformValue
 
-**Kind:** `type`
+**Kind:** `function`
 
-Функция cross-field валидации
+Трансформация значения поля (идемпотентная): при изменении пишет `transformer(value)` обратно.
+Запись отложена (`runOutsideEffect`) во избежание «Cycle detected» (эффект читает и пишет один сигнал).
 
 **Signature:**
 ```typescript
-export type TreeValidatorFn<TForm> = (ctx: FormContext<TForm>) => ValidationError | null;
+export function transformValue<T>(
+  target: Signal<T>,
+  transformer: (value: T) => T
+): BehaviorCleanup
 ```
 
 **Examples:**
 
 ```typescript
-validateTree((ctx) => {
-  const password = ctx.form.password.value.value;
-  const confirm = ctx.form.confirmPassword.value.value;
-  if (password !== confirm) {
-    return { code: 'mismatch', message: 'Passwords must match' };
-  }
-  return null;
-});
+transformValue(model.$.promoCode, (v) => (v ?? '').toUpperCase());
 ```
 
-_Source: src/core/types/validation-schema.ts_
+_Source: src/core/model/behaviors.ts_
 
 ### uniqueId
 
@@ -8293,28 +7049,23 @@ _Source: src/core/types/index.ts_
 
 **Kind:** `function`
 
-Адаптер для URL валидатора
-Поддерживает опциональные поля (string | undefined)
+Фабрика валидатора URL.
+
+Пустые значения пропускаются (используйте `required` для обязательности).
 
 **Signature:**
 ```typescript
-export function url<TForm, TField extends string | null | undefined = string>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  options?: ValidateOptions & {
-    /** Требовать наличие протокола (http:// или https://) */
-    requireProtocol?: boolean;
-    /** Разрешенные протоколы */
-    allowedProtocols?: string[];
-  }
-): void
+export function url<TForm = unknown, TField extends string | undefined = string>(
+  options?: UrlValidatorOptions
+): Validator<TForm, TField>
 ```
 
 **Examples:**
 
 ```typescript
-url(path.website);
-url(path.website, { message: 'Введите корректный URL' });
-url(path.website, { requireProtocol: true });
+validate(path.website, url());
+validate(path.website, url({ requireProtocol: true }));
+validate(path.website, url({ allowedProtocols: ['https'] }));
 ```
 
 _Source: src/core/validation/validators/url.ts_
@@ -8767,130 +7518,11 @@ return (
 
 _Source: src/hooks/useFormControlValue.ts_
 
-### useHiddenCondition
-
-**Kind:** `function`
-
-Хук для реактивной оценки функции hidden.
-
-Подписывается на изменения формы через сигналы и возвращает текущее
-значение hidden-условия.
-
-**Signature:**
-```typescript
-export function useHiddenCondition<T>(
-  hiddenFn: HiddenFn<T> | undefined,
-  form: FormProxy<T>,
-  path: FieldPath<T>
-): boolean
-```
-
-**Parameters:**
-- `hiddenFn` — - Функция, определяющая скрытие.
-- `form` — - {@link FormProxy} формы.
-- `path` — - Текущий {@link FieldPath}.
-
-**Returns:** `true`, если элемент должен быть скрыт.
-
-**Examples:**
-
-```tsx
-import { useHiddenCondition } from '@reformer/core';
-
-function MaybeHidden({ form, path, children }) {
-  const hidden = useHiddenCondition((f) => !f.subscribeNewsletter.value, form, path);
-  return hidden ? null : <>{children}</>;
-}
-```
-
-_Source: src/hooks/useHiddenCondition.ts_
-
-### validate
-
-**Kind:** `function`
-
-Зарегистрировать кастомный синхронный валидатор для поля
-Поддерживает опциональные поля
-
-**Signature:**
-```typescript
-export function validate<TForm, TField>(
-  fieldPath: FieldPathNode<TForm, TField> | undefined,
-  validatorFn: ContextualValidatorFn<TForm, TField>,
-  options?: ValidateOptions
-): void
-```
-
-**Examples:**
-
-```typescript
-validate(path.birthDate, (ctx: ValidationContext<TForm, TField>) => {
-  const birthDate = new Date(ctx.value());
-  const age = calculateAge(birthDate);
-
-  if (age < 18) {
-    return {
-      code: 'tooYoung',
-      message: 'Заемщику должно быть не менее 18 лет',
-    };
-  }
-
-  return null;
-});
-```
-
-_Source: src/core/validation/core/validate.ts_
-
-### validateAsync
-
-**Kind:** `function`
-
-Зарегистрировать асинхронный валидатор для поля
-
-**Signature:**
-```typescript
-export function validateAsync<TForm, TField>(
-  fieldPath: FieldPathNode<TForm, TField>,
-  validatorFn: ContextualAsyncValidatorFn<TForm, TField>,
-  options?: ValidateAsyncOptions
-): void
-```
-
-**Examples:**
-
-```typescript
-validateAsync(
-  path.inn,
-  async (ctx: ValidationContext<TForm, TField>) => {
-    const inn = ctx.value();
-    if (!inn) return null;
-
-    const response = await fetch('/api/validate-inn', {
-      method: 'POST',
-      body: JSON.stringify({ inn }),
-    });
-
-    const data = await response.json();
-    if (!data.valid) {
-      return {
-        code: 'invalidInn',
-        message: 'ИНН не найден в базе данных ФНС',
-      };
-    }
-
-    return null;
-  },
-  { debounce: 1000 }
-);
-```
-
-_Source: src/core/validation/core/validate-async.ts_
-
 ### ValidateAsyncOptions
 
 **Kind:** `interface`
 
-Опции для функции validateAsync
+Опции для функции validateAsync.
 
 **Signature:**
 ```typescript
@@ -8902,111 +7534,65 @@ export interface ValidateAsyncOptions extends ValidateOptions {
 
 _Source: src/core/types/validation-schema.ts_
 
-### validateForm
+### validateFormModel
 
 **Kind:** `function`
 
-Валидировать форму в соответствии с указанной схемой
-
-Функция создает временный контекст валидации, применяет валидаторы
-из схемы и очищает контекст без сохранения в реестр.
+In-form валидация: прогоняет {@link validateModel} и роутит ошибки в ноды формы
+(через реестр сигнал→нода): `node.setErrors(errors[path] ?? [])` — заодно очищает прошедшие поля
+И поля выключенных веток (`{ when, children }` с ложным условием). Дерево обходится ОДИН раз.
 
 **Signature:**
 ```typescript
-export async function validateForm<T extends FormFields>(
-  form: GroupNode<T>,
-  schema: ValidationSchemaFn<T>
-): Promise<boolean>
+export async function validateFormModel<T>(
+  model: FormModel<T>,
+  schema: unknown
+): Promise<ModelValidationResult>
 ```
 
-**Parameters:**
-- `form` — - GroupNode для валидации
-- `schema` — - Схема валидации (ValidationSchemaFn)
-
-**Returns:** Promise<boolean> - `true` если форма валидна, `false` если есть ошибки
-
-**Examples:**
+_Source: src/core/model/validate-model.ts_
 
-Multi-step форма: валидация текущего шага
-```typescript
-const goToNextStep = async () => {
-const isValid = await validateForm(form, step1LoanValidation);
+### validateModel
 
-if (!isValid) {
-form.markAsTouched(); // Показать ошибки
-return false;
-}
+**Kind:** `function`
 
-setCurrentStep(2);
-return true;
-};
-```
+Headless-валидация данных (sync + async). Работает без UI/нод.
 
-Полная валидация перед submit
+**Signature:**
 ```typescript
-const handleSubmit = async () => {
-const isValid = await validateForm(form, fullValidationSchema);
-
-if (isValid) {
-await form.submit(onSubmit);
-}
-};
+export async function validateModel<T>(
+  model: FormModel<T>,
+  schema: unknown
+): Promise<ModelValidationResult>
 ```
 
-Условная валидация
-```typescript
-const schema = isBusinessAccount
-? businessValidation
-: personalValidation;
+**Examples:**
 
-const isValid = await validateForm(form, schema);
+```typescript
+const res = await validateModel(model, schema);
+if (!res.valid) console.log(res.errors); // { 'email': [{ code, message }], ... }
 ```
 
-_Source: src/core/validation/validate-form.ts_
+_Source: src/core/model/validate-model.ts_
 
-### validateItems
+### validateModelSync
 
 **Kind:** `function`
 
-Применить validation schema к каждому элементу массива
-
-Регистрирует схему валидации, которая будет автоматически применяться
-к каждому элементу ArrayNode (как существующим, так и новым).
+Синхронная headless-валидация данных. Асинхронные валидаторы пропускаются.
 
 **Signature:**
 ```typescript
-export function validateItems<TForm, TItem>(
-  fieldPath: FieldPathNode<TForm, TItem[] | undefined> | undefined,
-  itemSchemaFn: ValidationSchemaFn<TItem>
-): void
-```
-
-**Parameters:**
-- `fieldPath` — - Поле-массив для валидации элементов
-- `itemSchemaFn` — - Validation schema для одного элемента
-
-**Examples:**
-
-```typescript
-import { propertyValidation } from './property-validation';
-
-// В additionalValidation
-applyWhen(path.hasProperty, (value) => value === true, (path) => {
-  // Проверка что массив не пустой
-  notEmpty(path.properties, { message: 'Добавьте хотя бы один объект имущества' });
-
-  // Валидация каждого элемента
-  validateItems(path.properties, propertyValidation);
-});
+export function validateModelSync<T>(model: FormModel<T>, schema: unknown): ModelValidationResult
 ```
 
-_Source: src/core/validation/validators/array-validators.ts_
+_Source: src/core/model/validate-model.ts_
 
 ### ValidateOptions
 
 **Kind:** `interface`
 
-Опции для функции validate
+Опции для функции validate.
 
 **Signature:**
 ```typescript
@@ -9020,88 +7606,6 @@ export interface ValidateOptions {
 
 _Source: src/core/types/validation-schema.ts_
 
-### validateTree
-
-**Kind:** `function`
-
-Зарегистрировать cross-field валидатор
-
-Используется для валидации, которая зависит от нескольких полей
-
-**Signature:**
-```typescript
-export function validateTree<TForm>(
-  validatorFn: TreeValidatorFn<TForm>,
-  options?: ValidateTreeOptions
-): void
-```
-
-**Examples:**
-
-```typescript
-// Явная типизация ctx для избежания implicit any
-validateTree(
-  (ctx: { form: MyForm }) => {
-    if (ctx.form.initialPayment && ctx.form.propertyValue) {
-      if (ctx.form.initialPayment > ctx.form.propertyValue) {
-        return {
-          code: 'initialPaymentTooHigh',
-          message: 'Первоначальный взнос не может превышать стоимость',
-        };
-      }
-    }
-    return null;
-  },
-  { targetField: 'initialPayment' }
-);
-```
-
-_Source: src/core/validation/core/validate-tree.ts_
-
-### ValidateTreeOptions
-
-**Kind:** `interface`
-
-Опции для функции validateTree
-
-**Signature:**
-```typescript
-export interface ValidateTreeOptions {
-  /** Поле, к которому привязать ошибку */
-  targetField?: string;
-}
-```
-
-_Source: src/core/types/validation-schema.ts_
-
-### ValidationContextImpl
-
-**Kind:** `class`
-
-Контекст валидации одного поля. Создаётся фреймворком и передаётся в валидаторы
-(`required`, `validate`, …) — напрямую инстанцировать не нужно.
-
-**Signature:**
-```typescript
-export class ValidationContextImpl<TForm, TField> extends BaseValidationContext<TForm> { /* … */ }
-```
-
-**Examples:**
-
-```typescript
-import { validate } from '@reformer/core/validators';
-
-validate(path.password, (value, ctx) => {
-  // ctx — экземпляр ValidationContextImpl, доступ к ctx.form для cross-field логики
-  if (value !== ctx.form.confirmPassword.value) {
-    return { code: 'mismatch', message: 'Пароли не совпадают' };
-  }
-  return null;
-});
-```
-
-_Source: src/core/validation/validation-context.ts_
-
 ### ValidationError
 
 **Kind:** `interface`
@@ -9121,52 +7625,32 @@ export interface ValidationError {
 
 _Source: src/core/types/index.ts_
 
-### ValidationRegistry
-
-**Kind:** `class`
+### Validator
 
-Реестр валидаторов для формы
+**Kind:** `type`
 
-Каждый экземпляр GroupNode создает собственный реестр (композиция).
-Устраняет race conditions и изолирует формы друг от друга.
+Чистый синхронный валидатор поля.
 
-Наследует AbstractRegistry для унификации:
-- Управления global stack
-- Template methods begin/end registration
+Принимает значение поля, прокси текущего поля (control) и прокси корня формы (root).
+Возвращает ValidationError либо null. Не знает про реестр валидации.
 
 **Signature:**
 ```typescript
-export class ValidationRegistry extends AbstractRegistry<ValidatorRegistration> {
-  /** Внутренний стек контекстов для управления condition blocks */ /* … */ }
+export type Validator<TForm, TField> = (
+  value: TField,
+  control: FormProxy<TField>,
+  root: FormProxy<TForm>
+) => ValidationError | null;
 ```
 
 **Examples:**
 
 ```typescript
-class GroupNode {
-  private readonly validationRegistry = new ValidationRegistry();
-
-  applyValidationSchema(schemaFn) {
-    this.validationRegistry.beginRegistration(); // Pushes this to global stack
-    schemaFn(createFieldPath(this));             // Uses getCurrent()
-    this.validationRegistry.endRegistration(this); // Pops from global stack
-  }
-}
-```
-
-_Source: src/core/validation/validation-registry.ts_
-
-### ValidationSchemaFn
-
-**Kind:** `type`
-
-Функция validation schema
-
-Принимает FieldPath и определяет все правила валидации для формы
-
-**Signature:**
-```typescript
-export type ValidationSchemaFn<T> = (path: FieldPath<T>) => void;
+const isAdult: Validator<MyForm, number> = (value, control, root) => {
+  if (value < 18) return { code: 'tooYoung', message: '18+' };
+  return null;
+};
+validate(path.age, isAdult);
 ```
 
 _Source: src/core/types/validation-schema.ts_
@@ -9184,141 +7668,32 @@ export type ValidatorFn<T = FormValue> = (value: T) => ValidationError | null;
 
 _Source: src/core/types/index.ts_
 
-### ValidatorRegistration
-
-**Kind:** `interface`
-
-Регистрация валидатора в системе
-
-**Signature:**
-```typescript
-export interface ValidatorRegistration {
-  fieldPath: string;
-  type: 'sync' | 'async' | 'tree';
-  validator:
-    | ContextualValidatorFn<unknown, unknown>
-    | ContextualAsyncValidatorFn<unknown, unknown>
-    | TreeValidatorFn<unknown>;
-  options?: ValidateOptions | ValidateAsyncOptions | ValidateTreeOptions;
-  condition?: {
-    fieldPath: string;
-    conditionFn: ConditionFn<unknown>;
-  };
-}
-```
-
-_Source: src/core/types/validation-schema.ts_
-
 ### watchField
 
 **Kind:** `function`
 
-Выполняет callback при изменении поля
+Реакция на изменение поля: вызывает `cb(value)` при каждом изменении (по умолчанию без вызова на
+инициализации; `immediate: true` — вызвать сразу).
 
 **Signature:**
 ```typescript
-export function watchField<TForm, TField>(
-  field: FieldPathNode<TForm, TField>,
-  callback: (value: TField, ctx: BehaviorContext<TForm>) => void | Promise<void>,
-  options?: WatchFieldOptions
-): void
+export function watchField<T>(
+  source: ReadonlySignal<T>,
+  cb: (value: T) => void,
+  options?: { immediate?: boolean }
+): BehaviorCleanup
 ```
 
-**Parameters:**
-- `field` — - Поле для отслеживания
-- `callback` — - Функция обратного вызова
-- `options` — - Опции (`debounce`, `immediate`)
-
 **Examples:**
 
-Async loader with try/catch + guard + debounce
-```typescript
-import { watchField, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface AddressForm { region: string; city: string }
-
-export const addressBehavior: BehaviorSchemaFn<AddressForm> = (path) => {
-watchField(
-path.region,
-async (region, ctx) => {
-if (!region) {
-ctx.form.city.updateComponentProps({ options: [] });
-return; // guard: пустое значение не триггерит fetch
-}
-try {
-const { data: cities } = await fetchCities(region);
-ctx.form.city.updateComponentProps({ options: cities });
-} catch (error) {
-console.error('[addressBehavior] failed to load cities:', error);
-ctx.form.city.updateComponentProps({ options: [] });
-}
-},
-{ immediate: false, debounce: 300 }, // обязательные опции для async
-);
-};
-```
-
-Sync handler с консолидацией нескольких зависимостей в один watcher
-```typescript
-import { watchField, type BehaviorSchemaFn } from '@reformer/core/behaviors';
-
-interface InsuranceForm {
-insuranceType: 'casco' | 'osago' | 'property' | '';
-vehicleVin: string;
-propertyType: string;
-}
-
-export const insuranceBehavior: BehaviorSchemaFn<InsuranceForm> = (path) => {
-// ОДИН watchField на trigger-поле — несколько watcher'ов на одно поле = "Cycle detected"
-watchField(
-path.insuranceType,
-(type, ctx) => {
-const isVehicle = type === 'casco' || type === 'osago';
-const isProperty = type === 'property';
-
-// Guard — ставим только если состояние реально меняется
-if (isVehicle) {
-if (ctx.form.vehicleVin.disabled.value) ctx.form.vehicleVin.enable();
-} else {
-if (!ctx.form.vehicleVin.disabled.value) ctx.form.vehicleVin.disable();
-if (ctx.form.vehicleVin.getValue() !== '') ctx.form.vehicleVin.setValue('');
-}
-
-if (isProperty) {
-if (ctx.form.propertyType.disabled.value) ctx.form.propertyType.enable();
-} else {
-if (!ctx.form.propertyType.disabled.value) ctx.form.propertyType.disable();
-if (ctx.form.propertyType.getValue() !== '') ctx.form.propertyType.setValue('');
-}
-},
-{ immediate: false }, // CRITICAL: предотвращает запуск во время инициализации
-);
-};
-```
-
-**See also:**
-- [docs/llms/22-cycle-detection.md](../../../../docs/llms/22-cycle-detection.md)
-
-_Source: src/core/behavior/behaviors/watch-field.ts_
-
-### WatchFieldOptions
-
-**Kind:** `interface`
-
-Опции для watchField
-
-**Signature:**
 ```typescript
-export interface WatchFieldOptions {
-  /** Debounce в мс */
-  debounce?: number;
-
-  /** Вызвать сразу при инициализации */
-  immediate?: boolean;
-}
+watchField(model.$.country, async (country) => {
+  model.city = '';
+  // ... загрузить города
+});
 ```
 
-_Source: src/core/behavior/types.ts_
+_Source: src/core/model/behaviors.ts_
 
 ### WithBehaviorSchema