@reformer/core 9.0.0 → 9.1.1

package/dist/behaviors.js

@@ -1,27 +1,28 @@
-import { effect as j } from "@preact/signals-core";
-import { r as $, m as x, c as O, w as F, e as S, t as A, a as C, s as M, b as D } from "./behaviors-O9a1Djj9.js";
+import { effect as O } from "@preact/signals-core";
+import { d as $, m as k, u as x, a as S, w as F, t as A, r as C, s as D, b as M } from "./behaviors-value-lCpqicfa.js";
+import { e as G } from "./behaviors-node-BMOI2JJF.js";
 let p = null;
-function k(e) {
+function P(e) {
   if (!p)
     throw new Error(
       `[@reformer/core/behaviors] "${e}" вызван вне defineFormBehavior(...) — операторы поведения можно вызывать только внутри схемы.`
     );
   return p;
 }
-function a(e) {
-  k("onDispose").cleanups.push(e);
+function s(e) {
+  P("onDispose").cleanups.push(e);
 }
 function y() {
-  const e = k("getScope");
+  const e = P("getScope");
   return { model: e.model, form: e.form };
 }
-function G(e) {
+function T(e) {
   return {
-    __run(n, t) {
-      const o = { cleanups: [], model: n, form: t }, r = p;
+    __run(t, n) {
+      const o = { cleanups: [], model: t, form: n }, r = p;
       p = o;
       try {
-        e({ model: n, form: t });
+        e({ model: t, form: n });
       } finally {
         p = r;
       }
@@ -32,211 +33,211 @@ function G(e) {
   };
 }
 function m(e) {
-  a(j(e));
+  s(O(e));
 }
-function g(e) {
+function _(e) {
   $(e);
 }
-const h = (e) => typeof e == "object" && e !== null && typeof e.peek == "function", P = (e) => Array.isArray(e) ? e : [e];
-function B(e) {
-  const n = {};
-  for (const t of Object.keys(e)) {
-    const o = e[t];
-    n[t] = h(o) ? o.value : B(o);
+const h = (e) => typeof e == "object" && e !== null && typeof e.peek == "function", B = (e) => Array.isArray(e) ? e : [e];
+function E(e) {
+  const t = {};
+  for (const n of Object.keys(e)) {
+    const o = e[n];
+    t[n] = h(o) ? o.value : E(o);
   }
-  return n;
+  return t;
 }
-function E(e, n) {
-  for (const t of Object.keys(e)) {
-    const o = e[t];
-    h(o) ? o.value = n?.[t] : E(o, n?.[t] ?? {});
+function W(e, t) {
+  for (const n of Object.keys(e)) {
+    const o = e[n];
+    h(o) ? o.value = t?.[n] : W(o, t?.[n] ?? {});
   }
 }
-function T(e) {
+function I(e) {
   if (!e) return;
-  const { form: n } = y();
-  return n.getFieldByPath(e);
+  const { form: t } = y();
+  return t.getFieldByPath(e);
 }
-function W(e) {
+function V(e) {
   return new Proxy(
     {},
     {
-      get: (n, t) => {
-        if (t === "$") return e;
-        if (typeof t != "string") return;
-        const o = e[t];
+      get: (t, n) => {
+        if (n === "$") return e;
+        if (typeof n != "string") return;
+        const o = e[n];
         if (o != null)
-          return h(o) ? o.value : W(o);
+          return h(o) ? o.value : V(o);
       }
     }
   );
 }
-function V(e) {
-  return (n) => {
+function j(e) {
+  return (t) => {
     try {
-      n();
-    } catch (t) {
-      if (t instanceof Error && /cycle detected/i.test(t.message)) {
+      t();
+    } catch (n) {
+      if (n instanceof Error && /cycle detected/i.test(n.message)) {
         const o = e.__path ?? "?";
         throw new Error(
           `[@reformer/core/behaviors] compute("${o}"): расходящийся цикл пересчёта — взаимные compute/computeFrom без стабилизации. Проверьте зависимости или добавьте стабилизирующее условие (when) / разорвите цикл через peek.`
         );
       }
-      throw t;
+      throw n;
     }
   };
 }
-function K(e, n, t) {
-  x(e);
-  const o = V(e);
+function Q(e, t, n) {
+  k(e), s(() => x(e));
+  const o = j(e);
   m(() => {
-    if (t?.when && !t.when()) return;
-    const r = n();
+    if (n?.when && !n.when()) return;
+    const r = t();
     e.peek() !== r && o(() => {
       e.value = r;
     });
   });
 }
-function L(e, n, t, o) {
-  x(n);
-  const r = V(n);
+function U(e, t, n, o) {
+  k(t), s(() => x(t));
+  const r = j(t);
   m(() => {
     const c = e.map((f) => f.value);
     if (o?.when && !o.when(...c)) return;
-    const i = t(...c);
-    n.peek() !== i && r(() => {
-      n.value = i;
+    const i = n(...c);
+    t.peek() !== i && r(() => {
+      t.value = i;
     });
   });
 }
-function Q(e, n, t) {
-  if (h(e) && h(n)) {
-    a(O(e, n, t));
+function X(e, t, n) {
+  if (h(e) && h(t)) {
+    s(S(e, t, n));
     return;
   }
-  const o = e, r = n;
+  const o = e, r = t;
   m(() => {
-    const c = B(o);
-    t?.when && !t.when() || g(() => E(r, c));
+    const c = E(o);
+    n?.when && !n.when() || _(() => W(r, c));
   });
 }
-function I(e, n, t) {
+function R(e, t, n) {
   let o;
   const r = (c) => {
     o?.abort(), o = new AbortController();
     const { signal: i } = o;
-    $(() => n(c, { signal: i }));
+    $(() => t(c, { signal: i }));
   };
-  if (!t?.debounce)
-    a(F(e, r, { immediate: t?.immediate }));
+  if (!n?.debounce)
+    s(F(e, r, { immediate: n?.immediate }));
   else {
     let c;
     const i = F(
       e,
       (f) => {
-        c && clearTimeout(c), c = setTimeout(() => r(f), t.debounce);
+        c && clearTimeout(c), c = setTimeout(() => r(f), n.debounce);
       },
-      { immediate: t?.immediate }
+      { immediate: n?.immediate }
     );
-    a(() => {
+    s(() => {
       c && clearTimeout(c), i();
     });
   }
-  a(() => o?.abort());
+  s(() => o?.abort());
 }
-function R(e, n, t) {
-  for (const o of P(e))
-    h(o) ? a(S(o, n, t)) : q(o, n, t);
+function q(e, t, n) {
+  for (const o of B(e))
+    h(o) ? s(G(o, t, n)) : z(o, t, n);
 }
-function U(e, n, t) {
-  R(e, () => !n(), t);
+function Y(e, t, n) {
+  q(e, () => !t(), n);
 }
-function q(e, n, t) {
-  const o = T(e.__path);
+function z(e, t, n) {
+  const o = I(e.__path);
   o && m(() => {
-    const r = n();
-    g(() => {
-      r ? o.enable() : (o.disable(), t?.resetOnDisable && o.reset());
+    const r = t();
+    _(() => {
+      r ? o.enable() : (o.disable(), n?.resetOnDisable && o.reset());
     });
   });
 }
-function X(e, n) {
-  a(A(e, n));
+function Z(e, t) {
+  s(A(e, t));
 }
-function Y(e, n, t) {
-  a(C(e, n, t));
+function ee(e, t, n) {
+  s(C(e, t, n));
 }
-function Z(e, n, t) {
-  a(M(e, n, t));
+function ne(e, t, n) {
+  s(D(e, t, n));
 }
-function ee(e, n) {
-  a(D(e, n));
+function te(e, t) {
+  s(M(e, t));
 }
-function _(e, n) {
-  return n.split(".").reduce((t, o) => t?.[o], e);
+function g(e, t) {
+  return t.split(".").reduce((n, o) => n?.[o], e);
 }
-function z(e) {
+function N(e) {
   return new Proxy(
     {},
     {
-      get(n, t) {
-        if (!(typeof t == "symbol" || t === "then"))
+      get(t, n) {
+        if (!(typeof n == "symbol" || n === "then"))
           throw new Error(
             `[@reformer/core/behaviors] applyEach: форма строки массива "${e}" недоступна (form.${String(
-              t
+              n
             )}) — массив не материализован в схеме формы. Per-row node-операции (enableWhen/updateComponentProps/reset) требуют узла { array, item } в схеме; value-операции (row.$.*: compute/copyFrom/transformValue) работают и без материализации.`
           );
       }
     }
   );
 }
-function N(e, n) {
-  const { model: t, form: o } = y(), r = e.__path;
+function H(e, t) {
+  const { model: n, form: o } = y(), r = e.__path;
   if (!r) return;
-  const c = _(t, r);
+  const c = g(n, r);
   if (!c) return;
   const i = o.getFieldByPath(
     r
-  ), f = i?.length, s = /* @__PURE__ */ new Map();
+  ), f = i?.length, u = /* @__PURE__ */ new Map();
   m(() => {
     const d = f ? f.value : c.length, w = /* @__PURE__ */ new Set();
-    for (let u = 0; u < d; u++) {
-      const l = c.at(u);
-      if (l != null && (w.add(l), !s.has(l))) {
-        const b = i?.at?.(u) ?? z(r);
-        s.set(l, n.__run(l, b));
+    for (let a = 0; a < d; a++) {
+      const l = c.at(a);
+      if (l != null && (w.add(l), !u.has(l))) {
+        const b = i?.at?.(a) ?? N(r);
+        u.set(l, t.__run(l, b));
       }
     }
-    for (const [u, l] of s)
-      w.has(u) || (l(), s.delete(u));
-  }), a(() => {
-    for (const d of s.values()) d();
-    s.clear();
+    for (const [a, l] of u)
+      w.has(a) || (l(), u.delete(a));
+  }), s(() => {
+    for (const d of u.values()) d();
+    u.clear();
   });
 }
 function v(e) {
   if (e == null || typeof e != "object") return;
-  const n = e;
-  if (typeof n.at == "function" && typeof n.length == "number") {
-    const t = n.length;
-    for (let o = 0; o < t; o++) v(n.at(o));
+  const t = e;
+  if (typeof t.at == "function" && typeof t.length == "number") {
+    const n = t.length;
+    for (let o = 0; o < n; o++) v(t.at(o));
     return;
   }
-  for (const t of Object.keys(e)) v(e[t]);
+  for (const n of Object.keys(e)) v(e[n]);
 }
-function te(e, n) {
-  const { model: t } = y(), o = e.__path;
+function oe(e, t) {
+  const { model: n } = y(), o = e.__path;
   if (!o) return;
-  const r = _(t, o);
-  r && N(
+  const r = g(n, o);
+  r && H(
     e,
-    G(({ model: c }) => {
-      I(n(c), (i) => {
+    T(({ model: c }) => {
+      R(t(c), (i) => {
         if (i)
           for (let f = 0; f < r.length; f++) {
-            const s = r.at(f);
-            if (s && s !== c) {
-              const d = n(s);
+            const u = r.at(f);
+            if (u && u !== c) {
+              const d = t(u);
               d.peek() && (d.value = !1);
             }
           }
@@ -244,57 +245,57 @@ function te(e, n) {
     })
   );
 }
-function ne(e, n) {
-  const { model: t } = y(), o = e.__path;
+function re(e, t) {
+  const { model: n } = y(), o = e.__path;
   if (!o) return;
-  const r = _(t, o);
+  const r = g(n, o);
   if (!r) return;
   let c = !1, i = 0;
   m(() => {
-    v(r), !c && (c = !0, g(() => {
+    v(r), !c && (c = !0, _(() => {
       c = !1;
-      const f = n(r.toArray());
-      let s = !1;
+      const f = t(r.toArray());
+      let u = !1;
       for (const { index: d, patch: w } of f) {
-        const u = r.at(d);
-        if (u)
+        const a = r.at(d);
+        if (a)
           for (const [l, b] of Object.entries(w))
-            u[l] !== b && (u[l] = b, s = !0);
+            a[l] !== b && (a[l] = b, u = !0);
       }
-      if (i = s ? i + 1 : 0, i > 50)
+      if (i = u ? i + 1 : 0, i > 50)
         throw i = 0, new Error(
           `[@reformer/core/behaviors] aggregateInto("${o}"): запись не сходится (>50 проходов) — derive должна быть идемпотентной на фикспоинте.`
         );
     }));
   });
 }
-function oe(e, n) {
-  const { form: t } = y();
-  for (const o of P(e)) {
+function ce(e, t) {
+  const { form: n } = y();
+  for (const o of B(e)) {
     const r = o, c = r.__path;
     if (!c) continue;
-    const i = t ? t.getFieldByPath(c) : void 0, f = i ? i.getProxy?.() ?? i : void 0;
-    a(n.__run(W(r), f));
+    const i = n ? n.getFieldByPath(c) : void 0, f = i ? i.getProxy?.() ?? i : void 0;
+    s(t.__run(V(r), f));
   }
 }
 export {
-  ne as aggregateInto,
-  oe as apply,
-  N as applyEach,
-  K as compute,
-  L as computeFrom,
-  Q as copyFrom,
-  g as defer,
-  G as defineFormBehavior,
-  U as disableWhen,
+  re as aggregateInto,
+  ce as apply,
+  H as applyEach,
+  Q as compute,
+  U as computeFrom,
+  X as copyFrom,
+  _ as defer,
+  T as defineFormBehavior,
+  Y as disableWhen,
   m as effect,
-  R as enableWhen,
-  te as exclusiveFlag,
+  q as enableWhen,
+  oe as exclusiveFlag,
   y as getScope,
-  I as onChange,
-  a as onDispose,
-  Y as resetWhen,
-  ee as revalidateWhen,
-  Z as syncFields,
-  X as transformValue
+  R as onChange,
+  s as onDispose,
+  ee as resetWhen,
+  te as revalidateWhen,
+  ne as syncFields,
+  Z as transformValue
 };

package/dist/{core/utils → form}/aggregate-signals.d.ts

@@ -1,6 +1,6 @@
 import { ReadonlySignal, Signal } from '@preact/signals-core';
-import { FieldStatus, ValidationError } from '../types';
-import { FormNode } from '../nodes/form-node';
+import { FieldStatus, ValidationError } from './types/index';
+import { FormNode } from './nodes/form-node';
 /**
  * Функция получения дочерних узлов
  * Возвращает массив FormNode для агрегации состояния

package/dist/form/behaviors-node.d.ts

@@ -0,0 +1,55 @@
+import { ReadonlySignal } from '@preact/signals-core';
+import { BehaviorCleanup } from '../state/behaviors-value';
+/**
+ * Условное включение поля (state-операция). Резолвит ноду по сигналу-цели через реестр
+ * сигнал→нода (заполняется `createForm`) и вызывает `enable()`/`disable()` (+`reset()` при
+ * `resetOnDisable`). `condition` реактивен (читает свои сигналы модели).
+ *
+ * Запись состояния отложена через `runOutsideEffect` (микротаск) для защиты от «Cycle detected».
+ * ⚠️ Поле должно быть материализовано в форме (`createForm`) — иначе ноды в реестре нет (например,
+ * элемент массива, который строится per-item).
+ *
+ * ⚠️ Если то же поле одновременно является целью `compute`/`computeFrom`, обязательно ограничь
+ * compute тем же условием (`when`), что и это `enableWhen`. Механизмы не согласованы: `enableWhen`
+ * работает со статус-машиной ноды (enable/disable/reset), а `compute` пишет `target.value` напрямую
+ * в сигнал модели и проверяет только собственный `options.when` — состояние `disabled` он НЕ смотрит.
+ * Поэтому при выключенном поле любое изменение зависимости compute молча заново заполнит его (а с
+ * `resetOnDisable` — перезапишет только что сброшенное значение), и так как `getValue()`/`submit`
+ * включают disabled-поля, мусор утечёт в payload. Это аналог правила #13 гайда add-behavior,
+ * которое сегодня сформулировано только для `copyFrom`; для `compute` то же ограничение обязательно.
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * enableWhen(model.$.propertyValue, () => model.loanType === 'mortgage', { resetOnDisable: true });
+ *
+ * // Поле-цель compute, которое ТАКЖЕ в resetOnDisable enableWhen: compute обязан нести тот же when,
+ * // иначе initialPayment заново заполнится в выключенном состоянии и утечёт в submit.
+ * compute(model.$.initialPayment, () => model.propertyValue * 0.2, {
+ *   when: () => model.loanType === 'mortgage',
+ * });
+ * ```
+ */
+export declare function enableWhen(target: ReadonlySignal<unknown>, condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): BehaviorCleanup;
+/**
+ * Условное выключение поля (инверсия {@link enableWhen}). Резолвит ноду по сигналу-цели через реестр
+ * сигнал→нода и вызывает `disable()`, когда `condition` истинно (+`reset()` при `resetOnDisable`).
+ * `condition` реактивен (читает свои сигналы модели).
+ *
+ * @group Model
+ * @param target Сигнал-цель поля (`model.$.<path>`).
+ * @param condition Реактивное условие; при `true` поле выключается.
+ * @param options.resetOnDisable Сбросить значение при выключении (по умолчанию `false`).
+ * @returns Cleanup для отписки.
+ *
+ * @example
+ * ```typescript
+ * // Поле скидки недоступно, пока не выбран промо-тариф
+ * disableWhen(model.$.discount, () => model.plan !== 'promo', { resetOnDisable: true });
+ * ```
+ */
+export declare function disableWhen(target: ReadonlySignal<unknown>, condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): BehaviorCleanup;

package/dist/form/behaviors.d.ts

@@ -0,0 +1,133 @@
+import { Signal, ReadonlySignal } from '@preact/signals-core';
+import { BehaviorCleanup, FormModel, FormProxy } from '../index';
+/** Контекст схемы поведения: модель (значения/сигналы) + форма (ноды). */
+export type BehaviorScope<T> = {
+    model: FormModel<T>;
+    form: FormProxy<T>;
+};
+/** Результат {@link defineFormBehavior}; передаётся в `createForm({ behavior })`. */
+export interface FormBehavior<T> {
+    /** @internal Запускается `createForm` после построения нод и заполнения реестра сигнал→нода. */
+    __run(model: FormModel<T>, form: FormProxy<T>): BehaviorCleanup;
+}
+export type { Signal, ReadonlySignal, BehaviorCleanup };
+/** Зарегистрировать произвольную отписку в активной схеме. */
+export declare function onDispose(cleanup: BehaviorCleanup): void;
+/** Текущий scope ({ model, form }) активной схемы (escape hatch для кросс-операторов). */
+export declare function getScope<T>(): BehaviorScope<T>;
+/**
+ * Описать поведение формы декларативно. Возвращает {@link FormBehavior} для `createForm({ behavior })`.
+ *
+ * @example
+ * ```ts
+ * export const myBehavior = defineFormBehavior<MyForm>(({ model, form }) => {
+ *   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) }));
+ * });
+ * ```
+ */
+export declare function defineFormBehavior<T>(setup: (scope: BehaviorScope<T>) => void): FormBehavior<T>;
+/** Реактивный эффект (авто-dispose). Колбэк может вернуть собственный cleanup. */
+export declare function effect(fn: () => void | (() => void)): void;
+/** Отложенная запись вне effect-контекста (микротаск) — защита от «Cycle detected». */
+export declare function defer(fn: () => void): void;
+/** Вычисляемое поле с auto-tracking: `target = read()` при изменении прочитанных сигналов. */
+export declare function compute<R>(target: Signal<R>, read: () => R, options?: {
+    when?: () => boolean;
+}): void;
+/** Вычисляемое поле с явным списком зависимостей (escape hatch). */
+export declare function computeFrom<R>(sources: ReadonlySignal<unknown>[], target: Signal<R>, fn: (...values: any[]) => R, options?: {
+    when?: (...values: any[]) => boolean;
+}): void;
+/** Копирование `source → target` — скаляр или группа (объект целиком). */
+export declare function copyFrom<T>(source: ReadonlySignal<T> | object, target: Signal<T> | object, options?: {
+    when?: () => boolean;
+    transform?: (value: T) => T;
+}): void;
+/** Контекст async-реакции: `signal` аннулируется, когда поле меняется снова до завершения колбэка. */
+export interface ChangeContext {
+    signal: AbortSignal;
+}
+/**
+ * Реакция на изменение поля; `{ debounce, immediate }`.
+ *
+ * Колбэк выполняется ВНЕ effect-контекста (микротаск/таймер) — можно безопасно писать сигналы и ноды
+ * (`updateComponentProps`/`reset`/`clear`) без ручного `defer` и без «Cycle detected».
+ *
+ * Для async-колбэков 2-м аргументом приходит `{ signal }` (AbortSignal): при следующей смене значения
+ * предыдущий `signal` аннулируется. Передавай его в `fetch` (сетевая отмена) или проверяй
+ * `signal.aborted` перед применением результата — это убирает гонки устаревших ответов (F2).
+ */
+export declare function onChange<T>(source: ReadonlySignal<T>, cb: (value: T, ctx: ChangeContext) => void, options?: {
+    immediate?: boolean;
+    debounce?: number;
+}): void;
+type EnableTarget = ReadonlySignal<unknown> | object;
+/** Условное включение поля(ей) — скаляр, массив целей или группа. `resetOnDisable=false` по умолчанию. */
+export declare function enableWhen(target: EnableTarget | EnableTarget[], condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): void;
+/** Условное выключение поля(ей) (инверсия {@link enableWhen}). */
+export declare function disableWhen(target: EnableTarget | EnableTarget[], condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): void;
+/** Трансформация значения поля (идемпотентная). */
+export declare function transformValue<T>(target: Signal<T>, transformer: (value: T) => T): void;
+/** Сброс значения по условию. */
+export declare function resetWhen<T>(target: Signal<T>, condition: () => boolean, options?: {
+    resetValue?: T;
+}): void;
+/** Двусторонняя синхронизация двух полей. */
+export declare function syncFields<T>(a: Signal<T>, b: Signal<T>, options?: {
+    transform?: (value: T) => T;
+}): void;
+/** Ревалидация при изменении зависимостей. */
+export declare function revalidateWhen(deps: ReadonlySignal<unknown>[], revalidate: () => void): void;
+/**
+ * Применить под-схему к КАЖДОМУ элементу динамического массива (per-item поведение).
+ * Реагирует на добавление/удаление строк: новым строкам поведение применяется, удалённым — отписывается.
+ *
+ * Под-схема получает scope строки: `model` (под-модель строки — `row.$.field`) и `form` (нода строки).
+ * - Value-операции (`compute`/`copyFrom`/`transformValue` на `row.$.*`) работают всегда.
+ * - Node-операции (`enableWhen`/`updateComponentProps`/`reset` через `form.*`) требуют, чтобы массив был
+ *   МАТЕРИАЛИЗОВАН в форме (узел `{ array, item }` в схеме) — тогда `form` строки = та же нода, что
+ *   рендерится, а её сигналы зарегистрированы (`enableWhen` резолвит ноду). Без материализации доступ
+ *   к `form.*` бросит понятную ошибку (см. {@link unmaterializedRowForm}).
+ *
+ * @example
+ * 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 — нужна материализация массива
+ * }));
+ */
+export declare function applyEach<TItem>(array: object, itemSchema: FormBehavior<TItem>): void;
+/**
+ * Взаимное исключение булева флага среди строк массива (single-selection — «единственный primary»).
+ * Когда флаг строки становится true, у остальных строк он сбрасывается в false. Не хрупок к push:
+ * новые строки с флагом false исключения не запускают.
+ *
+ * @example
+ * exclusiveFlag(model.$.contacts, (row) => row.$.primary);
+ */
+export declare function exclusiveFlag<TItem>(array: object, getFlag: (row: FormModel<TItem>) => Signal<boolean>): void;
+/**
+ * Агрегатная запись в строки массива. `derive(snapshot)` получает СНИМОК строк и возвращает список
+ * `{ index, patch }`, который применяется к строкам. Записи КОАЛЕСИРУЮТСЯ в один отложенный проход на
+ * финальном состоянии — поэтому массовые синхронные мутации (push в цикле) не вызывают каскад на
+ * промежуточных состояниях. `derive` должна сходиться (на фикспоинте возвращать те же значения).
+ *
+ * @example
+ * // последняя строка = 100 − Σ(остальные)
+ * aggregateInto(model.$.rows, (rows) => {
+ *   const n = rows.length; if (n === 0) return [];
+ *   const others = rows.slice(0, n - 1).reduce((s, r) => s + r.percent, 0);
+ *   return [{ index: n - 1, patch: { percent: 100 - others } }];
+ * });
+ */
+export declare function aggregateInto<TItem>(array: object, derive: (rows: TItem[]) => Array<{
+    index: number;
+    patch: Partial<TItem>;
+}>): void;
+/** Применить под-схему к одному или нескольким полям-группам (переиспользование). */
+export declare function apply<TField>(targets: object | object[], subSchema: FormBehavior<TField>): void;