cogsbox-state 0.5.462 → 0.5.464

package/dist/CogsState.jsx

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