@reformer/core 11.0.0-beta.1 → 11.0.0-beta.10

package/dist/form/validation/validators/multiple-of.d.ts

@@ -1,24 +0,0 @@
-import { Validator, ValidateOptions } from '../../types/validation-schema';
-/**
- * Фабрика валидатора, проверяющего что число кратно заданному.
- *
- * Пустые значения и не-числа пропускаются (используйте {@link required} и {@link isNumber}).
- *
- * @param divisor - Делитель: значение должно быть кратно ему
- * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
- *   попадает `multipleOf` (делитель).
- * @returns Чистый валидатор {@link Validator} для числового поля
- *
- * @example Проверка кратности
- * ```typescript
- * import { multipleOf } from '@reformer/core/validators';
- *
- * // Внутри FieldConfig схемы формы:
- * rating: {
- *   value: model.$.rating,
- *   component: Input,
- *   validators: [multipleOf(0.5, { message: 'Только шаг 0.5' })],
- * },
- * ```
- */
-export declare function multipleOf<TForm = unknown, TField extends number | null | undefined = number>(divisor: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/non-negative.d.ts

@@ -1,22 +0,0 @@
-import { Validator, ValidateOptions } from '../../types/validation-schema';
-/**
- * Фабрика валидатора, проверяющего что число неотрицательное (`≥ 0`).
- *
- * Пустые значения и не-числа пропускаются (используйте {@link required} и {@link isNumber}).
- *
- * @param options - Опции валидатора ({@link ValidateOptions}): `message`, `params`
- * @returns Чистый валидатор {@link Validator} для числового поля
- *
- * @example Проверка неотрицательности
- * ```typescript
- * import { nonNegative } from '@reformer/core/validators';
- *
- * // Внутри FieldConfig схемы формы:
- * balance: {
- *   value: model.$.balance,
- *   component: Input,
- *   validators: [nonNegative({ message: 'Баланс не может быть отрицательным' })],
- * },
- * ```
- */
-export declare function nonNegative<TForm = unknown, TField extends number | null | undefined = number>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/non-zero.d.ts

@@ -1,22 +0,0 @@
-import { Validator, ValidateOptions } from '../../types/validation-schema';
-/**
- * Фабрика валидатора, проверяющего что число не равно нулю.
- *
- * Пустые значения и не-числа пропускаются (используйте {@link required} и {@link isNumber}).
- *
- * @param options - Опции валидатора ({@link ValidateOptions}): `message`, `params`
- * @returns Чистый валидатор {@link Validator} для числового поля
- *
- * @example Проверка «не ноль»
- * ```typescript
- * import { nonZero } from '@reformer/core/validators';
- *
- * // Внутри FieldConfig схемы формы:
- * divisor: {
- *   value: model.$.divisor,
- *   component: Input,
- *   validators: [nonZero({ message: 'Не может быть нулём' })],
- * },
- * ```
- */
-export declare function nonZero<TForm = unknown, TField extends number | null | undefined = number>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/past-date.d.ts

@@ -1,23 +0,0 @@
-import { Validator, ValidateOptions } from '../../types/validation-schema';
-/**
- * Фабрика валидатора, проверяющего что дата не в будущем.
- *
- * Дата не должна быть позже сегодняшнего дня (сравнение по нормализованным датам).
- * Пустые и невалидные даты пропускаются (используйте {@link required} и {@link isDate}).
- *
- * @param options - Опции валидатора ({@link ValidateOptions}): `message`, `params`
- * @returns Чистый валидатор {@link Validator} для поля даты (`string | Date`)
- *
- * @example Дата не в будущем
- * ```typescript
- * import { required, pastDate } from '@reformer/core/validators';
- *
- * // Внутри FieldConfig схемы формы:
- * birthDate: {
- *   value: model.$.birthDate,
- *   component: DatePicker,
- *   validators: [required(), pastDate({ message: 'Дата рождения не может быть в будущем' })],
- * },
- * ```
- */
-export declare function pastDate<TForm = unknown, TField extends string | Date | null | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/pattern.d.ts

@@ -1,33 +0,0 @@
-import { Validator, ValidateOptions } from '../../types/validation-schema';
-/**
- * Фабрика валидатора регулярного выражения.
- *
- * Пустые значения (`''`/`null`/`undefined`) пропускаются (используйте {@link required}
- * для обязательности).
- *
- * @param regex - Регулярное выражение для проверки значения
- * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
- *   попадает `pattern` (строка-источник regex).
- * @returns Чистый валидатор {@link Validator} для строкового поля
- *
- * @example Проверка по регулярному выражению
- * ```typescript
- * import { required, pattern } from '@reformer/core/validators';
- *
- * // Внутри FieldConfig схемы формы:
- * name: {
- *   value: model.$.name,
- *   component: Input,
- *   validators: [pattern(/^[a-zA-Zа-яА-Я]+$/, { message: 'Только буквы' })],
- * },
- * phone: {
- *   value: model.$.phone,
- *   component: InputMask,
- *   validators: [
- *     required(),
- *     pattern(/^\+7 \(\d{3}\) \d{3}-\d{2}-\d{2}$/, { message: 'Формат +7 (999) 123-45-67' }),
- *   ],
- * },
- * ```
- */
-export declare function pattern<TForm = unknown, TField extends string | null | undefined = string>(regex: RegExp, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/required.d.ts

@@ -1,32 +0,0 @@
-import { Validator, ValidateOptions } from '../../types/validation-schema';
-/**
- * Фабрика валидатора обязательного поля.
- *
- * Возвращает чистую функцию-валидатор `(value, control, root)`. Передаётся в `validate()`.
- *
- * Пустыми считаются: `null`, `undefined`, `''` (пустая строка), `[]` (пустой массив —
- * обязательный multi-select / FormArray без выбранных элементов).
- * Для boolean полей требуется значение `true`.
- *
- * @param options - Опции валидатора ({@link ValidateOptions}): `message`, `params`
- * @returns Чистый валидатор {@link Validator} для поля схемы
- *
- * @example Обязательные поля в схеме формы
- * ```typescript
- * import { required } from '@reformer/core/validators';
- *
- * // Внутри FieldConfig схемы формы:
- * email: { value: model.$.email, component: Input, validators: [required()] },
- * phone: {
- *   value: model.$.phone,
- *   component: Input,
- *   validators: [required({ message: 'Укажите номер телефона' })],
- * },
- * agreeToTerms: {
- *   value: model.$.agreeToTerms,
- *   component: Checkbox,
- *   validators: [required({ message: 'Необходимо принять условия' })],
- * },
- * ```
- */
-export declare function required<TForm = unknown, TField = unknown>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/url.d.ts

@@ -1,43 +0,0 @@
-import { Validator, ValidateOptions } from '../../types/validation-schema';
-/**
- * Опции валидатора {@link url}. Расширяют {@link ValidateOptions} (`message`, `params`)
- * настройками проверки протокола.
- */
-export interface UrlValidatorOptions extends ValidateOptions {
-    /** Требовать наличие протокола (`http://` или `https://`). По умолчанию `false`. */
-    requireProtocol?: boolean;
-    /**
-     * Список разрешённых протоколов (без `://`), например `['https']`. Если задан,
-     * значение с иным протоколом даёт ошибку с кодом `url_protocol`.
-     */
-    allowedProtocols?: string[];
-}
-/**
- * Фабрика валидатора URL.
- *
- * Пустые значения (`''`/`null`/`undefined`) пропускаются (используйте {@link required}
- * для обязательности). При `requireProtocol` протокол обязателен; `allowedProtocols`
- * дополнительно ограничивает набор допустимых протоколов.
- *
- * @param options - Опции валидатора {@link UrlValidatorOptions}
- * @returns Чистый валидатор {@link Validator} для строкового поля
- *
- * @example Проверка URL
- * ```typescript
- * import { required, url } from '@reformer/core/validators';
- *
- * // Внутри FieldConfig схемы формы:
- * website: {
- *   value: model.$.website,
- *   component: Input,
- *   validators: [required(), url({ message: 'Введите корректный URL' })],
- * },
- * // Требовать протокол и ограничить схему только https:
- * homepage: {
- *   value: model.$.homepage,
- *   component: Input,
- *   validators: [url({ requireProtocol: true, allowedProtocols: ['https'] })],
- * },
- * ```
- */
-export declare function url<TForm = unknown, TField extends string | null | undefined = string>(options?: UrlValidatorOptions): Validator<TForm, TField>;

package/dist/form/validation-schema.d.ts

@@ -1,106 +0,0 @@
-import { FormModel, ModelArray, PathAwareSignal, ValidationError } from '../index';
-/**
- * Синхронное правило поля типа `TField`. Проверяется ТОЛЬКО значение (`value`).
- *
- * Позиционные `scope`/`root` помечены `never` намеренно: так встроенные value-only фабрики
- * (`required()`/`min()`/… — они `(value, model, root) => …`) и inline-правила `(value) => …`
- * ОБА присваиваются в `Rule<TField>[]` без `any`, при этом сохраняется проверка типа поля
- * (`validate(model.$.age, [email()])` подсветится — `email` ждёт `string`, поле `number`).
- * На вызове раннер приводит правило к callable и передаёт `(value, model, model)`.
- */
-export type Rule<TField> = (value: TField, scope: never, root: never) => ValidationError | null;
-/**
- * Асинхронное правило поля. Получает `AbortSignal` для отмены устаревших ответов (быстрый повторный
- * прогон той же схемы отменяет предыдущий). Сетевой сбой не должен блокировать — ловите и возвращайте `null`.
- */
-export type AsyncRule<TField> = (value: TField, ctx: {
-    signal: AbortSignal;
-}) => Promise<ValidationError | null>;
-/** Схема валидации — обычная функция над (под)моделью. First-class значение (можно `apply`/тестировать/переиспользовать). */
-export type ValidationSchema<T> = (ctx: {
-    model: FormModel<T>;
-}) => void;
-/**
- * Синхронные правила поля.
- *
- * @example
- * ```ts
- * validate(model.$.loanAmount, [required({ message: 'Сумма' }), min(50000)]);
- * ```
- */
-export declare function validate<TField>(sig: PathAwareSignal<TField>, rules: Rule<TField>[]): void;
-/**
- * Асинхронные правила поля (зеркалит движковое разделение `validators` / `asyncValidators`).
- * Раннер дожидается их и прокидывает `AbortSignal` для отмены устаревших ответов.
- *
- * @example
- * ```ts
- * validateAsync(model.$.username, [async (v, { signal }) => {
- *   const r = await fetch(`/api/free?u=${v}`, { signal });
- *   return (await r.json()).free ? null : { code: 'taken', message: 'Занято' };
- * }]);
- * ```
- */
-export declare function validateAsync<TField>(sig: PathAwareSignal<TField>, rules: AsyncRule<TField>[]): void;
-/**
- * Условная валидация: правила внутри `cb` активны, только пока `cond()` истинно; иначе их поля
- * ГАСЯТСЯ (пустой bucket → `setErrors([])`). Не трогает включение/сброс поля — это дело поведения (`enableWhen`).
- */
-export declare function validateWhen(cond: () => boolean, cb: () => void): void;
-/**
- * Cross-field правило: `fn` получает СНАПШОТ модели текущего scope (`model.get()`) и вешает ошибку на `sig`.
- * Для элементов массива / под-моделей захватывайте нужный снапшот в замыкание (`const item = im.get()`),
- * т.к. `fn` всегда получает модель ТЕКУЩЕГО scope (корень прогона), а не под-модель.
- */
-export declare function cross<TSnapshot>(sig: PathAwareSignal<unknown>, fn: (form: TSnapshot) => ValidationError | null): void;
-/**
- * Применить под-правила к КАЖДОМУ элементу текущего массива модели.
- * `U extends object` — элементы должны быть под-моделями (объектами); для массива примитивов валидируйте лист напрямую.
- */
-export declare function each<U extends object>(arr: ModelArray<U>, itemFn: (item: FormModel<U>) => void): void;
-/** Композиция под-схем в текущую (над той же моделью scope). Заменяет пошаговую группировку. */
-export declare function apply<T>(...schemas: ValidationSchema<T>[]): void;
-/**
- * Тонкая identity-обёртка для типизации/discoverability (как `defineFormBehavior`). Возвращает схему как есть.
- *
- * @example
- * ```ts
- * export const step1 = defineValidationSchema<LoanForm>(({ model }) => {
- *   validate(model.$.loanAmount, [required(), min(50000)]);
- * });
- * ```
- */
-export declare function defineValidationSchema<T>(schema: ValidationSchema<T>): ValidationSchema<T>;
-/**
- * Провалидировать модель ЛЮБОЙ схемой (шаг или вся форма). Открывает ambient-окно на время
- * синхронного прогона `schema`, дожидается async-правил, разносит ошибки по нодам формы и гасит
- * поля, ставшие валидными. Возвращает `true`, если нет блокирующих ошибок (`severity:'warning'` не блокирует).
- *
- * Гашение — на пару (model, schema): `validateModel(model, step2)` и `validateModel(model, form)` не мешают
- * друг другу. Устаревший прогон (быстрый повторный вызов той же (model, schema)) отменяется через `AbortSignal`
- * и возвращает `false` (**fail-closed** — отменённому результату нельзя доверять для submit).
- *
- * ⚠️ `schema` должна быть СТАБИЛЬНОЙ ссылкой: отмена устаревших прогонов ключится по идентичности `schema`.
- * Инлайн-стрелка (`validateModel(model, ({ model }) => …)`) каждый раз создаёт НОВЫЙ прогон без дедупликации —
- * держите схемы в `const` / `defineValidationSchema`.
- *
- * `options.touch` (§6): по завершении помечает `touched` ИМЕННО поля, которые схема проверяла
- * (не всё поддерево). Ошибки становятся видимыми (`shouldShowError = invalid && (touched||dirty)`)
- * без ручного `form.markAsTouched()`; при пошаговой валидации следующий шаг не показывается
- * «тронутым» до ввода. Валидные проверенные поля тоже метятся — это безвредно (ошибка не покажется).
- *
- * @param model - Модель данных формы.
- * @param schema - Схема валидации (стабильная ссылка).
- * @param options - `{ touch }` — пометить провалидированные поля `touched` для показа ошибок.
- *
- * @example
- * ```ts
- * const ok = await validateModel(model, step2Validation);              // один шаг
- * const all = await validateModel(model, formValidation);              // вся форма
- * const stepOk = await validateModel(model, step2Validation, { touch: true }); // + показать ошибки шага
- * ```
- */
-export declare function validateModel<T>(model: FormModel<T>, schema: ValidationSchema<T>, options?: {
-    touch?: boolean;
-}): Promise<boolean>;
-export * from './validation-strategy';

package/dist/form/validation-strategy.d.ts

@@ -1,55 +0,0 @@
-import { ReadonlySignal } from '@preact/signals-core';
-import { FormModel } from '../index';
-import { ValidationSchema } from './validation-schema';
-/**
- * Когда запускается schema-валидация:
- * - `submit` (по умолчанию) — только явным вызовом `validate()` (на отправке);
- * - `blur` — при потере фокуса поля (смена `touched` любого листа);
- * - `change` — на каждый ввод (с опц. `debounce`);
- * - `afterFirstSubmit` — тихо до первого `validate()`, затем live (см. `liveAfterSubmit`).
- */
-export type ValidationStrategyKind = 'submit' | 'blur' | 'change' | 'afterFirstSubmit';
-export interface ValidationStrategyOptions {
-    /** Стратегия запуска. Default `'submit'`. */
-    strategy?: ValidationStrategyKind;
-    /** Debounce (мс) для live-фаз (`change` и live-часть `afterFirstSubmit`). Default `0`. */
-    debounce?: number;
-    /** Режим live-фазы для `afterFirstSubmit`. Default `'change'`. */
-    liveAfterSubmit?: 'change' | 'blur';
-}
-export interface FormValidationController {
-    /**
-     * Полный прогон схемы с раскрытием ошибок (`touch: true`) — для submit. Также переводит
-     * `afterFirstSubmit` в live-фазу. Возвращает `false`, если есть блокирующие ошибки.
-     */
-    validate(): Promise<boolean>;
-    /** Армировать реактивные подписки стратегии. Идемпотентно. Возвращает `dispose`. НЕ звать при SSR. */
-    start(): () => void;
-    /** Снять подписки/таймеры. Идемпотентно. */
-    dispose(): void;
-    /** Идёт ли прогон (submit или live) — снапшот. */
-    readonly isValidating: boolean;
-    /** Реактивный сигнал состояния прогона (для тонкой подписки в UI). */
-    readonly validating: ReadonlySignal<boolean>;
-}
-/**
- * Собрать контроллер валидации формы с выбранной стратегией запуска. Переиспользует
- * {@link validateModel} как единственный движок прогона.
- *
- * Фабрика ЧИСТАЯ до `start()` (никаких подписок) — безопасна для SSR/headless. Реактивные триггеры
- * арминуются только в `start()` (в React — из `useEffect`).
- *
- * @typeParam T - Форма данных модели.
- * @param model - Модель данных.
- * @param schema - Схема валидации. **Стабильная ссылка** (иначе `validateModel` не отменит устаревший прогон).
- * @param options - {@link ValidationStrategyOptions}.
- *
- * @example
- * ```ts
- * const ctrl = createFormValidation(model, schema, { strategy: 'afterFirstSubmit', debounce: 300 });
- * const dispose = ctrl.start();               // на клиенте
- * const ok = await ctrl.validate();           // submit → раскрыть все ошибки
- * dispose();
- * ```
- */
-export declare function createFormValidation<T>(model: FormModel<T>, schema: ValidationSchema<T>, options?: ValidationStrategyOptions): FormValidationController;

package/dist/form/validators.d.ts

@@ -1,11 +0,0 @@
-/**
- * Точка входа сабпата `@reformer/core/validators` — все фабрики правил одним импортом.
- *
- * Гранулярные сабпаты (`@reformer/core/validators/required` и ещё 21) собираются отдельными
- * entry для tree-shaking; этот модуль отдаёт полный набор для случаев, когда правил много.
- *
- * Ранее здесь был ещё и default-экспорт (`validators` из корневого `index`), заведённый как
- * часть бандл-фикса «shared static registry». Реестров, ради которых он существовал, в коде
- * больше нет, чанк-шаринг он не обеспечивал, потребителей не имел — удалён в 7.0.
- */
-export * from './validation/index';

package/dist/form-model-DYCzGGKF.js

@@ -1,286 +0,0 @@
-import { signal as k } from "@preact/signals-core";
-import { i as b } from "./derived-registry-CluZCQ7U.js";
-const h = (e) => !(e === null || typeof e != "object" || Array.isArray(e) || e instanceof Date || typeof Blob < "u" && e instanceof Blob || typeof File < "u" && e instanceof File), a = (e, i) => e === "" ? String(i) : `${e}.${i}`, p = (e) => /^\d+$/.test(e), o = (e) => {
-  if (Array.isArray(e)) return e.map(o);
-  if (h(e)) {
-    const i = {};
-    for (const t of Object.keys(e)) i[t] = o(e[t]);
-    return i;
-  }
-  return e;
-}, u = (e, i) => {
-  if (e === i) return !0;
-  if (Array.isArray(e) && Array.isArray(i))
-    return e.length !== i.length ? !1 : e.every((t, r) => u(t, i[r]));
-  if (h(e) && h(i)) {
-    const t = Object.keys(e), r = Object.keys(i);
-    return t.length !== r.length ? !1 : t.every((n) => u(e[n], i[n]));
-  }
-  return !1;
-};
-class x {
-  constructor(i, t) {
-    this.path = t;
-    const r = k(i);
-    r.__path = t, this.signal = r, this.initial = o(i);
-  }
-  kind = "leaf";
-  signal;
-  initial;
-  rebase(i) {
-    this.path = i, this.signal.__path = i;
-  }
-  /** Реактивное чтение (внутри effect/computed создаёт зависимость). */
-  read() {
-    return this.signal.value;
-  }
-  /** Нереактивный снимок. */
-  peek() {
-    return this.signal.peek();
-  }
-  set(i) {
-    this.signal.value = i;
-  }
-  resetToInitial() {
-    this.signal.value = o(this.initial);
-  }
-  captureInitial() {
-    this.initial = o(this.signal.peek());
-  }
-  dirty() {
-    return !u(this.signal.peek(), this.initial);
-  }
-}
-class A {
-  constructor(i, t) {
-    this.path = t;
-    for (const r of Object.keys(i))
-      this.children.set(r, c(i[r], a(t, r)));
-  }
-  kind = "group";
-  children = /* @__PURE__ */ new Map();
-  rebase(i) {
-    this.path = i;
-    for (const [t, r] of this.children) r.rebase(a(i, t));
-  }
-  peek() {
-    const i = {};
-    for (const [t, r] of this.children) i[t] = r.peek();
-    return i;
-  }
-  set(i) {
-    if (i == null || typeof i != "object") return;
-    const t = i;
-    for (const [r, n] of this.children)
-      r in t && (n.kind === "leaf" && b(n.signal) || n.set(t[r]));
-  }
-  resetToInitial() {
-    for (const i of this.children.values()) i.resetToInitial();
-  }
-  captureInitial() {
-    for (const i of this.children.values()) i.captureInitial();
-  }
-  dirty() {
-    for (const i of this.children.values()) if (i.dirty()) return !0;
-    return !1;
-  }
-}
-class I {
-  constructor(i, t) {
-    this.path = t, this.items = k(i.map((r, n) => c(r, a(t, n)))), this.initial = o(i);
-  }
-  kind = "array";
-  items;
-  initial;
-  rebase(i) {
-    this.path = i, this.items.peek().forEach((t, r) => t.rebase(a(i, r)));
-  }
-  reindex() {
-    this.items.peek().forEach((i, t) => i.rebase(a(this.path, t)));
-  }
-  push(i) {
-    const t = this.items.peek();
-    this.items.value = [...t, c(i, a(this.path, t.length))];
-  }
-  insertAt(i, t) {
-    const r = [...this.items.peek()];
-    r.splice(i, 0, c(t, a(this.path, i))), this.items.value = r, this.reindex();
-  }
-  removeAt(i) {
-    const t = [...this.items.peek()];
-    t.splice(i, 1), this.items.value = t, this.reindex();
-  }
-  move(i, t) {
-    const r = [...this.items.peek()], [n] = r.splice(i, 1);
-    n && r.splice(t, 0, n), this.items.value = r, this.reindex();
-  }
-  swap(i, t) {
-    const r = [...this.items.peek()];
-    i < 0 || t < 0 || i >= r.length || t >= r.length || i === t || ([r[i], r[t]] = [r[t], r[i]], this.items.value = r, this.reindex());
-  }
-  clear() {
-    this.items.value = [];
-  }
-  peek() {
-    return this.items.peek().map((i) => i.peek());
-  }
-  set(i) {
-    const t = Array.isArray(i) ? i : [];
-    this.items.value = t.map((r, n) => c(r, a(this.path, n)));
-  }
-  resetToInitial() {
-    this.set(o(this.initial));
-  }
-  captureInitial() {
-    this.initial = o(this.peek());
-  }
-  dirty() {
-    return !u(this.peek(), this.initial);
-  }
-}
-function c(e, i) {
-  return Array.isArray(e) ? new I(e, i) : h(e) ? new A(e, i) : new x(e, i);
-}
-function l(e) {
-  if (e)
-    return e.kind === "group" ? _(e) : e.kind === "array" ? P(e) : e.read();
-}
-function P(e) {
-  const i = {
-    get length() {
-      return e.items.value.length;
-    },
-    push: (t) => e.push(t),
-    insertAt: (t, r) => e.insertAt(t, r),
-    removeAt: (t) => e.removeAt(t),
-    move: (t, r) => e.move(t, r),
-    swap: (t, r) => e.swap(t, r),
-    clear: () => e.clear(),
-    at: (t) => l(e.items.value[t]),
-    map: (t) => e.items.value.map((r, n) => t(l(r), n)),
-    forEach: (t) => e.items.value.forEach((r, n) => t(l(r), n)),
-    toArray: () => e.peek(),
-    [Symbol.iterator]: function* () {
-      const t = e.items.value;
-      for (let r = 0; r < t.length; r++) yield l(t[r]);
-    }
-  };
-  return new Proxy(i, {
-    get: (t, r, n) => r === "__path" ? e.path : typeof r == "string" && p(r) ? l(e.items.value[Number(r)]) : Reflect.get(t, r, n),
-    has: (t, r) => typeof r == "string" && p(r) ? Number(r) < e.items.value.length : Reflect.has(t, r)
-  });
-}
-function d(e) {
-  if (e.kind === "leaf") return e.signal;
-  if (e.kind === "group")
-    return new Proxy(
-      {},
-      {
-        get: (t, r) => {
-          if (r === "__path") return e.path;
-          if (typeof r != "string") return;
-          const n = e.children.get(r);
-          return n ? d(n) : void 0;
-        },
-        has: (t, r) => typeof r == "string" && e.children.has(r),
-        ownKeys: () => [...e.children.keys()],
-        getOwnPropertyDescriptor: (t, r) => typeof r == "string" && e.children.has(r) ? { enumerable: !0, configurable: !0 } : void 0
-      }
-    );
-  const i = e;
-  return new Proxy(
-    {
-      get length() {
-        return i.items.value.length;
-      }
-    },
-    {
-      get: (t, r, n) => {
-        if (r === "__path") return i.path;
-        if (typeof r == "string" && p(r)) {
-          const s = i.items.value[Number(r)];
-          return s ? d(s) : void 0;
-        }
-        return Reflect.get(t, r, n);
-      }
-    }
-  );
-}
-function j(e, i) {
-  if (!i) return;
-  let t = e;
-  for (const r of i.split(".")) {
-    if (!t) return;
-    if (t.kind === "group") t = t.children.get(r);
-    else if (t.kind === "array") t = t.items.peek()[Number(r)];
-    else return;
-  }
-  return t && t.kind === "leaf" ? t.signal : void 0;
-}
-const y = /* @__PURE__ */ new Set([
-  "$",
-  "get",
-  "set",
-  "patch",
-  "isDirty",
-  "reset",
-  "captureInitial",
-  "signalAt"
-]), v = /* @__PURE__ */ new WeakMap(), w = /* @__PURE__ */ new WeakMap();
-function _(e) {
-  const i = v.get(e);
-  if (i) return i;
-  const t = {
-    $: d(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) => j(e, n)
-  }, r = new Proxy(
-    {},
-    {
-      get: (n, s) => {
-        if (s === "__path") return e.path;
-        if (typeof s != "string") return;
-        const f = e.children.get(s);
-        if (f) return l(f);
-        if (y.has(s)) return t[s];
-      },
-      set: (n, s, f) => {
-        if (typeof s != "string") return !1;
-        const g = e.children.get(s);
-        return g ? (g.set(f), !0) : !1;
-      },
-      has: (n, s) => typeof s == "string" && (e.children.has(s) || y.has(s)),
-      ownKeys: () => [...e.children.keys()],
-      getOwnPropertyDescriptor: (n, s) => typeof s == "string" && e.children.has(s) ? { enumerable: !0, configurable: !0 } : void 0
-    }
-  );
-  return v.set(e, r), w.set(r, e), r;
-}
-function m(e, i) {
-  if (e.kind === "leaf") {
-    i(e.signal);
-    return;
-  }
-  if (e.kind === "group") {
-    for (const t of e.children.values()) m(t, i);
-    return;
-  }
-  for (const t of e.items.value) m(t, i);
-}
-function D(e, i) {
-  const t = w.get(e);
-  t && m(t, i);
-}
-function O(e) {
-  const i = new A(e, "");
-  return _(i);
-}
-export {
-  O as c,
-  D as e
-};