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

package/dist/model.js

@@ -1,23 +1,25 @@
-import { c as s, e as r, a as i } from "./create-model-B8U-COv-.js";
-import { b as o, i as c, a as n, m as t, u as d } from "./model-signals-proxy-2vqS243J.js";
-import { c as m, a as u, r as b, b as h, d as p, e as g, f as k, s as v, t as D, w as F } from "./behaviors-value-C7dSEhCc.js";
+import { c as s, e as r, a as l } from "./create-model-BBRHhHwK.js";
+import { a as o, d as c, i as d, b as n, c as t, m as f, u as m } from "./model-value-proxy-caTmAiUd.js";
+import { c as b, a as h, r as p, b as g, d as k, e as v, f as D, s as F, t as S, w as x } from "./behaviors-value-C7dSEhCc.js";
 export {
-  m as computeFrom,
-  u as copyFrom,
+  o as arrayOf,
+  b as computeFrom,
+  h as copyFrom,
   s as createModel,
   r as eachLeafSignal,
-  i as eachValueSignal,
-  o as isDerived,
-  c as isModelContainerSignal,
+  l as eachValueSignal,
+  c as isDerived,
+  d as isModelContainerSignal,
   n as isValueSignal,
   t as markDerived,
-  b as resetWhen,
-  h as revalidateWhen,
-  p as runOutsideEffect,
-  g as safeCallback,
-  k as safeDebouncedCallback,
-  v as syncFields,
-  D as transformValue,
-  d as unmarkDerived,
-  F as watchField
+  f as modelOf,
+  p as resetWhen,
+  g as revalidateWhen,
+  k as runOutsideEffect,
+  v as safeCallback,
+  D as safeDebouncedCallback,
+  F as syncFields,
+  S as transformValue,
+  m as unmarkDerived,
+  x as watchField
 };

package/dist/node-BeV_lV5i.js

@@ -0,0 +1,100 @@
+import { signal as o, effect as a } from "@preact/signals-core";
+import { b as f, i as c, f as u } from "./model-value-proxy-caTmAiUd.js";
+import { g as d } from "./signal-node-registry-tiwel-TV.js";
+import { d as l } from "./behaviors-value-C7dSEhCc.js";
+function p() {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    hiddenOverrides: /* @__PURE__ */ new Map(),
+    propsOverrides: /* @__PURE__ */ new Map(),
+    refRegistry: /* @__PURE__ */ new Map(),
+    conditionRegistry: /* @__PURE__ */ new Map(),
+    effectRegistry: [],
+    callbackRegistry: /* @__PURE__ */ new Map(),
+    lifecycleRegistry: /* @__PURE__ */ new Map(),
+    version: o(0),
+    versionFor(t) {
+      let r = e.get(t);
+      return r || (r = o(0), e.set(t, r)), r;
+    }
+  };
+}
+function g(e = p()) {
+  const t = (r) => {
+    e.version.value++, e.versionFor(r).value++;
+  };
+  return {
+    __overrideMaps: e,
+    node: (r) => ({
+      setHidden(n) {
+        return e.hiddenOverrides.set(r, n), t(r), this;
+      },
+      resetHidden() {
+        return e.hiddenOverrides.delete(r), t(r), this;
+      },
+      patchProps(n) {
+        return e.propsOverrides.set(r, {
+          ...e.propsOverrides.get(r) ?? {},
+          ...n
+        }), t(r), this;
+      },
+      resetProps() {
+        return e.propsOverrides.delete(r), t(r), this;
+      },
+      getRef() {
+        let n = e.refRegistry.get(r);
+        return n || (n = { current: null }, e.refRegistry.set(r, n)), n;
+      },
+      __selector: r,
+      __overrideMaps: e
+    })
+  };
+}
+function S() {
+  const e = /* @__PURE__ */ new WeakMap();
+  return {
+    scopeOf(t) {
+      let r = e.get(t);
+      return r || (r = g(), e.set(t, r)), r;
+    }
+  };
+}
+function s(e, t, r) {
+  if (e == null || typeof e != "object" || f(e) || c(e) || u(e) || e.$$typeof !== void 0 || r.has(e)) return;
+  if (r.add(e), Array.isArray(e)) {
+    for (const i of e) s(i, t, r);
+    return;
+  }
+  const n = e.selector;
+  typeof n == "string" && t.add(n);
+  for (const i of Object.values(e)) s(i, t, r);
+}
+function b(e, t) {
+  const r = /* @__PURE__ */ new Set();
+  return s(t, r, /* @__PURE__ */ new WeakSet()), [.../* @__PURE__ */ new Set([
+    ...e.hiddenOverrides.keys(),
+    ...e.propsOverrides.keys(),
+    ...e.conditionRegistry.keys(),
+    ...e.callbackRegistry.keys(),
+    ...e.lifecycleRegistry.keys()
+  ])].filter((i) => !r.has(i));
+}
+function y(e, t, r) {
+  return a(() => {
+    const n = t(), i = d(e);
+    i && l(() => {
+      n ? i.enable() : (i.disable(), r?.resetOnDisable && i.reset());
+    });
+  });
+}
+function M(e, t, r) {
+  return y(e, () => !t(), r);
+}
+export {
+  g as a,
+  p as b,
+  S as c,
+  M as d,
+  y as e,
+  b as u
+};

package/dist/platforms/react/form-bundle-context.d.ts

@@ -0,0 +1,27 @@
+import { FormBundle } from '../../form/form-bundle';
+/**
+ * Контекст сборки. Значение — бандл `createForm`; вне рендерера — `null`.
+ *
+ * @example
+ * ```tsx
+ * <FormBundleContext.Provider value={bundle}>
+ *   <MyWizard />
+ * </FormBundleContext.Provider>
+ * ```
+ */
+export declare const FormBundleContext: import('react').Context<FormBundle<any> | null>;
+/**
+ * Бандл сборки, внутри которой отрисован компонент; `null` — компонент стоит вне рендерера
+ * (например, визард в разметке React-руками получает форму и валидацию пропсами).
+ *
+ * @typeParam T - Форма данных модели.
+ *
+ * @example
+ * ```tsx
+ * function StepFooter() {
+ *   const bundle = useFormBundleContext<CreditForm>();
+ *   return <button onClick={() => bundle?.validation?.validateAll()}>Проверить</button>;
+ * }
+ * ```
+ */
+export declare function useFormBundleContext<T = unknown>(): FormBundle<T> | null;

package/dist/platforms/react/index.d.ts

@@ -20,6 +20,7 @@ export { useFormValidation } from './hooks/use-form-validation';
 export type { UseFormValidationArgs, UseFormValidationResult } from './hooks/use-form-validation';
 export { useFormBundle } from './hooks/use-form-bundle';
 export type { FormBundleLike } from './hooks/use-form-bundle';
+export { FormBundleContext, useFormBundleContext } from './form-bundle-context';
 export type { FieldControlState, ArrayControlState } from './hooks/types';
 export { getFieldAdapter, bindFieldProps, FIELD_WRAPPER_ONLY_PROPS, } from './field-binding/field-adapter';
 export type { FieldAdapter, FieldAdapterCarrier, FieldSeam } from './field-binding/field-adapter';

package/dist/strategy-DgzELWno.js

@@ -0,0 +1,204 @@
+import { g as W, m as E, h as $ } from "./model-value-proxy-caTmAiUd.js";
+import { signal as O, effect as P } from "@preact/signals-core";
+import { a as V } from "./create-model-BBRHhHwK.js";
+import { g as h } from "./signal-node-registry-tiwel-TV.js";
+let p = null;
+function A(e, r) {
+  const t = p;
+  p = e;
+  try {
+    return r();
+  } finally {
+    p = t;
+  }
+}
+function c(e) {
+  if (!p)
+    throw new Error(
+      `[@reformer/core/validation] "${e}" вызван вне схемы валидации — операторы валидации можно вызывать только внутри прогона validateModel(...) (напрямую или через apply/each).`
+    );
+  return p;
+}
+function m(e, r) {
+  let t = e.errors.get(r);
+  return t || e.errors.set(r, t = []), t;
+}
+const y = (e) => e.whenStack.every((r) => r());
+function _(e, r) {
+  const t = c("validate"), n = m(t, e);
+  if (!y(t)) return;
+  const o = e.peek();
+  for (const a of r) {
+    const i = a(o, t.model, t.root);
+    i && n.push(i);
+  }
+}
+function j(e, r) {
+  const t = c("validateAsync"), n = m(t, e);
+  if (!y(t)) return;
+  const o = e.peek(), a = t.signal;
+  for (const i of r)
+    t.pending.push(
+      i(o, { signal: a }).then(
+        (s) => {
+          s && !a.aborted && n.push(s);
+        },
+        () => {
+        }
+      )
+    );
+}
+function z(e, r) {
+  const t = c("validateWhen");
+  t.whenStack.push(e);
+  try {
+    r();
+  } finally {
+    t.whenStack.pop();
+  }
+}
+function G(e, r) {
+  const t = c("cross"), n = m(t, e);
+  if (!y(t)) return;
+  const o = r(t.model.get());
+  o && n.push(o);
+}
+function F(e, r, t) {
+  const n = r;
+  A(
+    { ...e, model: n },
+    () => t({ model: n })
+  );
+}
+function M(e, r) {
+  const t = $(r);
+  if (!t)
+    throw new TypeError(
+      `[@reformer/core/validation] ${e}: ожидался массив под-форм модели — \`model.$.<массив>\`. Массив примитивов — одно значение поля, его проверяют целиком: \`validate(model.$.<массив>, [...])\`.`
+    );
+  return E(t);
+}
+function I(e, r) {
+  const t = c("applyEach"), n = M("applyEach", e), o = n.length;
+  for (let a = 0; a < o; a++) F(t, n.at(a), r);
+}
+function J(e, r) {
+  c("each");
+  const t = M("each", e), n = t.length;
+  for (let o = 0; o < n; o++) r(t.at(o));
+}
+function K(...e) {
+  const r = c("apply");
+  if (typeof e[0] == "function") {
+    for (const o of e) o({ model: r.model });
+    return;
+  }
+  const [t, n] = e;
+  for (const o of Array.isArray(t) ? t : [t]) {
+    const a = W(o);
+    if (!a)
+      throw new TypeError(
+        "[@reformer/core/validation] apply: ожидалась группа модели — `model.$.<группа>`. Массив под-форм подключают через `applyEach`."
+      );
+    F(r, E(a), n);
+  }
+}
+function Q(e) {
+  return e;
+}
+const x = /* @__PURE__ */ new WeakMap();
+function C(e, r) {
+  let t = x.get(e);
+  t || x.set(e, t = /* @__PURE__ */ new WeakMap());
+  let n = t.get(r);
+  return n || t.set(r, n = { fields: /* @__PURE__ */ new Set(), ac: null }), n;
+}
+const L = (e) => {
+  for (const r of e.values()) for (const t of r) if (t.severity !== "warning") return !0;
+  return !1;
+};
+function H(e) {
+  return e.aborted ? Promise.resolve() : new Promise((r) => {
+    e.addEventListener("abort", () => r(), { once: !0 });
+  });
+}
+async function q(e, r, t) {
+  const n = C(e, r);
+  n.ac?.abort();
+  const o = new AbortController();
+  n.ac = o;
+  const a = {
+    model: e,
+    root: e,
+    errors: /* @__PURE__ */ new Map(),
+    pending: [],
+    whenStack: [],
+    signal: o.signal
+  };
+  if (A(a, () => r({ model: e })), a.pending.length && await Promise.race([Promise.all(a.pending), H(o.signal)]), o.signal.aborted) return !1;
+  const i = new Set(a.errors.keys());
+  for (const s of n.fields) i.has(s) || h(s)?.setErrors([]);
+  for (const s of i) h(s)?.setErrors(a.errors.get(s) ?? []);
+  if (t?.touch) for (const s of i) h(s)?.markAsTouched();
+  return n.fields = i, !L(a.errors);
+}
+function U(e, r, t = {}) {
+  const { strategy: n = "submit", debounce: o = 0, liveAfterSubmit: a = "change" } = t, i = O(!1);
+  let s = 0, w = !1, u, l;
+  const b = async (f) => {
+    s++, i.value = !0;
+    try {
+      return await q(e, r, { touch: f });
+    } finally {
+      --s === 0 && (i.value = !1);
+    }
+  }, g = () => {
+    b(!1);
+  }, T = () => {
+    if (!o) {
+      g();
+      return;
+    }
+    l && clearTimeout(l), l = setTimeout(g, o);
+  }, k = (f, d) => {
+    let S = !0;
+    return P(() => {
+      if (V(e, f), S) {
+        S = !1;
+        return;
+      }
+      n === "afterFirstSubmit" && !w || d();
+    });
+  }, v = {
+    async validate() {
+      return w = !0, b(!0);
+    },
+    start() {
+      if (u) return () => v.dispose();
+      const f = n === "afterFirstSubmit" ? a : n;
+      return f === "change" ? u = k((d) => void d.value, T) : f === "blur" && (u = k((d) => void h(d)?.touched.value, g)), () => v.dispose();
+    },
+    dispose() {
+      l && (clearTimeout(l), l = void 0), u?.(), u = void 0;
+    },
+    get isValidating() {
+      return i.value;
+    },
+    get validating() {
+      return i;
+    }
+  };
+  return v;
+}
+export {
+  j as a,
+  z as b,
+  G as c,
+  K as d,
+  J as e,
+  I as f,
+  Q as g,
+  q as h,
+  U as i,
+  _ as v
+};

package/dist/validation.js

@@ -1,12 +1,13 @@
-import { d as s, h as d, c as i, f as l, e as t, v as o, a as c, g as n, b as r } from "./strategy-BXS_gBfz.js";
+import { d as s, f as i, i as d, c as l, g as t, e as c, v as o, a as h, h as n, b as p } from "./strategy-DgzELWno.js";
 export {
   s as apply,
+  i as applyEach,
   d as createFormValidation,
-  i as cross,
-  l as defineValidationSchema,
-  t as each,
+  l as cross,
+  t as defineValidationSchema,
+  c as each,
   o as validate,
-  c as validateAsync,
+  h as validateAsync,
   n as validateModel,
-  r as validateWhen
+  p as validateWhen
 };

package/docs/llms/03-api-signatures.md

@@ -11,7 +11,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([...])
@@ -67,7 +67,7 @@ maxAge(years: number, options?: { message?: string })
 `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';
 
@@ -75,7 +75,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 },
@@ -262,7 +262,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`,

package/docs/llms/09-formschema.md

@@ -25,7 +25,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';
@@ -66,7 +66,7 @@ const schema = {
   },
 };
 
-const form = createForm<MyForm>({ model, schema });
+const form = createFormFromModel<MyForm>({ model, schema });
 ```
 
 ### Nested Objects
@@ -111,7 +111,7 @@ const schema = {
 
 ```typescript
 // M1: данные из модели + схема (+ опциональный декларативный behavior)
-const form = createForm<MyForm>({
+const form = createFormFromModel<MyForm>({
   model,                 // FormModel<MyForm> — обязателен
   schema,                // дерево узлов, привязанных к сигналам
   behavior: myBehavior,  // опционально: defineFormBehavior(...) из @reformer/core/behaviors
@@ -126,12 +126,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> — вложенный доступ

package/docs/llms/10-arrays.md

@@ -6,7 +6,7 @@
 элемента из его под-модели (`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 };
@@ -25,7 +25,7 @@ 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`) — иначе
@@ -47,7 +47,7 @@ const model = createModel<MyForm>({ tags: [] });
 const schema = {
   tags: { value: model.$.tags, component: SelectMulti }, // поле над массивом целиком
 };
-const form = createForm<MyForm>({ model, schema });
+const form = createFormFromModel<MyForm>({ model, schema });
 
 form.tags.setValue(['a', 'b']); // FieldNode<string[]>
 model.$.tags.value = ['c']; // ручка значения: заменяет массив целиком
@@ -62,6 +62,25 @@ validate(model.$.tags, [required(), maxLength(3)]); // правило получ
 - Запись в узел-ГРУППУ (`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`.
+
 ### Один массив — три слоя (три разных движка)
 
 Одна и та же коллекция описывается **тремя разными формами** — по одной на движок. Их легко
@@ -73,7 +92,7 @@ validate(model.$.tags, [required(), maxLength(3)]); // правило получ
    `model.$.properties`.
 
    ```typescript
-   // узел схемы для createForm({ model, schema })
+   // узел схемы для createFormFromModel({ model, schema })
    properties: { array: model.properties, item: propertyItem },
    ```
 

package/docs/llms/16-ui-components.md

@@ -19,7 +19,7 @@
 
 ```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 = {
@@ -54,7 +54,7 @@ function RegistrationPage() {
         componentProps: { label: 'I agree to terms' },
       },
     };
-    return createForm<RegistrationForm>({ model, schema });
+    return createFormFromModel<RegistrationForm>({ model, schema });
   }, []);
 
   return (

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

@@ -56,7 +56,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` значение группы сохраняется (удобно, когда оно копируется

package/docs/llms/21-array-operations.md

@@ -76,6 +76,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 − Σ остальных»):

package/docs/llms/28-submit-and-reset.md

@@ -48,7 +48,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';
 
@@ -66,7 +66,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) => {
@@ -198,7 +198,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 }) => {

package/docs/llms/29-async-preload.md

@@ -30,7 +30,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 };
@@ -51,7 +51,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() возвращает к этим значениям
 ```
@@ -138,14 +138,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) }) };
   }, []);
 }
 ```