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

package/llms.txt

@@ -38,6 +38,8 @@
 - 31-async-validator-debounce.md — async-validator-debounce
 - 32-async-options-loading.md — async-options-loading
 - 33-validation-strategy.md — useFormValidation — Единый выбор стратегии валидации
+- 34-i18n.md — i18n — локаль, загрузка словарей и провайдер
+- 35-unified-contract.md — Единый контракт формы — одна схема, одна сборка, одно поведение
 - API Reference (auto-generated from JSDoc)
 
 ## 1. 1. API Reference
@@ -274,7 +276,7 @@ createModel<T extends object>(initial: T): FormModel<T>
 // model.arrayField         → ModelArray<Item>            (push/removeAt/insertAt/move/swap/clear/at/map/length)
 
 // Форма (ноды поверх сигналов модели)
-createForm<T>({ model, schema, behavior? }): FormProxy<T>
+createFormFromModel<T>({ model, schema, behavior? }): FormProxy<T>
 // form.<field>             → FieldNode / GroupNode / FormArrayProxy
 // form.<field>.setValue(v) / .value.value / .errors.value / .disabled.value
 // form.<field>.enable() / .disable() / .reset() / .markAsTouched() / .setErrors([...])
@@ -320,11 +322,17 @@ minAge(years: number, options?: { message?: string })
 maxAge(years: number, options?: { message?: string })
 ```
 
+Кроме `message`, каждое правило принимает `messageKey` (ключ словаря приложения) и `params`.
+Без `message` правило кладёт в ошибку пустую строку, а текст при отображении берётся из словаря
+локали по коду (`validation.<code>`): «Обязательное поле» под русской локалью, английская фраза без
+провайдера. Явное `message` важнее словаря, но языком не переключается; для локализуемого текста —
+`messageKey`. Подробно — [34-i18n.md](./34-i18n.md).
+
 Использование: layout-дерево `createForm` привязывает поля к сигналам, правила живут отдельной
 `ValidationSchema` и гоняются раннером `validateModel` по требованию.
 
 ```typescript
-import { createModel, createForm } from '@reformer/core';
+import { createModel, createForm, createFormFromModel } from '@reformer/core';
 import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
 import { required, min, max, email } from '@reformer/core/validators';
 
@@ -332,7 +340,7 @@ type Loan = { email: string; age: number | null; amount: number | null };
 const model = createModel<Loan>({ email: '', age: null, amount: null });
 
 // layout-схема createForm НЕ несёт validators — только привязка поля к сигналу + компонент
-const form = createForm({
+const form = createFormFromModel({
   model,
   schema: {
     email:  { value: model.$.email,  component: Input },
@@ -519,7 +527,7 @@ const behavior = defineFormBehavior<MyForm>(({ model, form }) => {
   });
 });
 
-const form = createForm({ model, schema, behavior });
+const form = createFormFromModel({ model, schema, behavior });
 ```
 
 DSL-операторы: `compute` (auto-tracking, без явного списка источников), `computeFrom`, `copyFrom`,
@@ -1105,7 +1113,7 @@ layout-схеме НЕТ — правила живут в отдельной с
 ### Primitive Fields
 
 ```typescript
-import { createModel, createForm } from '@reformer/core';
+import { createModel, createFormFromModel } from '@reformer/core';
 import { defineValidationSchema, validate } from '@reformer/core/validation';
 import { required } from '@reformer/core/validators';
 import { Input, InputNumber, SelectAsync, CheckboxWithLabel } from '@reformer/ui-kit';
@@ -1146,7 +1154,7 @@ const schema = {
   },
 };
 
-const form = createForm<MyForm>({ model, schema });
+const form = createFormFromModel<MyForm>({ model, schema });
 ```
 
 ### Nested Objects
@@ -1191,7 +1199,7 @@ const schema = {
 
 ```typescript
 // M1: данные из модели + схема (+ опциональный декларативный behavior)
-const form = createForm<MyForm>({
+const form = createFormFromModel<MyForm>({
   model,                 // FormModel<MyForm> — обязателен
   schema,                // дерево узлов, привязанных к сигналам
   behavior: myBehavior,  // опционально: defineFormBehavior(...) из @reformer/core/behaviors
@@ -1206,12 +1214,12 @@ model.items.push({ id: '1', name: 'Item' }); // операции над масс
 > **Тип `schema` в M1 — `unknown`, не `FormSchema<T>`.** Это осознанно: интерпретатор обходит
 > произвольную структуру и собирает листья `{ value: signal, component?, ... }`, поэтому обёртки
 > (`{ children: [...] }`, wizard/steps) компилируются. Строгий `FormSchema<T>` (keyed-map по полям
-> `T`) применяется только на legacy-пути `createForm(schema)` без модели.
+> `T`) применяется только на legacy-пути `createLegacyForm(schema)` без модели.
 
 ### createForm Returns a Proxy
 
 ```typescript
-const form = createForm<MyForm>({ model, schema });
+const form = createFormFromModel<MyForm>({ model, schema });
 
 form.email;          // FieldNode<string> — TypeScript знает тип
 form.address.city;   // FieldNode<string> — вложенный доступ
@@ -1232,7 +1240,7 @@ if (isFieldNode(node)) { /* ... */ }
 элемента из его под-модели (`FormModel<Item>`).
 
 ```typescript
-import { createModel, createForm, type FormModel } from '@reformer/core';
+import { createModel, createFormFromModel, type FormModel } from '@reformer/core';
 import { Input, InputNumber } from '@reformer/ui-kit';
 
 type Item = { id: string; name: string; price: number };
@@ -1251,13 +1259,62 @@ const schema = {
   items: { array: model.items, item: itemSchema },
 };
 
-const form = createForm<MyForm>({ model, schema });
+const form = createFormFromModel<MyForm>({ model, schema });
 ```
 
 > **Type constraint:** тип элемента `Item` объявляй через `type`-alias (не `interface`) — иначе
 > он не совместим с `Record<string, FormValue>` и `ArrayNode<Item>` его отвергнет.
 > См. `30-type-safety-recipes.md`.
 
+### Массив как ОДНО значение поля
+
+Массив бывает не набором под-форм, а одним значением: мультивыбор, теги, список файлов. Чем он
+является, решает **схема**, а не данные: `{ array, item }` — набор под-форм, а узел поля
+`{ value: model.$.<путь>, component }` — одно значение. Массив, к которому в схеме ничего не
+привязано, в форму не попадает.
+
+```typescript
+type MyForm = { tags: string[] };
+
+const model = createModel<MyForm>({ tags: [] });
+
+const schema = {
+  tags: { value: model.$.tags, component: SelectMulti }, // поле над массивом целиком
+};
+const form = createFormFromModel<MyForm>({ model, schema });
+
+form.tags.setValue(['a', 'b']); // FieldNode<string[]>
+model.$.tags.value = ['c']; // ручка значения: заменяет массив целиком
+validate(model.$.tags, [required(), maxLength(3)]); // правило получает массив
+```
+
+- `model.$.<массив>` — записываемая ручка значения (`PathAwareSignal`): подходит для `value:` в
+  схеме, `validate`/`cross`, `enableWhen`/`copyFrom` и для `model.signalAt(path)`.
+- Узел-массив хранит только массив: запись `null`/`undefined` даёт `[]`. Нужно отличать «не
+  выбирали» от «выбрали ничего» — объявляй поле `T[] | null` с начальным `null`: в рантайме это
+  лист, и привязывается он так же.
+- Запись в узел-ГРУППУ (`model.$.<группа>.value = …`) — ошибка: группа пишется по полям или через
+  `model.patch(...)`.
+
+### Массив в группе и в строке другого массива
+
+Узел `{ array, item }` стоит на любой глубине: массив в группе получает ноду `form.<группа>.<массив>`,
+массив в строке — `form.<массив>.at(i).<массив>`. Под-схема строки объявляет свои массивы так же.
+
+```typescript
+const contactItem = (contact: FormModel<Contact>) => ({
+  name: { value: contact.$.name, component: Input },
+  phones: { array: contact.phones, item: phoneItem }, // массив в строке массива
+});
+
+const schema = {
+  hotlines: { array: model.details.hotlines, item: phoneItem }, // массив в группе
+  contacts: { array: model.contacts, item: contactItem },
+};
+```
+
+Поведение строк вложенного массива — `applyEach` внутри схемы строки, см. `21-array-operations.md`.
+
 ### Один массив — три слоя (три разных движка)
 
 Одна и та же коллекция описывается **тремя разными формами** — по одной на движок. Их легко
@@ -1269,7 +1326,7 @@ const form = createForm<MyForm>({ model, schema });
    `model.$.properties`.
 
    ```typescript
-   // узел схемы для createForm({ model, schema })
+   // узел схемы для createFormFromModel({ model, schema })
    properties: { array: model.properties, item: propertyItem },
    ```
 
@@ -1829,7 +1886,7 @@ the guide below.
 
 ```tsx
 import { useMemo } from 'react';
-import { createModel, createForm } from '@reformer/core';
+import { createModel, createFormFromModel } from '@reformer/core';
 import { FormField, Input, SelectAsync, CheckboxWithLabel, Button } from '@reformer/ui-kit';
 
 type RegistrationForm = {
@@ -1864,7 +1921,7 @@ function RegistrationPage() {
         componentProps: { label: 'I agree to terms' },
       },
     };
-    return createForm<RegistrationForm>({ model, schema });
+    return createFormFromModel<RegistrationForm>({ model, schema });
   }, []);
 
   return (
@@ -2193,7 +2250,7 @@ export const creditBehavior = defineFormBehavior<CreditForm>(({ model }) => {
 - **Все поля должны быть материализованы в модели** (`createModel`), даже те, что показываются
   только под условием. `enableWhen`/`compute`/`copyFrom` принимают сигналы `model.$.field`, а не
   строковые пути; сигнала для несуществующего поля нет.
-- Поведение подключается к форме через `createForm({ model, schema, behavior })` — форма владеет
+- Поведение подключается к форме через `createFormFromModel({ model, schema, behavior })` — форма владеет
   жизненным циклом, DSL-операторы регистрируют свой cleanup сами (ручной массив cleanup'ов не нужен).
 - Таргетом может быть и **группа**: `enableWhen(model.$.residenceAddress, () => model.sameAsRegistration === false)`
   проходит по поддереву; без `resetOnDisable` значение группы сохраняется (удобно, когда оно копируется
@@ -2640,6 +2697,32 @@ const behavior = defineFormBehavior<MyForm>(({ model }) => {
 });
 ```
 
+### Вложенные области — массив в группе и в строке массива
+
+Узел `{ array, item }` и операторы `applyEach` / `apply` / `enableWhen` работают на любой глубине:
+цель оператора — **ручка** `model.$.…`, под-модель и нода находятся по её идентичности, а не по
+пути.
+
+```typescript
+const phoneBehavior = defineFormBehavior<Phone>(({ model: phone }) => {
+  enableWhen(phone.$.number, () => phone.primary);
+});
+
+const contactBehavior = defineFormBehavior<Contact>(({ model: contact }) => {
+  applyEach(contact.$.phones, phoneBehavior); // массив внутри строки
+  enableWhen(contact.$.address, () => contact.quantity > 0); // группа внутри строки
+  apply(contact.$.address, addressBehavior); // под-схема получает настоящую под-модель
+});
+
+const behavior = defineFormBehavior<MyForm>(({ model }) => {
+  applyEach(model.$.contacts, contactBehavior);
+});
+```
+
+Ручка → value-фасад: `modelOf(model.$.address)` — под-модель (`get` / `set` / `patch`),
+`modelOf(model.$.phones)` — фасад массива (`push` / `removeAt` / `at`). Нода формы по ручке —
+`getNodeForSignal(model.$.address)`.
+
 ### Aggregate write — aggregateInto
 
 Агрегатная запись в строки (например, «последняя строка = 100 − Σ остальных»):
@@ -3456,7 +3539,7 @@ form.<field>.clearErrors();
 
 ```tsx
 import { useMemo } from 'react';
-import { createModel, createForm } from '@reformer/core';
+import { createModel, createForm, createFormFromModel } from '@reformer/core';
 import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
 import { required, email, minLength } from '@reformer/core/validators';
 
@@ -3474,7 +3557,7 @@ function RegistrationForm() {
   const { model, form } = useMemo(() => {
     const m = createModel<RegistrationFormData>({ username: '', email: '', password: '' });
     // schema здесь — layout-дерево нод (компоненты/раскладка), без валидаторов.
-    return { model: m, form: createForm({ model: m, schema: buildLayout(m) }) };
+    return { model: m, form: createFormFromModel({ model: m, schema: buildLayout(m) }) };
   }, []);
 
   const handleSubmit = async (e: React.FormEvent) => {
@@ -3606,7 +3689,7 @@ const handleSubmit = async (e) => {
 
 ```typescript
 // ❌ Валидаторы в layout-дереве, отдаваемом в createForm — layout не несёт правил
-createForm({ model, schema: { username: { value: '', validators: [required()] } } });
+createFormFromModel({ model, schema: { username: { value: '', validators: [required()] } } });
 
 // ✅ Валидация — отдельная схема, прогоняется раннером
 const schema = defineValidationSchema<T>(({ model }) => {
@@ -3698,7 +3781,7 @@ Initial values задаются в `createModel(initial)`; `reset()` возвр
 ### Initial values в модели
 
 ```typescript
-import { createModel, createForm } from '@reformer/core';
+import { createModel, createFormFromModel } from '@reformer/core';
 import { Input, SelectAsync, CheckboxWithLabel } from '@reformer/ui-kit';
 
 type ProfileForm = { username: string; language: 'ru' | 'en'; marketing: boolean };
@@ -3719,7 +3802,7 @@ const schema = {
   },
   marketing: { value: model.$.marketing, component: CheckboxWithLabel, componentProps: { label: 'Рассылка' } },
 };
-const form = createForm({ model, schema });
+const form = createFormFromModel({ model, schema });
 // model.get() === { username: '', language: 'ru', marketing: true }
 // после правок: model.reset() возвращает к этим значениям
 ```
@@ -3806,14 +3889,14 @@ export const addressBehavior = defineFormBehavior<AddressForm>(({ model, form })
 // ❌ model/form пересоздаются на каждый рендер → preload запускается каждый раз
 function MyForm() {
   const model = createModel<T>(initial);   // КАЖДЫЙ рендер!
-  const form = createForm({ model, schema });
+  const form = createFormFromModel({ model, schema });
 }
 
 // ✅ Стабильные ссылки через useMemo
 function MyForm() {
   const { model, form } = useMemo(() => {
     const m = createModel<T>(initial);
-    return { model: m, form: createForm({ model: m, schema: buildSchema(m) }) };
+    return { model: m, form: createFormFromModel({ model: m, schema: buildSchema(m) }) };
   }, []);
 }
 ```
@@ -4345,7 +4428,7 @@ function createFormValidation<T>(
 `markAsTouched` не нужен.
 
 ```tsx
-import { createModel, createForm, useFormValidation } from '@reformer/core';
+import { createModel, createFormFromModel, useFormValidation } from '@reformer/core';
 import { defineValidationSchema, validate } from '@reformer/core/validation';
 import { required, email, minLength } from '@reformer/core/validators';
 
@@ -4360,7 +4443,7 @@ const registrationValidation = defineValidationSchema<RegistrationData>(({ model
 
 function RegistrationForm() {
   const model = useMemo(() => createModel<RegistrationData>({ username: '', email: '', password: '' }), []);
-  const form = useMemo(() => createForm({ model }), [model]);
+  const form = useMemo(() => createFormFromModel({ model }), [model]);
 
   const { submit, isValidating } = useFormValidation({
     model,
@@ -4465,7 +4548,527 @@ if (typeof window !== 'undefined') ctrl.start();
 - [31-async-validator-debounce.md](./31-async-validator-debounce.md) — async-правила и отмена устаревших прогонов
 - [13-multi-step.md](./13-multi-step.md) — per-step / полная валидация wizard (`validateStep` / `validateAll`)
 
-## 82. API Reference
+## 82. Purpose
+
+**i18n — локаль, загрузка словарей и провайдер**
+
+Подпуть `@reformer/core/i18n` — общий рантайм локализации для всех пакетов `@reformer/*`: объект
+локали, загрузка словарей, React-провайдер, перевод и форматирование. Язык задаётся провайдером,
+подгружается динамически и переключается на лету; узлы формы при этом не пересоздаются.
+
+Без провайдера всё работает на английском: у каждого пакета есть встроенная английская таблица.
+
+> Импорт всегда из `@reformer/core/i18n`. Из главной бочки `@reformer/core` этот модуль не
+> реэкспортируется: React-контекст локализации обязан существовать в одном экземпляре.
+
+## 83. Локаль — это данные
+
+```typescript
+interface FormLocale {
+  code: string; // BCP 47: 'en', 'ru', 'pt-BR' — по нему работают Intl и plural
+  messages: Record<string, string>; // плоский словарь: ключ → сообщение ICU
+  weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+  dateLocale?: unknown; // необязательно: объект локали react-day-picker / date-fns
+  dateFormat?: string; // необязательно: токены date-fns для DatePicker
+}
+```
+
+Функций в локали нет, поэтому её можно положить JSON-файлом на сервер и получить по сети:
+
+```json
+{ "code": "ru", "weekStartsOn": 1, "messages": { "profile.title": "Профиль" } }
+```
+
+`extendLocale(base, patch)` возвращает новую локаль: словари сливаются (ключи из `patch` важнее),
+остальные поля заменяются.
+
+## 84. Формат сообщений — подмножество ICU
+
+| Конструкция         | Пример                                                                    |
+| ------------------- | ------------------------------------------------------------------------- |
+| подстановка         | `Открыт файл {name}`                                                      |
+| множественные формы | `{count, plural, one{# файл} few{# файла} many{# файлов} other{# файла}}` |
+| точное значение     | `{count, plural, =0{файлов нет} other{# файлов}}`                         |
+| выбор               | `{gender, select, male{он} female{она} other{оно}}`                       |
+| экранирование       | `'{'` → `{`, `'}'` → `}`, `''` → `'`                                      |
+
+- Ветка `other` обязательна. `#` внутри `plural` — число, отформатированное по языку.
+- Типы `number`, `date`, `time`, `selectordinal` не поддерживаются: числа и даты форматируйте
+  отдельно (`useI18n().number`, `.date`) и передавайте готовой строкой.
+- Категории (`one`/`few`/`many`) берутся из `Intl.PluralRules` языка локали.
+
+## 85. Загрузка локалей
+
+Откуда брать словарь, решает приложение: источник — функция `(code) => локаль | словарь`.
+
+```typescript
+import { createLocaleLoader, fetchMessages } from '@reformer/core/i18n';
+import { loadCoreLocale } from '@reformer/core/locale';
+
+export const loadLocale = createLocaleLoader([
+  loadCoreLocale, // встроенные словари ядра — чанк нужного языка
+  fetchMessages((code) => `/locales/${code}.json`), // ключи приложения и правки — с сервера
+]);
+```
+
+- Источники опрашиваются параллельно, сливаются по порядку: поздний перекрывает ранний.
+- Источник отдаёт локаль целиком (`{ code, messages, … }`) или голый словарь (`{ "a.b": "…" }`);
+  `null` означает «для этого языка у меня ничего нет» и ошибкой не считается.
+- Результат кэшируется по коду языка, идущий запрос не дублируется.
+- Отказ любого источника — отказ загрузки. Источник, которому можно промахнуться, оборачивайте:
+  `(code) => source(code).catch(() => null)`.
+- `loadLocale.peek(code)` — уже загруженная локаль или `undefined`; `loadLocale.preload(code)` — то
+  же, что вызов загрузчика.
+
+Ядро отдаёт свои локали в трёх видах:
+
+| Вид               | Импорт                                      | Для чего                                        |
+| ----------------- | ------------------------------------------- | ----------------------------------------------- |
+| загрузчик         | `loadCoreLocale` из `@reformer/core/locale` | основной путь: чанк языка по запросу            |
+| JSON-файл         | `@reformer/core/locale/ru.json`             | выложить на свой сервер, править без пересборки |
+| синхронный модуль | `ru` из `@reformer/core/locale/ru`          | SSR и тесты                                     |
+
+Встроенные языки ядра — `en` и `ru`. Словарь ядра несёт тексты ошибок валидации
+(`validation.<code>`) и единицы размера файла (`format.fileSize.b|kb|mb|gb|tb`).
+
+Пакеты выше отдают локаль накопительно и в тех же трёх видах, поэтому источник встроенных словарей
+в загрузчике всегда один — самого верхнего из используемых пакетов:
+
+| Пакеты приложения               | Источник                                     | Что в локали                      |
+| ------------------------------- | -------------------------------------------- | --------------------------------- |
+| только ядро                     | `loadCoreLocale` из `@reformer/core/locale`  | ошибки валидации, размер файла    |
+| ядро + `@reformer/cdk`          | `loadCdkLocale` из `@reformer/cdk/locale`    | то же плюс строки cdk (`cdk.*`)   |
+| ядро + cdk + `@reformer/ui-kit` | `loadKitLocale` из `@reformer/ui-kit/locale` | то же плюс подписи кита (`kit.*`) |
+
+## 86. Провайдер
+
+```tsx
+import { I18nProvider } from '@reformer/core/i18n';
+
+function App() {
+  const [lang, setLang] = useState('ru');
+  return (
+    <I18nProvider lang={lang} load={loadLocale}>
+      <LangSwitch value={lang} onChange={setLang} />
+      <CreditForm />
+    </I18nProvider>
+  );
+}
+```
+
+| Проп            | Назначение                                                               |
+| --------------- | ------------------------------------------------------------------------ |
+| `lang` + `load` | провайдер грузит локаль сам                                              |
+| `fallback`      | что показать, пока не загружена самая первая локаль; по умолчанию ничего |
+| `onError`       | отказ загрузки `(error, lang)`                                           |
+| `locale`        | готовый объект вместо `lang` + `load` — SSR, тесты                       |
+
+Поведение при `lang` + `load`:
+
+- при смене `lang` на экране остаётся прежний язык, пока новый не загрузится;
+  `useI18n().pending` — для индикатора;
+- при быстром переключении применяется только последний запрос;
+- ошибка загрузки язык не меняет и попадает в `useI18n().error` и `onError`;
+- если локаль уже в кэше (`await loadLocale.preload(lang)` до монтирования), первый рендер
+  синхронный и `fallback` не показывается.
+
+SSR: эффекты на сервере не выполняются, поэтому там передавайте готовый объект —
+`<I18nProvider locale={ru}>` — либо заранее вызовите `preload`.
+
+Вложенный провайдер заменяет локаль для своего поддерева целиком.
+
+## 87. Хуки
+
+```typescript
+const { code, locale, pending, error, t, has, number, date, fileSize } = useI18n();
+
+t('profile.title'); // ключ приложения
+t('cart.items', { count: 3 }); // с подстановками
+t('cart.empty', undefined, 'Your cart is empty'); // английский текст на случай промаха
+number(1234.5); // '1 234,5' в ru
+date(new Date(), { dateStyle: 'long' }); // '15 января 2024 г.' в ru
+fileSize(1536); // '1,5 КБ' в ru, '1.5 KB' без провайдера
+```
+
+`useMessages(builtinEn)` — для авторов пакетов и китов: ищет ключ в локали провайдера, а при
+промахе берёт встроенную английскую таблицу пакета. Тип ключа выводится из таблицы.
+
+```tsx
+import en from './locale/en.json';
+
+function ClearButton() {
+  const t = useMessages(en);
+  return <button aria-label={t('kit.select.clear')} />;
+}
+```
+
+## 88. Тексты ошибок валидации
+
+Правила из `@reformer/core/validators` несут только `code` и `params`; готового текста у них нет
+(`message` по умолчанию — пустая строка). Строку даёт резолвер при отображении ошибки:
+
+1. `messageKey` автора правила — если такой ключ есть в активной локали;
+2. явное `message` автора правила;
+3. `validation.<code>` из словаря локали;
+4. `validation.<code>` из встроенной английской таблицы ядра;
+5. сам код — для своих кодов, которых нет ни в одном словаре.
+
+```typescript
+validate(model.$.email, [
+  required(), // «Обязательное поле» в ru, английская фраза без провайдера
+  minLength(5, { message: 'Слишком коротко' }), // явный текст: важнее словаря, но языком не переключается
+  email({ messageKey: 'profile.email.invalid' }), // ключ словаря приложения: переключается вместе с языком
+]);
+```
+
+- Текст получается при отображении, а не при проверке: смена языка переводит уже показанные
+  ошибки без повторной валидации.
+- `FormField` (`@reformer/cdk`, `@reformer/ui-kit`) резолвит ошибку сам. В своём компоненте —
+  `useValidationMessage()`; вне React — `resolveValidationError(error, createI18n(locale))`.
+- Свой код ошибки локализуется ключом `validation.<свой_код>` в словаре приложения либо
+  `messageKey` в самом правиле.
+- Встроенный текст меняется тем же ключом в словаре приложения:
+  `extendLocale(ru, { messages: { 'validation.required': 'Заполните поле' } })`.
+- Параметры готовятся до подстановки: `Date` — по языку (`15 янв. 2030 г.`), массив — перечнем,
+  размеры в байтах (`maxFileSize`, `minFileSize`, `actualSize`, `maxTotalFileSize`, `actualTotal`) —
+  строкой с единицей (`5 МБ`). Числа остаются числами, поэтому в сообщении работает `plural`.
+
+```tsx
+function FieldErrors({ control }: { control: FieldNode<string> }) {
+  const message = useValidationMessage();
+  const { errors, shouldShowError } = useFormControl(control);
+  return shouldShowError ? <span role="alert">{message(errors[0])}</span> : null;
+}
+```
+
+Смонтированный `ValidationMessagesProvider` из `@reformer/cdk` заменяет этот резолвер целиком:
+локаль для ошибок в его поддереве не участвует.
+
+## 89. Что показывается, когда ключа нет
+
+| Ключ                       | Нет в локали                                                    | Сообщение не разбирается                              |
+| -------------------------- | --------------------------------------------------------------- | ----------------------------------------------------- |
+| пакета (`useMessages`)     | встроенный английский пакета                                    | встроенный английский, `console.error` вне production |
+| приложения (`useI18n().t`) | `defaultMessage`, затем сам ключ; `console.warn` вне production | то же, `console.error`                                |
+
+Пропущенная подстановка выводится как `{name}`. Форма не падает ни в одном из случаев: неполный
+словарь, пришедший по сети, — законный сценарий.
+
+## 90. Проверка словаря в тестах
+
+```typescript
+import { validateLocale } from '@reformer/core/i18n';
+
+expect(validateLocale(ruJson, enJson)).toEqual([]);
+// находит: syntax (не разбирается), missing / extra (ключи), arguments (потерянная подстановка)
+```
+
+## 91. Описатели сообщений (низкий уровень)
+
+`msg(key, values?, defaultMessage?)` создаёт описатель сообщения, `defineMessages(appEn)` — `msg` с
+типизированными ключами, `resolveLocalized(value, i18n)` раскрывает описатели в объекте пропсов.
+
+> ⚠️ Рендереры и `FormField` описатели сами пока НЕ раскрывают. Не кладите `msg(...)` в
+> `componentProps` схемы: компонент получит объект вместо строки. До появления раскрытия в
+> рендерерах вызывайте `resolveLocalized` вручную или используйте `useI18n().t`.
+
+## 92. Anti-patterns
+
+```typescript
+// ❌ Импорт из главной бочки — i18n там нет, а второй путь импорта дал бы вторую копию контекста
+import { I18nProvider } from '@reformer/core';
+
+// ✅ Единственный путь импорта — подпуть i18n
+import { I18nProvider } from '@reformer/core/i18n';
+```
+
+```tsx
+// ❌ Новый загрузчик на каждый рендер: кэш теряется, локаль грузится заново, первый кадр — fallback
+<I18nProvider lang={lang} load={createLocaleLoader([loadCoreLocale])}>
+
+// ✅ Загрузчик — константа модуля: один кэш на приложение
+const loadLocale = createLocaleLoader([loadCoreLocale]);
+<I18nProvider lang={lang} load={loadLocale}>
+```
+
+```typescript
+// ❌ Число или дата типами ICU внутри сообщения — не поддерживается, сообщение не разберётся
+const message = 'Итого: {total, number}';
+
+// ✅ Отформатировать отдельно и передать готовой строкой
+t('cart.total', { total: number(total, { style: 'currency', currency: 'RUB' }) });
+```
+
+```tsx
+// ❌ Ошибка выводится полем message: у правил без своего текста оно пустое — на экране ничего
+<span>{errors[0].message}</span>;
+
+// ✅ Текст ошибки — через резолвер: он знает словарь локали, messageKey и явное сообщение
+const message = useValidationMessage();
+<span>{message(errors[0])}</span>;
+```
+
+```typescript
+// ❌ Настройки локали без словаря: объект без поля messages принимается за словарь сообщений
+const source = () => ({ weekStartsOn: 1 });
+
+// ✅ Часть локали узнаётся по полю messages — отдавайте его хотя бы пустым
+const source = () => ({ weekStartsOn: 1, messages: {} });
+```
+
+## 93. See also
+
+- [28-submit-and-reset.md](./28-submit-and-reset.md) — жизненный цикл формы; смена языка его не затрагивает
+- [33-validation-strategy.md](./33-validation-strategy.md) — когда запускается валидация
+
+## 94. Purpose
+
+**Единый контракт формы — одна схема, одна сборка, одно поведение**
+
+Форма описывается одинаково для всех способов реализации — разметка в JSX, рендерер по TS-схеме,
+рендерер по JSON. Схема одна (дерево узлов), привязка одна (ручка `model.$.…`), сборка одна
+(`createForm`), поведение одно (`defineFormBehavior`). Способы отличаются только видом схемы
+(билдер или документ) и тем, кто рисует результат.
+
+Прежние записи — ключи `value` / `array`, оператор `each`, `createCoreForm` — пока принимаются.
+Новый код пишется так, как описано здесь.
+
+| Слой      | поле                              | массив под-форм                           | подформа                              |
+| --------- | --------------------------------- | ----------------------------------------- | ------------------------------------- |
+| схема     | `{ model: model.$.x, component }` | `{ model: model.$.items, item }`          | `{ model: model.$.group, part }`      |
+| валидация | `validate(model.$.x, rules)`      | `applyEach(model.$.items, itemRules)`     | `apply(model.$.group, groupRules)`    |
+| поведение | `compute(model.$.x, …)`           | `applyEach(model.$.items, itemBehavior)`  | `apply(model.$.group, groupBehavior)` |
+
+Правило привязки: `model.$.…` — привязка (схема, правило, оператор). Без `$` — чтение значения
+(`model.loanType === 'mortgage'`), мутация (`model.items.push()`) и под-модель как область.
+
+## 95. Модель — начальные значения и шаблоны элементов
+
+```typescript
+import { arrayOf, createModel } from '@reformer/core';
+
+const blankPhone = (): Phone => ({ number: '' });
+const blankCoBorrower = (): CoBorrower => ({ name: '', phones: arrayOf(blankPhone) });
+
+export const createCreditModel = () =>
+  createModel<CreditForm>({
+    loanType: 'consumer',
+    registrationAddress: { city: '', street: '' },
+    coBorrowers: arrayOf(blankCoBorrower), // пустой массив + шаблон нового элемента
+    tags: [], // массив как одно значение поля — шаблон не нужен
+  });
+```
+
+`arrayOf(blank, items?)` возвращает обычный массив `U[]` и запоминает фабрику нового элемента.
+После этого `push()` и `insertAt(i)` без значения кладут элемент по шаблону — в модели, в ноде
+массива формы и в кнопке «Добавить» секции массива.
+
+- Шаблон переживает `set` / `patch` / `reset` модели.
+- Вложенный массив объявляется внутри шаблона элемента; элементы, пришедшие обычными данными
+  (загрузка с сервера), получают его шаблон из шаблона родителя.
+- У массива без шаблона `push()` без значения бросает ошибку с подсказкой.
+- Шаблон привязан к самому массиву: до `createModel` его нельзя копировать. `structuredClone`,
+  `JSON.parse(JSON.stringify(…))` и `[...array]` отдают массив без шаблона. Начальные значения с
+  `arrayOf` держат в фабрике, а не в константе, которую клонируют.
+
+## 96. Схема — одно дерево
+
+```typescript
+import type { FormModel } from '@reformer/core';
+
+// подформа: объявлена один раз, получает под-модель
+const address = (model: FormModel<Address>) => ({
+  component: Box,
+  children: [
+    { model: model.$.city, component: Input, componentProps: { label: 'Город' } },
+    { model: model.$.street, component: Input, componentProps: { label: 'Улица' } },
+  ],
+});
+
+// строка массива — такая же функция от под-модели
+const coBorrower = (model: FormModel<CoBorrower>) => ({
+  selector: 'co-borrower',
+  component: Box,
+  children: [{ model: model.$.name, component: Input, componentProps: { label: 'ФИО' } }],
+});
+
+export const creditSchema = (model: FormModel<CreditForm>) => ({
+  component: Box,
+  children: [
+    { model: model.$.loanType, component: SelectAsync, componentProps: { label: 'Тип' } }, // поле
+    { model: model.$.tags, component: SelectMulti }, // массив как одно значение
+    {
+      selector: 'registration',
+      component: Section,
+      componentProps: { title: 'Адрес регистрации' },
+      children: [{ model: model.$.registrationAddress, part: address }], // подформа
+    },
+    { model: model.$.coBorrowers, component: FormArray, item: coBorrower }, // массив под-форм
+  ],
+});
+```
+
+Чем узел является, решают ручка и соседние ключи:
+
+| Узел            | Как отличить                                  |
+| --------------- | --------------------------------------------- |
+| поле            | `model` — лист или массив; нет `item`, `part` |
+| массив под-форм | `model` — массив, `item` — функция            |
+| подформа        | `model` — группа, `part` — функция            |
+| контейнер       | есть `children`, нет `model`                  |
+
+- Узел узнаётся по ЗНАЧЕНИЮ: в записи «имя поля → узел» поле данных может называться `model`,
+  `item`, `part` или `value` — под таким ключом лежит обычный вложенный узел.
+- Поля подформы принадлежат той же форме: `form.registrationAddress.city`.
+- Билдер `item` / `part` вызывается один раз на под-модель; сборка и рендерер получают одно и то
+  же поддерево (`schemaSubtree(builder, subModel)`).
+- `initialValue` узла-массива — запасной шаблон нового элемента для форм, чья модель создаётся из
+  данных без кода. Шаблон модели (`arrayOf`) главнее.
+
+## 97. Валидация — подформа и массив подключаются привязкой
+
+```typescript
+import {
+  apply,
+  applyEach,
+  cross,
+  defineValidationSchema,
+  validate,
+  validateWhen,
+} from '@reformer/core/validation';
+
+const addressRules = defineValidationSchema<Address>(({ model }) => {
+  validate(model.$.city, [required()]);
+  cross<Address>(model.$.street, (address) =>
+    address.city !== '' && address.street === '' ? streetRequired : null
+  );
+});
+
+const coBorrowerRules = defineValidationSchema<CoBorrower>(({ model }) => {
+  validate(model.$.name, [required()]);
+});
+
+export const contactsRules = defineValidationSchema<CreditForm>(({ model }) => {
+  apply(model.$.registrationAddress, addressRules);
+  validateWhen(
+    () => !model.sameAsRegistration,
+    () => apply(model.$.residenceAddress, addressRules)
+  );
+  applyEach(model.$.coBorrowers, coBorrowerRules);
+});
+```
+
+- У схемы, подключённой через `apply(ручка, схема)` / `applyEach`, своя область: `model` — под-модель,
+  `cross` получает её снапшот. Захватывать снапшот в замыкание больше не нужно.
+- Одна и та же схема подключается и к группе, и к элементам массива.
+- `apply(model.$.a, rules)` принимает и массив ручек: `apply([model.$.a, model.$.b], rules)`.
+- `apply(schemaA, schemaB)` — композиция схем над той же моделью — остаётся.
+- Правило получает `(value, scope, root)`: модель области и корень прогона.
+- `each(model.items, (item) => …)` — прежняя запись `applyEach`: принимает фасад и ручку, области
+  не создаёт.
+
+## 98. Поведение — модель, форма и схема
+
+```typescript
+import {
+  apply,
+  applyEach,
+  defineFormBehavior,
+  enableWhen,
+  hideWhen,
+  onComponentEvent,
+  onMount,
+} from '@reformer/core/behaviors';
+
+const addressBehavior = defineFormBehavior<Address>(({ model, schema }) => {
+  hideWhen(schema.node('street'), () => model.city === ''); // узел ищется внутри части
+});
+
+export const creditBehavior = defineFormBehavior<CreditForm>(({ model, form, schema }) => {
+  const isMortgage = () => model.loanType === 'mortgage';
+
+  enableWhen(model.$.propertyValue, isMortgage, { resetOnDisable: true });
+  hideWhen(schema.node('mortgage'), () => !isMortgage());
+  onComponentEvent(schema.node('wizard'), 'onSubmit', () => submitApplication(model.get()));
+  onMount(schema.node('data-boundary'), () => void loadApplication(model));
+
+  apply([model.$.registrationAddress, model.$.residenceAddress], addressBehavior);
+  applyEach(model.$.coBorrowers, coBorrowerBehavior);
+});
+```
+
+Операторы узлов схемы:
+
+| Оператор                                  | Что записывает                                             |
+| ----------------------------------------- | ---------------------------------------------------------- |
+| `hideWhen(node, condition)`               | узел скрыт, пока условие истинно                           |
+| `onComponentEvent(node, event, handler)`  | обработчик пропа-события компонента                        |
+| `onMount(node, fn)` / `onUnmount(node, fn)` | хуки монтирования узла                                   |
+| `onInit(node, fn)`                        | `fn` вызывается сразу, до первого рендера                  |
+| `renderEffect(schema, fn)`                | реактивный эффект, пока схема области смонтирована         |
+| `schema.node(sel).setHidden / patchProps` | принудительная видимость и пропсы узла                     |
+| `schema.node(sel).getRef()`               | ref на компонент узла — объект `{ current }`               |
+
+- **Области изолированы.** `schema.node(selector)` ищет узел только в своей области: корневое
+  поведение — в корневом дереве, поведение подформы и строки массива — в своём поддереве. До узла
+  строки или части корень дотягивается через `applyEach` / `apply`. Два монтирования одной части
+  не конфликтуют.
+- **Исключение — ref по пути модели**: `schema.node('phones.0.number').getRef()` ищется от корня.
+- **Операторы узлов только записывают правило — исполняет его рендерер.** При разметке в JSX они
+  ничего не делают: видимость, отправка и загрузка данных остаются в JSX.
+- Правило на селектор, которого нет в дереве, ничего не делает; в dev — предупреждение.
+
+## 99. Сборка — `createForm`
+
+```tsx
+import { createForm, useFormBundle } from '@reformer/core';
+
+const credit = useFormBundle(() =>
+  createForm<CreditForm>({
+    model: createCreditModel(), // либо initial: { … }
+    schema: creditSchema, // (model) => узел; для JSON — документ + registry
+    behavior: creditBehavior,
+    validation: { steps: { loan: loanRules, contacts: contactsRules }, extras: crossRules },
+  })
+);
+// credit = { model, form, validation, render }
+
+<FormRenderer form={credit} settings={{ fieldWrapper: FormField }} />; // рендерер
+<FormField control={credit.form.loanType} />; // разметка в JSX — та же сборка
+```
+
+- Порядок: модель → `seed` → дерево схемы → ноды формы → поведение → валидация → `setup`. Дерево
+  строится один раз.
+- `validation` в бандле типизирована по конфигу: правила переданы — поле есть всегда.
+- `render` — `{ tree, controller, node(selector) }`: готовое дерево и схема-контроллер сборки.
+- JSON: `createForm({ model, schema: document, registry })` — дерево собирает
+  `registry.resolveSchema`. Ядро документ не разбирает.
+- Внутри рендерера бандл доступен компонентам через `useFormBundleContext()` — так визард берёт
+  форму и валидацию сам.
+
+### Низкоуровневые фабрики
+
+| Задача                                         | Фабрика                                  |
+| ---------------------------------------------- | ---------------------------------------- |
+| форма из модели и готового дерева, без бандла  | `createFormFromModel({ model, schema })` |
+| форма без модели — плоская схема полей         | `createLegacyForm(schema)`               |
+
+`createForm` с готовым деревом вместо билдера или без модели бросает ошибку с отсылкой к нужной
+фабрике.
+
+## 100. Частые ошибки
+
+| Ошибка                                             | Как правильно                                           |
+| -------------------------------------------------- | ------------------------------------------------------- |
+| `model: model.address` (под-модель у поля)         | `model: model.$.address.city` — привязка всегда с `$`   |
+| `{ model: model.$.address, component }` без `part` | группа полем не бывает — нужен `part`                   |
+| `createForm({ model, schema: дерево })`            | `schema` — билдер `(model) => узел`                     |
+| `hideWhen(schema.node('row-узел'), …)` из корня    | внутри `applyEach(model.$.items, itemBehavior)`         |
+| `push({})` для новой строки                        | `arrayOf(blank)` в модели и `push()` без значения       |
+| `createModel(structuredClone(INITIAL))` с `arrayOf` | фабрика начальных значений — клон теряет шаблон массива |
+| `cross` в подформе читает корень                   | `apply(model.$.group, rules)` — область подформы        |
+
+## 101. API Reference
 
 _Auto-generated from JSDoc on public exports._
 
@@ -4515,14 +5118,22 @@ _Source: src/form/types/index.ts_
 
 **Kind:** `function`
 
-Композиция под-схем в текущую (над той же моделью scope). Заменяет пошаговую группировку.
+Применить под-схему к одному или нескольким полям-группам (переиспользование).
+
+Под-схема получает scope группы: `model` — настоящая под-модель (`model.$.field`, чтение и
+запись значений, `get`/`set`/`patch`), `form` — нода группы. Цель — ручка группы
+(`model.$.address`); работает и в корневой схеме, и в схеме строки массива.
 
 **Signature:**
 ```typescript
-export function apply<T>(...schemas: ValidationSchema<T>[]): void
+export function apply<TField>(targets: object | object[], subSchema: FormBehavior<TField>): void
 ```
 
-_Source: src/form/validation/operators.ts_
+**Examples:**
+
+apply([model.$.registrationAddress, model.$.residenceAddress], addressBehavior);
+
+_Source: src/form/behaviors/collections.ts_
 
 ### applyEach
 
@@ -4538,6 +5149,9 @@ _Source: src/form/validation/operators.ts_
   рендерится, а её сигналы зарегистрированы (`enableWhen` резолвит ноду). Без материализации доступ
   к `form.*` бросит понятную ошибку (см. {@link unmaterializedRowForm}).
 
+Работает на любой глубине: массив в корне, в группе и в строке другого массива — в схеме строки
+можно снова вызвать `applyEach`.
+
 **Signature:**
 ```typescript
 export function applyEach<TItem>(array: object, itemSchema: FormBehavior<TItem>): void
@@ -4548,6 +5162,7 @@ export function applyEach<TItem>(array: object, itemSchema: FormBehavior<TItem>)
 applyEach(model.$.items, defineFormBehavior<Item>(({ model: row, form }) => {
   compute(row.$.lineTotal, () => row.qty * row.price);    // value-op — всегда
   enableWhen(row.$.discount, () => row.qty > 10);          // node-op — нужна материализация массива
+  applyEach(row.$.phones, phoneBehavior);                  // массив внутри строки
 }));
 
 _Source: src/form/behaviors/collections.ts_
@@ -4764,6 +5379,52 @@ export interface ArrayNodeLike {
 
 _Source: src/form/types/index.ts_
 
+### arrayOf
+
+**Kind:** `function`
+
+Массив модели с шаблоном нового элемента.
+
+Шаблон — фабрика значения, которое получает `push()` / `insertAt(i)` без аргумента: кнопка
+«Добавить» секции массива, `model.items.push()` в поведении. Объявляется там же, где остальные
+начальные значения, — в модели; схеме и JSX знать его не нужно.
+
+Возвращает обычный массив: тип поля остаётся `U[]`. Шаблон переживает `set` / `patch` / `reset`
+модели. Вложенные массивы объявляются внутри шаблона элемента — тогда и элементы, пришедшие
+обычными данными (загрузка с сервера), получают их шаблоны.
+
+Шаблон привязан к самому массиву, поэтому до `createModel` его нельзя копировать:
+`structuredClone`, `JSON.parse(JSON.stringify(…))` и `[...array]` отдают массив без шаблона, и
+`push()` без значения бросит ошибку. Начальные значения с `arrayOf` держат в фабрике
+(`const initial = () => ({ items: arrayOf(blank) })`), а не в константе, которую клонируют.
+
+**Signature:**
+```typescript
+export function arrayOf<U>(blank: () => U, items: readonly U[] = []): U[]
+```
+
+**Parameters:**
+- `blank` — - Фабрика нового элемента. Вызывается на каждое добавление — значение не делится
+между элементами.
+- `items` — - Начальные элементы. По умолчанию массив пуст.
+
+**Returns:** Массив начальных значений с шаблоном.
+
+**Examples:**
+
+```typescript
+const blankPhone = () => ({ number: '' });
+const blankCoBorrower = () => ({ name: '', phones: arrayOf(blankPhone) });
+
+const model = createModel({ coBorrowers: arrayOf(blankCoBorrower) });
+
+model.coBorrowers.push(); // { name: '', phones: [] }
+model.coBorrowers.at(0).phones.push(); // { number: '' }
+model.coBorrowers.push({ name: 'Анна', phones: [] }); // значение целиком — как раньше
+```
+
+_Source: src/model/model-nodes.ts_
+
 ### AsyncRule
 
 **Kind:** `type`
@@ -4857,13 +5518,21 @@ _Source: src/model/behaviors-value.ts_
 
 **Kind:** `type`
 
-Контекст схемы поведения: модель (значения/сигналы) + форма (ноды).
+Область схемы поведения: модель (значения и сигналы), форма (ноды) и схема (узлы разметки).
+
+`schema` адресует узлы СВОЕЙ области: в корневом поведении — корневое дерево, в поведении
+подформы (`apply`) и строки массива (`applyEach`) — поддерево этой части. Правила узлов
+(`hideWhen`, `onComponentEvent`, `onMount`) исполняет рендерер; без него они ничего не делают.
 
 **Signature:**
 ```typescript
-export type BehaviorScope<T> = { model: FormModel<T>; form: FormProxy<T> };
-```
-
+export type BehaviorScope<T> = {
+  model: FormModel<T>;
+  form: FormProxy<T>;
+  schema: SchemaScope;
+};
+```
+
 _Source: src/form/behaviors/types.ts_
 
 ### bindFieldProps
@@ -4932,6 +5601,35 @@ await v!.validateAll();     // все шаги + extras
 
 _Source: src/form/validation/config.ts_
 
+### bundledLocaleSource
+
+**Kind:** `function`
+
+Источник встроенных локалей пакета: по чанку на язык. Язык ищется точно, затем по основной части
+кода (`ru-RU` → `ru`). Языка нет — источник отдаёт `null`: подписи пакета останутся английскими,
+пока приложение не даст их своим источником.
+
+**Signature:**
+```typescript
+export function bundledLocaleSource(
+  loaders: Readonly<Record<string, () => Promise<FormLocale>>>
+): LocaleSource
+```
+
+**Parameters:**
+- `loaders` — - Код языка → ленивый импорт его локали.
+
+**Examples:**
+
+```ts
+export const loadKitLocale = bundledLocaleSource({
+  en: () => import('./en').then((m) => m.en),
+  ru: () => import('./ru').then((m) => m.ru),
+});
+```
+
+_Source: src/i18n/loader.ts_
+
 ### ChangeContext
 
 **Kind:** `interface`
@@ -5049,6 +5747,19 @@ copyFrom(model.$.email, model.$.emailAdditional, { when: () => model.sameEmail }
 
 _Source: src/model/behaviors-value.ts_
 
+### CORE_LOCALES
+
+**Kind:** `const`
+
+Языки, которые ядро поставляет само.
+
+**Signature:**
+```typescript
+export const CORE_LOCALES: readonly string[]
+```
+
+_Source: src/locale/index.ts_
+
 ### CORE_RUNTIME_TOKEN
 
 **Kind:** `const`
@@ -5131,6 +5842,8 @@ const credit = useFormBundle(() =>
 return <FormWizard form={credit.form} config={credit.validation} steps={STEPS} />;
 ```
 
+**Deprecated:** Пишите `createForm` — та же сборка, в бандле вдобавок дерево для рендерера.
+
 _Source: src/form/create-core-form.ts_
 
 ### CreateCoreFormConfig
@@ -5143,8 +5856,8 @@ _Source: src/form/create-core-form.ts_
 ```typescript
 export interface CreateCoreFormConfig<T> extends CreateFormConfigBase<T, CoreForm<T>> {
   /**
-   * Билдер схемы формы. Именно функция, а не готовое дерево: листья схемы держат сами сигналы
-   * модели (`value: model.$.email`), поэтому построить дерево до модели нечем.
+   * Билдер схемы формы. Именно функция, а не готовое дерево: узлы схемы держат ручки модели
+   * (`model: model.$.email`), поэтому построить дерево до модели нечем.
    */
   schema?: (model: FormModel<T>) => FormSchemaNode;
 }
@@ -5156,53 +5869,89 @@ _Source: src/form/create-core-form.ts_
 
 **Kind:** `function`
 
-Создать форму из {@link FormModel} + единой схемы (архитектура M1, рекомендуемый путь).
+Собрать модель, форму, валидацию и дерево для рендера за один проход.
 
 **Signature:**
 ```typescript
-export function createForm<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>;
+export function createForm<T extends object>(
+  config: CreateFormConfig<T> & { validation: FormValidation<T> | ValidationSchema<T> }
+): ValidatedFormBundle<T>;
 ```
 
 **Parameters:**
-- `args` — - Модель данных, layout-схема (component/componentProps) и (опционально) поведение
+- `config` — - {@link CreateFormConfig}: (`initial` | `model`) + опц. `schema`, `registry`,
+`behavior`, `validation`, `seed`, `setup`.
 
-**Returns:** Типизированная форма с Proxy-доступом к полям
+**Returns:** 
 
 **Examples:**
 
-Архитектура M1: `createModel` + layout-схема + `createForm({ model, schema })`
-```typescript
-import { createModel, createForm } from '@reformer/core';
-import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
-import { required, email, minLength } from '@reformer/core/validators';
+Рендерер по TS-схеме
+```tsx
+const credit = useFormBundle(() =>
+createForm<CreditForm>({
+model: createCreditModel(),
+schema: creditSchema, // (model) => узел
+behavior: creditBehavior,
+validation: { steps: { loan: loanRules }, extras: crossRules },
+})
+);
+return <FormRenderer form={credit} settings={{ fieldWrapper: FormField }} />;
+```
 
-interface UserForm {
-email: string;
-password: string;
-}
+React-руками — та же сборка, разметка в JSX
+```tsx
+const credit = useFormBundle(() => createForm<CreditForm>({ initial, schema: creditSchema }));
+return <FormField control={credit.form.loanType} />;
+```
+
+JSON — документ схемы и реестр
+```tsx
+const credit = useFormBundle(() =>
+createForm<CreditForm>({ model: createCreditModel(), schema: creditJson, registry })
+);
+return <FormRenderer form={credit} />;
+```
 
-const model = createModel<UserForm>({ email: '', password: '' });
+_Source: src/form/form-bundle.ts_
 
-// Layout-схема НЕ несёт validators — только component/componentProps.
-const schema = {
-children: [
-{ value: model.$.email, component: Input },
-{ value: model.$.password, component: Input },
-],
-};
+### CreateFormConfig
 
-const form = createForm<UserForm>({ model, schema });
-form.email.setValue('test@mail.com');
+**Kind:** `interface`
 
-// Валидация — ОТДЕЛЬНАЯ схема, прогон внешним раннером (ошибки сами доезжают до нод):
-const validation = defineValidationSchema<UserForm>(({ model }) => {
-validate(model.$.email, [required(), email()]);
-validate(model.$.password, [required(), minLength(8)]);
-});
-const ok = await validateModel(model, validation);
+Конфиг {@link createForm}.
+
+**Signature:**
+```typescript
+export interface CreateFormConfig<T> {
+  /** Начальные значения — из них создаётся модель. Взаимоисключимо с `model`. */
+  initial?: T;
+  /** Готовая модель (если создана отдельной фабрикой). Приоритетнее `initial`. */
+  model?: FormModel<T>;
+  /**
+   * Схема формы: билдер дерева `(model) => узел` либо документ (JSON) — тогда нужен `registry`.
+   * Билдер, а не готовое дерево: узлы держат ручки модели (`model: model.$.email`), и построить
+   * дерево до модели нечем.
+   */
+  schema?: ((model: FormModel<T>) => FormSchemaNode) | object;
+  /** Реестр JSON-варианта: превращает документ схемы в дерево. */
+  registry?: SchemaResolver;
+  /** Поведение формы: значения, состояние нод и правила узлов схемы. */
+  behavior?: FormBehavior<T>;
+  /** Правила валидации: готовая схема либо {@link FormValidation} со стратегией и шагами. */
+  validation?: FormValidation<T> | ValidationSchema<T>;
+  /**
+   * Правка модели ДО сборки формы. Нужна там, где значение обязано существовать к моменту
+   * построения нод — например, массив, наполняемый из вычислений (реактивные `onChange` на
+   * инициализации не срабатывают).
+   */
+  seed?: (model: FormModel<T>) => void;
+  /** Донастройка ПОСЛЕ сборки: получает готовый бандл. */
+  setup?: (bundle: FormBundle<T>) => void;
+}
 ```
 
-_Source: src/form/create-form.ts_
+_Source: src/form/form-bundle.ts_
 
 ### CreateFormConfigBase
 
@@ -5229,7 +5978,7 @@ export interface CreateFormConfigBase<T, B> {
   seed?: (model: FormModel<T>) => void;
   /**
    * Донастройка ПОСЛЕ сборки. Единственное место для правок, которые обязаны идти следом за
-   * `createForm`: поле, чьё значение уже массив, ноды не получает (см. `buildModelConfig`),
+   * сборкой формы: поле, чьё значение уже массив, ноды не получает (см. `buildModelConfig`),
    * поэтому такой префилл выполняется здесь.
    */
   setup?: (bundle: B) => void;
@@ -5246,12 +5995,14 @@ _Source: src/form/create-core-form.ts_
 
 Значения принадлежат модели (источник истины), ноды формы держат UI/валидационное состояние и
 ссылаются на сигналы модели по идентичности (`node.value === model.$.path`). Обходит структуру
-модели, привязывает конфиг поля (component/componentProps) из схемы, материализует
-top-level массивы как {@link ModelArrayNode}, заполняет реестр сигнал→нода (для `enableWhen`/
-роутинга ошибок) и, при наличии, запускает декларативное поведение (cleanup живёт на форме).
+модели, привязывает конфиг поля (component/componentProps) из схемы, материализует массивы
+под-форм как {@link ModelArrayNode} (на любой глубине), заполняет реестр ручка→нода (для
+`enableWhen`, `apply`/`applyEach` и роутинга ошибок) и, при наличии, запускает декларативное
+поведение (cleanup живёт на форме).
 
-Обычно вызывается неявно через {@link createForm} с аргументом `{ model, schema }` — прямой вызов
-нужен редко (например, для построения формы элемента массива).
+Обычно вызывается сборкой одним вызовом (`createForm`): она строит дерево схемы, зовёт эту
+фабрику и собирает валидацию. Прямой вызов нужен там, где бандл не нужен, — форма элемента
+массива, тесты, свой слой сборки.
 
 **Signature:**
 ```typescript
@@ -5265,7 +6016,7 @@ export function createFormFromModel<T>(args: CreateFormFromModelArgs<T>): FormPr
 
 **Examples:**
 
-Форма из модели + схемы (эквивалент `createForm({ model, schema })`)
+Форма из модели + схемы (эквивалент `createFormFromModel({ model, schema })`)
 ```typescript
 import { createModel, createFormFromModel } from '@reformer/core';
 
@@ -5293,7 +6044,7 @@ console.log(model.email); // 'user@mail.com'
 ```
 
 **See also:**
-- {@link createForm} - основная фабрика (диспетчеризует сюда при аргументе `{ model, schema }`)
+- `createForm` — сборка одним вызовом: модель, форма, валидация и дерево для рендера
 
 _Source: src/form/create-form.ts_
 
@@ -5319,6 +6070,12 @@ export interface CreateFormFromModelArgs<T> {
    * заполнения реестра сигнал→нода; cleanup живёт на форме и вызывается в `form.dispose()`.
    */
   behavior?: FormBehavior<T>;
+  /**
+   * Схема-контроллер сборки: через него поведение получает `schema` своей области. Его передаёт
+   * сборка одним вызовом, чтобы правила узлов (`hideWhen`, `onComponentEvent`) дошли до рендерера.
+   * Без него поведение пишет правила в собственный контроллер, который никто не читает.
+   */
+  schemaController?: SchemaController;
 }
 ```
 
@@ -5359,6 +6116,153 @@ dispose();
 
 _Source: src/form/validation/strategy.ts_
 
+### createI18n
+
+**Kind:** `function`
+
+Ручка для локали. Для одного и того же объекта локали возвращается один и тот же объект —
+ручку можно держать в зависимостях хуков.
+
+**Signature:**
+```typescript
+export function createI18n(locale: FormLocale): I18nHandle
+```
+
+**Parameters:**
+- `locale` — - Локаль; см. {@link FormLocale}.
+
+**Examples:**
+
+```ts
+const i18n = createI18n({ code: 'ru', messages: { 'cart.items': '{count, plural, one{# товар} few{# товара} other{# товаров}}' } });
+i18n.t('cart.items', { count: 3 });  // '3 товара'
+i18n.fileSize(1536);                 // '1,5 КБ'
+```
+
+_Source: src/i18n/translator.ts_
+
+### createLegacyForm
+
+**Kind:** `function`
+
+Создать форму из плоской схемы полей с инлайн-значениями (`value: ''`) — путь ДО архитектуры M1.
+
+Значения живут в нодах, модели нет: поведение (`defineFormBehavior`) и внешняя валидация
+(`validateModel`) к такой форме не подключаются. Для нового кода — {@link createFormFromModel}
+либо сборка одним вызовом.
+
+**Signature:**
+```typescript
+export function createLegacyForm<T>(schema: FormSchema<T>): FormProxy<T>;
+```
+
+**Parameters:**
+- `schema` — - Схема полей формы
+
+**Returns:** Типизированная форма с Proxy-доступом к полям
+
+**Examples:**
+
+```typescript
+const form = createLegacyForm<UserForm>({
+  email: { value: '', component: Input },
+  password: { value: '', component: Input },
+});
+```
+
+_Source: src/form/create-form.ts_
+
+### createLocaleLoader
+
+**Kind:** `function`
+
+Собирает загрузчик из источников. Источники опрашиваются параллельно, а сливаются по порядку:
+поздний перекрывает ранний. Результат кэшируется по коду языка, идущий запрос не дублируется.
+Отказ любого источника — отказ загрузки; из кэша такой запрос удаляется, и следующая попытка
+пойдёт заново. Источник, которому можно промахнуться, приложение оборачивает само:
+`(code) => source(code).catch(() => null)`.
+
+Код языка у результата — всегда запрошенный: по нему работает `Intl`, и он не должен зависеть
+от того, что написано внутри файла.
+
+**Signature:**
+```typescript
+export function createLocaleLoader(sources: readonly LocaleSource[]): LocaleLoader
+```
+
+**Parameters:**
+- `sources` — - Источники в порядке возрастания приоритета.
+
+**Examples:**
+
+```ts
+import { createLocaleLoader, fetchMessages } from '@reformer/core/i18n';
+import { loadKitLocale } from '@reformer/ui-kit/locale';
+
+export const loadLocale = createLocaleLoader([
+  loadKitLocale,                                    // подписи кита — чанк нужного языка
+  fetchMessages((code) => `/locales/${code}.json`), // ключи приложения и правки — с сервера
+]);
+```
+
+_Source: src/i18n/loader.ts_
+
+### createLocaleStore
+
+**Kind:** `function`
+
+Создаёт хранилище. Загрузка при создании НЕ начинается: начальное состояние считается чисто —
+из кэша загрузчика, если локаль там уже есть, — а запрос уходит на первый {@link LocaleStore.setLang}.
+Это позволяет создавать хранилище прямо в рендере.
+
+**Signature:**
+```typescript
+export function createLocaleStore(
+  load: LocaleLoad,
+  lang: string,
+  options: LocaleStoreOptions = {}
+): LocaleStore
+```
+
+**Parameters:**
+- `load` — - Загрузчик локалей.
+- `lang` — - Начальный язык.
+- `options` — - См. {@link LocaleStoreOptions}.
+
+_Source: src/i18n/locale-store.ts_
+
+### createMessageFormatter
+
+**Kind:** `function`
+
+Форматтер одной локали с кэшем разбора: сообщение разбирается один раз, на первый вызов.
+Это внутренность `I18nService.t()` — сам `t()` добавляет сверху поиск ключа в словаре, маркер
+пропущенного ключа и откат на резервную локаль.
+
+**Signature:**
+```typescript
+export function createMessageFormatter(
+  locale: string,
+  options: MessageFormatOptions = {}
+): (source: string, values?: MessageValues) => string
+```
+
+**Parameters:**
+- `locale` — - Локаль форматтера.
+- `options` — - Настройки; см. {@link MessageFormatOptions}.
+
+**Returns:** Функция `(сообщение, значения) => строка`.
+
+**Examples:**
+
+```ts
+const format = createMessageFormatter('ru');
+format('{count, plural, one{# файл} few{# файла} many{# файлов} other{# файла}}', { count: 5 });
+// '5 файлов'
+```
+
+_Source: src/i18n/message-format.ts_
+
 ### createModel
 
 **Kind:** `function`
@@ -5395,13 +6299,70 @@ model.get();                  // { email: 'a@b.c', profile: { name: 'Ada' }, tag
 
 _Source: src/model/create-model.ts_
 
+### createSchemaController
+
+**Kind:** `function`
+
+Схема-контроллер одной сборки формы.
+
+**Signature:**
+```typescript
+export function createSchemaController(): SchemaController
+```
+
+**Examples:**
+
+```typescript
+const controller = createSchemaController();
+const root = controller.scopeOf(model);
+root.node('mortgage').setHidden(true);
+
+controller.scopeOf(model.items.at(0)); // область строки — свои селекторы
+```
+
+_Source: src/form/schema-controller.ts_
+
+### createSchemaOverrideMaps
+
+**Kind:** `function`
+
+Пустое хранилище переопределений области.
+
+**Signature:**
+```typescript
+export function createSchemaOverrideMaps(): SchemaOverrideMaps
+```
+
+_Source: src/form/schema-controller.ts_
+
+### createSchemaScope
+
+**Kind:** `function`
+
+Схема области поверх хранилища: `node(selector)` → управление узлом.
+
+**Signature:**
+```typescript
+export function createSchemaScope(
+  maps: SchemaOverrideMaps = createSchemaOverrideMaps()
+): SchemaScope
+```
+
+**Parameters:**
+- `maps` — - Хранилище области; по умолчанию создаётся новое.
+
+_Source: src/form/schema-controller.ts_
+
 ### cross
 
 **Kind:** `function`
 
-Cross-field правило: `fn` получает СНАПШОТ модели текущего scope (`model.get()`) и вешает ошибку на `sig`.
-Для элементов массива / под-моделей захватывайте нужный снапшот в замыкание (`const item = im.get()`),
-т.к. `fn` всегда получает модель ТЕКУЩЕГО scope (корень прогона), а не под-модель.
+Cross-field правило: `fn` получает СНАПШОТ модели текущей области (`model.get()`) и вешает
+ошибку на `sig`.
+
+Область — та модель, с которой запущена схема: в корне прогона это вся форма, а в схеме,
+подключённой через {@link apply} / {@link applyEach}, — под-модель группы или строки массива.
+Поэтому правила подформы пишутся один раз и не знают, где она стоит.
 
 **Signature:**
 ```typescript
@@ -5413,6 +6374,20 @@ export function cross<TSnapshot>(
 
 _Source: src/form/validation/operators.ts_
 
+### DEFAULT_LOCALE
+
+**Kind:** `const`
+
+Локаль «провайдера нет»: английский, пустой словарь. Каждый пакет при промахе по словарю берёт
+свою встроенную английскую таблицу, поэтому пустой словарь означает «всё по-английски».
+
+**Signature:**
+```typescript
+export const DEFAULT_LOCALE: FormLocale
+```
+
+_Source: src/i18n/locale.ts_
+
 ### defer
 
 **Kind:** `function`
@@ -5440,15 +6415,47 @@ export function defineFormBehavior<T>(setup: (scope: BehaviorScope<T>) => void):
 **Examples:**
 
 ```ts
-export const myBehavior = defineFormBehavior<MyForm>(({ model, form }) => {
+export const myBehavior = defineFormBehavior<MyForm>(({ model, form, schema }) => {
   compute(model.$.total, () => model.price * model.qty);
   enableWhen([model.$.city], () => Boolean(model.country));
   onChange(model.$.country, async (c) => form.city.updateComponentProps({ options: await load(c) }));
+  hideWhen(schema.node('delivery'), () => model.country === '');
 });
 ```
 
 _Source: src/form/behaviors/context.ts_
 
+### defineMessages
+
+**Kind:** `function`
+
+`msg` с типизированными ключами: принимает английский словарь приложения, проверяет ключ при
+компиляции и подставляет английский текст как `defaultMessage` — без провайдера и при промахе
+по локали форма покажет его, а не ключ.
+
+**Signature:**
+```typescript
+export function defineMessages<D extends Messages>(
+  defaults: D
+): {
+  msg(key: keyof D & string, values?: Readonly<Record<string, unknown>>): MessageDescriptor;
+}
+```
+
+**Parameters:**
+- `defaults` — - Английский словарь приложения.
+
+**Examples:**
+
+```ts
+import appEn from './locales/en.json';
+
+export const { msg } = defineMessages(appEn);
+msg('profile.email.label'); // опечатка в ключе — ошибка компиляции
+```
+
+_Source: src/i18n/descriptor.ts_
+
 ### defineValidationSchema
 
 **Kind:** `function`
@@ -5506,17 +6513,21 @@ _Source: src/form/behaviors/node.ts_
 
 **Kind:** `function`
 
-Применить под-правила к КАЖДОМУ элементу текущего массива модели.
-`U extends object` — элементы должны быть под-моделями (объектами); для массива примитивов валидируйте лист напрямую.
+Применить под-правила к КАЖДОМУ элементу массива — прежняя запись {@link applyEach}.
+
+Колбэк получает под-модель элемента, но области не создаёт: `cross` внутри него видит снапшот
+корня прогона.
 
 **Signature:**
 ```typescript
 export function each<U extends object>(
-  arr: ModelArray<U>,
+  arr: ArrayBinding<U> | ModelArray<U>,
   itemFn: (item: FormModel<U>) => void
 ): void
 ```
 
+**Deprecated:** Пишите `applyEach(model.$.<массив>, schema)`.
+
 _Source: src/form/validation/operators.ts_
 
 ### eachLeafSignal
@@ -5526,9 +6537,11 @@ _Source: src/form/validation/operators.ts_
 Обойти ВСЕ листовые сигналы модели (включая элементы массивов), вызвав `visit` на каждом.
 
 Внутри реактивного `effect` служит подпиской «любое поле изменилось»: `visit(sig => void sig.value)`
-подписывает на значения листьев, а обход массивов через `items.value` — на их состав. Так строятся
-триггеры `change`/`blur` стратегий валидации (см. `createFormValidation`), тем же паттерном, что
-`revalidateWhen`, но без ручного перечисления зависимостей.
+подписывает на значения листьев, а обход массивов через `items.value` — на их состав. Тот же
+паттерн, что `revalidateWhen`, но без ручного перечисления зависимостей.
+
+Сами массивы обход не посещает — только их элементы. Поле, привязанное к массиву целиком
+(мультивыбор), живёт на сигнале массива; чтобы увидеть и его, берите {@link eachValueSignal}.
 
 **Signature:**
 ```typescript
@@ -5540,6 +6553,28 @@ export function eachLeafSignal<T>(
 
 _Source: src/model/create-model.ts_
 
+### eachValueSignal
+
+**Kind:** `function`
+
+Обойти ВСЕ ручки значений модели: листья (включая элементы массивов) И сами массивы.
+
+Отличие от {@link eachLeafSignal} — узлы-массивы: массив бывает одним значением поля
+(`{ value: model.$.tags, component }`), и нода такого поля привязана к сигналу массива, а не
+к сигналам элементов. Обходчику, которому нужна именно НОДА поля (стратегия `blur` подписывается
+на её `touched`), одних листьев мало — он не увидел бы мультивыбор. Так строятся триггеры
+`change`/`blur` стратегий валидации (см. `createFormValidation`).
+
+**Signature:**
+```typescript
+export function eachValueSignal<T>(
+  model: FormModel<T>,
+  visit: (signal: PathAwareSignal<unknown>) => void
+): void
+```
+
+_Source: src/model/create-model.ts_
+
 ### effect
 
 **Kind:** `function`
@@ -5713,23 +6748,76 @@ exclusiveFlag(model.$.contacts, (row) => row.$.primary);
 
 _Source: src/form/behaviors/collections.ts_
 
-### FIELD_WRAPPER_ONLY_PROPS
+### extendLocale
 
-**Kind:** `const`
+**Kind:** `function`
 
-Props, которые адресованы обёртке поля, а не контролу: `labelTooltip` рисует `FormField` у
-подписи. Они приходят в общем мешке `componentProps`, и без среза утекли бы в DOM контрола.
+Новая локаль на основе существующей: словари сливаются (ключи из `patch` важнее), остальные
+поля заменяются. Исходный объект не меняется.
 
 **Signature:**
 ```typescript
-export const FIELD_WRAPPER_ONLY_PROPS: readonly string[]
+export function extendLocale(base: FormLocale, patch: Partial<FormLocale>): FormLocale
 ```
 
-_Source: src/platforms/react/field-binding/field-adapter.ts_
+**Parameters:**
+- `base` — - Локаль-основа, например поставляемая китом.
+- `patch` — - Свои ключи, переопределения китовых подписей и поля локали.
 
-### FieldAdapter
+**Examples:**
 
-**Kind:** `interface`
+```ts
+import { ru } from '@reformer/ui-kit/locale/ru';
+
+const appRu = extendLocale(ru, {
+  messages: { 'profile.title': 'Профиль', 'kit.formWizard.submit': 'Отправить' },
+});
+```
+
+_Source: src/i18n/locale.ts_
+
+### fetchMessages
+
+**Kind:** `function`
+
+Источник локали по сети: забирает JSON по адресу, построенному из кода языка. Файл может быть
+словарём (`{ "profile.title": "Профиль" }`) или локалью целиком (`{ "code": "ru", "messages": … }`).
+Ответ не `2xx` — ошибка загрузки.
+
+**Signature:**
+```typescript
+export function fetchMessages(url: (code: string) => string, init?: RequestInit): LocaleSource
+```
+
+**Parameters:**
+- `url` — - Адрес файла для языка.
+- `init` — - Параметры запроса, передаются в `fetch` как есть.
+
+**Examples:**
+
+```ts
+fetchMessages((code) => `/locales/${code}.json`);
+```
+
+_Source: src/i18n/loader.ts_
+
+### FIELD_WRAPPER_ONLY_PROPS
+
+**Kind:** `const`
+
+Props, которые адресованы обёртке поля, а не контролу: `labelTooltip` рисует `FormField` у
+подписи. Они приходят в общем мешке `componentProps`, и без среза утекли бы в DOM контрола.
+
+**Signature:**
+```typescript
+export const FIELD_WRAPPER_ONLY_PROPS: readonly string[]
+```
+
+_Source: src/platforms/react/field-binding/field-adapter.ts_
+
+### FieldAdapter
+
+**Kind:** `interface`
 
 Адаптер поля: описывает диалект контрола (`checked`/`onCheckedChange`, `value`/`onValueChange`,
 DOM-событие в `onChange`, …). Все ключи необязательны — по умолчанию seam проходит как есть.
@@ -5895,11 +6983,12 @@ export interface FieldControlState<T> {
    * @example
    * ```tsx
    * const { errors } = useFormControl(field);
+   * const message = useValidationMessage(); // из '@reformer/core/i18n'
    *
    * return (
    *   <ul className="error-list">
    *     {errors.map((error, i) => (
-   *       <li key={i}>{error.message}</li>
+   *       <li key={i}>{message(error)}</li>
    *     ))}
    *   </ul>
    * );
@@ -5962,12 +7051,13 @@ export interface FieldControlState<T> {
    * @example
    * ```tsx
    * const { shouldShowError, errors } = useFormControl(field);
+   * const message = useValidationMessage(); // из '@reformer/core/i18n'
    *
    * return (
    *   <div>
    *     <input {...props} />
    *     {shouldShowError && (
-   *       <span className="error">{errors[0]?.message}</span>
+   *       <span className="error">{message(errors[0])}</span>
    *     )}
    *   </div>
    * );
@@ -6030,6 +7120,7 @@ control: FieldNode<string>;
 
 function TextField({ control }: Props) {
 const state = useFormControl(control);
+const message = useValidationMessage(); // из '@reformer/core/i18n'
 
 return (
 <div>
@@ -6039,7 +7130,7 @@ disabled={state.disabled}
 onChange={e => control.setValue(e.target.value)}
 />
 {state.shouldShowError && state.errors[0] && (
-<span className="error">{state.errors[0].message}</span>
+<span className="error">{message(state.errors[0])}</span>
 )}
 </div>
 );
@@ -6262,6 +7353,33 @@ todos.forEach((item, i) => {
 
 _Source: src/form/types/form-proxy.ts_
 
+### formatPattern
+
+**Kind:** `function`
+
+Собирает строку из разобранного сообщения. Значения подставляются как текст и повторно
+не разбираются.
+
+**Signature:**
+```typescript
+export function formatPattern(
+  pattern: MessagePattern,
+  values: MessageValues,
+  locale: string,
+  options: MessageFormatOptions = {}
+): string
+```
+
+**Parameters:**
+- `pattern` — - Результат {@link parseMessage}.
+- `values` — - Значения аргументов.
+- `locale` — - Локаль для {@link Intl.PluralRules} и {@link Intl.NumberFormat} (`ru`, `en`, …).
+- `options` — - Настройки; см. {@link MessageFormatOptions}.
+
+**Returns:** Готовая строка интерфейса.
+
+_Source: src/i18n/message-format.ts_
+
 ### FormBehavior
 
 **Kind:** `interface`
@@ -6271,13 +7389,57 @@ _Source: src/form/types/form-proxy.ts_
 **Signature:**
 ```typescript
 export interface FormBehavior<T> {
-  /** @internal Запускается `createForm` после построения нод и заполнения реестра сигнал→нода. */
-  __run(model: FormModel<T>, form: FormProxy<T>): BehaviorCleanup;
+  /**
+   * @internal Запускается сборкой формы после построения нод и заполнения реестра сигнал→нода.
+   * `controller` — схема-контроллер сборки; без него поведение получает собственный, который
+   * никто не читает (модель без рендерера).
+   */
+  __run(model: FormModel<T>, form: FormProxy<T>, controller?: SchemaController): BehaviorCleanup;
 }
 ```
 
 _Source: src/form/behaviors/types.ts_
 
+### FormBundle
+
+**Kind:** `interface`
+
+Результат {@link createForm}.
+
+**Signature:**
+```typescript
+export interface FormBundle<T> {
+  model: FormModel<T>;
+  form: FormProxy<T>;
+  /** Собранная валидация; есть, если в конфиге заданы правила. */
+  validation?: FormValidationBundle<T>;
+  render: FormRender;
+}
+```
+
+_Source: src/form/form-bundle.ts_
+
+### FormBundleContext
+
+**Kind:** `const`
+
+Контекст сборки. Значение — бандл `createForm`; вне рендерера — `null`.
+
+**Signature:**
+```typescript
+export const FormBundleContext
+```
+
+**Examples:**
+
+```tsx
+<FormBundleContext.Provider value={bundle}>
+  <MyWizard />
+</FormBundleContext.Provider>
+```
+
+_Source: src/platforms/react/form-bundle-context.ts_
+
 ### FormBundleLike
 
 **Kind:** `interface`
@@ -6407,6 +7569,43 @@ try {
 
 _Source: src/form/validation/error-handler.ts_
 
+### FormLocale
+
+**Kind:** `interface`
+
+Локаль формы.
+
+**Signature:**
+```typescript
+export interface FormLocale {
+  /** Код языка BCP 47 (`en`, `ru`, `pt-BR`): по нему работают `Intl` и множественные формы. */
+  readonly code: string;
+  /** Словарь сообщений. Ключа нет — пакет подставит встроенный английский. */
+  readonly messages: Messages;
+  /** Первый день недели календаря. По умолчанию — воскресенье. */
+  readonly weekStartsOn?: WeekStart;
+  /**
+   * Необязательное переопределение: объект локали `react-day-picker` / `date-fns`. Для ядра
+   * непрозрачен. Без него даты форматируются через `Intl` по {@link FormLocale.code}.
+   */
+  readonly dateLocale?: unknown;
+  /** Необязательное переопределение: формат даты в токенах `date-fns` для DatePicker. */
+  readonly dateFormat?: string;
+}
+```
+
+**Examples:**
+
+```ts
+const ru: FormLocale = {
+  code: 'ru',
+  weekStartsOn: 1,
+  messages: { 'kit.select.selected': 'Выбрано: {count}' },
+};
+```
+
+_Source: src/i18n/locale.ts_
+
 ### FormModel
 
 **Kind:** `type`
@@ -6507,7 +7706,7 @@ interface UserForm {
   };
 }
 
-const form = createForm<UserForm>(schema);
+const form = createLegacyForm<UserForm>(schema);
 
 // Доступ к методам GroupNode
 await form.validate();
@@ -6521,6 +7720,30 @@ form.profile.name.setValue('John');
 
 _Source: src/form/types/form-proxy.ts_
 
+### FormRender
+
+**Kind:** `interface`
+
+Часть бандла для рендерера: готовое дерево и схема-контроллер сборки.
+
+**Signature:**
+```typescript
+export interface FormRender {
+  /** Корневой узел дерева схемы; `undefined`, если схема не задана. */
+  readonly tree: FormSchemaNode | undefined;
+  /** Схема-контроллер сборки: области корня, строк массивов и подформ. */
+  readonly controller: SchemaController;
+  /** Управление узлом КОРНЕВОЙ области по его `selector`. */
+  node(selector: string): SchemaNodeControl;
+  /** Обёртка поля из реестра (JSON-вариант). */
+  readonly fieldWrapper?: unknown;
+  /** Граница ошибок из реестра (JSON-вариант). */
+  readonly errorBoundary?: unknown;
+}
+```
+
+_Source: src/form/form-bundle.ts_
+
 ### FormSchema
 
 **Kind:** `type`
@@ -6534,7 +7757,7 @@ _Source: src/form/types/form-proxy.ts_
 Использует NonNullable для корректной обработки опциональных полей.
 
 ⚠️ Не путать с {@link FormSchemaNode} — тот описывает **узел дерева** M1-схемы (лист/массив/
-контейнер), передаваемой в `createForm({ model, schema })`. `FormSchema` — это data-shaped конфиг
+контейнер), передаваемой в `createFormFromModel({ model, schema })`. `FormSchema` — это data-shaped конфиг
 (ключи = поля данных), а не узел дерева.
 
 **Signature:**
@@ -6590,12 +7813,13 @@ _Source: src/form/types/deep-schema.ts_
 
 **Kind:** `interface`
 
-Узел единой схемы M1 — layout-дерево, обходимое `createForm({ model, schema })`
+Узел единой схемы M1 — layout-дерево, обходимое `createFormFromModel({ model, schema })`
 и рендерерами (schema-валидация живёт отдельно — `@reformer/core/validation`).
 
 Узел совмещает несколько ролей (различаются рантаймом по форме):
- - **поле** — несёт `value: Signal` (сигнал модели `model.$.x`) + `component`/`validators`;
- - **массив** — `{ array: model.<path>, item(itemModel) }`;
+ - **поле** — `{ model: model.$.x, component, componentProps }`;
+ - **массив под-форм** — `{ model: model.$.items, item: (model) => узел }`;
+ - **подформа** — `{ model: model.$.group, part: (model) => узел }`;
  - **контейнер/ветка** — вложенные узлы (`children`), опц. условие `when`;
  - **record-of-fields** — под-узлы под произвольными именованными ключами (индексная сигнатура).
 
@@ -6606,9 +7830,20 @@ _Source: src/form/types/deep-schema.ts_
 ```typescript
 export interface FormSchemaNode {
   /**
-   * «Ручка» значения поля — маркер узла-поля. Обычно сигнал модели (`model.$.<path>`), но форма
-   * зависит от таргета (для массива `model.$.x` — дерево сигналов; в renderer-типах сужается до
-   * `Signal`). Движок разбирает узел как поле рантаймом по `value instanceof Signal`.
+   * Привязка узла к части модели — ручка из дерева `model.$`. Чем узел является, решают ручка и
+   * соседние ключи:
+   *  - лист или массив (`model.$.email`, `model.$.tags`) — **поле**;
+   *  - массив вместе с {@link FormSchemaNode.item} — **массив под-форм**;
+   *  - группа вместе с {@link FormSchemaNode.part} — **подформа**.
+   *
+   * Узел распознаётся по значению, а не по имени ключа: в записи «имя поля → узел» поле данных
+   * может называться `model`, и тогда под этим ключом лежит обычный вложенный узел.
+   */
+  model?: unknown;
+  /**
+   * Прежняя запись привязки поля — то же, что {@link FormSchemaNode.model}.
+   *
+   * @deprecated Пишите `model: model.$.<path>`.
    */
   value?: unknown;
   /**
@@ -6638,14 +7873,27 @@ export interface FormSchemaNode {
    * выводит на своём месте в порядке следования.
    */
   children?: readonly (FormSchemaNode | string | number | Signal<any>)[];
-  /** Реактивный массив модели (`model.<path>`) — маркер узла-массива (вместе с `item`). */
+  /**
+   * Прежняя запись привязки массива под-форм — фасад `model.<path>` (вместе с `item`).
+   *
+   * @deprecated Пишите `model: model.$.<path>`.
+   */
   array?: SchemaArrayControl;
   /** Схема элемента массива: под-модель элемента → узел поддерева. */
-  item?: (itemModel: any) => FormSchemaNode;
+  item?: (model: any) => FormSchemaNode;
+  /**
+   * Подформа: под-модель группы → узел поддерева. Часть объявляется один раз и подключается к
+   * любой группе той же формы данных: `{ model: model.$.registrationAddress, part: address }`.
+   * Привязки внутри части идут через `$` полученной под-модели.
+   */
+  part?: (model: any) => FormSchemaNode;
   /**
-   * Значение нового элемента массива для кнопки «Добавить»: либо готовое значение,
-   * либо фабрика `() => value`. Тип не различает варианты (union `unknown | (() => unknown)`
-   * схлопывается в `unknown`) — рантайм различает по `typeof initialValue === 'function'`.
+   * Шаблон нового элемента массива для кнопки «Добавить»: либо готовое значение, либо фабрика
+   * `() => value`. Запасной путь — для форм, чья модель создаётся из данных без кода: шаблон,
+   * объявленный в модели (`arrayOf(blank)`), главнее.
+   *
+   * Тип не различает варианты (union `unknown | (() => unknown)` схлопывается в `unknown`) —
+   * рантайм различает по `typeof initialValue === 'function'`.
    */
   initialValue?: unknown;
   /** Свободная вложенность: record-of-fields и произвольные под-узлы. */
@@ -6864,21 +8112,22 @@ _Source: src/platforms/react/field-binding/field-adapter.ts_
 
 **Kind:** `function`
 
-Найти ноду формы по сигналу модели.
+Найти ноду формы по ручке модели.
 
-Используется state-операциями behavior (`enableWhen`/`disableWhen`) и роутингом ошибок
-валидации в ноды. Возвращает `undefined`, если форма ещё не построена или поле не
-материализовано в этой форме (например, элемент массива, который строится per-item).
+Используется state-операциями behavior (`enableWhen`/`disableWhen`), подключением под-схем
+(`apply`/`applyEach`) и роутингом ошибок валидации в ноды. Возвращает `undefined`, если форма
+ещё не построена или эта часть модели в форме не материализована (например, массив без
+item-схемы).
 
 **Signature:**
 ```typescript
-export function getNodeForSignal(signal: Signal<any>): FormNode<any> | undefined
+export function getNodeForSignal(signal: object): FormNode<any> | undefined
 ```
 
 **Parameters:**
-- `signal` — - Сигнал значения из {@link FormModel}
+- `signal` — - Ручка из {@link FormModel}: `model.$.<поле>`, `model.$.<группа>`, `model.$.<массив>`
 
-**Returns:** Нода формы для этого поля или `undefined`
+**Returns:** Нода формы — поля, группы или массива — либо `undefined`
 
 **Examples:**
 
@@ -6890,8 +8139,14 @@ const sig = model.$.email;
 getNodeForSignal(sig)?.setErrors([{ code: 'required', message: 'Обязательно' }]);
 ```
 
+Нода группы и строки массива
+```typescript
+getNodeForSignal(model.$.address)?.disable(); // группа целиком
+getNodeForSignal(model.$.phones[0])?.markAsTouched(); // форма строки массива
+```
+
 **See also:**
-- {@link registerSignalNode} - регистрация связи сигнал→нода
+- {@link registerSignalNode} - регистрация связи ручка→нода
 
 _Source: src/form/signal-node-registry.ts_
 
@@ -6925,7 +8180,7 @@ _Source: src/form/type-guards.ts_
 
 **Kind:** `function`
 
-Текущий scope ({ model, form }) активной схемы (escape hatch для кросс-операторов).
+Текущая область ({ model, form, schema }) активной схемы (escape hatch для кросс-операторов).
 
 **Signature:**
 ```typescript
@@ -6941,7 +8196,7 @@ _Source: src/form/behaviors/context.ts_
 GroupNode - узел для группы полей
 
 Создаётся из {@link FormSchema} (дерево field-конфигов). Обычно строится через `createForm`
-(M1: `createForm({ model, schema })`); schema-валидация/behavior живут на слое модели
+(M1: `createFormFromModel({ model, schema })`); schema-валидация/behavior живут на слое модели
 (`validateModel` из `@reformer/core/validation`, `computeFrom`/`enableWhen`/…), а не на ноде.
 
 **Signature:**
@@ -6988,6 +8243,185 @@ export interface GroupNodeConfig<T> {
 
 _Source: src/form/types/index.ts_
 
+### hideWhen
+
+**Kind:** `function`
+
+Скрывать узел, пока условие истинно.
+
+Условие реактивно: пересчитывается при изменении любого сигнала, прочитанного внутри него.
+Принудительное `schema.node(selector).setHidden(...)` главнее условия.
+
+**Signature:**
+```typescript
+export function hideWhen(node: SchemaNodeControl, condition: () => boolean): void
+```
+
+**Examples:**
+
+```typescript
+hideWhen(schema.node('mortgage'), () => model.loanType !== 'mortgage');
+```
+
+_Source: src/form/behaviors/schema-operators.ts_
+
+### I18N_CONTEXT_MARKER
+
+**Kind:** `const`
+
+Имя контекста и одновременно маркер, по которому страж ищет его копии в сборках.
+
+**Signature:**
+```typescript
+export const I18N_CONTEXT_MARKER
+```
+
+_Source: src/platforms/react/i18n/context.ts_
+
+### I18nContextValue
+
+**Kind:** `interface`
+
+Что видит компонент: ручка активной локали и состояние её загрузки.
+
+**Signature:**
+```typescript
+export interface I18nContextValue extends I18nHandle {
+  /** Идёт загрузка другого языка; на экране пока прежний. Без загрузчика всегда `false`. */
+  readonly pending: boolean;
+  /** Ошибка последней загрузки языка. */
+  readonly error: unknown;
+}
+```
+
+_Source: src/platforms/react/i18n/context.ts_
+
+### I18nHandle
+
+**Kind:** `interface`
+
+Ручка локали: перевод и форматирование по одному языку.
+
+**Signature:**
+```typescript
+export interface I18nHandle {
+  /** Локаль, по которой работает ручка. */
+  readonly locale: FormLocale;
+  /** Код языка — то же, что `locale.code`. */
+  readonly code: string;
+  /** Есть ли ключ в словаре локали (встроенные английские таблицы не учитываются). */
+  has(key: string): boolean;
+  /**
+   * Перевод ключа приложения: словарь локали → `defaultMessage` → встроенная таблица ядра → ключ.
+   *
+   * @param key - Ключ сообщения.
+   * @param values - Значения подстановок.
+   * @param defaultMessage - Английский текст на случай, если ключа в локали нет.
+   */
+  t(key: string, values?: MessageValues, defaultMessage?: string): string;
+  /** Число по правилам языка. */
+  number(value: number, options?: Intl.NumberFormatOptions): string;
+  /** Дата по правилам языка. */
+  date(value: Date | number, options?: Intl.DateTimeFormatOptions): string;
+  /** Размер файла: `1536` → `1.5 KB` (`1,5 КБ` в русской локали). База — 1024. */
+  fileSize(bytes: number): string;
+}
+```
+
+_Source: src/i18n/translator.ts_
+
+### I18nLoadingProviderProps
+
+**Kind:** `interface`
+
+Режим «провайдер грузит сам».
+
+**Signature:**
+```typescript
+export interface I18nLoadingProviderProps {
+  /** Код языка. Смена кода запускает загрузку; до её конца на экране прежний язык. */
+  lang: string;
+  /** Загрузчик локалей — обычно результат `createLocaleLoader`. */
+  load: LocaleLoad;
+  /**
+   * Что показать, пока не загружена самая первая локаль. По умолчанию — ничего: иначе на кадр
+   * мелькнул бы встроенный английский. Если локаль уже в кэше загрузчика (`load.preload(lang)`
+   * до монтирования), первый рендер синхронный и `fallback` не показывается.
+   */
+  fallback?: ReactNode;
+  /** Отказ загрузки. Язык на экране при этом не меняется. */
+  onError?: (error: unknown, lang: string) => void;
+  children?: ReactNode;
+}
+```
+
+_Source: src/platforms/react/i18n/provider.ts_
+
+### I18nProvider
+
+**Kind:** `function`
+
+Провайдер локализации для подписей компонентов, ошибок валидации и авторских подписей формы.
+Без провайдера компоненты говорят встроенным английским.
+
+При смене `lang` на экране остаётся прежний язык, пока новый не загрузится (`useI18n().pending`
+— для индикатора). При быстром переключении применяется только последний запрос. Вложенный
+провайдер заменяет локаль для своего поддерева целиком.
+
+**Signature:**
+```typescript
+export function I18nProvider(props: I18nProviderProps): ReactElement | null
+```
+
+**Examples:**
+
+Провайдер грузит локаль сам
+```tsx
+const [lang, setLang] = useState('ru');
+
+<I18nProvider lang={lang} load={loadLocale}>
+<LangSwitch value={lang} onChange={setLang} />
+<CreditForm />
+</I18nProvider>
+```
+
+Готовая локаль — SSR и тесты
+```tsx
+import { ru } from '@reformer/ui-kit/locale/ru';
+
+<I18nProvider locale={ru}><CreditForm /></I18nProvider>
+```
+
+_Source: src/platforms/react/i18n/provider.ts_
+
+### I18nProviderProps
+
+**Kind:** `type`
+
+**Signature:**
+```typescript
+export type I18nProviderProps = I18nStaticProviderProps | I18nLoadingProviderProps;
+```
+
+_Source: src/platforms/react/i18n/provider.ts_
+
+### I18nStaticProviderProps
+
+**Kind:** `interface`
+
+Режим «готовая локаль».
+
+**Signature:**
+```typescript
+export interface I18nStaticProviderProps {
+  /** Локаль. Смена объекта переключает язык сразу. */
+  locale: FormLocale;
+  children?: ReactNode;
+}
+```
+
+_Source: src/platforms/react/i18n/provider.ts_
+
 ### integer
 
 **Kind:** `function`
@@ -7233,6 +8667,19 @@ if (isGroupNode(node)) {
 
 _Source: src/form/type-guards.ts_
 
+### isMessageDescriptor
+
+**Kind:** `function`
+
+Является ли значение описателем сообщения.
+
+**Signature:**
+```typescript
+export function isMessageDescriptor(value: unknown): value is MessageDescriptor
+```
+
+_Source: src/i18n/descriptor.ts_
+
 ### isModelContainerSignal
 
 **Kind:** `function`
@@ -7293,6 +8740,207 @@ validate(model.$.amount, [required(), isNumber({ message: 'Введите чис
 
 _Source: src/form/validators/is-number.ts_
 
+### isValueSignal
+
+**Kind:** `function`
+
+«Ручка значения», к которой можно привязать поле: лист (`instanceof Signal`) либо узел-массив
+дерева `model.$` (значение — массив целиком, `.value` читается и пишется).
+
+Группа сюда не входит: она читается целиком, но не пишется и полем не бывает. Этой проверкой
+`createForm` и рендереры отличают узел-поле схемы (`{ value, component }`) от контейнера —
+вместо голого `value instanceof Signal`, который узел-массив не проходит.
+
+**Signature:**
+```typescript
+export function isValueSignal(value: unknown): value is Signal<unknown>
+```
+
+**Examples:**
+
+```typescript
+const model = createModel({ name: '', tags: [] as string[], address: { city: '' } });
+isValueSignal(model.$.name);    // true — лист
+isValueSignal(model.$.tags);    // true — массив как значение
+isValueSignal(model.$.address); // false — группа
+```
+
+_Source: src/model/model-signals-proxy.ts_
+
+### loadCoreLocale
+
+**Kind:** `const`
+
+Источник локалей ядра для `createLocaleLoader`: чанк нужного языка по запросу.
+
+**Signature:**
+```typescript
+export const loadCoreLocale
+```
+
+**Examples:**
+
+```ts
+const loadLocale = createLocaleLoader([loadCoreLocale, fetchMessages((code) => `/locales/${code}.json`)]);
+```
+
+_Source: src/locale/index.ts_
+
+### LocaleIssue
+
+**Kind:** `interface`
+
+Что не так со словарём.
+
+**Signature:**
+```typescript
+export interface LocaleIssue {
+  readonly key: string;
+  /**
+   * - `syntax` — сообщение не разбирается;
+   * - `missing` — ключ есть в образце, но его нет в словаре;
+   * - `extra` — ключа нет в образце;
+   * - `arguments` — набор подстановок не совпадает с образцом.
+   */
+  readonly kind: 'syntax' | 'missing' | 'extra' | 'arguments';
+  readonly message: string;
+}
+```
+
+_Source: src/i18n/locale.ts_
+
+### LocaleLoad
+
+**Kind:** `interface`
+
+Функция загрузки локали. `peek` — необязательный синхронный кэш (есть у `createLocaleLoader`).
+
+**Signature:**
+```typescript
+export interface LocaleLoad {
+  (code: string): Promise<FormLocale>;
+  peek?(code: string): FormLocale | undefined;
+}
+```
+
+_Source: src/i18n/locale-store.ts_
+
+### LocaleLoader
+
+**Kind:** `interface`
+
+Загрузчик локалей с кэшем.
+
+**Signature:**
+```typescript
+export interface LocaleLoader {
+  /** Загрузить локаль языка. Повторный вызов возвращает тот же промис и ту же локаль. */
+  (code: string): Promise<FormLocale>;
+  /** Уже загруженная локаль или `undefined`. Позволяет провайдеру отрисоваться синхронно. */
+  peek(code: string): FormLocale | undefined;
+  /** То же, что вызов загрузчика; имя для чтения в коде старта приложения. */
+  preload(code: string): Promise<FormLocale>;
+}
+```
+
+_Source: src/i18n/loader.ts_
+
+### LocaleSource
+
+**Kind:** `type`
+
+Источник локали. Получает код языка, отдаёт локаль или словарь — сразу или промисом.
+`null`/`undefined` означает «для этого языка у меня ничего нет» и ошибкой не считается.
+
+**Signature:**
+```typescript
+export type LocaleSource = (code: string) => LocaleSourceResult | Promise<LocaleSourceResult>;
+```
+
+_Source: src/i18n/loader.ts_
+
+### LocaleSourceResult
+
+**Kind:** `type`
+
+Что может вернуть источник: локаль целиком, её часть, голый словарь или ничего.
+
+**Signature:**
+```typescript
+export type LocaleSourceResult = Partial<FormLocale> | Messages | null | undefined;
+```
+
+_Source: src/i18n/loader.ts_
+
+### LocaleStore
+
+**Kind:** `interface`
+
+Хранилище активной локали.
+
+**Signature:**
+```typescript
+export interface LocaleStore {
+  getState(): LocaleStoreState;
+  subscribe(listener: () => void): () => void;
+  /** Запросить язык. Повторный запрос того же языка, пока он грузится или уже показан, — no-op. */
+  setLang(lang: string): void;
+}
+```
+
+_Source: src/i18n/locale-store.ts_
+
+### LocaleStoreOptions
+
+**Kind:** `interface`
+
+Настройки хранилища.
+
+**Signature:**
+```typescript
+export interface LocaleStoreOptions {
+  /** Вызывается при отказе загрузки языка, который всё ещё запрошен. */
+  readonly onError?: (error: unknown, lang: string) => void;
+}
+```
+
+_Source: src/i18n/locale-store.ts_
+
+### LocaleStoreState
+
+**Kind:** `interface`
+
+Состояние хранилища. Объект неизменяемый: новая ссылка — новое состояние.
+
+**Signature:**
+```typescript
+export interface LocaleStoreState {
+  /** Запрошенный язык. Пока `pending`, может отличаться от языка `locale`. */
+  readonly lang: string;
+  /** Локаль, которая сейчас на экране; `null` — ни одна ещё не загружена. */
+  readonly locale: FormLocale | null;
+  /** Идёт загрузка запрошенного языка. */
+  readonly pending: boolean;
+  /** Ошибка последней загрузки; сбрасывается следующей удачной. */
+  readonly error: unknown;
+}
+```
+
+_Source: src/i18n/locale-store.ts_
+
+### LocalizableText
+
+**Kind:** `type`
+
+Текст, который можно задать строкой или описателем.
+
+**Signature:**
+```typescript
+export type LocalizableText = string | MessageDescriptor;
+```
+
+_Source: src/i18n/descriptor.ts_
+
 ### makeElementFieldHandle
 
 **Kind:** `function`
@@ -7530,122 +9178,280 @@ _Source: src/form/validators/max-files.ts_
 
 Фабрика валидатора максимального размера файла.
 
-Работает с одиночным файлом или массивом (`File` либо файлоподобный дескриптор с
-`name`/`size`). Проверяется каждый файл; в ошибку попадает первый нарушивший.
-Пустые значения (`null`/`undefined`/`''`/`[]`) и элементы без числового `size`
-(например, дескриптор загруженного файла без размера) пропускаются
-(используйте {@link required} для обязательности).
+Работает с одиночным файлом или массивом (`File` либо файлоподобный дескриптор с
+`name`/`size`). Проверяется каждый файл; в ошибку попадает первый нарушивший.
+Пустые значения (`null`/`undefined`/`''`/`[]`) и элементы без числового `size`
+(например, дескриптор загруженного файла без размера) пропускаются
+(используйте {@link required} для обязательности).
+
+**Signature:**
+```typescript
+export function maxFileSize<TForm = unknown, TField = unknown>(
+  maxSize: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `maxSize` — - Максимально допустимый размер файла в байтах (включительно)
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `maxFileSize`, `fileName` и `actualSize`.
+
+**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+
+**Examples:**
+
+Ограничение размера вложений
+```typescript
+import { defineValidationSchema, validate } from '@reformer/core/validation';
+import { maxFileSize } from '@reformer/core/validators';
+
+// Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
+const validation = defineValidationSchema<MyForm>(({ model }) => {
+validate(model.$.documents, [maxFileSize(5 * 1024 * 1024, { message: 'Файл больше 5 МБ' })]);
+});
+```
+
+_Source: src/form/validators/max-file-size.ts_
+
+### maxLength
+
+**Kind:** `function`
+
+Фабрика валидатора максимальной длины строки или массива.
+
+Работает со строкой или массивом (проверяется `value.length`). Пустые значения
+(`null`/`undefined`/`''`) и значения без числового `length` пропускаются
+(используйте {@link required} для обязательности).
+
+**Signature:**
+```typescript
+export function maxLength<TForm = unknown, TField = unknown>(
+  maxLen: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `maxLen` — - Максимально допустимая длина (включительно)
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `maxLength` и `actualLength`.
+
+**Returns:** Чистый валидатор {@link Validator} для строки или массива
+
+**Examples:**
+
+Максимальная длина строки
+```typescript
+import { defineValidationSchema, validate } from '@reformer/core/validation';
+import { maxLength } from '@reformer/core/validators';
+
+// Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
+const validation = defineValidationSchema<MyForm>(({ model }) => {
+validate(model.$.name, [maxLength(50)]);
+validate(model.$.bio, [maxLength(500, { message: 'Максимум 500 символов' })]);
+});
+```
+
+_Source: src/form/validators/max-length.ts_
+
+### maxTotalFileSize
+
+**Kind:** `function`
+
+Фабрика валидатора суммарного размера всех файлов.
+
+Складывает `size` всех файлов значения (элементы без числового `size` в сумму
+не входят). Пустые значения (`null`/`undefined`/`''`/`[]`) пропускаются
+(используйте {@link required} для обязательности).
+
+**Signature:**
+```typescript
+export function maxTotalFileSize<TForm = unknown, TField = unknown>(
+  maxTotal: number,
+  options?: ValidateOptions
+): Validator<TForm, TField>
+```
+
+**Parameters:**
+- `maxTotal` — - Максимально допустимый суммарный размер в байтах (включительно)
+- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+попадают `maxTotalFileSize` и `actualTotal`.
+
+**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+
+**Examples:**
+
+Суммарно не более 20 МБ
+```typescript
+import { defineValidationSchema, validate } from '@reformer/core/validation';
+import { maxTotalFileSize } from '@reformer/core/validators';
+
+// Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
+const validation = defineValidationSchema<MyForm>(({ model }) => {
+validate(model.$.documents, [maxTotalFileSize(20 * 1024 * 1024, { message: 'Суммарно не более 20 МБ' })]);
+});
+```
+
+_Source: src/form/validators/max-total-file-size.ts_
+
+### MESSAGE_DESCRIPTOR
+
+**Kind:** `const`
+
+Бренд описателя. `Symbol.for` — чтобы описатель узнавался и через границу двух копий модуля
+(разные чанки, разные версии пакета на странице).
+
+**Signature:**
+```typescript
+export const MESSAGE_DESCRIPTOR: unique symbol
+```
+
+_Source: src/i18n/descriptor.ts_
+
+### messageArguments
+
+**Kind:** `function`
+
+Имена аргументов сообщения, включая те, что встречаются только внутри веток `plural`/`select`.
+
+**Signature:**
+```typescript
+export function messageArguments(
+  pattern: MessagePattern,
+  out: Set<string> = new Set()
+): Set<string>
+```
+
+**Parameters:**
+- `pattern` — - Результат `parseMessage`.
+
+_Source: src/i18n/locale.ts_
+
+### MessageBranches
+
+**Kind:** `type`
+
+Ветки `plural`/`select`: категория CLDR (`one`, `few`, …), точное совпадение (`=0`) или значение `select`.
+
+**Signature:**
+```typescript
+export type MessageBranches = ReadonlyMap<string, MessagePattern>;
+```
+
+_Source: src/i18n/message-format.ts_
+
+### MessageDescriptor
+
+**Kind:** `interface`
+
+Описатель сообщения. Намеренно без ключей `value`, `array`, `item`, `component`: обход схемы в
+`createForm` узнаёт по ним узел, а описатель узлом не является.
+
+**Signature:**
+```typescript
+export interface MessageDescriptor {
+  readonly [MESSAGE_DESCRIPTOR]: true;
+  /** Ключ сообщения в словаре приложения. */
+  readonly key: string;
+  /** Значения подстановок. */
+  readonly values?: Readonly<Record<string, unknown>>;
+  /** Английский текст на случай, если ключа в локали нет. */
+  readonly defaultMessage?: string;
+}
+```
+
+_Source: src/i18n/descriptor.ts_
+
+### MessageFormatOptions
+
+**Kind:** `interface`
+
+Настройки форматирования.
 
 **Signature:**
 ```typescript
-export function maxFileSize<TForm = unknown, TField = unknown>(
-  maxSize: number,
-  options?: ValidateOptions
-): Validator<TForm, TField>
+export interface MessageFormatOptions {
+  /**
+   * Что подставить вместо аргумента, которого нет в значениях (или чьё значение не число там, где
+   * ожидалось число). По умолчанию — заметный маркер `⟦name⟧`, тот же приём, что и для пропущенного
+   * ключа: пропуск должен попадаться разработчику, а не пользователю.
+   */
+  readonly onMissingArgument?: (name: string) => string;
+}
 ```
 
-**Parameters:**
-- `maxSize` — - Максимально допустимый размер файла в байтах (включительно)
-- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
-попадают `maxFileSize`, `fileName` и `actualSize`.
+_Source: src/i18n/message-format.ts_
 
-**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+### MessageNode
 
-**Examples:**
+**Kind:** `type`
 
-Ограничение размера вложений
-```typescript
-import { defineValidationSchema, validate } from '@reformer/core/validation';
-import { maxFileSize } from '@reformer/core/validators';
+Узел разобранного сообщения.
 
-// Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
-const validation = defineValidationSchema<MyForm>(({ model }) => {
-validate(model.$.documents, [maxFileSize(5 * 1024 * 1024, { message: 'Файл больше 5 МБ' })]);
-});
+**Signature:**
+```typescript
+export type MessageNode =
+  | { readonly kind: 'text'; readonly value: string }
+  | { readonly kind: 'arg'; readonly name: string }
+  | { readonly kind: 'number'; readonly name: string }
+  | { readonly kind: 'plural'; readonly name: string; readonly branches: MessageBranches }
+  | { readonly kind: 'select'; readonly name: string; readonly branches: MessageBranches };
 ```
 
-_Source: src/form/validators/max-file-size.ts_
-
-### maxLength
+_Source: src/i18n/message-format.ts_
 
-**Kind:** `function`
+### MessagePattern
 
-Фабрика валидатора максимальной длины строки или массива.
+**Kind:** `type`
 
-Работает со строкой или массивом (проверяется `value.length`). Пустые значения
-(`null`/`undefined`/`''`) и значения без числового `length` пропускаются
-(используйте {@link required} для обязательности).
+Разобранное сообщение — плоская последовательность узлов.
 
 **Signature:**
 ```typescript
-export function maxLength<TForm = unknown, TField = unknown>(
-  maxLen: number,
-  options?: ValidateOptions
-): Validator<TForm, TField>
+export type MessagePattern = readonly MessageNode[];
 ```
 
-**Parameters:**
-- `maxLen` — - Максимально допустимая длина (включительно)
-- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
-попадают `maxLength` и `actualLength`.
+_Source: src/i18n/message-format.ts_
 
-**Returns:** Чистый валидатор {@link Validator} для строки или массива
+### Messages
 
-**Examples:**
+**Kind:** `type`
 
-Максимальная длина строки
-```typescript
-import { defineValidationSchema, validate } from '@reformer/core/validation';
-import { maxLength } from '@reformer/core/validators';
+Плоский словарь: ключ → сообщение в формате ICU (см. `message-format.ts`).
 
-// Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
-const validation = defineValidationSchema<MyForm>(({ model }) => {
-validate(model.$.name, [maxLength(50)]);
-validate(model.$.bio, [maxLength(500, { message: 'Максимум 500 символов' })]);
-});
+**Signature:**
+```typescript
+export type Messages = Readonly<Record<string, string>>;
 ```
 
-_Source: src/form/validators/max-length.ts_
-
-### maxTotalFileSize
+_Source: src/i18n/locale.ts_
 
-**Kind:** `function`
+### MessageSyntaxError
 
-Фабрика валидатора суммарного размера всех файлов.
+**Kind:** `class`
 
-Складывает `size` всех файлов значения (элементы без числового `size` в сумму
-не входят). Пустые значения (`null`/`undefined`/`''`/`[]`) пропускаются
-(используйте {@link required} для обязательности).
+Отказ разбора сообщения: синтаксис или отсутствие обязательной ветки `other`.
 
 **Signature:**
 ```typescript
-export function maxTotalFileSize<TForm = unknown, TField = unknown>(
-  maxTotal: number,
-  options?: ValidateOptions
-): Validator<TForm, TField>
+export class MessageSyntaxError extends Error { /* … */ }
 ```
 
-**Parameters:**
-- `maxTotal` — - Максимально допустимый суммарный размер в байтах (включительно)
-- `options` — - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
-попадают `maxTotalFileSize` и `actualTotal`.
+_Source: src/i18n/message-format.ts_
 
-**Returns:** Чистый валидатор {@link Validator} для файла или массива файлов
+### MessageValues
 
-**Examples:**
+**Kind:** `type`
 
-Суммарно не более 20 МБ
-```typescript
-import { defineValidationSchema, validate } from '@reformer/core/validation';
-import { maxTotalFileSize } from '@reformer/core/validators';
+Значения аргументов сообщения.
 
-// Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
-const validation = defineValidationSchema<MyForm>(({ model }) => {
-validate(model.$.documents, [maxTotalFileSize(20 * 1024 * 1024, { message: 'Суммарно не более 20 МБ' })]);
-});
+**Signature:**
+```typescript
+export type MessageValues = Readonly<Record<string, unknown>>;
 ```
 
-_Source: src/form/validators/max-total-file-size.ts_
+_Source: src/i18n/message-format.ts_
 
 ### min
 
@@ -7923,7 +9729,10 @@ export interface ModelApi<T> {
   reset(): void;
   /** Зафиксировать текущие значения как новый initial-снимок («точка отсчёта»). */
   captureInitial(): void;
-  /** Резолв строкового пути в сигнал (для error-routing/мостов). */
+  /**
+   * Резолв строкового пути в сигнал (для error-routing/мостов): лист либо массив целиком
+   * (ручка значения массива — см. {@link ModelArraySignals}). Для пути группы — `undefined`.
+   */
   signalAt(path: string): PathAwareSignal<unknown> | undefined;
 }
 ```
@@ -7947,10 +9756,13 @@ export interface ModelArray<U> {
   readonly __path: string;
   /** Реактивная длина. */
   readonly length: number;
-  /** Добавить элемент в конец (значение элемента целиком). */
-  push(item: U): void;
-  /** Вставить элемент по индексу. */
-  insertAt(index: number, item: U): void;
+  /**
+   * Добавить элемент в конец (значение элемента целиком). Без значения — элемент по шаблону
+   * массива (`arrayOf(blank)` в модели); шаблона нет — ошибка.
+   */
+  push(item?: U): void;
+  /** Вставить элемент по индексу. Без значения — элемент по шаблону, как у {@link push}. */
+  insertAt(index: number, item?: U): void;
   /** Удалить элемент по индексу. */
   removeAt(index: number): void;
   /** Переместить элемент. */
@@ -7987,8 +9799,8 @@ _Source: src/model/types.ts_
 export interface ModelArrayControl<TItem extends object> {
   readonly length: number;
   at(index: number): FormModel<TItem> | undefined;
-  push(item: TItem): void;
-  insertAt(index: number, item: TItem): void;
+  push(item?: TItem): void;
+  insertAt(index: number, item?: TItem): void;
   removeAt(index: number): void;
   move(from: number, to: number): void;
   swap(a: number, b: number): void;
@@ -8012,7 +9824,7 @@ _Source: src/form/nodes/model-array-node.ts_
 reorder/повторном рендере не пересоздаются (состояние и валидация сохраняются). Реализует тот же
 контракт, что ждут секции массива и `useFormControl` (`length`/`value`/`valid`/`errors`/`at`/`push`/…).
 
-Обычно создаётся не напрямую, а `createForm({ model, schema })`: когда в схеме встречается узел
+Обычно создаётся не напрямую, а `createFormFromModel({ model, schema })`: когда в схеме встречается узел
 массива `{ array: model.<field>, item: (item) => itemSchema }`, форма материализует его как
 `ModelArrayNode` и кладёт под `form.<field>` (совместим с `FormArraySection`).
 
@@ -8032,7 +9844,7 @@ name: { value: item.$.name, component: Input },
 qty: { value: item.$.qty, component: Input },
 });
 
-const form = createForm({
+const form = createFormFromModel({
 model,
 schema: {
 children: [{ array: model.rows, item: rowItem }],
@@ -8052,12 +9864,23 @@ _Source: src/form/nodes/model-array-node.ts_
 **Kind:** `type`
 
 Узел-массив дерева `model.$`: индексируемый доступ к под-сигналам элементов, реактивная `length`
-и {@link ReadonlySignal} значения массива целиком (реагирует и на правку элемента, и на изменение
-состава — push/removeAt/move).
+и сигнал значения массива целиком (реагирует и на правку элемента, и на изменение состава —
+push/removeAt/move).
+
+В отличие от группы, узел ЗАПИСЫВАЕМ: `model.$.tags.value = ['a']` заменяет массив целиком. Это
+делает его {@link PathAwareSignal} — к нему привязывают поле (`{ value: model.$.tags, component }`),
+правило (`validate(model.$.tags, …)`) и поведение, как к листу. Так массив служит ОДНИМ значением
+поля: мультивыбор, теги, список файлов.
+
+`V` — объявленный тип поля, включая `null`/`undefined`: поле `string[] | null` с начальным `null`
+в рантайме — лист с тем же `.value`/`peek`/`subscribe`, поэтому общая часть честна для обоих
+случаев. `length` и индексы есть только у настоящего узла-массива (начальное значение — массив).
 
 **Signature:**
 ```typescript
-export type ModelArraySignals<U, V> = ContainerSignal<V, 'length'> & {
+export type ModelArraySignals<U, V> = Signal<V> & {
+  /** Путь массива в модели (dot-нотация). */
+  readonly __path: string;
   readonly length: number;
   readonly [index: number]: ModelSignalNode<U>;
 };
@@ -8099,6 +9922,57 @@ export type ModelObject<T> = {
 
 _Source: src/model/types.ts_
 
+### modelOf
+
+**Kind:** `function`
+
+Value-фасад по ручке дерева `model.$`: группа → под-модель {@link FormModel}, массив →
+{@link ModelArray}. Обратная операция к `model.$`: `modelOf(model.$.address) === model.address`.
+
+Ручка находит фасад по ИДЕНТИЧНОСТИ, а не по пути. Путь для этого не годится: он абсолютный
+(`items.0.phones`) и меняется при перестановке строк, а области поведения и формы строк
+вложенные — поиск по пути от под-модели строки ничего не находит.
+
+Лист ручкой контейнера не является — функция бросает. В частности, группа или массив,
+созданные из начального `null`, в модели — лист: вид узла фиксируется при создании.
+
+**Signature:**
+```typescript
+export function modelOf<V extends object | null | undefined>(handle: { peek(): V }): ModelOf<V>
+```
+
+**Parameters:**
+- `handle` — - Узел-группа или узел-массив дерева `model.$`.
+
+**Returns:** Под-модель группы либо фасад массива.
+
+**Examples:**
+
+```typescript
+const model = createModel({ address: { city: '' }, phones: [{ number: '' }] });
+
+modelOf(model.$.address).city = 'Казань'; // под-модель: чтение, запись, get/set/patch
+modelOf(model.$.phones).push({ number: '+7' }); // фасад массива: мутации и обход
+modelOf(model.$.phones[0]).number; // строка массива — тоже группа
+```
+
+_Source: src/model/model-value-proxy.ts_
+
+### ModelOf
+
+**Kind:** `type`
+
+Value-фасад для ручки {@link modelOf}: массив → {@link ModelArray}, объект → под-модель
+{@link FormModel}.
+
+**Signature:**
+```typescript
+export type ModelOf<V> =
+  NonNullable<V> extends ReadonlyArray<infer U> ? ModelArray<U> : FormModel<NonNullable<V>>;
+```
+
+_Source: src/model/model-value-proxy.ts_
+
 ### ModelSignals
 
 **Kind:** `type`
@@ -8140,6 +10014,34 @@ export type ModelValue<V> =
 
 _Source: src/model/types.ts_
 
+### msg
+
+**Kind:** `function`
+
+Создаёт описатель сообщения.
+
+**Signature:**
+```typescript
+export function msg(
+  key: string,
+  values?: Readonly<Record<string, unknown>>,
+  defaultMessage?: string
+): MessageDescriptor
+```
+
+**Parameters:**
+- `key` — - Ключ в словаре приложения.
+- `values` — - Значения подстановок.
+- `defaultMessage` — - Английский текст на случай, если ключа в локали нет.
+
+**Examples:**
+
+```ts
+{ value: model.$.email, component: Input, componentProps: { label: msg('profile.email.label') } }
+```
+
+_Source: src/i18n/descriptor.ts_
+
 ### multipleOf
 
 **Kind:** `function`
@@ -8249,6 +10151,25 @@ const node = factory.createNode({ value: '', component: Input }); // → FieldNo
 
 _Source: src/form/factories/node-factory.ts_
 
+### NodeLifecycleHooks
+
+**Kind:** `interface`
+
+Хуки жизненного цикла узла схемы. Каждый хук опционален; повторная регистрация перезаписывает
+предыдущее значение.
+
+**Signature:**
+```typescript
+export interface NodeLifecycleHooks {
+  /** Срабатывает один раз при mount узла. Может вернуть cleanup-функцию. */
+  onMount?: () => void | (() => void);
+  /** Срабатывает один раз при unmount узла. */
+  onUnmount?: () => void;
+}
+```
+
+_Source: src/form/schema-controller.ts_
+
 ### nonNegative
 
 **Kind:** `function`
@@ -8343,6 +10264,34 @@ export function onChange<T>(
 
 _Source: src/form/behaviors/operators.ts_
 
+### onComponentEvent
+
+**Kind:** `function`
+
+Повесить обработчик на проп-событие компонента узла (`onSubmit`, `onChange`, …).
+
+Обработчик получает те же аргументы, что и исходный проп компонента, и перекрывает одноимённый
+проп из `componentProps`.
+
+**Signature:**
+```typescript
+export function onComponentEvent(
+  node: SchemaNodeControl,
+  event: string,
+  handler: (...args: any[]) => any
+): void
+```
+
+**Examples:**
+
+```typescript
+onComponentEvent(schema.node('wizard'), 'onSubmit', async () => {
+  await submitApplication(model.get());
+});
+```
+
+_Source: src/form/behaviors/schema-operators.ts_
+
 ### onDispose
 
 **Kind:** `function`
@@ -8356,6 +10305,95 @@ export function onDispose(cleanup: BehaviorCleanup): void
 
 _Source: src/form/behaviors/context.ts_
 
+### onInit
+
+**Kind:** `function`
+
+Синхронный хук времени сборки: `fn` вызывается сразу, до первого рендера узла. Единственный
+хук, способный повлиять на первый рендер, — внутри можно править пропсы через
+`schema.node(selector).patchProps({ … })`.
+
+К монтированию узла не привязан; аргумент `node` принимается ради симметрии с
+{@link onMount} / {@link onUnmount}.
+
+**Signature:**
+```typescript
+export function onInit(_node: SchemaNodeControl, fn: () => void): void
+```
+
+**Examples:**
+
+```typescript
+onInit(schema.node('summary'), () => {
+  schema.node('summary').patchProps({ currency: detectCurrency() });
+});
+```
+
+_Source: src/form/behaviors/schema-operators.ts_
+
+### onMount
+
+**Kind:** `function`
+
+Хук после первого монтирования узла. Может вернуть очистку — она выполнится при размонтировании.
+
+**Signature:**
+```typescript
+export function onMount(node: SchemaNodeControl, fn: () => void | (() => void)): void
+```
+
+**Examples:**
+
+```typescript
+onMount(schema.node('data-boundary'), () => void loadApplication());
+```
+
+_Source: src/form/behaviors/schema-operators.ts_
+
+### onUnmount
+
+**Kind:** `function`
+
+Хук перед размонтированием узла.
+
+**Signature:**
+```typescript
+export function onUnmount(node: SchemaNodeControl, fn: () => void): void
+```
+
+**Examples:**
+
+```typescript
+onUnmount(schema.node('wizard'), () => saveDraft(model.get()));
+```
+
+_Source: src/form/behaviors/schema-operators.ts_
+
+### parseMessage
+
+**Kind:** `function`
+
+Разбирает сообщение в дерево. Бросает {@link MessageSyntaxError} на ошибке синтаксиса и на
+`plural`/`select` без ветки `other`.
+
+**Signature:**
+```typescript
+export function parseMessage(source: string): MessagePattern
+```
+
+**Parameters:**
+- `source` — - Текст сообщения из словаря.
+
+**Returns:** Разобранное сообщение для {@link formatPattern}.
+
+**Examples:**
+
+```ts
+parseMessage('{count, plural, one{# файл} few{# файла} many{# файлов} other{# файла}}');
+```
+
+_Source: src/i18n/message-format.ts_
+
 ### pastDate
 
 **Kind:** `function`
@@ -8526,35 +10564,60 @@ _Source: src/form/validators/phone.ts_
 
 **Kind:** `function`
 
-Связать сигнал модели с его нодой формы.
+Связать ручку модели с её нодой формы.
 
-Вызывается движком при сборке формы (`createForm`/{@link createFormFromModel}) для каждого
-листового поля. Прикладной код обычно этот реестр не заполняет напрямую.
+Вызывается движком при сборке формы (`createForm`/{@link createFormFromModel}) для каждого поля,
+группы и массива под-форм. Прикладной код обычно этот реестр не заполняет напрямую.
 
 **Signature:**
 ```typescript
-export function registerSignalNode(signal: Signal<any>, node: FormNode<any>): void
+export function registerSignalNode(signal: object, node: FormNode<any>): void
 ```
 
 **Parameters:**
-- `signal` — - Сигнал значения из {@link FormModel} (ручка поля, `model.$.path`)
-- `node` — - Нода формы, отвечающая за это поле
+- `signal` — - Ручка из {@link FormModel}: сигнал листа, узел-массив или узел-группа дерева `model.$`
+- `node` — - Нода формы, отвечающая за эту часть модели
+
+**Examples:**
+
+Привязка листовых полей при построении формы
+```typescript
+import { registerSignalNode } from '@reformer/core';
+
+const sig = model.signalAt('profile.email');
+const node = group.getFieldByPath('profile.email');
+if (sig && node) registerSignalNode(sig, node);
+```
+
+**See also:**
+- {@link getNodeForSignal} - обратный поиск ноды по ручке
+
+_Source: src/form/signal-node-registry.ts_
+
+### renderEffect
+
+**Kind:** `function`
+
+Реактивный эффект, живущий, пока схема области смонтирована рендерером.
+
+В отличие от `effect` поведения, запускается после монтирования — внутри доступны ref узлов
+(`schema.node(selector).getRef().current`). Может вернуть функцию очистки.
+
+**Signature:**
+```typescript
+export function renderEffect(schema: SchemaScope, effectFn: () => void | (() => void)): void
+```
 
 **Examples:**
 
-Привязка листовых полей при построении формы
 ```typescript
-import { registerSignalNode } from '@reformer/core';
-
-const sig = model.signalAt('profile.email');
-const node = group.getFieldByPath('profile.email');
-if (sig && node) registerSignalNode(sig, node);
+const wizard = schema.node('wizard').getRef<FormWizardHandle>();
+renderEffect(schema, () => {
+  if (model.loanType === 'mortgage') wizard.current?.goToStep(1);
+});
 ```
 
-**See also:**
-- {@link getNodeForSignal} - обратный поиск ноды по сигналу
-
-_Source: src/form/signal-node-registry.ts_
+_Source: src/form/behaviors/schema-operators.ts_
 
 ### required
 
@@ -8620,6 +10683,81 @@ resetWhen(model.$.cardNumber, () => model.paymentType !== 'card', { resetValue:
 
 _Source: src/model/behaviors-value.ts_
 
+### ResolvedSchema
+
+**Kind:** `interface`
+
+Дерево, собранное реестром из документа схемы (JSON), и то, что реестр хочет донести до
+рендерера вместе с ним.
+
+**Signature:**
+```typescript
+export interface ResolvedSchema {
+  /** Корневой узел дерева. */
+  tree: FormSchemaNode;
+  /** Обёртка поля — компонент, которым рендерер оборачивает каждое поле. */
+  fieldWrapper?: unknown;
+  /** Граница ошибок — компонент, которым рендерер оборачивает дерево. */
+  errorBoundary?: unknown;
+}
+```
+
+_Source: src/form/form-bundle.ts_
+
+### resolveLocalized
+
+**Kind:** `function`
+
+Заменяет описатели сообщений на строки по активной локали. Обходит массивы и простые
+объекты-литералы — подписи опций, заголовки шагов; сигналы, React-элементы, функции и
+экземпляры классов (узлы формы) возвращает как есть. Поддерево без описателей сохраняет ссылку:
+если раскрывать было нечего, возвращается тот же объект.
+
+**Signature:**
+```typescript
+export function resolveLocalized<T>(value: T, i18n: I18nHandle): T
+```
+
+**Parameters:**
+- `value` — - Пропсы, массив или одиночное значение.
+- `i18n` — - Ручка активной локали (`createI18n` / `useI18n`).
+
+**Examples:**
+
+```ts
+resolveLocalized({ label: msg('profile.email.label'), options: [{ value: 'a', label: msg('opt.a') }] }, i18n);
+// { label: 'Почта', options: [{ value: 'a', label: 'Вариант А' }] }
+```
+
+_Source: src/i18n/resolve-localized.ts_
+
+### resolveValidationError
+
+**Kind:** `function`
+
+Отображаемый текст ошибки валидации. Порядок источников — в шапке модуля.
+
+**Signature:**
+```typescript
+export function resolveValidationError(error: ValidationError, i18n: I18nHandle): string
+```
+
+**Parameters:**
+- `error` — - Ошибка от правила: `code`, `message`, `messageKey`, `params`.
+- `i18n` — - Ручка активной локали (`createI18n` / `useI18n`).
+
+**Examples:**
+
+```ts
+resolveValidationError({ code: 'minLength', message: '', params: { minLength: 8 } }, i18n);
+// 'Enter at least 8 characters' · в русской локали — 'Не меньше 8 символов'
+
+resolveValidationError({ code: 'required', message: 'Укажите телефон' }, i18n);
+// 'Укажите телефон' — явное сообщение автора важнее словаря
+```
+
+_Source: src/i18n/validation-message.ts_
+
 ### revalidateWhen
 
 **Kind:** `function`
@@ -8653,7 +10791,8 @@ _Source: src/model/behaviors-value.ts_
 (`required()`/`min()`/… — они `(value, model, root) => …`) и inline-правила `(value) => …`
 ОБА присваиваются в `Rule<TField>[]` без `any`, при этом сохраняется проверка типа поля
 (`validate(model.$.age, [email()])` подсветится — `email` ждёт `string`, поле `number`).
-На вызове раннер приводит правило к callable и передаёт `(value, model, model)`.
+На вызове раннер приводит правило к callable и передаёт `(value, scope, root)`: модель текущей
+области (в корне прогона — вся модель) и корень прогона.
 
 **Signature:**
 ```typescript
@@ -8789,13 +10928,155 @@ export interface SchemaArrayControl {
   /** Реактивная длина. */
   readonly length: number;
   at(index: number): unknown;
-  push(item: unknown): void;
+  push(item?: unknown): void;
   removeAt(index: number): void;
 }
 ```
 
 _Source: src/form/types/schema-node.ts_
 
+### SchemaController
+
+**Kind:** `interface`
+
+Схема-контроллер сборки: области по под-моделям.
+
+**Signature:**
+```typescript
+export interface SchemaController {
+  /**
+   * Область под-модели: корня сборки, строки массива или группы подформы. Создаётся при первом
+   * обращении; повторное обращение отдаёт ту же область.
+   */
+  scopeOf(subModel: object): SchemaScope;
+}
+```
+
+_Source: src/form/schema-controller.ts_
+
+### SchemaNodeControl
+
+**Kind:** `interface`
+
+Управление одним узлом схемы. Получается через `schema.node(selector)`.
+
+**Signature:**
+```typescript
+export interface SchemaNodeControl {
+  /** Принудительно скрыть или показать узел, минуя условие `hideWhen`. */
+  setHidden(value: boolean): this;
+  /** Убрать принудительное значение — снова действует условие `hideWhen`. */
+  resetHidden(): this;
+  /** Подмешать объект в `componentProps` узла. */
+  patchProps(partial: Record<string, unknown>): this;
+  /** Убрать подмешанные пропсы. */
+  resetProps(): this;
+  /**
+   * Ref на компонент узла. Создаётся один раз на селектор; рендерер вешает его на компонент.
+   * Компонент обязан принимать `ref`.
+   */
+  getRef<H>(): { current: H | null };
+  /** @internal Селектор узла. */
+  __selector: string;
+  /** @internal Хранилище области. */
+  __overrideMaps: SchemaOverrideMaps;
+}
+```
+
+_Source: src/form/schema-controller.ts_
+
+### SchemaOverrideMaps
+
+**Kind:** `interface`
+
+Хранилище переопределений одной области схемы. Ключ каждой карты — `selector` узла.
+
+**Signature:**
+```typescript
+export interface SchemaOverrideMaps {
+  hiddenOverrides: Map<string, boolean | null>;
+  propsOverrides: Map<string, Record<string, unknown> | null>;
+  refRegistry: Map<string, { current: any }>;
+  /** Условия скрытия узлов: selector → реактивное условие. */
+  conditionRegistry: Map<string, () => boolean>;
+  /** Реактивные эффекты, живущие, пока область смонтирована (`renderEffect`). */
+  effectRegistry: Array<() => void | (() => void)>;
+  /** Обработчики событий компонентов: selector → { имя пропа → обработчик }. */
+  callbackRegistry: Map<string, Map<string, (...args: any[]) => any>>;
+  /** Хуки жизненного цикла узла: selector → { onMount, onUnmount }. */
+  lifecycleRegistry: Map<string, NodeLifecycleHooks>;
+  /** Общий счётчик изменений области. Узлы на него не подписываются — см. `versionFor`. */
+  version: Signal<number>;
+  /**
+   * Версия-сигнал одного селектора (создаётся лениво). Узел подписывается только на сигнал СВОЕГО
+   * селектора, поэтому `setHidden` / `patchProps` уведомляют один узел, а не всё дерево.
+   */
+  versionFor(selector: string): Signal<number>;
+}
+```
+
+_Source: src/form/schema-controller.ts_
+
+### SchemaResolver
+
+**Kind:** `interface`
+
+Реестр, умеющий превратить документ схемы в дерево. Метод необязателен: у интерфейса реестра
+есть сторонние реализации, и ядро документ само не разбирает.
+
+**Signature:**
+```typescript
+export interface SchemaResolver {
+  resolveSchema?(document: unknown, model: FormModel<never>): ResolvedSchema;
+}
+```
+
+_Source: src/form/form-bundle.ts_
+
+### SchemaScope
+
+**Kind:** `interface`
+
+Схема одной области: адресует узлы по `selector`.
+
+**Signature:**
+```typescript
+export interface SchemaScope {
+  /** Управление узлом области по его `selector`. */
+  node(selector: string): SchemaNodeControl;
+  /** @internal Хранилище области — его читает рендерер. */
+  __overrideMaps: SchemaOverrideMaps;
+}
+```
+
+_Source: src/form/schema-controller.ts_
+
+### schemaSubtree
+
+**Kind:** `function`
+
+Поддерево схемы для под-модели — результат `builder(subModel)`, один на пару.
+
+**Signature:**
+```typescript
+export function schemaSubtree<N>(builder: (subModel: any) => N, subModel: object): N
+```
+
+**Parameters:**
+- `builder` — - Билдер поддерева: `item` узла-массива или `part` узла-подформы.
+- `subModel` — - Под-модель строки массива или группы.
+
+**Returns:** Узел поддерева; повторный вызов с той же парой отдаёт тот же объект.
+
+**Examples:**
+
+```typescript
+const row = model.items.at(0);
+schemaSubtree(itemSchema, row) === schemaSubtree(itemSchema, row); // true
+```
+
+_Source: src/form/schema-subtree.ts_
+
 ### SetValueOptions
 
 **Kind:** `interface`
@@ -8984,6 +11265,32 @@ transformValue(model.$.promoCode, (v) => (v ?? '').toUpperCase());
 
 _Source: src/model/behaviors-value.ts_
 
+### translateBuiltin
+
+**Kind:** `function`
+
+Перевод ключа пакета: словарь локали, затем встроенная английская таблица пакета, затем сам
+ключ. Английская таблица форматируется по английским правилам — её множественные формы и
+группировка чисел не зависят от активного языка.
+
+**Signature:**
+```typescript
+export function translateBuiltin(
+  locale: FormLocale,
+  builtin: Messages,
+  key: string,
+  values?: MessageValues
+): string
+```
+
+**Parameters:**
+- `locale` — - Активная локаль.
+- `builtin` — - Встроенная английская таблица пакета-владельца ключа.
+- `key` — - Ключ сообщения.
+- `values` — - Значения подстановок.
+
+_Source: src/i18n/translator.ts_
+
 ### UnknownRecord
 
 **Kind:** `type`
@@ -8998,6 +11305,36 @@ export type UnknownRecord = Record<string, unknown>;
 
 _Source: src/form/types/index.ts_
 
+### unknownSchemaSelectors
+
+**Kind:** `function`
+
+Селекторы, на которые в области записаны правила, но которых нет в её дереве. Такое правило
+ничего не делает — сборка и рендерер в dev предупреждают о нём.
+
+Ref в проверку не входит: его разрешено брать по абсолютному пути модели
+(`phones.0.number`), а такой строки при сборке может ещё не быть.
+
+**Signature:**
+```typescript
+export function unknownSchemaSelectors(maps: SchemaOverrideMaps, tree: unknown): string[]
+```
+
+**Parameters:**
+- `maps` — - Хранилище области.
+- `tree` — - Дерево (поддерево) области.
+
+**Returns:** Селекторы с правилами, не найденные в дереве.
+
+**Examples:**
+
+```typescript
+const scope = controller.scopeOf(model);
+unknownSchemaSelectors(scope.__overrideMaps, tree); // ['mortgage'] — узла с таким selector нет
+```
+
+_Source: src/form/schema-controller.ts_
+
 ### unmarkDerived
 
 **Kind:** `function`
@@ -9185,6 +11522,29 @@ const credit = useFormBundle(() => createCoreForm<CreditForm>({ model: createCre
 
 _Source: src/platforms/react/hooks/use-form-bundle.ts_
 
+### useFormBundleContext
+
+**Kind:** `function`
+
+Бандл сборки, внутри которой отрисован компонент; `null` — компонент стоит вне рендерера
+(например, визард в разметке React-руками получает форму и валидацию пропсами).
+
+**Signature:**
+```typescript
+export function useFormBundleContext<T = unknown>(): FormBundle<T> | null
+```
+
+**Examples:**
+
+```tsx
+function StepFooter() {
+  const bundle = useFormBundleContext<CreditForm>();
+  return <button onClick={() => bundle?.validation?.validateAll()}>Проверить</button>;
+}
+```
+
+_Source: src/platforms/react/form-bundle-context.ts_
+
 ### useFormControl
 
 **Kind:** `function`
@@ -9227,6 +11587,7 @@ export function useFormControl(
 Текстовое поле с валидацией
 ```tsx
 import { useFormControl } from '@reformer/core';
+import { useValidationMessage } from '@reformer/core/i18n';
 import type { FieldNode } from '@reformer/core';
 
 interface TextFieldProps {
@@ -9242,6 +11603,8 @@ shouldShowError,
 errors,
 pending
 } = useFormControl(control);
+// Текст ошибки даёт резолвер: у правил без своего сообщения `message` пуст.
+const message = useValidationMessage();
 
 return (
 <div className="field">
@@ -9261,7 +11624,7 @@ return (
 
 {shouldShowError && errors[0] && (
 <span className="error" role="alert">
- {errors[0].message}
+ {message(errors[0])}
 </span>
 )}
 </div>
@@ -9309,6 +11672,7 @@ control: FieldNode<string>;
 
 function Select({ control }: SelectProps) {
 const { value, disabled, componentProps, shouldShowError, errors } = useFormControl(control);
+const message = useValidationMessage(); // из '@reformer/core/i18n'
 const options = componentProps.options as Array<{ value: string; label: string }>;
 
 return (
@@ -9326,7 +11690,7 @@ onBlur={() => control.markAsTouched()}
  </option>
 ))}
 </select>
-{shouldShowError && <span className="error">{errors[0]?.message}</span>}
+{shouldShowError && <span className="error">{message(errors[0])}</span>}
 </div>
 );
 }
@@ -9564,6 +11928,7 @@ dangerouslySetInnerHTML={{ __html: html }}
 // Основной редактор использует useFormControl для полного состояния
 function MarkdownEditor({ control }: MarkdownEditorProps) {
 const { value, shouldShowError, errors } = useFormControl(control);
+const message = useValidationMessage(); // из '@reformer/core/i18n'
 
 return (
 <div className="editor-container">
@@ -9571,7 +11936,7 @@ return (
 value={value}
 onChange={e => control.setValue(e.target.value)}
 />
-{shouldShowError && <span className="error">{errors[0]?.message}</span>}
+{shouldShowError && <span className="error">{message(errors[0])}</span>}
 
 {/* Preview обновляется только при изменении value *}
 <MarkdownPreview control={control} />
@@ -9675,12 +12040,104 @@ export interface UseFormValidationResult {
 
 _Source: src/platforms/react/hooks/use-form-validation.ts_
 
+### useI18n
+
+**Kind:** `function`
+
+Активная локаль: перевод ключей приложения, форматирование чисел, дат и размеров, состояние
+загрузки языка. Без провайдера — английский с пустым словарём.
+
+**Signature:**
+```typescript
+export function useI18n(): I18nContextValue
+```
+
+**Examples:**
+
+```tsx
+function LangBadge() {
+  const { code, pending, t } = useI18n();
+  return <span aria-busy={pending}>{t('app.language')}: {code}</span>;
+}
+```
+
+_Source: src/platforms/react/i18n/hooks.ts_
+
+### useMessages
+
+**Kind:** `function`
+
+Переводчик пакета: ищет ключ в локали провайдера, а при промахе берёт встроенную английскую
+таблицу этого пакета. Так пакет говорит по-английски без провайдера и не зависит от того, знает
+ли локаль его ключи. Тип ключа выводится из таблицы — опечатка в ключе не скомпилируется.
+
+`defaults` должен быть стабильной ссылкой (импорт JSON-модуля), иначе переводчик будет
+пересоздаваться на каждый рендер.
+
+**Signature:**
+```typescript
+export function useMessages<D extends Messages>(
+  defaults: D
+): (key: keyof D & string, values?: MessageValues) => string
+```
+
+**Parameters:**
+- `defaults` — - Встроенная английская таблица пакета.
+
+**Returns:** Функция `(ключ, значения?) => строка`; её идентичность меняется вместе с локалью.
+
+**Examples:**
+
+```tsx
+import en from './locale/en.json';
+
+const useKitMessages = () => useMessages(en);
+
+function ClearButton() {
+  const t = useKitMessages();
+  return <button aria-label={t('kit.select.clear')} />;
+}
+```
+
+_Source: src/platforms/react/i18n/hooks.ts_
+
+### useValidationMessage
+
+**Kind:** `function`
+
+Резолвер текста ошибки валидации по активной локали: `messageKey` автора → явное `message` →
+словарь локали по коду → встроенный английский → код. Идентичность функции меняется вместе с
+локалью, поэтому показанные ошибки переводятся при смене языка без повторной валидации.
+
+`FormField` из `@reformer/cdk` использует его сам; вызывайте напрямую, если рисуете ошибки
+своим компонентом.
+
+**Signature:**
+```typescript
+export function useValidationMessage(): (error: ValidationError) => string
+```
+
+**Examples:**
+
+```tsx
+function FieldErrors({ control }: { control: FieldNode<string> }) {
+  const message = useValidationMessage();
+  const { errors } = useFormControl(control);
+  return <>{errors.map((error) => <span key={error.code}>{message(error)}</span>)}</>;
+}
+```
+
+_Source: src/platforms/react/i18n/hooks.ts_
+
 ### validate
 
 **Kind:** `function`
 
 Синхронные правила поля.
 
+Поле — лист либо массив целиком: `model.$.<массив>` — такая же ручка значения, и правило
+получает массив (мультивыбор, теги, список файлов).
+
 **Signature:**
 ```typescript
 export function validate<TField>(sig: PathAwareSignal<TField>, rules: Rule<TField>[]): void
@@ -9690,6 +12147,7 @@ export function validate<TField>(sig: PathAwareSignal<TField>, rules: Rule<TFiel
 
 ```ts
 validate(model.$.loanAmount, [required({ message: 'Сумма' }), min(50000)]);
+validate(model.$.tags, [required(), maxLength(3)]); // tags: string[] — массив как значение
 ```
 
 _Source: src/form/validation/operators.ts_
@@ -9720,6 +12178,34 @@ validateAsync(model.$.username, [async (v, { signal }) => {
 
 _Source: src/form/validation/operators.ts_
 
+### validateLocale
+
+**Kind:** `function`
+
+Проверяет словарь: каждое сообщение разбирается, а при заданном образце — набор ключей и имена
+подстановок совпадают с ним. Нужна там, где компилятор не поможет: словарь пришёл по сети или
+написан вне репозитория. В рантайме вызывать не обязательно — битое или пропущенное сообщение
+и так откатится на встроенный английский; проверка нужна тестам и CI.
+
+**Signature:**
+```typescript
+export function validateLocale(messages: Messages, reference?: Messages): LocaleIssue[]
+```
+
+**Parameters:**
+- `messages` — - Проверяемый словарь.
+- `reference` — - Образец, обычно английский словарь того же пакета.
+
+**Returns:** Список расхождений; пустой — словарь в порядке.
+
+**Examples:**
+
+```ts
+expect(validateLocale(ruJson, enJson)).toEqual([]);
+```
+
+_Source: src/i18n/locale.ts_
+
 ### validateModel
 
 **Kind:** `function`
@@ -9776,8 +12262,20 @@ _Source: src/form/validation/run.ts_
 ```typescript
 export interface ValidateOptions {
   /** Готовое сообщение об ошибке. Если не задано, валидаторы кладут `''`, и отображаемый текст
-   * резолвится из `code` (см. резолвер сообщений в `@reformer/cdk`). */
+   * берётся из словаря локали по `code` (`validation.<code>`; см. `resolveValidationError` в
+   * `@reformer/core/i18n`). Явное сообщение важнее словаря, но не переключается вместе с языком —
+   * для локализуемого текста используйте {@link ValidateOptions.messageKey}. */
   message?: string;
+  /**
+   * Ключ сообщения в словаре приложения — локализуемый текст автора правила. Если ключ есть в
+   * активной локали, он важнее и `message`, и текста по `code`; если нет — в ход идёт `message`.
+   *
+   * @example
+   * ```ts
+   * required({ messageKey: 'profile.name.required', message: 'Name is required' });
+   * ```
+   */
+  messageKey?: string;
   /** Параметры ошибки (подстановка в шаблон сообщения / i18n). */
   params?: Record<string, FormValue>;
 }
@@ -9809,7 +12307,13 @@ _Source: src/form/validation/operators.ts_
 ```typescript
 export interface ValidationError {
   code: string;
+  /**
+   * Готовый текст ошибки. Пустая строка — «автор правила текста не задавал»: отображаемую строку
+   * тогда даёт резолвер по `code` (словарь локали `validation.<code>`).
+   */
   message: string;
+  /** Ключ сообщения в словаре приложения; при наличии в активной локали важнее `message`. */
+  messageKey?: string;
   params?: Record<string, FormValue>;
   /** Severity level: 'error' (default) blocks submission, 'warning' shows message but allows submission */
   severity?: 'error' | 'warning';
@@ -9929,3 +12433,16 @@ watchField(model.$.country, async (country) => {
 ```
 
 _Source: src/model/behaviors-value.ts_
+
+### WeekStart
+
+**Kind:** `type`
+
+День недели, с которого начинается календарь: `0` — воскресенье, `1` — понедельник.
+
+**Signature:**
+```typescript
+export type WeekStart = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+```
+
+_Source: src/i18n/locale.ts_