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

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;
     /** Переместить элемент. */
@@ -108,12 +111,23 @@ type ContainerSignal<T, TKeys extends PropertyKey> = Omit<ReadonlySignal<T>, TKe
 export type ModelGroupSignals<T> = ModelSignals<T> & ContainerSignal<T, keyof T>;
 /**
  * Узел-массив дерева `model.$`: индексируемый доступ к под-сигналам элементов, реактивная `length`
- * и {@link ReadonlySignal} значения массива целиком (реагирует и на правку элемента, и на изменение
- * состава — push/removeAt/move).
+ * и сигнал значения массива целиком (реагирует и на правку элемента, и на изменение состава —
+ * push/removeAt/move).
+ *
+ * В отличие от группы, узел ЗАПИСЫВАЕМ: `model.$.tags.value = ['a']` заменяет массив целиком. Это
+ * делает его {@link PathAwareSignal} — к нему привязывают поле (`{ value: model.$.tags, component }`),
+ * правило (`validate(model.$.tags, …)`) и поведение, как к листу. Так массив служит ОДНИМ значением
+ * поля: мультивыбор, теги, список файлов.
+ *
+ * `V` — объявленный тип поля, включая `null`/`undefined`: поле `string[] | null` с начальным `null`
+ * в рантайме — лист с тем же `.value`/`peek`/`subscribe`, поэтому общая часть честна для обоих
+ * случаев. `length` и индексы есть только у настоящего узла-массива (начальное значение — массив).
  *
  * @group Model
  */
-export type ModelArraySignals<U, V> = ContainerSignal<V, 'length'> & {
+export type ModelArraySignals<U, V> = Signal<V> & {
+    /** Путь массива в модели (dot-нотация). */
+    readonly __path: string;
     readonly length: number;
     readonly [index: number]: ModelSignalNode<U>;
 };
@@ -124,7 +138,7 @@ export type ModelArraySignals<U, V> = ContainerSignal<V, 'length'> & {
  * `PathAwareSignal<string>`, а не `ModelGroupSignals<never>`.
  * @internal
  */
-type ModelSignalNode<V> = NonNullable<V> extends ReadonlyArray<infer U> ? ModelArraySignals<U, NonNullable<V>> : NonNullable<V> extends Opaque ? PathAwareSignal<V> : NonNullable<V> extends object ? ModelGroupSignals<NonNullable<V>> : PathAwareSignal<V>;
+type ModelSignalNode<V> = NonNullable<V> extends ReadonlyArray<infer U> ? ModelArraySignals<U, V> : NonNullable<V> extends Opaque ? PathAwareSignal<V> : NonNullable<V> extends object ? ModelGroupSignals<NonNullable<V>> : PathAwareSignal<V>;
 /**
  * API уровня модели (доступно на корне, под-моделях вложенных объектов-групп и элементов массива).
  *
@@ -158,7 +172,10 @@ export interface ModelApi<T> {
     reset(): void;
     /** Зафиксировать текущие значения как новый initial-снимок («точка отсчёта»). */
     captureInitial(): void;
-    /** Резолв строкового пути в сигнал (для error-routing/мостов). */
+    /**
+     * Резолв строкового пути в сигнал (для error-routing/мостов): лист либо массив целиком
+     * (ручка значения массива — см. {@link ModelArraySignals}). Для пути группы — `undefined`.
+     */
     signalAt(path: string): PathAwareSignal<unknown> | undefined;
 }
 /**

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
+};

package/dist/model.js

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