cogsbox-state 0.5.435 → 0.5.437

package/dist/CogsState.jsx

@@ -1,260 +1,272 @@
 "use client";
-import { jsx as re, Fragment as ke } from "react/jsx-runtime";
-import { memo as Re, useState as X, useRef as G, useCallback as ce, useEffect as Q, useLayoutEffect as de, useMemo as ge, createElement as le, startTransition as je } from "react";
-import { createRoot as Ce } from "react-dom/client";
-import { transformStateFunc as Fe, isFunction as ee, isArray as Te, getDifferences as Pe, isDeepEqual as se } from "./utility.js";
-import { ValidationWrapper as be } from "./Functions.jsx";
-import Oe from "superjson";
-import { v4 as te } from "uuid";
-import { getGlobalStore as t, formRefStore as pe } from "./store.js";
-import { useCogsConfig as _e } from "./CogsStateClient.jsx";
-import { useInView as Le } from "react-intersection-observer";
-function he(e, i) {
-  const f = t.getState().getInitialOptions, g = t.getState().setInitialStateOptions, h = f(e) || {};
-  g(e, {
-    ...h,
-    ...i
+import { jsx as ot, Fragment as Ut } from "react/jsx-runtime";
+import { memo as Ot, useState as K, useRef as q, useCallback as ct, useEffect as Z, useLayoutEffect as dt, useMemo as St, createElement as lt, startTransition as Rt } from "react";
+import { createRoot as At } from "react-dom/client";
+import { transformStateFunc as Nt, isFunction as at, isArray as Tt, getDifferences as Ct, isDeepEqual as st } from "./utility.js";
+import { ValidationWrapper as kt } from "./Functions.jsx";
+import Ft from "superjson";
+import { v4 as rt } from "uuid";
+import { getGlobalStore as e, formRefStore as vt } from "./store.js";
+import { useCogsConfig as Pt } from "./CogsStateClient.jsx";
+import { useInView as jt } from "react-intersection-observer";
+function yt(t, n) {
+  const g = e.getState().getInitialOptions, S = e.getState().setInitialStateOptions, y = g(t) || {};
+  S(t, {
+    ...y,
+    ...n
   });
 }
-function Ee({
-  stateKey: e,
-  options: i,
-  initialOptionsPart: f
+function Et({
+  stateKey: t,
+  options: n,
+  initialOptionsPart: g
 }) {
-  const g = ae(e) || {}, h = f[e] || {}, p = t.getState().setInitialStateOptions, M = { ...h, ...g };
-  let l = !1;
-  if (i)
-    for (const u in i)
-      M.hasOwnProperty(u) ? (u == "localStorage" && i[u] && M[u].key !== i[u]?.key && (l = !0, M[u] = i[u]), u == "defaultState" && i[u] && M[u] !== i[u] && !se(M[u], i[u]) && (l = !0, M[u] = i[u])) : (l = !0, M[u] = i[u]);
-  l && p(e, M);
+  const S = nt(t) || {}, y = g[t] || {}, I = e.getState().setInitialStateOptions, E = { ...y, ...S };
+  let u = !1;
+  if (n)
+    for (const f in n)
+      E.hasOwnProperty(f) ? (f == "localStorage" && n[f] && E[f].key !== n[f]?.key && (u = !0, E[f] = n[f]), f == "defaultState" && n[f] && E[f] !== n[f] && !st(E[f], n[f]) && (u = !0, E[f] = n[f])) : (u = !0, E[f] = n[f]);
+  u && I(t, E);
 }
-function it(e, { formElements: i, validation: f }) {
-  return { initialState: e, formElements: i, validation: f };
+function ie(t, { formElements: n, validation: g }) {
+  return { initialState: t, formElements: n, validation: g };
 }
-const ct = (e, i) => {
-  let f = e;
-  const [g, h] = Fe(f);
-  Object.keys(g).forEach((l) => {
-    let u = h[l] || {};
+const Lt = (t, n) => {
+  let g = t;
+  const [S, y] = Nt(g);
+  n?.__fromSyncSchema && n?.__syncNotifications && e.getState().setInitialStateOptions("__notifications", n.__syncNotifications), Object.keys(S).forEach((u) => {
+    let f = y[u] || {};
     const A = {
-      ...u
+      ...f
     };
-    if (i?.formElements && (A.formElements = {
-      ...i.formElements,
-      ...u.formElements || {}
-    }), i?.validation && (A.validation = {
-      ...i.validation,
-      ...u.validation || {}
-    }, i.validation.key && !u.validation?.key && (A.validation.key = `${i.validation.key}.${l}`)), Object.keys(A).length > 0) {
-      const b = ae(l);
-      b ? t.getState().setInitialStateOptions(l, {
-        ...b,
+    if (n?.formElements && (A.formElements = {
+      ...n.formElements,
+      ...f.formElements || {}
+    }), n?.validation && (A.validation = {
+      ...n.validation,
+      ...f.validation || {}
+    }, n.validation.key && !f.validation?.key && (A.validation.key = `${n.validation.key}.${u}`)), Object.keys(A).length > 0) {
+      const w = nt(u);
+      w ? e.getState().setInitialStateOptions(u, {
+        ...w,
         ...A
-      }) : t.getState().setInitialStateOptions(l, A);
+      }) : e.getState().setInitialStateOptions(u, A);
     }
-  }), Object.keys(g).forEach((l) => {
-    t.getState().initializeShadowState(l, g[l]);
+  }), Object.keys(S).forEach((u) => {
+    e.getState().initializeShadowState(u, S[u]);
   });
-  const p = (l, u) => {
-    const [A] = X(u?.componentId ?? te());
-    Ee({
-      stateKey: l,
-      options: u,
-      initialOptionsPart: h
+  const I = (u, f) => {
+    const [A] = K(f?.componentId ?? rt());
+    Et({
+      stateKey: u,
+      options: f,
+      initialOptionsPart: y
     });
-    const b = t.getState().getShadowValue(l) || g[l], o = u?.modifyState ? u.modifyState(b) : b;
-    return Be(o, {
-      stateKey: l,
-      syncUpdate: u?.syncUpdate,
+    const w = e.getState().getShadowValue(u) || S[u], i = f?.modifyState ? f.modifyState(w) : w;
+    return zt(i, {
+      stateKey: u,
+      syncUpdate: f?.syncUpdate,
       componentId: A,
-      localStorage: u?.localStorage,
-      middleware: u?.middleware,
-      reactiveType: u?.reactiveType,
-      reactiveDeps: u?.reactiveDeps,
-      defaultState: u?.defaultState,
-      dependencies: u?.dependencies,
-      serverState: u?.serverState
+      localStorage: f?.localStorage,
+      middleware: f?.middleware,
+      reactiveType: f?.reactiveType,
+      reactiveDeps: f?.reactiveDeps,
+      defaultState: f?.defaultState,
+      dependencies: f?.dependencies,
+      serverState: f?.serverState
     });
   };
-  function M(l, u) {
-    Ee({ stateKey: l, options: u, initialOptionsPart: h }), u.localStorage && xe(l, u), ie(l);
+  function E(u, f) {
+    Et({ stateKey: u, options: f, initialOptionsPart: y }), f.localStorage && xt(u, f), it(u);
   }
-  return { useCogsState: p, setCogsOptions: M };
-}, {
-  getInitialOptions: ae,
-  getValidationErrors: Ne,
-  setStateLog: We,
-  updateInitialStateGlobal: $e,
-  addValidationError: ve,
-  removeValidationError: ne
-} = t.getState(), He = (e, i, f, g, h) => {
-  f?.log && console.log(
+  return { useCogsState: I, setCogsOptions: E };
+};
+function ce(t) {
+  const n = {};
+  for (const g in t.schemas) {
+    const S = t.schemas[g];
+    S.rawSchema ? n[g] = S.rawSchema : S.schemas?.defaults ? n[g] = S.schemas.defaults : n[g] = {};
+  }
+  return Lt(n, {
+    __fromSyncSchema: !0,
+    __syncNotifications: t.notifications
+  });
+}
+const {
+  getInitialOptions: nt,
+  getValidationErrors: le,
+  setStateLog: Wt,
+  updateInitialStateGlobal: _t,
+  addValidationError: pt,
+  removeValidationError: ut
+} = e.getState(), Ht = (t, n, g, S, y) => {
+  g?.log && console.log(
     "saving to localstorage",
-    i,
-    f.localStorage?.key,
-    g
+    n,
+    g.localStorage?.key,
+    S
   );
-  const p = ee(f?.localStorage?.key) ? f.localStorage?.key(e) : f?.localStorage?.key;
-  if (p && g) {
-    const M = `${g}-${i}-${p}`;
-    let l;
+  const I = at(g?.localStorage?.key) ? g.localStorage?.key(t) : g?.localStorage?.key;
+  if (I && S) {
+    const E = `${S}-${n}-${I}`;
+    let u;
     try {
-      l = Se(M)?.lastSyncedWithServer;
+      u = gt(E)?.lastSyncedWithServer;
     } catch {
     }
-    const u = t.getState().getShadowMetadata(i, []), A = {
-      state: e,
+    const f = e.getState().getShadowMetadata(n, []), A = {
+      state: t,
       lastUpdated: Date.now(),
-      lastSyncedWithServer: l,
-      stateSource: u?.stateSource,
-      baseServerState: u?.baseServerState
-    }, b = Oe.serialize(A);
+      lastSyncedWithServer: u,
+      stateSource: f?.stateSource,
+      baseServerState: f?.baseServerState
+    }, w = Ft.serialize(A);
     window.localStorage.setItem(
-      M,
-      JSON.stringify(b.json)
+      E,
+      JSON.stringify(w.json)
     );
   }
-}, Se = (e) => {
-  if (!e) return null;
+}, gt = (t) => {
+  if (!t) return null;
   try {
-    const i = window.localStorage.getItem(e);
-    return i ? JSON.parse(i) : null;
-  } catch (i) {
-    return console.error("Error loading from localStorage:", i), null;
+    const n = window.localStorage.getItem(t);
+    return n ? JSON.parse(n) : null;
+  } catch (n) {
+    return console.error("Error loading from localStorage:", n), null;
   }
-}, xe = (e, i) => {
-  const f = t.getState().getShadowValue(e), { sessionId: g } = _e(), h = ee(i?.localStorage?.key) ? i.localStorage.key(f) : i?.localStorage?.key;
-  if (h && g) {
-    const p = Se(
-      `${g}-${e}-${h}`
+}, xt = (t, n) => {
+  const g = e.getState().getShadowValue(t), { sessionId: S } = Pt(), y = at(n?.localStorage?.key) ? n.localStorage.key(g) : n?.localStorage?.key;
+  if (y && S) {
+    const I = gt(
+      `${S}-${t}-${y}`
     );
-    if (p && p.lastUpdated > (p.lastSyncedWithServer || 0))
-      return ie(e), !0;
+    if (I && I.lastUpdated > (I.lastSyncedWithServer || 0))
+      return it(t), !0;
   }
   return !1;
-}, ie = (e) => {
-  const i = t.getState().getShadowMetadata(e, []);
-  if (!i) return;
-  const f = /* @__PURE__ */ new Set();
-  i?.components?.forEach((g) => {
-    (g ? Array.isArray(g.reactiveType) ? g.reactiveType : [g.reactiveType || "component"] : null)?.includes("none") || f.add(() => g.forceUpdate());
+}, it = (t) => {
+  const n = e.getState().getShadowMetadata(t, []);
+  if (!n) return;
+  const g = /* @__PURE__ */ new Set();
+  n?.components?.forEach((S) => {
+    (S ? Array.isArray(S.reactiveType) ? S.reactiveType : [S.reactiveType || "component"] : null)?.includes("none") || g.add(() => S.forceUpdate());
   }), queueMicrotask(() => {
-    f.forEach((g) => g());
+    g.forEach((S) => S());
   });
-}, lt = (e, i) => {
-  const f = t.getState().getShadowMetadata(e, []);
-  if (f) {
-    const g = `${e}////${i}`, h = f?.components?.get(g);
-    if ((h ? Array.isArray(h.reactiveType) ? h.reactiveType : [h.reactiveType || "component"] : null)?.includes("none"))
+}, ue = (t, n) => {
+  const g = e.getState().getShadowMetadata(t, []);
+  if (g) {
+    const S = `${t}////${n}`, y = g?.components?.get(S);
+    if ((y ? Array.isArray(y.reactiveType) ? y.reactiveType : [y.reactiveType || "component"] : null)?.includes("none"))
       return;
-    h && h.forceUpdate();
+    y && y.forceUpdate();
   }
 };
-function we(e, i, f, g) {
-  const h = t.getState(), p = h.getShadowMetadata(e, i);
-  if (h.setShadowMetadata(e, i, {
-    ...p,
+function wt(t, n, g, S) {
+  const y = e.getState(), I = y.getShadowMetadata(t, n);
+  if (y.setShadowMetadata(t, n, {
+    ...I,
     isDirty: !1,
     stateSource: "server",
-    lastServerSync: g || Date.now()
-  }), Array.isArray(f)) {
-    const M = h.getShadowMetadata(e, i);
-    M?.arrayKeys && M.arrayKeys.forEach((l, u) => {
-      const A = l.split(".").slice(1), b = f[u];
-      b !== void 0 && we(
-        e,
+    lastServerSync: S || Date.now()
+  }), Array.isArray(g)) {
+    const E = y.getShadowMetadata(t, n);
+    E?.arrayKeys && E.arrayKeys.forEach((u, f) => {
+      const A = u.split(".").slice(1), w = g[f];
+      w !== void 0 && wt(
+        t,
         A,
-        b,
-        g
+        w,
+        S
       );
     });
-  } else f && typeof f == "object" && f.constructor === Object && Object.keys(f).forEach((M) => {
-    const l = [...i, M], u = f[M];
-    we(e, l, u, g);
+  } else g && typeof g == "object" && g.constructor === Object && Object.keys(g).forEach((E) => {
+    const u = [...n, E], f = g[E];
+    wt(t, u, f, S);
   });
 }
-function Be(e, {
-  stateKey: i,
-  localStorage: f,
-  formElements: g,
-  reactiveDeps: h,
-  reactiveType: p,
-  componentId: M,
-  defaultState: l,
-  syncUpdate: u,
+function zt(t, {
+  stateKey: n,
+  localStorage: g,
+  formElements: S,
+  reactiveDeps: y,
+  reactiveType: I,
+  componentId: E,
+  defaultState: u,
+  syncUpdate: f,
   dependencies: A,
-  serverState: b
+  serverState: w
 } = {}) {
-  const [o, S] = X({}), { sessionId: T } = _e();
-  let W = !i;
-  const [c] = X(i ?? te()), x = t.getState().stateLog[c], Y = G(/* @__PURE__ */ new Set()), J = G(M ?? te()), U = G(
+  const [i, h] = K({}), { sessionId: M } = Pt();
+  let z = !n;
+  const [c] = K(n ?? rt()), B = e.getState().stateLog[c], J = q(/* @__PURE__ */ new Set()), H = q(E ?? rt()), W = q(
     null
   );
-  U.current = ae(c) ?? null, Q(() => {
-    if (u && u.stateKey === c && u.path?.[0]) {
-      const n = `${u.stateKey}:${u.path.join(".")}`;
-      t.getState().setSyncInfo(n, {
-        timeStamp: u.timeStamp,
-        userId: u.userId
+  W.current = nt(c) ?? null, Z(() => {
+    if (f && f.stateKey === c && f.path?.[0]) {
+      const o = `${f.stateKey}:${f.path.join(".")}`;
+      e.getState().setSyncInfo(o, {
+        timeStamp: f.timeStamp,
+        userId: f.userId
       });
     }
-  }, [u]);
-  const v = ce(
-    (n) => {
-      const a = n ? { ...ae(c), ...n } : ae(c), d = a?.defaultState || l || e;
+  }, [f]);
+  const m = ct(
+    (o) => {
+      const a = o ? { ...nt(c), ...o } : nt(c), d = a?.defaultState || u || t;
       if (a?.serverState?.status === "success" && a?.serverState?.data !== void 0)
         return {
           value: a.serverState.data,
           source: "server",
           timestamp: a.serverState.timestamp || Date.now()
         };
-      if (a?.localStorage?.key && T) {
-        const m = ee(a.localStorage.key) ? a.localStorage.key(d) : a.localStorage.key, P = Se(
-          `${T}-${c}-${m}`
+      if (a?.localStorage?.key && M) {
+        const p = at(a.localStorage.key) ? a.localStorage.key(d) : a.localStorage.key, V = gt(
+          `${M}-${c}-${p}`
         );
-        if (P && P.lastUpdated > (a?.serverState?.timestamp || 0))
+        if (V && V.lastUpdated > (a?.serverState?.timestamp || 0))
           return {
-            value: P.state,
+            value: V.state,
             source: "localStorage",
-            timestamp: P.lastUpdated
+            timestamp: V.lastUpdated
           };
       }
       return {
-        value: d || e,
+        value: d || t,
         source: "default",
         timestamp: Date.now()
       };
     },
-    [c, l, e, T]
+    [c, u, t, M]
   );
-  Q(() => {
-    t.getState().setServerStateUpdate(c, b);
-  }, [b, c]), Q(() => t.getState().subscribeToPath(c, (r) => {
+  Z(() => {
+    e.getState().setServerStateUpdate(c, w);
+  }, [w, c]), Z(() => e.getState().subscribeToPath(c, (r) => {
     if (r?.type === "SERVER_STATE_UPDATE") {
       const a = r.serverState;
       if (a?.status === "success" && a.data !== void 0) {
-        he(c, { serverState: a });
-        const w = typeof a.merge == "object" ? a.merge : a.merge === !0 ? {} : null, m = t.getState().getShadowValue(c), P = a.data;
-        if (w && Array.isArray(m) && Array.isArray(P)) {
-          const D = w.key || "id", j = new Set(
-            m.map((O) => O[D])
-          ), F = P.filter((O) => !j.has(O[D]));
-          F.length > 0 && F.forEach((O) => {
-            t.getState().insertShadowArrayElement(c, [], O);
-            const L = t.getState().getShadowMetadata(c, []);
-            if (L?.arrayKeys) {
-              const N = L.arrayKeys[L.arrayKeys.length - 1];
-              if (N) {
-                const B = N.split(".").slice(1);
-                t.getState().setShadowMetadata(c, B, {
+        yt(c, { serverState: a });
+        const l = typeof a.merge == "object" ? a.merge : a.merge === !0 ? {} : null, p = e.getState().getShadowValue(c), V = a.data;
+        if (l && Array.isArray(p) && Array.isArray(V)) {
+          const U = l.key || "id", C = new Set(
+            p.map((x) => x[U])
+          ), F = V.filter((x) => !C.has(x[U]));
+          F.length > 0 && F.forEach((x) => {
+            e.getState().insertShadowArrayElement(c, [], x);
+            const N = e.getState().getShadowMetadata(c, []);
+            if (N?.arrayKeys) {
+              const j = N.arrayKeys[N.arrayKeys.length - 1];
+              if (j) {
+                const b = j.split(".").slice(1);
+                e.getState().setShadowMetadata(c, b, {
                   isDirty: !1,
                   stateSource: "server",
                   lastServerSync: a.timestamp || Date.now()
                 });
-                const V = t.getState().getShadowValue(N);
-                V && typeof V == "object" && !Array.isArray(V) && Object.keys(V).forEach((E) => {
-                  const $ = [...B, E];
-                  t.getState().setShadowMetadata(c, $, {
+                const k = e.getState().getShadowValue(j);
+                k && typeof k == "object" && !Array.isArray(k) && Object.keys(k).forEach((P) => {
+                  const O = [...b, P];
+                  e.getState().setShadowMetadata(c, O, {
                     isDirty: !1,
                     stateSource: "server",
                     lastServerSync: a.timestamp || Date.now()
@@ -264,634 +276,620 @@ function Be(e, {
             }
           });
         } else
-          t.getState().initializeShadowState(c, P), we(
+          e.getState().initializeShadowState(c, V), wt(
             c,
             [],
-            P,
+            V,
             a.timestamp
           );
-        const R = t.getState().getShadowMetadata(c, []);
-        t.getState().setShadowMetadata(c, [], {
-          ...R,
+        const _ = e.getState().getShadowMetadata(c, []);
+        e.getState().setShadowMetadata(c, [], {
+          ..._,
           stateSource: "server",
           lastServerSync: a.timestamp || Date.now(),
           isDirty: !1
         });
       }
     }
-  }), [c, v]), Q(() => {
-    const n = t.getState().getShadowMetadata(c, []);
-    if (n && n.stateSource)
+  }), [c, m]), Z(() => {
+    const o = e.getState().getShadowMetadata(c, []);
+    if (o && o.stateSource)
       return;
-    const r = ae(c);
-    if (r?.defaultState !== void 0 || l !== void 0) {
-      const a = r?.defaultState || l;
-      r?.defaultState || he(c, {
+    const r = nt(c);
+    if (r?.defaultState !== void 0 || u !== void 0) {
+      const a = r?.defaultState || u;
+      r?.defaultState || yt(c, {
         defaultState: a
       });
-      const { value: d, source: w, timestamp: m } = v();
-      t.getState().initializeShadowState(c, d), t.getState().setShadowMetadata(c, [], {
-        stateSource: w,
-        lastServerSync: w === "server" ? m : void 0,
+      const { value: d, source: l, timestamp: p } = m();
+      e.getState().initializeShadowState(c, d), e.getState().setShadowMetadata(c, [], {
+        stateSource: l,
+        lastServerSync: l === "server" ? p : void 0,
         isDirty: !1,
-        baseServerState: w === "server" ? d : void 0
-      }), ie(c);
+        baseServerState: l === "server" ? d : void 0
+      }), it(c);
     }
-  }, [c, ...A || []]), de(() => {
-    W && he(c, {
-      formElements: g,
-      defaultState: l,
-      localStorage: f,
-      middleware: U.current?.middleware
+  }, [c, ...A || []]), dt(() => {
+    z && yt(c, {
+      formElements: S,
+      defaultState: u,
+      localStorage: g,
+      middleware: W.current?.middleware
     });
-    const n = `${c}////${J.current}`, r = t.getState().getShadowMetadata(c, []), a = r?.components || /* @__PURE__ */ new Map();
-    return a.set(n, {
-      forceUpdate: () => S({}),
-      reactiveType: p ?? ["component", "deps"],
+    const o = `${c}////${H.current}`, r = e.getState().getShadowMetadata(c, []), a = r?.components || /* @__PURE__ */ new Map();
+    return a.set(o, {
+      forceUpdate: () => h({}),
+      reactiveType: I ?? ["component", "deps"],
       paths: /* @__PURE__ */ new Set(),
-      depsFunction: h || void 0,
-      deps: h ? h(t.getState().getShadowValue(c)) : [],
-      prevDeps: h ? h(t.getState().getShadowValue(c)) : []
-    }), t.getState().setShadowMetadata(c, [], {
+      depsFunction: y || void 0,
+      deps: y ? y(e.getState().getShadowValue(c)) : [],
+      prevDeps: y ? y(e.getState().getShadowValue(c)) : []
+    }), e.getState().setShadowMetadata(c, [], {
       ...r,
       components: a
-    }), S({}), () => {
-      const d = t.getState().getShadowMetadata(c, []), w = d?.components?.get(n);
-      w?.paths && w.paths.forEach((m) => {
-        const R = m.split(".").slice(1), D = t.getState().getShadowMetadata(c, R);
-        D?.pathComponents && D.pathComponents.size === 0 && (delete D.pathComponents, t.getState().setShadowMetadata(c, R, D));
-      }), d?.components && t.getState().setShadowMetadata(c, [], d);
+    }), h({}), () => {
+      const d = e.getState().getShadowMetadata(c, []), l = d?.components?.get(o);
+      l?.paths && l.paths.forEach((p) => {
+        const _ = p.split(".").slice(1), U = e.getState().getShadowMetadata(c, _);
+        U?.pathComponents && U.pathComponents.size === 0 && (delete U.pathComponents, e.getState().setShadowMetadata(c, _, U));
+      }), d?.components && e.getState().setShadowMetadata(c, [], d);
     };
   }, []);
-  const K = G(null), oe = (n, r, a, d) => {
-    const w = [c, ...r].join(".");
+  const Y = q(null), Q = (o, r, a) => {
+    const d = [c, ...r].join(".");
     if (Array.isArray(r)) {
-      const V = `${c}-${r.join(".")}`;
-      Y.current.add(V);
+      const b = `${c}-${r.join(".")}`;
+      J.current.add(b);
     }
-    const m = t.getState(), P = m.getShadowMetadata(c, r), R = m.getShadowValue(w), D = a.updateType === "insert" && ee(n) ? n({ state: R, uuid: te() }) : ee(n) ? n(R) : n, F = {
+    const l = e.getState(), p = l.getShadowMetadata(c, r), V = l.getShadowValue(d), _ = a.updateType === "insert" && at(o) ? o({ state: V, uuid: rt() }) : at(o) ? o(V) : o, C = {
       timeStamp: Date.now(),
       stateKey: c,
       path: r,
       updateType: a.updateType,
       status: "new",
-      oldValue: R,
-      newValue: D
+      oldValue: V,
+      newValue: _
     };
     switch (a.updateType) {
       case "insert": {
-        m.insertShadowArrayElement(c, r, F.newValue), m.markAsDirty(c, r, { bubble: !0 });
-        const V = m.getShadowMetadata(c, r);
-        if (V?.arrayKeys) {
-          const E = V.arrayKeys[V.arrayKeys.length - 1];
-          if (E) {
-            const $ = E.split(".").slice(1);
-            m.markAsDirty(c, $, { bubble: !1 });
+        l.insertShadowArrayElement(c, r, C.newValue), l.markAsDirty(c, r, { bubble: !0 });
+        const b = l.getShadowMetadata(c, r);
+        if (b?.arrayKeys) {
+          const k = b.arrayKeys[b.arrayKeys.length - 1];
+          if (k) {
+            const P = k.split(".").slice(1);
+            l.markAsDirty(c, P, { bubble: !1 });
           }
         }
         break;
       }
       case "cut": {
-        const V = r.slice(0, -1);
-        m.removeShadowArrayElement(c, r), m.markAsDirty(c, V, { bubble: !0 });
+        const b = r.slice(0, -1);
+        l.removeShadowArrayElement(c, r), l.markAsDirty(c, b, { bubble: !0 });
         break;
       }
       case "update": {
-        m.updateShadowAtPath(c, r, F.newValue), m.markAsDirty(c, r, { bubble: !0 });
+        l.updateShadowAtPath(c, r, C.newValue), l.markAsDirty(c, r, { bubble: !0 });
         break;
       }
     }
-    if (console.log("sdadasdasd", K.current, F), K.current && K.current.connected && K.current.updateState({ operation: F }), P?.signals && P.signals.length > 0) {
-      const V = a.updateType === "cut" ? null : D;
-      P.signals.forEach(({ parentId: E, position: $, effect: I }) => {
-        const y = document.querySelector(`[data-parent-id="${E}"]`);
-        if (y) {
-          const k = Array.from(y.childNodes);
-          if (k[$]) {
-            let C = V;
-            if (I && V !== null)
+    if (a.sync !== !1 && Y.current && Y.current.connected && Y.current.updateState({ operation: C }), p?.signals && p.signals.length > 0) {
+      const b = a.updateType === "cut" ? null : _;
+      p.signals.forEach(({ parentId: k, position: P, effect: O }) => {
+        const v = document.querySelector(`[data-parent-id="${k}"]`);
+        if (v) {
+          const T = Array.from(v.childNodes);
+          if (T[P]) {
+            let $ = b;
+            if (O && b !== null)
               try {
-                C = new Function(
+                $ = new Function(
                   "state",
-                  `return (${I})(state)`
-                )(V);
-              } catch (_) {
-                console.error("Error evaluating effect function:", _);
+                  `return (${O})(state)`
+                )(b);
+              } catch (D) {
+                console.error("Error evaluating effect function:", D);
               }
-            C != null && typeof C == "object" && (C = JSON.stringify(C)), k[$].textContent = String(C ?? "");
+            $ != null && typeof $ == "object" && ($ = JSON.stringify($)), T[P].textContent = String($ ?? "");
           }
         }
       });
     }
-    if (a.updateType === "insert" && P?.mapWrappers && P.mapWrappers.length > 0) {
-      const V = m.getShadowMetadata(c, r)?.arrayKeys || [], E = V[V.length - 1], $ = m.getShadowValue(E), I = m.getShadowValue(
+    if (a.updateType === "insert" && p?.mapWrappers && p.mapWrappers.length > 0) {
+      const b = l.getShadowMetadata(c, r)?.arrayKeys || [], k = b[b.length - 1], P = l.getShadowValue(k), O = l.getShadowValue(
         [c, ...r].join(".")
       );
-      if (!E || $ === void 0) return;
-      P.mapWrappers.forEach((y) => {
-        let k = !0, C = -1;
-        if (y.meta?.transforms && y.meta.transforms.length > 0) {
-          for (const _ of y.meta.transforms)
-            if (_.type === "filter" && !_.fn($, -1)) {
-              k = !1;
+      if (!k || P === void 0) return;
+      p.mapWrappers.forEach((v) => {
+        let T = !0, $ = -1;
+        if (v.meta?.transforms && v.meta.transforms.length > 0) {
+          for (const D of v.meta.transforms)
+            if (D.type === "filter" && !D.fn(P, -1)) {
+              T = !1;
               break;
             }
-          if (k) {
-            const _ = Ie(
+          if (T) {
+            const D = It(
               c,
               r,
-              y.meta.transforms
-            ), q = y.meta.transforms.find(
-              (H) => H.type === "sort"
+              v.meta.transforms
+            ), R = v.meta.transforms.find(
+              (L) => L.type === "sort"
             );
-            if (q) {
-              const H = _.map((z) => ({
-                key: z,
-                value: m.getShadowValue(z)
+            if (R) {
+              const L = D.map((G) => ({
+                key: G,
+                value: l.getShadowValue(G)
               }));
-              H.push({ key: E, value: $ }), H.sort((z, Z) => q.fn(z.value, Z.value)), C = H.findIndex(
-                (z) => z.key === E
+              L.push({ key: k, value: P }), L.sort((G, tt) => R.fn(G.value, tt.value)), $ = L.findIndex(
+                (G) => G.key === k
               );
             } else
-              C = _.length;
+              $ = D.length;
           }
         } else
-          k = !0, C = V.length - 1;
-        if (k && y.containerRef && y.containerRef.isConnected) {
-          const _ = document.createElement("div");
-          _.setAttribute("data-item-path", E);
-          const q = Array.from(y.containerRef.children);
-          C >= 0 && C < q.length ? y.containerRef.insertBefore(
-            _,
-            q[C]
-          ) : y.containerRef.appendChild(_);
-          const H = Ce(_), z = te(), Z = E.split(".").slice(1), ue = y.rebuildStateShape({
-            path: y.path,
-            currentState: I,
-            componentId: y.componentId,
-            meta: y.meta
+          T = !0, $ = b.length - 1;
+        if (T && v.containerRef && v.containerRef.isConnected) {
+          const D = document.createElement("div");
+          D.setAttribute("data-item-path", k);
+          const R = Array.from(v.containerRef.children);
+          $ >= 0 && $ < R.length ? v.containerRef.insertBefore(
+            D,
+            R[$]
+          ) : v.containerRef.appendChild(D);
+          const L = At(D), G = rt(), tt = k.split(".").slice(1), et = v.rebuildStateShape({
+            path: v.path,
+            currentState: O,
+            componentId: v.componentId,
+            meta: v.meta
           });
-          H.render(
-            le(Me, {
+          L.render(
+            lt(Mt, {
               stateKey: c,
-              itemComponentId: z,
-              itemPath: Z,
-              localIndex: C,
-              arraySetter: ue,
-              rebuildStateShape: y.rebuildStateShape,
-              renderFn: y.mapFn
+              itemComponentId: G,
+              itemPath: tt,
+              localIndex: $,
+              arraySetter: et,
+              rebuildStateShape: v.rebuildStateShape,
+              renderFn: v.mapFn
             })
           );
         }
       });
     }
     if (a.updateType === "cut") {
-      const V = r.slice(0, -1), E = m.getShadowMetadata(c, V);
-      E?.mapWrappers && E.mapWrappers.length > 0 && E.mapWrappers.forEach(($) => {
-        if ($.containerRef && $.containerRef.isConnected) {
-          const I = $.containerRef.querySelector(
-            `[data-item-path="${w}"]`
+      const b = r.slice(0, -1), k = l.getShadowMetadata(c, b);
+      k?.mapWrappers && k.mapWrappers.length > 0 && k.mapWrappers.forEach((P) => {
+        if (P.containerRef && P.containerRef.isConnected) {
+          const O = P.containerRef.querySelector(
+            `[data-item-path="${d}"]`
           );
-          I && I.remove();
+          O && O.remove();
         }
       });
     }
-    a.updateType === "update" && (d || U.current?.validation?.key) && r && ne(
-      (d || U.current?.validation?.key) + "." + r.join(".")
-    );
-    const O = r.slice(0, r.length - 1);
-    a.updateType === "cut" && U.current?.validation?.key && ne(
-      U.current?.validation?.key + "." + O.join(".")
-    ), a.updateType === "insert" && U.current?.validation?.key && Ne(
-      U.current?.validation?.key + "." + O.join(".")
-    ).filter((E) => {
-      let $ = E?.split(".").length;
-      const I = "";
-      if (E == O.join(".") && $ == O.length - 1) {
-        let y = E + "." + O;
-        ne(E), ve(y, I);
+    const x = e.getState().getShadowValue(c), N = e.getState().getShadowMetadata(c, []), j = /* @__PURE__ */ new Set();
+    if (console.log(
+      "rootMeta",
+      c,
+      e.getState().shadowStateStore
+    ), !N?.components)
+      return x;
+    if (a.updateType === "update") {
+      let b = [...r];
+      for (; ; ) {
+        const k = l.getShadowMetadata(c, b);
+        if (k?.pathComponents && k.pathComponents.forEach((P) => {
+          if (j.has(P))
+            return;
+          const O = N.components?.get(P);
+          O && ((Array.isArray(O.reactiveType) ? O.reactiveType : [O.reactiveType || "component"]).includes("none") || (O.forceUpdate(), j.add(P)));
+        }), b.length === 0)
+          break;
+        b.pop();
       }
-    });
-    const L = m.getShadowValue(c), N = m.getShadowMetadata(c, []), B = /* @__PURE__ */ new Set();
-    if (!N?.components)
-      return L;
-    if (a.updateType === "update")
-      P?.pathComponents && P.pathComponents.forEach((V) => {
-        if (B.has(V))
-          return;
-        const E = N.components?.get(V);
-        E && ((Array.isArray(E.reactiveType) ? E.reactiveType : [E.reactiveType || "component"]).includes("none") || (E.forceUpdate(), B.add(V)));
-      }), D && typeof D == "object" && !Te(D) && R && typeof R == "object" && !Te(R) && Pe(D, R).forEach((E) => {
-        const $ = E.split("."), I = [...r, ...$], y = m.getShadowMetadata(c, I);
-        y?.pathComponents && y.pathComponents.forEach((k) => {
-          if (B.has(k))
+      _ && typeof _ == "object" && !Tt(_) && V && typeof V == "object" && !Tt(V) && Ct(_, V).forEach((P) => {
+        const O = P.split("."), v = [...r, ...O], T = l.getShadowMetadata(c, v);
+        T?.pathComponents && T.pathComponents.forEach(($) => {
+          if (j.has($))
             return;
-          const C = N.components?.get(k);
-          C && ((Array.isArray(C.reactiveType) ? C.reactiveType : [C.reactiveType || "component"]).includes("none") || (C.forceUpdate(), B.add(k)));
+          const D = N.components?.get($);
+          D && ((Array.isArray(D.reactiveType) ? D.reactiveType : [D.reactiveType || "component"]).includes("none") || (D.forceUpdate(), j.add($)));
         });
       });
-    else if (a.updateType === "insert" || a.updateType === "cut") {
-      const V = a.updateType === "insert" ? r : r.slice(0, -1), E = m.getShadowMetadata(c, V);
-      if (E?.signals && E.signals.length > 0) {
-        const $ = [c, ...V].join("."), I = m.getShadowValue($);
-        E.signals.forEach(({ parentId: y, position: k, effect: C }) => {
-          const _ = document.querySelector(
-            `[data-parent-id="${y}"]`
+    } else if (a.updateType === "insert" || a.updateType === "cut") {
+      const b = a.updateType === "insert" ? r : r.slice(0, -1), k = l.getShadowMetadata(c, b);
+      if (k?.signals && k.signals.length > 0) {
+        const P = [c, ...b].join("."), O = l.getShadowValue(P);
+        k.signals.forEach(({ parentId: v, position: T, effect: $ }) => {
+          const D = document.querySelector(
+            `[data-parent-id="${v}"]`
           );
-          if (_) {
-            const q = Array.from(_.childNodes);
-            if (q[k]) {
-              let H = I;
-              if (C)
+          if (D) {
+            const R = Array.from(D.childNodes);
+            if (R[T]) {
+              let L = O;
+              if ($)
                 try {
-                  H = new Function(
+                  L = new Function(
                     "state",
-                    `return (${C})(state)`
-                  )(I);
-                } catch (z) {
-                  console.error("Error evaluating effect function:", z), H = I;
+                    `return (${$})(state)`
+                  )(O);
+                } catch (G) {
+                  console.error("Error evaluating effect function:", G), L = O;
                 }
-              H != null && typeof H == "object" && (H = JSON.stringify(H)), q[k].textContent = String(H ?? "");
+              L != null && typeof L == "object" && (L = JSON.stringify(L)), R[T].textContent = String(L ?? "");
             }
           }
         });
       }
-      E?.pathComponents && E.pathComponents.forEach(($) => {
-        if (!B.has($)) {
-          const I = N.components?.get($);
-          I && (I.forceUpdate(), B.add($));
+      k?.pathComponents && k.pathComponents.forEach((P) => {
+        if (!j.has(P)) {
+          const O = N.components?.get(P);
+          O && (O.forceUpdate(), j.add(P));
         }
       });
     }
-    return N.components.forEach((V, E) => {
-      if (B.has(E))
+    return N.components.forEach((b, k) => {
+      if (j.has(k))
         return;
-      const $ = Array.isArray(V.reactiveType) ? V.reactiveType : [V.reactiveType || "component"];
-      if ($.includes("all")) {
-        V.forceUpdate(), B.add(E);
+      const P = Array.isArray(b.reactiveType) ? b.reactiveType : [b.reactiveType || "component"];
+      if (P.includes("all")) {
+        b.forceUpdate(), j.add(k);
         return;
       }
-      if ($.includes("deps") && V.depsFunction) {
-        const I = m.getShadowValue(c), y = V.depsFunction(I);
-        let k = !1;
-        y === !0 ? k = !0 : Array.isArray(y) && (se(V.prevDeps, y) || (V.prevDeps = y, k = !0)), k && (V.forceUpdate(), B.add(E));
+      if (P.includes("deps") && b.depsFunction) {
+        const O = l.getShadowValue(c), v = b.depsFunction(O);
+        let T = !1;
+        v === !0 ? T = !0 : Array.isArray(v) && (st(b.prevDeps, v) || (b.prevDeps = v, T = !0)), T && (b.forceUpdate(), j.add(k));
       }
-    }), B.clear(), We(c, (V) => {
-      const E = [...V ?? [], F], $ = /* @__PURE__ */ new Map();
-      return E.forEach((I) => {
-        const y = `${I.stateKey}:${JSON.stringify(I.path)}`, k = $.get(y);
-        k ? (k.timeStamp = Math.max(k.timeStamp, I.timeStamp), k.newValue = I.newValue, k.oldValue = k.oldValue ?? I.oldValue, k.updateType = I.updateType) : $.set(y, { ...I });
-      }), Array.from($.values());
-    }), He(
-      D,
+    }), j.clear(), Wt(c, (b) => {
+      const k = [...b ?? [], C], P = /* @__PURE__ */ new Map();
+      return k.forEach((O) => {
+        const v = `${O.stateKey}:${JSON.stringify(O.path)}`, T = P.get(v);
+        T ? (T.timeStamp = Math.max(T.timeStamp, O.timeStamp), T.newValue = O.newValue, T.oldValue = T.oldValue ?? O.oldValue, T.updateType = O.updateType) : P.set(v, { ...O });
+      }), Array.from(P.values());
+    }), Ht(
+      _,
       c,
-      U.current,
-      T
-    ), U.current?.middleware && U.current.middleware({
-      updateLog: x,
-      update: F
-    }), L;
+      W.current,
+      M
+    ), W.current?.middleware && W.current.middleware({
+      updateLog: B,
+      update: C
+    }), x;
   };
-  t.getState().initialStateGlobal[c] || $e(c, e);
-  const fe = ge(() => De(
+  e.getState().initialStateGlobal[c] || _t(c, t);
+  const X = St(() => Dt(
     c,
-    oe,
-    J.current,
-    T
-  ), [c, T]), s = U.current?.cogsSync;
-  return s && (K.current = s(fe)), fe;
+    Q,
+    H.current,
+    M
+  ), [c, M]), s = W.current?.cogsSync;
+  return s && (Y.current = s(X)), X;
 }
-function qe(e) {
-  return !e || e.length === 0 ? "" : e.map(
-    (i) => (
+function Bt(t) {
+  return !t || t.length === 0 ? "" : t.map(
+    (n) => (
       // Safely stringify dependencies. An empty array becomes '[]'.
-      `${i.type}${JSON.stringify(i.dependencies || [])}`
+      `${n.type}${JSON.stringify(n.dependencies || [])}`
     )
   ).join("");
 }
-const Ie = (e, i, f) => {
-  let g = t.getState().getShadowMetadata(e, i)?.arrayKeys || [];
-  if (!f || f.length === 0)
-    return g;
-  let h = g.map((p) => ({
-    key: p,
-    value: t.getState().getShadowValue(p)
+const It = (t, n, g) => {
+  let S = e.getState().getShadowMetadata(t, n)?.arrayKeys || [];
+  if (!g || g.length === 0)
+    return S;
+  let y = S.map((I) => ({
+    key: I,
+    value: e.getState().getShadowValue(I)
   }));
-  for (const p of f)
-    p.type === "filter" ? h = h.filter(
-      ({ value: M }, l) => p.fn(M, l)
-    ) : p.type === "sort" && h.sort((M, l) => p.fn(M.value, l.value));
-  return h.map(({ key: p }) => p);
-}, Ve = (e, i, f) => {
-  const g = `${e}////${i}`, p = t.getState().getShadowMetadata(e, [])?.components?.get(g);
-  if (!p || p.reactiveType == "none" || !(Array.isArray(p.reactiveType) ? p.reactiveType : [p.reactiveType]).includes("component"))
-    return;
-  const M = [e, ...f].join(".");
-  p.paths.add(M);
-  const l = t.getState().getShadowMetadata(e, f) || {}, u = l.pathComponents || /* @__PURE__ */ new Set();
-  u.add(g), t.getState().setShadowMetadata(e, f, {
-    ...l,
-    pathComponents: u
-  });
-}, ye = (e, i, f) => {
-  const g = t.getState(), h = g.getShadowMetadata(e, []), p = /* @__PURE__ */ new Set();
-  h?.components && h.components.forEach((l, u) => {
-    (Array.isArray(l.reactiveType) ? l.reactiveType : [l.reactiveType || "component"]).includes("all") && (l.forceUpdate(), p.add(u));
-  }), g.getShadowMetadata(e, [...i, "getSelected"])?.pathComponents?.forEach((l) => {
-    h?.components?.get(l)?.forceUpdate();
+  for (const I of g)
+    I.type === "filter" ? y = y.filter(
+      ({ value: E }, u) => I.fn(E, u)
+    ) : I.type === "sort" && y.sort((E, u) => I.fn(E.value, u.value));
+  return y.map(({ key: I }) => I);
+}, Vt = (t, n, g) => {
+  const S = `${t}////${n}`, { addPathComponent: y, getShadowMetadata: I } = e.getState(), u = I(t, [])?.components?.get(S);
+  !u || u.reactiveType === "none" || !(Array.isArray(u.reactiveType) ? u.reactiveType : [u.reactiveType]).includes("component") || y(t, g, S);
+}, ft = (t, n, g) => {
+  const S = e.getState(), y = S.getShadowMetadata(t, []), I = /* @__PURE__ */ new Set();
+  y?.components && y.components.forEach((u, f) => {
+    (Array.isArray(u.reactiveType) ? u.reactiveType : [u.reactiveType || "component"]).includes("all") && (u.forceUpdate(), I.add(f));
+  }), S.getShadowMetadata(t, [...n, "getSelected"])?.pathComponents?.forEach((u) => {
+    y?.components?.get(u)?.forceUpdate();
   });
-  const M = g.getShadowMetadata(e, i);
-  for (let l of M?.arrayKeys || []) {
-    const u = l + ".selected", A = g.getShadowMetadata(
-      e,
-      u.split(".").slice(1)
+  const E = S.getShadowMetadata(t, n);
+  for (let u of E?.arrayKeys || []) {
+    const f = u + ".selected", A = S.getShadowMetadata(
+      t,
+      f.split(".").slice(1)
     );
-    l == f && A?.pathComponents?.forEach((b) => {
-      h?.components?.get(b)?.forceUpdate();
+    u == g && A?.pathComponents?.forEach((w) => {
+      y?.components?.get(w)?.forceUpdate();
     });
   }
 };
-function De(e, i, f, g) {
-  const h = /* @__PURE__ */ new Map();
-  let p = 0;
-  const M = (b) => {
-    const o = b.join(".");
-    for (const [S] of h)
-      (S === o || S.startsWith(o + ".")) && h.delete(S);
-    p++;
+function Dt(t, n, g, S) {
+  const y = /* @__PURE__ */ new Map();
+  let I = 0;
+  const E = (w) => {
+    const i = w.join(".");
+    for (const [h] of y)
+      (h === i || h.startsWith(i + ".")) && y.delete(h);
+    I++;
   };
-  function l({
-    currentState: b,
-    path: o = [],
-    meta: S,
-    componentId: T
+  function u({
+    currentState: w,
+    path: i = [],
+    meta: h,
+    componentId: M
   }) {
-    const W = o.map(String).join("."), c = [e, ...o].join(".");
-    b = t.getState().getShadowValue(c, S?.validIds);
-    const x = function() {
-      return t().getShadowValue(e, o);
-    }, Y = {
-      apply(U, v, K) {
+    const z = i.map(String).join("."), c = [t, ...i].join(".");
+    w = e.getState().getShadowValue(c, h?.validIds);
+    const B = function() {
+      return e().getShadowValue(t, i);
+    }, J = {
+      apply(W, m, Y) {
       },
-      get(U, v) {
-        if (v === "_rebuildStateShape")
-          return l;
-        if (Object.getOwnPropertyNames(u).includes(v) && o.length === 0)
-          return u[v];
-        if (v === "getDifferences")
+      get(W, m) {
+        if (m === "_rebuildStateShape")
+          return u;
+        if (Object.getOwnPropertyNames(f).includes(m) && i.length === 0)
+          return f[m];
+        if (m === "getDifferences")
           return () => {
-            const s = t.getState().getShadowMetadata(e, []), n = t.getState().getShadowValue(e);
+            const s = e.getState().getShadowMetadata(t, []), o = e.getState().getShadowValue(t);
             let r;
-            return s?.stateSource === "server" && s.baseServerState ? r = s.baseServerState : r = t.getState().initialStateGlobal[e], Pe(n, r);
+            return s?.stateSource === "server" && s.baseServerState ? r = s.baseServerState : r = e.getState().initialStateGlobal[t], Ct(o, r);
           };
-        if (v === "sync" && o.length === 0)
+        if (m === "sync" && i.length === 0)
           return async function() {
-            const s = t.getState().getInitialOptions(e), n = s?.sync;
-            if (!n)
-              return console.error(`No mutation defined for state key "${e}"`), { success: !1, error: "No mutation defined" };
-            const r = t.getState().getShadowValue(e, []), a = s?.validation?.key;
+            const s = e.getState().getInitialOptions(t), o = s?.sync;
+            if (!o)
+              return console.error(`No mutation defined for state key "${t}"`), { success: !1, error: "No mutation defined" };
+            const r = e.getState().getShadowValue(t, []), a = s?.validation?.key;
             try {
-              const d = await n.action(r);
-              if (d && !d.success && d.errors && a && (t.getState().removeValidationError(a), d.errors.forEach((w) => {
-                const m = [a, ...w.path].join(".");
-                t.getState().addValidationError(m, w.message);
-              }), ie(e)), d?.success) {
-                const w = t.getState().getShadowMetadata(e, []);
-                t.getState().setShadowMetadata(e, [], {
-                  ...w,
+              const d = await o.action(r);
+              if (d && !d.success && d.errors && a && (e.getState().removeValidationError(a), d.errors.forEach((l) => {
+                const p = [a, ...l.path].join(".");
+                e.getState().addValidationError(p, l.message);
+              }), it(t)), d?.success) {
+                const l = e.getState().getShadowMetadata(t, []);
+                e.getState().setShadowMetadata(t, [], {
+                  ...l,
                   isDirty: !1,
                   lastServerSync: Date.now(),
                   stateSource: "server",
                   baseServerState: r
                   // Update base server state
-                }), n.onSuccess && n.onSuccess(d.data);
-              } else !d?.success && n.onError && n.onError(d.error);
+                }), o.onSuccess && o.onSuccess(d.data);
+              } else !d?.success && o.onError && o.onError(d.error);
               return d;
             } catch (d) {
-              return n.onError && n.onError(d), { success: !1, error: d };
+              return o.onError && o.onError(d), { success: !1, error: d };
             }
           };
-        if (v === "_status" || v === "getStatus") {
+        if (m === "_status" || m === "getStatus") {
           const s = () => {
-            const n = t.getState().getShadowMetadata(e, o), r = t.getState().getShadowValue(c);
-            return n?.isDirty === !0 ? "dirty" : n?.isDirty === !1 || n?.stateSource === "server" ? "synced" : n?.stateSource === "localStorage" ? "restored" : n?.stateSource === "default" ? "fresh" : t.getState().getShadowMetadata(e, [])?.stateSource === "server" && !n?.isDirty ? "synced" : r !== void 0 && !n ? "fresh" : "unknown";
+            const o = e.getState().getShadowMetadata(t, i), r = e.getState().getShadowValue(c);
+            return o?.isDirty === !0 ? "dirty" : o?.isDirty === !1 || o?.stateSource === "server" ? "synced" : o?.stateSource === "localStorage" ? "restored" : o?.stateSource === "default" ? "fresh" : e.getState().getShadowMetadata(t, [])?.stateSource === "server" && !o?.isDirty ? "synced" : r !== void 0 && !o ? "fresh" : "unknown";
           };
-          return v === "_status" ? s() : s;
+          return m === "_status" ? s() : s;
         }
-        if (v === "removeStorage")
+        if (m === "removeStorage")
           return () => {
-            const s = t.getState().initialStateGlobal[e], n = ae(e), r = ee(n?.localStorage?.key) ? n.localStorage.key(s) : n?.localStorage?.key, a = `${g}-${e}-${r}`;
+            const s = e.getState().initialStateGlobal[t], o = nt(t), r = at(o?.localStorage?.key) ? o.localStorage.key(s) : o?.localStorage?.key, a = `${S}-${t}-${r}`;
             a && localStorage.removeItem(a);
           };
-        if (v === "showValidationErrors")
+        if (m === "showValidationErrors")
           return () => {
-            const s = t.getState().getInitialOptions(e)?.validation;
-            if (!s?.key) throw new Error("Validation key not found");
-            return t.getState().getValidationErrors(s.key + "." + o.join("."));
+            const s = e.getState().getShadowMetadata(t, i);
+            return s?.validation?.status === "VALIDATION_FAILED" && s.validation.message ? [s.validation.message] : [];
           };
-        if (Array.isArray(b)) {
-          if (v === "getSelected")
+        if (Array.isArray(w)) {
+          if (m === "getSelected")
             return () => {
-              const s = e + "." + o.join(".");
-              Ve(e, T, [
-                ...o,
+              const s = t + "." + i.join(".");
+              Vt(t, M, [
+                ...i,
                 "getSelected"
               ]);
-              const n = t.getState().selectedIndicesMap;
-              if (!n || !n.has(s))
+              const o = e.getState().selectedIndicesMap;
+              if (!o || !o.has(s))
                 return;
-              const r = n.get(s);
-              if (S?.validIds && !S.validIds.includes(r))
+              const r = o.get(s);
+              if (h?.validIds && !h.validIds.includes(r))
                 return;
-              const a = t.getState().getShadowValue(r);
+              const a = e.getState().getShadowValue(r);
               if (a)
-                return l({
+                return u({
                   currentState: a,
                   path: r.split(".").slice(1),
-                  componentId: T
+                  componentId: M
                 });
             };
-          if (v === "getSelectedIndex")
-            return () => t.getState().getSelectedIndex(
-              e + "." + o.join("."),
-              S?.validIds
+          if (m === "getSelectedIndex")
+            return () => e.getState().getSelectedIndex(
+              t + "." + i.join("."),
+              h?.validIds
             );
-          if (v === "clearSelected")
-            return ye(e, o), () => {
-              t.getState().clearSelectedIndex({
-                arrayKey: e + "." + o.join(".")
+          if (m === "clearSelected")
+            return ft(t, i), () => {
+              e.getState().clearSelectedIndex({
+                arrayKey: t + "." + i.join(".")
               });
             };
-          if (v === "useVirtualView")
+          if (m === "useVirtualView")
             return (s) => {
               const {
-                itemHeight: n = 50,
+                itemHeight: o = 50,
                 overscan: r = 6,
                 stickToBottom: a = !1,
                 scrollStickTolerance: d = 75
-              } = s, w = G(null), [m, P] = X({
+              } = s, l = q(null), [p, V] = K({
                 startIndex: 0,
                 endIndex: 10
-              }), [R, D] = X({}), j = G(!0), F = G({
+              }), [_, U] = K({}), C = q(!0), F = q({
                 isUserScrolling: !1,
                 lastScrollTop: 0,
                 scrollUpCount: 0,
                 isNearBottom: !0
-              }), O = G(
+              }), x = q(
                 /* @__PURE__ */ new Map()
               );
-              de(() => {
-                if (!a || !w.current || F.current.isUserScrolling)
+              dt(() => {
+                if (!a || !l.current || F.current.isUserScrolling)
                   return;
-                const I = w.current;
-                I.scrollTo({
-                  top: I.scrollHeight,
-                  behavior: j.current ? "instant" : "smooth"
+                const v = l.current;
+                v.scrollTo({
+                  top: v.scrollHeight,
+                  behavior: C.current ? "instant" : "smooth"
                 });
-              }, [R, a]);
-              const L = t.getState().getShadowMetadata(e, o)?.arrayKeys || [], { totalHeight: N, itemOffsets: B } = ge(() => {
-                let I = 0;
-                const y = /* @__PURE__ */ new Map();
-                return (t.getState().getShadowMetadata(e, o)?.arrayKeys || []).forEach((C) => {
-                  const _ = C.split(".").slice(1), q = t.getState().getShadowMetadata(e, _)?.virtualizer?.itemHeight || n;
-                  y.set(C, {
-                    height: q,
-                    offset: I
-                  }), I += q;
-                }), O.current = y, { totalHeight: I, itemOffsets: y };
-              }, [L.length, n]);
-              de(() => {
-                if (a && L.length > 0 && w.current && !F.current.isUserScrolling && j.current) {
-                  const I = w.current, y = () => {
-                    if (I.clientHeight > 0) {
-                      const k = Math.ceil(
-                        I.clientHeight / n
-                      ), C = L.length - 1, _ = Math.max(
+              }, [_, a]);
+              const N = e.getState().getShadowMetadata(t, i)?.arrayKeys || [], { totalHeight: j, itemOffsets: b } = St(() => {
+                let v = 0;
+                const T = /* @__PURE__ */ new Map();
+                return (e.getState().getShadowMetadata(t, i)?.arrayKeys || []).forEach((D) => {
+                  const R = D.split(".").slice(1), L = e.getState().getShadowMetadata(t, R)?.virtualizer?.itemHeight || o;
+                  T.set(D, {
+                    height: L,
+                    offset: v
+                  }), v += L;
+                }), x.current = T, { totalHeight: v, itemOffsets: T };
+              }, [N.length, o]);
+              dt(() => {
+                if (a && N.length > 0 && l.current && !F.current.isUserScrolling && C.current) {
+                  const v = l.current, T = () => {
+                    if (v.clientHeight > 0) {
+                      const $ = Math.ceil(
+                        v.clientHeight / o
+                      ), D = N.length - 1, R = Math.max(
                         0,
-                        C - k - r
+                        D - $ - r
                       );
-                      P({ startIndex: _, endIndex: C }), requestAnimationFrame(() => {
-                        E("instant"), j.current = !1;
+                      V({ startIndex: R, endIndex: D }), requestAnimationFrame(() => {
+                        P("instant"), C.current = !1;
                       });
                     } else
-                      requestAnimationFrame(y);
+                      requestAnimationFrame(T);
                   };
-                  y();
+                  T();
                 }
-              }, [L.length, a, n, r]);
-              const V = ce(() => {
-                const I = w.current;
-                if (!I) return;
-                const y = I.scrollTop, { scrollHeight: k, clientHeight: C } = I, _ = F.current, q = k - (y + C), H = _.isNearBottom;
-                _.isNearBottom = q <= d, y < _.lastScrollTop ? (_.scrollUpCount++, _.scrollUpCount > 3 && H && (_.isUserScrolling = !0, console.log("User scrolled away from bottom"))) : _.isNearBottom && (_.isUserScrolling = !1, _.scrollUpCount = 0), _.lastScrollTop = y;
-                let z = 0;
-                for (let Z = 0; Z < L.length; Z++) {
-                  const ue = L[Z], me = O.current.get(ue);
-                  if (me && me.offset + me.height > y) {
-                    z = Z;
+              }, [N.length, a, o, r]);
+              const k = ct(() => {
+                const v = l.current;
+                if (!v) return;
+                const T = v.scrollTop, { scrollHeight: $, clientHeight: D } = v, R = F.current, L = $ - (T + D), G = R.isNearBottom;
+                R.isNearBottom = L <= d, T < R.lastScrollTop ? (R.scrollUpCount++, R.scrollUpCount > 3 && G && (R.isUserScrolling = !0, console.log("User scrolled away from bottom"))) : R.isNearBottom && (R.isUserScrolling = !1, R.scrollUpCount = 0), R.lastScrollTop = T;
+                let tt = 0;
+                for (let et = 0; et < N.length; et++) {
+                  const ht = N[et], mt = x.current.get(ht);
+                  if (mt && mt.offset + mt.height > T) {
+                    tt = et;
                     break;
                   }
                 }
-                if (z !== m.startIndex) {
-                  const Z = Math.ceil(C / n);
-                  P({
-                    startIndex: Math.max(0, z - r),
+                if (tt !== p.startIndex) {
+                  const et = Math.ceil(D / o);
+                  V({
+                    startIndex: Math.max(0, tt - r),
                     endIndex: Math.min(
-                      L.length - 1,
-                      z + Z + r
+                      N.length - 1,
+                      tt + et + r
                     )
                   });
                 }
               }, [
-                L.length,
-                m.startIndex,
-                n,
+                N.length,
+                p.startIndex,
+                o,
                 r,
                 d
               ]);
-              Q(() => {
-                const I = w.current;
-                if (!(!I || !a))
-                  return I.addEventListener("scroll", V, {
+              Z(() => {
+                const v = l.current;
+                if (!(!v || !a))
+                  return v.addEventListener("scroll", k, {
                     passive: !0
                   }), () => {
-                    I.removeEventListener("scroll", V);
+                    v.removeEventListener("scroll", k);
                   };
-              }, [V, a]);
-              const E = ce(
-                (I = "smooth") => {
-                  const y = w.current;
-                  if (!y) return;
+              }, [k, a]);
+              const P = ct(
+                (v = "smooth") => {
+                  const T = l.current;
+                  if (!T) return;
                   F.current.isUserScrolling = !1, F.current.isNearBottom = !0, F.current.scrollUpCount = 0;
-                  const k = () => {
-                    const C = (_ = 0) => {
-                      if (_ > 5) return;
-                      const q = y.scrollHeight, H = y.scrollTop, z = y.clientHeight;
-                      H + z >= q - 1 || (y.scrollTo({
-                        top: q,
-                        behavior: I
+                  const $ = () => {
+                    const D = (R = 0) => {
+                      if (R > 5) return;
+                      const L = T.scrollHeight, G = T.scrollTop, tt = T.clientHeight;
+                      G + tt >= L - 1 || (T.scrollTo({
+                        top: L,
+                        behavior: v
                       }), setTimeout(() => {
-                        const Z = y.scrollHeight, ue = y.scrollTop;
-                        (Z !== q || ue + z < Z - 1) && C(_ + 1);
+                        const et = T.scrollHeight, ht = T.scrollTop;
+                        (et !== L || ht + tt < et - 1) && D(R + 1);
                       }, 50));
                     };
-                    C();
+                    D();
                   };
-                  "requestIdleCallback" in window ? requestIdleCallback(k, { timeout: 100 }) : requestAnimationFrame(() => {
-                    requestAnimationFrame(k);
+                  "requestIdleCallback" in window ? requestIdleCallback($, { timeout: 100 }) : requestAnimationFrame(() => {
+                    requestAnimationFrame($);
                   });
                 },
                 []
               );
-              return Q(() => {
-                if (!a || !w.current) return;
-                const I = w.current, y = F.current;
-                let k;
-                const C = () => {
-                  clearTimeout(k), k = setTimeout(() => {
-                    !y.isUserScrolling && y.isNearBottom && E(
-                      j.current ? "instant" : "smooth"
+              return Z(() => {
+                if (!a || !l.current) return;
+                const v = l.current, T = F.current;
+                let $;
+                const D = () => {
+                  clearTimeout($), $ = setTimeout(() => {
+                    !T.isUserScrolling && T.isNearBottom && P(
+                      C.current ? "instant" : "smooth"
                     );
                   }, 100);
-                }, _ = new MutationObserver(() => {
-                  y.isUserScrolling || C();
+                }, R = new MutationObserver(() => {
+                  T.isUserScrolling || D();
                 });
-                _.observe(I, {
+                R.observe(v, {
                   childList: !0,
                   subtree: !0,
                   attributes: !0,
                   attributeFilter: ["style", "class"]
                   // More specific than just 'height'
                 });
-                const q = (H) => {
-                  H.target instanceof HTMLImageElement && !y.isUserScrolling && C();
+                const L = (G) => {
+                  G.target instanceof HTMLImageElement && !T.isUserScrolling && D();
                 };
-                return I.addEventListener("load", q, !0), j.current ? setTimeout(() => {
-                  E("instant");
-                }, 0) : C(), () => {
-                  clearTimeout(k), _.disconnect(), I.removeEventListener("load", q, !0);
+                return v.addEventListener("load", L, !0), C.current ? setTimeout(() => {
+                  P("instant");
+                }, 0) : D(), () => {
+                  clearTimeout($), R.disconnect(), v.removeEventListener("load", L, !0);
                 };
-              }, [a, L.length, E]), {
-                virtualState: ge(() => {
-                  const I = t.getState(), y = I.getShadowValue(
-                    [e, ...o].join(".")
-                  ), k = I.getShadowMetadata(e, o)?.arrayKeys || [], C = y.slice(
-                    m.startIndex,
-                    m.endIndex + 1
-                  ), _ = k.slice(
-                    m.startIndex,
-                    m.endIndex + 1
+              }, [a, N.length, P]), {
+                virtualState: St(() => {
+                  const v = e.getState(), T = v.getShadowValue(
+                    [t, ...i].join(".")
+                  ), $ = v.getShadowMetadata(t, i)?.arrayKeys || [], D = T.slice(
+                    p.startIndex,
+                    p.endIndex + 1
+                  ), R = $.slice(
+                    p.startIndex,
+                    p.endIndex + 1
                   );
-                  return l({
-                    currentState: C,
-                    path: o,
-                    componentId: T,
-                    meta: { ...S, validIds: _ }
+                  return u({
+                    currentState: D,
+                    path: i,
+                    componentId: M,
+                    meta: { ...h, validIds: R }
                   });
-                }, [m.startIndex, m.endIndex, L.length]),
+                }, [p.startIndex, p.endIndex, N.length]),
                 virtualizerProps: {
                   outer: {
-                    ref: w,
+                    ref: l,
                     style: {
                       overflowY: "auto",
                       height: "100%",
@@ -900,100 +898,100 @@ function De(e, i, f, g) {
                   },
                   inner: {
                     style: {
-                      height: `${N}px`,
+                      height: `${j}px`,
                       position: "relative"
                     }
                   },
                   list: {
                     style: {
-                      transform: `translateY(${O.current.get(
-                        L[m.startIndex]
+                      transform: `translateY(${x.current.get(
+                        N[p.startIndex]
                       )?.offset || 0}px)`
                     }
                   }
                 },
-                scrollToBottom: E,
-                scrollToIndex: (I, y = "smooth") => {
-                  if (w.current && L[I]) {
-                    const k = O.current.get(L[I])?.offset || 0;
-                    w.current.scrollTo({ top: k, behavior: y });
+                scrollToBottom: P,
+                scrollToIndex: (v, T = "smooth") => {
+                  if (l.current && N[v]) {
+                    const $ = x.current.get(N[v])?.offset || 0;
+                    l.current.scrollTo({ top: $, behavior: T });
                   }
                 }
               };
             };
-          if (v === "stateMap")
+          if (m === "stateMap")
             return (s) => {
-              const [n, r] = X(
-                S?.validIds ?? t.getState().getShadowMetadata(e, o)?.arrayKeys
-              ), a = t.getState().getShadowValue(c, S?.validIds);
-              if (!n)
+              const [o, r] = K(
+                h?.validIds ?? e.getState().getShadowMetadata(t, i)?.arrayKeys
+              ), a = e.getState().getShadowValue(c, h?.validIds);
+              if (!o)
                 throw new Error("No array keys found for mapping");
-              const d = l({
+              const d = u({
                 currentState: a,
-                path: o,
-                componentId: T,
-                meta: S
+                path: i,
+                componentId: M,
+                meta: h
               });
-              return a.map((w, m) => {
-                const P = n[m]?.split(".").slice(1), R = l({
-                  currentState: w,
-                  path: P,
-                  componentId: T,
-                  meta: S
+              return a.map((l, p) => {
+                const V = o[p]?.split(".").slice(1), _ = u({
+                  currentState: l,
+                  path: V,
+                  componentId: M,
+                  meta: h
                 });
                 return s(
-                  R,
-                  m,
+                  _,
+                  p,
                   d
                 );
               });
             };
-          if (v === "$stateMap")
-            return (s) => le(Ge, {
+          if (m === "$stateMap")
+            return (s) => lt(qt, {
               proxy: {
-                _stateKey: e,
-                _path: o,
+                _stateKey: t,
+                _path: i,
                 _mapFn: s,
-                _meta: S
+                _meta: h
               },
-              rebuildStateShape: l
+              rebuildStateShape: u
             });
-          if (v === "stateFind")
+          if (m === "stateFind")
             return (s) => {
-              const n = S?.validIds ?? t.getState().getShadowMetadata(e, o)?.arrayKeys;
-              if (n)
-                for (let r = 0; r < n.length; r++) {
-                  const a = n[r];
+              const o = h?.validIds ?? e.getState().getShadowMetadata(t, i)?.arrayKeys;
+              if (o)
+                for (let r = 0; r < o.length; r++) {
+                  const a = o[r];
                   if (!a) continue;
-                  const d = t.getState().getShadowValue(a);
+                  const d = e.getState().getShadowValue(a);
                   if (s(d, r)) {
-                    const w = a.split(".").slice(1);
-                    return l({
+                    const l = a.split(".").slice(1);
+                    return u({
                       currentState: d,
-                      path: w,
-                      componentId: T,
-                      meta: S
+                      path: l,
+                      componentId: M,
+                      meta: h
                       // Pass along meta for potential further chaining
                     });
                   }
                 }
             };
-          if (v === "stateFilter")
+          if (m === "stateFilter")
             return (s) => {
-              const n = S?.validIds ?? t.getState().getShadowMetadata(e, o)?.arrayKeys;
-              if (!n)
+              const o = h?.validIds ?? e.getState().getShadowMetadata(t, i)?.arrayKeys;
+              if (!o)
                 throw new Error("No array keys found for filtering.");
-              const r = [], a = b.filter(
-                (d, w) => s(d, w) ? (r.push(n[w]), !0) : !1
+              const r = [], a = w.filter(
+                (d, l) => s(d, l) ? (r.push(o[l]), !0) : !1
               );
-              return l({
+              return u({
                 currentState: a,
-                path: o,
-                componentId: T,
+                path: i,
+                componentId: M,
                 meta: {
                   validIds: r,
                   transforms: [
-                    ...S?.transforms || [],
+                    ...h?.transforms || [],
                     {
                       type: "filter",
                       fn: s
@@ -1002,422 +1000,458 @@ function De(e, i, f, g) {
                 }
               });
             };
-          if (v === "stateSort")
+          if (m === "stateSort")
             return (s) => {
-              const n = S?.validIds ?? t.getState().getShadowMetadata(e, o)?.arrayKeys;
-              if (!n)
+              const o = h?.validIds ?? e.getState().getShadowMetadata(t, i)?.arrayKeys;
+              if (!o)
                 throw new Error("No array keys found for sorting");
-              const r = b.map((a, d) => ({
+              const r = w.map((a, d) => ({
                 item: a,
-                key: n[d]
+                key: o[d]
               }));
-              return r.sort((a, d) => s(a.item, d.item)).filter(Boolean), l({
+              return r.sort((a, d) => s(a.item, d.item)).filter(Boolean), u({
                 currentState: r.map((a) => a.item),
-                path: o,
-                componentId: T,
+                path: i,
+                componentId: M,
                 meta: {
                   validIds: r.map((a) => a.key),
                   transforms: [
-                    ...S?.transforms || [],
+                    ...h?.transforms || [],
                     { type: "sort", fn: s }
                   ]
                 }
               });
             };
-          if (v === "stream")
+          if (m === "stream")
             return function(s = {}) {
               const {
-                bufferSize: n = 100,
+                bufferSize: o = 100,
                 flushInterval: r = 100,
                 bufferStrategy: a = "accumulate",
                 store: d,
-                onFlush: w
+                onFlush: l
               } = s;
-              let m = [], P = !1, R = null;
-              const D = (N) => {
-                if (!P) {
-                  if (a === "sliding" && m.length >= n)
-                    m.shift();
-                  else if (a === "dropping" && m.length >= n)
+              let p = [], V = !1, _ = null;
+              const U = (j) => {
+                if (!V) {
+                  if (a === "sliding" && p.length >= o)
+                    p.shift();
+                  else if (a === "dropping" && p.length >= o)
                     return;
-                  m.push(N), m.length >= n && j();
+                  p.push(j), p.length >= o && C();
                 }
-              }, j = () => {
-                if (m.length === 0) return;
-                const N = [...m];
-                if (m = [], d) {
-                  const B = d(N);
-                  B !== void 0 && (Array.isArray(B) ? B : [B]).forEach((E) => {
-                    i(E, o, {
+              }, C = () => {
+                if (p.length === 0) return;
+                const j = [...p];
+                if (p = [], d) {
+                  const b = d(j);
+                  b !== void 0 && (Array.isArray(b) ? b : [b]).forEach((P) => {
+                    n(P, i, {
                       updateType: "insert"
                     });
                   });
                 } else
-                  N.forEach((B) => {
-                    i(B, o, {
+                  j.forEach((b) => {
+                    n(b, i, {
                       updateType: "insert"
                     });
                   });
-                w?.(N);
+                l?.(j);
               };
-              r > 0 && (R = setInterval(j, r));
-              const F = te(), O = t.getState().getShadowMetadata(e, o) || {}, L = O.streams || /* @__PURE__ */ new Map();
-              return L.set(F, { buffer: m, flushTimer: R }), t.getState().setShadowMetadata(e, o, {
-                ...O,
-                streams: L
+              r > 0 && (_ = setInterval(C, r));
+              const F = rt(), x = e.getState().getShadowMetadata(t, i) || {}, N = x.streams || /* @__PURE__ */ new Map();
+              return N.set(F, { buffer: p, flushTimer: _ }), e.getState().setShadowMetadata(t, i, {
+                ...x,
+                streams: N
               }), {
-                write: (N) => D(N),
-                writeMany: (N) => N.forEach(D),
-                flush: () => j(),
+                write: (j) => U(j),
+                writeMany: (j) => j.forEach(U),
+                flush: () => C(),
                 pause: () => {
-                  P = !0;
+                  V = !0;
                 },
                 resume: () => {
-                  P = !1, m.length > 0 && j();
+                  V = !1, p.length > 0 && C();
                 },
                 close: () => {
-                  j(), R && clearInterval(R);
-                  const N = t.getState().getShadowMetadata(e, o);
-                  N?.streams && N.streams.delete(F);
+                  C(), _ && clearInterval(_);
+                  const j = e.getState().getShadowMetadata(t, i);
+                  j?.streams && j.streams.delete(F);
                 }
               };
             };
-          if (v === "stateList")
-            return (s) => /* @__PURE__ */ re(() => {
-              const r = G(/* @__PURE__ */ new Map()), a = S?.transforms && S.transforms.length > 0 ? `${T}-${qe(S.transforms)}` : `${T}-base`, [d, w] = X({}), { validIds: m, arrayValues: P } = ge(() => {
-                const D = t.getState().getShadowMetadata(e, o)?.transformCaches?.get(a);
-                let j;
-                D && D.validIds ? j = D.validIds : (j = Ie(
-                  e,
-                  o,
-                  S?.transforms
-                ), t.getState().setTransformCache(e, o, a, {
-                  validIds: j,
+          if (m === "stateList")
+            return (s) => /* @__PURE__ */ ot(() => {
+              const r = q(/* @__PURE__ */ new Map()), a = h?.transforms && h.transforms.length > 0 ? `${M}-${Bt(h.transforms)}` : `${M}-base`, [d, l] = K({}), { validIds: p, arrayValues: V } = St(() => {
+                const U = e.getState().getShadowMetadata(t, i)?.transformCaches?.get(a);
+                let C;
+                U && U.validIds ? C = U.validIds : (C = It(
+                  t,
+                  i,
+                  h?.transforms
+                ), e.getState().setTransformCache(t, i, a, {
+                  validIds: C,
                   computedAt: Date.now(),
-                  transforms: S?.transforms || []
+                  transforms: h?.transforms || []
                 }));
-                const F = t.getState().getShadowValue(c, j);
+                const F = e.getState().getShadowValue(c, C);
                 return {
-                  validIds: j,
+                  validIds: C,
                   arrayValues: F || []
                 };
               }, [a, d]);
-              if (console.log("freshValues", m, P), Q(() => {
-                const D = t.getState().subscribeToPath(c, (j) => {
-                  if (j.type === "GET_SELECTED")
+              if (Z(() => {
+                const U = e.getState().subscribeToPath(c, (C) => {
+                  if (C.type === "GET_SELECTED")
                     return;
-                  const O = t.getState().getShadowMetadata(e, o)?.transformCaches;
-                  if (O)
-                    for (const L of O.keys())
-                      L.startsWith(T) && O.delete(L);
-                  (j.type === "INSERT" || j.type === "REMOVE" || j.type === "CLEAR_SELECTION") && (console.log("sssssssssssssssssssssssssssss", j), w({}));
+                  const x = e.getState().getShadowMetadata(t, i)?.transformCaches;
+                  if (x)
+                    for (const N of x.keys())
+                      N.startsWith(M) && x.delete(N);
+                  (C.type === "INSERT" || C.type === "REMOVE" || C.type === "CLEAR_SELECTION") && l({});
                 });
                 return () => {
-                  D();
+                  U();
                 };
-              }, [T, c]), !Array.isArray(P))
+              }, [M, c]), !Array.isArray(V))
                 return null;
-              const R = l({
-                currentState: P,
-                path: o,
-                componentId: T,
+              const _ = u({
+                currentState: V,
+                path: i,
+                componentId: M,
                 meta: {
-                  ...S,
-                  validIds: m
+                  ...h,
+                  validIds: p
                 }
               });
-              return console.log("sssssssssssssssssssssssssssss", R), /* @__PURE__ */ re(ke, { children: P.map((D, j) => {
-                const F = m[j];
+              return /* @__PURE__ */ ot(Ut, { children: V.map((U, C) => {
+                const F = p[C];
                 if (!F)
                   return null;
-                let O = r.current.get(F);
-                O || (O = te(), r.current.set(F, O));
-                const L = F.split(".").slice(1);
-                return le(Me, {
+                let x = r.current.get(F);
+                x || (x = rt(), r.current.set(F, x));
+                const N = F.split(".").slice(1);
+                return lt(Mt, {
                   key: F,
-                  stateKey: e,
-                  itemComponentId: O,
-                  itemPath: L,
-                  localIndex: j,
-                  arraySetter: R,
-                  rebuildStateShape: l,
+                  stateKey: t,
+                  itemComponentId: x,
+                  itemPath: N,
+                  localIndex: C,
+                  arraySetter: _,
+                  rebuildStateShape: u,
                   renderFn: s
                 });
               }) });
             }, {});
-          if (v === "stateFlattenOn")
+          if (m === "stateFlattenOn")
             return (s) => {
-              const n = b;
-              h.clear(), p++;
-              const r = n.flatMap(
+              const o = w;
+              y.clear(), I++;
+              const r = o.flatMap(
                 (a) => a[s] ?? []
               );
-              return l({
+              return u({
                 currentState: r,
-                path: [...o, "[*]", s],
-                componentId: T,
-                meta: S
+                path: [...i, "[*]", s],
+                componentId: M,
+                meta: h
               });
             };
-          if (v === "index")
+          if (m === "index")
             return (s) => {
-              const r = t.getState().getShadowMetadata(e, o)?.arrayKeys?.filter(
-                (w) => !S?.validIds || S?.validIds && S?.validIds?.includes(w)
+              const r = e.getState().getShadowMetadata(t, i)?.arrayKeys?.filter(
+                (l) => !h?.validIds || h?.validIds && h?.validIds?.includes(l)
               )?.[s];
               if (!r) return;
-              const a = t.getState().getShadowValue(r, S?.validIds);
-              return l({
+              const a = e.getState().getShadowValue(r, h?.validIds);
+              return u({
                 currentState: a,
                 path: r.split(".").slice(1),
-                componentId: T,
-                meta: S
+                componentId: M,
+                meta: h
               });
             };
-          if (v === "last")
+          if (m === "last")
             return () => {
-              const s = t.getState().getShadowValue(e, o);
+              const s = e.getState().getShadowValue(t, i);
               if (s.length === 0) return;
-              const n = s.length - 1, r = s[n], a = [...o, n.toString()];
-              return l({
+              const o = s.length - 1, r = s[o], a = [...i, o.toString()];
+              return u({
                 currentState: r,
                 path: a,
-                componentId: T,
-                meta: S
+                componentId: M,
+                meta: h
               });
             };
-          if (v === "insert")
-            return (s, n) => (i(s, o, { updateType: "insert" }), l({
-              currentState: t.getState().getShadowValue(e, o),
-              path: o,
-              componentId: T,
-              meta: S
+          if (m === "insert")
+            return (s, o) => (n(s, i, { updateType: "insert" }), u({
+              currentState: e.getState().getShadowValue(t, i),
+              path: i,
+              componentId: M,
+              meta: h
             }));
-          if (v === "uniqueInsert")
-            return (s, n, r) => {
-              const a = t.getState().getShadowValue(e, o), d = ee(s) ? s(a) : s;
-              let w = null;
-              if (!a.some((P) => {
-                const R = n ? n.every(
-                  (D) => se(P[D], d[D])
-                ) : se(P, d);
-                return R && (w = P), R;
+          if (m === "uniqueInsert")
+            return (s, o, r) => {
+              const a = e.getState().getShadowValue(t, i), d = at(s) ? s(a) : s;
+              let l = null;
+              if (!a.some((V) => {
+                const _ = o ? o.every(
+                  (U) => st(V[U], d[U])
+                ) : st(V, d);
+                return _ && (l = V), _;
               }))
-                M(o), i(d, o, { updateType: "insert" });
-              else if (r && w) {
-                const P = r(w), R = a.map(
-                  (D) => se(D, w) ? P : D
+                E(i), n(d, i, { updateType: "insert" });
+              else if (r && l) {
+                const V = r(l), _ = a.map(
+                  (U) => st(U, l) ? V : U
                 );
-                M(o), i(R, o, {
+                E(i), n(_, i, {
                   updateType: "update"
                 });
               }
             };
-          if (v === "cut")
-            return (s, n) => {
-              const r = S?.validIds ?? t.getState().getShadowMetadata(e, o)?.arrayKeys;
+          if (m === "cut")
+            return (s, o) => {
+              const r = h?.validIds ?? e.getState().getShadowMetadata(t, i)?.arrayKeys;
               if (!r || r.length === 0) return;
               const a = s == -1 ? r.length - 1 : s !== void 0 ? s : r.length - 1, d = r[a];
               if (!d) return;
-              const w = d.split(".").slice(1);
-              i(b, w, {
+              const l = d.split(".").slice(1);
+              n(w, l, {
                 updateType: "cut"
               });
             };
-          if (v === "cutSelected")
+          if (m === "cutSelected")
             return () => {
-              t.getState().getShadowMetadata(e, o)?.arrayKeys;
-              const s = Ie(
-                e,
-                o,
-                S?.transforms
+              const s = It(
+                t,
+                i,
+                h?.transforms
               );
-              if (console.log("validKeys", s), !s || s.length === 0) return;
-              const n = t.getState().selectedIndicesMap.get(c);
+              if (!s || s.length === 0) return;
+              const o = e.getState().selectedIndicesMap.get(c);
               let r = s.findIndex(
-                (d) => d === n
+                (l) => l === o
               );
-              console.log("indexToCut", r);
               const a = s[r == -1 ? s.length - 1 : r]?.split(".").slice(1);
-              console.log("pathForCut", a), i(b, a, {
+              e.getState().clearSelectedIndex({ arrayKey: c });
+              const d = a?.slice(0, -1);
+              ft(t, d), n(w, a, {
                 updateType: "cut"
               });
             };
-          if (v === "cutByValue")
+          if (m === "cutByValue")
             return (s) => {
-              const n = t.getState().getShadowMetadata(e, o), r = S?.validIds ?? n?.arrayKeys;
+              const o = e.getState().getShadowMetadata(t, i), r = h?.validIds ?? o?.arrayKeys;
               if (!r) return;
               let a = null;
               for (const d of r)
-                if (t.getState().getShadowValue(d) === s) {
+                if (e.getState().getShadowValue(d) === s) {
                   a = d;
                   break;
                 }
               if (a) {
                 const d = a.split(".").slice(1);
-                i(null, d, { updateType: "cut" });
+                n(null, d, { updateType: "cut" });
               }
             };
-          if (v === "toggleByValue")
+          if (m === "toggleByValue")
             return (s) => {
-              const n = t.getState().getShadowMetadata(e, o), r = S?.validIds ?? n?.arrayKeys;
+              const o = e.getState().getShadowMetadata(t, i), r = h?.validIds ?? o?.arrayKeys;
               if (!r) return;
               let a = null;
               for (const d of r) {
-                const w = t.getState().getShadowValue(d);
-                if (console.log("itemValue sdasdasdasd", w), w === s) {
+                const l = e.getState().getShadowValue(d);
+                if (console.log("itemValue sdasdasdasd", l), l === s) {
                   a = d;
                   break;
                 }
               }
               if (console.log("itemValue keyToCut", a), a) {
                 const d = a.split(".").slice(1);
-                console.log("itemValue keyToCut", a), i(s, d, {
+                console.log("itemValue keyToCut", a), n(s, d, {
                   updateType: "cut"
                 });
               } else
-                i(s, o, { updateType: "insert" });
+                n(s, i, { updateType: "insert" });
             };
-          if (v === "findWith")
-            return (s, n) => {
-              const r = t.getState().getShadowMetadata(e, o)?.arrayKeys;
+          if (m === "findWith")
+            return (s, o) => {
+              const r = e.getState().getShadowMetadata(t, i)?.arrayKeys;
               if (!r)
                 throw new Error("No array keys found for sorting");
               let a = null, d = [];
-              for (const w of r) {
-                let m = t.getState().getShadowValue(w, S?.validIds);
-                if (m && m[s] === n) {
-                  a = m, d = w.split(".").slice(1);
+              for (const l of r) {
+                let p = e.getState().getShadowValue(l, h?.validIds);
+                if (p && p[s] === o) {
+                  a = p, d = l.split(".").slice(1);
                   break;
                 }
               }
-              return l({
+              return u({
                 currentState: a,
                 path: d,
-                componentId: T,
-                meta: S
+                componentId: M,
+                meta: h
               });
             };
         }
-        if (v === "cut") {
-          let s = t.getState().getShadowValue(o.join("."));
+        if (m === "cut") {
+          let s = e.getState().getShadowValue(i.join("."));
           return () => {
-            i(s, o, { updateType: "cut" });
+            n(s, i, { updateType: "cut" });
           };
         }
-        if (v === "get")
-          return () => (Ve(e, T, o), t.getState().getShadowValue(c, S?.validIds));
-        if (v === "$derive")
-          return (s) => Ae({
-            _stateKey: e,
-            _path: o,
+        if (m === "get")
+          return () => (Vt(t, M, i), e.getState().getShadowValue(c, h?.validIds));
+        if (m === "getState")
+          return () => e.getState().getShadowValue(c, h?.validIds);
+        if (m === "$derive")
+          return (s) => bt({
+            _stateKey: t,
+            _path: i,
             _effect: s.toString(),
-            _meta: S
+            _meta: h
           });
-        if (v === "$get")
-          return () => Ae({ _stateKey: e, _path: o, _meta: S });
-        if (v === "lastSynced") {
-          const s = `${e}:${o.join(".")}`;
-          return t.getState().getSyncInfo(s);
+        if (m === "$get")
+          return () => bt({ _stateKey: t, _path: i, _meta: h });
+        if (m === "lastSynced") {
+          const s = `${t}:${i.join(".")}`;
+          return e.getState().getSyncInfo(s);
         }
-        if (v == "getLocalStorage")
-          return (s) => Se(g + "-" + e + "-" + s);
-        if (v === "isSelected") {
-          const s = [e, ...o].slice(0, -1);
-          if (ye(e, o, void 0), Array.isArray(
-            t.getState().getShadowValue(s.join("."), S?.validIds)
+        if (m == "getLocalStorage")
+          return (s) => gt(S + "-" + t + "-" + s);
+        if (m === "isSelected") {
+          const s = [t, ...i].slice(0, -1);
+          if (ft(t, i, void 0), Array.isArray(
+            e.getState().getShadowValue(s.join("."), h?.validIds)
           )) {
-            o[o.length - 1];
-            const n = s.join("."), r = t.getState().selectedIndicesMap.get(n), a = e + "." + o.join(".");
+            i[i.length - 1];
+            const o = s.join("."), r = e.getState().selectedIndicesMap.get(o), a = t + "." + i.join(".");
             return r === a;
           }
           return;
         }
-        if (v === "setSelected")
+        if (m === "setSelected")
           return (s) => {
-            const n = o.slice(0, -1), r = e + "." + n.join("."), a = e + "." + o.join(".");
-            ye(e, n, void 0), t.getState().selectedIndicesMap.get(r), s && t.getState().setSelectedIndex(r, a);
+            const o = i.slice(0, -1), r = t + "." + o.join("."), a = t + "." + i.join(".");
+            ft(t, o, void 0), e.getState().selectedIndicesMap.get(r), s && e.getState().setSelectedIndex(r, a);
           };
-        if (v === "toggleSelected")
+        if (m === "toggleSelected")
           return () => {
-            const s = o.slice(0, -1), n = e + "." + s.join("."), r = e + "." + o.join(".");
-            t.getState().selectedIndicesMap.get(n) === r ? t.getState().clearSelectedIndex({ arrayKey: n }) : t.getState().setSelectedIndex(n, r);
+            const s = i.slice(0, -1), o = t + "." + s.join("."), r = t + "." + i.join(".");
+            e.getState().selectedIndicesMap.get(o) === r ? e.getState().clearSelectedIndex({ arrayKey: o }) : e.getState().setSelectedIndex(o, r);
           };
-        if (v === "_componentId")
-          return T;
-        if (o.length == 0) {
-          if (v === "addValidation")
+        if (m === "_componentId")
+          return M;
+        if (i.length == 0) {
+          if (m === "addValidation")
             return (s) => {
-              const n = t.getState().getInitialOptions(e)?.validation;
-              if (!n?.key) throw new Error("Validation key not found");
-              ne(n.key), s.forEach((r) => {
-                const a = [n.key, ...r.path].join(".");
-                ve(a, r.message);
-              }), ie(e);
+              const o = e.getState().getInitialOptions(t)?.validation;
+              if (!o?.key) throw new Error("Validation key not found");
+              ut(o.key), s.forEach((r) => {
+                const a = [o.key, ...r.path].join(".");
+                pt(a, r.message);
+              }), it(t);
             };
-          if (v === "applyJsonPatch")
+          if (m === "applyJsonPatch")
             return (s) => {
-              const n = t.getState(), r = (a) => !a || a === "/" ? [] : a.split("/").slice(1).map((d) => d.replace(/~1/g, "/").replace(/~0/g, "~"));
-              for (const a of s) {
-                const d = r(a.path);
-                switch (a.op) {
+              const o = e.getState(), r = o.getShadowMetadata(t, []);
+              if (!r?.components) return;
+              const a = (l) => !l || l === "/" ? [] : l.split("/").slice(1).map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~")), d = /* @__PURE__ */ new Set();
+              for (const l of s) {
+                const p = a(l.path);
+                switch (l.op) {
                   case "add":
                   case "replace": {
-                    const { value: w } = a;
-                    n.updateShadowAtPath(e, d, w), n.markAsDirty(e, d, { bubble: !0 });
+                    const { value: V } = l;
+                    o.updateShadowAtPath(t, p, V), o.markAsDirty(t, p, { bubble: !0 });
+                    let _ = [...p];
+                    for (; ; ) {
+                      const U = o.getShadowMetadata(
+                        t,
+                        _
+                      );
+                      if (console.log("pathMeta", U), U?.pathComponents && U.pathComponents.forEach((C) => {
+                        if (!d.has(C)) {
+                          const F = r.components?.get(C);
+                          F && (F.forceUpdate(), d.add(C));
+                        }
+                      }), _.length === 0) break;
+                      _.pop();
+                    }
                     break;
                   }
                   case "remove": {
-                    n.removeShadowArrayElement(e, d);
-                    const w = d.slice(0, -1);
-                    n.markAsDirty(e, w, { bubble: !0 });
+                    const V = p.slice(0, -1);
+                    o.removeShadowArrayElement(t, p), o.markAsDirty(t, V, { bubble: !0 });
+                    let _ = [...V];
+                    for (; ; ) {
+                      const U = o.getShadowMetadata(
+                        t,
+                        _
+                      );
+                      if (U?.pathComponents && U.pathComponents.forEach((C) => {
+                        if (!d.has(C)) {
+                          const F = r.components?.get(C);
+                          F && (F.forceUpdate(), d.add(C));
+                        }
+                      }), _.length === 0) break;
+                      _.pop();
+                    }
                     break;
                   }
                 }
               }
             };
-          if (v === "validateZodSchema")
+          if (m === "validateZodSchema")
             return () => {
-              const s = t.getState().getInitialOptions(e)?.validation;
-              if (!s?.zodSchema || !s?.key)
-                throw new Error("Zod schema or validation key not found");
-              ne(s.key);
-              const n = t.getState().getShadowValue(e), r = s.zodSchema.safeParse(n);
-              return r.success ? !0 : (r.error.errors.forEach((a) => {
-                const d = [s.key, ...a.path].join(".");
-                ve(d, a.message);
-              }), ie(e), !1);
+              const s = e.getState().getInitialOptions(t)?.validation, o = s?.zodSchemaV4 || s?.zodSchemaV3;
+              if (!o || !s?.key)
+                throw new Error(
+                  "Zod schema (v3 or v4) or validation key not found"
+                );
+              ut(s.key);
+              const r = e.getState().getShadowValue(t), a = o.safeParse(r);
+              return a.success ? !0 : ("issues" in a.error ? a.error.issues.forEach((d) => {
+                const l = [s.key, ...d.path].join(".");
+                pt(l, d.message);
+              }) : a.error.errors.forEach((d) => {
+                const l = [s.key, ...d.path].join(".");
+                pt(l, d.message);
+              }), it(t), !1);
             };
-          if (v === "getComponents")
-            return () => t.getState().getShadowMetadata(e, [])?.components;
-          if (v === "getAllFormRefs")
-            return () => pe.getState().getFormRefsByStateKey(e);
+          if (m === "getComponents")
+            return () => e.getState().getShadowMetadata(t, [])?.components;
+          if (m === "getAllFormRefs")
+            return () => vt.getState().getFormRefsByStateKey(t);
         }
-        if (v === "getFormRef")
-          return () => pe.getState().getFormRef(e + "." + o.join("."));
-        if (v === "validationWrapper")
+        if (m === "getFormRef")
+          return () => vt.getState().getFormRef(t + "." + i.join("."));
+        if (m === "validationWrapper")
           return ({
             children: s,
-            hideMessage: n
-          }) => /* @__PURE__ */ re(
-            be,
+            hideMessage: o
+          }) => /* @__PURE__ */ ot(
+            kt,
             {
-              formOpts: n ? { validation: { message: "" } } : void 0,
-              path: o,
-              stateKey: e,
+              formOpts: o ? { validation: { message: "" } } : void 0,
+              path: i,
+              stateKey: t,
               children: s
             }
           );
-        if (v === "_stateKey") return e;
-        if (v === "_path") return o;
-        if (v === "update")
-          return (s) => (i(s, o, { updateType: "update" }), {
+        if (m === "_stateKey") return t;
+        if (m === "_path") return i;
+        if (m === "update")
+          return (s) => (n(s, i, { updateType: "update" }), {
             /**
              * Marks this specific item, which was just updated, as 'synced' (not dirty).
              */
             synced: () => {
-              const n = t.getState().getShadowMetadata(e, o);
-              t.getState().setShadowMetadata(e, o, {
-                ...n,
+              const o = e.getState().getShadowMetadata(t, i);
+              e.getState().setShadowMetadata(t, i, {
+                ...o,
                 isDirty: !1,
                 // EXPLICITLY set to false, not just undefined
                 stateSource: "server",
@@ -1425,385 +1459,462 @@ function De(e, i, f, g) {
                 lastServerSync: Date.now()
                 // Add timestamp
               });
-              const r = [e, ...o].join(".");
-              t.getState().notifyPathSubscribers(r, {
+              const r = [t, ...i].join(".");
+              e.getState().notifyPathSubscribers(r, {
                 type: "SYNC_STATUS_CHANGE",
                 isDirty: !1
               });
             }
           });
-        if (v === "toggle") {
-          const s = t.getState().getShadowValue([e, ...o].join("."));
-          if (console.log("currentValueAtPath", s), typeof b != "boolean")
+        if (m === "toggle") {
+          const s = e.getState().getShadowValue([t, ...i].join("."));
+          if (console.log("currentValueAtPath", s), typeof w != "boolean")
             throw new Error("toggle() can only be used on boolean values");
           return () => {
-            i(!s, o, {
+            n(!s, i, {
               updateType: "update"
             });
           };
         }
-        if (v === "formElement")
-          return (s, n) => /* @__PURE__ */ re(
-            be,
+        if (m === "formElement")
+          return (s, o) => /* @__PURE__ */ ot(
+            Zt,
             {
-              formOpts: n,
-              path: o,
-              stateKey: e,
-              children: /* @__PURE__ */ re(
-                Ze,
-                {
-                  stateKey: e,
-                  path: o,
-                  rebuildStateShape: l,
-                  setState: i,
-                  formOpts: n,
-                  renderFn: s
-                }
-              )
+              stateKey: t,
+              path: i,
+              rebuildStateShape: u,
+              setState: n,
+              formOpts: o,
+              renderFn: s
             }
           );
-        const oe = [...o, v], fe = t.getState().getShadowValue(e, oe);
-        return l({
-          currentState: fe,
-          path: oe,
-          componentId: T,
-          meta: S
+        const Q = [...i, m], X = e.getState().getShadowValue(t, Q);
+        return u({
+          currentState: X,
+          path: Q,
+          componentId: M,
+          meta: h
         });
       }
-    }, J = new Proxy(x, Y);
-    return h.set(W, {
-      proxy: J,
-      stateVersion: p
-    }), J;
+    }, H = new Proxy(B, J);
+    return y.set(z, {
+      proxy: H,
+      stateVersion: I
+    }), H;
   }
-  const u = {
-    removeValidation: (b) => {
-      b?.validationKey && ne(b.validationKey);
+  const f = {
+    removeValidation: (w) => {
+      w?.validationKey && ut(w.validationKey);
     },
-    revertToInitialState: (b) => {
-      const o = t.getState().getInitialOptions(e)?.validation;
-      o?.key && ne(o.key), b?.validationKey && ne(b.validationKey);
-      const S = t.getState().getShadowMetadata(e, []);
-      S?.stateSource === "server" && S.baseServerState ? S.baseServerState : t.getState().initialStateGlobal[e];
-      const T = t.getState().initialStateGlobal[e];
-      t.getState().clearSelectedIndexesForState(e), h.clear(), p++, t.getState().initializeShadowState(e, T), l({
-        currentState: T,
+    revertToInitialState: (w) => {
+      const i = e.getState().getInitialOptions(t)?.validation;
+      i?.key && ut(i.key), w?.validationKey && ut(w.validationKey);
+      const h = e.getState().getShadowMetadata(t, []);
+      h?.stateSource === "server" && h.baseServerState ? h.baseServerState : e.getState().initialStateGlobal[t];
+      const M = e.getState().initialStateGlobal[t];
+      e.getState().clearSelectedIndexesForState(t), y.clear(), I++, e.getState().initializeShadowState(t, M), u({
+        currentState: M,
         path: [],
-        componentId: f
+        componentId: g
       });
-      const W = ae(e), c = ee(W?.localStorage?.key) ? W?.localStorage?.key(T) : W?.localStorage?.key, x = `${g}-${e}-${c}`;
-      x && localStorage.removeItem(x);
-      const Y = t.getState().getShadowMetadata(e, []);
-      return Y && Y?.components?.forEach((J) => {
-        J.forceUpdate();
-      }), T;
+      const z = nt(t), c = at(z?.localStorage?.key) ? z?.localStorage?.key(M) : z?.localStorage?.key, B = `${S}-${t}-${c}`;
+      B && localStorage.removeItem(B);
+      const J = e.getState().getShadowMetadata(t, []);
+      return J && J?.components?.forEach((H) => {
+        H.forceUpdate();
+      }), M;
     },
-    updateInitialState: (b) => {
-      h.clear(), p++;
-      const o = De(
-        e,
-        i,
-        f,
-        g
-      ), S = t.getState().initialStateGlobal[e], T = ae(e), W = ee(T?.localStorage?.key) ? T?.localStorage?.key(S) : T?.localStorage?.key, c = `${g}-${e}-${W}`;
-      return localStorage.getItem(c) && localStorage.removeItem(c), je(() => {
-        $e(e, b), t.getState().initializeShadowState(e, b);
-        const x = t.getState().getShadowMetadata(e, []);
-        x && x?.components?.forEach((Y) => {
-          Y.forceUpdate();
+    updateInitialState: (w) => {
+      y.clear(), I++;
+      const i = Dt(
+        t,
+        n,
+        g,
+        S
+      ), h = e.getState().initialStateGlobal[t], M = nt(t), z = at(M?.localStorage?.key) ? M?.localStorage?.key(h) : M?.localStorage?.key, c = `${S}-${t}-${z}`;
+      return localStorage.getItem(c) && localStorage.removeItem(c), Rt(() => {
+        _t(t, w), e.getState().initializeShadowState(t, w);
+        const B = e.getState().getShadowMetadata(t, []);
+        B && B?.components?.forEach((J) => {
+          J.forceUpdate();
         });
       }), {
-        fetchId: (x) => o.get()[x]
+        fetchId: (B) => i.get()[B]
       };
     }
   };
-  return l({
-    currentState: t.getState().getShadowValue(e, []),
-    componentId: f,
+  return u({
+    currentState: e.getState().getShadowValue(t, []),
+    componentId: g,
     path: []
   });
 }
-function Ae(e) {
-  return le(ze, { proxy: e });
+function bt(t) {
+  return lt(Gt, { proxy: t });
 }
-function Ge({
-  proxy: e,
-  rebuildStateShape: i
+function qt({
+  proxy: t,
+  rebuildStateShape: n
 }) {
-  const f = G(null), g = G(`map-${crypto.randomUUID()}`), h = G(!1), p = G(/* @__PURE__ */ new Map());
-  Q(() => {
-    const l = f.current;
-    if (!l || h.current) return;
-    const u = setTimeout(() => {
-      const A = t.getState().getShadowMetadata(e._stateKey, e._path) || {}, b = A.mapWrappers || [];
-      b.push({
-        instanceId: g.current,
-        mapFn: e._mapFn,
-        containerRef: l,
-        rebuildStateShape: i,
-        path: e._path,
-        componentId: g.current,
-        meta: e._meta
-      }), t.getState().setShadowMetadata(e._stateKey, e._path, {
+  const g = q(null), S = q(`map-${crypto.randomUUID()}`), y = q(!1), I = q(/* @__PURE__ */ new Map());
+  Z(() => {
+    const u = g.current;
+    if (!u || y.current) return;
+    const f = setTimeout(() => {
+      const A = e.getState().getShadowMetadata(t._stateKey, t._path) || {}, w = A.mapWrappers || [];
+      w.push({
+        instanceId: S.current,
+        mapFn: t._mapFn,
+        containerRef: u,
+        rebuildStateShape: n,
+        path: t._path,
+        componentId: S.current,
+        meta: t._meta
+      }), e.getState().setShadowMetadata(t._stateKey, t._path, {
         ...A,
-        mapWrappers: b
-      }), h.current = !0, M();
+        mapWrappers: w
+      }), y.current = !0, E();
     }, 0);
     return () => {
-      if (clearTimeout(u), g.current) {
-        const A = t.getState().getShadowMetadata(e._stateKey, e._path) || {};
+      if (clearTimeout(f), S.current) {
+        const A = e.getState().getShadowMetadata(t._stateKey, t._path) || {};
         A.mapWrappers && (A.mapWrappers = A.mapWrappers.filter(
-          (b) => b.instanceId !== g.current
-        ), t.getState().setShadowMetadata(e._stateKey, e._path, A));
+          (w) => w.instanceId !== S.current
+        ), e.getState().setShadowMetadata(t._stateKey, t._path, A));
       }
-      p.current.forEach((A) => A.unmount());
+      I.current.forEach((A) => A.unmount());
     };
   }, []);
-  const M = () => {
-    const l = f.current;
-    if (!l) return;
-    const u = t.getState().getShadowValue(
-      [e._stateKey, ...e._path].join("."),
-      e._meta?.validIds
+  const E = () => {
+    const u = g.current;
+    if (!u) return;
+    const f = e.getState().getShadowValue(
+      [t._stateKey, ...t._path].join("."),
+      t._meta?.validIds
     );
-    if (!Array.isArray(u)) return;
-    const A = e._meta?.validIds ?? t.getState().getShadowMetadata(e._stateKey, e._path)?.arrayKeys ?? [], b = i({
-      currentState: u,
-      path: e._path,
-      componentId: g.current,
-      meta: e._meta
+    if (!Array.isArray(f)) return;
+    const A = t._meta?.validIds ?? e.getState().getShadowMetadata(t._stateKey, t._path)?.arrayKeys ?? [], w = n({
+      currentState: f,
+      path: t._path,
+      componentId: S.current,
+      meta: t._meta
     });
-    u.forEach((o, S) => {
-      const T = A[S];
-      if (!T) return;
-      const W = te(), c = document.createElement("div");
-      c.setAttribute("data-item-path", T), l.appendChild(c);
-      const x = Ce(c);
-      p.current.set(T, x);
-      const Y = T.split(".").slice(1);
-      x.render(
-        le(Me, {
-          stateKey: e._stateKey,
-          itemComponentId: W,
-          itemPath: Y,
-          localIndex: S,
-          arraySetter: b,
-          rebuildStateShape: i,
-          renderFn: e._mapFn
+    f.forEach((i, h) => {
+      const M = A[h];
+      if (!M) return;
+      const z = rt(), c = document.createElement("div");
+      c.setAttribute("data-item-path", M), u.appendChild(c);
+      const B = At(c);
+      I.current.set(M, B);
+      const J = M.split(".").slice(1);
+      B.render(
+        lt(Mt, {
+          stateKey: t._stateKey,
+          itemComponentId: z,
+          itemPath: J,
+          localIndex: h,
+          arraySetter: w,
+          rebuildStateShape: n,
+          renderFn: t._mapFn
         })
       );
     });
   };
-  return /* @__PURE__ */ re("div", { ref: f, "data-map-container": g.current });
+  return /* @__PURE__ */ ot("div", { ref: g, "data-map-container": S.current });
 }
-function ze({
-  proxy: e
+function Gt({
+  proxy: t
 }) {
-  const i = G(null), f = G(null), g = G(!1), h = `${e._stateKey}-${e._path.join(".")}`, p = t.getState().getShadowValue(
-    [e._stateKey, ...e._path].join("."),
-    e._meta?.validIds
+  const n = q(null), g = q(null), S = q(!1), y = `${t._stateKey}-${t._path.join(".")}`, I = e.getState().getShadowValue(
+    [t._stateKey, ...t._path].join("."),
+    t._meta?.validIds
   );
-  return Q(() => {
-    const M = i.current;
-    if (!M || g.current) return;
-    const l = setTimeout(() => {
-      if (!M.parentElement) {
-        console.warn("Parent element not found for signal", h);
+  return Z(() => {
+    const E = n.current;
+    if (!E || S.current) return;
+    const u = setTimeout(() => {
+      if (!E.parentElement) {
+        console.warn("Parent element not found for signal", y);
         return;
       }
-      const u = M.parentElement, b = Array.from(u.childNodes).indexOf(M);
-      let o = u.getAttribute("data-parent-id");
-      o || (o = `parent-${crypto.randomUUID()}`, u.setAttribute("data-parent-id", o)), f.current = `instance-${crypto.randomUUID()}`;
-      const S = t.getState().getShadowMetadata(e._stateKey, e._path) || {}, T = S.signals || [];
-      T.push({
-        instanceId: f.current,
-        parentId: o,
-        position: b,
-        effect: e._effect
-      }), t.getState().setShadowMetadata(e._stateKey, e._path, {
-        ...S,
-        signals: T
+      const f = E.parentElement, w = Array.from(f.childNodes).indexOf(E);
+      let i = f.getAttribute("data-parent-id");
+      i || (i = `parent-${crypto.randomUUID()}`, f.setAttribute("data-parent-id", i)), g.current = `instance-${crypto.randomUUID()}`;
+      const h = e.getState().getShadowMetadata(t._stateKey, t._path) || {}, M = h.signals || [];
+      M.push({
+        instanceId: g.current,
+        parentId: i,
+        position: w,
+        effect: t._effect
+      }), e.getState().setShadowMetadata(t._stateKey, t._path, {
+        ...h,
+        signals: M
       });
-      let W = p;
-      if (e._effect)
+      let z = I;
+      if (t._effect)
         try {
-          W = new Function(
+          z = new Function(
             "state",
-            `return (${e._effect})(state)`
-          )(p);
-        } catch (x) {
-          console.error("Error evaluating effect function:", x);
+            `return (${t._effect})(state)`
+          )(I);
+        } catch (B) {
+          console.error("Error evaluating effect function:", B);
         }
-      W !== null && typeof W == "object" && (W = JSON.stringify(W));
-      const c = document.createTextNode(String(W ?? ""));
-      M.replaceWith(c), g.current = !0;
+      z !== null && typeof z == "object" && (z = JSON.stringify(z));
+      const c = document.createTextNode(String(z ?? ""));
+      E.replaceWith(c), S.current = !0;
     }, 0);
     return () => {
-      if (clearTimeout(l), f.current) {
-        const u = t.getState().getShadowMetadata(e._stateKey, e._path) || {};
-        u.signals && (u.signals = u.signals.filter(
-          (A) => A.instanceId !== f.current
-        ), t.getState().setShadowMetadata(e._stateKey, e._path, u));
+      if (clearTimeout(u), g.current) {
+        const f = e.getState().getShadowMetadata(t._stateKey, t._path) || {};
+        f.signals && (f.signals = f.signals.filter(
+          (A) => A.instanceId !== g.current
+        ), e.getState().setShadowMetadata(t._stateKey, t._path, f));
       }
     };
-  }, []), le("span", {
-    ref: i,
+  }, []), lt("span", {
+    ref: n,
     style: { display: "contents" },
-    "data-signal-id": h
+    "data-signal-id": y
   });
 }
-const Me = Re(
-  Ye,
-  (e, i) => e.itemPath.join(".") === i.itemPath.join(".") && e.stateKey === i.stateKey && e.itemComponentId === i.itemComponentId && e.localIndex === i.localIndex
-), Je = (e) => {
-  const [i, f] = X(!1);
-  return de(() => {
-    if (!e.current) {
-      f(!0);
+const Mt = Ot(
+  Yt,
+  (t, n) => t.itemPath.join(".") === n.itemPath.join(".") && t.stateKey === n.stateKey && t.itemComponentId === n.itemComponentId && t.localIndex === n.localIndex
+), Jt = (t) => {
+  const [n, g] = K(!1);
+  return dt(() => {
+    if (!t.current) {
+      g(!0);
       return;
     }
-    const g = Array.from(e.current.querySelectorAll("img"));
-    if (g.length === 0) {
-      f(!0);
+    const S = Array.from(t.current.querySelectorAll("img"));
+    if (S.length === 0) {
+      g(!0);
       return;
     }
-    let h = 0;
-    const p = () => {
-      h++, h === g.length && f(!0);
+    let y = 0;
+    const I = () => {
+      y++, y === S.length && g(!0);
     };
-    return g.forEach((M) => {
-      M.complete ? p() : (M.addEventListener("load", p), M.addEventListener("error", p));
+    return S.forEach((E) => {
+      E.complete ? I() : (E.addEventListener("load", I), E.addEventListener("error", I));
     }), () => {
-      g.forEach((M) => {
-        M.removeEventListener("load", p), M.removeEventListener("error", p);
+      S.forEach((E) => {
+        E.removeEventListener("load", I), E.removeEventListener("error", I);
       });
     };
-  }, [e.current]), i;
+  }, [t.current]), n;
 };
-function Ye({
-  stateKey: e,
-  itemComponentId: i,
-  itemPath: f,
-  localIndex: g,
-  arraySetter: h,
-  rebuildStateShape: p,
-  renderFn: M
+function Yt({
+  stateKey: t,
+  itemComponentId: n,
+  itemPath: g,
+  localIndex: S,
+  arraySetter: y,
+  rebuildStateShape: I,
+  renderFn: E
 }) {
-  const [, l] = X({}), { ref: u, inView: A } = Le(), b = G(null), o = Je(b), S = G(!1), T = [e, ...f].join(".");
-  Ue(e, i, l);
-  const W = ce(
-    (U) => {
-      b.current = U, u(U);
+  const [, u] = K({}), { ref: f, inView: A } = jt(), w = q(null), i = Jt(w), h = q(!1), M = [t, ...g].join(".");
+  $t(t, n, u);
+  const z = ct(
+    (W) => {
+      w.current = W, f(W);
     },
-    [u]
+    [f]
   );
-  Q(() => {
-    t.getState().subscribeToPath(T, (U) => {
-      l({});
+  Z(() => {
+    e.getState().subscribeToPath(M, (W) => {
+      u({});
     });
-  }, []), Q(() => {
-    if (!A || !o || S.current)
+  }, []), Z(() => {
+    if (!A || !i || h.current)
       return;
-    const U = b.current;
-    if (U && U.offsetHeight > 0) {
-      S.current = !0;
-      const v = U.offsetHeight;
-      t.getState().setShadowMetadata(e, f, {
+    const W = w.current;
+    if (W && W.offsetHeight > 0) {
+      h.current = !0;
+      const m = W.offsetHeight;
+      e.getState().setShadowMetadata(t, g, {
         virtualizer: {
-          itemHeight: v,
-          domRef: U
+          itemHeight: m,
+          domRef: W
         }
       });
-      const K = f.slice(0, -1), oe = [e, ...K].join(".");
-      t.getState().notifyPathSubscribers(oe, {
+      const Y = g.slice(0, -1), Q = [t, ...Y].join(".");
+      e.getState().notifyPathSubscribers(Q, {
         type: "ITEMHEIGHT",
-        itemKey: f.join("."),
-        ref: b.current
+        itemKey: g.join("."),
+        ref: w.current
       });
     }
-  }, [A, o, e, f]);
-  const c = [e, ...f].join("."), x = t.getState().getShadowValue(c);
-  if (x === void 0)
+  }, [A, i, t, g]);
+  const c = [t, ...g].join("."), B = e.getState().getShadowValue(c);
+  if (B === void 0)
     return null;
-  const Y = p({
-    currentState: x,
-    path: f,
-    componentId: i
-  }), J = M(Y, g, h);
-  return /* @__PURE__ */ re("div", { ref: W, children: J });
+  const J = I({
+    currentState: B,
+    path: g,
+    componentId: n
+  }), H = E(J, S, y);
+  return /* @__PURE__ */ ot("div", { ref: z, children: H });
 }
-function Ze({
-  stateKey: e,
-  path: i,
-  rebuildStateShape: f,
-  renderFn: g,
-  formOpts: h,
-  setState: p
+function Zt({
+  stateKey: t,
+  path: n,
+  rebuildStateShape: g,
+  renderFn: S,
+  formOpts: y,
+  setState: I
 }) {
-  const [M] = X(() => te()), [, l] = X({}), u = [e, ...i].join(".");
-  Ue(e, M, l);
-  const A = t.getState().getShadowValue(u), [b, o] = X(A), S = G(!1), T = G(null);
-  Q(() => {
-    !S.current && !se(A, b) && o(A);
-  }, [A]), Q(() => {
-    const J = t.getState().subscribeToPath(u, (U) => {
-      l({});
+  const [E] = K(() => rt()), [, u] = K({}), f = [t, ...n].join(".");
+  $t(t, E, u);
+  const A = e.getState().getShadowValue(f), [w, i] = K(A), h = q(!1), M = q(null);
+  Z(() => {
+    !h.current && !st(A, w) && i(A);
+  }, [A]), Z(() => {
+    const H = e.getState().subscribeToPath(f, (W) => {
+      !h.current && w !== W && u({});
     });
     return () => {
-      J(), T.current && (clearTimeout(T.current), S.current = !1);
+      H(), M.current && (clearTimeout(M.current), h.current = !1);
     };
   }, []);
-  const W = ce(
-    (J) => {
-      o(J), S.current = !0, T.current && clearTimeout(T.current);
-      const U = h?.debounceTime ?? 200;
-      T.current = setTimeout(() => {
-        S.current = !1, p(J, i, { updateType: "update" });
-      }, U);
+  const z = ct(
+    (H) => {
+      typeof A === "number" && typeof H == "string" && (H = H === "" ? 0 : Number(H)), i(H), h.current = !0, M.current && clearTimeout(M.current);
+      const m = y?.debounceTime ?? 200;
+      M.current = setTimeout(() => {
+        h.current = !1, I(H, n, { updateType: "update" });
+        const { getInitialOptions: Y, setShadowMetadata: Q, getShadowMetadata: X } = e.getState(), s = Y(t)?.validation, o = s?.zodSchemaV4 || s?.zodSchemaV3;
+        if (o) {
+          const r = e.getState().getShadowValue(t), a = o.safeParse(r), d = X(t, n) || {};
+          if (a.success)
+            Q(t, n, {
+              ...d,
+              validation: {
+                status: "VALID_LIVE",
+                validatedValue: H
+              }
+            });
+          else {
+            const p = ("issues" in a.error ? a.error.issues : a.error.errors).filter(
+              (V) => JSON.stringify(V.path) === JSON.stringify(n)
+            );
+            p.length > 0 ? Q(t, n, {
+              ...d,
+              validation: {
+                status: "INVALID_LIVE",
+                message: p[0]?.message,
+                validatedValue: H
+              }
+            }) : Q(t, n, {
+              ...d,
+              validation: {
+                status: "VALID_LIVE",
+                validatedValue: H
+              }
+            });
+          }
+        }
+      }, m), u({});
     },
-    [p, i, h?.debounceTime]
-  ), c = ce(() => {
-    T.current && (clearTimeout(T.current), S.current = !1, p(b, i, { updateType: "update" }));
-  }, [p, i, b]), x = f({
+    [I, n, y?.debounceTime, t]
+  ), c = ct(async () => {
+    console.log("handleBlur triggered"), M.current && (clearTimeout(M.current), M.current = null, h.current = !1, I(w, n, { updateType: "update" }));
+    const { getInitialOptions: H } = e.getState(), W = H(t)?.validation, m = W?.zodSchemaV4 || W?.zodSchemaV3;
+    if (!m) return;
+    const Y = e.getState().getShadowMetadata(t, n);
+    e.getState().setShadowMetadata(t, n, {
+      ...Y,
+      validation: {
+        status: "DIRTY",
+        validatedValue: w
+      }
+    });
+    const Q = e.getState().getShadowValue(t), X = m.safeParse(Q);
+    if (console.log("result ", X), X.success)
+      e.getState().setShadowMetadata(t, n, {
+        ...Y,
+        validation: {
+          status: "VALID_PENDING_SYNC",
+          validatedValue: w
+        }
+      });
+    else {
+      const s = "issues" in X.error ? X.error.issues : X.error.errors;
+      console.log("All validation errors:", s), console.log("Current blur path:", n);
+      const o = s.filter((r) => {
+        if (console.log("Processing error:", r), n.some((d) => d.startsWith("id:"))) {
+          console.log("Detected array path with ULID");
+          const d = n[0].startsWith("id:") ? [] : n.slice(0, -1);
+          console.log("Parent path:", d);
+          const l = e.getState().getShadowMetadata(t, d);
+          if (console.log("Array metadata:", l), l?.arrayKeys) {
+            const p = [t, ...n.slice(0, -1)].join("."), V = l.arrayKeys.indexOf(p);
+            console.log("Item key:", p, "Index:", V);
+            const _ = [...d, V, ...n.slice(-1)], U = JSON.stringify(r.path) === JSON.stringify(_);
+            return console.log("Zod path comparison:", {
+              zodPath: _,
+              errorPath: r.path,
+              match: U
+            }), U;
+          }
+        }
+        const a = JSON.stringify(r.path) === JSON.stringify(n);
+        return console.log("Direct path comparison:", {
+          errorPath: r.path,
+          currentPath: n,
+          match: a
+        }), a;
+      });
+      console.log("Filtered path errors:", o), e.getState().setShadowMetadata(t, n, {
+        ...Y,
+        validation: {
+          status: "VALIDATION_FAILED",
+          message: o[0]?.message,
+          validatedValue: w
+        }
+      });
+    }
+    u({});
+  }, [t, n, w, I]), B = g({
     currentState: A,
-    path: i,
-    componentId: M
-  }), Y = new Proxy(x, {
-    get(J, U) {
-      return U === "inputProps" ? {
-        value: b ?? "",
-        onChange: (v) => {
-          W(v.target.value);
+    path: n,
+    componentId: E
+  }), J = new Proxy(B, {
+    get(H, W) {
+      return W === "inputProps" ? {
+        value: w ?? "",
+        onChange: (m) => {
+          z(m.target.value);
         },
+        // 5. Wire the new onBlur handler to the input props.
         onBlur: c,
-        ref: pe.getState().getFormRef(e + "." + i.join("."))
-      } : J[U];
+        ref: vt.getState().getFormRef(t + "." + n.join("."))
+      } : H[W];
     }
   });
-  return /* @__PURE__ */ re(ke, { children: g(Y) });
+  return /* @__PURE__ */ ot(kt, { formOpts: y, path: n, stateKey: t, children: S(J) });
 }
-function Ue(e, i, f) {
-  const g = `${e}////${i}`;
-  de(() => {
-    const h = t.getState().getShadowMetadata(e, []), p = h?.components || /* @__PURE__ */ new Map();
-    return p.set(g, {
-      forceUpdate: () => f({}),
+function $t(t, n, g) {
+  const S = `${t}////${n}`;
+  dt(() => {
+    const { registerComponent: y, unregisterComponent: I } = e.getState();
+    return y(t, S, {
+      forceUpdate: () => g({}),
       paths: /* @__PURE__ */ new Set(),
       reactiveType: ["component"]
-    }), t.getState().setShadowMetadata(e, [], {
-      ...h,
-      components: p
     }), () => {
-      const M = t.getState().getShadowMetadata(e, []);
-      M?.components && M.components.delete(g);
+      I(t, S);
     };
-  }, [e, g]);
+  }, [t, S]);
 }
 export {
-  Ae as $cogsSignal,
-  it as addStateOptions,
-  ct as createCogsState,
-  lt as notifyComponent,
-  Be as useCogsStateFn
+  bt as $cogsSignal,
+  ie as addStateOptions,
+  Lt as createCogsState,
+  ce as createCogsStateFromSync,
+  ue as notifyComponent,
+  zt as useCogsStateFn
 };
 //# sourceMappingURL=CogsState.jsx.map