cogsbox-state 0.5.465 → 0.5.466

package/dist/CogsState.jsx

@@ -1,601 +1,596 @@
 "use client";
-import { jsx as ne, Fragment as Ne } from "react/jsx-runtime";
-import { memo as $e, useState as J, useRef as B, useCallback as ae, useEffect as q, useLayoutEffect as ie, useMemo as we, createElement as Me, startTransition as je } from "react";
-import { transformStateFunc as Fe, isFunction as X, isDeepEqual as oe, isArray as Le, getDifferences as xe } from "./utility.js";
-import { ValidationWrapper as _e } from "./Functions.jsx";
-import Re from "superjson";
-import { v4 as ee } from "uuid";
-import { getGlobalStore as I, formRefStore as Ie } from "./store.js";
-import { useCogsConfig as ke } from "./CogsStateClient.jsx";
-import { useInView as He } from "react-intersection-observer";
+import { jsx as ie, Fragment as Ce } from "react/jsx-runtime";
+import { useState as K, useRef as L, useEffect as W, useCallback as we, useLayoutEffect as ce, useMemo as le, createElement as Ie, startTransition as De } from "react";
+import { transformStateFunc as Ue, isFunction as z, isDeepEqual as ae, isArray as Fe, getDifferences as $e } from "./utility.js";
+import { ValidationWrapper as je, FormElementWrapper as Oe, MemoizedCogsItemWrapper as Ne } from "./Components.jsx";
+import xe from "superjson";
+import { v4 as X } from "uuid";
+import { getGlobalStore as T, formRefStore as Ee } from "./store.js";
+import { useCogsConfig as Ve } from "./CogsStateClient.jsx";
 const {
   getInitialOptions: G,
-  updateInitialStateGlobal: Pe,
+  updateInitialStateGlobal: ke,
   // ALIAS THE NEW FUNCTIONS TO THE OLD NAMES
-  getShadowMetadata: D,
-  setShadowMetadata: x,
-  getShadowValue: F,
-  initializeShadowState: ce,
-  updateShadowAtPath: Be,
-  insertShadowArrayElement: Ce,
-  removeShadowArrayElement: We,
-  getSelectedIndex: kt,
-  setInitialStateOptions: de,
-  setServerStateUpdate: qe,
-  markAsDirty: fe,
-  registerComponent: ze,
-  unregisterComponent: Ge,
-  addPathComponent: Je,
-  clearSelectedIndexesForState: Ze,
-  addStateLog: Ye,
-  setSyncInfo: Qe,
-  clearSelectedIndex: Xe,
-  getSyncInfo: Ke,
-  notifyPathSubscribers: De,
-  subscribeToPath: et
+  getShadowMetadata: V,
+  setShadowMetadata: J,
+  getShadowValue: R,
+  initializeShadowState: oe,
+  updateShadowAtPath: Re,
+  insertShadowArrayElement: Le,
+  insertManyShadowArrayElements: qe,
+  removeShadowArrayElement: Be,
+  getSelectedIndex: Tt,
+  setInitialStateOptions: ue,
+  setServerStateUpdate: We,
+  markAsDirty: de,
+  registerComponent: It,
+  unregisterComponent: bt,
+  addPathComponent: Ge,
+  clearSelectedIndexesForState: He,
+  addStateLog: ze,
+  setSyncInfo: Je,
+  clearSelectedIndex: Ze,
+  getSyncInfo: Ye,
+  notifyPathSubscribers: Qe,
+  subscribeToPath: Et
   // Note: The old functions are no longer imported under their original names
-} = I.getState();
-function Z(e, t, c) {
-  const n = D(e, t);
-  if (!!!n?.arrayKeys)
-    return { isArray: !1, value: I.getState().getShadowValue(e, t), keys: [] };
-  const s = t.join("."), u = c?.arrayViews?.[s] ?? n.arrayKeys;
-  return Array.isArray(u) && u.length === 0 ? { isArray: !0, value: [], keys: [] } : { isArray: !0, value: I.getState().getShadowValue(e, t, u), keys: u ?? [] };
+} = T.getState();
+function B(e, r, l) {
+  const a = V(e, r);
+  if (!!!a?.arrayKeys)
+    return { isArray: !1, value: T.getState().getShadowValue(e, r), keys: [] };
+  const s = r.length > 0 ? r.join(".") : "root", c = l?.arrayViews?.[s] ?? a.arrayKeys;
+  return Array.isArray(c) && c.length === 0 ? { isArray: !0, value: [], keys: [] } : { isArray: !0, value: T.getState().getShadowValue(e, r, c), keys: c ?? [] };
 }
-function ve(e, t, c) {
-  for (let n = 0; n < e.length; n++)
-    if (c(e[n], n)) {
-      const d = t[n];
-      if (d)
-        return { key: d, index: n, value: e[n] };
+function ve(e, r, l) {
+  for (let a = 0; a < e.length; a++)
+    if (l(e[a], a)) {
+      const S = r[a];
+      if (S)
+        return { key: S, index: a, value: e[a] };
     }
   return null;
 }
-function pe(e, t) {
-  const c = G(e) || {};
-  de(e, {
-    ...c,
-    ...t
+function pe(e, r) {
+  const l = G(e) || {};
+  ue(e, {
+    ...l,
+    ...r
   });
 }
-function Ee({
+function Me({
   stateKey: e,
-  options: t,
-  initialOptionsPart: c
+  options: r,
+  initialOptionsPart: l
 }) {
-  const n = G(e) || {}, s = { ...c[e] || {}, ...n };
-  let u = !1;
-  if (t)
-    for (const i in t)
-      s.hasOwnProperty(i) ? (i == "localStorage" && t[i] && s[i].key !== t[i]?.key && (u = !0, s[i] = t[i]), i == "defaultState" && t[i] && s[i] !== t[i] && !oe(s[i], t[i]) && (u = !0, s[i] = t[i])) : (u = !0, s[i] = t[i]);
-  s.syncOptions && (!t || !t.hasOwnProperty("syncOptions")) && (u = !0), u && de(e, s);
+  const a = G(e) || {}, s = { ...l[e] || {}, ...a };
+  let c = !1;
+  if (r)
+    for (const i in r)
+      s.hasOwnProperty(i) ? (i == "localStorage" && r[i] && s[i].key !== r[i]?.key && (c = !0, s[i] = r[i]), i == "defaultState" && r[i] && s[i] !== r[i] && !ae(s[i], r[i]) && (c = !0, s[i] = r[i])) : (c = !0, s[i] = r[i]);
+  s.syncOptions && (!r || !r.hasOwnProperty("syncOptions")) && (c = !0), c && ue(e, s);
 }
-function Pt(e, { formElements: t, validation: c }) {
-  return { initialState: e, formElements: t, validation: c };
+function Mt(e, { formElements: r, validation: l }) {
+  return { initialState: e, formElements: r, validation: l };
 }
-const tt = (e, t) => {
-  let c = e;
-  const [n, d] = Fe(c);
-  t?.__fromSyncSchema && t?.__syncNotifications && I.getState().setInitialStateOptions("__notifications", t.__syncNotifications), t?.__fromSyncSchema && t?.__apiParamsMap && I.getState().setInitialStateOptions("__apiParamsMap", t.__apiParamsMap), Object.keys(n).forEach((i) => {
-    let S = d[i] || {};
-    const r = {
-      ...S
+const Xe = (e, r) => {
+  let l = e;
+  const [a, S] = Ue(l);
+  r?.__fromSyncSchema && r?.__syncNotifications && T.getState().setInitialStateOptions("__notifications", r.__syncNotifications), r?.__fromSyncSchema && r?.__apiParamsMap && T.getState().setInitialStateOptions("__apiParamsMap", r.__apiParamsMap), Object.keys(a).forEach((i) => {
+    let f = S[i] || {};
+    const t = {
+      ...f
     };
-    if (t?.formElements && (r.formElements = {
-      ...t.formElements,
-      ...S.formElements || {}
-    }), t?.validation && (r.validation = {
-      ...t.validation,
-      ...S.validation || {}
-    }, t.validation.key && !S.validation?.key && (r.validation.key = `${t.validation.key}.${i}`)), t?.__syncSchemas?.[i]?.schemas?.validation && (r.validation = {
-      zodSchemaV4: t.__syncSchemas[i].schemas.validation,
-      ...S.validation
-    }), Object.keys(r).length > 0) {
-      const l = G(i);
-      l ? de(i, {
-        ...l,
-        ...r
-      }) : de(i, r);
+    if (r?.formElements && (t.formElements = {
+      ...r.formElements,
+      ...f.formElements || {}
+    }), r?.validation && (t.validation = {
+      ...r.validation,
+      ...f.validation || {}
+    }, r.validation.key && !f.validation?.key && (t.validation.key = `${r.validation.key}.${i}`)), r?.__syncSchemas?.[i]?.schemas?.validation && (t.validation = {
+      zodSchemaV4: r.__syncSchemas[i].schemas.validation,
+      ...f.validation
+    }), Object.keys(t).length > 0) {
+      const u = G(i);
+      u ? ue(i, {
+        ...u,
+        ...t
+      }) : ue(i, t);
     }
-  }), Object.keys(n).forEach((i) => {
-    ce(i, n[i]);
-  }), console.log("new stateObject ", I.getState().shadowStateStore);
-  const s = (i, S) => {
-    const [r] = J(S?.componentId ?? ee());
-    Ee({
+  }), Object.keys(a).forEach((i) => {
+    oe(i, a[i]);
+  }), console.log("new stateObject ", T.getState().shadowStateStore);
+  const s = (i, f) => {
+    const [t] = K(f?.componentId ?? X());
+    Me({
       stateKey: i,
-      options: S,
-      initialOptionsPart: d
+      options: f,
+      initialOptionsPart: S
     });
-    const l = F(i, []) || n[i], M = S?.modifyState ? S.modifyState(l) : l;
-    return ft(M, {
+    const u = R(i, []) || a[i], I = f?.modifyState ? f.modifyState(u) : u;
+    return lt(I, {
       stateKey: i,
-      syncUpdate: S?.syncUpdate,
-      componentId: r,
-      localStorage: S?.localStorage,
-      middleware: S?.middleware,
-      reactiveType: S?.reactiveType,
-      reactiveDeps: S?.reactiveDeps,
-      defaultState: S?.defaultState,
-      dependencies: S?.dependencies,
-      serverState: S?.serverState,
-      syncOptions: S?.syncOptions,
-      __useSync: t?.__useSync
+      syncUpdate: f?.syncUpdate,
+      componentId: t,
+      localStorage: f?.localStorage,
+      middleware: f?.middleware,
+      reactiveType: f?.reactiveType,
+      reactiveDeps: f?.reactiveDeps,
+      defaultState: f?.defaultState,
+      dependencies: f?.dependencies,
+      serverState: f?.serverState,
+      syncOptions: f?.syncOptions,
+      __useSync: r?.__useSync
     });
   };
-  function u(i, S) {
-    Ee({ stateKey: i, options: S, initialOptionsPart: d }), S.localStorage && nt(i, S), be(i);
+  function c(i, f) {
+    Me({ stateKey: i, options: f, initialOptionsPart: S }), f.localStorage && et(i, f), be(i);
   }
-  return { useCogsState: s, setCogsOptions: u };
+  return { useCogsState: s, setCogsOptions: c };
 };
-function Ct(e, t) {
-  const c = e.schemas, n = {}, d = {};
-  for (const s in c) {
-    const u = c[s];
-    n[s] = u?.schemas?.defaultValues || {}, u?.api?.queryData?._paramType && (d[s] = u.api.queryData._paramType);
+function At(e, r) {
+  const l = e.schemas, a = {}, S = {};
+  for (const s in l) {
+    const c = l[s];
+    a[s] = c?.schemas?.defaultValues || {}, c?.api?.queryData?._paramType && (S[s] = c.api.queryData._paramType);
   }
-  return tt(n, {
+  return Xe(a, {
     __fromSyncSchema: !0,
     __syncNotifications: e.notifications,
-    __apiParamsMap: d,
-    __useSync: t,
-    __syncSchemas: c
+    __apiParamsMap: S,
+    __useSync: r,
+    __syncSchemas: l
   });
 }
-const rt = (e, t, c, n, d) => {
-  c?.log && console.log(
+const Ke = (e, r, l, a, S) => {
+  l?.log && console.log(
     "saving to localstorage",
-    t,
-    c.localStorage?.key,
-    n
+    r,
+    l.localStorage?.key,
+    a
   );
-  const s = X(c?.localStorage?.key) ? c.localStorage?.key(e) : c?.localStorage?.key;
-  if (s && n) {
-    const u = `${n}-${t}-${s}`;
+  const s = z(l?.localStorage?.key) ? l.localStorage?.key(e) : l?.localStorage?.key;
+  if (s && a) {
+    const c = `${a}-${r}-${s}`;
     let i;
     try {
-      i = me(u)?.lastSyncedWithServer;
+      i = ge(c)?.lastSyncedWithServer;
     } catch {
     }
-    const S = D(t, []), r = {
+    const f = V(r, []), t = {
       state: e,
       lastUpdated: Date.now(),
       lastSyncedWithServer: i,
-      stateSource: S?.stateSource,
-      baseServerState: S?.baseServerState
-    }, l = Re.serialize(r);
+      stateSource: f?.stateSource,
+      baseServerState: f?.baseServerState
+    }, u = xe.serialize(t);
     window.localStorage.setItem(
-      u,
-      JSON.stringify(l.json)
+      c,
+      JSON.stringify(u.json)
     );
   }
-}, me = (e) => {
+}, ge = (e) => {
   if (!e) return null;
   try {
-    const t = window.localStorage.getItem(e);
-    return t ? JSON.parse(t) : null;
-  } catch (t) {
-    return console.error("Error loading from localStorage:", t), null;
+    const r = window.localStorage.getItem(e);
+    return r ? JSON.parse(r) : null;
+  } catch (r) {
+    return console.error("Error loading from localStorage:", r), null;
   }
-}, nt = (e, t) => {
-  const c = F(e, []), { sessionId: n } = ke(), d = X(t?.localStorage?.key) ? t.localStorage.key(c) : t?.localStorage?.key;
-  if (d && n) {
-    const s = me(
-      `${n}-${e}-${d}`
+}, et = (e, r) => {
+  const l = R(e, []), { sessionId: a } = Ve(), S = z(r?.localStorage?.key) ? r.localStorage.key(l) : r?.localStorage?.key;
+  if (S && a) {
+    const s = ge(
+      `${a}-${e}-${S}`
     );
     if (s && s.lastUpdated > (s.lastSyncedWithServer || 0))
       return be(e), !0;
   }
   return !1;
 }, be = (e) => {
-  const t = D(e, []);
-  if (!t) return;
-  const c = /* @__PURE__ */ new Set();
-  t?.components?.forEach((n) => {
-    (n ? Array.isArray(n.reactiveType) ? n.reactiveType : [n.reactiveType || "component"] : null)?.includes("none") || c.add(() => n.forceUpdate());
+  const r = V(e, []);
+  if (!r) return;
+  const l = /* @__PURE__ */ new Set();
+  r?.components?.forEach((a) => {
+    (a ? Array.isArray(a.reactiveType) ? a.reactiveType : [a.reactiveType || "component"] : null)?.includes("none") || l.add(() => a.forceUpdate());
   }), queueMicrotask(() => {
-    c.forEach((n) => n());
+    l.forEach((a) => a());
   });
 };
-function ge(e, t, c, n) {
-  const d = D(e, t);
-  if (x(e, t, {
-    ...d,
+function fe(e, r, l, a) {
+  const S = V(e, r);
+  if (J(e, r, {
+    ...S,
     isDirty: !1,
     stateSource: "server",
-    lastServerSync: n || Date.now()
-  }), Array.isArray(c)) {
-    const s = D(e, t);
-    s?.arrayKeys && s.arrayKeys.forEach((u, i) => {
-      const S = [...t, u], r = c[i];
-      r !== void 0 && ge(
+    lastServerSync: a || Date.now()
+  }), Array.isArray(l)) {
+    const s = V(e, r);
+    s?.arrayKeys && s.arrayKeys.forEach((c, i) => {
+      const f = [...r, c], t = l[i];
+      t !== void 0 && fe(
         e,
-        S,
-        r,
-        n
+        f,
+        t,
+        a
       );
     });
-  } else c && typeof c == "object" && c.constructor === Object && Object.keys(c).forEach((s) => {
-    const u = [...t, s], i = c[s];
-    ge(e, u, i, n);
+  } else l && typeof l == "object" && l.constructor === Object && Object.keys(l).forEach((s) => {
+    const c = [...r, s], i = l[s];
+    fe(e, c, i, a);
   });
 }
 let Se = [], Te = !1;
-function ot() {
-  Te || (Te = !0, queueMicrotask(ut));
+function tt() {
+  Te || (Te = !0, queueMicrotask(it));
 }
-function at(e, t, c) {
-  const n = I.getState().getShadowValue(e, t), d = X(c) ? c(n) : c;
-  Be(e, t, d), fe(e, t, { bubble: !0 });
-  const s = D(e, t);
+function rt(e, r, l) {
+  const a = T.getState().getShadowValue(e, r), S = z(l) ? l(a) : l;
+  Re(e, r, S), de(e, r, { bubble: !0 });
+  const s = V(e, r);
   return {
     type: "update",
-    oldValue: n,
-    newValue: d,
+    oldValue: a,
+    newValue: S,
     shadowMeta: s
   };
 }
-function st(e, t) {
-  e?.signals?.length && e.signals.forEach(({ parentId: c, position: n, effect: d }) => {
-    const s = document.querySelector(`[data-parent-id="${c}"]`);
+function nt(e, r) {
+  e?.signals?.length && e.signals.forEach(({ parentId: l, position: a, effect: S }) => {
+    const s = document.querySelector(`[data-parent-id="${l}"]`);
     if (!s) return;
-    const u = Array.from(s.childNodes);
-    if (!u[n]) return;
-    let i = t;
-    if (d && t !== null)
+    const c = Array.from(s.childNodes);
+    if (!c[a]) return;
+    let i = r;
+    if (S && r !== null)
       try {
-        i = new Function("state", `return (${d})(state)`)(
-          t
+        i = new Function("state", `return (${S})(state)`)(
+          r
         );
-      } catch (S) {
-        console.error("Error evaluating effect function:", S);
+      } catch (f) {
+        console.error("Error evaluating effect function:", f);
       }
-    i !== null && typeof i == "object" && (i = JSON.stringify(i)), u[n].textContent = String(i ?? "");
+    i !== null && typeof i == "object" && (i = JSON.stringify(i)), c[a].textContent = String(i ?? "");
   });
 }
-function it(e, t, c) {
-  const n = D(e, []);
-  if (!n?.components)
+function at(e, r, l) {
+  const a = V(e, []);
+  if (!a?.components)
     return /* @__PURE__ */ new Set();
-  const d = /* @__PURE__ */ new Set();
-  if (c.type === "update") {
-    let s = [...t];
+  const S = /* @__PURE__ */ new Set();
+  if (l.type === "update") {
+    let s = [...r];
     for (; ; ) {
-      const u = D(e, s);
-      if (u?.pathComponents && u.pathComponents.forEach((i) => {
-        const S = n.components?.get(i);
-        S && ((Array.isArray(S.reactiveType) ? S.reactiveType : [S.reactiveType || "component"]).includes("none") || d.add(S));
+      const c = V(e, s);
+      if (c?.pathComponents && c.pathComponents.forEach((i) => {
+        const f = a.components?.get(i);
+        f && ((Array.isArray(f.reactiveType) ? f.reactiveType : [f.reactiveType || "component"]).includes("none") || S.add(f));
       }), s.length === 0) break;
       s.pop();
     }
-    c.newValue && typeof c.newValue == "object" && !Le(c.newValue) && xe(c.newValue, c.oldValue).forEach((i) => {
-      const S = i.split("."), r = [...t, ...S], l = D(e, r);
-      l?.pathComponents && l.pathComponents.forEach((M) => {
-        const _ = n.components?.get(M);
-        _ && ((Array.isArray(_.reactiveType) ? _.reactiveType : [_.reactiveType || "component"]).includes("none") || d.add(_));
+    l.newValue && typeof l.newValue == "object" && !Fe(l.newValue) && $e(l.newValue, l.oldValue).forEach((i) => {
+      const f = i.split("."), t = [...r, ...f], u = V(e, t);
+      u?.pathComponents && u.pathComponents.forEach((I) => {
+        const U = a.components?.get(I);
+        U && ((Array.isArray(U.reactiveType) ? U.reactiveType : [U.reactiveType || "component"]).includes("none") || S.add(U));
       });
     });
-  } else if (c.type === "insert" || c.type === "cut") {
-    const s = c.type === "insert" ? t : t.slice(0, -1), u = D(e, s);
-    u?.pathComponents && u.pathComponents.forEach((i) => {
-      const S = n.components?.get(i);
-      S && d.add(S);
+  } else if (l.type === "insert" || l.type === "cut") {
+    const s = l.type === "insert" ? r : r.slice(0, -1), c = V(e, s);
+    c?.pathComponents && c.pathComponents.forEach((i) => {
+      const f = a.components?.get(i);
+      f && S.add(f);
     });
   }
-  return n.components.forEach((s, u) => {
-    if (d.has(s))
+  return a.components.forEach((s, c) => {
+    if (S.has(s))
       return;
     const i = Array.isArray(s.reactiveType) ? s.reactiveType : [s.reactiveType || "component"];
     if (i.includes("all"))
-      d.add(s);
+      S.add(s);
     else if (i.includes("deps") && s.depsFunction) {
-      const S = F(e, []), r = s.depsFunction(S);
-      (r === !0 || Array.isArray(r) && !oe(s.prevDeps, r)) && (s.prevDeps = r, d.add(s));
+      const f = R(e, []), t = s.depsFunction(f);
+      (t === !0 || Array.isArray(t) && !ae(s.prevDeps, t)) && (s.prevDeps = t, S.add(s));
     }
-  }), d;
+  }), S;
 }
-function ct(e, t, c) {
-  let n;
-  if (X(c)) {
-    const { value: s } = K(e, t);
-    n = c({ state: s, uuid: ee() });
+function ot(e, r, l) {
+  let a;
+  if (z(l)) {
+    const { value: s } = Q(e, r);
+    a = l({ state: s, uuid: X() });
   } else
-    n = c;
-  Ce(e, t, n), fe(e, t, { bubble: !0 });
-  const d = D(e, t);
-  if (d?.arrayKeys) {
-    const s = d.arrayKeys[d.arrayKeys.length - 1];
+    a = l;
+  Le(e, r, a), de(e, r, { bubble: !0 });
+  const S = V(e, r);
+  if (S?.arrayKeys) {
+    const s = S.arrayKeys[S.arrayKeys.length - 1];
     if (s) {
-      const u = s.split(".").slice(1);
-      fe(e, u, { bubble: !1 });
+      const c = s.split(".").slice(1);
+      de(e, c, { bubble: !1 });
     }
   }
-  return { type: "insert", newValue: n, shadowMeta: d };
+  return { type: "insert", newValue: a, shadowMeta: S };
 }
-function lt(e, t) {
-  const c = t.slice(0, -1), n = F(e, t);
-  return We(e, t), fe(e, c, { bubble: !0 }), { type: "cut", oldValue: n, parentPath: c };
+function st(e, r) {
+  const l = r.slice(0, -1), a = R(e, r);
+  return Be(e, r), de(e, l, { bubble: !0 }), { type: "cut", oldValue: a, parentPath: l };
 }
-function ut() {
-  const e = /* @__PURE__ */ new Set(), t = [], c = [];
-  for (const n of Se) {
-    if (n.status && n.updateType) {
-      c.push(n);
+function it() {
+  const e = /* @__PURE__ */ new Set(), r = [], l = [];
+  for (const a of Se) {
+    if (a.status && a.updateType) {
+      l.push(a);
       continue;
     }
-    const d = n, s = d.type === "cut" ? null : d.newValue;
-    d.shadowMeta?.signals?.length > 0 && t.push({ shadowMeta: d.shadowMeta, displayValue: s }), it(
-      d.stateKey,
-      d.path,
-      d
+    const S = a, s = S.type === "cut" ? null : S.newValue;
+    S.shadowMeta?.signals?.length > 0 && r.push({ shadowMeta: S.shadowMeta, displayValue: s }), at(
+      S.stateKey,
+      S.path,
+      S
     ).forEach((i) => {
       e.add(i);
     });
   }
-  c.length > 0 && Ye(c), t.forEach(({ shadowMeta: n, displayValue: d }) => {
-    st(n, d);
-  }), e.forEach((n) => {
-    n.forceUpdate();
+  l.length > 0 && ze(l), r.forEach(({ shadowMeta: a, displayValue: S }) => {
+    nt(a, S);
+  }), e.forEach((a) => {
+    a.forceUpdate();
   }), Se = [], Te = !1;
 }
-function dt(e, t, c, n) {
-  return (s, u, i, S) => {
-    d(e, u, s, i);
+function ct(e, r, l, a) {
+  return (s, c, i, f) => {
+    S(e, c, s, i);
   };
-  function d(s, u, i, S) {
-    let r;
-    switch (S.updateType) {
+  function S(s, c, i, f) {
+    let t;
+    switch (f.updateType) {
       case "update":
-        r = at(s, u, i);
+        t = rt(s, c, i);
         break;
       case "insert":
-        r = ct(s, u, i);
+        t = ot(s, c, i);
         break;
       case "cut":
-        r = lt(s, u);
+        t = st(s, c);
         break;
     }
-    r.stateKey = s, r.path = u, Se.push(r), ot();
-    const l = {
+    t.stateKey = s, t.path = c, Se.push(t), tt();
+    const u = {
       timeStamp: Date.now(),
       stateKey: s,
-      path: u,
-      updateType: S.updateType,
+      path: c,
+      updateType: f.updateType,
       status: "new",
-      oldValue: r.oldValue,
-      newValue: r.newValue ?? null
+      oldValue: t.oldValue,
+      newValue: t.newValue ?? null
     };
-    Se.push(l), r.newValue !== void 0 && rt(
-      r.newValue,
+    Se.push(u), t.newValue !== void 0 && Ke(
+      t.newValue,
       s,
-      n.current,
-      c
-    ), n.current?.middleware && n.current.middleware({ update: l }), S.sync !== !1 && t.current?.connected && t.current.updateState({ operation: l });
+      a.current,
+      l
+    ), a.current?.middleware && a.current.middleware({ update: u }), f.sync !== !1 && r.current?.connected && r.current.updateState({ operation: u });
   }
 }
-function ft(e, {
-  stateKey: t,
-  localStorage: c,
-  formElements: n,
-  reactiveDeps: d,
+function lt(e, {
+  stateKey: r,
+  localStorage: l,
+  formElements: a,
+  reactiveDeps: S,
   reactiveType: s,
-  componentId: u,
+  componentId: c,
   defaultState: i,
-  syncUpdate: S,
-  dependencies: r,
-  serverState: l,
-  __useSync: M
+  syncUpdate: f,
+  dependencies: t,
+  serverState: u,
+  __useSync: I
 } = {}) {
-  const [_, C] = J({}), { sessionId: U } = ke();
-  let j = !t;
-  const [w] = J(t ?? ee()), Y = B(u ?? ee()), f = B(
+  const [U, O] = K({}), { sessionId: F } = Ve();
+  let x = !r;
+  const [w] = K(r ?? X()), ee = L(c ?? X()), m = L(
     null
   );
-  f.current = G(w) ?? null, q(() => {
-    if (S && S.stateKey === w && S.path?.[0]) {
-      const m = `${S.stateKey}:${S.path.join(".")}`;
-      Qe(m, {
-        timeStamp: S.timeStamp,
-        userId: S.userId
+  m.current = G(w) ?? null, W(() => {
+    if (f && f.stateKey === w && f.path?.[0]) {
+      const g = `${f.stateKey}:${f.path.join(".")}`;
+      Je(g, {
+        timeStamp: f.timeStamp,
+        userId: f.userId
       });
     }
-  }, [S]);
-  const R = ae(
-    (m) => {
-      const p = m ? { ...G(w), ...m } : G(w), T = p?.defaultState || i || e;
+  }, [f]);
+  const te = we(
+    (g) => {
+      const p = g ? { ...G(w), ...g } : G(w), b = p?.defaultState || i || e;
       if (p?.serverState?.status === "success" && p?.serverState?.data !== void 0)
         return {
           value: p.serverState.data,
           source: "server",
           timestamp: p.serverState.timestamp || Date.now()
         };
-      if (p?.localStorage?.key && U) {
-        const E = X(p.localStorage.key) ? p.localStorage.key(T) : p.localStorage.key, b = me(
-          `${U}-${w}-${E}`
+      if (p?.localStorage?.key && F) {
+        const M = z(p.localStorage.key) ? p.localStorage.key(b) : p.localStorage.key, A = ge(
+          `${F}-${w}-${M}`
         );
-        if (b && b.lastUpdated > (p?.serverState?.timestamp || 0))
+        if (A && A.lastUpdated > (p?.serverState?.timestamp || 0))
           return {
-            value: b.state,
+            value: A.state,
             source: "localStorage",
-            timestamp: b.lastUpdated
+            timestamp: A.lastUpdated
           };
       }
       return {
-        value: T || e,
+        value: b || e,
         source: "default",
         timestamp: Date.now()
       };
     },
-    [w, i, e, U]
+    [w, i, e, F]
   );
-  q(() => {
-    qe(w, l);
-  }, [l, w]), q(() => I.getState().subscribeToPath(w, (h) => {
-    if (h?.type === "SERVER_STATE_UPDATE") {
-      const p = h.serverState;
+  W(() => {
+    We(w, u);
+  }, [u, w]), W(() => T.getState().subscribeToPath(w, (y) => {
+    if (y?.type === "SERVER_STATE_UPDATE") {
+      const p = y.serverState;
       if (p?.status !== "success" || p.data === void 0)
         return;
-      console.log(
-        "✅ SERVER_STATE_UPDATE received with data:",
-        p
-      ), pe(w, { serverState: p });
-      const T = typeof p.merge == "object" ? p.merge : p.merge === !0 ? { strategy: "append" } : null, A = F(w, []), E = p.data;
-      if (T && T.strategy === "append" && "key" in T && // Type guard for key
-      Array.isArray(A) && Array.isArray(E)) {
-        const b = T.key;
-        if (!b) {
+      pe(w, { serverState: p });
+      const b = typeof p.merge == "object" ? p.merge : p.merge === !0 ? { strategy: "append" } : null, _ = R(w, []), M = p.data;
+      if (b && b.strategy === "append" && "key" in b && // Type guard for key
+      Array.isArray(_) && Array.isArray(M)) {
+        const A = b.key;
+        if (!A) {
           console.error(
             "CogsState: Merge strategy 'append' requires a 'key' field."
           );
           return;
         }
-        console.log("SERVER_STATE_UPDATE 2");
-        const N = new Set(
-          A.map((W) => W[b])
-        ), V = E.filter(
-          (W) => !N.has(W[b])
+        const D = new Set(
+          _.map((j) => j[A])
+        ), E = M.filter(
+          (j) => !D.has(j[A])
         );
-        V.length > 0 && V.forEach((W) => {
-          Ce(w, [], W);
-        });
-        const O = F(w, []);
-        ge(
+        E.length > 0 && qe(w, [], E);
+        const k = R(w, []);
+        fe(
           w,
           [],
-          O,
+          k,
           p.timestamp
         );
       } else
-        ce(w, E), ge(
+        oe(w, M), fe(
           w,
           [],
-          E,
+          M,
           p.timestamp
         );
     }
-  }), [w, R]), q(() => {
-    const m = I.getState().getShadowMetadata(w, []);
-    if (m && m.stateSource)
+  }), [w, te]), W(() => {
+    const g = T.getState().getShadowMetadata(w, []);
+    if (g && g.stateSource)
       return;
-    const h = G(w), p = {
-      syncEnabled: !!v && !!y,
-      validationEnabled: !!(h?.validation?.zodSchemaV4 || h?.validation?.zodSchemaV3),
-      localStorageEnabled: !!h?.localStorage?.key
+    const y = G(w), p = {
+      syncEnabled: !!v && !!h,
+      validationEnabled: !!(y?.validation?.zodSchemaV4 || y?.validation?.zodSchemaV3),
+      localStorageEnabled: !!y?.localStorage?.key
     };
-    if (x(w, [], {
-      ...m,
+    if (J(w, [], {
+      ...g,
       features: p
-    }), h?.defaultState !== void 0 || i !== void 0) {
-      const T = h?.defaultState || i;
-      h?.defaultState || pe(w, {
-        defaultState: T
+    }), y?.defaultState !== void 0 || i !== void 0) {
+      const b = y?.defaultState || i;
+      y?.defaultState || pe(w, {
+        defaultState: b
       });
-      const { value: A, source: E, timestamp: b } = R();
-      ce(w, A), x(w, [], {
-        stateSource: E,
-        lastServerSync: E === "server" ? b : void 0,
+      const { value: _, source: M, timestamp: A } = te();
+      oe(w, _), J(w, [], {
+        stateSource: M,
+        lastServerSync: M === "server" ? A : void 0,
         isDirty: !1,
-        baseServerState: E === "server" ? A : void 0
+        baseServerState: M === "server" ? _ : void 0
       }), be(w);
     }
-  }, [w, ...r || []]), ie(() => {
-    j && pe(w, {
-      formElements: n,
+  }, [w, ...t || []]), ce(() => {
+    x && pe(w, {
+      formElements: a,
       defaultState: i,
-      localStorage: c,
-      middleware: f.current?.middleware
+      localStorage: l,
+      middleware: m.current?.middleware
     });
-    const m = `${w}////${Y.current}`, h = D(w, []), p = h?.components || /* @__PURE__ */ new Map();
-    return p.set(m, {
-      forceUpdate: () => C({}),
+    const g = `${w}////${ee.current}`, y = V(w, []), p = y?.components || /* @__PURE__ */ new Map();
+    return p.set(g, {
+      forceUpdate: () => O({}),
       reactiveType: s ?? ["component"],
       paths: /* @__PURE__ */ new Set(),
-      depsFunction: d || void 0,
-      deps: d ? d(F(w, [])) : [],
-      prevDeps: d ? d(F(w, [])) : []
-    }), x(w, [], {
-      ...h,
+      depsFunction: S || void 0,
+      deps: S ? S(R(w, [])) : [],
+      prevDeps: S ? S(R(w, [])) : []
+    }), J(w, [], {
+      ...y,
       components: p
-    }), C({}), () => {
-      const T = D(w, []), A = T?.components?.get(m);
-      A?.paths && A.paths.forEach((E) => {
-        const N = E.split(".").slice(1), V = I.getState().getShadowMetadata(w, N);
-        V?.pathComponents && V.pathComponents.size === 0 && (delete V.pathComponents, I.getState().setShadowMetadata(w, N, V));
-      }), T?.components && x(w, [], T);
+    }), O({}), () => {
+      const b = V(w, []), _ = b?.components?.get(g);
+      _?.paths && _.paths.forEach((M) => {
+        const D = M.split(".").slice(1), E = T.getState().getShadowMetadata(w, D);
+        E?.pathComponents && E.pathComponents.size === 0 && (delete E.pathComponents, T.getState().setShadowMetadata(w, D, E));
+      }), b?.components && J(w, [], b);
     };
   }, []);
-  const a = B(null), o = dt(
+  const o = L(null), n = ct(
     w,
-    a,
-    U,
-    f
+    o,
+    F,
+    m
   );
-  I.getState().initialStateGlobal[w] || Pe(w, e);
-  const g = we(() => Oe(
+  T.getState().initialStateGlobal[w] || ke(w, e);
+  const d = le(() => Pe(
     w,
-    o,
-    Y.current,
-    U
-  ), [w, U]), v = M, y = f.current?.syncOptions;
-  return v && (a.current = v(
-    g,
-    y ?? {}
-  )), g;
+    n,
+    ee.current,
+    F
+  ), [w, F]), v = I, h = m.current?.syncOptions;
+  return v && (o.current = v(
+    d,
+    h ?? {}
+  )), d;
 }
-const gt = (e, t, c) => {
-  let n = D(e, t)?.arrayKeys || [];
-  if (console.log("ids", n), !c || c.length === 0)
-    return n;
-  for (const d of c)
-    if (d.type === "filter") {
-      const s = [];
-      n.forEach((u, i) => {
-        const S = F(e, [...t, u]);
-        d.fn(S, i) && s.push(u);
-      }), n = s;
-    } else d.type === "sort" && n.sort((s, u) => {
-      const i = F(e, [...t, s]), S = F(e, [...t, u]);
-      return d.fn(i, S);
+const ut = (e, r, l) => {
+  let a = V(e, r)?.arrayKeys || [];
+  const S = l?.transforms;
+  if (!S || S.length === 0)
+    return a;
+  for (const s of S)
+    if (s.type === "filter") {
+      const c = [];
+      a.forEach((i, f) => {
+        const t = R(e, [...r, i]);
+        s.fn(t, f) && c.push(i);
+      }), a = c;
+    } else s.type === "sort" && a.sort((c, i) => {
+      const f = R(e, [...r, c]), t = R(e, [...r, i]);
+      return s.fn(f, t);
     });
-  return n;
-}, Ve = (e, t, c) => {
-  const n = `${e}////${t}`, s = D(e, [])?.components?.get(n);
-  !s || s.reactiveType === "none" || !(Array.isArray(s.reactiveType) ? s.reactiveType : [s.reactiveType]).includes("component") || Je(e, c, n);
-}, ue = (e, t, c) => {
-  const n = I.getState(), d = n.getShadowMetadata(e, []), s = /* @__PURE__ */ new Set();
-  d?.components && d.components.forEach((i, S) => {
-    (Array.isArray(i.reactiveType) ? i.reactiveType : [i.reactiveType || "component"]).includes("all") && (i.forceUpdate(), s.add(S));
-  }), n.getShadowMetadata(e, [...t, "getSelected"])?.pathComponents?.forEach((i) => {
-    d?.components?.get(i)?.forceUpdate();
+  return a;
+}, Ae = (e, r, l) => {
+  const a = `${e}////${r}`, s = V(e, [])?.components?.get(a);
+  !s || s.reactiveType === "none" || !(Array.isArray(s.reactiveType) ? s.reactiveType : [s.reactiveType]).includes("component") || Ge(e, l, a);
+}, ne = (e, r, l) => {
+  const a = V(e, []), S = /* @__PURE__ */ new Set();
+  a?.components && a.components.forEach((c, i) => {
+    (Array.isArray(c.reactiveType) ? c.reactiveType : [c.reactiveType || "component"]).includes("all") && (c.forceUpdate(), S.add(i));
+  }), V(e, [
+    ...r,
+    "getSelected"
+  ])?.pathComponents?.forEach((c) => {
+    a?.components?.get(c)?.forceUpdate();
   });
-  const u = n.getShadowMetadata(e, t);
-  for (let i of u?.arrayKeys || []) {
-    const S = i + ".selected", r = n.getShadowMetadata(
-      e,
-      S.split(".").slice(1)
-    );
-    i == c && r?.pathComponents?.forEach((l) => {
-      d?.components?.get(l)?.forceUpdate();
+  const s = V(e, r);
+  for (let c of s?.arrayKeys || []) {
+    const i = c + ".selected", f = V(e, i.split(".").slice(1));
+    c == l && f?.pathComponents?.forEach((t) => {
+      a?.components?.get(t)?.forceUpdate();
     });
   }
 };
-function K(e, t, c) {
-  const n = D(e, t), d = t.join("."), s = c?.arrayViews?.[d];
+function Q(e, r, l) {
+  const a = V(e, r), S = r.length > 0 ? r.join(".") : "root", s = l?.arrayViews?.[S];
   if (Array.isArray(s) && s.length === 0)
     return {
-      shadowMeta: n,
+      shadowMeta: a,
       value: [],
-      arrayKeys: n?.arrayKeys
+      arrayKeys: a?.arrayKeys
     };
-  const u = F(e, t, s);
+  const c = R(e, r, s);
   return {
-    shadowMeta: n,
-    value: u,
-    arrayKeys: n?.arrayKeys
+    shadowMeta: a,
+    value: c,
+    arrayKeys: a?.arrayKeys
   };
 }
-function Oe(e, t, c, n) {
-  const d = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Set([
+function Pe(e, r, l, a) {
+  const S = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Set([
     "sync",
     "getStatus",
     "removeStorage",
@@ -646,278 +641,276 @@ function Oe(e, t, c, n) {
     "formElement"
     // Add ANY other method names here
   ]);
-  function u({
-    path: r = [],
-    meta: l,
-    componentId: M
+  function c({
+    path: t = [],
+    meta: u,
+    componentId: I
   }) {
-    const _ = l ? JSON.stringify(l.arrayViews || l.transforms) : "", C = r.join(".") + ":" + _;
-    if (d.has(C))
-      return d.get(C);
-    const U = [e, ...r].join("."), j = {
-      get(Y, f) {
-        if (r.length === 0 && f in i)
-          return i[f];
-        if (!s.has(f)) {
-          const a = [...r, f];
-          return u({
-            path: a,
-            componentId: M,
-            meta: l
+    const U = u ? JSON.stringify(u.arrayViews || u.transforms) : "", O = t.join(".") + ":" + U;
+    if (S.has(O))
+      return S.get(O);
+    const F = [e, ...t].join("."), x = {
+      get(ee, m) {
+        if (t.length === 0 && m in i)
+          return i[m];
+        if (!s.has(m)) {
+          const o = [...t, m];
+          return c({
+            path: o,
+            componentId: I,
+            meta: u
           });
         }
-        if (f === "_rebuildStateShape")
-          return u;
-        if (f === "sync" && r.length === 0)
+        if (m === "_rebuildStateShape")
+          return c;
+        if (m === "sync" && t.length === 0)
           return async function() {
-            const a = I.getState().getInitialOptions(e), o = a?.sync;
-            if (!o)
+            const o = T.getState().getInitialOptions(e), n = o?.sync;
+            if (!n)
               return console.error(`No mutation defined for state key "${e}"`), { success: !1, error: "No mutation defined" };
-            const g = I.getState().getShadowValue(e, []), v = a?.validation?.key;
+            const d = T.getState().getShadowValue(e, []), v = o?.validation?.key;
             try {
-              const y = await o.action(g);
-              if (y && !y.success && y.errors, y?.success) {
-                const m = I.getState().getShadowMetadata(e, []);
-                x(e, [], {
-                  ...m,
+              const h = await n.action(d);
+              if (h && !h.success && h.errors, h?.success) {
+                const g = T.getState().getShadowMetadata(e, []);
+                J(e, [], {
+                  ...g,
                   isDirty: !1,
                   lastServerSync: Date.now(),
                   stateSource: "server",
-                  baseServerState: g
+                  baseServerState: d
                   // Update base server state
-                }), o.onSuccess && o.onSuccess(y.data);
-              } else !y?.success && o.onError && o.onError(y.error);
-              return y;
-            } catch (y) {
-              return o.onError && o.onError(y), { success: !1, error: y };
+                }), n.onSuccess && n.onSuccess(h.data);
+              } else !h?.success && n.onError && n.onError(h.error);
+              return h;
+            } catch (h) {
+              return n.onError && n.onError(h), { success: !1, error: h };
             }
           };
-        if (f === "_status" || f === "getStatus") {
-          const a = () => {
-            const { shadowMeta: o, value: g } = K(e, r, l);
-            return o?.isDirty === !0 ? "dirty" : o?.stateSource === "server" || o?.isDirty === !1 ? "synced" : o?.stateSource === "localStorage" ? "restored" : o?.stateSource === "default" || g !== void 0 && !o ? "fresh" : "unknown";
+        if (m === "_status" || m === "getStatus") {
+          const o = () => {
+            const { shadowMeta: n, value: d } = Q(e, t, u);
+            return n?.isDirty === !0 ? "dirty" : n?.stateSource === "server" || n?.isDirty === !1 ? "synced" : n?.stateSource === "localStorage" ? "restored" : n?.stateSource === "default" || d !== void 0 && !n ? "fresh" : "unknown";
           };
-          return f === "_status" ? a() : a;
+          return m === "_status" ? o() : o;
         }
-        if (f === "removeStorage")
+        if (m === "removeStorage")
           return () => {
-            const a = I.getState().initialStateGlobal[e], o = G(e), g = X(o?.localStorage?.key) ? o.localStorage.key(a) : o?.localStorage?.key, v = `${n}-${e}-${g}`;
+            const o = T.getState().initialStateGlobal[e], n = G(e), d = z(n?.localStorage?.key) ? n.localStorage.key(o) : n?.localStorage?.key, v = `${a}-${e}-${d}`;
             v && localStorage.removeItem(v);
           };
-        if (f === "showValidationErrors")
+        if (m === "showValidationErrors")
           return () => {
-            const { shadowMeta: a } = K(e, r, l);
-            return a?.validation?.status === "INVALID" && a.validation.errors.length > 0 ? a.validation.errors.filter((o) => o.severity === "error").map((o) => o.message) : [];
+            const { shadowMeta: o } = Q(e, t, u);
+            return o?.validation?.status === "INVALID" && o.validation.errors.length > 0 ? o.validation.errors.filter((n) => n.severity === "error").map((n) => n.message) : [];
           };
-        if (f === "getSelected")
+        if (m === "getSelected")
           return () => {
-            const a = [e, ...r].join(".");
-            Ve(e, M, [
-              ...r,
+            const o = [e, ...t].join(".");
+            Ae(e, I, [
+              ...t,
               "getSelected"
             ]);
-            const o = I.getState().selectedIndicesMap.get(a);
-            if (!o)
+            const n = T.getState().selectedIndicesMap.get(o);
+            if (!n)
               return;
-            const g = r.join("."), v = l?.arrayViews?.[g], y = o.split(".").pop();
-            if (!(v && !v.includes(y) || F(
+            const d = t.join("."), v = u?.arrayViews?.[d], h = n.split(".").pop();
+            if (!(v && !v.includes(h) || R(
               e,
-              o.split(".").slice(1)
+              n.split(".").slice(1)
             ) === void 0))
-              return u({
-                path: o.split(".").slice(1),
-                componentId: M,
-                meta: l
+              return c({
+                path: n.split(".").slice(1),
+                componentId: I,
+                meta: u
               });
           };
-        if (f === "getSelectedIndex")
+        if (m === "getSelectedIndex")
           return () => {
-            const a = e + "." + r.join(".");
-            r.join(".");
-            const o = I.getState().selectedIndicesMap.get(a);
-            if (!o)
+            const o = e + "." + t.join(".");
+            t.join(".");
+            const n = T.getState().selectedIndicesMap.get(o);
+            if (!n)
               return -1;
-            const { keys: g } = Z(e, r, l);
-            if (!g)
+            const { keys: d } = B(e, t, u);
+            if (!d)
               return -1;
-            const v = o.split(".").pop();
-            return g.indexOf(v);
+            const v = n.split(".").pop();
+            return d.indexOf(v);
           };
-        if (f === "clearSelected")
-          return ue(e, r), () => {
-            Xe({
-              arrayKey: e + "." + r.join(".")
+        if (m === "clearSelected")
+          return ne(e, t), () => {
+            Ze({
+              arrayKey: e + "." + t.join(".")
             });
           };
-        if (f === "useVirtualView")
-          return (a) => {
+        if (m === "useVirtualView")
+          return (o) => {
             const {
-              itemHeight: o = 50,
-              overscan: g = 6,
+              itemHeight: n = 50,
+              overscan: d = 6,
               stickToBottom: v = !1,
-              scrollStickTolerance: y = 75
-            } = a, m = B(null), [h, p] = J({
+              scrollStickTolerance: h = 75
+            } = o, g = L(null), [y, p] = K({
               startIndex: 0,
               endIndex: 10
-            }), [T, A] = J({}), E = B(!0), b = B({
+            }), [b, _] = K({}), M = L(!0);
+            W(() => {
+              const C = setInterval(() => {
+                _({});
+              }, 1e3);
+              return () => clearInterval(C);
+            }, []);
+            const A = L({
               isUserScrolling: !1,
               lastScrollTop: 0,
               scrollUpCount: 0,
               isNearBottom: !0
-            }), N = B(
+            }), D = L(
               /* @__PURE__ */ new Map()
-            );
-            ie(() => {
-              if (!v || !m.current || b.current.isUserScrolling)
-                return;
-              const k = m.current;
-              k.scrollTo({
-                top: k.scrollHeight,
-                behavior: E.current ? "instant" : "smooth"
+            ), { keys: E } = B(e, t, u);
+            W(() => {
+              const C = [e, ...t].join("."), P = T.getState().subscribeToPath(C, (N) => {
+                N.type !== "GET_SELECTED" && N.type;
               });
-            }, [T, v]);
-            const { arrayKeys: V = [] } = K(e, r, l), { totalHeight: O, itemOffsets: W } = we(() => {
-              let k = 0;
-              const P = /* @__PURE__ */ new Map();
-              return (I.getState().getShadowMetadata(e, r)?.arrayKeys || []).forEach((L) => {
-                const $ = L.split(".").slice(1), z = I.getState().getShadowMetadata(e, $)?.virtualizer?.itemHeight || o;
-                P.set(L, {
-                  height: z,
-                  offset: k
-                }), k += z;
-              }), N.current = P, { totalHeight: k, itemOffsets: P };
-            }, [V.length, o]);
-            ie(() => {
-              if (v && V.length > 0 && m.current && !b.current.isUserScrolling && E.current) {
-                const k = m.current, P = () => {
-                  if (k.clientHeight > 0) {
-                    const H = Math.ceil(
-                      k.clientHeight / o
-                    ), L = V.length - 1, $ = Math.max(
+              return () => {
+                P();
+              };
+            }, [I, e, t.join(".")]), ce(() => {
+              if (v && E.length > 0 && g.current && !A.current.isUserScrolling && M.current) {
+                const C = g.current, P = () => {
+                  if (C.clientHeight > 0) {
+                    const N = Math.ceil(
+                      C.clientHeight / n
+                    ), q = E.length - 1, $ = Math.max(
                       0,
-                      L - H - g
+                      q - N - d
                     );
-                    p({ startIndex: $, endIndex: L }), requestAnimationFrame(() => {
-                      te("instant"), E.current = !1;
+                    p({ startIndex: $, endIndex: q }), requestAnimationFrame(() => {
+                      Y("instant"), M.current = !1;
                     });
                   } else
                     requestAnimationFrame(P);
                 };
                 P();
               }
-            }, [V.length, v, o, g]);
-            const le = ae(() => {
-              const k = m.current;
-              if (!k) return;
-              const P = k.scrollTop, { scrollHeight: H, clientHeight: L } = k, $ = b.current, z = H - (P + L), se = $.isNearBottom;
-              $.isNearBottom = z <= y, P < $.lastScrollTop ? ($.scrollUpCount++, $.scrollUpCount > 3 && se && ($.isUserScrolling = !0, console.log("User scrolled away from bottom"))) : $.isNearBottom && ($.isUserScrolling = !1, $.scrollUpCount = 0), $.lastScrollTop = P;
-              let re = 0;
-              for (let Q = 0; Q < V.length; Q++) {
-                const ye = V[Q], he = N.current.get(ye);
+            }, [E.length, v, n, d]);
+            const k = L(y);
+            ce(() => {
+              k.current = y;
+            }, [y]);
+            const j = L(E);
+            ce(() => {
+              j.current = E;
+            }, [E]);
+            const se = we(() => {
+              const C = g.current;
+              if (!C) return;
+              const P = C.scrollTop, { scrollHeight: N, clientHeight: q } = C, $ = A.current, re = N - (P + q), ye = $.isNearBottom;
+              $.isNearBottom = re <= h, P < $.lastScrollTop ? ($.scrollUpCount++, $.scrollUpCount > 3 && ye && ($.isUserScrolling = !0, console.log("User scrolled away from bottom"))) : $.isNearBottom && ($.isUserScrolling = !1, $.scrollUpCount = 0), $.lastScrollTop = P;
+              let Z = 0;
+              for (let H = 0; H < E.length; H++) {
+                const me = E[H], he = D.current.get(me);
                 if (he && he.offset + he.height > P) {
-                  re = Q;
+                  Z = H;
                   break;
                 }
               }
-              if (re !== h.startIndex) {
-                const Q = Math.ceil(L / o);
+              if (console.log(
+                "hadnlescroll ",
+                D.current,
+                Z,
+                y
+              ), Z !== y.startIndex && y.startIndex != 0) {
+                const H = Math.ceil(q / n);
                 p({
-                  startIndex: Math.max(0, re - g),
+                  startIndex: Math.max(0, Z - d),
                   endIndex: Math.min(
-                    V.length - 1,
-                    re + Q + g
+                    E.length - 1,
+                    Z + H + d
                   )
                 });
               }
             }, [
-              V.length,
-              h.startIndex,
-              o,
-              g,
-              y
+              E.length,
+              y.startIndex,
+              n,
+              d,
+              h
             ]);
-            q(() => {
-              const k = m.current;
-              if (!(!k || !v))
-                return k.addEventListener("scroll", le, {
+            W(() => {
+              const C = g.current;
+              if (C)
+                return C.addEventListener("scroll", se, {
                   passive: !0
                 }), () => {
-                  k.removeEventListener("scroll", le);
+                  C.removeEventListener("scroll", se);
                 };
-            }, [le, v]);
-            const te = ae(
-              (k = "smooth") => {
-                const P = m.current;
+            }, [se, v]);
+            const Y = we(
+              (C = "smooth") => {
+                const P = g.current;
                 if (!P) return;
-                b.current.isUserScrolling = !1, b.current.isNearBottom = !0, b.current.scrollUpCount = 0;
-                const H = () => {
-                  const L = ($ = 0) => {
+                A.current.isUserScrolling = !1, A.current.isNearBottom = !0, A.current.scrollUpCount = 0;
+                const N = () => {
+                  const q = ($ = 0) => {
                     if ($ > 5) return;
-                    const z = P.scrollHeight, se = P.scrollTop, re = P.clientHeight;
-                    se + re >= z - 1 || (P.scrollTo({
-                      top: z,
-                      behavior: k
+                    const re = P.scrollHeight, ye = P.scrollTop, Z = P.clientHeight;
+                    ye + Z >= re - 1 || (P.scrollTo({
+                      top: re,
+                      behavior: C
                     }), setTimeout(() => {
-                      const Q = P.scrollHeight, ye = P.scrollTop;
-                      (Q !== z || ye + re < Q - 1) && L($ + 1);
+                      const H = P.scrollHeight, me = P.scrollTop;
+                      (H !== re || me + Z < H - 1) && q($ + 1);
                     }, 50));
                   };
-                  L();
+                  q();
                 };
-                "requestIdleCallback" in window ? requestIdleCallback(H, { timeout: 100 }) : requestAnimationFrame(() => {
-                  requestAnimationFrame(H);
+                "requestIdleCallback" in window ? requestIdleCallback(N, { timeout: 100 }) : requestAnimationFrame(() => {
+                  requestAnimationFrame(N);
                 });
               },
               []
             );
-            return q(() => {
-              if (!v || !m.current) return;
-              const k = m.current, P = b.current;
-              let H;
-              const L = () => {
-                clearTimeout(H), H = setTimeout(() => {
-                  !P.isUserScrolling && P.isNearBottom && te(
-                    E.current ? "instant" : "smooth"
+            return W(() => {
+              if (!v || !g.current) return;
+              const C = g.current, P = A.current;
+              let N;
+              const q = () => {
+                clearTimeout(N), N = setTimeout(() => {
+                  !P.isUserScrolling && P.isNearBottom && Y(
+                    M.current ? "instant" : "smooth"
                   );
                 }, 100);
               }, $ = new MutationObserver(() => {
-                P.isUserScrolling || L();
+                P.isUserScrolling || q();
               });
-              $.observe(k, {
+              return $.observe(C, {
                 childList: !0,
                 subtree: !0,
                 attributes: !0,
                 attributeFilter: ["style", "class"]
-                // More specific than just 'height'
-              });
-              const z = (se) => {
-                se.target instanceof HTMLImageElement && !P.isUserScrolling && L();
+              }), M.current ? setTimeout(() => {
+                Y("instant");
+              }, 0) : q(), () => {
+                clearTimeout(N), $.disconnect();
               };
-              return k.addEventListener("load", z, !0), E.current ? setTimeout(() => {
-                te("instant");
-              }, 0) : L(), () => {
-                clearTimeout(H), $.disconnect(), k.removeEventListener("load", z, !0);
-              };
-            }, [v, V.length, te]), {
-              virtualState: we(() => {
-                const k = I.getState(), P = k.getShadowValue(e, r), H = k.getShadowMetadata(e, r)?.arrayKeys || [];
-                P.slice(
-                  h.startIndex,
-                  h.endIndex + 1
-                );
-                const L = H.slice(
-                  h.startIndex,
-                  h.endIndex + 1
-                ), $ = r.length > 0 ? r.join(".") : "root";
-                return u({
-                  path: r,
-                  componentId: M,
-                  meta: { ...l, arrayViews: { [$]: L } }
+            }, [v, E.length, Y]), {
+              virtualState: le(() => {
+                const C = Array.isArray(E) ? E.slice(y.startIndex, y.endIndex + 1) : [], P = t.length > 0 ? t.join(".") : "root";
+                return c({
+                  path: t,
+                  componentId: I,
+                  meta: {
+                    ...u,
+                    arrayViews: { [P]: C },
+                    serverStateIsUpStream: !0
+                  }
                 });
-              }, [h.startIndex, h.endIndex, V.length]),
+              }, [y.startIndex, y.endIndex, E, u]),
               virtualizerProps: {
                 outer: {
-                  ref: m,
+                  ref: g,
                   style: {
                     overflowY: "auto",
                     height: "100%",
@@ -926,445 +919,442 @@ function Oe(e, t, c, n) {
                 },
                 inner: {
                   style: {
-                    height: `${O}px`,
                     position: "relative"
                   }
                 },
                 list: {
                   style: {
-                    transform: `translateY(${N.current.get(V[h.startIndex])?.offset || 0}px)`
+                    transform: `translateY(${D.current.get(E[y.startIndex])?.offset || 0}px)`
                   }
                 }
               },
-              scrollToBottom: te,
-              scrollToIndex: (k, P = "smooth") => {
-                if (m.current && V[k]) {
-                  const H = N.current.get(V[k])?.offset || 0;
-                  m.current.scrollTo({ top: H, behavior: P });
+              scrollToBottom: Y,
+              scrollToIndex: (C, P = "smooth") => {
+                if (g.current && E[C]) {
+                  const N = D.current.get(E[C])?.offset || 0;
+                  g.current.scrollTo({ top: N, behavior: P });
                 }
               }
             };
           };
-        if (f === "stateMap")
-          return (a) => {
-            const { value: o, keys: g } = Z(
+        if (m === "stateMap")
+          return (o) => {
+            const { value: n, keys: d } = B(
               e,
-              r,
-              l
+              t,
+              u
             );
-            if (!g || !Array.isArray(o))
+            if (!d || !Array.isArray(n))
               return [];
-            const v = u({
-              path: r,
-              componentId: M,
-              meta: l
+            const v = c({
+              path: t,
+              componentId: I,
+              meta: u
             });
-            return o.map((y, m) => {
-              const h = g[m];
-              if (!h) return;
-              const p = [...r, h], T = u({
+            return n.map((h, g) => {
+              const y = d[g];
+              if (!y) return;
+              const p = [...t, y], b = c({
                 path: p,
                 // This now correctly points to the item in the shadow store.
-                componentId: M,
-                meta: l
+                componentId: I,
+                meta: u
               });
-              return a(T, m, v);
+              return o(b, g, v);
             });
           };
-        if (f === "stateFilter")
-          return (a) => {
-            const o = r.length > 0 ? r.join(".") : "root", { keys: g, value: v } = Z(
+        if (m === "stateFilter")
+          return (o) => {
+            const n = t.length > 0 ? t.join(".") : "root", { keys: d, value: v } = B(
               e,
-              r,
-              l
+              t,
+              u
             );
             if (!Array.isArray(v))
               throw new Error("stateFilter can only be used on arrays");
-            const y = [];
-            return v.forEach((m, h) => {
-              if (a(m, h)) {
-                const p = g[h];
-                p && y.push(p);
+            const h = [];
+            return v.forEach((g, y) => {
+              if (o(g, y)) {
+                const p = d[y];
+                p && h.push(p);
               }
-            }), u({
-              path: r,
-              componentId: M,
+            }), c({
+              path: t,
+              componentId: I,
               meta: {
-                ...l,
+                ...u,
                 arrayViews: {
-                  ...l?.arrayViews || {},
-                  [o]: y
+                  ...u?.arrayViews || {},
+                  [n]: h
                 },
                 transforms: [
-                  ...l?.transforms || [],
-                  { type: "filter", fn: a, path: r }
+                  ...u?.transforms || [],
+                  { type: "filter", fn: o, path: t }
                 ]
               }
             });
           };
-        if (f === "stateSort")
-          return (a) => {
-            const o = r.join("."), { value: g, keys: v } = Z(
+        if (m === "stateSort")
+          return (o) => {
+            const n = t.length > 0 ? t.join(".") : "root", { value: d, keys: v } = B(
               e,
-              r,
-              l
+              t,
+              u
             );
-            if (!Array.isArray(g) || !v)
+            if (!Array.isArray(d) || !v)
               throw new Error("No array keys found for sorting");
-            const y = g.map((h, p) => ({
-              item: h,
+            const h = d.map((y, p) => ({
+              item: y,
               key: v[p]
             }));
-            y.sort((h, p) => a(h.item, p.item));
-            const m = y.map((h) => h.key);
-            return u({
-              path: r,
-              componentId: M,
+            h.sort((y, p) => o(y.item, p.item));
+            const g = h.map((y) => y.key);
+            return c({
+              path: t,
+              componentId: I,
               meta: {
-                ...l,
+                ...u,
                 arrayViews: {
-                  ...l?.arrayViews || {},
-                  [o]: m
+                  ...u?.arrayViews || {},
+                  [n]: g
                 },
                 transforms: [
-                  ...l?.transforms || [],
-                  { type: "sort", fn: a, path: r }
+                  ...u?.transforms || [],
+                  { type: "sort", fn: o, path: t }
                 ]
               }
             });
           };
-        if (f === "stream")
-          return function(a = {}) {
+        if (m === "stream")
+          return function(o = {}) {
             const {
-              bufferSize: o = 100,
-              flushInterval: g = 100,
+              bufferSize: n = 100,
+              flushInterval: d = 100,
               bufferStrategy: v = "accumulate",
-              store: y,
-              onFlush: m
-            } = a;
-            let h = [], p = !1, T = null;
-            const A = (O) => {
+              store: h,
+              onFlush: g
+            } = o;
+            let y = [], p = !1, b = null;
+            const _ = (k) => {
               if (!p) {
-                if (v === "sliding" && h.length >= o)
-                  h.shift();
-                else if (v === "dropping" && h.length >= o)
+                if (v === "sliding" && y.length >= n)
+                  y.shift();
+                else if (v === "dropping" && y.length >= n)
                   return;
-                h.push(O), h.length >= o && E();
+                y.push(k), y.length >= n && M();
               }
-            }, E = () => {
-              if (h.length === 0) return;
-              const O = [...h];
-              if (h = [], y) {
-                const W = y(O);
-                W !== void 0 && (Array.isArray(W) ? W : [W]).forEach((te) => {
-                  t(te, r, {
+            }, M = () => {
+              if (y.length === 0) return;
+              const k = [...y];
+              if (y = [], h) {
+                const j = h(k);
+                j !== void 0 && (Array.isArray(j) ? j : [j]).forEach((Y) => {
+                  r(Y, t, {
                     updateType: "insert"
                   });
                 });
               } else
-                O.forEach((W) => {
-                  t(W, r, {
+                k.forEach((j) => {
+                  r(j, t, {
                     updateType: "insert"
                   });
                 });
-              m?.(O);
+              g?.(k);
             };
-            g > 0 && (T = setInterval(E, g));
-            const b = ee(), N = D(e, r) || {}, V = N.streams || /* @__PURE__ */ new Map();
-            return V.set(b, { buffer: h, flushTimer: T }), x(e, r, {
-              ...N,
-              streams: V
+            d > 0 && (b = setInterval(M, d));
+            const A = X(), D = V(e, t) || {}, E = D.streams || /* @__PURE__ */ new Map();
+            return E.set(A, { buffer: y, flushTimer: b }), J(e, t, {
+              ...D,
+              streams: E
             }), {
-              write: (O) => A(O),
-              writeMany: (O) => O.forEach(A),
-              flush: () => E(),
+              write: (k) => _(k),
+              writeMany: (k) => k.forEach(_),
+              flush: () => M(),
               pause: () => {
                 p = !0;
               },
               resume: () => {
-                p = !1, h.length > 0 && E();
+                p = !1, y.length > 0 && M();
               },
               close: () => {
-                E(), T && clearInterval(T);
-                const O = I.getState().getShadowMetadata(e, r);
-                O?.streams && O.streams.delete(b);
+                M(), b && clearInterval(b);
+                const k = T.getState().getShadowMetadata(e, t);
+                k?.streams && k.streams.delete(A);
               }
             };
           };
-        if (f === "stateList")
-          return (a) => (console.log("meta outside", JSON.stringify(l)), /* @__PURE__ */ ne(() => {
-            const g = B(/* @__PURE__ */ new Map()), [v, y] = J({});
-            console.log("updateTrigger updateTrigger  updateTrigger");
-            const m = gt(
+        if (m === "stateList")
+          return (o) => /* @__PURE__ */ ie(() => {
+            const d = L(/* @__PURE__ */ new Map()), [v, h] = K({}), g = t.length > 0 ? t.join(".") : "root", y = le(() => ut(e, t, u), [
               e,
-              r,
-              l?.transforms
-            ), h = r.length > 0 ? r.join(".") : "root", p = {
-              ...l,
+              t.join("."),
+              // Only recalculate if the underlying array keys or transforms change
+              V(e, t)?.arrayKeys,
+              u?.transforms
+            ]), p = le(() => ({
+              ...u,
               arrayViews: {
-                ...l?.arrayViews || {},
-                [h]: m
-                // Update the arrayViews with the new valid IDs
+                ...u?.arrayViews || {},
+                [g]: y
               }
-            }, { value: T } = Z(
+            }), [u, g, y]), { value: b } = B(
               e,
-              r,
+              t,
               p
             );
-            if (console.log("validIds", m), console.log("arrayValues", T), q(() => {
-              const E = I.getState().subscribeToPath(U, (b) => {
-                if (console.log("changed array statelist  ", b), b.type === "GET_SELECTED")
+            if (W(() => {
+              const A = T.getState().subscribeToPath(F, (D) => {
+                if (D.type === "GET_SELECTED")
                   return;
-                const V = I.getState().getShadowMetadata(e, r)?.transformCaches;
-                if (V)
-                  for (const O of V.keys())
-                    O.startsWith(M) && V.delete(O);
-                (b.type === "INSERT" || b.type === "REMOVE" || b.type === "CLEAR_SELECTION") && y({});
+                const k = T.getState().getShadowMetadata(e, t)?.transformCaches;
+                if (k)
+                  for (const j of k.keys())
+                    j.startsWith(I) && k.delete(j);
+                (D.type === "INSERT" || D.type === "INSERT_MANY" || D.type === "REMOVE" || D.type === "CLEAR_SELECTION" || D.type === "SERVER_STATE_UPDATE" && !u?.serverStateIsUpStream) && h({});
               });
               return () => {
-                E();
+                A();
               };
-            }, [M, U]), !Array.isArray(T))
+            }, [I, F]), !Array.isArray(b))
               return null;
-            const A = u({
-              path: r,
-              componentId: M,
+            const _ = c({
+              path: t,
+              componentId: I,
               meta: p
               // Use updated meta here
-            });
-            return console.log("arrayValues", T), /* @__PURE__ */ ne(Ne, { children: T.map((E, b) => {
-              const N = m[b];
-              if (!N)
+            }), M = b.map((A, D) => {
+              const E = y[D];
+              if (!E)
                 return null;
-              let V = g.current.get(N);
-              V || (V = ee(), g.current.set(N, V));
-              const O = [...r, N];
-              return Me(mt, {
-                key: N,
+              let k = d.current.get(E);
+              k || (k = X(), d.current.set(E, k));
+              const j = [...t, E];
+              return Ie(Ne, {
+                key: E,
                 stateKey: e,
-                itemComponentId: V,
-                itemPath: O,
-                localIndex: b,
-                arraySetter: A,
-                rebuildStateShape: u,
-                renderFn: a
+                itemComponentId: k,
+                itemPath: j,
+                localIndex: D,
+                arraySetter: _,
+                rebuildStateShape: c,
+                renderFn: o
               });
-            }) });
-          }, {}));
-        if (f === "stateFlattenOn")
-          return (a) => {
-            const o = r.join("."), g = l?.arrayViews?.[o], v = I.getState().getShadowValue(e, r, g);
-            return Array.isArray(v) ? u({
-              path: [...r, "[*]", a],
-              componentId: M,
-              meta: l
+            });
+            return /* @__PURE__ */ ie(Ce, { children: M });
+          }, {});
+        if (m === "stateFlattenOn")
+          return (o) => {
+            const n = t.length > 0 ? t.join(".") : "root", d = u?.arrayViews?.[n], v = T.getState().getShadowValue(e, t, d);
+            return Array.isArray(v) ? c({
+              path: [...t, "[*]", o],
+              componentId: I,
+              meta: u
             }) : [];
           };
-        if (f === "index")
-          return (a) => {
-            const o = r.join("."), g = l?.arrayViews?.[o];
-            if (g) {
-              const m = g[a];
-              return m ? u({
-                path: [...r, m],
-                componentId: M,
-                meta: l
+        if (m === "index")
+          return (o) => {
+            const n = t.length > 0 ? t.join(".") : "root", d = u?.arrayViews?.[n];
+            if (d) {
+              const g = d[o];
+              return g ? c({
+                path: [...t, g],
+                componentId: I,
+                meta: u
               }) : void 0;
             }
-            const v = D(e, r);
+            const v = V(e, t);
             if (!v?.arrayKeys) return;
-            const y = v.arrayKeys[a];
-            if (y)
-              return u({
-                path: [...r, y],
-                componentId: M,
-                meta: l
+            const h = v.arrayKeys[o];
+            if (h)
+              return c({
+                path: [...t, h],
+                componentId: I,
+                meta: u
               });
           };
-        if (f === "last")
+        if (m === "last")
           return () => {
-            const { keys: a } = Z(e, r, l);
-            if (!a || a.length === 0)
+            const { keys: o } = B(e, t, u);
+            if (!o || o.length === 0)
               return;
-            const o = a[a.length - 1];
-            if (!o)
+            const n = o[o.length - 1];
+            if (!n)
               return;
-            const g = [...r, o];
-            return u({
-              path: g,
-              componentId: M,
-              meta: l
+            const d = [...t, n];
+            return c({
+              path: d,
+              componentId: I,
+              meta: u
             });
           };
-        if (f === "insert")
-          return (a, o) => {
-            t(a, r, { updateType: "insert" });
+        if (m === "insert")
+          return (o, n) => {
+            r(o, t, { updateType: "insert" });
           };
-        if (f === "uniqueInsert")
-          return (a, o, g) => {
-            const { value: v } = K(
+        if (m === "uniqueInsert")
+          return (o, n, d) => {
+            const { value: v } = Q(
               e,
-              r,
-              l
-            ), y = X(a) ? a(v) : a;
-            let m = null;
+              t,
+              u
+            ), h = z(o) ? o(v) : o;
+            let g = null;
             if (!v.some((p) => {
-              const T = o ? o.every(
-                (A) => oe(p[A], y[A])
-              ) : oe(p, y);
-              return T && (m = p), T;
+              const b = n ? n.every(
+                (_) => ae(p[_], h[_])
+              ) : ae(p, h);
+              return b && (g = p), b;
             }))
-              t(y, r, { updateType: "insert" });
-            else if (g && m) {
-              const p = g(m), T = v.map(
-                (A) => oe(A, m) ? p : A
+              r(h, t, { updateType: "insert" });
+            else if (d && g) {
+              const p = d(g), b = v.map(
+                (_) => ae(_, g) ? p : _
               );
-              t(T, r, {
+              r(b, t, {
                 updateType: "update"
               });
             }
           };
-        if (f === "cut")
-          return (a, o) => {
-            const g = D(e, r);
-            if (!g?.arrayKeys || g.arrayKeys.length === 0)
+        if (m === "cut")
+          return (o, n) => {
+            const d = V(e, t);
+            if (!d?.arrayKeys || d.arrayKeys.length === 0)
               return;
-            const v = a === -1 ? g.arrayKeys.length - 1 : a !== void 0 ? a : g.arrayKeys.length - 1, y = g.arrayKeys[v];
-            y && t(null, [...r, y], {
+            const v = o === -1 ? d.arrayKeys.length - 1 : o !== void 0 ? o : d.arrayKeys.length - 1, h = d.arrayKeys[v];
+            h && r(null, [...t, h], {
               updateType: "cut"
             });
           };
-        if (f === "cutSelected")
+        if (m === "cutSelected")
           return () => {
-            const a = [e, ...r].join("."), { keys: o } = Z(e, r, l);
-            if (!o || o.length === 0)
+            const o = [e, ...t].join("."), { keys: n } = B(e, t, u);
+            if (!n || n.length === 0)
               return;
-            const g = I.getState().selectedIndicesMap.get(a);
-            if (!g)
+            const d = T.getState().selectedIndicesMap.get(o);
+            if (!d)
               return;
-            const v = g.split(".").pop();
-            if (!o.includes(v))
+            const v = d.split(".").pop();
+            if (!n.includes(v))
               return;
-            const y = g.split(".").slice(1);
-            I.getState().clearSelectedIndex({ arrayKey: a });
-            const m = y.slice(0, -1);
-            ue(e, m), t(null, y, {
+            const h = d.split(".").slice(1);
+            T.getState().clearSelectedIndex({ arrayKey: o });
+            const g = h.slice(0, -1);
+            ne(e, g), r(null, h, {
               updateType: "cut"
             });
           };
-        if (f === "cutByValue")
-          return (a) => {
+        if (m === "cutByValue")
+          return (o) => {
             const {
-              isArray: o,
-              value: g,
+              isArray: n,
+              value: d,
               keys: v
-            } = Z(e, r, l);
-            if (!o) return;
-            const y = ve(g, v, (m) => m === a);
-            y && t(null, [...r, y.key], {
+            } = B(e, t, u);
+            if (!n) return;
+            const h = ve(d, v, (g) => g === o);
+            h && r(null, [...t, h.key], {
               updateType: "cut"
             });
           };
-        if (f === "toggleByValue")
-          return (a) => {
+        if (m === "toggleByValue")
+          return (o) => {
             const {
-              isArray: o,
-              value: g,
+              isArray: n,
+              value: d,
               keys: v
-            } = Z(e, r, l);
-            if (!o) return;
-            const y = ve(g, v, (m) => m === a);
-            if (y) {
-              const m = [...r, y.key];
-              t(null, m, {
+            } = B(e, t, u);
+            if (!n) return;
+            const h = ve(d, v, (g) => g === o);
+            if (h) {
+              const g = [...t, h.key];
+              r(null, g, {
                 updateType: "cut"
               });
             } else
-              t(a, r, { updateType: "insert" });
+              r(o, t, { updateType: "insert" });
           };
-        if (f === "findWith")
-          return (a, o) => {
-            const { isArray: g, value: v, keys: y } = Z(e, r, l);
-            if (!g)
+        if (m === "findWith")
+          return (o, n) => {
+            const { isArray: d, value: v, keys: h } = B(e, t, u);
+            if (!d)
               throw new Error("findWith can only be used on arrays");
-            const m = ve(
+            const g = ve(
               v,
-              y,
-              (h) => h?.[a] === o
+              h,
+              (y) => y?.[o] === n
             );
-            return u(m ? {
-              path: [...r, m.key],
-              // e.g., ['itemInstances', 'inst-1', 'properties', 'prop-b']
-              componentId: M,
-              meta: l
+            return c(g ? {
+              path: [...t, g.key],
+              componentId: I,
+              meta: u
             } : {
-              path: [...r, `not_found_${ee()}`],
-              componentId: M,
-              meta: l
+              path: [...t, `not_found_${X()}`],
+              componentId: I,
+              meta: u
             });
           };
-        if (f === "cutThis") {
-          const { value: a } = K(e, r, l);
-          return () => {
-            t(a, r, { updateType: "cut" });
+        if (m === "cutThis") {
+          const { value: o } = Q(e, t, u), n = t.slice(0, -1);
+          return ne(e, n), () => {
+            r(o, t, { updateType: "cut" });
           };
         }
-        if (f === "get")
+        if (m === "get")
           return () => {
-            Ve(e, M, r);
-            const { value: a } = K(e, r, l);
-            return a;
+            Ae(e, I, t);
+            const { value: o } = Q(e, t, u);
+            return o;
           };
-        if (f === "$derive")
-          return (a) => Ae({
+        if (m === "$derive")
+          return (o) => _e({
             _stateKey: e,
-            _path: r,
-            _effect: a.toString(),
-            _meta: l
+            _path: t,
+            _effect: o.toString(),
+            _meta: u
           });
-        if (f === "$get")
-          return () => Ae({ _stateKey: e, _path: r, _meta: l });
-        if (f === "lastSynced") {
-          const a = `${e}:${r.join(".")}`;
-          return Ke(a);
+        if (m === "$get")
+          return () => _e({ _stateKey: e, _path: t, _meta: u });
+        if (m === "lastSynced") {
+          const o = `${e}:${t.join(".")}`;
+          return Ye(o);
         }
-        if (f == "getLocalStorage")
-          return (a) => me(n + "-" + e + "-" + a);
-        if (f === "isSelected") {
-          const a = r.slice(0, -1);
-          if (D(e, a)?.arrayKeys) {
-            const g = e + "." + a.join("."), v = I.getState().selectedIndicesMap.get(g), y = e + "." + r.join(".");
-            return ue(e, a, void 0), v === y;
+        if (m == "getLocalStorage")
+          return (o) => ge(a + "-" + e + "-" + o);
+        if (m === "isSelected") {
+          const o = t.slice(0, -1);
+          if (V(e, o)?.arrayKeys) {
+            const d = e + "." + o.join("."), v = T.getState().selectedIndicesMap.get(d), h = e + "." + t.join(".");
+            return v === h;
           }
           return;
         }
-        if (f === "setSelected")
-          return (a) => {
-            const o = r.slice(0, -1), g = e + "." + o.join("."), v = e + "." + r.join(".");
-            ue(e, o, void 0), I.getState().selectedIndicesMap.get(g), a && I.getState().setSelectedIndex(g, v);
+        if (m === "setSelected")
+          return (o) => {
+            const n = t.slice(0, -1), d = e + "." + n.join("."), v = e + "." + t.join(".");
+            ne(e, n, void 0), T.getState().selectedIndicesMap.get(d), o && T.getState().setSelectedIndex(d, v);
           };
-        if (f === "toggleSelected")
+        if (m === "toggleSelected")
           return () => {
-            const a = r.slice(0, -1), o = e + "." + a.join("."), g = e + "." + r.join(".");
-            I.getState().selectedIndicesMap.get(o) === g ? I.getState().clearSelectedIndex({ arrayKey: o }) : I.getState().setSelectedIndex(o, g);
+            const o = t.slice(0, -1), n = e + "." + o.join("."), d = e + "." + t.join(".");
+            T.getState().selectedIndicesMap.get(n) === d ? T.getState().clearSelectedIndex({ arrayKey: n }) : T.getState().setSelectedIndex(n, d), ne(e, o);
           };
-        if (f === "_componentId")
-          return M;
-        if (r.length == 0) {
-          if (f === "addZodValidation")
-            return (a) => {
-              a.forEach((o) => {
-                const g = I.getState().getShadowMetadata(e, o.path) || {};
-                I.getState().setShadowMetadata(e, o.path, {
-                  ...g,
+        if (m === "_componentId")
+          return I;
+        if (t.length == 0) {
+          if (m === "addZodValidation")
+            return (o) => {
+              o.forEach((n) => {
+                const d = T.getState().getShadowMetadata(e, n.path) || {};
+                T.getState().setShadowMetadata(e, n.path, {
+                  ...d,
                   validation: {
                     status: "INVALID",
                     errors: [
                       {
                         source: "client",
-                        message: o.message,
+                        message: n.message,
                         severity: "error",
-                        code: o.code
+                        code: n.code
                       }
                     ],
                     lastValidated: Date.now(),
@@ -1373,13 +1363,13 @@ function Oe(e, t, c, n) {
                 });
               });
             };
-          if (f === "clearZodValidation")
-            return (a) => {
-              if (!a)
+          if (m === "clearZodValidation")
+            return (o) => {
+              if (!o)
                 throw new Error("clearZodValidation requires a path");
-              const o = D(e, a) || {};
-              x(e, a, {
-                ...o,
+              const n = V(e, o) || {};
+              J(e, o, {
+                ...n,
                 validation: {
                   status: "NOT_VALIDATED",
                   errors: [],
@@ -1387,197 +1377,197 @@ function Oe(e, t, c, n) {
                 }
               });
             };
-          if (f === "applyJsonPatch")
-            return (a) => {
-              const o = I.getState(), g = o.getShadowMetadata(e, []);
-              if (!g?.components) return;
-              const v = (m) => !m || m === "/" ? [] : m.split("/").slice(1).map((h) => h.replace(/~1/g, "/").replace(/~0/g, "~")), y = /* @__PURE__ */ new Set();
-              for (const m of a) {
-                const h = v(m.path);
-                switch (m.op) {
+          if (m === "applyJsonPatch")
+            return (o) => {
+              const n = T.getState(), d = n.getShadowMetadata(e, []);
+              if (!d?.components) return;
+              const v = (g) => !g || g === "/" ? [] : g.split("/").slice(1).map((y) => y.replace(/~1/g, "/").replace(/~0/g, "~")), h = /* @__PURE__ */ new Set();
+              for (const g of o) {
+                const y = v(g.path);
+                switch (g.op) {
                   case "add":
                   case "replace": {
-                    const { value: p } = m;
-                    o.updateShadowAtPath(e, h, p), o.markAsDirty(e, h, { bubble: !0 });
-                    let T = [...h];
+                    const { value: p } = g;
+                    n.updateShadowAtPath(e, y, p), n.markAsDirty(e, y, { bubble: !0 });
+                    let b = [...y];
                     for (; ; ) {
-                      const A = o.getShadowMetadata(
+                      const _ = n.getShadowMetadata(
                         e,
-                        T
+                        b
                       );
-                      if (A?.pathComponents && A.pathComponents.forEach((E) => {
-                        if (!y.has(E)) {
-                          const b = g.components?.get(E);
-                          b && (b.forceUpdate(), y.add(E));
+                      if (_?.pathComponents && _.pathComponents.forEach((M) => {
+                        if (!h.has(M)) {
+                          const A = d.components?.get(M);
+                          A && (A.forceUpdate(), h.add(M));
                         }
-                      }), T.length === 0) break;
-                      T.pop();
+                      }), b.length === 0) break;
+                      b.pop();
                     }
                     break;
                   }
                   case "remove": {
-                    const p = h.slice(0, -1);
-                    o.removeShadowArrayElement(e, h), o.markAsDirty(e, p, { bubble: !0 });
-                    let T = [...p];
+                    const p = y.slice(0, -1);
+                    n.removeShadowArrayElement(e, y), n.markAsDirty(e, p, { bubble: !0 });
+                    let b = [...p];
                     for (; ; ) {
-                      const A = o.getShadowMetadata(
+                      const _ = n.getShadowMetadata(
                         e,
-                        T
+                        b
                       );
-                      if (A?.pathComponents && A.pathComponents.forEach((E) => {
-                        if (!y.has(E)) {
-                          const b = g.components?.get(E);
-                          b && (b.forceUpdate(), y.add(E));
+                      if (_?.pathComponents && _.pathComponents.forEach((M) => {
+                        if (!h.has(M)) {
+                          const A = d.components?.get(M);
+                          A && (A.forceUpdate(), h.add(M));
                         }
-                      }), T.length === 0) break;
-                      T.pop();
+                      }), b.length === 0) break;
+                      b.pop();
                     }
                     break;
                   }
                 }
               }
             };
-          if (f === "getComponents")
-            return () => D(e, [])?.components;
-          if (f === "getAllFormRefs")
-            return () => Ie.getState().getFormRefsByStateKey(e);
+          if (m === "getComponents")
+            return () => V(e, [])?.components;
+          if (m === "getAllFormRefs")
+            return () => Ee.getState().getFormRefsByStateKey(e);
         }
-        if (f === "getFormRef")
-          return () => Ie.getState().getFormRef(e + "." + r.join("."));
-        if (f === "validationWrapper")
+        if (m === "getFormRef")
+          return () => Ee.getState().getFormRef(e + "." + t.join("."));
+        if (m === "validationWrapper")
           return ({
-            children: a,
-            hideMessage: o
-          }) => /* @__PURE__ */ ne(
-            _e,
+            children: o,
+            hideMessage: n
+          }) => /* @__PURE__ */ ie(
+            je,
             {
-              formOpts: o ? { validation: { message: "" } } : void 0,
-              path: r,
+              formOpts: n ? { validation: { message: "" } } : void 0,
+              path: t,
               stateKey: e,
-              children: a
+              children: o
             }
           );
-        if (f === "_stateKey") return e;
-        if (f === "_path") return r;
-        if (f === "update")
-          return (a) => (t(a, r, { updateType: "update" }), {
+        if (m === "_stateKey") return e;
+        if (m === "_path") return t;
+        if (m === "update")
+          return (o) => (console.log("udpating", o, t), r(o, t, { updateType: "update" }), {
             synced: () => {
-              const o = I.getState().getShadowMetadata(e, r);
-              x(e, r, {
-                ...o,
+              const n = T.getState().getShadowMetadata(e, t);
+              J(e, t, {
+                ...n,
                 isDirty: !1,
                 stateSource: "server",
                 lastServerSync: Date.now()
               });
-              const g = [e, ...r].join(".");
-              De(g, {
+              const d = [e, ...t].join(".");
+              Qe(d, {
                 type: "SYNC_STATUS_CHANGE",
                 isDirty: !1
               });
             }
           });
-        if (f === "toggle") {
-          const { value: a } = K(
+        if (m === "toggle") {
+          const { value: o } = Q(
             e,
-            r,
-            l
+            t,
+            u
           );
-          if (typeof a != "boolean")
+          if (typeof o != "boolean")
             throw new Error("toggle() can only be used on boolean values");
           return () => {
-            t(!a, r, {
+            r(!o, t, {
               updateType: "update"
             });
           };
         }
-        if (f === "formElement")
-          return (a, o) => /* @__PURE__ */ ne(
-            vt,
+        if (m === "formElement")
+          return (o, n) => /* @__PURE__ */ ie(
+            Oe,
             {
               stateKey: e,
-              path: r,
-              rebuildStateShape: u,
-              setState: t,
-              formOpts: o,
-              renderFn: a
+              path: t,
+              rebuildStateShape: c,
+              setState: r,
+              formOpts: n,
+              renderFn: o
             }
           );
-        const R = [...r, f];
-        return I.getState().getShadowValue(e, R), u({
-          path: R,
-          componentId: M,
-          meta: l
+        const te = [...t, m];
+        return T.getState().getShadowValue(e, te), c({
+          path: te,
+          componentId: I,
+          meta: u
         });
       }
-    }, w = new Proxy({}, j);
-    return d.set(C, w), w;
+    }, w = new Proxy({}, x);
+    return S.set(O, w), w;
   }
   const i = {
-    revertToInitialState: (r) => {
-      const l = I.getState().getShadowMetadata(e, []);
-      l?.stateSource === "server" && l.baseServerState ? l.baseServerState : I.getState().initialStateGlobal[e];
-      const M = I.getState().initialStateGlobal[e];
-      Ze(e), ce(e, M), u({
+    revertToInitialState: (t) => {
+      const u = T.getState().getShadowMetadata(e, []);
+      u?.stateSource === "server" && u.baseServerState ? u.baseServerState : T.getState().initialStateGlobal[e];
+      const I = T.getState().initialStateGlobal[e];
+      He(e), oe(e, I), c({
         path: [],
-        componentId: c
+        componentId: l
       });
-      const _ = G(e), C = X(_?.localStorage?.key) ? _?.localStorage?.key(M) : _?.localStorage?.key, U = `${n}-${e}-${C}`;
-      U && localStorage.removeItem(U);
-      const j = I.getState().getShadowMetadata(e, []);
-      return j && j?.components?.forEach((w) => {
+      const U = G(e), O = z(U?.localStorage?.key) ? U?.localStorage?.key(I) : U?.localStorage?.key, F = `${a}-${e}-${O}`;
+      F && localStorage.removeItem(F);
+      const x = T.getState().getShadowMetadata(e, []);
+      return x && x?.components?.forEach((w) => {
         w.forceUpdate();
-      }), M;
+      }), I;
     },
-    updateInitialState: (r) => {
-      const l = Oe(
+    updateInitialState: (t) => {
+      const u = Pe(
         e,
-        t,
-        c,
-        n
-      ), M = I.getState().initialStateGlobal[e], _ = G(e), C = X(_?.localStorage?.key) ? _?.localStorage?.key(M) : _?.localStorage?.key, U = `${n}-${e}-${C}`;
-      return localStorage.getItem(U) && localStorage.removeItem(U), je(() => {
-        Pe(e, r), ce(e, r);
-        const j = I.getState().getShadowMetadata(e, []);
-        j && j?.components?.forEach((w) => {
+        r,
+        l,
+        a
+      ), I = T.getState().initialStateGlobal[e], U = G(e), O = z(U?.localStorage?.key) ? U?.localStorage?.key(I) : U?.localStorage?.key, F = `${a}-${e}-${O}`;
+      return localStorage.getItem(F) && localStorage.removeItem(F), De(() => {
+        ke(e, t), oe(e, t);
+        const x = T.getState().getShadowMetadata(e, []);
+        x && x?.components?.forEach((w) => {
           w.forceUpdate();
         });
       }), {
-        fetchId: (j) => l.get()[j]
+        fetchId: (x) => u.get()[x]
       };
     }
   };
-  return u({
-    componentId: c,
+  return c({
+    componentId: l,
     path: []
   });
 }
-function Ae(e) {
-  return Me(St, { proxy: e });
+function _e(e) {
+  return Ie(dt, { proxy: e });
 }
-function St({
+function dt({
   proxy: e
 }) {
-  const t = B(null), c = B(null), n = B(!1), d = `${e._stateKey}-${e._path.join(".")}`, s = e._path.join("."), u = e._meta?.arrayViews?.[s], i = F(e._stateKey, e._path, u);
-  return q(() => {
-    const S = t.current;
-    if (!S || n.current) return;
-    const r = setTimeout(() => {
-      if (!S.parentElement) {
-        console.warn("Parent element not found for signal", d);
+  const r = L(null), l = L(null), a = L(!1), S = `${e._stateKey}-${e._path.join(".")}`, s = e._path.length > 0 ? e._path.join(".") : "root", c = e._meta?.arrayViews?.[s], i = R(e._stateKey, e._path, c);
+  return W(() => {
+    const f = r.current;
+    if (!f || a.current) return;
+    const t = setTimeout(() => {
+      if (!f.parentElement) {
+        console.warn("Parent element not found for signal", S);
         return;
       }
-      const l = S.parentElement, _ = Array.from(l.childNodes).indexOf(S);
-      let C = l.getAttribute("data-parent-id");
-      C || (C = `parent-${crypto.randomUUID()}`, l.setAttribute("data-parent-id", C)), c.current = `instance-${crypto.randomUUID()}`;
-      const U = I.getState().getShadowMetadata(e._stateKey, e._path) || {}, j = U.signals || [];
-      j.push({
-        instanceId: c.current,
-        parentId: C,
-        position: _,
+      const u = f.parentElement, U = Array.from(u.childNodes).indexOf(f);
+      let O = u.getAttribute("data-parent-id");
+      O || (O = `parent-${crypto.randomUUID()}`, u.setAttribute("data-parent-id", O)), l.current = `instance-${crypto.randomUUID()}`;
+      const F = T.getState().getShadowMetadata(e._stateKey, e._path) || {}, x = F.signals || [];
+      x.push({
+        instanceId: l.current,
+        parentId: O,
+        position: U,
         effect: e._effect
-      }), I.getState().setShadowMetadata(e._stateKey, e._path, {
-        ...U,
-        signals: j
+      }), T.getState().setShadowMetadata(e._stateKey, e._path, {
+        ...F,
+        signals: x
       });
       let w = i;
       if (e._effect)
@@ -1586,281 +1576,32 @@ function St({
             "state",
             `return (${e._effect})(state)`
           )(i);
-        } catch (f) {
-          console.error("Error evaluating effect function:", f);
+        } catch (m) {
+          console.error("Error evaluating effect function:", m);
         }
       w !== null && typeof w == "object" && (w = JSON.stringify(w));
-      const Y = document.createTextNode(String(w ?? ""));
-      S.replaceWith(Y), n.current = !0;
+      const ee = document.createTextNode(String(w ?? ""));
+      f.replaceWith(ee), a.current = !0;
     }, 0);
     return () => {
-      if (clearTimeout(r), c.current) {
-        const l = I.getState().getShadowMetadata(e._stateKey, e._path) || {};
-        l.signals && (l.signals = l.signals.filter(
-          (M) => M.instanceId !== c.current
-        ), I.getState().setShadowMetadata(e._stateKey, e._path, l));
+      if (clearTimeout(t), l.current) {
+        const u = T.getState().getShadowMetadata(e._stateKey, e._path) || {};
+        u.signals && (u.signals = u.signals.filter(
+          (I) => I.instanceId !== l.current
+        ), T.getState().setShadowMetadata(e._stateKey, e._path, u));
       }
     };
-  }, []), Me("span", {
-    ref: t,
+  }, []), Ie("span", {
+    ref: r,
     style: { display: "contents" },
-    "data-signal-id": d
+    "data-signal-id": S
   });
 }
-const mt = $e(
-  ht,
-  (e, t) => e.itemPath.join(".") === t.itemPath.join(".") && e.stateKey === t.stateKey && e.itemComponentId === t.itemComponentId && e.localIndex === t.localIndex
-), yt = (e) => {
-  const [t, c] = J(!1);
-  return ie(() => {
-    if (!e.current) {
-      c(!0);
-      return;
-    }
-    const n = Array.from(e.current.querySelectorAll("img"));
-    if (n.length === 0) {
-      c(!0);
-      return;
-    }
-    let d = 0;
-    const s = () => {
-      d++, d === n.length && c(!0);
-    };
-    return n.forEach((u) => {
-      u.complete ? s() : (u.addEventListener("load", s), u.addEventListener("error", s));
-    }), () => {
-      n.forEach((u) => {
-        u.removeEventListener("load", s), u.removeEventListener("error", s);
-      });
-    };
-  }, [e.current]), t;
-};
-function ht({
-  stateKey: e,
-  itemComponentId: t,
-  itemPath: c,
-  localIndex: n,
-  arraySetter: d,
-  rebuildStateShape: s,
-  renderFn: u
-}) {
-  const [, i] = J({}), { ref: S, inView: r } = He(), l = B(null), M = yt(l), _ = B(!1), C = [e, ...c].join(".");
-  Ue(e, t, i);
-  const U = ae(
-    (f) => {
-      l.current = f, S(f);
-    },
-    [S]
-  );
-  q(() => {
-    et(C, (f) => {
-      i({});
-    });
-  }, []), q(() => {
-    if (!r || !M || _.current)
-      return;
-    const f = l.current;
-    if (f && f.offsetHeight > 0) {
-      _.current = !0;
-      const R = f.offsetHeight;
-      x(e, c, {
-        virtualizer: {
-          itemHeight: R,
-          domRef: f
-        }
-      });
-      const a = c.slice(0, -1), o = [e, ...a].join(".");
-      De(o, {
-        type: "ITEMHEIGHT",
-        itemKey: c.join("."),
-        ref: l.current
-      });
-    }
-  }, [r, M, e, c]);
-  const j = F(e, c);
-  if (j === void 0)
-    return null;
-  const w = s({
-    currentState: j,
-    path: c,
-    componentId: t
-  }), Y = u(w, n, d);
-  return /* @__PURE__ */ ne("div", { ref: U, children: Y });
-}
-function vt({
-  stateKey: e,
-  path: t,
-  rebuildStateShape: c,
-  renderFn: n,
-  formOpts: d,
-  setState: s
-}) {
-  const [u] = J(() => ee()), [, i] = J({}), S = [e, ...t].join(".");
-  Ue(e, u, i);
-  const r = F(e, t), [l, M] = J(r), _ = B(!1), C = B(null);
-  q(() => {
-    !_.current && !oe(r, l) && M(r);
-  }, [r]), q(() => {
-    const f = I.getState().subscribeToPath(S, (R) => {
-      !_.current && l !== R && i({});
-    });
-    return () => {
-      f(), C.current && (clearTimeout(C.current), _.current = !1);
-    };
-  }, []);
-  const U = ae(
-    (f) => {
-      typeof r === "number" && typeof f == "string" && (f = f === "" ? 0 : Number(f)), M(f), _.current = !0, C.current && clearTimeout(C.current);
-      const a = d?.debounceTime ?? 200;
-      C.current = setTimeout(() => {
-        if (_.current = !1, s(f, t, { updateType: "update" }), !I.getState().getShadowMetadata(e, [])?.features?.validationEnabled) return;
-        const g = G(e)?.validation, v = g?.zodSchemaV4 || g?.zodSchemaV3;
-        if (v) {
-          const y = F(e, []), m = v.safeParse(y), h = D(e, t) || {};
-          if (m.success)
-            x(e, t, {
-              ...h,
-              validation: {
-                status: "VALID",
-                errors: [],
-                lastValidated: Date.now(),
-                validatedValue: f
-              }
-            });
-          else {
-            const T = ("issues" in m.error ? m.error.issues : m.error.errors).filter(
-              (A) => JSON.stringify(A.path) === JSON.stringify(t)
-            );
-            T.length > 0 ? x(e, t, {
-              ...h,
-              validation: {
-                status: "INVALID",
-                errors: [
-                  {
-                    source: "client",
-                    message: T[0]?.message,
-                    severity: "warning"
-                    // Gentle error during typing
-                  }
-                ],
-                lastValidated: Date.now(),
-                validatedValue: f
-              }
-            }) : x(e, t, {
-              ...h,
-              validation: {
-                status: "VALID",
-                errors: [],
-                lastValidated: Date.now(),
-                validatedValue: f
-              }
-            });
-          }
-        }
-      }, a), i({});
-    },
-    [s, t, d?.debounceTime, e]
-  ), j = ae(async () => {
-    if (console.log("handleBlur triggered"), C.current && (clearTimeout(C.current), C.current = null, _.current = !1, s(l, t, { updateType: "update" })), !D(e, [])?.features?.validationEnabled) return;
-    const { getInitialOptions: R } = I.getState(), a = R(e)?.validation, o = a?.zodSchemaV4 || a?.zodSchemaV3;
-    if (!o) return;
-    const g = D(e, t);
-    x(e, t, {
-      ...g,
-      validation: {
-        status: "VALIDATING",
-        errors: [],
-        lastValidated: Date.now(),
-        validatedValue: l
-      }
-    });
-    const v = F(e, []), y = o.safeParse(v);
-    if (console.log("result ", y), y.success)
-      x(e, t, {
-        ...g,
-        validation: {
-          status: "VALID",
-          errors: [],
-          lastValidated: Date.now(),
-          validatedValue: l
-        }
-      });
-    else {
-      const m = "issues" in y.error ? y.error.issues : y.error.errors;
-      console.log("All validation errors:", m), console.log("Current blur path:", t);
-      const h = m.filter((p) => {
-        if (console.log("Processing error:", p), t.some((A) => A.startsWith("id:"))) {
-          console.log("Detected array path with ULID");
-          const A = t[0].startsWith("id:") ? [] : t.slice(0, -1);
-          console.log("Parent path:", A);
-          const E = I.getState().getShadowMetadata(e, A);
-          if (console.log("Array metadata:", E), E?.arrayKeys) {
-            const b = [e, ...t.slice(0, -1)].join("."), N = E.arrayKeys.indexOf(b);
-            console.log("Item key:", b, "Index:", N);
-            const V = [...A, N, ...t.slice(-1)], O = JSON.stringify(p.path) === JSON.stringify(V);
-            return console.log("Zod path comparison:", {
-              zodPath: V,
-              errorPath: p.path,
-              match: O
-            }), O;
-          }
-        }
-        const T = JSON.stringify(p.path) === JSON.stringify(t);
-        return console.log("Direct path comparison:", {
-          errorPath: p.path,
-          currentPath: t,
-          match: T
-        }), T;
-      });
-      console.log("Filtered path errors:", h), x(e, t, {
-        ...g,
-        validation: {
-          status: "INVALID",
-          errors: h.map((p) => ({
-            source: "client",
-            message: p.message,
-            severity: "error"
-            // Hard error on blur
-          })),
-          lastValidated: Date.now(),
-          validatedValue: l
-        }
-      });
-    }
-    i({});
-  }, [e, t, l, s]), w = c({
-    path: t,
-    componentId: u
-  }), Y = new Proxy(w, {
-    get(f, R) {
-      return R === "inputProps" ? {
-        value: l ?? "",
-        onChange: (a) => {
-          U(a.target.value);
-        },
-        // 5. Wire the new onBlur handler to the input props.
-        onBlur: j,
-        ref: Ie.getState().getFormRef(e + "." + t.join("."))
-      } : f[R];
-    }
-  });
-  return /* @__PURE__ */ ne(_e, { formOpts: d, path: t, stateKey: e, children: n(Y) });
-}
-function Ue(e, t, c) {
-  const n = `${e}////${t}`;
-  ie(() => (ze(e, n, {
-    forceUpdate: () => c({}),
-    paths: /* @__PURE__ */ new Set(),
-    reactiveType: ["component"]
-  }), () => {
-    Ge(e, n);
-  }), [e, n]);
-}
 export {
-  Ae as $cogsSignal,
-  Pt as addStateOptions,
-  tt as createCogsState,
-  Ct as createCogsStateFromSync,
-  ft as useCogsStateFn
+  _e as $cogsSignal,
+  Mt as addStateOptions,
+  Xe as createCogsState,
+  At as createCogsStateFromSync,
+  lt as useCogsStateFn
 };
 //# sourceMappingURL=CogsState.jsx.map