cogsbox-state 0.5.454 → 0.5.456

package/dist/CogsState.jsx

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