@reformer/core 9.0.0-beta.2 → 9.1.0

package/dist/behaviors-node-BMOI2JJF.js

@@ -0,0 +1,26 @@
+import { effect as o } from "@preact/signals-core";
+import { d as a } from "./behaviors-value-lCpqicfa.js";
+const s = /* @__PURE__ */ new WeakMap();
+function l(e, n) {
+  s.set(e, n);
+}
+function f(e) {
+  return s.get(e);
+}
+function u(e, n, r) {
+  return o(() => {
+    const i = n(), t = f(e);
+    t && a(() => {
+      i ? t.enable() : (t.disable(), r?.resetOnDisable && t.reset());
+    });
+  });
+}
+function g(e, n, r) {
+  return u(e, () => !n(), r);
+}
+export {
+  g as d,
+  u as e,
+  f as g,
+  l as r
+};

package/dist/behaviors-value-lCpqicfa.js

@@ -0,0 +1,148 @@
+import { effect as f } from "@preact/signals-core";
+const a = /* @__PURE__ */ new WeakMap();
+function h(e) {
+  a.set(e, (a.get(e) ?? 0) + 1);
+}
+function y(e) {
+  const n = a.get(e);
+  n !== void 0 && (n <= 1 ? a.delete(e) : a.set(e, n - 1));
+}
+function E(e) {
+  return a.has(e);
+}
+const m = "runOutsideEffect";
+function v(e, n) {
+  process.env.NODE_ENV !== "production" && console.error(`[${n}]`, e);
+}
+function p(e) {
+  return typeof e == "object" && e !== null && typeof e.then == "function";
+}
+function d(e, n) {
+  try {
+    const t = e();
+    p(t) && t.then(void 0, (r) => v(r, n));
+  } catch (t) {
+    v(t, n);
+  }
+}
+function D(e) {
+  return (...n) => {
+    s(() => e(...n));
+  };
+}
+function s(e) {
+  let n = !1;
+  return queueMicrotask(() => {
+    n || d(e, m);
+  }), () => {
+    n = !0;
+  };
+}
+function w(e, n) {
+  return () => {
+    n(() => d(e, "safeDebouncedCallback"));
+  };
+}
+function b(e, n, t, r) {
+  return f(() => {
+    const u = e.map((c) => c.value);
+    if (r?.when && !r.when(...u)) return;
+    const o = t(...u);
+    n.peek() !== o && (n.value = o);
+  });
+}
+function F(e, n, t) {
+  return f(() => {
+    const r = e.value;
+    if (t?.when && !t.when()) return;
+    const u = t?.transform ? t.transform(r) : r;
+    n.peek() !== u && (n.value = u);
+  });
+}
+function x(e, n, t) {
+  let r = !0;
+  return f(() => {
+    const u = e.value;
+    r && (r = !1, !t?.immediate) || n(u);
+  });
+}
+function C(e, n) {
+  let t = !1;
+  return f(() => {
+    const r = e.value;
+    t || s(() => {
+      const u = n(r);
+      if (e.peek() !== u) {
+        t = !0;
+        try {
+          e.value = u;
+        } finally {
+          t = !1;
+        }
+      }
+    });
+  });
+}
+function O(e, n, t) {
+  const r = t?.resetValue ?? null;
+  return f(() => {
+    const u = n();
+    s(() => {
+      u && e.peek() !== r && (e.value = r);
+    });
+  });
+}
+function V(e, n, t) {
+  const r = t?.transform;
+  let u = !1;
+  const o = f(() => {
+    const i = e.value;
+    u || s(() => {
+      u = !0;
+      try {
+        const l = r ? r(i) : i;
+        n.peek() !== l && (n.value = l);
+      } finally {
+        u = !1;
+      }
+    });
+  }), c = f(() => {
+    const i = n.value;
+    u || s(() => {
+      u = !0;
+      try {
+        e.peek() !== i && (e.value = i);
+      } finally {
+        u = !1;
+      }
+    });
+  });
+  return () => {
+    o(), c();
+  };
+}
+function N(e, n) {
+  let t = !0;
+  return f(() => {
+    if (e.forEach((r) => r.value), t) {
+      t = !1;
+      return;
+    }
+    s(() => n());
+  });
+}
+export {
+  F as a,
+  N as b,
+  b as c,
+  s as d,
+  D as e,
+  w as f,
+  E as i,
+  h as m,
+  O as r,
+  V as s,
+  C as t,
+  y as u,
+  x as w
+};

package/dist/behaviors.d.ts

@@ -1,133 +1,2 @@
-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;
+export * from './form/behaviors'
+export {}

package/dist/behaviors.js

@@ -1,5 +1,6 @@
 import { effect as O } from "@preact/signals-core";
-import { r as $, m as k, u as x, c as S, w as F, e as A, t as C, a as D, s as M, b as G } from "./behaviors-Br4Im38V.js";
+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 P(e) {
   if (!p)
@@ -86,7 +87,7 @@ function j(e) {
     }
   };
 }
-function L(e, t, n) {
+function Q(e, t, n) {
   k(e), s(() => x(e));
   const o = j(e);
   m(() => {
@@ -97,7 +98,7 @@ function L(e, t, n) {
     });
   });
 }
-function Q(e, t, n, o) {
+function U(e, t, n, o) {
   k(t), s(() => x(t));
   const r = j(t);
   m(() => {
@@ -109,7 +110,7 @@ function Q(e, t, n, o) {
     });
   });
 }
-function U(e, t, n) {
+function X(e, t, n) {
   if (h(e) && h(t)) {
     s(S(e, t, n));
     return;
@@ -146,9 +147,9 @@ function R(e, t, n) {
 }
 function q(e, t, n) {
   for (const o of B(e))
-    h(o) ? s(A(o, t, n)) : z(o, t, n);
+    h(o) ? s(G(o, t, n)) : z(o, t, n);
 }
-function X(e, t, n) {
+function Y(e, t, n) {
   q(e, () => !t(), n);
 }
 function z(e, t, n) {
@@ -160,17 +161,17 @@ function z(e, t, n) {
     });
   });
 }
-function Y(e, t) {
-  s(C(e, t));
-}
-function Z(e, t, n) {
-  s(D(e, t, n));
+function Z(e, t) {
+  s(A(e, t));
 }
 function ee(e, t, n) {
-  s(M(e, t, n));
+  s(C(e, t, n));
+}
+function ne(e, t, n) {
+  s(D(e, t, n));
 }
-function ne(e, t) {
-  s(G(e, t));
+function te(e, t) {
+  s(M(e, t));
 }
 function g(e, t) {
   return t.split(".").reduce((n, o) => n?.[o], e);
@@ -224,7 +225,7 @@ function v(e) {
   }
   for (const n of Object.keys(e)) v(e[n]);
 }
-function te(e, t) {
+function oe(e, t) {
   const { model: n } = y(), o = e.__path;
   if (!o) return;
   const r = g(n, o);
@@ -244,7 +245,7 @@ function te(e, t) {
     })
   );
 }
-function oe(e, t) {
+function re(e, t) {
   const { model: n } = y(), o = e.__path;
   if (!o) return;
   const r = g(n, o);
@@ -268,7 +269,7 @@ function oe(e, t) {
     }));
   });
 }
-function re(e, t) {
+function ce(e, t) {
   const { form: n } = y();
   for (const o of B(e)) {
     const r = o, c = r.__path;
@@ -278,23 +279,23 @@ function re(e, t) {
   }
 }
 export {
-  oe as aggregateInto,
-  re as apply,
+  re as aggregateInto,
+  ce as apply,
   H as applyEach,
-  L as compute,
-  Q as computeFrom,
-  U as copyFrom,
+  Q as compute,
+  U as computeFrom,
+  X as copyFrom,
   _ as defer,
   T as defineFormBehavior,
-  X as disableWhen,
+  Y as disableWhen,
   m as effect,
   q as enableWhen,
-  te as exclusiveFlag,
+  oe as exclusiveFlag,
   y as getScope,
   R as onChange,
   s as onDispose,
-  Z as resetWhen,
-  ne as revalidateWhen,
-  ee as syncFields,
-  Y as transformValue
+  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;

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

@@ -1,7 +1,7 @@
-import { FormProxy, GroupNodeConfig, FormSchema } from '../types';
-import { FormSchemaNode } from '../types/schema-node';
-import { FormModel } from '../model/types';
-import { FormBehavior } from '../../behaviors';
+import { FormProxy, GroupNodeConfig, FormSchema } from './types/index';
+import { FormSchemaNode } from './types/schema-node';
+import { FormModel } from '../state/types';
+import { FormBehavior } from './behaviors';
 /**
  * Аргументы createForm под архитектуру M1: данные приходят из {@link FormModel},
  * конфиг полей (component/componentProps/validators) — из единой схемы.
@@ -52,6 +52,7 @@ export interface CreateFormFromModelArgs<T> {
  *   component: Section,
  *   children: [
  *     { value: model.$.email, component: Input, validators: [required] },
+ *     // вложенная группа: `model.$.profile.name` (≡ под-модель `model.profile.$.name` — тот же сигнал)
  *     { value: model.$.profile.name, component: Input },
  *   ],
  * };

package/dist/{core/utils → form}/error-handler.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from '../types';
+import { ValidationError } from './types/contracts';
 /**
  * Стратегия обработки ошибок
  *