cogsbox-state 0.5.461 → 0.5.463

package/dist/CogsState.jsx

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