cogsbox-state 0.5.427 → 0.5.429

package/dist/CogsState.jsx

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