cogsbox-state 0.5.434 → 0.5.435

package/dist/CogsState.jsx

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