cogsbox-state 0.5.242 → 0.5.244

package/dist/CogsState.jsx

@@ -1,177 +1,177 @@
 "use client";
-import { jsx as fe } from "react/jsx-runtime";
-import { useState as se, useRef as ee, useEffect as ce, useLayoutEffect as we, useMemo as Ee, createElement as re, useSyncExternalStore as $e, startTransition as Ae } from "react";
-import { transformStateFunc as Ne, isDeepEqual as M, isFunction as z, getNestedValue as G, getDifferences as le, debounce as Ve } from "./utility.js";
-import { pushFunc as ie, updateFn as X, cutFunc as K, ValidationWrapper as ke, FormControlComponent as _e } from "./Functions.jsx";
-import Ce from "superjson";
-import { v4 as de } from "uuid";
+import { jsx as Se } from "react/jsx-runtime";
+import { useState as te, useRef as ee, useEffect as le, useLayoutEffect as pe, useMemo as ke, createElement as ae, useSyncExternalStore as Te, startTransition as Ae } from "react";
+import { transformStateFunc as Ne, isDeepEqual as G, isFunction as J, getNestedValue as L, getDifferences as de, debounce as Ve } from "./utility.js";
+import { pushFunc as ce, updateFn as X, cutFunc as K, ValidationWrapper as be, FormControlComponent as Ce } from "./Functions.jsx";
+import Pe from "superjson";
+import { v4 as ue } from "uuid";
 import "zod";
-import { getGlobalStore as n, formRefStore as Se } from "./store.js";
-import { useCogsConfig as pe } from "./CogsStateClient.jsx";
-import { applyPatch as Pe } from "fast-json-patch";
-function me(e, i) {
-  const S = n.getState().getInitialOptions, l = n.getState().setInitialStateOptions, c = S(e) || {};
-  l(e, {
-    ...c,
-    ...i
+import { getGlobalStore as n, formRefStore as me } from "./store.js";
+import { useCogsConfig as we } from "./CogsStateClient.jsx";
+import { applyPatch as _e } from "fast-json-patch";
+function ye(e, s) {
+  const y = n.getState().getInitialOptions, g = n.getState().setInitialStateOptions, m = y(e) || {};
+  g(e, {
+    ...m,
+    ...s
   });
 }
-function ye({
+function ve({
   stateKey: e,
-  options: i,
-  initialOptionsPart: S
+  options: s,
+  initialOptionsPart: y
 }) {
-  const l = Z(e) || {}, c = S[e] || {}, b = n.getState().setInitialStateOptions, p = { ...c, ...l };
-  let I = !1;
-  if (i)
-    for (const s in i)
-      p.hasOwnProperty(s) ? (s == "localStorage" && i[s] && p[s].key !== i[s]?.key && (I = !0, p[s] = i[s]), s == "initialState" && i[s] && p[s] !== i[s] && // Different references
-      !M(p[s], i[s]) && (I = !0, p[s] = i[s])) : (I = !0, p[s] = i[s]);
-  I && b(e, p);
+  const g = H(e) || {}, m = y[e] || {}, $ = n.getState().setInitialStateOptions, w = { ...m, ...g };
+  let h = !1;
+  if (s)
+    for (const i in s)
+      w.hasOwnProperty(i) ? (i == "localStorage" && s[i] && w[i].key !== s[i]?.key && (h = !0, w[i] = s[i]), i == "initialState" && s[i] && w[i] !== s[i] && // Different references
+      !G(w[i], s[i]) && (h = !0, w[i] = s[i])) : (h = !0, w[i] = s[i]);
+  h && $(e, w);
 }
-function Ke(e, { formElements: i, validation: S }) {
-  return { initialState: e, formElements: i, validation: S };
+function Qe(e, { formElements: s, validation: y }) {
+  return { initialState: e, formElements: s, validation: y };
 }
-const et = (e, i) => {
-  let S = e;
-  const [l, c] = Ne(S);
-  (Object.keys(c).length > 0 || i && Object.keys(i).length > 0) && Object.keys(c).forEach((I) => {
-    c[I] = c[I] || {}, c[I].formElements = {
-      ...i?.formElements,
+const Ke = (e, s) => {
+  let y = e;
+  const [g, m] = Ne(y);
+  (Object.keys(m).length > 0 || s && Object.keys(s).length > 0) && Object.keys(m).forEach((h) => {
+    m[h] = m[h] || {}, m[h].formElements = {
+      ...s?.formElements,
       // Global defaults first
-      ...i?.validation,
-      ...c[I].formElements || {}
+      ...s?.validation,
+      ...m[h].formElements || {}
       // State-specific overrides
-    }, Z(I) || n.getState().setInitialStateOptions(I, c[I]);
-  }), n.getState().setInitialStates(l), n.getState().setCreatedState(l);
-  const b = (I, s) => {
-    const [h] = se(s?.componentId ?? de());
-    ye({
-      stateKey: I,
-      options: s,
-      initialOptionsPart: c
+    }, H(h) || n.getState().setInitialStateOptions(h, m[h]);
+  }), n.getState().setInitialStates(g), n.getState().setCreatedState(g);
+  const $ = (h, i) => {
+    const [v] = te(i?.componentId ?? ue());
+    ve({
+      stateKey: h,
+      options: i,
+      initialOptionsPart: m
     });
-    const r = n.getState().cogsStateStore[I] || l[I], m = s?.modifyState ? s.modifyState(r) : r, [R, P] = Me(
-      m,
+    const r = n.getState().cogsStateStore[h] || g[h], f = i?.modifyState ? i.modifyState(r) : r, [U, C] = Me(
+      f,
       {
-        stateKey: I,
-        syncUpdate: s?.syncUpdate,
-        componentId: h,
-        localStorage: s?.localStorage,
-        middleware: s?.middleware,
-        enabledSync: s?.enabledSync,
-        reactiveType: s?.reactiveType,
-        reactiveDeps: s?.reactiveDeps,
-        initialState: s?.initialState,
-        dependencies: s?.dependencies,
-        serverState: s?.serverState
+        stateKey: h,
+        syncUpdate: i?.syncUpdate,
+        componentId: v,
+        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 P;
+    return C;
   };
-  function p(I, s) {
-    ye({ stateKey: I, options: s, initialOptionsPart: c }), s.localStorage && je(I, s), ae(I);
+  function w(h, i) {
+    ve({ stateKey: h, options: i, initialOptionsPart: m }), i.localStorage && Re(h, i), ie(h);
   }
-  return { useCogsState: b, setCogsOptions: p };
+  return { useCogsState: $, setCogsOptions: w };
 }, {
-  setUpdaterState: te,
-  setState: J,
-  getInitialOptions: Z,
-  getKeyState: Te,
+  setUpdaterState: ne,
+  setState: Z,
+  getInitialOptions: H,
+  getKeyState: Ee,
   getValidationErrors: xe,
   setStateLog: Oe,
   updateInitialStateGlobal: ge,
-  addValidationError: Fe,
-  removeValidationError: q,
-  setServerSyncActions: Re
-} = n.getState(), ve = (e, i, S, l, c) => {
-  S?.log && console.log(
+  addValidationError: je,
+  removeValidationError: B,
+  setServerSyncActions: Fe
+} = n.getState(), Ie = (e, s, y, g, m) => {
+  y?.log && console.log(
     "saving to localstorage",
-    i,
-    S.localStorage?.key,
-    l
+    s,
+    y.localStorage?.key,
+    g
   );
-  const b = z(S?.localStorage?.key) ? S.localStorage?.key(e) : S?.localStorage?.key;
-  if (b && l) {
-    const p = `${l}-${i}-${b}`;
-    let I;
+  const $ = J(y?.localStorage?.key) ? y.localStorage?.key(e) : y?.localStorage?.key;
+  if ($ && g) {
+    const w = `${g}-${s}-${$}`;
+    let h;
     try {
-      I = oe(p)?.lastSyncedWithServer;
+      h = oe(w)?.lastSyncedWithServer;
     } catch {
     }
-    const s = {
+    const i = {
       state: e,
       lastUpdated: Date.now(),
-      lastSyncedWithServer: c ?? I
-    }, h = Ce.serialize(s);
+      lastSyncedWithServer: m ?? h
+    }, v = Pe.serialize(i);
     window.localStorage.setItem(
-      p,
-      JSON.stringify(h.json)
+      w,
+      JSON.stringify(v.json)
     );
   }
 }, oe = (e) => {
   if (!e) return null;
   try {
-    const i = window.localStorage.getItem(e);
-    return i ? JSON.parse(i) : null;
-  } catch (i) {
-    return console.error("Error loading from localStorage:", i), null;
+    const s = window.localStorage.getItem(e);
+    return s ? JSON.parse(s) : null;
+  } catch (s) {
+    return console.error("Error loading from localStorage:", s), null;
   }
-}, je = (e, i) => {
-  const S = n.getState().cogsStateStore[e], { sessionId: l } = pe(), c = z(i?.localStorage?.key) ? i.localStorage.key(S) : i?.localStorage?.key;
-  if (c && l) {
-    const b = oe(
-      `${l}-${e}-${c}`
+}, Re = (e, s) => {
+  const y = n.getState().cogsStateStore[e], { sessionId: g } = we(), m = J(s?.localStorage?.key) ? s.localStorage.key(y) : s?.localStorage?.key;
+  if (m && g) {
+    const $ = oe(
+      `${g}-${e}-${m}`
     );
-    if (b && b.lastUpdated > (b.lastSyncedWithServer || 0))
-      return J(e, b.state), ae(e), !0;
+    if ($ && $.lastUpdated > ($.lastSyncedWithServer || 0))
+      return Z(e, $.state), ie(e), !0;
   }
   return !1;
-}, be = (e, i, S, l, c, b) => {
-  const p = {
-    initialState: i,
-    updaterState: ne(
+}, $e = (e, s, y, g, m, $) => {
+  const w = {
+    initialState: s,
+    updaterState: re(
       e,
-      l,
-      c,
-      b
+      g,
+      m,
+      $
     ),
-    state: S
+    state: y
   };
-  ge(e, p.initialState), te(e, p.updaterState), J(e, p.state);
-}, ae = (e) => {
-  const i = n.getState().stateComponents.get(e);
-  if (!i) return;
-  const S = /* @__PURE__ */ new Set();
-  i.components.forEach((l) => {
-    (l ? Array.isArray(l.reactiveType) ? l.reactiveType : [l.reactiveType || "component"] : null)?.includes("none") || S.add(() => l.forceUpdate());
+  ge(e, w.initialState), ne(e, w.updaterState), Z(e, w.state);
+}, ie = (e) => {
+  const s = n.getState().stateComponents.get(e);
+  if (!s) return;
+  const y = /* @__PURE__ */ new Set();
+  s.components.forEach((g) => {
+    (g ? Array.isArray(g.reactiveType) ? g.reactiveType : [g.reactiveType || "component"] : null)?.includes("none") || y.add(() => g.forceUpdate());
   }), queueMicrotask(() => {
-    S.forEach((l) => l());
+    y.forEach((g) => g());
   });
-}, tt = (e, i) => {
-  const S = n.getState().stateComponents.get(e);
-  if (S) {
-    const l = `${e}////${i}`, c = S.components.get(l);
-    if ((c ? Array.isArray(c.reactiveType) ? c.reactiveType : [c.reactiveType || "component"] : null)?.includes("none"))
+}, et = (e, s) => {
+  const y = n.getState().stateComponents.get(e);
+  if (y) {
+    const g = `${e}////${s}`, m = y.components.get(g);
+    if ((m ? Array.isArray(m.reactiveType) ? m.reactiveType : [m.reactiveType || "component"] : null)?.includes("none"))
       return;
-    c && c.forceUpdate();
+    m && m.forceUpdate();
   }
-}, De = (e, i, S, l) => {
+}, Ue = (e, s, y, g) => {
   switch (e) {
     case "update":
       return {
-        oldValue: G(i, l),
-        newValue: G(S, l)
+        oldValue: L(s, g),
+        newValue: L(y, g)
       };
     case "insert":
       return {
         oldValue: null,
         // or undefined
-        newValue: G(S, l)
+        newValue: L(y, g)
       };
     case "cut":
       return {
-        oldValue: G(i, l),
+        oldValue: L(s, g),
         newValue: null
         // or undefined
       };
@@ -179,328 +179,313 @@ const et = (e, i) => {
       return { oldValue: null, newValue: null };
   }
 };
-function ue(e, i, S) {
-  const l = i.split(".");
-  let c = e;
-  for (const b of l)
-    c.children.has(b) || c.children.set(b, {
-      subscribers: /* @__PURE__ */ new Set(),
-      children: /* @__PURE__ */ new Map()
-    }), c = c.children.get(b);
-  c.subscribers.add(S);
-}
-function Ue(e, i, S) {
-  const l = i.split(".");
-  let c = e;
-  for (const b of l)
-    if (c = c.children.get(b), !c) return;
-  c.subscribers.delete(S);
-}
-function he(e, i) {
-  console.log("Getting subscribers for path:", i);
-  const S = i.split("."), l = new Set(e.subscribers);
-  console.log("Root subscribers:", e.subscribers);
-  let c = e;
-  for (const b of S) {
-    if (c = c.children?.get(b), console.log(`Segment ${b} subscribers:`, c?.subscribers), !c) break;
-    c.subscribers.forEach((p) => l.add(p));
-  }
-  return console.log("Total subscribers found:", l), l;
-}
 function Me(e, {
-  stateKey: i,
-  serverSync: S,
-  localStorage: l,
-  formElements: c,
-  reactiveDeps: b,
-  reactiveType: p,
-  componentId: I,
-  initialState: s,
-  syncUpdate: h,
+  stateKey: s,
+  serverSync: y,
+  localStorage: g,
+  formElements: m,
+  reactiveDeps: $,
+  reactiveType: w,
+  componentId: h,
+  initialState: i,
+  syncUpdate: v,
   dependencies: r,
-  serverState: m
+  serverState: f
 } = {}) {
-  const [R, P] = se({}), { sessionId: x } = pe();
-  let j = !i;
-  const [y] = se(i ?? de()), d = n.getState().stateLog[y], Q = ee(/* @__PURE__ */ new Set()), W = ee(I ?? de()), k = ee(
+  const [U, C] = te({}), { sessionId: P } = we();
+  let M = !s;
+  const [S] = te(s ?? ue()), c = n.getState().stateLog[S], Q = ee(/* @__PURE__ */ new Set()), z = ee(h ?? ue()), V = ee(
     null
   );
-  k.current = Z(y) ?? null, ce(() => {
-    if (h && h.stateKey === y && h.path?.[0]) {
-      J(y, (o) => ({
-        ...o,
-        [h.path[0]]: h.newValue
+  V.current = H(S) ?? null, le(() => {
+    if (v && v.stateKey === S && v.path?.[0]) {
+      Z(S, (a) => ({
+        ...a,
+        [v.path[0]]: v.newValue
       }));
-      const t = `${h.stateKey}:${h.path.join(".")}`;
+      const t = `${v.stateKey}:${v.path.join(".")}`;
       n.getState().setSyncInfo(t, {
-        timeStamp: h.timeStamp,
-        userId: h.userId
+        timeStamp: v.timeStamp,
+        userId: v.userId
       });
     }
-  }, [h]), ce(() => {
-    if (s) {
-      me(y, {
-        initialState: s
+  }, [v]), le(() => {
+    if (i) {
+      ye(S, {
+        initialState: i
       });
-      const t = k.current, a = t?.serverState?.id !== void 0 && t?.serverState?.status === "success" && t?.serverState?.data, g = n.getState().initialStateGlobal[y];
-      if (!(g && !M(g, s) || !g) && !a)
+      const t = V.current, o = t?.serverState?.id !== void 0 && t?.serverState?.status === "success" && t?.serverState?.data, l = n.getState().initialStateGlobal[S];
+      if (!(l && !G(l, i) || !l) && !o)
         return;
-      let f = null;
-      const $ = z(t?.localStorage?.key) ? t?.localStorage?.key(s) : t?.localStorage?.key;
-      $ && x && (f = oe(`${x}-${y}-${$}`));
-      let T = s, w = !1;
-      const N = a ? Date.now() : 0, _ = f?.lastUpdated || 0, D = f?.lastSyncedWithServer || 0;
-      a && N > _ ? (T = t.serverState.data, w = !0) : f && _ > D && (T = f.state, t?.localStorage?.onChange && t?.localStorage?.onChange(T)), be(
-        y,
-        s,
-        T,
-        H,
-        W.current,
-        x
-      ), w && $ && x && ve(T, y, t, x, Date.now()), ae(y), (Array.isArray(p) ? p : [p || "component"]).includes("none") || P({});
+      let u = null;
+      const A = J(t?.localStorage?.key) ? t?.localStorage?.key(i) : t?.localStorage?.key;
+      A && P && (u = oe(`${P}-${S}-${A}`));
+      let p = i, k = !1;
+      const b = o ? Date.now() : 0, N = u?.lastUpdated || 0, _ = u?.lastSyncedWithServer || 0;
+      o && b > N ? (p = t.serverState.data, k = !0) : u && N > _ && (p = u.state, t?.localStorage?.onChange && t?.localStorage?.onChange(p)), $e(
+        S,
+        i,
+        p,
+        Y,
+        z.current,
+        P
+      ), k && A && P && Ie(p, S, t, P, Date.now()), ie(S), (Array.isArray(w) ? w : [w || "component"]).includes("none") || C({});
     }
   }, [
-    s,
-    m?.status,
-    m?.data,
+    i,
+    f?.status,
+    f?.data,
     ...r || []
-  ]), we(() => {
-    j && me(y, {
-      serverSync: S,
-      formElements: c,
-      initialState: s,
-      localStorage: l,
-      middleware: k.current?.middleware
+  ]), pe(() => {
+    M && ye(S, {
+      serverSync: y,
+      formElements: m,
+      initialState: i,
+      localStorage: g,
+      middleware: V.current?.middleware
     });
-    const t = `${y}////${W.current}`, o = n.getState().stateComponents.get(y) || {
-      components: /* @__PURE__ */ new Map(),
-      pathTrie: {
-        subscribers: /* @__PURE__ */ new Set(),
-        children: /* @__PURE__ */ new Map()
-      }
+    const t = `${S}////${z.current}`, a = n.getState().stateComponents.get(S) || {
+      components: /* @__PURE__ */ new Map()
     };
-    return o.components.set(t, {
-      forceUpdate: () => P({}),
+    return a.components.set(t, {
+      forceUpdate: () => C({}),
       paths: /* @__PURE__ */ new Set(),
       deps: [],
-      depsFunction: b || void 0,
-      reactiveType: p ?? ["component", "deps"]
-    }), n.getState().stateComponents.set(y, o), P({}), () => {
-      const a = `${y}////${W.current}`;
-      o && (o.components.delete(a), o.components.size === 0 && n.getState().stateComponents.delete(y));
+      depsFunction: $ || void 0,
+      reactiveType: w ?? ["component", "deps"]
+    }), n.getState().stateComponents.set(S, a), C({}), () => {
+      const o = `${S}////${z.current}`;
+      a && (a.components.delete(o), a.components.size === 0 && n.getState().stateComponents.delete(S));
     };
   }, []);
-  const H = (t, o, a, g) => {
-    if (Array.isArray(o)) {
-      const v = `${y}-${o.join(".")}`;
-      Q.current.add(v);
+  const Y = (t, a, o, l) => {
+    if (Array.isArray(a)) {
+      const I = `${S}-${a.join(".")}`;
+      Q.current.add(I);
     }
-    J(y, (v) => {
-      const f = z(t) ? t(v) : t, $ = `${y}-${o.join(".")}`;
-      if ($) {
-        let F = !1, E = n.getState().signalDomElements.get($);
-        if ((!E || E.size === 0) && (a.updateType === "insert" || a.updateType === "cut")) {
-          const O = o.slice(0, -1), U = G(f, O);
-          if (Array.isArray(U)) {
+    Z(S, (I) => {
+      const u = J(t) ? t(I) : t, A = `${S}-${a.join(".")}`;
+      if (A) {
+        let F = !1, T = n.getState().signalDomElements.get(A);
+        if ((!T || T.size === 0) && (o.updateType === "insert" || o.updateType === "cut")) {
+          const x = a.slice(0, -1), D = L(u, x);
+          if (Array.isArray(D)) {
             F = !0;
-            const A = `${y}-${O.join(".")}`;
-            E = n.getState().signalDomElements.get(A);
+            const E = `${S}-${x.join(".")}`;
+            T = n.getState().signalDomElements.get(E);
           }
         }
-        if (E) {
-          const O = F ? G(f, o.slice(0, -1)) : G(f, o);
-          E.forEach(({ parentId: U, position: A, effect: V }) => {
-            const C = document.querySelector(
-              `[data-parent-id="${U}"]`
+        if (T) {
+          const x = F ? L(u, a.slice(0, -1)) : L(u, a);
+          T.forEach(({ parentId: D, position: E, effect: j }) => {
+            const O = document.querySelector(
+              `[data-parent-id="${D}"]`
             );
-            if (C) {
-              const B = Array.from(C.childNodes);
-              if (B[A]) {
-                const Y = V ? new Function("state", `return (${V})(state)`)(O) : O;
-                B[A].textContent = String(Y);
+            if (O) {
+              const q = Array.from(O.childNodes);
+              if (q[E]) {
+                const R = j ? new Function("state", `return (${j})(state)`)(x) : x;
+                q[E].textContent = String(R);
               }
             }
           });
         }
       }
-      a.updateType === "update" && (g || k.current?.validation?.key) && o && q(
-        (g || k.current?.validation?.key) + "." + o.join(".")
+      o.updateType === "update" && (l || V.current?.validation?.key) && a && B(
+        (l || V.current?.validation?.key) + "." + a.join(".")
       );
-      const T = o.slice(0, o.length - 1);
-      a.updateType === "cut" && k.current?.validation?.key && q(
-        k.current?.validation?.key + "." + T.join(".")
-      ), a.updateType === "insert" && k.current?.validation?.key && xe(
-        k.current?.validation?.key + "." + T.join(".")
-      ).filter(([E, O]) => {
-        let U = E?.split(".").length;
-        if (E == T.join(".") && U == T.length - 1) {
-          let A = E + "." + T;
-          q(E), Fe(A, O);
+      const p = a.slice(0, a.length - 1);
+      o.updateType === "cut" && V.current?.validation?.key && B(
+        V.current?.validation?.key + "." + p.join(".")
+      ), o.updateType === "insert" && V.current?.validation?.key && xe(
+        V.current?.validation?.key + "." + p.join(".")
+      ).filter(([T, x]) => {
+        let D = T?.split(".").length;
+        if (T == p.join(".") && D == p.length - 1) {
+          let E = T + "." + p;
+          B(T), je(E, x);
         }
       });
-      const w = n.getState().stateComponents.get(y);
-      if (w && w.pathTrie) {
-        const F = le(v, f), E = /* @__PURE__ */ new Set();
-        F.forEach((A) => {
-          he(
-            w.pathTrie,
-            A
-          ).forEach((C) => E.add(C));
-        });
-        const O = a.updateType === "update" ? o.join(".") : o.slice(0, -1).join(".") || "";
-        he(
-          w.pathTrie,
-          O
-        ).forEach((A) => E.add(A)), console.log("componentsToUpdate", E), E.forEach((A) => {
-          const V = w.components.get(A);
-          if (V) {
-            const C = Array.isArray(V.reactiveType) ? V.reactiveType : [V.reactiveType || "component"];
-            if (C.includes("none")) return;
-            if (C.includes("all")) {
-              V.forceUpdate();
-              return;
+      const k = n.getState().stateComponents.get(S);
+      if (console.log("stateEntry >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", k), k) {
+        const F = de(I, u), T = new Set(F), x = o.updateType === "update" ? a.join(".") : a.slice(0, -1).join(".") || "";
+        for (const [
+          D,
+          E
+        ] of k.components.entries()) {
+          let j = !1;
+          const O = Array.isArray(E.reactiveType) ? E.reactiveType : [E.reactiveType || "component"];
+          if (console.log("component", E), !O.includes("none")) {
+            if (O.includes("all")) {
+              E.forceUpdate();
+              continue;
             }
-            if (C.includes("deps") && V.depsFunction) {
-              const B = V.depsFunction(f);
-              let Y = !1;
-              if (typeof B == "boolean" ? B && (Y = !0) : M(V.deps, B) || (V.deps = B, Y = !0), Y) {
-                V.forceUpdate();
-                return;
+            if (O.includes("component") && ((E.paths.has(x) || E.paths.has("")) && (j = !0), !j))
+              for (const q of T) {
+                let R = q;
+                for (; ; ) {
+                  if (E.paths.has(R)) {
+                    j = !0;
+                    break;
+                  }
+                  const se = R.lastIndexOf(".");
+                  if (se !== -1) {
+                    const fe = R.substring(
+                      0,
+                      se
+                    );
+                    if (!isNaN(
+                      Number(R.substring(se + 1))
+                    ) && E.paths.has(fe)) {
+                      j = !0;
+                      break;
+                    }
+                    R = fe;
+                  } else
+                    R = "";
+                  if (R === "")
+                    break;
+                }
+                if (j) break;
               }
+            if (!j && O.includes("deps") && E.depsFunction) {
+              const q = E.depsFunction(u);
+              let R = !1;
+              typeof q == "boolean" ? q && (R = !0) : G(E.deps, q) || (E.deps = q, R = !0), R && (j = !0);
             }
-            C.includes("component") && V.forceUpdate();
+            j && E.forceUpdate();
           }
-        });
+        }
       }
-      const N = Date.now();
-      o = o.map((F, E) => {
-        const O = o.slice(0, -1), U = G(f, O);
-        return E === o.length - 1 && ["insert", "cut"].includes(a.updateType) ? (U.length - 1).toString() : F;
+      const b = Date.now();
+      a = a.map((F, T) => {
+        const x = a.slice(0, -1), D = L(u, x);
+        return T === a.length - 1 && ["insert", "cut"].includes(o.updateType) ? (D.length - 1).toString() : F;
       });
-      const { oldValue: _, newValue: D } = De(
-        a.updateType,
-        v,
-        f,
-        o
-      ), L = {
-        timeStamp: N,
-        stateKey: y,
-        path: o,
-        updateType: a.updateType,
+      const { oldValue: N, newValue: _ } = Ue(
+        o.updateType,
+        I,
+        u,
+        a
+      ), W = {
+        timeStamp: b,
+        stateKey: S,
+        path: a,
+        updateType: o.updateType,
         status: "new",
-        oldValue: _,
-        newValue: D
+        oldValue: N,
+        newValue: _
       };
-      if (Oe(y, (F) => {
-        const O = [...F ?? [], L].reduce((U, A) => {
-          const V = `${A.stateKey}:${JSON.stringify(A.path)}`, C = U.get(V);
-          return C ? (C.timeStamp = Math.max(C.timeStamp, A.timeStamp), C.newValue = A.newValue, C.oldValue = C.oldValue ?? A.oldValue, C.updateType = A.updateType) : U.set(V, { ...A }), U;
+      if (Oe(S, (F) => {
+        const x = [...F ?? [], W].reduce((D, E) => {
+          const j = `${E.stateKey}:${JSON.stringify(E.path)}`, O = D.get(j);
+          return O ? (O.timeStamp = Math.max(O.timeStamp, E.timeStamp), O.newValue = E.newValue, O.oldValue = O.oldValue ?? E.oldValue, O.updateType = E.updateType) : D.set(j, { ...E }), D;
         }, /* @__PURE__ */ new Map());
-        return Array.from(O.values());
-      }), ve(
-        f,
-        y,
-        k.current,
-        x
-      ), k.current?.middleware && k.current.middleware({
-        updateLog: d,
-        update: L
-      }), k.current?.serverSync) {
-        const F = n.getState().serverState[y], E = k.current?.serverSync;
-        Re(y, {
-          syncKey: typeof E.syncKey == "string" ? E.syncKey : E.syncKey({ state: f }),
+        return Array.from(x.values());
+      }), Ie(
+        u,
+        S,
+        V.current,
+        P
+      ), V.current?.middleware && V.current.middleware({
+        updateLog: c,
+        update: W
+      }), V.current?.serverSync) {
+        const F = n.getState().serverState[S], T = V.current?.serverSync;
+        Fe(S, {
+          syncKey: typeof T.syncKey == "string" ? T.syncKey : T.syncKey({ state: u }),
           rollBackState: F,
-          actionTimeStamp: Date.now() + (E.debounce ?? 3e3),
+          actionTimeStamp: Date.now() + (T.debounce ?? 3e3),
           status: "waiting"
         });
       }
-      return f;
+      return u;
     });
   };
-  n.getState().updaterState[y] || (te(
-    y,
-    ne(
-      y,
-      H,
-      W.current,
-      x
+  n.getState().updaterState[S] || (ne(
+    S,
+    re(
+      S,
+      Y,
+      z.current,
+      P
     )
-  ), n.getState().cogsStateStore[y] || J(y, e), n.getState().initialStateGlobal[y] || ge(y, e));
-  const u = Ee(() => ne(
-    y,
-    H,
-    W.current,
-    x
-  ), [y, x]);
-  return [Te(y), u];
+  ), n.getState().cogsStateStore[S] || Z(S, e), n.getState().initialStateGlobal[S] || ge(S, e));
+  const d = ke(() => re(
+    S,
+    Y,
+    z.current,
+    P
+  ), [S, P]);
+  return [Ee(S), d];
 }
-function ne(e, i, S, l) {
-  const c = /* @__PURE__ */ new Map();
-  let b = 0;
-  const p = (h) => {
-    const r = h.join(".");
-    for (const [m] of c)
-      (m === r || m.startsWith(r + ".")) && c.delete(m);
-    b++;
-  }, I = {
-    removeValidation: (h) => {
-      h?.validationKey && q(h.validationKey);
+function re(e, s, y, g) {
+  const m = /* @__PURE__ */ new Map();
+  let $ = 0;
+  const w = (v) => {
+    const r = v.join(".");
+    for (const [f] of m)
+      (f === r || f.startsWith(r + ".")) && m.delete(f);
+    $++;
+  }, h = {
+    removeValidation: (v) => {
+      v?.validationKey && B(v.validationKey);
     },
-    revertToInitialState: (h) => {
+    revertToInitialState: (v) => {
       const r = n.getState().getInitialOptions(e)?.validation;
-      r?.key && q(r?.key), h?.validationKey && q(h.validationKey);
-      const m = n.getState().initialStateGlobal[e];
-      n.getState().clearSelectedIndexesForState(e), c.clear(), b++;
-      const R = s(m, []), P = Z(e), x = z(P?.localStorage?.key) ? P?.localStorage?.key(m) : P?.localStorage?.key, j = `${l}-${e}-${x}`;
-      j && localStorage.removeItem(j), te(e, R), J(e, m);
-      const y = n.getState().stateComponents.get(e);
-      return y && y.components.forEach((d) => {
-        d.forceUpdate();
-      }), m;
+      r?.key && B(r?.key), v?.validationKey && B(v.validationKey);
+      const f = n.getState().initialStateGlobal[e];
+      n.getState().clearSelectedIndexesForState(e), m.clear(), $++;
+      const U = i(f, []), C = H(e), P = J(C?.localStorage?.key) ? C?.localStorage?.key(f) : C?.localStorage?.key, M = `${g}-${e}-${P}`;
+      M && localStorage.removeItem(M), ne(e, U), Z(e, f);
+      const S = n.getState().stateComponents.get(e);
+      return S && S.components.forEach((c) => {
+        c.forceUpdate();
+      }), f;
     },
-    updateInitialState: (h) => {
-      c.clear(), b++;
-      const r = ne(
+    updateInitialState: (v) => {
+      m.clear(), $++;
+      const r = re(
         e,
-        i,
-        S,
-        l
-      ), m = n.getState().initialStateGlobal[e], R = Z(e), P = z(R?.localStorage?.key) ? R?.localStorage?.key(m) : R?.localStorage?.key, x = `${l}-${e}-${P}`;
-      return localStorage.getItem(x) && localStorage.removeItem(x), Ae(() => {
-        ge(e, h), te(e, r), J(e, h);
-        const j = n.getState().stateComponents.get(e);
-        j && j.components.forEach((y) => {
-          y.forceUpdate();
+        s,
+        y,
+        g
+      ), f = n.getState().initialStateGlobal[e], U = H(e), C = J(U?.localStorage?.key) ? U?.localStorage?.key(f) : U?.localStorage?.key, P = `${g}-${e}-${C}`;
+      return localStorage.getItem(P) && localStorage.removeItem(P), Ae(() => {
+        ge(e, v), ne(e, r), Z(e, v);
+        const M = n.getState().stateComponents.get(e);
+        M && M.components.forEach((S) => {
+          S.forceUpdate();
         });
       }), {
-        fetchId: (j) => r.get()[j]
+        fetchId: (M) => r.get()[M]
       };
     },
     _initialState: n.getState().initialStateGlobal[e],
     _serverState: n.getState().serverState[e],
     _isLoading: n.getState().isLoadingGlobal[e],
     _isServerSynced: () => {
-      const h = n.getState().serverState[e];
-      return !!(h && M(h, Te(e)));
+      const v = n.getState().serverState[e];
+      return !!(v && G(v, Ee(e)));
     }
   };
-  function s(h, r = [], m) {
-    const R = r.map(String).join(".");
-    c.get(R);
-    const P = function() {
+  function i(v, r = [], f) {
+    const U = r.map(String).join(".");
+    m.get(U);
+    const C = function() {
       return n().getNestedState(e, r);
     };
-    Object.keys(I).forEach((y) => {
-      P[y] = I[y];
+    Object.keys(h).forEach((S) => {
+      C[S] = h[S];
     });
-    const x = {
-      apply(y, d, Q) {
+    const P = {
+      apply(S, c, Q) {
         return console.log(
           `PROXY APPLY TRAP HIT: stateKey=${e}, path=${r.join(".")}`
         ), console.trace("Apply trap stack trace"), n().getNestedState(e, r);
       },
-      get(y, d) {
-        m?.validIndices && !Array.isArray(h) && (m = { ...m, validIndices: void 0 });
+      get(S, c) {
+        f?.validIndices && !Array.isArray(v) && (f = { ...f, validIndices: void 0 });
         const Q = /* @__PURE__ */ new Set([
           "insert",
           "cut",
@@ -524,586 +509,560 @@ function ne(e, i, S, l) {
           "_stateKey",
           "getComponents"
         ]);
-        if (d !== "then" && !d.startsWith("$") && d !== "stateMapNoRender" && !Q.has(d)) {
-          const u = `${e}////${S}`, t = n.getState().stateComponents.get(e);
-          if (console.log("stateEntry", t), t) {
-            const o = t.components.get(u);
-            if (o && !o.paths.has("")) {
-              const a = r.join(".");
-              let g = !0;
-              for (const v of o.paths)
-                if (a.startsWith(v) && (a === v || a[v.length] === ".")) {
-                  g = !1;
+        if (c !== "then" && !c.startsWith("$") && c !== "stateMapNoRender" && !Q.has(c)) {
+          const d = `${e}////${y}`, t = n.getState().stateComponents.get(e);
+          if (t) {
+            const a = t.components.get(d);
+            if (a && !a.paths.has("")) {
+              const o = r.join(".");
+              let l = !0;
+              for (const I of a.paths)
+                if (o.startsWith(I) && (o === I || o[I.length] === ".")) {
+                  l = !1;
                   break;
                 }
-              if (g) {
-                console.log(
-                  "ADDING PATH:",
-                  a,
-                  "for component:",
-                  u
-                ), o.paths.add(a);
-                const v = n.getState().stateComponents.get(e);
-                v && v.pathTrie ? (console.log(
-                  "ADDING TO TRIE:",
-                  a,
-                  u
-                ), ue(
-                  v.pathTrie,
-                  a,
-                  u
-                ), console.log("TRIE AFTER ADD:", v.pathTrie)) : console.log("NO TRIE FOUND for state:", e);
-              }
+              l && a.paths.add(o);
             }
           }
         }
-        if (d === "getDifferences")
-          return () => le(
+        if (c === "getDifferences")
+          return () => de(
             n.getState().cogsStateStore[e],
             n.getState().initialStateGlobal[e]
           );
-        if (d === "sync" && r.length === 0)
+        if (c === "sync" && r.length === 0)
           return async function() {
-            const u = n.getState().getInitialOptions(e), t = u?.sync;
+            const d = n.getState().getInitialOptions(e), t = d?.sync;
             if (!t)
               return console.error(`No mutation defined for state key "${e}"`), { success: !1, error: "No mutation defined" };
-            const o = n.getState().getNestedState(e, []), a = u?.validation?.key;
+            const a = n.getState().getNestedState(e, []), o = d?.validation?.key;
             try {
-              const g = await t.action(o);
-              if (g && !g.success && g.errors && a) {
-                n.getState().removeValidationError(a), g.errors.forEach((f) => {
-                  const $ = [a, ...f.path].join(".");
-                  n.getState().addValidationError($, f.message);
+              const l = await t.action(a);
+              if (l && !l.success && l.errors && o) {
+                n.getState().removeValidationError(o), l.errors.forEach((u) => {
+                  const A = [o, ...u.path].join(".");
+                  n.getState().addValidationError(A, u.message);
                 });
-                const v = n.getState().stateComponents.get(e);
-                v && v.components.forEach((f) => {
-                  f.forceUpdate();
+                const I = n.getState().stateComponents.get(e);
+                I && I.components.forEach((u) => {
+                  u.forceUpdate();
                 });
               }
-              return g?.success && t.onSuccess ? t.onSuccess(g.data) : !g?.success && t.onError && t.onError(g.error), g;
-            } catch (g) {
-              return t.onError && t.onError(g), { success: !1, error: g };
+              return l?.success && t.onSuccess ? t.onSuccess(l.data) : !l?.success && t.onError && t.onError(l.error), l;
+            } catch (l) {
+              return t.onError && t.onError(l), { success: !1, error: l };
             }
           };
-        if (d === "_status") {
-          const u = n.getState().getNestedState(e, r), t = n.getState().initialStateGlobal[e], o = G(t, r);
-          return M(u, o) ? "fresh" : "stale";
+        if (c === "_status") {
+          const d = n.getState().getNestedState(e, r), t = n.getState().initialStateGlobal[e], a = L(t, r);
+          return G(d, a) ? "fresh" : "stale";
         }
-        if (d === "getStatus")
+        if (c === "getStatus")
           return function() {
-            const u = n().getNestedState(
+            const d = n().getNestedState(
               e,
               r
-            ), t = n.getState().initialStateGlobal[e], o = G(t, r);
-            return M(u, o) ? "fresh" : "stale";
+            ), t = n.getState().initialStateGlobal[e], a = L(t, r);
+            return G(d, a) ? "fresh" : "stale";
           };
-        if (d === "removeStorage")
+        if (c === "removeStorage")
           return () => {
-            const u = n.getState().initialStateGlobal[e], t = Z(e), o = z(t?.localStorage?.key) ? t?.localStorage?.key(u) : t?.localStorage?.key, a = `${l}-${e}-${o}`;
-            a && localStorage.removeItem(a);
+            const d = n.getState().initialStateGlobal[e], t = H(e), a = J(t?.localStorage?.key) ? t?.localStorage?.key(d) : t?.localStorage?.key, o = `${g}-${e}-${a}`;
+            o && localStorage.removeItem(o);
           };
-        if (d === "showValidationErrors")
+        if (c === "showValidationErrors")
           return () => {
-            const u = n.getState().getInitialOptions(e)?.validation;
-            if (!u?.key)
+            const d = n.getState().getInitialOptions(e)?.validation;
+            if (!d?.key)
               throw new Error("Validation key not found");
-            return n.getState().getValidationErrors(u.key + "." + r.join("."));
+            return n.getState().getValidationErrors(d.key + "." + r.join("."));
           };
-        if (Array.isArray(h)) {
-          const u = () => m?.validIndices ? h.map((o, a) => ({
-            item: o,
-            originalIndex: m.validIndices[a]
-          })) : n.getState().getNestedState(e, r).map((o, a) => ({
-            item: o,
-            originalIndex: a
+        if (Array.isArray(v)) {
+          const d = () => f?.validIndices ? v.map((a, o) => ({
+            item: a,
+            originalIndex: f.validIndices[o]
+          })) : n.getState().getNestedState(e, r).map((a, o) => ({
+            item: a,
+            originalIndex: o
           }));
-          if (d === "getSelected")
+          if (c === "getSelected")
             return () => {
               const t = n.getState().getSelectedIndex(e, r.join("."));
               if (t !== void 0)
-                return s(
-                  h[t],
+                return i(
+                  v[t],
                   [...r, t.toString()],
-                  m
+                  f
                 );
             };
-          if (d === "clearSelected")
+          if (c === "clearSelected")
             return () => {
               n.getState().clearSelectedIndex({ stateKey: e, path: r });
             };
-          if (d === "getSelectedIndex")
+          if (c === "getSelectedIndex")
             return () => n.getState().getSelectedIndex(e, r.join(".")) ?? -1;
-          if (d === "stateSort")
+          if (c === "stateSort")
             return (t) => {
-              const a = [...u()].sort(
-                (f, $) => t(f.item, $.item)
-              ), g = a.map(({ item: f }) => f), v = {
-                ...m,
-                validIndices: a.map(
-                  ({ originalIndex: f }) => f
+              const o = [...d()].sort(
+                (u, A) => t(u.item, A.item)
+              ), l = o.map(({ item: u }) => u), I = {
+                ...f,
+                validIndices: o.map(
+                  ({ originalIndex: u }) => u
                 )
               };
-              return s(g, r, v);
+              return i(l, r, I);
             };
-          if (d === "stateFilter")
+          if (c === "stateFilter")
             return (t) => {
-              const a = u().filter(
-                ({ item: f }, $) => t(f, $)
-              ), g = a.map(({ item: f }) => f), v = {
-                ...m,
-                validIndices: a.map(
-                  ({ originalIndex: f }) => f
+              const o = d().filter(
+                ({ item: u }, A) => t(u, A)
+              ), l = o.map(({ item: u }) => u), I = {
+                ...f,
+                validIndices: o.map(
+                  ({ originalIndex: u }) => u
                 )
               };
-              return s(g, r, v);
+              return i(l, r, I);
             };
-          if (d === "stateMap")
+          if (c === "stateMap")
             return (t) => {
-              const o = n.getState().getNestedState(e, r);
-              return o.map((a, g) => {
-                let v;
-                m?.validIndices && m.validIndices[g] !== void 0 ? v = m.validIndices[g] : v = g;
-                const f = [...r, v.toString()], $ = s(a, f, m), T = `${S}-${r.join(".")}-${v}`, w = `${e}////${T}`, N = n.getState().stateComponents.get(e);
-                return N && N.pathTrie && (N.components.set(w, {
-                  forceUpdate: () => {
+              const a = n.getState().getNestedState(e, r);
+              return Array.isArray(a) ? a.map((o, l) => {
+                let I;
+                f?.validIndices && f.validIndices[l] !== void 0 ? I = f.validIndices[l] : I = l;
+                const u = [...r, I.toString()], A = i(o, u, f);
+                return t(o, A, {
+                  register: () => {
+                    const [, k] = te({}), b = `${y}-${r.join(".")}-${I}`;
+                    pe(() => {
+                      const N = `${e}////${b}`, _ = n.getState().stateComponents.get(e) || {
+                        components: /* @__PURE__ */ new Map()
+                      };
+                      return _.components.set(N, {
+                        forceUpdate: () => k({}),
+                        paths: /* @__PURE__ */ new Set([u.join(".")])
+                        // ATOMIC: Subscribes only to this item's path.
+                      }), n.getState().stateComponents.set(e, _), () => {
+                        const W = n.getState().stateComponents.get(e);
+                        W && W.components.delete(N);
+                      };
+                    }, [e, b]);
                   },
-                  // This will be updated when component mounts
-                  paths: /* @__PURE__ */ new Set([f.join(".")]),
-                  deps: [],
-                  depsFunction: void 0,
-                  reactiveType: ["component"]
-                }), ue(
-                  N.pathTrie,
-                  f.join("."),
-                  w
-                )), t(
-                  a,
-                  $,
-                  g,
-                  o,
-                  s(o, r, m)
-                );
-              });
+                  index: l,
+                  originalIndex: I
+                });
+              }) : (console.warn(
+                `stateMap called on a non-array value at path: ${r.join(".")}. The current value is:`,
+                a
+              ), null);
             };
-          if (d === "stateMapNoRender")
-            return (t) => h.map((a, g) => {
-              let v;
-              m?.validIndices && m.validIndices[g] !== void 0 ? v = m.validIndices[g] : v = g;
-              const f = [...r, v.toString()], $ = s(a, f, m);
+          if (c === "stateMapNoRender")
+            return (t) => v.map((o, l) => {
+              let I;
+              f?.validIndices && f.validIndices[l] !== void 0 ? I = f.validIndices[l] : I = l;
+              const u = [...r, I.toString()], A = i(o, u, f);
               return t(
-                a,
-                $,
-                g,
-                h,
-                s(h, r, m)
+                o,
+                A,
+                l,
+                v,
+                i(v, r, f)
               );
             });
-          if (d === "$stateMap")
-            return (t) => re(Ge, {
+          if (c === "$stateMap")
+            return (t) => ae(De, {
               proxy: {
                 _stateKey: e,
                 _path: r,
                 _mapFn: t
                 // Pass the actual function, not string
               },
-              rebuildStateShape: s
+              rebuildStateShape: i
             });
-          if (d === "stateFlattenOn")
+          if (c === "stateFlattenOn")
             return (t) => {
-              const o = h;
-              c.clear(), b++;
-              const a = o.flatMap(
-                (g) => g[t] ?? []
+              const a = v;
+              m.clear(), $++;
+              const o = a.flatMap(
+                (l) => l[t] ?? []
               );
-              return s(
-                a,
+              return i(
+                o,
                 [...r, "[*]", t],
-                m
+                f
               );
             };
-          if (d === "index")
+          if (c === "index")
             return (t) => {
-              const o = h[t];
-              return s(o, [...r, t.toString()]);
+              const a = v[t];
+              return i(a, [...r, t.toString()]);
             };
-          if (d === "last")
+          if (c === "last")
             return () => {
               const t = n.getState().getNestedState(e, r);
               if (t.length === 0) return;
-              const o = t.length - 1, a = t[o], g = [...r, o.toString()];
-              return s(a, g);
+              const a = t.length - 1, o = t[a], l = [...r, a.toString()];
+              return i(o, l);
             };
-          if (d === "insert")
-            return (t) => (p(r), ie(i, t, r, e), s(
+          if (c === "insert")
+            return (t) => (w(r), ce(s, t, r, e), i(
               n.getState().getNestedState(e, r),
               r
             ));
-          if (d === "uniqueInsert")
-            return (t, o, a) => {
-              const g = n.getState().getNestedState(e, r), v = z(t) ? t(g) : t;
-              let f = null;
-              if (!g.some((T) => {
-                if (o) {
-                  const N = o.every(
-                    (_) => M(T[_], v[_])
+          if (c === "uniqueInsert")
+            return (t, a, o) => {
+              const l = n.getState().getNestedState(e, r), I = J(t) ? t(l) : t;
+              let u = null;
+              if (!l.some((p) => {
+                if (a) {
+                  const b = a.every(
+                    (N) => G(p[N], I[N])
                   );
-                  return N && (f = T), N;
+                  return b && (u = p), b;
                 }
-                const w = M(T, v);
-                return w && (f = T), w;
+                const k = G(p, I);
+                return k && (u = p), k;
               }))
-                p(r), ie(i, v, r, e);
-              else if (a && f) {
-                const T = a(f), w = g.map(
-                  (N) => M(N, f) ? T : N
+                w(r), ce(s, I, r, e);
+              else if (o && u) {
+                const p = o(u), k = l.map(
+                  (b) => G(b, u) ? p : b
                 );
-                p(r), X(i, w, r);
+                w(r), X(s, k, r);
               }
             };
-          if (d === "cut")
-            return (t, o) => {
-              if (!o?.waitForSync)
-                return p(r), K(i, r, e, t), s(
+          if (c === "cut")
+            return (t, a) => {
+              if (!a?.waitForSync)
+                return w(r), K(s, r, e, t), i(
                   n.getState().getNestedState(e, r),
                   r
                 );
             };
-          if (d === "cutByValue")
+          if (c === "cutByValue")
             return (t) => {
-              for (let o = 0; o < h.length; o++)
-                h[o] === t && K(i, r, e, o);
+              for (let a = 0; a < v.length; a++)
+                v[a] === t && K(s, r, e, a);
             };
-          if (d === "toggleByValue")
+          if (c === "toggleByValue")
             return (t) => {
-              const o = h.findIndex((a) => a === t);
-              o > -1 ? K(i, r, e, o) : ie(i, t, r, e);
+              const a = v.findIndex((o) => o === t);
+              a > -1 ? K(s, r, e, a) : ce(s, t, r, e);
             };
-          if (d === "stateFind")
+          if (c === "stateFind")
             return (t) => {
-              const a = u().find(
-                ({ item: v }, f) => t(v, f)
+              const o = d().find(
+                ({ item: I }, u) => t(I, u)
               );
-              if (!a) return;
-              const g = [...r, a.originalIndex.toString()];
-              return s(a.item, g, m);
+              if (!o) return;
+              const l = [...r, o.originalIndex.toString()];
+              return i(o.item, l, f);
             };
-          if (d === "findWith")
-            return (t, o) => {
-              const g = u().find(
-                ({ item: f }) => f[t] === o
+          if (c === "findWith")
+            return (t, a) => {
+              const l = d().find(
+                ({ item: u }) => u[t] === a
               );
-              if (!g) return;
-              const v = [...r, g.originalIndex.toString()];
-              return s(g.item, v, m);
+              if (!l) return;
+              const I = [...r, l.originalIndex.toString()];
+              return i(l.item, I, f);
             };
         }
-        const W = r[r.length - 1];
-        if (!isNaN(Number(W))) {
-          const u = r.slice(0, -1), t = n.getState().getNestedState(e, u);
-          if (Array.isArray(t) && d === "cut")
+        const z = r[r.length - 1];
+        if (!isNaN(Number(z))) {
+          const d = r.slice(0, -1), t = n.getState().getNestedState(e, d);
+          if (Array.isArray(t) && c === "cut")
             return () => K(
-              i,
-              u,
+              s,
+              d,
               e,
-              Number(W)
+              Number(z)
             );
         }
-        if (d === "get")
+        if (c === "get")
           return () => n.getState().getNestedState(e, r);
-        if (d === "$derive")
-          return (u) => Ie({
+        if (c === "$derive")
+          return (d) => he({
             _stateKey: e,
             _path: r,
-            _effect: u.toString()
+            _effect: d.toString()
           });
-        if (d === "$get")
-          return () => Ie({
+        if (c === "$get")
+          return () => he({
             _stateKey: e,
             _path: r
           });
-        if (d === "lastSynced") {
-          const u = `${e}:${r.join(".")}`;
-          return n.getState().getSyncInfo(u);
+        if (c === "lastSynced") {
+          const d = `${e}:${r.join(".")}`;
+          return n.getState().getSyncInfo(d);
         }
-        if (d == "getLocalStorage")
-          return (u) => oe(l + "-" + e + "-" + u);
-        if (d === "_selected") {
-          const u = r.slice(0, -1), t = u.join("."), o = n.getState().getNestedState(e, u);
-          return Array.isArray(o) ? Number(r[r.length - 1]) === n.getState().getSelectedIndex(e, t) : void 0;
+        if (c == "getLocalStorage")
+          return (d) => oe(g + "-" + e + "-" + d);
+        if (c === "_selected") {
+          const d = r.slice(0, -1), t = d.join("."), a = n.getState().getNestedState(e, d);
+          return Array.isArray(a) ? Number(r[r.length - 1]) === n.getState().getSelectedIndex(e, t) : void 0;
         }
-        if (d === "setSelected")
-          return (u) => {
-            const t = r.slice(0, -1), o = Number(r[r.length - 1]), a = t.join(".");
-            u ? n.getState().setSelectedIndex(e, a, o) : n.getState().setSelectedIndex(e, a, void 0);
-            const g = n.getState().getNestedState(e, [...t]);
-            X(i, g, t), p(t);
+        if (c === "setSelected")
+          return (d) => {
+            const t = r.slice(0, -1), a = Number(r[r.length - 1]), o = t.join(".");
+            d ? n.getState().setSelectedIndex(e, o, a) : n.getState().setSelectedIndex(e, o, void 0);
+            const l = n.getState().getNestedState(e, [...t]);
+            X(s, l, t), w(t);
           };
-        if (d === "toggleSelected")
+        if (c === "toggleSelected")
           return () => {
-            const u = r.slice(0, -1), t = Number(r[r.length - 1]), o = u.join("."), a = n.getState().getSelectedIndex(e, o);
+            const d = r.slice(0, -1), t = Number(r[r.length - 1]), a = d.join("."), o = n.getState().getSelectedIndex(e, a);
             n.getState().setSelectedIndex(
               e,
-              o,
-              a === t ? void 0 : t
+              a,
+              o === t ? void 0 : t
             );
-            const g = n.getState().getNestedState(e, [...u]);
-            X(i, g, u), p(u);
+            const l = n.getState().getNestedState(e, [...d]);
+            X(s, l, d), w(d);
           };
         if (r.length == 0) {
-          if (d === "applyJsonPatch")
-            return (u) => {
-              const t = n.getState().cogsStateStore[e], a = Pe(t, u).newDocument;
-              be(
+          if (c === "applyJsonPatch")
+            return (d) => {
+              const t = n.getState().cogsStateStore[e], o = _e(t, d).newDocument;
+              $e(
                 e,
                 n.getState().initialStateGlobal[e],
-                a,
-                i,
-                S,
-                l
+                o,
+                s,
+                y,
+                g
               );
-              const g = n.getState().stateComponents.get(e);
-              if (g) {
-                const v = le(t, a), f = new Set(v);
+              const l = n.getState().stateComponents.get(e);
+              if (l) {
+                const I = de(t, o), u = new Set(I);
                 for (const [
-                  $,
-                  T
-                ] of g.components.entries()) {
-                  let w = !1;
-                  const N = Array.isArray(T.reactiveType) ? T.reactiveType : [T.reactiveType || "component"];
-                  if (!N.includes("none")) {
-                    if (N.includes("all")) {
-                      T.forceUpdate();
+                  A,
+                  p
+                ] of l.components.entries()) {
+                  let k = !1;
+                  const b = Array.isArray(p.reactiveType) ? p.reactiveType : [p.reactiveType || "component"];
+                  if (!b.includes("none")) {
+                    if (b.includes("all")) {
+                      p.forceUpdate();
                       continue;
                     }
-                    if (N.includes("component") && (T.paths.has("") && (w = !0), !w))
-                      for (const _ of f) {
-                        if (T.paths.has(_)) {
-                          w = !0;
+                    if (b.includes("component") && (p.paths.has("") && (k = !0), !k))
+                      for (const N of u) {
+                        if (p.paths.has(N)) {
+                          k = !0;
                           break;
                         }
-                        let D = _.lastIndexOf(".");
-                        for (; D !== -1; ) {
-                          const L = _.substring(0, D);
-                          if (T.paths.has(L)) {
-                            w = !0;
+                        let _ = N.lastIndexOf(".");
+                        for (; _ !== -1; ) {
+                          const W = N.substring(0, _);
+                          if (p.paths.has(W)) {
+                            k = !0;
                             break;
                           }
-                          const F = _.substring(
-                            D + 1
+                          const F = N.substring(
+                            _ + 1
                           );
                           if (!isNaN(Number(F))) {
-                            const E = L.lastIndexOf(".");
-                            if (E !== -1) {
-                              const O = L.substring(
+                            const T = W.lastIndexOf(".");
+                            if (T !== -1) {
+                              const x = W.substring(
                                 0,
-                                E
+                                T
                               );
-                              if (T.paths.has(O)) {
-                                w = !0;
+                              if (p.paths.has(x)) {
+                                k = !0;
                                 break;
                               }
                             }
                           }
-                          D = L.lastIndexOf(".");
+                          _ = W.lastIndexOf(".");
                         }
-                        if (w) break;
+                        if (k) break;
                       }
-                    if (!w && N.includes("deps") && T.depsFunction) {
-                      const _ = T.depsFunction(a);
-                      let D = !1;
-                      typeof _ == "boolean" ? _ && (D = !0) : M(T.deps, _) || (T.deps = _, D = !0), D && (w = !0);
+                    if (!k && b.includes("deps") && p.depsFunction) {
+                      const N = p.depsFunction(o);
+                      let _ = !1;
+                      typeof N == "boolean" ? N && (_ = !0) : G(p.deps, N) || (p.deps = N, _ = !0), _ && (k = !0);
                     }
-                    w && T.forceUpdate();
+                    k && p.forceUpdate();
                   }
                 }
               }
             };
-          if (d === "validateZodSchema")
+          if (c === "validateZodSchema")
             return () => {
-              const u = n.getState().getInitialOptions(e)?.validation, t = n.getState().addValidationError;
-              if (!u?.zodSchema)
+              const d = n.getState().getInitialOptions(e)?.validation, t = n.getState().addValidationError;
+              if (!d?.zodSchema)
                 throw new Error("Zod schema not found");
-              if (!u?.key)
+              if (!d?.key)
                 throw new Error("Validation key not found");
-              q(u.key);
-              const o = n.getState().cogsStateStore[e];
+              B(d.key);
+              const a = n.getState().cogsStateStore[e];
               try {
-                const a = n.getState().getValidationErrors(u.key);
-                a && a.length > 0 && a.forEach(([v]) => {
-                  v && v.startsWith(u.key) && q(v);
+                const o = n.getState().getValidationErrors(d.key);
+                o && o.length > 0 && o.forEach(([I]) => {
+                  I && I.startsWith(d.key) && B(I);
                 });
-                const g = u.zodSchema.safeParse(o);
-                return g.success ? !0 : (g.error.errors.forEach((f) => {
-                  const $ = f.path, T = f.message, w = [u.key, ...$].join(".");
-                  t(w, T);
-                }), ae(e), !1);
-              } catch (a) {
-                return console.error("Zod schema validation failed", a), !1;
+                const l = d.zodSchema.safeParse(a);
+                return l.success ? !0 : (l.error.errors.forEach((u) => {
+                  const A = u.path, p = u.message, k = [d.key, ...A].join(".");
+                  t(k, p);
+                }), ie(e), !1);
+              } catch (o) {
+                return console.error("Zod schema validation failed", o), !1;
               }
             };
-          if (d === "_componentId") return S;
-          if (d === "getComponents")
+          if (c === "_componentId") return y;
+          if (c === "getComponents")
             return () => n().stateComponents.get(e);
-          if (d === "getAllFormRefs")
-            return () => Se.getState().getFormRefsByStateKey(e);
-          if (d === "_initialState")
+          if (c === "getAllFormRefs")
+            return () => me.getState().getFormRefsByStateKey(e);
+          if (c === "_initialState")
             return n.getState().initialStateGlobal[e];
-          if (d === "_serverState")
+          if (c === "_serverState")
             return n.getState().serverState[e];
-          if (d === "_isLoading")
+          if (c === "_isLoading")
             return n.getState().isLoadingGlobal[e];
-          if (d === "revertToInitialState")
-            return I.revertToInitialState;
-          if (d === "updateInitialState") return I.updateInitialState;
-          if (d === "removeValidation") return I.removeValidation;
+          if (c === "revertToInitialState")
+            return h.revertToInitialState;
+          if (c === "updateInitialState") return h.updateInitialState;
+          if (c === "removeValidation") return h.removeValidation;
         }
-        if (d === "getFormRef")
-          return () => Se.getState().getFormRef(e + "." + r.join("."));
-        if (d === "validationWrapper")
+        if (c === "getFormRef")
+          return () => me.getState().getFormRef(e + "." + r.join("."));
+        if (c === "validationWrapper")
           return ({
-            children: u,
+            children: d,
             hideMessage: t
-          }) => /* @__PURE__ */ fe(
-            ke,
+          }) => /* @__PURE__ */ Se(
+            be,
             {
               formOpts: t ? { validation: { message: "" } } : void 0,
               path: r,
               validationKey: n.getState().getInitialOptions(e)?.validation?.key || "",
               stateKey: e,
-              validIndices: m?.validIndices,
-              children: u
+              validIndices: f?.validIndices,
+              children: d
             }
           );
-        if (d === "_stateKey") return e;
-        if (d === "_path") return r;
-        if (d === "_isServerSynced") return I._isServerSynced;
-        if (d === "update")
-          return (u, t) => {
+        if (c === "_stateKey") return e;
+        if (c === "_path") return r;
+        if (c === "_isServerSynced") return h._isServerSynced;
+        if (c === "update")
+          return (d, t) => {
             if (t?.debounce)
               Ve(() => {
-                X(i, u, r, "");
-                const o = n.getState().getNestedState(e, r);
-                t?.afterUpdate && t.afterUpdate(o);
+                X(s, d, r, "");
+                const a = n.getState().getNestedState(e, r);
+                t?.afterUpdate && t.afterUpdate(a);
               }, t.debounce);
             else {
-              X(i, u, r, "");
-              const o = n.getState().getNestedState(e, r);
-              t?.afterUpdate && t.afterUpdate(o);
+              X(s, d, r, "");
+              const a = n.getState().getNestedState(e, r);
+              t?.afterUpdate && t.afterUpdate(a);
             }
-            p(r);
+            w(r);
           };
-        if (d === "formElement")
-          return (u, t) => /* @__PURE__ */ fe(
-            _e,
+        if (c === "formElement")
+          return (d, t) => /* @__PURE__ */ Se(
+            Ce,
             {
-              setState: i,
+              setState: s,
               stateKey: e,
               path: r,
-              child: u,
+              child: d,
               formOpts: t
             }
           );
-        const k = [...r, d], H = n.getState().getNestedState(e, k);
-        return s(H, k, m);
+        const V = [...r, c], Y = n.getState().getNestedState(e, V);
+        return i(Y, V, f);
       }
-    }, j = new Proxy(P, x);
-    return c.set(R, {
-      proxy: j,
-      stateVersion: b
-    }), j;
+    }, M = new Proxy(C, P);
+    return m.set(U, {
+      proxy: M,
+      stateVersion: $
+    }), M;
   }
-  return s(
+  return i(
     n.getState().getNestedState(e, [])
   );
 }
-function Ie(e) {
-  return re(We, { proxy: e });
+function he(e) {
+  return ae(We, { proxy: e });
 }
-function Ge({
+function De({
   proxy: e,
-  rebuildStateShape: i
+  rebuildStateShape: s
 }) {
-  const S = n().getNestedState(e._stateKey, e._path);
-  return Array.isArray(S) ? i(
-    S,
+  const y = n().getNestedState(e._stateKey, e._path);
+  return Array.isArray(y) ? s(
+    y,
     e._path
   ).stateMapNoRender(
-    (c, b, p, I, s) => e._mapFn(c, b, p, I, s)
+    (m, $, w, h, i) => e._mapFn(m, $, w, h, i)
   ) : null;
 }
 function We({
   proxy: e
 }) {
-  const i = ee(null), S = `${e._stateKey}-${e._path.join(".")}`;
-  return ce(() => {
-    const l = i.current;
-    if (!l || !l.parentElement) return;
-    const c = l.parentElement, p = Array.from(c.childNodes).indexOf(l);
-    let I = c.getAttribute("data-parent-id");
-    I || (I = `parent-${crypto.randomUUID()}`, c.setAttribute("data-parent-id", I));
-    const h = {
+  const s = ee(null), y = `${e._stateKey}-${e._path.join(".")}`;
+  return le(() => {
+    const g = s.current;
+    if (!g || !g.parentElement) return;
+    const m = g.parentElement, w = Array.from(m.childNodes).indexOf(g);
+    let h = m.getAttribute("data-parent-id");
+    h || (h = `parent-${crypto.randomUUID()}`, m.setAttribute("data-parent-id", h));
+    const v = {
       instanceId: `instance-${crypto.randomUUID()}`,
-      parentId: I,
-      position: p,
+      parentId: h,
+      position: w,
       effect: e._effect
     };
-    n.getState().addSignalElement(S, h);
+    n.getState().addSignalElement(y, v);
     const r = n.getState().getNestedState(e._stateKey, e._path);
-    let m;
+    let f;
     if (e._effect)
       try {
-        m = new Function(
+        f = new Function(
           "state",
           `return (${e._effect})(state)`
         )(r);
-      } catch (P) {
-        console.error("Error evaluating effect function during mount:", P), m = r;
+      } catch (C) {
+        console.error("Error evaluating effect function during mount:", C), f = r;
       }
     else
-      m = r;
-    m !== null && typeof m == "object" && (m = JSON.stringify(m));
-    const R = document.createTextNode(String(m));
-    l.replaceWith(R);
-  }, [e._stateKey, e._path.join("."), e._effect]), re("span", {
-    ref: i,
+      f = r;
+    f !== null && typeof f == "object" && (f = JSON.stringify(f));
+    const U = document.createTextNode(String(f));
+    g.replaceWith(U);
+  }, [e._stateKey, e._path.join("."), e._effect]), ae("span", {
+    ref: s,
     style: { display: "none" },
-    "data-signal-id": S
+    "data-signal-id": y
   });
 }
-function nt(e) {
-  const i = $e(
-    (S) => {
-      const l = n.getState().stateComponents.get(e._stateKey) || {
-        components: /* @__PURE__ */ new Map(),
-        pathTrie: {
-          subscribers: /* @__PURE__ */ new Set(),
-          children: /* @__PURE__ */ new Map()
-        }
-      }, c = `signal-${e._stateKey}-${Date.now()}`;
-      return l.components.set(c, {
-        forceUpdate: S,
-        paths: /* @__PURE__ */ new Set([e._path.join(".")]),
-        deps: [],
-        depsFunction: void 0,
-        reactiveType: ["component"]
-      }), l.pathTrie && ue(l.pathTrie, e._path.join("."), c), n.getState().stateComponents.set(e._stateKey, l), () => {
-        l.components.delete(c), l.pathTrie && Ue(
-          l.pathTrie,
-          e._path.join("."),
-          c
-        );
+function tt(e) {
+  const s = Te(
+    (y) => {
+      const g = n.getState().stateComponents.get(e._stateKey) || {
+        components: /* @__PURE__ */ new Map()
       };
+      return g.components.set(e._stateKey, {
+        forceUpdate: y,
+        paths: /* @__PURE__ */ new Set([e._path.join(".")])
+      }), () => g.components.delete(e._stateKey);
     },
     () => n.getState().getNestedState(e._stateKey, e._path)
   );
-  return re("text", {}, String(i));
+  return ae("text", {}, String(s));
 }
 export {
-  Ie as $cogsSignal,
-  nt as $cogsSignalStore,
-  Ke as addStateOptions,
-  et as createCogsState,
-  tt as notifyComponent,
+  he as $cogsSignal,
+  tt as $cogsSignalStore,
+  Qe as addStateOptions,
+  Ke as createCogsState,
+  et as notifyComponent,
   Me as useCogsStateFn
 };
 //# sourceMappingURL=CogsState.jsx.map