cogsbox-state 0.5.426 → 0.5.428

package/dist/CogsState.jsx

@@ -1,178 +1,179 @@
 "use client";
-import { jsx as pt } from "react/jsx-runtime";
-import { useState as it, useRef as q, useEffect as rt, useLayoutEffect as Ct, useMemo as Et, createElement as dt, useSyncExternalStore as Ut, startTransition as Ft, useCallback as St } from "react";
-import { transformStateFunc as Dt, isDeepEqual as Y, isFunction as tt, getNestedValue as Z, getDifferences as Tt, debounce as Lt } from "./utility.js";
-import { pushFunc as wt, updateFn as lt, cutFunc as gt, ValidationWrapper as Gt, FormControlComponent as Wt } from "./Functions.jsx";
-import Ht from "superjson";
-import { v4 as At } from "uuid";
+import { jsx as At } from "react/jsx-runtime";
+import { useState as ct, useRef as z, useEffect as nt, useLayoutEffect as Pt, useMemo as Et, createElement as ut, useSyncExternalStore as Ut, startTransition as Dt, useCallback as St } from "react";
+import { transformStateFunc as Lt, isDeepEqual as Z, isFunction as X, getNestedValue as U, getDifferences as Mt, debounce as Gt } from "./utility.js";
+import { pushFunc as $t, updateFn as dt, cutFunc as ft, ValidationWrapper as Wt, FormControlComponent as zt } from "./Functions.jsx";
+import Bt from "superjson";
+import { v4 as kt } from "uuid";
 import "zod";
-import { getGlobalStore as r, formRefStore as bt } from "./store.js";
-import { useCogsConfig as _t } from "./CogsStateClient.jsx";
-import { applyPatch as zt } from "fast-json-patch";
-import Bt from "react-use-measure";
-function Vt(t, i) {
-  const S = r.getState().getInitialOptions, f = r.getState().setInitialStateOptions, h = S(t) || {};
-  f(t, {
-    ...h,
-    ...i
+import { getGlobalStore as o, formRefStore as Vt } from "./store.js";
+import { useCogsConfig as Ot } from "./CogsStateClient.jsx";
+import { applyPatch as Ht } from "fast-json-patch";
+import qt from "react-use-measure";
+import "ulid";
+function Nt(t, s) {
+  const S = o.getState().getInitialOptions, g = o.getState().setInitialStateOptions, I = S(t) || {};
+  g(t, {
+    ...I,
+    ...s
   });
 }
-function $t({
+function Ct({
   stateKey: t,
-  options: i,
+  options: s,
   initialOptionsPart: S
 }) {
-  const f = st(t) || {}, h = S[t] || {}, x = r.getState().setInitialStateOptions, p = { ...h, ...f };
+  const g = it(t) || {}, I = S[t] || {}, k = o.getState().setInitialStateOptions, w = { ...I, ...g };
   let y = !1;
-  if (i)
-    for (const s in i)
-      p.hasOwnProperty(s) ? (s == "localStorage" && i[s] && p[s].key !== i[s]?.key && (y = !0, p[s] = i[s]), s == "initialState" && i[s] && p[s] !== i[s] && // Different references
-      !Y(p[s], i[s]) && (y = !0, p[s] = i[s])) : (y = !0, p[s] = i[s]);
-  y && x(t, p);
+  if (s)
+    for (const i in s)
+      w.hasOwnProperty(i) ? (i == "localStorage" && s[i] && w[i].key !== s[i]?.key && (y = !0, w[i] = s[i]), i == "initialState" && s[i] && w[i] !== s[i] && // Different references
+      !Z(w[i], s[i]) && (y = !0, w[i] = s[i])) : (y = !0, w[i] = s[i]);
+  y && k(t, w);
 }
-function ge(t, { formElements: i, validation: S }) {
-  return { initialState: t, formElements: i, validation: S };
+function me(t, { formElements: s, validation: S }) {
+  return { initialState: t, formElements: s, validation: S };
 }
-const Se = (t, i) => {
+const Ie = (t, s) => {
   let S = t;
-  const [f, h] = Dt(S);
-  (Object.keys(h).length > 0 || i && Object.keys(i).length > 0) && Object.keys(h).forEach((y) => {
-    h[y] = h[y] || {}, h[y].formElements = {
-      ...i?.formElements,
+  const [g, I] = Lt(S);
+  (Object.keys(I).length > 0 || s && Object.keys(s).length > 0) && Object.keys(I).forEach((y) => {
+    I[y] = I[y] || {}, I[y].formElements = {
+      ...s?.formElements,
       // Global defaults first
-      ...i?.validation,
-      ...h[y].formElements || {}
+      ...s?.validation,
+      ...I[y].formElements || {}
       // State-specific overrides
-    }, st(y) || r.getState().setInitialStateOptions(y, h[y]);
-  }), r.getState().setInitialStates(f), r.getState().setCreatedState(f);
-  const x = (y, s) => {
-    const [m] = it(s?.componentId ?? At());
-    $t({
+    }, it(y) || o.getState().setInitialStateOptions(y, I[y]);
+  }), o.getState().setInitialStates(g), o.getState().setCreatedState(g);
+  const k = (y, i) => {
+    const [$] = ct(i?.componentId ?? kt());
+    Ct({
       stateKey: y,
-      options: s,
-      initialOptionsPart: h
+      options: i,
+      initialOptionsPart: I
     });
-    const n = r.getState().cogsStateStore[y] || f[y], u = s?.modifyState ? s.modifyState(n) : n, [L, R] = Qt(
-      u,
+    const v = o.getState().cogsStateStore[y] || g[y], r = i?.modifyState ? i.modifyState(v) : v, [h, M] = Kt(
+      r,
       {
         stateKey: y,
-        syncUpdate: s?.syncUpdate,
-        componentId: m,
-        localStorage: s?.localStorage,
-        middleware: s?.middleware,
-        enabledSync: s?.enabledSync,
-        reactiveType: s?.reactiveType,
-        reactiveDeps: s?.reactiveDeps,
-        initialState: s?.initialState,
-        dependencies: s?.dependencies,
-        serverState: s?.serverState
+        syncUpdate: i?.syncUpdate,
+        componentId: $,
+        localStorage: i?.localStorage,
+        middleware: i?.middleware,
+        enabledSync: i?.enabledSync,
+        reactiveType: i?.reactiveType,
+        reactiveDeps: i?.reactiveDeps,
+        initialState: i?.initialState,
+        dependencies: i?.dependencies,
+        serverState: i?.serverState
       }
     );
-    return R;
+    return M;
   };
-  function p(y, s) {
-    $t({ stateKey: y, options: s, initialOptionsPart: h }), s.localStorage && Zt(y, s), ut(y);
+  function w(y, i) {
+    Ct({ stateKey: y, options: i, initialOptionsPart: I }), i.localStorage && Qt(y, i), et(y);
   }
-  return { useCogsState: x, setCogsOptions: p };
+  return { useCogsState: k, setCogsOptions: w };
 }, {
   setUpdaterState: mt,
-  setState: ot,
-  getInitialOptions: st,
+  setState: rt,
+  getInitialOptions: it,
   getKeyState: Rt,
-  getValidationErrors: qt,
-  setStateLog: Jt,
-  updateInitialStateGlobal: kt,
-  addValidationError: Mt,
+  getValidationErrors: Jt,
+  setStateLog: Zt,
+  updateInitialStateGlobal: Tt,
+  addValidationError: xt,
   removeValidationError: Q,
   setServerSyncActions: Yt
-} = r.getState(), Nt = (t, i, S, f, h) => {
+} = o.getState(), pt = (t, s, S, g, I) => {
   S?.log && console.log(
     "saving to localstorage",
-    i,
+    s,
     S.localStorage?.key,
-    f
+    g
   );
-  const x = tt(S?.localStorage?.key) ? S.localStorage?.key(t) : S?.localStorage?.key;
-  if (x && f) {
-    const p = `${f}-${i}-${x}`;
+  const k = X(S?.localStorage?.key) ? S.localStorage?.key(t) : S?.localStorage?.key;
+  if (k && g) {
+    const w = `${g}-${s}-${k}`;
     let y;
     try {
-      y = yt(p)?.lastSyncedWithServer;
+      y = vt(w)?.lastSyncedWithServer;
     } catch {
     }
-    const s = {
+    const i = {
       state: t,
       lastUpdated: Date.now(),
-      lastSyncedWithServer: h ?? y
-    }, m = Ht.serialize(s);
+      lastSyncedWithServer: I ?? y
+    }, $ = Bt.serialize(i);
     window.localStorage.setItem(
-      p,
-      JSON.stringify(m.json)
+      w,
+      JSON.stringify($.json)
     );
   }
-}, yt = (t) => {
+}, vt = (t) => {
   if (!t) return null;
   try {
-    const i = window.localStorage.getItem(t);
-    return i ? JSON.parse(i) : null;
-  } catch (i) {
-    return console.error("Error loading from localStorage:", i), null;
+    const s = window.localStorage.getItem(t);
+    return s ? JSON.parse(s) : null;
+  } catch (s) {
+    return console.error("Error loading from localStorage:", s), null;
   }
-}, Zt = (t, i) => {
-  const S = r.getState().cogsStateStore[t], { sessionId: f } = _t(), h = tt(i?.localStorage?.key) ? i.localStorage.key(S) : i?.localStorage?.key;
-  if (h && f) {
-    const x = yt(
-      `${f}-${t}-${h}`
+}, Qt = (t, s) => {
+  const S = o.getState().cogsStateStore[t], { sessionId: g } = Ot(), I = X(s?.localStorage?.key) ? s.localStorage.key(S) : s?.localStorage?.key;
+  if (I && g) {
+    const k = vt(
+      `${g}-${t}-${I}`
     );
-    if (x && x.lastUpdated > (x.lastSyncedWithServer || 0))
-      return ot(t, x.state), ut(t), !0;
+    if (k && k.lastUpdated > (k.lastSyncedWithServer || 0))
+      return rt(t, k.state), et(t), !0;
   }
   return !1;
-}, Ot = (t, i, S, f, h, x) => {
-  const p = {
-    initialState: i,
-    updaterState: ht(
+}, jt = (t, s, S, g, I, k) => {
+  const w = {
+    initialState: s,
+    updaterState: It(
       t,
-      f,
-      h,
-      x
+      g,
+      I,
+      k
     ),
     state: S
   };
-  kt(t, p.initialState), mt(t, p.updaterState), ot(t, p.state);
-}, ut = (t) => {
-  const i = r.getState().stateComponents.get(t);
-  if (!i) return;
+  Tt(t, w.initialState), mt(t, w.updaterState), rt(t, w.state);
+}, et = (t) => {
+  const s = o.getState().stateComponents.get(t);
+  if (!s) return;
   const S = /* @__PURE__ */ new Set();
-  i.components.forEach((f) => {
-    (f ? Array.isArray(f.reactiveType) ? f.reactiveType : [f.reactiveType || "component"] : null)?.includes("none") || S.add(() => f.forceUpdate());
+  s.components.forEach((g) => {
+    (g ? Array.isArray(g.reactiveType) ? g.reactiveType : [g.reactiveType || "component"] : null)?.includes("none") || S.add(() => g.forceUpdate());
   }), queueMicrotask(() => {
-    S.forEach((f) => f());
+    S.forEach((g) => g());
   });
-}, me = (t, i) => {
-  const S = r.getState().stateComponents.get(t);
+}, ve = (t, s) => {
+  const S = o.getState().stateComponents.get(t);
   if (S) {
-    const f = `${t}////${i}`, h = S.components.get(f);
-    if ((h ? Array.isArray(h.reactiveType) ? h.reactiveType : [h.reactiveType || "component"] : null)?.includes("none"))
+    const g = `${t}////${s}`, I = S.components.get(g);
+    if ((I ? Array.isArray(I.reactiveType) ? I.reactiveType : [I.reactiveType || "component"] : null)?.includes("none"))
       return;
-    h && h.forceUpdate();
+    I && I.forceUpdate();
   }
-}, Xt = (t, i, S, f) => {
+}, Xt = (t, s, S, g) => {
   switch (t) {
     case "update":
       return {
-        oldValue: Z(i, f),
-        newValue: Z(S, f)
+        oldValue: U(s, g),
+        newValue: U(S, g)
       };
     case "insert":
       return {
         oldValue: null,
         // or undefined
-        newValue: Z(S, f)
+        newValue: U(S, g)
       };
     case "cut":
       return {
-        oldValue: Z(i, f),
+        oldValue: U(s, g),
         newValue: null
         // or undefined
       };
@@ -180,327 +181,333 @@ const Se = (t, i) => {
       return { oldValue: null, newValue: null };
   }
 };
-function Qt(t, {
-  stateKey: i,
+function Kt(t, {
+  stateKey: s,
   serverSync: S,
-  localStorage: f,
-  formElements: h,
-  reactiveDeps: x,
-  reactiveType: p,
+  localStorage: g,
+  formElements: I,
+  reactiveDeps: k,
+  reactiveType: w,
   componentId: y,
-  initialState: s,
-  syncUpdate: m,
-  dependencies: n,
-  serverState: u
+  initialState: i,
+  syncUpdate: $,
+  dependencies: v,
+  serverState: r
 } = {}) {
-  const [L, R] = it({}), { sessionId: D } = _t();
-  let H = !i;
-  const [g] = it(i ?? At()), c = r.getState().stateLog[g], ft = q(/* @__PURE__ */ new Set()), et = q(y ?? At()), O = q(
+  const [h, M] = ct({}), { sessionId: _ } = Ot();
+  let Y = !s;
+  const [f] = ct(s ?? kt()), G = o.getState().stateLog[f], c = z(/* @__PURE__ */ new Set()), K = z(y ?? kt()), P = z(
     null
   );
-  O.current = st(g) ?? null, rt(() => {
-    if (m && m.stateKey === g && m.path?.[0]) {
-      ot(g, (o) => ({
-        ...o,
-        [m.path[0]]: m.newValue
+  P.current = it(f) ?? null, nt(() => {
+    if ($ && $.stateKey === f && $.path?.[0]) {
+      rt(f, (e) => ({
+        ...e,
+        [$.path[0]]: $.newValue
       }));
-      const e = `${m.stateKey}:${m.path.join(".")}`;
-      r.getState().setSyncInfo(e, {
-        timeStamp: m.timeStamp,
-        userId: m.userId
+      const n = `${$.stateKey}:${$.path.join(".")}`;
+      o.getState().setSyncInfo(n, {
+        timeStamp: $.timeStamp,
+        userId: $.userId
       });
     }
-  }, [m]), rt(() => {
-    if (s) {
-      Vt(g, {
-        initialState: s
+  }, [$]), nt(() => {
+    if (i) {
+      Nt(f, {
+        initialState: i
       });
-      const e = O.current, a = e?.serverState?.id !== void 0 && e?.serverState?.status === "success" && e?.serverState?.data, d = r.getState().initialStateGlobal[g];
-      if (!(d && !Y(d, s) || !d) && !a)
+      const n = P.current, a = n?.serverState?.id !== void 0 && n?.serverState?.status === "success" && n?.serverState?.data, d = o.getState().initialStateGlobal[f];
+      if (!(d && !Z(d, i) || !d) && !a)
         return;
-      let v = null;
-      const T = tt(e?.localStorage?.key) ? e?.localStorage?.key(s) : e?.localStorage?.key;
-      T && D && (v = yt(`${D}-${g}-${T}`));
-      let E = s, k = !1;
-      const C = a ? Date.now() : 0, $ = v?.lastUpdated || 0, M = v?.lastSyncedWithServer || 0;
-      a && C > $ ? (E = e.serverState.data, k = !0) : v && $ > M && (E = v.state, e?.localStorage?.onChange && e?.localStorage?.onChange(E)), r.getState().initializeShadowState(g, s), Ot(
-        g,
-        s,
-        E,
-        ct,
-        et.current,
-        D
-      ), k && T && D && Nt(E, g, e, D, Date.now()), ut(g), (Array.isArray(p) ? p : [p || "component"]).includes("none") || R({});
+      let l = null;
+      const m = X(n?.localStorage?.key) ? n?.localStorage?.key(i) : n?.localStorage?.key;
+      m && _ && (l = vt(`${_}-${f}-${m}`));
+      let x = i, b = !1;
+      const R = a ? Date.now() : 0, B = l?.lastUpdated || 0, D = l?.lastSyncedWithServer || 0;
+      a && R > B ? (x = n.serverState.data, b = !0) : l && B > D && (x = l.state, n?.localStorage?.onChange && n?.localStorage?.onChange(x)), o.getState().initializeShadowState(f, i), jt(
+        f,
+        i,
+        x,
+        ot,
+        K.current,
+        _
+      ), b && m && _ && pt(x, f, n, _, Date.now()), et(f), (Array.isArray(w) ? w : [w || "component"]).includes("none") || M({});
     }
   }, [
-    s,
-    u?.status,
-    u?.data,
-    ...n || []
-  ]), Ct(() => {
-    H && Vt(g, {
+    i,
+    r?.status,
+    r?.data,
+    ...v || []
+  ]), Pt(() => {
+    Y && Nt(f, {
       serverSync: S,
-      formElements: h,
-      initialState: s,
-      localStorage: f,
-      middleware: O.current?.middleware
+      formElements: I,
+      initialState: i,
+      localStorage: g,
+      middleware: P.current?.middleware
     });
-    const e = `${g}////${et.current}`, o = r.getState().stateComponents.get(g) || {
+    const n = `${f}////${K.current}`, e = o.getState().stateComponents.get(f) || {
       components: /* @__PURE__ */ new Map()
     };
-    return o.components.set(e, {
-      forceUpdate: () => R({}),
+    return e.components.set(n, {
+      forceUpdate: () => M({}),
       paths: /* @__PURE__ */ new Set(),
       deps: [],
-      depsFunction: x || void 0,
-      reactiveType: p ?? ["component", "deps"]
-    }), r.getState().stateComponents.set(g, o), R({}), () => {
-      o && (o.components.delete(e), o.components.size === 0 && r.getState().stateComponents.delete(g));
+      depsFunction: k || void 0,
+      reactiveType: w ?? ["component", "deps"]
+    }), o.getState().stateComponents.set(f, e), M({}), () => {
+      e && (e.components.delete(n), e.components.size === 0 && o.getState().stateComponents.delete(f));
     };
   }, []);
-  const ct = (e, o, a, d) => {
-    if (Array.isArray(o)) {
-      const v = `${g}-${o.join(".")}`;
-      ft.current.add(v);
+  const ot = (n, e, a, d) => {
+    if (Array.isArray(e)) {
+      const l = `${f}-${e.join(".")}`;
+      c.current.add(l);
     }
-    const w = r.getState();
-    ot(g, (v) => {
-      const T = tt(e) ? e(v) : e, E = `${g}-${o.join(".")}`;
-      if (E) {
-        let _ = !1, I = w.signalDomElements.get(E);
-        if ((!I || I.size === 0) && (a.updateType === "insert" || a.updateType === "cut")) {
-          const j = o.slice(0, -1), N = Z(T, j);
-          if (Array.isArray(N)) {
-            _ = !0;
-            const A = `${g}-${j.join(".")}`;
-            I = w.signalDomElements.get(A);
+    const u = o.getState();
+    rt(f, (l) => {
+      const m = X(n) ? n(l) : n, x = `${f}-${e.join(".")}`;
+      if (x) {
+        let N = !1, T = u.signalDomElements.get(x);
+        if ((!T || T.size === 0) && (a.updateType === "insert" || a.updateType === "cut")) {
+          const E = e.slice(0, -1), p = U(m, E);
+          if (Array.isArray(p)) {
+            N = !0;
+            const A = `${f}-${E.join(".")}`;
+            T = u.signalDomElements.get(A);
           }
         }
-        if (I) {
-          const j = _ ? Z(T, o.slice(0, -1)) : Z(T, o);
-          I.forEach(({ parentId: N, position: A, effect: U }) => {
-            const F = document.querySelector(
-              `[data-parent-id="${N}"]`
+        if (T) {
+          const E = N ? U(m, e.slice(0, -1)) : U(m, e);
+          T.forEach(({ parentId: p, position: A, effect: C }) => {
+            const q = document.querySelector(
+              `[data-parent-id="${p}"]`
             );
-            if (F) {
-              const B = Array.from(F.childNodes);
-              if (B[A]) {
-                const G = U ? new Function("state", `return (${U})(state)`)(j) : j;
-                B[A].textContent = String(G);
+            if (q) {
+              const W = Array.from(q.childNodes);
+              if (W[A]) {
+                const O = C ? new Function("state", `return (${C})(state)`)(E) : E;
+                W[A].textContent = String(O);
               }
             }
           });
         }
       }
-      console.log("shadowState", w.shadowStateStore), a.updateType === "update" && (d || O.current?.validation?.key) && o && Q(
-        (d || O.current?.validation?.key) + "." + o.join(".")
+      a.updateType === "update" && (d || P.current?.validation?.key) && e && Q(
+        (d || P.current?.validation?.key) + "." + e.join(".")
       );
-      const k = o.slice(0, o.length - 1);
-      a.updateType === "cut" && O.current?.validation?.key && Q(
-        O.current?.validation?.key + "." + k.join(".")
-      ), a.updateType === "insert" && O.current?.validation?.key && qt(
-        O.current?.validation?.key + "." + k.join(".")
-      ).filter(([I, j]) => {
-        let N = I?.split(".").length;
-        if (I == k.join(".") && N == k.length - 1) {
-          let A = I + "." + k;
-          Q(I), Mt(A, j);
+      const b = e.slice(0, e.length - 1);
+      a.updateType === "cut" && P.current?.validation?.key && Q(
+        P.current?.validation?.key + "." + b.join(".")
+      ), a.updateType === "insert" && P.current?.validation?.key && Jt(
+        P.current?.validation?.key + "." + b.join(".")
+      ).filter((T) => {
+        let E = T?.split(".").length;
+        const p = "";
+        if (T == b.join(".") && E == b.length - 1) {
+          let A = T + "." + b;
+          Q(T), xt(A, p);
         }
       });
-      const C = w.stateComponents.get(g);
-      if (console.log("stateEntry >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", C), C) {
-        const _ = Tt(v, T), I = new Set(_), j = a.updateType === "update" ? o.join(".") : o.slice(0, -1).join(".") || "";
+      const R = u.stateComponents.get(f);
+      if (R) {
+        const N = Mt(l, m), T = new Set(N), E = a.updateType === "update" ? e.join(".") : e.slice(0, -1).join(".") || "";
         for (const [
-          N,
+          p,
           A
-        ] of C.components.entries()) {
-          let U = !1;
-          const F = Array.isArray(A.reactiveType) ? A.reactiveType : [A.reactiveType || "component"];
-          if (console.log("component", A), !F.includes("none")) {
-            if (F.includes("all")) {
+        ] of R.components.entries()) {
+          let C = !1;
+          const q = Array.isArray(A.reactiveType) ? A.reactiveType : [A.reactiveType || "component"];
+          if (!q.includes("none")) {
+            if (q.includes("all")) {
               A.forceUpdate();
               continue;
             }
-            if (F.includes("component") && ((A.paths.has(j) || A.paths.has("")) && (U = !0), !U))
-              for (const B of I) {
-                let G = B;
+            if (q.includes("component") && ((A.paths.has(E) || A.paths.has("")) && (C = !0), !C))
+              for (const W of T) {
+                let O = W;
                 for (; ; ) {
-                  if (A.paths.has(G)) {
-                    U = !0;
+                  if (A.paths.has(O)) {
+                    C = !0;
                     break;
                   }
-                  const b = G.lastIndexOf(".");
-                  if (b !== -1) {
-                    const V = G.substring(
+                  const lt = O.lastIndexOf(".");
+                  if (lt !== -1) {
+                    const V = O.substring(
                       0,
-                      b
+                      lt
                     );
                     if (!isNaN(
-                      Number(G.substring(b + 1))
+                      Number(O.substring(lt + 1))
                     ) && A.paths.has(V)) {
-                      U = !0;
+                      C = !0;
                       break;
                     }
-                    G = V;
+                    O = V;
                   } else
-                    G = "";
-                  if (G === "")
+                    O = "";
+                  if (O === "")
                     break;
                 }
-                if (U) break;
+                if (C) break;
               }
-            if (!U && F.includes("deps") && A.depsFunction) {
-              const B = A.depsFunction(T);
-              let G = !1;
-              typeof B == "boolean" ? B && (G = !0) : Y(A.deps, B) || (A.deps = B, G = !0), G && (U = !0);
+            if (!C && q.includes("deps") && A.depsFunction) {
+              const W = A.depsFunction(m);
+              let O = !1;
+              typeof W == "boolean" ? W && (O = !0) : Z(A.deps, W) || (A.deps = W, O = !0), O && (C = !0);
             }
-            U && A.forceUpdate();
+            C && A.forceUpdate();
           }
         }
       }
-      const $ = Date.now();
-      o = o.map((_, I) => {
-        const j = o.slice(0, -1), N = Z(T, j);
-        return I === o.length - 1 && ["insert", "cut"].includes(a.updateType) ? (N.length - 1).toString() : _;
-      });
-      const { oldValue: M, newValue: z } = Xt(
+      const B = Date.now();
+      let { oldValue: D, newValue: H } = Xt(
         a.updateType,
-        v,
-        T,
-        o
-      ), K = {
-        timeStamp: $,
-        stateKey: g,
-        path: o,
+        l,
+        m,
+        e
+      );
+      const at = {
+        timeStamp: B,
+        stateKey: f,
+        path: e,
         updateType: a.updateType,
         status: "new",
-        oldValue: M,
-        newValue: z
+        oldValue: D,
+        newValue: H
       };
       switch (a.updateType) {
-        case "update":
-          w.updateShadowAtPath(g, o, T);
+        case "insert": {
+          const N = e.slice(0, -1), E = e[e.length - 1].split(":")[1];
+          H = U(m, N).find((A) => A.id == E), D = null, u.insertShadowArrayElement(f, N, H);
           break;
-        case "insert":
-          const _ = o.slice(0, -1);
-          w.insertShadowArrayElement(g, _, z);
+        }
+        case "cut": {
+          D = U(l, e), H = null, u.removeShadowArrayElement(f, e);
           break;
-        case "cut":
-          const I = o.slice(0, -1), j = parseInt(o[o.length - 1]);
-          w.removeShadowArrayElement(g, I, j);
+        }
+        case "update": {
+          D = U(l, e), H = U(m, e);
+          const N = e.map((T, E) => {
+            const p = e.slice(0, E + 1), A = U(m, p);
+            return A?.id ? `id:${A.id}` : T;
+          });
+          u.updateShadowAtPath(f, N, H);
           break;
+        }
       }
-      if (Jt(g, (_) => {
-        const j = [..._ ?? [], K].reduce((N, A) => {
-          const U = `${A.stateKey}:${JSON.stringify(A.path)}`, F = N.get(U);
-          return F ? (F.timeStamp = Math.max(F.timeStamp, A.timeStamp), F.newValue = A.newValue, F.oldValue = F.oldValue ?? A.oldValue, F.updateType = A.updateType) : N.set(U, { ...A }), N;
-        }, /* @__PURE__ */ new Map());
-        return Array.from(j.values());
-      }), Nt(
-        T,
-        g,
-        O.current,
-        D
-      ), O.current?.middleware && O.current.middleware({
-        updateLog: c,
-        update: K
-      }), O.current?.serverSync) {
-        const _ = w.serverState[g], I = O.current?.serverSync;
-        Yt(g, {
-          syncKey: typeof I.syncKey == "string" ? I.syncKey : I.syncKey({ state: T }),
-          rollBackState: _,
-          actionTimeStamp: Date.now() + (I.debounce ?? 3e3),
+      if (Zt(f, (N) => {
+        const T = [...N ?? [], at], E = /* @__PURE__ */ new Map();
+        return T.forEach((p) => {
+          const A = `${p.stateKey}:${JSON.stringify(p.path)}`, C = E.get(A);
+          C ? (C.timeStamp = Math.max(C.timeStamp, p.timeStamp), C.newValue = p.newValue, C.oldValue = C.oldValue ?? p.oldValue, C.updateType = p.updateType) : E.set(A, { ...p });
+        }), Array.from(E.values());
+      }), pt(
+        m,
+        f,
+        P.current,
+        _
+      ), P.current?.middleware && P.current.middleware({
+        updateLog: G,
+        update: at
+      }), P.current?.serverSync) {
+        const N = u.serverState[f], T = P.current?.serverSync;
+        Yt(f, {
+          syncKey: typeof T.syncKey == "string" ? T.syncKey : T.syncKey({ state: m }),
+          rollBackState: N,
+          actionTimeStamp: Date.now() + (T.debounce ?? 3e3),
           status: "waiting"
         });
       }
-      return T;
+      return m;
     });
   };
-  r.getState().updaterState[g] || (mt(
-    g,
-    ht(
-      g,
-      ct,
-      et.current,
-      D
+  o.getState().updaterState[f] || (mt(
+    f,
+    It(
+      f,
+      ot,
+      K.current,
+      _
     )
-  ), r.getState().cogsStateStore[g] || ot(g, t), r.getState().initialStateGlobal[g] || kt(g, t));
-  const l = Et(() => ht(
-    g,
-    ct,
-    et.current,
-    D
-  ), [g, D]);
-  return [Rt(g), l];
+  ), o.getState().cogsStateStore[f] || rt(f, t), o.getState().initialStateGlobal[f] || Tt(f, t));
+  const yt = Et(() => It(
+    f,
+    ot,
+    K.current,
+    _
+  ), [f, _]);
+  return [Rt(f), yt];
 }
-function ht(t, i, S, f) {
-  const h = /* @__PURE__ */ new Map();
-  let x = 0;
-  const p = (m) => {
-    const n = m.join(".");
-    for (const [u] of h)
-      (u === n || u.startsWith(n + ".")) && h.delete(u);
-    x++;
+function It(t, s, S, g) {
+  const I = /* @__PURE__ */ new Map();
+  let k = 0;
+  const w = (v) => {
+    const r = v.join(".");
+    for (const [h] of I)
+      (h === r || h.startsWith(r + ".")) && I.delete(h);
+    k++;
   }, y = {
-    removeValidation: (m) => {
-      m?.validationKey && Q(m.validationKey);
+    removeValidation: (v) => {
+      v?.validationKey && Q(v.validationKey);
     },
-    revertToInitialState: (m) => {
-      const n = r.getState().getInitialOptions(t)?.validation;
-      n?.key && Q(n?.key), m?.validationKey && Q(m.validationKey);
-      const u = r.getState().initialStateGlobal[t];
-      r.getState().clearSelectedIndexesForState(t), h.clear(), x++;
-      const L = s(u, []), R = st(t), D = tt(R?.localStorage?.key) ? R?.localStorage?.key(u) : R?.localStorage?.key, H = `${f}-${t}-${D}`;
-      H && localStorage.removeItem(H), mt(t, L), ot(t, u);
-      const g = r.getState().stateComponents.get(t);
-      return g && g.components.forEach((c) => {
+    revertToInitialState: (v) => {
+      const r = o.getState().getInitialOptions(t)?.validation;
+      r?.key && Q(r?.key), v?.validationKey && Q(v.validationKey);
+      const h = o.getState().initialStateGlobal[t];
+      o.getState().initializeShadowState(t, h), o.getState().clearSelectedIndexesForState(t), I.clear(), k++;
+      const M = $(h, []), _ = it(t), Y = X(_?.localStorage?.key) ? _?.localStorage?.key(h) : _?.localStorage?.key, f = `${g}-${t}-${Y}`;
+      f && localStorage.removeItem(f), mt(t, M), rt(t, h);
+      const G = o.getState().stateComponents.get(t);
+      return G && G.components.forEach((c) => {
         c.forceUpdate();
-      }), u;
+      }), h;
     },
-    updateInitialState: (m) => {
-      h.clear(), x++;
-      const n = ht(
+    updateInitialState: (v) => {
+      I.clear(), k++;
+      const r = It(
         t,
-        i,
+        s,
         S,
-        f
-      ), u = r.getState().initialStateGlobal[t], L = st(t), R = tt(L?.localStorage?.key) ? L?.localStorage?.key(u) : L?.localStorage?.key, D = `${f}-${t}-${R}`;
-      return localStorage.getItem(D) && localStorage.removeItem(D), Ft(() => {
-        kt(t, m), r.getState().initializeShadowState(t, m), mt(t, n), ot(t, m);
-        const H = r.getState().stateComponents.get(t);
-        H && H.components.forEach((g) => {
-          g.forceUpdate();
+        g
+      ), h = o.getState().initialStateGlobal[t], M = it(t), _ = X(M?.localStorage?.key) ? M?.localStorage?.key(h) : M?.localStorage?.key, Y = `${g}-${t}-${_}`;
+      return localStorage.getItem(Y) && localStorage.removeItem(Y), Dt(() => {
+        Tt(t, v), o.getState().initializeShadowState(t, v), mt(t, r), rt(t, v);
+        const f = o.getState().stateComponents.get(t);
+        f && f.components.forEach((G) => {
+          G.forceUpdate();
         });
       }), {
-        fetchId: (H) => n.get()[H]
+        fetchId: (f) => r.get()[f]
       };
     },
-    _initialState: r.getState().initialStateGlobal[t],
-    _serverState: r.getState().serverState[t],
-    _isLoading: r.getState().isLoadingGlobal[t],
+    _initialState: o.getState().initialStateGlobal[t],
+    _serverState: o.getState().serverState[t],
+    _isLoading: o.getState().isLoadingGlobal[t],
     _isServerSynced: () => {
-      const m = r.getState().serverState[t];
-      return !!(m && Y(m, Rt(t)));
+      const v = o.getState().serverState[t];
+      return !!(v && Z(v, Rt(t)));
     }
   };
-  function s(m, n = [], u) {
-    const L = n.map(String).join(".");
-    h.get(L);
-    const R = function() {
-      return r().getNestedState(t, n);
+  function i(v) {
+    const r = [t, ...v].join(".");
+    return o.getState().shadowStateStore.get(r)?.arrayKeys || null;
+  }
+  function $(v, r = [], h) {
+    const M = r.map(String).join(".");
+    I.get(M);
+    const _ = function() {
+      return o().getNestedState(t, r);
     };
-    Object.keys(y).forEach((g) => {
-      R[g] = y[g];
+    Object.keys(y).forEach((G) => {
+      _[G] = y[G];
     });
-    const D = {
-      apply(g, c, ft) {
-        return console.log(
-          `PROXY APPLY TRAP HIT: stateKey=${t}, path=${n.join(".")}`
-        ), console.trace("Apply trap stack trace"), r().getNestedState(t, n);
+    const Y = {
+      apply(G, c, K) {
+        return o().getNestedState(t, r);
       },
-      get(g, c) {
-        u?.validIndices && !Array.isArray(m) && (u = { ...u, validIndices: void 0 });
-        const ft = /* @__PURE__ */ new Set([
+      get(G, c) {
+        const K = /* @__PURE__ */ new Set([
           "insert",
           "cut",
           "cutByValue",
@@ -523,740 +530,669 @@ function ht(t, i, S, f) {
           "_stateKey",
           "getComponents"
         ]);
-        if (c !== "then" && !c.startsWith("$") && c !== "stateMapNoRender" && !ft.has(c)) {
-          const l = `${t}////${S}`, e = r.getState().stateComponents.get(t);
+        if (c !== "then" && !c.startsWith("$") && c !== "stateMapNoRender" && !K.has(c)) {
+          const n = `${t}////${S}`, e = o.getState().stateComponents.get(t);
           if (e) {
-            const o = e.components.get(l);
-            if (o && !o.paths.has("")) {
-              const a = n.join(".");
-              let d = !0;
-              for (const w of o.paths)
-                if (a.startsWith(w) && (a === w || a[w.length] === ".")) {
-                  d = !1;
+            const a = e.components.get(n);
+            if (a && !a.paths.has("")) {
+              const d = r.join(".");
+              let u = !0;
+              for (const l of a.paths)
+                if (d.startsWith(l) && (d === l || d[l.length] === ".")) {
+                  u = !1;
                   break;
                 }
-              d && o.paths.add(a);
+              u && a.paths.add(d);
             }
           }
         }
         if (c === "getDifferences")
-          return () => Tt(
-            r.getState().cogsStateStore[t],
-            r.getState().initialStateGlobal[t]
+          return () => Mt(
+            o.getState().cogsStateStore[t],
+            o.getState().initialStateGlobal[t]
           );
-        if (c === "sync" && n.length === 0)
+        if (c === "sync" && r.length === 0)
           return async function() {
-            const l = r.getState().getInitialOptions(t), e = l?.sync;
+            const n = o.getState().getInitialOptions(t), e = n?.sync;
             if (!e)
               return console.error(`No mutation defined for state key "${t}"`), { success: !1, error: "No mutation defined" };
-            const o = r.getState().getNestedState(t, []), a = l?.validation?.key;
+            const a = o.getState().getNestedState(t, []), d = n?.validation?.key;
             try {
-              const d = await e.action(o);
-              if (d && !d.success && d.errors && a) {
-                r.getState().removeValidationError(a), d.errors.forEach((v) => {
-                  const T = [a, ...v.path].join(".");
-                  r.getState().addValidationError(T, v.message);
-                });
-                const w = r.getState().stateComponents.get(t);
-                w && w.components.forEach((v) => {
-                  v.forceUpdate();
-                });
-              }
-              return d?.success && e.onSuccess ? e.onSuccess(d.data) : !d?.success && e.onError && e.onError(d.error), d;
-            } catch (d) {
-              return e.onError && e.onError(d), { success: !1, error: d };
+              const u = await e.action(a);
+              return u && !u.success && u.errors && d && (o.getState().removeValidationError(d), u.errors.forEach((l) => {
+                const m = [d, ...l.path].join(".");
+                o.getState().addValidationError(m, l.message);
+              }), et(t)), u?.success && e.onSuccess ? e.onSuccess(u.data) : !u?.success && e.onError && e.onError(u.error), u;
+            } catch (u) {
+              return e.onError && e.onError(u), { success: !1, error: u };
             }
           };
         if (c === "_status") {
-          const l = r.getState().getNestedState(t, n), e = r.getState().initialStateGlobal[t], o = Z(e, n);
-          return Y(l, o) ? "fresh" : "stale";
+          const n = o.getState().getNestedState(t, r), e = o.getState().initialStateGlobal[t], a = U(e, r);
+          return Z(n, a) ? "fresh" : "stale";
         }
         if (c === "getStatus")
           return function() {
-            const l = r().getNestedState(
+            const n = o().getNestedState(
               t,
-              n
-            ), e = r.getState().initialStateGlobal[t], o = Z(e, n);
-            return Y(l, o) ? "fresh" : "stale";
+              r
+            ), e = o.getState().initialStateGlobal[t], a = U(e, r);
+            return Z(n, a) ? "fresh" : "stale";
           };
         if (c === "removeStorage")
           return () => {
-            const l = r.getState().initialStateGlobal[t], e = st(t), o = tt(e?.localStorage?.key) ? e?.localStorage?.key(l) : e?.localStorage?.key, a = `${f}-${t}-${o}`;
-            a && localStorage.removeItem(a);
+            const n = o.getState().initialStateGlobal[t], e = it(t), a = X(e?.localStorage?.key) ? e.localStorage.key(n) : e?.localStorage?.key, d = `${g}-${t}-${a}`;
+            d && localStorage.removeItem(d);
           };
         if (c === "showValidationErrors")
           return () => {
-            const l = r.getState().getInitialOptions(t)?.validation;
-            if (!l?.key)
-              throw new Error("Validation key not found");
-            return r.getState().getValidationErrors(l.key + "." + n.join("."));
+            const n = o.getState().getInitialOptions(t)?.validation;
+            if (!n?.key) throw new Error("Validation key not found");
+            return o.getState().getValidationErrors(n.key + "." + r.join("."));
           };
-        if (Array.isArray(m)) {
-          const l = () => u?.validIndices ? m.map((o, a) => ({
-            item: o,
-            originalIndex: u.validIndices[a]
-          })) : r.getState().getNestedState(t, n).map((o, a) => ({
-            item: o,
-            originalIndex: a
-          }));
+        if (Array.isArray(v)) {
           if (c === "getSelected")
             return () => {
-              const e = r.getState().getSelectedIndex(t, n.join("."));
-              if (e !== void 0)
-                return s(
-                  m[e],
-                  [...n, e.toString()],
-                  u
-                );
+              const n = o.getState().getSelectedIndex(t, r.join("."));
+              if (n === void 0) return;
+              const e = o.getState().getNestedState(t, r);
+              if (!e || n >= e.length)
+                return;
+              const a = e[n], d = `id:${a.id}`;
+              return $(a, [...r, d], h);
             };
           if (c === "clearSelected")
             return () => {
-              r.getState().clearSelectedIndex({ stateKey: t, path: n });
+              o.getState().clearSelectedIndex({ stateKey: t, path: r });
             };
           if (c === "getSelectedIndex")
-            return () => r.getState().getSelectedIndex(t, n.join(".")) ?? -1;
+            return () => {
+              const n = o.getState().getSelectedIndex(t, r.join("."));
+              if (n === void 0) return -1;
+              if (h?.validIds) {
+                const a = (i(r) || [])[n];
+                return a ? h.validIds.indexOf(a) : -1;
+              }
+              return n;
+            };
           if (c === "useVirtualView")
-            return (e) => {
+            return (n) => {
               const {
-                itemHeight: o = 50,
+                itemHeight: e = 50,
                 overscan: a = 6,
                 stickToBottom: d = !1,
-                dependencies: w = []
-              } = e, v = q(null), [T, E] = it({
+                dependencies: u = []
+              } = n, l = z(null), [m, x] = ct({
                 startIndex: 0,
                 endIndex: 10
-              }), [k, C] = it(0), $ = q(!0), M = q(!1), z = q(0), K = q(T);
-              rt(() => r.getState().subscribeToShadowState(t, () => {
-                C((V) => V + 1);
+              }), [b, R] = ct(0), B = z(!0), D = z(!1), H = z(0), at = z(m), N = i(r);
+              nt(() => o.getState().subscribeToShadowState(t, () => {
+                R((j) => j + 1);
               }), [t]);
-              const _ = r().getNestedState(
+              const T = o().getNestedState(
                 t,
-                n
-              ), I = _.length, { totalHeight: j, positions: N } = Et(() => {
-                const b = r.getState().getShadowMetadata(t, n) || [];
+                r
+              ), E = T.length, { totalHeight: p, positions: A } = Et(() => {
                 let V = 0;
-                const P = [];
-                for (let W = 0; W < I; W++) {
-                  P[W] = V;
-                  const J = b[W]?.virtualizer?.itemHeight;
-                  V += J || o;
+                const j = [];
+                for (let F = 0; F < E; F++) {
+                  j[F] = V;
+                  const L = N?.[F];
+                  if (L) {
+                    const tt = [...r, L], st = o.getState().getShadowMetadata(t, tt)?.virtualizer?.itemHeight;
+                    V += st || e;
+                  } else
+                    V += e;
                 }
-                return { totalHeight: V, positions: P };
+                return { totalHeight: V, positions: j };
               }, [
-                I,
+                E,
                 t,
-                n.join("."),
-                o,
-                k
-              ]), A = Et(() => {
-                const b = Math.max(0, T.startIndex), V = Math.min(I, T.endIndex), P = Array.from(
-                  { length: V - b },
-                  (J, at) => b + at
-                ), W = P.map((J) => _[J]);
-                return s(W, n, {
-                  ...u,
-                  validIndices: P
+                r.join("."),
+                e,
+                b,
+                N
+              ]), C = Et(() => {
+                const V = Math.max(0, m.startIndex), j = Math.min(E, m.endIndex), F = T.slice(V, j), L = N?.slice(V, j);
+                return $(F, r, {
+                  ...h,
+                  validIds: L
                 });
-              }, [T.startIndex, T.endIndex, _, I]), U = St(() => {
-                const b = r.getState().getShadowMetadata(t, n) || [], V = I - 1;
-                if (V >= 0) {
-                  const P = b[V];
-                  if (P?.virtualizer?.domRef) {
-                    const W = P.virtualizer.domRef;
-                    if (W && W.scrollIntoView)
-                      return W.scrollIntoView({
+              }, [
+                m.startIndex,
+                m.endIndex,
+                T,
+                E,
+                N
+              ]), q = St(() => {
+                const V = E - 1;
+                if (V >= 0 && N?.[V]) {
+                  const j = N[V], F = [...r, j], L = o.getState().getShadowMetadata(t, F);
+                  if (L?.virtualizer?.domRef) {
+                    const tt = L.virtualizer.domRef;
+                    if (tt?.scrollIntoView)
+                      return tt.scrollIntoView({
                         behavior: "auto",
-                        block: "end",
-                        inline: "nearest"
+                        block: "end"
                       }), !0;
                   }
                 }
                 return !1;
-              }, [t, n, I]);
-              rt(() => {
-                if (!d || I === 0) return;
-                const b = I > z.current, V = z.current === 0 && I > 0;
-                if ((b || V) && $.current && !M.current) {
-                  const P = Math.ceil(
-                    (v.current?.clientHeight || 0) / o
-                  ), W = {
-                    startIndex: Math.max(
-                      0,
-                      I - P - a
-                    ),
-                    endIndex: I
-                  };
-                  E(W);
-                  const J = setTimeout(() => {
-                    B(I - 1, "smooth");
-                  }, 50);
-                  return () => clearTimeout(J);
-                }
-                z.current = I;
-              }, [I, o, a]), rt(() => {
-                const b = v.current;
-                if (!b) return;
-                const V = () => {
-                  const { scrollTop: P, scrollHeight: W, clientHeight: J } = b, at = W - P - J;
-                  $.current = at < 5, at > 100 && (M.current = !0), at < 5 && (M.current = !1);
-                  let nt = 0;
-                  for (let X = 0; X < N.length; X++)
-                    if (N[X] > P - o * a) {
-                      nt = Math.max(0, X - 1);
+              }, [t, r, E, N]);
+              nt(() => {
+                if (!d || E === 0) return;
+                E > H.current && B.current && !D.current && setTimeout(() => O(E - 1, "smooth"), 50), H.current = E;
+              }, [E, d]), nt(() => {
+                const V = l.current;
+                if (!V) return;
+                const j = () => {
+                  const { scrollTop: F, scrollHeight: L, clientHeight: tt } = V, gt = L - F - tt;
+                  B.current = gt < 5, gt > 100 && (D.current = !0), gt < 5 && (D.current = !1);
+                  let st = 0;
+                  for (let J = 0; J < A.length; J++)
+                    if (A[J] > F - e * a) {
+                      st = Math.max(0, J - 1);
                       break;
                     }
-                  let xt = nt;
-                  const jt = P + J;
-                  for (let X = nt; X < N.length && !(N[X] > jt + o * a); X++)
-                    xt = X;
-                  const vt = Math.max(0, nt), It = Math.min(
-                    I,
-                    xt + 1 + a
+                  let bt = st;
+                  const Ft = F + tt;
+                  for (let J = st; J < A.length && !(A[J] > Ft + e * a); J++)
+                    bt = J;
+                  const ht = Math.max(0, st), wt = Math.min(
+                    E,
+                    bt + 1 + a
                   );
-                  (vt !== K.current.startIndex || It !== K.current.endIndex) && (K.current = {
-                    startIndex: vt,
-                    endIndex: It
-                  }, E({
-                    startIndex: vt,
-                    endIndex: It
+                  (ht !== at.current.startIndex || wt !== at.current.endIndex) && (at.current = {
+                    startIndex: ht,
+                    endIndex: wt
+                  }, x({
+                    startIndex: ht,
+                    endIndex: wt
                   }));
                 };
-                if (b.addEventListener("scroll", V, {
+                return V.addEventListener("scroll", j, {
                   passive: !0
-                }), d && I > 0 && !M.current) {
-                  const { scrollTop: P } = b;
-                  P === 0 && (b.scrollTop = b.scrollHeight, $.current = !0);
-                }
-                return V(), () => {
-                  b.removeEventListener("scroll", V);
-                };
-              }, [N, I, o, a, d]);
-              const F = St(() => {
-                $.current = !0, M.current = !1, !U() && v.current && (v.current.scrollTop = v.current.scrollHeight);
-              }, [U]), B = St(
-                (b, V = "smooth") => {
-                  const P = v.current;
-                  if (!P) return;
-                  if (b === I - 1) {
-                    P.scrollTo({
-                      top: P.scrollHeight,
-                      behavior: V
-                    });
-                    return;
-                  }
-                  const nt = (r.getState().getShadowMetadata(t, n) || [])[b]?.virtualizer?.domRef;
-                  nt ? nt.scrollIntoView({
-                    behavior: V,
-                    block: "center"
-                  }) : N[b] !== void 0 && P.scrollTo({
-                    top: N[b],
-                    behavior: V
-                  });
+                }), j(), () => V.removeEventListener("scroll", j);
+              }, [A, E, e, a, d]);
+              const W = St(() => {
+                B.current = !0, D.current = !1, !q() && l.current && (l.current.scrollTop = l.current.scrollHeight);
+              }, [q]), O = St(
+                (V, j = "smooth") => {
+                  const F = l.current;
+                  if (!F) return;
+                  const L = A[V];
+                  L !== void 0 && F.scrollTo({ top: L, behavior: j });
                 },
-                [N, t, n, I]
-                // Add totalCount to the dependencies
-              ), G = {
+                [A]
+              ), lt = {
                 outer: {
-                  ref: v,
+                  ref: l,
                   style: { overflowY: "auto", height: "100%" }
                 },
                 inner: {
                   style: {
-                    height: `${j}px`,
+                    height: `${p}px`,
                     position: "relative"
                   }
                 },
                 list: {
                   style: {
-                    transform: `translateY(${N[T.startIndex] || 0}px)`
+                    transform: `translateY(${A[m.startIndex] || 0}px)`
                   }
                 }
               };
               return {
-                virtualState: A,
-                virtualizerProps: G,
-                scrollToBottom: F,
-                scrollToIndex: B
+                virtualState: C,
+                virtualizerProps: lt,
+                scrollToBottom: W,
+                scrollToIndex: O
               };
             };
+          if (c === "stateMap")
+            return (n) => {
+              const e = v, a = h?.validIds || i(r) || [], d = $(v, r, h);
+              return e.map((u, l) => {
+                const m = a[l] || `id:${u.id}`, x = [...r, m], b = $(u, x, h);
+                return n(
+                  u,
+                  b,
+                  l,
+                  v,
+                  d
+                );
+              });
+            };
           if (c === "stateMapNoRender")
-            return (e) => m.map((a, d) => {
-              let w;
-              u?.validIndices && u.validIndices[d] !== void 0 ? w = u.validIndices[d] : w = d;
-              const v = [...n, w.toString()], T = s(a, v, u);
-              return e(
-                a,
-                T,
-                d,
-                m,
-                s(m, n, u)
-              );
-            });
+            return (n) => {
+              const e = v, a = h?.validIds || i(r) || [], d = $(v, r, h);
+              return e.map((u, l) => {
+                const m = a[l] || `id:${u.id}`, x = [...r, m], b = $(u, x, h);
+                return n(
+                  u,
+                  b,
+                  l,
+                  v,
+                  d
+                );
+              });
+            };
           if (c === "$stateMap")
-            return (e) => dt(Kt, {
-              proxy: {
-                _stateKey: t,
-                _path: n,
-                _mapFn: e
-                // Pass the actual function, not string
-              },
-              rebuildStateShape: s
+            return (n) => ut(te, {
+              proxy: { _stateKey: t, _path: r, _mapFn: n },
+              rebuildStateShape: $
             });
           if (c === "stateList")
-            return (e, o) => {
-              const a = r.getState().getNestedState(t, n);
-              return Array.isArray(a) ? (u?.validIndices || Array.from({ length: a.length }, (w, v) => v)).map((w, v) => {
-                const T = a[w], E = [...n, w.toString()], k = s(T, E, u), C = `${S}-${n.join(".")}-${w}`;
-                return dt(ee, {
-                  key: w,
+            return (n) => {
+              const e = v;
+              if (!Array.isArray(e)) return null;
+              const a = h?.validIds || i(r) || [], d = i(r) || [], u = $(
+                e,
+                r,
+                h
+              );
+              return e.map((l, m) => {
+                const x = a[m] || `id:${l.id}`, b = d.indexOf(x), R = [...r, x], B = $(l, R, h), D = `${S}-${r.join(".")}-${x}`;
+                return ut(ne, {
+                  key: x,
                   stateKey: t,
-                  itemComponentId: C,
-                  formOpts: o,
-                  itemPath: E,
-                  children: e(
-                    T,
-                    k,
-                    { localIndex: v, originalIndex: w },
-                    a,
-                    s(a, n, u)
+                  itemComponentId: D,
+                  itemPath: R,
+                  children: n(
+                    l,
+                    B,
+                    { localIndex: m, originalIndex: b },
+                    e,
+                    u
                   )
                 });
-              }) : (console.warn(
-                `stateList called on a non-array value at path: ${n.join(".")}.`
-              ), null);
+              });
             };
           if (c === "stateFlattenOn")
-            return (e) => {
-              const o = m;
-              h.clear(), x++;
-              const a = o.flatMap(
-                (d) => d[e] ?? []
+            return (n) => {
+              const e = v;
+              I.clear(), k++;
+              const a = e.flatMap(
+                (d) => d[n] ?? []
               );
-              return s(
+              return $(
                 a,
-                [...n, "[*]", e],
-                u
+                [...r, "[*]", n],
+                h
               );
             };
           if (c === "index")
-            return (e) => {
-              const o = m[e];
-              return s(o, [...n, e.toString()]);
+            return (n) => {
+              const a = (h?.validIds || i(r))?.[n];
+              if (!a)
+                return $(void 0, [
+                  ...r,
+                  n.toString()
+                ]);
+              const u = o.getState().getNestedState(t, r).find(
+                (m) => `id:${m.id}` === a
+              ), l = [...r, a];
+              return $(u, l, h);
             };
           if (c === "last")
             return () => {
-              const e = r.getState().getNestedState(t, n);
-              if (e.length === 0) return;
-              const o = e.length - 1, a = e[o], d = [...n, o.toString()];
-              return s(a, d);
+              const n = o.getState().getNestedState(t, r);
+              if (n.length === 0) return;
+              const e = n.length - 1, a = n[e], d = [...r, e.toString()];
+              return $(a, d);
             };
           if (c === "insert")
-            return (e) => (p(n), wt(i, e, n, t), s(
-              r.getState().getNestedState(t, n),
-              n
+            return (n) => (w(r), $t(s, n, r, t), $(
+              o.getState().getNestedState(t, r),
+              r
             ));
           if (c === "uniqueInsert")
-            return (e, o, a) => {
-              const d = r.getState().getNestedState(t, n), w = tt(e) ? e(d) : e;
-              let v = null;
-              if (!d.some((E) => {
-                if (o) {
-                  const C = o.every(
-                    ($) => Y(E[$], w[$])
-                  );
-                  return C && (v = E), C;
-                }
-                const k = Y(E, w);
-                return k && (v = E), k;
+            return (n, e, a) => {
+              const d = o.getState().getNestedState(t, r), u = X(n) ? n(d) : n;
+              let l = null;
+              if (!d.some((x) => {
+                const b = e ? e.every(
+                  (R) => Z(x[R], u[R])
+                ) : Z(x, u);
+                return b && (l = x), b;
               }))
-                p(n), wt(i, w, n, t);
-              else if (a && v) {
-                const E = a(v), k = d.map(
-                  (C) => Y(C, v) ? E : C
+                w(r), $t(s, u, r, t);
+              else if (a && l) {
+                const x = a(l), b = d.map(
+                  (R) => Z(R, l) ? x : R
                 );
-                p(n), lt(i, k, n);
+                w(r), dt(s, b, r);
               }
             };
           if (c === "cut")
-            return (e, o) => {
-              if (!o?.waitForSync)
-                return p(n), gt(i, n, t, e), s(
-                  r.getState().getNestedState(t, n),
-                  n
+            return (n, e) => {
+              if (!e?.waitForSync)
+                return w(r), ft(s, r, t, n), $(
+                  o.getState().getNestedState(t, r),
+                  r
                 );
             };
           if (c === "cutByValue")
-            return (e) => {
-              for (let o = 0; o < m.length; o++)
-                m[o] === e && gt(i, n, t, o);
+            return (n) => {
+              const e = v.findIndex((a) => a === n);
+              e > -1 && ft(s, r, t, e);
             };
           if (c === "toggleByValue")
-            return (e) => {
-              const o = m.findIndex((a) => a === e);
-              o > -1 ? gt(i, n, t, o) : wt(i, e, n, t);
+            return (n) => {
+              const e = v.findIndex((a) => a === n);
+              e > -1 ? ft(s, r, t, e) : $t(s, n, r, t);
             };
-          if (c === "stateFind")
-            return (e) => {
-              const a = l().find(
-                ({ item: w }, v) => e(w, v)
-              );
-              if (!a) return;
-              const d = [...n, a.originalIndex.toString()];
-              return s(a.item, d, u);
+          if (c === "stateFilter")
+            return (n) => {
+              const e = h?.validIds || i(r) || [], a = o.getState().getNestedState(t, r), d = new Map(
+                a.map((m) => [`id:${m.id}`, m])
+              ), u = [], l = [];
+              return e.forEach((m, x) => {
+                const b = d.get(m);
+                b && n(b, x) && (u.push(m), l.push(b));
+              }), $(l, r, {
+                validIds: u
+              });
+            };
+          if (c === "stateSort")
+            return (n) => {
+              const a = v.map((l) => ({
+                item: l,
+                id: `id:${l.id}`
+              }));
+              a.sort((l, m) => n(l.item, m.item));
+              const d = a.map((l) => l.item), u = a.map((l) => l.id);
+              return $(d, r, {
+                validIds: u
+              });
             };
           if (c === "findWith")
-            return (e, o) => {
-              const d = l().find(
-                ({ item: v }) => v[e] === o
+            return (n, e) => {
+              const a = v.find(
+                (l) => l[n] === e
               );
-              if (!d) return;
-              const w = [...n, d.originalIndex.toString()];
-              return s(d.item, w, u);
+              if (!a) return;
+              const d = `id:${a.id}`, u = [...r, d];
+              return $(a, u, h);
             };
         }
-        const et = n[n.length - 1];
-        if (!isNaN(Number(et))) {
-          const l = n.slice(0, -1), e = r.getState().getNestedState(t, l);
+        const P = r[r.length - 1];
+        if (!isNaN(Number(P))) {
+          const n = r.slice(0, -1), e = o.getState().getNestedState(t, n);
           if (Array.isArray(e) && c === "cut")
-            return () => gt(
-              i,
-              l,
+            return () => ft(
+              s,
+              n,
               t,
-              Number(et)
+              Number(P)
             );
         }
         if (c === "get")
           return () => {
-            if (u?.validIndices && Array.isArray(m)) {
-              const l = r.getState().getNestedState(t, n);
-              return u.validIndices.map((e) => l[e]);
+            if (h?.validIds && Array.isArray(v)) {
+              const n = o.getState().getNestedState(t, r);
+              if (!Array.isArray(n)) return [];
+              const e = new Map(
+                n.map((a) => [`id:${a.id}`, a])
+              );
+              return h.validIds.map((a) => e.get(a)).filter(Boolean);
             }
-            return r.getState().getNestedState(t, n);
+            return o.getState().getNestedState(t, r);
           };
         if (c === "$derive")
-          return (l) => Pt({
+          return (n) => _t({
             _stateKey: t,
-            _path: n,
-            _effect: l.toString()
+            _path: r,
+            _effect: n.toString()
           });
         if (c === "$get")
-          return () => Pt({
-            _stateKey: t,
-            _path: n
-          });
+          return () => _t({ _stateKey: t, _path: r });
         if (c === "lastSynced") {
-          const l = `${t}:${n.join(".")}`;
-          return r.getState().getSyncInfo(l);
+          const n = `${t}:${r.join(".")}`;
+          return o.getState().getSyncInfo(n);
         }
         if (c == "getLocalStorage")
-          return (l) => yt(f + "-" + t + "-" + l);
+          return (n) => vt(g + "-" + t + "-" + n);
         if (c === "_selected") {
-          const l = n.slice(0, -1), e = l.join("."), o = r.getState().getNestedState(t, l);
-          return Array.isArray(o) ? Number(n[n.length - 1]) === r.getState().getSelectedIndex(t, e) : void 0;
+          const n = r.slice(0, -1), e = n.join(".");
+          if (Array.isArray(
+            o.getState().getNestedState(t, n)
+          )) {
+            const a = r[r.length - 1];
+            return i(n)?.indexOf(a) === o.getState().getSelectedIndex(t, e);
+          }
+          return;
         }
         if (c === "setSelected")
-          return (l) => {
-            const e = n.slice(0, -1), o = Number(n[n.length - 1]), a = e.join(".");
-            l ? r.getState().setSelectedIndex(t, a, o) : r.getState().setSelectedIndex(t, a, void 0);
-            const d = r.getState().getNestedState(t, [...e]);
-            lt(i, d, e), p(e);
+          return (n) => {
+            const e = r.slice(0, -1), a = r[r.length - 1], u = i(e)?.indexOf(a);
+            if (u === void 0 || u === -1) return;
+            const l = e.join(".");
+            o.getState().setSelectedIndex(
+              t,
+              l,
+              n ? u : void 0
+            );
+            const m = o.getState().getNestedState(t, [...e]);
+            dt(s, m, e), w(e);
           };
         if (c === "toggleSelected")
           return () => {
-            const l = n.slice(0, -1), e = Number(n[n.length - 1]), o = l.join("."), a = r.getState().getSelectedIndex(t, o);
-            r.getState().setSelectedIndex(
+            const n = r.slice(0, -1), e = r[r.length - 1], d = i(n)?.indexOf(e);
+            if (d === void 0 || d === -1) return;
+            const u = n.join("."), l = o.getState().getSelectedIndex(t, u);
+            o.getState().setSelectedIndex(
               t,
-              o,
-              a === e ? void 0 : e
+              u,
+              l === d ? void 0 : d
             );
-            const d = r.getState().getNestedState(t, [...l]);
-            lt(i, d, l), p(l);
+            const m = o.getState().getNestedState(t, [...n]);
+            dt(s, m, n), w(n);
           };
-        if (n.length == 0) {
+        if (r.length == 0) {
           if (c === "addValidation")
-            return (l) => {
-              const e = r.getState().getInitialOptions(t)?.validation;
-              if (!e?.key)
-                throw new Error("Validation key not found");
-              Q(e.key), console.log("addValidationError", l), l.forEach((o) => {
-                const a = [e.key, ...o.path].join(".");
-                console.log("fullErrorPath", a), Mt(a, o.message);
-              }), ut(t);
+            return (n) => {
+              const e = o.getState().getInitialOptions(t)?.validation;
+              if (!e?.key) throw new Error("Validation key not found");
+              Q(e.key), n.forEach((a) => {
+                const d = [e.key, ...a.path].join(".");
+                xt(d, a.message);
+              }), et(t);
             };
           if (c === "applyJsonPatch")
-            return (l) => {
-              const e = r.getState().cogsStateStore[t], a = zt(e, l).newDocument;
-              Ot(
+            return (n) => {
+              const e = o.getState().cogsStateStore[t], a = Ht(e, n).newDocument;
+              jt(
                 t,
-                r.getState().initialStateGlobal[t],
+                o.getState().initialStateGlobal[t],
                 a,
-                i,
+                s,
                 S,
-                f
-              );
-              const d = r.getState().stateComponents.get(t);
-              if (d) {
-                const w = Tt(e, a), v = new Set(w);
-                for (const [
-                  T,
-                  E
-                ] of d.components.entries()) {
-                  let k = !1;
-                  const C = Array.isArray(E.reactiveType) ? E.reactiveType : [E.reactiveType || "component"];
-                  if (!C.includes("none")) {
-                    if (C.includes("all")) {
-                      E.forceUpdate();
-                      continue;
-                    }
-                    if (C.includes("component") && (E.paths.has("") && (k = !0), !k))
-                      for (const $ of v) {
-                        if (E.paths.has($)) {
-                          k = !0;
-                          break;
-                        }
-                        let M = $.lastIndexOf(".");
-                        for (; M !== -1; ) {
-                          const z = $.substring(0, M);
-                          if (E.paths.has(z)) {
-                            k = !0;
-                            break;
-                          }
-                          const K = $.substring(
-                            M + 1
-                          );
-                          if (!isNaN(Number(K))) {
-                            const _ = z.lastIndexOf(".");
-                            if (_ !== -1) {
-                              const I = z.substring(
-                                0,
-                                _
-                              );
-                              if (E.paths.has(I)) {
-                                k = !0;
-                                break;
-                              }
-                            }
-                          }
-                          M = z.lastIndexOf(".");
-                        }
-                        if (k) break;
-                      }
-                    if (!k && C.includes("deps") && E.depsFunction) {
-                      const $ = E.depsFunction(a);
-                      let M = !1;
-                      typeof $ == "boolean" ? $ && (M = !0) : Y(E.deps, $) || (E.deps = $, M = !0), M && (k = !0);
-                    }
-                    k && E.forceUpdate();
-                  }
-                }
-              }
+                g
+              ), et(t);
             };
           if (c === "validateZodSchema")
             return () => {
-              const l = r.getState().getInitialOptions(t)?.validation, e = r.getState().addValidationError;
-              if (!l?.zodSchema)
-                throw new Error("Zod schema not found");
-              if (!l?.key)
-                throw new Error("Validation key not found");
-              Q(l.key);
-              const o = r.getState().cogsStateStore[t];
-              try {
-                const a = r.getState().getValidationErrors(l.key);
-                a && a.length > 0 && a.forEach(([w]) => {
-                  w && w.startsWith(l.key) && Q(w);
-                });
-                const d = l.zodSchema.safeParse(o);
-                return d.success ? !0 : (d.error.errors.forEach((v) => {
-                  const T = v.path, E = v.message, k = [l.key, ...T].join(".");
-                  e(k, E);
-                }), ut(t), !1);
-              } catch (a) {
-                return console.error("Zod schema validation failed", a), !1;
-              }
+              const n = o.getState().getInitialOptions(t)?.validation;
+              if (!n?.zodSchema || !n?.key)
+                throw new Error("Zod schema or validation key not found");
+              Q(n.key);
+              const e = o.getState().cogsStateStore[t], a = n.zodSchema.safeParse(e);
+              return a.success ? !0 : (a.error.errors.forEach((d) => {
+                const u = [n.key, ...d.path].join(".");
+                xt(u, d.message);
+              }), et(t), !1);
             };
           if (c === "_componentId") return S;
           if (c === "getComponents")
-            return () => r().stateComponents.get(t);
+            return () => o().stateComponents.get(t);
           if (c === "getAllFormRefs")
-            return () => bt.getState().getFormRefsByStateKey(t);
+            return () => Vt.getState().getFormRefsByStateKey(t);
           if (c === "_initialState")
-            return r.getState().initialStateGlobal[t];
+            return o.getState().initialStateGlobal[t];
           if (c === "_serverState")
-            return r.getState().serverState[t];
+            return o.getState().serverState[t];
           if (c === "_isLoading")
-            return r.getState().isLoadingGlobal[t];
+            return o.getState().isLoadingGlobal[t];
           if (c === "revertToInitialState")
             return y.revertToInitialState;
           if (c === "updateInitialState") return y.updateInitialState;
           if (c === "removeValidation") return y.removeValidation;
         }
         if (c === "getFormRef")
-          return () => bt.getState().getFormRef(t + "." + n.join("."));
+          return () => Vt.getState().getFormRef(t + "." + r.join("."));
         if (c === "validationWrapper")
           return ({
-            children: l,
+            children: n,
             hideMessage: e
-          }) => /* @__PURE__ */ pt(
-            Gt,
+          }) => /* @__PURE__ */ At(
+            Wt,
             {
               formOpts: e ? { validation: { message: "" } } : void 0,
-              path: n,
+              path: r,
               stateKey: t,
-              validIndices: u?.validIndices,
-              children: l
+              children: n
             }
           );
         if (c === "_stateKey") return t;
-        if (c === "_path") return n;
+        if (c === "_path") return r;
         if (c === "_isServerSynced") return y._isServerSynced;
         if (c === "update")
-          return (l, e) => {
+          return (n, e) => {
             if (e?.debounce)
-              Lt(() => {
-                lt(i, l, n, "");
-                const o = r.getState().getNestedState(t, n);
-                e?.afterUpdate && e.afterUpdate(o);
+              Gt(() => {
+                dt(s, n, r, "");
+                const a = o.getState().getNestedState(t, r);
+                e?.afterUpdate && e.afterUpdate(a);
               }, e.debounce);
             else {
-              lt(i, l, n, "");
-              const o = r.getState().getNestedState(t, n);
-              e?.afterUpdate && e.afterUpdate(o);
+              dt(s, n, r, "");
+              const a = o.getState().getNestedState(t, r);
+              e?.afterUpdate && e.afterUpdate(a);
             }
-            p(n);
+            w(r);
           };
         if (c === "formElement")
-          return (l, e) => /* @__PURE__ */ pt(
-            Wt,
+          return (n, e) => /* @__PURE__ */ At(
+            zt,
             {
-              setState: i,
+              setState: s,
               stateKey: t,
-              path: n,
-              child: l,
+              path: r,
+              child: n,
               formOpts: e
             }
           );
-        const O = [...n, c], ct = r.getState().getNestedState(t, O);
-        return s(ct, O, u);
+        const ot = [...r, c], yt = o.getState().getNestedState(t, ot);
+        return $(yt, ot, h);
       }
-    }, H = new Proxy(R, D);
-    return h.set(L, {
-      proxy: H,
-      stateVersion: x
-    }), H;
+    }, f = new Proxy(_, Y);
+    return I.set(M, {
+      proxy: f,
+      stateVersion: k
+    }), f;
   }
-  return s(
-    r.getState().getNestedState(t, [])
+  return $(
+    o.getState().getNestedState(t, [])
   );
 }
-function Pt(t) {
-  return dt(te, { proxy: t });
+function _t(t) {
+  return ut(ee, { proxy: t });
 }
-function Kt({
+function te({
   proxy: t,
-  rebuildStateShape: i
+  rebuildStateShape: s
 }) {
-  const S = r().getNestedState(t._stateKey, t._path);
-  return Array.isArray(S) ? i(
+  const S = o().getNestedState(t._stateKey, t._path);
+  return Array.isArray(S) ? s(
     S,
     t._path
   ).stateMapNoRender(
-    (h, x, p, y, s) => t._mapFn(h, x, p, y, s)
+    (I, k, w, y, i) => t._mapFn(I, k, w, y, i)
   ) : null;
 }
-function te({
+function ee({
   proxy: t
 }) {
-  const i = q(null), S = `${t._stateKey}-${t._path.join(".")}`;
-  return rt(() => {
-    const f = i.current;
-    if (!f || !f.parentElement) return;
-    const h = f.parentElement, p = Array.from(h.childNodes).indexOf(f);
-    let y = h.getAttribute("data-parent-id");
-    y || (y = `parent-${crypto.randomUUID()}`, h.setAttribute("data-parent-id", y));
-    const m = {
+  const s = z(null), S = `${t._stateKey}-${t._path.join(".")}`;
+  return nt(() => {
+    const g = s.current;
+    if (!g || !g.parentElement) return;
+    const I = g.parentElement, w = Array.from(I.childNodes).indexOf(g);
+    let y = I.getAttribute("data-parent-id");
+    y || (y = `parent-${crypto.randomUUID()}`, I.setAttribute("data-parent-id", y));
+    const $ = {
       instanceId: `instance-${crypto.randomUUID()}`,
       parentId: y,
-      position: p,
+      position: w,
       effect: t._effect
     };
-    r.getState().addSignalElement(S, m);
-    const n = r.getState().getNestedState(t._stateKey, t._path);
-    let u;
+    o.getState().addSignalElement(S, $);
+    const v = o.getState().getNestedState(t._stateKey, t._path);
+    let r = v;
     if (t._effect)
       try {
-        u = new Function(
+        r = new Function(
           "state",
           `return (${t._effect})(state)`
-        )(n);
-      } catch (R) {
-        console.error("Error evaluating effect function during mount:", R), u = n;
+        )(v);
+      } catch (M) {
+        console.error("Error evaluating effect function:", M);
       }
-    else
-      u = n;
-    u !== null && typeof u == "object" && (u = JSON.stringify(u));
-    const L = document.createTextNode(String(u));
-    f.replaceWith(L);
-  }, [t._stateKey, t._path.join("."), t._effect]), dt("span", {
-    ref: i,
+    r !== null && typeof r == "object" && (r = JSON.stringify(r));
+    const h = document.createTextNode(String(r));
+    g.replaceWith(h);
+  }, [t._stateKey, t._path.join("."), t._effect]), ut("span", {
+    ref: s,
     style: { display: "none" },
     "data-signal-id": S
   });
 }
-function he(t) {
-  const i = Ut(
+function ye(t) {
+  const s = Ut(
     (S) => {
-      const f = r.getState().stateComponents.get(t._stateKey) || {
-        components: /* @__PURE__ */ new Map()
-      };
-      return f.components.set(t._stateKey, {
+      const g = o.getState().stateComponents.get(t._stateKey) || { components: /* @__PURE__ */ new Map() };
+      return g.components.set(t._stateKey, {
         forceUpdate: S,
         paths: /* @__PURE__ */ new Set([t._path.join(".")])
-      }), () => f.components.delete(t._stateKey);
+      }), o.getState().stateComponents.set(t._stateKey, g), () => g.components.delete(t._stateKey);
     },
-    () => r.getState().getNestedState(t._stateKey, t._path)
+    () => o.getState().getNestedState(t._stateKey, t._path)
   );
-  return dt("text", {}, String(i));
+  return ut("text", {}, String(s));
 }
-function ee({
+function ne({
   stateKey: t,
-  itemComponentId: i,
+  itemComponentId: s,
   itemPath: S,
-  formOpts: f,
-  children: h
+  children: g
 }) {
-  const [, x] = it({}), [p, y] = Bt(), s = q(null), m = q(null), n = St(
-    (u) => {
-      p(u), s.current = u;
+  const [, I] = ct({}), [k, w] = qt(), y = z(null), i = z(null), $ = St(
+    (v) => {
+      k(v), y.current = v;
     },
-    [p]
+    [k]
   );
-  return rt(() => {
-    y.height > 0 && y.height !== m.current && (m.current = y.height, r.getState().setShadowMetadata(t, S, {
-      virtualizer: {
-        itemHeight: y.height,
-        domRef: s.current
-        // Store the actual DOM element reference
-      }
+  return nt(() => {
+    w.height > 0 && w.height !== i.current && (i.current = w.height, o.getState().setShadowMetadata(t, S, {
+      virtualizer: { itemHeight: w.height, domRef: y.current }
     }));
-  }, [y.height, t, S]), Ct(() => {
-    const u = `${t}////${i}`, L = r.getState().stateComponents.get(t) || {
-      components: /* @__PURE__ */ new Map()
-    };
-    return L.components.set(u, {
-      forceUpdate: () => x({}),
+  }, [w.height, t, S]), Pt(() => {
+    const v = `${t}////${s}`, r = o.getState().stateComponents.get(t) || { components: /* @__PURE__ */ new Map() };
+    return r.components.set(v, {
+      forceUpdate: () => I({}),
       paths: /* @__PURE__ */ new Set([S.join(".")])
-    }), r.getState().stateComponents.set(t, L), () => {
-      const R = r.getState().stateComponents.get(t);
-      R && R.components.delete(u);
+    }), o.getState().stateComponents.set(t, r), () => {
+      const h = o.getState().stateComponents.get(t);
+      h && h.components.delete(v);
     };
-  }, [t, i, S.join(".")]), /* @__PURE__ */ pt("div", { ref: n, children: h });
+  }, [t, s, S.join(".")]), /* @__PURE__ */ At("div", { ref: $, children: g });
 }
 export {
-  Pt as $cogsSignal,
-  he as $cogsSignalStore,
-  ge as addStateOptions,
-  Se as createCogsState,
-  me as notifyComponent,
-  Qt as useCogsStateFn
+  _t as $cogsSignal,
+  ye as $cogsSignalStore,
+  me as addStateOptions,
+  Ie as createCogsState,
+  ve as notifyComponent,
+  Kt as useCogsStateFn
 };
 //# sourceMappingURL=CogsState.jsx.map