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

package/dist/model/index.d.ts

@@ -13,7 +13,9 @@
  * Состав (реэкспорты — из тех же файлов, что использует зонтик `.`, поэтому `.` и `/model` — один
  * module-инстанс: общий `derived`-WeakMap, единая идентичность `Signal`):
  * - **модель** — `createModel` + типы `FormModel`/`ModelArray`/… + `PathAwareSignal`;
+ * - **шаблон элемента массива** — `arrayOf(blank)`: что кладёт `push()` без значения;
  * - **обход значений** — `eachLeafSignal` (листья) и `eachValueSignal` (листья и массивы целиком);
+ * - **ручка → фасад** — `modelOf(model.$.<группа | массив>)`: под-модель или фасад массива;
  * - **value-операции** (реактивные правила) — `computeFrom`/`copyFrom`/`watchField`/`transformValue`/
  *   `resetWhen`/`syncFields`/`revalidateWhen`;
  * - **producer-owned флаг** — `markDerived`/`isDerived`/`unmarkDerived`;
@@ -23,8 +25,11 @@
  * @module model
  */
 export { createModel, eachLeafSignal, eachValueSignal } from './create-model';
+export { arrayOf } from './model-nodes';
 export type { FormModel, ModelArray, ModelArraySignals, ModelGroupSignals, ModelObject, ModelValue, ModelSignals, ModelApi, PathAwareSignal, } from './types';
 export { isModelContainerSignal, isValueSignal } from './model-signals-proxy';
+export { modelOf } from './model-value-proxy';
+export type { ModelOf } from './model-value-proxy';
 export { computeFrom, copyFrom, watchField, transformValue, resetWhen, syncFields, revalidateWhen, } from './behaviors-value';
 export type { BehaviorCleanup } from './behaviors-value';
 export { markDerived, isDerived, unmarkDerived } from './derived-registry';

package/dist/model/model-nodes.d.ts

@@ -1,6 +1,50 @@
 import { Signal } from '@preact/signals-core';
 import { PathAwareSignal } from './types';
 export declare const isIndexKey: (key: string) => boolean;
+/** Фабрика нового элемента массива. */
+type Blank = () => unknown;
+/**
+ * Образец того же места модели внутри шаблона родительского массива. Ленивый: шаблон родителя
+ * ради него вызывается, только когда образец действительно понадобился.
+ */
+type Shape = () => unknown;
+/**
+ * Массив модели с шаблоном нового элемента.
+ *
+ * Шаблон — фабрика значения, которое получает `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) })`), а не в константе, которую клонируют.
+ *
+ * @typeParam U - Тип элемента массива.
+ * @param blank - Фабрика нового элемента. Вызывается на каждое добавление — значение не делится
+ *   между элементами.
+ * @param items - Начальные элементы. По умолчанию массив пуст.
+ * @returns Массив начальных значений с шаблоном.
+ *
+ * @example
+ * ```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: [] }); // значение целиком — как раньше
+ * ```
+ *
+ * @group Model
+ */
+export declare function arrayOf<U>(blank: () => U, items?: readonly U[]): U[];
 export type ModelNode = LeafNode | GroupNode | ArrayNode;
 declare class LeafNode {
     path: string;
@@ -22,7 +66,11 @@ export declare class GroupNode {
     path: string;
     readonly kind: "group";
     readonly children: Map<string, ModelNode>;
-    constructor(initial: Record<string, unknown>, path: string);
+    /**
+     * @param shape Образец той же группы из шаблона родительского массива: из него вложенные
+     *   массивы берут шаблоны, если значение пришло обычными данными (см. {@link ArrayNode}).
+     */
+    constructor(initial: Record<string, unknown>, path: string, shape?: Shape);
     rebase(path: string): void;
     /** Реактивное чтение поддерева (внутри effect/computed подписывает на все листья группы). */
     read(): Record<string, unknown>;
@@ -34,14 +82,27 @@ export declare class GroupNode {
 }
 export declare class ArrayNode {
     path: string;
+    private readonly shape?;
     readonly kind: "array";
     readonly items: Signal<ModelNode[]>;
     private initial;
-    constructor(initial: unknown[], path: string);
+    private blank;
+    private fallback;
+    private sample;
+    /** @param shape Образец того же массива из шаблона родителя (см. {@link GroupNode}). */
+    constructor(initial: unknown[], path: string, shape?: Shape | undefined);
+    /** Шаблон по старшинству: свой (`arrayOf`) → из шаблона родителя → из схемы. */
+    private template;
+    private readonly itemShape;
+    private build;
+    /** Значение нового элемента: переданное либо из шаблона. */
+    private fresh;
+    /** Шаблон из схемы (`initialValue` узла-массива) — запасной: шаблон модели главнее. */
+    provideBlank(blank: Blank): void;
     rebase(path: string): void;
     private reindex;
-    push(value: unknown): void;
-    insertAt(index: number, value: unknown): void;
+    push(value?: unknown): void;
+    insertAt(index: number, value?: unknown): void;
     removeAt(index: number): void;
     move(from: number, to: number): void;
     swap(a: number, b: number): void;
@@ -57,4 +118,6 @@ export declare class ArrayNode {
     captureInitial(): void;
     dirty(): boolean;
 }
+/** Значение `initialValue` узла-массива схемы как шаблон: фабрика — как есть, значение — копией. */
+export declare const blankFrom: (initialValue: unknown) => Blank;
 export {};

package/dist/model/model-signals-proxy.d.ts

@@ -1,6 +1,6 @@
 import { Signal } from '@preact/signals-core';
 import { PathAwareSignal } from './types';
-import { ModelNode, GroupNode } from './model-nodes';
+import { ModelNode, GroupNode, ArrayNode } from './model-nodes';
 /**
  * Узел дерева `$`: лист → сам {@link PathAwareSignal}, группа/массив → контейнерный узел —
  * {@link ReadonlySignal} агрегированного значения ПЛЮС доступ к детям по имени/индексу.
@@ -20,6 +20,13 @@ import { ModelNode, GroupNode } from './model-nodes';
  * полей, а потребители, перечисляющие модель, не видят служебных ключей.
  */
 export declare function signalsProxy(node: ModelNode): any;
+/**
+ * Узел модели за контейнерной ручкой дерева `$` (группа или массив). Для листа и для всего, что
+ * ручкой не является, — `undefined`.
+ *
+ * @internal
+ */
+export declare function containerNodeOf(handle: unknown): GroupNode | ArrayNode | undefined;
 /**
  * Узел дерева `model.$` — контейнер (группа/массив), а не лист?
  *

package/dist/model/model-value-proxy.d.ts

@@ -1,3 +1,79 @@
 import { GroupNode } from './model-nodes';
+import { FormModel, ModelArray } from './types';
 export declare const rootByFacade: WeakMap<object, GroupNode>;
 export declare function makeFormModel(group: GroupNode): any;
+/**
+ * Value-фасад для ручки {@link modelOf}: массив → {@link ModelArray}, объект → под-модель
+ * {@link FormModel}.
+ *
+ * @group Model
+ */
+export type ModelOf<V> = NonNullable<V> extends ReadonlyArray<infer U> ? ModelArray<U> : FormModel<NonNullable<V>>;
+/**
+ * Value-фасад по ручке дерева `model.$`: группа → под-модель {@link FormModel}, массив →
+ * {@link ModelArray}. Обратная операция к `model.$`: `modelOf(model.$.address) === model.address`.
+ *
+ * Ручка находит фасад по ИДЕНТИЧНОСТИ, а не по пути. Путь для этого не годится: он абсолютный
+ * (`items.0.phones`) и меняется при перестановке строк, а области поведения и формы строк
+ * вложенные — поиск по пути от под-модели строки ничего не находит.
+ *
+ * Лист ручкой контейнера не является — функция бросает. В частности, группа или массив,
+ * созданные из начального `null`, в модели — лист: вид узла фиксируется при создании.
+ *
+ * @typeParam V - Значение, которое хранит ручка (выводится из `peek()`).
+ * @param handle - Узел-группа или узел-массив дерева `model.$`.
+ * @returns Под-модель группы либо фасад массива.
+ * @throws TypeError если `handle` — лист или не ручка модели.
+ *
+ * @example
+ * ```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; // строка массива — тоже группа
+ * ```
+ *
+ * @group Model
+ */
+export declare function modelOf<V extends object | null | undefined>(handle: {
+    peek(): V;
+}): ModelOf<V>;
+/**
+ * Ручка `$` по value-фасаду: под-модель → её `model.$`, фасад массива → узел-массив дерева `$`.
+ * Для всего остального — `undefined`.
+ *
+ * @internal
+ */
+export declare function signalsOf(facade: unknown): object | undefined;
+/**
+ * Ручка массива по привязке: сама ручка `model.$.<массив>` либо value-фасад `model.<массив>`.
+ * Для всего остального — `undefined`.
+ *
+ * @internal
+ */
+export declare function arrayHandleOf(binding: unknown): object | undefined;
+/**
+ * Ручка группы по привязке: `model.$.<группа>` либо под-модель `model.<группа>`. Для всего
+ * остального — `undefined`.
+ *
+ * @internal
+ */
+export declare function groupHandleOf(binding: unknown): object | undefined;
+/**
+ * Запасной шаблон нового элемента массива — `initialValue` узла-массива схемы. Действует, только
+ * если модель своего шаблона не объявила (`arrayOf`): так живут формы, чья модель строится из
+ * данных без кода.
+ *
+ * @internal
+ */
+export declare function provideArrayBlank(handle: unknown, initialValue: unknown): void;
+/**
+ * Value-фасад модели (под-модель или фасад массива), а не обычный объект?
+ *
+ * Обходчикам чужих деревьев (схема формы) в фасад спускаться нельзя: чтение его ключей — это
+ * реактивное чтение значений модели.
+ *
+ * @internal
+ */
+export declare function isModelFacade(value: unknown): boolean;

package/dist/model/types.d.ts

@@ -57,10 +57,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;
     /** Переместить элемент. */

package/dist/model-value-proxy-caTmAiUd.js

@@ -0,0 +1,419 @@
+import { batch as A, signal as x, Signal as I, computed as F } from "@preact/signals-core";
+const u = /* @__PURE__ */ new WeakMap();
+function z(e) {
+  u.set(e, (u.get(e) ?? 0) + 1);
+}
+function Q(e) {
+  const t = u.get(e);
+  t !== void 0 && (t <= 1 ? u.delete(e) : u.set(e, t - 1));
+}
+function T(e) {
+  return u.has(e);
+}
+const d = (e) => !(e === null || typeof e != "object" || Array.isArray(e) || e instanceof Date || typeof Blob < "u" && e instanceof Blob || typeof File < "u" && e instanceof File), h = (e, t) => e === "" ? String(t) : `${e}.${t}`, v = (e) => /^\d+$/.test(e), c = (e) => {
+  if (Array.isArray(e)) return e.map(c);
+  if (d(e)) {
+    const t = {};
+    for (const r of Object.keys(e)) t[r] = c(e[r]);
+    return t;
+  }
+  return e;
+}, g = (e, t) => {
+  if (e === t) return !0;
+  if (Array.isArray(e) && Array.isArray(t))
+    return e.length !== t.length ? !1 : e.every((r, i) => g(r, t[i]));
+  if (d(e) && d(t)) {
+    const r = Object.keys(e), i = Object.keys(t);
+    return r.length !== i.length ? !1 : r.every((n) => g(e[n], t[n]));
+  }
+  return !1;
+}, M = Symbol.for("@reformer/core:arrayBlank"), _ = (e) => Array.isArray(e) ? e[M] : void 0, W = (e, t) => d(e) ? e[t] : void 0;
+function U(e, t = []) {
+  const r = [...t];
+  return Object.defineProperty(r, M, { value: e }), r;
+}
+class C {
+  constructor(t, r) {
+    this.path = r;
+    const i = x(t);
+    i.__path = r, this.signal = i, this.initial = c(t);
+  }
+  kind = "leaf";
+  signal;
+  initial;
+  rebase(t) {
+    this.path = t, this.signal.__path = t;
+  }
+  /** Реактивное чтение (внутри effect/computed создаёт зависимость). */
+  read() {
+    return this.signal.value;
+  }
+  /** Нереактивный снимок. */
+  peek() {
+    return this.signal.peek();
+  }
+  set(t) {
+    this.signal.value = t;
+  }
+  resetToInitial() {
+    this.signal.value = c(this.initial);
+  }
+  captureInitial() {
+    this.initial = c(this.signal.peek());
+  }
+  dirty() {
+    return !g(this.signal.peek(), this.initial);
+  }
+}
+class K {
+  /**
+   * @param shape Образец той же группы из шаблона родительского массива: из него вложенные
+   *   массивы берут шаблоны, если значение пришло обычными данными (см. {@link ArrayNode}).
+   */
+  constructor(t, r, i) {
+    this.path = r;
+    for (const n of Object.keys(t)) {
+      const s = i && (() => W(i(), n));
+      this.children.set(n, E(t[n], h(r, n), s));
+    }
+  }
+  kind = "group";
+  children = /* @__PURE__ */ new Map();
+  rebase(t) {
+    this.path = t;
+    for (const [r, i] of this.children) i.rebase(h(t, r));
+  }
+  /** Реактивное чтение поддерева (внутри effect/computed подписывает на все листья группы). */
+  read() {
+    const t = {};
+    for (const [r, i] of this.children) t[r] = i.read();
+    return t;
+  }
+  peek() {
+    const t = {};
+    for (const [r, i] of this.children) t[r] = i.peek();
+    return t;
+  }
+  set(t) {
+    if (t == null || typeof t != "object") return;
+    const r = t;
+    A(() => {
+      for (const [i, n] of this.children)
+        i in r && (n.kind === "leaf" && T(n.signal) || n.set(r[i]));
+    });
+  }
+  resetToInitial() {
+    A(() => {
+      for (const t of this.children.values()) t.resetToInitial();
+    });
+  }
+  captureInitial() {
+    for (const t of this.children.values()) t.captureInitial();
+  }
+  dirty() {
+    for (const t of this.children.values()) if (t.dirty()) return !0;
+    return !1;
+  }
+}
+class G {
+  /** @param shape Образец того же массива из шаблона родителя (см. {@link GroupNode}). */
+  constructor(t, r, i) {
+    this.path = r, this.shape = i, this.blank = _(t), this.items = x(t.map((n, s) => this.build(n, s))), this.initial = c(t);
+  }
+  kind = "array";
+  items;
+  initial;
+  // Шаблон нового элемента (`arrayOf`). Принадлежит узлу, а не значению: `set`/`reset` заменяют
+  // элементы, узел остаётся — и шаблон с ним.
+  blank;
+  // Запасной шаблон — `initialValue` узла-массива схемы.
+  fallback;
+  // Образец элемента — один вызов шаблона. Нужен только ради вложенных шаблонов: элемент из
+  // обычных данных (`set` с сервера, `push(значение)`) метку `arrayOf` на своих массивах не несёт.
+  sample;
+  /** Шаблон по старшинству: свой (`arrayOf`) → из шаблона родителя → из схемы. */
+  template() {
+    return this.blank ??= _(this.shape?.()), this.blank ?? this.fallback;
+  }
+  // Образец читается лениво — лишний вызов шаблона случается, только когда вложенному массиву
+  // элемента из обычных данных понадобился свой шаблон.
+  itemShape = () => {
+    if (!this.sample) {
+      const t = this.template();
+      if (!t) return;
+      this.sample = { value: t() };
+    }
+    return this.sample.value;
+  };
+  build(t, r) {
+    return E(t, h(this.path, r), this.itemShape);
+  }
+  /** Значение нового элемента: переданное либо из шаблона. */
+  fresh(t) {
+    if (t !== void 0) return t;
+    const r = this.template();
+    if (!r)
+      throw new Error(
+        `[@reformer/core] ${this.path || "массив"}: добавление элемента без значения, а шаблона у массива нет. Объявите его в модели — \`arrayOf(() => ({ … }))\` — либо передайте значение: \`push(значение)\`.`
+      );
+    return r();
+  }
+  /** Шаблон из схемы (`initialValue` узла-массива) — запасной: шаблон модели главнее. */
+  provideBlank(t) {
+    this.fallback ??= t;
+  }
+  rebase(t) {
+    this.path = t, this.items.peek().forEach((r, i) => r.rebase(h(t, i)));
+  }
+  reindex() {
+    this.items.peek().forEach((t, r) => t.rebase(h(this.path, r)));
+  }
+  push(t) {
+    const r = this.items.peek();
+    this.items.value = [...r, this.build(this.fresh(t), r.length)];
+  }
+  insertAt(t, r) {
+    const i = [...this.items.peek()];
+    i.splice(t, 0, this.build(this.fresh(r), t)), this.items.value = i, this.reindex();
+  }
+  removeAt(t) {
+    const r = [...this.items.peek()];
+    r.splice(t, 1), this.items.value = r, this.reindex();
+  }
+  move(t, r) {
+    const i = [...this.items.peek()], [n] = i.splice(t, 1);
+    n && i.splice(r, 0, n), this.items.value = i, this.reindex();
+  }
+  swap(t, r) {
+    const i = [...this.items.peek()];
+    t < 0 || r < 0 || t >= i.length || r >= i.length || t === r || ([i[t], i[r]] = [i[r], i[t]], this.items.value = i, this.reindex());
+  }
+  clear() {
+    this.items.value = [];
+  }
+  /**
+   * Реактивное чтение массива. Читаем `items.value` (а не `.peek()`) — внутри effect/computed это
+   * подписка на СОСТАВ массива, поэтому push/removeAt/move ретригерят наравне с правкой элемента.
+   */
+  read() {
+    return this.items.value.map((t) => t.read());
+  }
+  peek() {
+    return this.items.peek().map((t) => t.peek());
+  }
+  set(t) {
+    const r = Array.isArray(t) ? t : [];
+    this.items.value = r.map((i, n) => this.build(i, n));
+  }
+  resetToInitial() {
+    this.set(c(this.initial));
+  }
+  captureInitial() {
+    this.initial = c(this.peek());
+  }
+  dirty() {
+    return !g(this.peek(), this.initial);
+  }
+}
+function E(e, t, r) {
+  return Array.isArray(e) ? new G(e, t, r) : d(e) ? new K(e, t, r) : new C(e, t);
+}
+const H = (e) => typeof e == "function" ? e : () => c(e), O = /* @__PURE__ */ new WeakMap(), N = /* @__PURE__ */ new WeakMap();
+function L(e) {
+  const t = F(() => e.read());
+  return {
+    get value() {
+      return t.value;
+    },
+    peek: () => t.peek(),
+    subscribe: (r) => t.subscribe(r),
+    valueOf: () => t.value,
+    toString: () => String(t.value),
+    toJSON: () => t.value,
+    brand: t.brand
+  };
+}
+function p(e) {
+  if (e.kind === "leaf") return e.signal;
+  const t = O.get(e);
+  if (t) return t;
+  const r = L(e), i = e.kind === "group", n = (l) => i ? e.children.get(l) : v(l) ? e.items.value[Number(l)] : void 0, s = i ? {} : {
+    get length() {
+      return e.items.value.length;
+    }
+  }, o = new Proxy(s, {
+    get: (l, a, k) => {
+      if (a === "__path") return e.path;
+      if (a === "__kind") return e.kind;
+      if (typeof a != "string") return Reflect.get(r, a, r);
+      const m = n(a);
+      return m ? p(m) : !i && Reflect.has(l, a) ? Reflect.get(l, a, k) : Reflect.get(r, a, r);
+    },
+    set: (l, a, k) => {
+      if (!i && a === "value")
+        return e.set(k), !0;
+      const m = e.path === "" ? "model.$" : `model.$.${e.path}`;
+      throw new TypeError(
+        `[@reformer/core] ${m}: запись в «${String(a)}» ` + (i ? "узла-группы невозможна — группа читается целиком, а пишется по полям (model.$.<поле>.value) либо через model.patch(...)" : "узла-массива невозможна — массив заменяется целиком через .value, а элемент правится своим сигналом (model.$.<массив>[i].value)")
+      );
+    },
+    has: (l, a) => typeof a == "string" && (n(a) !== void 0 || !i && Reflect.has(l, a)),
+    ownKeys: () => i ? [...e.children.keys()] : Reflect.ownKeys(s),
+    getOwnPropertyDescriptor: (l, a) => typeof a == "string" && n(a) ? { enumerable: !0, configurable: !0 } : i ? void 0 : Reflect.getOwnPropertyDescriptor(l, a)
+  });
+  return O.set(e, o), N.set(o, e), o;
+}
+function P(e) {
+  if (!(e == null || typeof e != "object"))
+    return N.get(e);
+}
+function V(e) {
+  if (e == null || typeof e != "object") return !1;
+  const t = e.__kind;
+  return t === "group" || t === "array";
+}
+function y(e) {
+  return e == null || typeof e != "object" ? !1 : e.__kind === "array";
+}
+function X(e) {
+  return e instanceof I || y(e);
+}
+function q(e, t) {
+  if (!t) return;
+  let r = e;
+  for (const i of t.split(".")) {
+    if (!r) return;
+    if (r.kind === "group") r = r.children.get(i);
+    else if (r.kind === "array") r = r.items.peek()[Number(i)];
+    else return;
+  }
+  if (r)
+    return r.kind === "leaf" ? r.signal : r.kind === "array" ? p(r) : void 0;
+}
+function f(e) {
+  if (e)
+    return e.kind === "group" ? B(e) : e.kind === "array" ? R(e) : e.read();
+}
+const S = /* @__PURE__ */ new WeakMap(), b = /* @__PURE__ */ new WeakMap();
+function R(e) {
+  const t = S.get(e);
+  if (t) return t;
+  const r = {
+    get length() {
+      return e.items.value.length;
+    },
+    push: (n) => e.push(n),
+    insertAt: (n, s) => e.insertAt(n, s),
+    removeAt: (n) => e.removeAt(n),
+    move: (n, s) => e.move(n, s),
+    swap: (n, s) => e.swap(n, s),
+    clear: () => e.clear(),
+    at: (n) => f(e.items.value[n]),
+    map: (n) => e.items.value.map((s, o) => n(f(s), o)),
+    forEach: (n) => e.items.value.forEach((s, o) => n(f(s), o)),
+    toArray: () => e.peek(),
+    [Symbol.iterator]: function* () {
+      const n = e.items.value;
+      for (let s = 0; s < n.length; s++) yield f(n[s]);
+    }
+  }, i = new Proxy(r, {
+    get: (n, s, o) => s === "__path" ? e.path : typeof s == "string" && v(s) ? f(e.items.value[Number(s)]) : Reflect.get(n, s, o),
+    has: (n, s) => typeof s == "string" && v(s) ? Number(s) < e.items.value.length : Reflect.has(n, s)
+  });
+  return S.set(e, i), b.set(i, e), i;
+}
+const $ = /* @__PURE__ */ new Set([
+  "$",
+  "get",
+  "set",
+  "patch",
+  "isDirty",
+  "reset",
+  "captureInitial",
+  "signalAt"
+]), j = /* @__PURE__ */ new WeakMap(), w = /* @__PURE__ */ new WeakMap();
+function B(e) {
+  const t = j.get(e);
+  if (t) return t;
+  const r = {
+    $: p(e),
+    get: () => e.peek(),
+    set: (n) => e.set(n),
+    patch: (n) => e.set(n),
+    isDirty: () => e.dirty(),
+    reset: () => e.resetToInitial(),
+    captureInitial: () => e.captureInitial(),
+    signalAt: (n) => q(e, n)
+  }, i = new Proxy(
+    {},
+    {
+      get: (n, s) => {
+        if (s === "__path") return e.path;
+        if (typeof s != "string") return;
+        const o = e.children.get(s);
+        if (o) return f(o);
+        if ($.has(s)) return r[s];
+      },
+      set: (n, s, o) => {
+        if (typeof s != "string") return !1;
+        const l = e.children.get(s);
+        return l ? (l.set(o), !0) : !1;
+      },
+      has: (n, s) => typeof s == "string" && (e.children.has(s) || $.has(s)),
+      ownKeys: () => [...e.children.keys()],
+      getOwnPropertyDescriptor: (n, s) => typeof s == "string" && e.children.has(s) ? { enumerable: !0, configurable: !0 } : void 0
+    }
+  );
+  return j.set(e, i), w.set(i, e), i;
+}
+function Y(e) {
+  const t = P(e);
+  if (!t) {
+    const r = e?.__path, i = typeof r == "string" && r !== "" ? ` «${r}»` : "";
+    throw new TypeError(
+      e instanceof I ? `[@reformer/core] modelOf: ручка${i} — лист, у него нет под-модели. Группа или массив, созданные из начального null, в модели тоже лист: задайте начальное значение объектом или массивом.` : "[@reformer/core] modelOf: ожидалась ручка группы или массива из дерева model.$ (например, model.$.address или model.$.items)."
+    );
+  }
+  return t.kind === "group" ? B(t) : R(t);
+}
+function D(e) {
+  if (e == null || typeof e != "object") return;
+  const t = b.get(e);
+  if (t) return p(t);
+  const r = w.get(e);
+  return r ? p(r) : void 0;
+}
+function Z(e) {
+  if (y(e)) return e;
+  const t = D(e);
+  return y(t) ? t : void 0;
+}
+function ee(e) {
+  const t = V(e) ? e : D(e);
+  return t !== void 0 && !y(t) ? t : void 0;
+}
+function te(e, t) {
+  const r = P(e);
+  r?.kind === "array" && r.provideBlank(H(t));
+}
+function re(e) {
+  return e == null || typeof e != "object" ? !1 : b.has(e) || w.has(e);
+}
+export {
+  K as G,
+  U as a,
+  X as b,
+  z as c,
+  T as d,
+  B as e,
+  re as f,
+  ee as g,
+  Z as h,
+  V as i,
+  y as j,
+  Y as m,
+  te as p,
+  w as r,
+  p as s,
+  Q as u
+};