cogsbox-state 0.5.460 → 0.5.462

package/dist/CogsState.jsx

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