cogsbox-sync 0.0.1

package/dist/index.js

@@ -0,0 +1,2755 @@
+// src/useWebsocketConnection.ts
+import { useRef, useCallback, useState, useEffect } from "react";
+var connectionPool = /* @__PURE__ */ new Map();
+function getOrCreateConnectionState(url) {
+  if (!connectionPool.has(url)) {
+    connectionPool.set(url, {
+      socket: null,
+      connected: false,
+      error: null,
+      reconnectAttempts: 0,
+      reconnectTimer: null,
+      refCount: 0
+    });
+  }
+  return connectionPool.get(url);
+}
+function useWebSocketConnection(config) {
+  const [, forceUpdate] = useState({});
+  const shouldConnect = config.connect !== false;
+  const connectionState = getOrCreateConnectionState(config.url);
+  const currentUrlRef = useRef(config.url);
+  currentUrlRef.current = config.url;
+  const onConnectRef = useRef(config.onConnect);
+  const onMessageRef = useRef(config.onMessage);
+  const onDisconnectRef = useRef(config.onDisconnect);
+  const onErrorRef = useRef(config.onError);
+  const onRefreshTokenRef = useRef(config.onRefreshToken);
+  useEffect(() => {
+    onConnectRef.current = config.onConnect;
+    onMessageRef.current = config.onMessage;
+    onDisconnectRef.current = config.onDisconnect;
+    onErrorRef.current = config.onError;
+    onRefreshTokenRef.current = config.onRefreshToken;
+  });
+  const notifySubscribers = useCallback(() => {
+    forceUpdate({});
+  }, []);
+  const connect = useCallback(() => {
+    const state = getOrCreateConnectionState(config.url);
+    if (state.socket && state.socket.readyState === WebSocket.CLOSED) {
+      console.log("[WS] Cleaning up closed socket");
+      state.socket = null;
+      state.connected = false;
+    }
+    if (state.socket && (state.socket.readyState === WebSocket.CONNECTING || state.socket.readyState === WebSocket.OPEN)) {
+      console.log("[WS] Socket already connecting or connected");
+      return;
+    }
+    if (state.reconnectTimer) {
+      clearTimeout(state.reconnectTimer);
+      state.reconnectTimer = null;
+    }
+    try {
+      console.log(`[WS] Creating new WebSocket connection to ${config.url}`);
+      const socket = new WebSocket(config.url);
+      state.socket = socket;
+      socket.onopen = () => {
+        console.log("[WS] Socket opened successfully");
+        state.connected = true;
+        state.error = null;
+        state.reconnectAttempts = 0;
+        onConnectRef.current?.(socket);
+        notifySubscribers();
+      };
+      socket.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          onMessageRef.current?.(data, state.socket);
+        } catch (err) {
+          console.error("Failed to parse message", err);
+        }
+      };
+      socket.onclose = (event) => {
+        console.log(
+          `[WS] Socket closed - Code: ${event.code}, Reason: ${event.reason}`
+        );
+        state.connected = false;
+        state.socket = null;
+        onDisconnectRef.current?.();
+        notifySubscribers();
+        if (state.refCount > 0 && event.code !== 1e3) {
+          const attempts = state.reconnectAttempts || 0;
+          if (attempts < (config.maxReconnectAttempts || 5)) {
+            const delay = Math.min(1e3 * Math.pow(2, attempts), 1e4);
+            console.log(
+              `[WS] Scheduling reconnect in ${delay}ms (attempt ${attempts + 1})`
+            );
+            state.reconnectAttempts = attempts + 1;
+            state.reconnectTimer = setTimeout(() => {
+              if (state.refCount > 0) {
+                connect();
+              }
+            }, delay);
+          }
+        }
+      };
+      socket.onerror = (error) => {
+        console.error("[WS] WebSocket error:", error);
+        state.error = "Connection error";
+        state.connected = false;
+        onErrorRef.current?.("Connection error");
+        notifySubscribers();
+      };
+    } catch (err) {
+      console.error("[WS] Connection error:", err);
+      const errorMsg = err instanceof Error ? err.message : "Failed to connect";
+      state.error = errorMsg;
+      onErrorRef.current?.(errorMsg);
+      notifySubscribers();
+      if (state.refCount > 0) {
+        const attempts = state.reconnectAttempts || 0;
+        if (attempts < (config.maxReconnectAttempts || 5)) {
+          const delay = Math.min(1e3 * Math.pow(2, attempts), 1e4);
+          state.reconnectAttempts = attempts + 1;
+          state.reconnectTimer = setTimeout(() => {
+            if (state.refCount > 0) {
+              connect();
+            }
+          }, delay);
+        }
+      }
+    }
+  }, [config.url, config.maxReconnectAttempts, notifySubscribers]);
+  useEffect(() => {
+    if (!shouldConnect) {
+      return;
+    }
+    const state = getOrCreateConnectionState(config.url);
+    state.refCount++;
+    if (state.reconnectTimer) {
+      clearTimeout(state.reconnectTimer);
+      state.reconnectTimer = null;
+    }
+    if (state.refCount === 1 || !state.socket || state.socket.readyState === WebSocket.CLOSED) {
+      console.log(
+        `[WS] Connecting to ${config.url} (refCount: ${state.refCount})`
+      );
+      connect();
+    } else if (state.socket && state.socket.readyState === WebSocket.OPEN) {
+      console.log(
+        `[WS] Reusing existing connection (refCount: ${state.refCount})`
+      );
+      notifySubscribers();
+    }
+    return () => {
+      const state2 = getOrCreateConnectionState(config.url);
+      state2.refCount--;
+      console.log(`[WS] Component unmounting (refCount: ${state2.refCount})`);
+      if (state2.reconnectTimer) {
+        clearTimeout(state2.reconnectTimer);
+        state2.reconnectTimer = null;
+      }
+      if (state2.refCount === 0) {
+        state2.reconnectTimer = setTimeout(() => {
+          if (state2.refCount === 0) {
+            if (state2.socket && (state2.socket.readyState === WebSocket.OPEN || state2.socket.readyState === WebSocket.CONNECTING)) {
+              console.log(
+                `[WS] Closing connection to ${config.url} due to no more references.`
+              );
+              state2.socket.close(1e3, "No more references");
+            }
+            console.log(
+              `[WS] Deleting connection state for ${config.url} from the pool.`
+            );
+            connectionPool.delete(config.url);
+          }
+        }, 500);
+      }
+      notifySubscribers();
+    };
+  }, [config.url, shouldConnect, connect, notifySubscribers]);
+  const sendMessage = useCallback(
+    (payload) => {
+      const state = getOrCreateConnectionState(currentUrlRef.current);
+      if (state.socket && state.socket.readyState === WebSocket.OPEN) {
+        state.socket.send(JSON.stringify(payload));
+        return true;
+      } else {
+        console.warn("WebSocket not ready, message NOT sent");
+        return false;
+      }
+    },
+    []
+    // Remove config.url from dependencies since we're using the ref
+  );
+  const subscribe = useCallback((callback) => {
+    return () => {
+    };
+  }, []);
+  return {
+    connection: connectionState,
+    sendMessage,
+    subscribe
+  };
+}
+
+// ../../node_modules/.pnpm/cogsbox-shape@0.5.170_zod@4.3.6/node_modules/cogsbox-shape/dist/schema.js
+import { z } from "zod";
+var isFunction = (fn) => typeof fn === "function";
+
+// src/SyncProvider.tsx
+import {
+  createContext,
+  useCallback as useCallback2,
+  useContext,
+  useEffect as useEffect2,
+  useMemo,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+
+// src/vite/getRefreshtoken.ts
+async function refreshSyncToken({
+  refreshToken,
+  clientId
+}) {
+  const apiToken = import.meta.env.VITE_COGS_SYNC_API_TOKEN;
+  const serverUrl = import.meta.env.VITE_COGS_SYNC_SERVER_URL;
+  if (!apiToken) return null;
+  try {
+    const response = await fetch(`${serverUrl}/refresh-token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        // Use the apiToken from Vite's env
+        Authorization: `Bearer ${apiToken}`
+      },
+      body: JSON.stringify({
+        refreshToken,
+        clientId
+      })
+    });
+    if (!response.ok) return null;
+    const { sessionToken } = await response.json();
+    return sessionToken;
+  } catch (error) {
+    console.error("Token refresh failed:", error);
+    return null;
+  }
+}
+
+// src/SyncProvider.tsx
+import { create } from "zustand";
+import { Fragment, jsx } from "react/jsx-runtime";
+var useNotificationStore = create((set, get) => ({
+  isConnected: false,
+  notificationsByChannel: {},
+  channelSubscribers: /* @__PURE__ */ new Map(),
+  setConnectionStatus: (status) => set({ isConnected: status }),
+  addNotifications: (newNotifications) => {
+    set((state) => {
+      const updatedChannels = { ...state.notificationsByChannel };
+      for (const notification of newNotifications) {
+        const channel = notification.channel;
+        if (!channel) {
+          console.warn("Notification missing channel/type:", notification);
+          continue;
+        }
+        const existing = updatedChannels[channel] || [];
+        updatedChannels[channel] = [...existing, notification.payload];
+        const subs = state.channelSubscribers.get(channel);
+        if (subs) {
+          subs.forEach((cb) => cb([notification.payload]));
+        }
+      }
+      return { notificationsByChannel: updatedChannels };
+    });
+  },
+  addSubscriber: (channel, callback) => {
+    const subs = get().channelSubscribers.get(channel) || /* @__PURE__ */ new Set();
+    subs.add(callback);
+    const updated = new Map(get().channelSubscribers);
+    updated.set(channel, subs);
+    set({ channelSubscribers: updated });
+    return () => {
+      const copy2 = new Map(get().channelSubscribers);
+      const current = copy2.get(channel);
+      if (current) {
+        current.delete(callback);
+        if (current.size === 0) copy2.delete(channel);
+        else copy2.set(channel, current);
+        set({ channelSubscribers: copy2 });
+      }
+    };
+  },
+  subscribeToPath: (path, callback) => get().addSubscriber(path, callback)
+}));
+var SyncContext = createContext({
+  token: null,
+  refreshToken: null,
+  socketUrl: null,
+  clientId: null,
+  sessionId: "",
+  refreshAccessToken: () => Promise.resolve(null)
+});
+var NotificationContext = createContext({
+  subscribe: () => () => {
+  },
+  isNotificationConnected: false
+});
+function SyncProvider({
+  children,
+  tokens
+}) {
+  const sessionId = useRef2(crypto.randomUUID()).current;
+  const {
+    sessionToken,
+    refreshToken,
+    serverUrl: socketUrl,
+    clientId
+  } = tokens || {};
+  const [currentToken, setCurrentToken] = useState2(sessionToken);
+  const setConnectionStatus = useNotificationStore(
+    (state) => state.setConnectionStatus
+  );
+  const isNotificationConnected = useNotificationStore(
+    (state) => state.isConnected
+  );
+  const subscriptions = useRef2(
+    /* @__PURE__ */ new Map()
+  );
+  const addNotifications = useNotificationStore(
+    (state) => state.addNotifications
+  );
+  const refreshTokenRef = useRef2(refreshToken);
+  const isRefreshing = useRef2(false);
+  const refreshAccessToken = useCallback2(async () => {
+    if (!refreshTokenRef.current || isRefreshing.current) {
+      return null;
+    }
+    isRefreshing.current = true;
+    try {
+      const newToken = await refreshSyncToken({
+        refreshToken: refreshTokenRef.current,
+        clientId
+      });
+      if (newToken) {
+        setCurrentToken(newToken);
+        return newToken;
+      }
+      return null;
+    } catch (error) {
+      console.error("Token refresh failed:", error);
+      return null;
+    } finally {
+      isRefreshing.current = false;
+    }
+  }, [clientId]);
+  useWebSocketConnection({
+    url: clientId && sessionToken ? `${socketUrl}/user-presence/${clientId}?token=${currentToken}&sessionId=${sessionId}` : "",
+    connect: Boolean(clientId && currentToken),
+    onConnect: (e) => {
+      setConnectionStatus(true);
+    },
+    onDisconnect: () => setConnectionStatus(false),
+    onMessage: (data) => {
+      if (data.type === "notifications_batch" && Array.isArray(data.payload)) {
+        console.log("data.payload ---------------------", data.payload);
+        addNotifications(data.payload);
+        return;
+      }
+    }
+  });
+  const subscribe = useCallback2(
+    (channel, callback) => {
+      if (!subscriptions.current.has(channel)) {
+        subscriptions.current.set(channel, /* @__PURE__ */ new Set());
+      }
+      subscriptions.current.get(channel).add(callback);
+      return () => {
+        const callbacks = subscriptions.current.get(channel);
+        if (callbacks) {
+          callbacks.delete(callback);
+          if (callbacks.size === 0) {
+            subscriptions.current.delete(channel);
+          }
+        }
+      };
+    },
+    []
+  );
+  const notificationValue = useMemo(
+    () => ({
+      subscribe,
+      isNotificationConnected
+    }),
+    [subscribe, isNotificationConnected]
+  );
+  if (!sessionToken || !socketUrl) {
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  return /* @__PURE__ */ jsx(
+    SyncContext.Provider,
+    {
+      value: {
+        token: currentToken,
+        refreshToken,
+        socketUrl,
+        clientId,
+        sessionId,
+        refreshAccessToken
+      },
+      children: /* @__PURE__ */ jsx(NotificationContext.Provider, { value: notificationValue, children })
+    }
+  );
+}
+function useSync(options) {
+  const { token, socketUrl, clientId, sessionId, refreshAccessToken } = useContext(SyncContext);
+  const [clientActivity, setClientActivity] = useState2({});
+  const currentToken = useRef2(token);
+  useEffect2(() => {
+    currentToken.current = token;
+  }, [token]);
+  const determinedSyncId = isFunction(options.stateRoom) ? options.stateRoom({ clientId: clientId ?? "" }) : options.stateRoom;
+  const syncIdString = useMemo(() => {
+    let baseKey = `${options.stateKey}::${determinedSyncId}`;
+    if (options.apiParams && Object.keys(options.apiParams).length > 0) {
+      const paramString = Object.entries(options.apiParams).sort(([a2], [b3]) => a2.localeCompare(b3)).map(([key, value]) => `${key}:${value}`).join(",");
+      baseKey = `${options.stateKey}[${paramString}]::${determinedSyncId}`;
+    }
+    return baseKey;
+  }, [options.stateKey, determinedSyncId, JSON.stringify(options.apiParams)]);
+  const syndIdRef = useRef2(syncIdString);
+  syndIdRef.current = syncIdString;
+  const subScribers = useRef2([]);
+  const isInitialised = useRef2(false);
+  const eventHandlers = useRef2({
+    onInitialState: null,
+    onPatch: null,
+    onValidationError: null,
+    onStateRequest: null,
+    onSubscribersUpdate: null,
+    onClientActivity: null
+  });
+  const isReadyToConnect = Boolean(
+    token && socketUrl && sessionId && determinedSyncId
+  );
+  const { connection, sendMessage } = useWebSocketConnection({
+    url: `${socketUrl}/sync/${syndIdRef.current}?token=${currentToken.current}&sessionId=${sessionId}`,
+    connect: isReadyToConnect,
+    onDisconnect() {
+      console.log("useSync WebSocket disconnected");
+      isInitialised.current = false;
+    },
+    onConnect: async () => {
+      console.log("useSync WebSocket onConnect");
+      sendMessage({
+        type: "initialSend",
+        syncKey: syncIdString,
+        isArray: false,
+        inMemoryState: options?.inMemoryState,
+        apiParams: options.apiParams
+      });
+    },
+    onMessage: async (data, ws) => {
+      switch (data.type) {
+        case "auth_failed":
+          console.log("auth_failed", data);
+          const newToken = await refreshAccessToken();
+          if (newToken) {
+            currentToken.current = newToken;
+          }
+          break;
+        case "updateInitialState":
+          if (data.syncKey === syndIdRef.current) {
+            isInitialised.current = true;
+            console.log("Received initial state", data);
+            eventHandlers.current.onInitialState?.(data.data, data.version);
+          }
+          break;
+        case "requestInitialState":
+          if (data.syncKey === syndIdRef.current) {
+            const state = eventHandlers.current.onStateRequest?.();
+            if (state !== void 0) {
+              sendMessage({
+                type: "providingInitialState",
+                syncKey: syncIdString,
+                state
+              });
+            }
+          }
+          break;
+        case "clientActivity":
+          if (data.syncKey === syndIdRef.current) {
+            console.log("Received client activity:", data.activity);
+            eventHandlers.current.onClientActivity?.(data.activity);
+          }
+          break;
+        case "subscribers":
+          if (data.syncKey === syndIdRef.current) {
+            console.log("Received subscriber list:", data.subscribers);
+            subScribers.current = data.subscribers;
+            eventHandlers.current.onSubscribersUpdate?.(data.subscribers);
+          }
+          break;
+        case "applyPatch":
+          if (data.syncKey === syndIdRef.current) {
+            console.log("applyPatch", data);
+            eventHandlers.current.onPatch?.(
+              data.data,
+              data.sessionId,
+              data.version
+            );
+          }
+          break;
+        case "validationError":
+          console.log("Sync validation error:", data.details, data.message);
+          eventHandlers.current.onValidationError?.(
+            data.details,
+            data.sessionId
+          );
+          break;
+        case "syncReady":
+          console.log("Sync ready for syncKey:", data.syncKey);
+          break;
+        case "fetchStateFromDb":
+          if (determinedSyncId) {
+            sendMessage({
+              type: "initialSend",
+              syncKey: syncIdString,
+              isArray: false,
+              inMemoryState: options?.inMemoryState,
+              apiParams: options.apiParams
+            });
+          }
+          break;
+        case "error":
+          console.error("Sync error:", data);
+          break;
+      }
+    }
+  });
+  useEffect2(() => {
+    if (connection.connected && syncIdString && options.apiParams) {
+      sendMessage({
+        type: "initialSend",
+        syncKey: syncIdString,
+        isArray: false,
+        inMemoryState: options?.inMemoryState,
+        apiParams: options.apiParams
+      });
+    }
+  }, [JSON.stringify(options.apiParams), connection.connected]);
+  useEffect2(() => {
+    if (determinedSyncId && connection.connected && isInitialised.current) {
+      sendMessage({
+        type: "requestState",
+        syncKey: syncIdString
+      });
+    }
+  }, [determinedSyncId, connection.connected, syncIdString]);
+  return {
+    sessionId,
+    connected: connection.connected,
+    clientId,
+    subscribers: subScribers.current,
+    // Event handler setters
+    onInitialState: (handler) => {
+      eventHandlers.current.onInitialState = handler;
+    },
+    onPatch: (handler) => {
+      eventHandlers.current.onPatch = handler;
+    },
+    onValidationError: (handler) => {
+      eventHandlers.current.onValidationError = handler;
+    },
+    onStateRequest: (handler) => {
+      eventHandlers.current.onStateRequest = handler;
+    },
+    onSubscribersUpdate: (handler) => {
+      eventHandlers.current.onSubscribersUpdate = handler;
+    },
+    onClientActivity: (handler) => {
+      eventHandlers.current.onClientActivity = handler;
+    },
+    clientActivity,
+    // Actions
+    sendUpdate: (operation) => {
+      sendMessage({
+        type: "queueUpdate",
+        data: { operation }
+      });
+    },
+    reportClientActivity: (event) => {
+      console.log("reportClientActivity", event);
+      sendMessage({
+        type: "clientStatus",
+        syncKey: syncIdString,
+        status: {
+          // Create the wrapper object here
+          event,
+          // <-- Pass the event object directly into a property
+          timestamp: Date.now(),
+          sessionId
+        }
+      });
+    },
+    requestState: () => {
+      sendMessage({
+        type: "requestState",
+        syncKey: syncIdString
+      });
+    }
+  };
+}
+function useNotifications(channel) {
+  const { subscribe, isNotificationConnected } = useContext(NotificationContext);
+  let notifications = null;
+  return { notifications, isConnected: isNotificationConnected };
+}
+function createNotificationHook(syncSchema) {
+  const useSyncNotifications = (type) => {
+    const [notifications, setNotifications] = useState2([]);
+    const isConnected = useNotificationStore((state) => state.isConnected);
+    useEffect2(() => {
+      const current = useNotificationStore.getState().notificationsByChannel[type] || [];
+      setNotifications(current);
+      const unsubscribe = useNotificationStore.getState().addSubscriber(type, (newOnes) => {
+        setNotifications(
+          (prev) => [...prev, ...newOnes]
+        );
+      });
+      return unsubscribe;
+    }, [type]);
+    return { notifications, isConnected };
+  };
+  return { useSyncNotifications };
+}
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/CogsState.js
+import { jsx as H, Fragment as pe } from "react/jsx-runtime";
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/pluginStore.js
+import { create as l } from "zustand";
+var b = l((u3, o2) => ({
+  stateHandlers: /* @__PURE__ */ new Map(),
+  registerStateHandler: (e, s2) => u3((n2) => {
+    const t = new Map(n2.stateHandlers);
+    return t.set(e, s2), console.log("addign handler", e, s2), { stateHandlers: t };
+  }),
+  registeredPlugins: [],
+  pluginOptions: /* @__PURE__ */ new Map(),
+  setRegisteredPlugins: (e) => u3({ registeredPlugins: e }),
+  setPluginOptionsForState: (e, s2) => u3((n2) => {
+    const t = new Map(n2.pluginOptions), r2 = /* @__PURE__ */ new Map();
+    return Object.entries(s2).forEach(([i2, p2]) => {
+      n2.registeredPlugins.some((a2) => a2.name === i2) && r2.set(i2, p2);
+    }), r2.size > 0 && t.set(e, r2), { pluginOptions: t };
+  }),
+  getPluginConfigsForState: (e) => {
+    const s2 = o2(), n2 = s2.pluginOptions.get(e);
+    return n2 ? s2.registeredPlugins.map((t) => {
+      const r2 = n2.get(t.name);
+      return r2 !== void 0 ? { plugin: t, options: r2 } : null;
+    }).filter(Boolean) : [];
+  },
+  updateSubscribers: /* @__PURE__ */ new Set(),
+  subscribeToUpdates: (e) => (o2().updateSubscribers.add(e), () => {
+    o2().updateSubscribers.delete(e);
+  }),
+  notifyUpdate: (e) => {
+    o2().updateSubscribers.forEach((s2) => s2(e));
+  },
+  formUpdateSubscribers: /* @__PURE__ */ new Set(),
+  subscribeToFormUpdates: (e) => (o2().formUpdateSubscribers.add(e), () => {
+    o2().formUpdateSubscribers.delete(e);
+  }),
+  notifyFormUpdate: (e) => {
+    o2().formUpdateSubscribers.forEach((s2) => s2(e));
+  },
+  hookResults: /* @__PURE__ */ new Map(),
+  setHookResult: (e, s2, n2) => u3((t) => {
+    const r2 = new Map(t.hookResults), i2 = new Map(r2.get(e) ?? /* @__PURE__ */ new Map());
+    return n2 === void 0 ? i2.delete(s2) : i2.set(s2, n2), i2.size > 0 ? r2.set(e, i2) : r2.delete(e), { hookResults: r2 };
+  }),
+  getHookResult: (e, s2) => o2().hookResults.get(e)?.get(s2),
+  removeHookResult: (e, s2) => u3((n2) => {
+    const t = new Map(n2.hookResults), r2 = new Map(t.get(e) ?? /* @__PURE__ */ new Map());
+    return r2.delete(s2), r2.size > 0 ? t.set(e, r2) : t.delete(e), { hookResults: t };
+  })
+}));
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/CogsState.js
+import { useState as ee, useRef as G, useCallback as Ae, useEffect as q, useLayoutEffect as Me, useMemo as ye, createElement as ue, startTransition as $e } from "react";
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/utility.js
+var u = (e) => e && typeof e == "object" && !Array.isArray(e) && e !== null;
+var y = (e) => Array.isArray(e);
+var d = (e, n2, i2 = {}, r2 = []) => {
+  if (u(e) && u(n2)) {
+    const t = Object.keys(e), l3 = Object.keys(n2);
+    if (t.length !== l3.length)
+      return false;
+    for (let s2 of t) {
+      const o2 = e[s2], f3 = n2[s2];
+      if (!(s2 in e) || !(s2 in n2))
+        return false;
+      const c = [...r2, s2];
+      if (!d(o2, f3, i2, c))
+        return false;
+    }
+    return true;
+  } else if (y(e) && y(n2)) {
+    if (e.length !== n2.length)
+      return false;
+    for (let t = 0; t < e.length; t++)
+      if (!d(e[t], n2[t], i2, [
+        ...r2,
+        t.toString()
+      ]))
+        return false;
+    return true;
+  } else
+    return e === n2 || Number.isNaN(e) && Number.isNaN(n2);
+};
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/Components.js
+import { jsx as I2, Fragment as U } from "react/jsx-runtime";
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/plugins.js
+import { z as l2 } from "zod";
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/store.js
+import { create as A } from "zustand";
+function O(u3, o2 = "zod4") {
+  if (!u3) return null;
+  let e = u3, t = false, a2 = false, n2, s2 = false;
+  for (let l3 = 0; l3 < 20; l3++) {
+    const f3 = e?.def || e?._def;
+    if (!f3) break;
+    const p2 = f3.typeName || f3.type || e._type;
+    if (p2 === "ZodUnion" || p2 === "union")
+      if (f3.options && f3.options.length > 0) {
+        e = f3.options[0];
+        continue;
+      } else
+        break;
+    if (p2 === "ZodOptional" || p2 === "optional")
+      a2 = true;
+    else if (p2 === "ZodNullable" || p2 === "nullable")
+      t = true;
+    else if (p2 === "ZodDefault" || p2 === "default")
+      s2 = true, n2 = typeof f3.defaultValue == "function" ? f3.defaultValue() : f3.defaultValue;
+    else if (p2 !== "ZodEffects" && p2 !== "effects")
+      break;
+    const y2 = f3.innerType || f3.schema || e._inner;
+    if (!y2 || y2 === e)
+      break;
+    e = y2;
+  }
+  const r2 = e, i2 = r2?.def || r2?._def, c = i2?.typeName || i2?.type || r2?._type;
+  return c === "ZodNumber" || c === "number" ? {
+    type: "number",
+    schema: u3,
+    source: o2,
+    default: s2 ? n2 : 0,
+    nullable: t,
+    optional: a2
+  } : c === "ZodString" || c === "string" ? {
+    type: "string",
+    schema: u3,
+    source: o2,
+    default: s2 ? n2 : "",
+    nullable: t,
+    optional: a2
+  } : c === "ZodBoolean" || c === "boolean" ? {
+    type: "boolean",
+    schema: u3,
+    source: o2,
+    default: s2 ? n2 : false,
+    nullable: t,
+    optional: a2
+  } : c === "ZodArray" || c === "array" ? {
+    type: "array",
+    schema: u3,
+    source: o2,
+    default: s2 ? n2 : [],
+    nullable: t,
+    optional: a2
+  } : c === "ZodObject" || c === "object" ? {
+    type: "object",
+    schema: u3,
+    source: o2,
+    default: s2 ? n2 : {},
+    nullable: t,
+    optional: a2
+  } : c === "ZodDate" || c === "date" ? {
+    type: "date",
+    schema: u3,
+    source: o2,
+    default: s2 ? n2 : /* @__PURE__ */ new Date(),
+    nullable: t,
+    optional: a2
+  } : null;
+}
+function E(u3) {
+  if (u3 === null)
+    return {
+      type: "unknown",
+      schema: null,
+      source: "default",
+      default: null,
+      nullable: true
+    };
+  if (u3 === void 0)
+    return {
+      type: "unknown",
+      schema: null,
+      source: "default",
+      default: void 0,
+      optional: true
+    };
+  const o2 = typeof u3;
+  return o2 === "number" ? { type: "number", schema: null, source: "runtime", default: u3 } : o2 === "string" ? { type: "string", schema: null, source: "runtime", default: u3 } : o2 === "boolean" ? { type: "boolean", schema: null, source: "runtime", default: u3 } : Array.isArray(u3) ? { type: "array", schema: null, source: "runtime", default: [] } : u3 instanceof Date ? { type: "date", schema: null, source: "runtime", default: u3 } : o2 === "object" ? { type: "object", schema: null, source: "runtime", default: {} } : { type: "unknown", schema: null, source: "runtime", default: u3 };
+}
+function _(u3, o2, e) {
+  if (o2 == null || typeof o2 != "object") {
+    const t = { _meta: { value: o2 } };
+    return t._meta.typeInfo = I(o2, e), t;
+  }
+  if (Array.isArray(o2)) {
+    const t = { _meta: { arrayKeys: [] } };
+    return t._meta.typeInfo = I(o2, e), o2.forEach((a2, n2) => {
+      const s2 = M(), r2 = e ? {
+        ...e,
+        path: [...e.path, n2.toString()]
+      } : void 0;
+      t[s2] = _(u3, a2, r2), t._meta.arrayKeys.push(s2);
+    }), t;
+  }
+  if (o2.constructor === Object) {
+    const t = { _meta: {} };
+    t._meta.typeInfo = I(o2, e);
+    for (const a2 in o2)
+      if (Object.prototype.hasOwnProperty.call(o2, a2)) {
+        const n2 = e ? {
+          ...e,
+          path: [...e.path, a2]
+        } : void 0;
+        t[a2] = _(u3, o2[a2], n2);
+      }
+    return t;
+  }
+  return {
+    _meta: {
+      value: o2,
+      typeInfo: E(o2)
+    }
+  };
+}
+function I(u3, o2) {
+  if (o2) {
+    let e = null;
+    if (o2.schemas.zodV4) {
+      const t = o2.path.length === 0 ? o2.schemas.zodV4 : j(o2.schemas.zodV4, o2.path);
+      t && (e = O(t, "zod4"));
+    }
+    if (!e && o2.schemas.zodV3) {
+      const t = o2.path.length === 0 ? o2.schemas.zodV3 : j(o2.schemas.zodV3, o2.path);
+      t && (e = O(t, "zod3"));
+    }
+    if (!e && o2.schemas.sync?.[o2.stateKey] && (e = E(u3), e.source = "sync"), e) return e;
+  }
+  return E(u3);
+}
+function N(u3, o2, e) {
+  const t = h.get(u3) || h.get(`[${u3}`);
+  if (!t) return;
+  function a2(n2, s2) {
+    if (!n2 || typeof n2 != "object") return;
+    const r2 = j(o2, s2);
+    if (r2) {
+      const i2 = O(r2, e);
+      i2 && (n2._meta || (n2._meta = {}), n2._meta.typeInfo = {
+        ...i2,
+        schema: r2
+      });
+    }
+    n2._meta?.arrayKeys ? n2._meta.arrayKeys.forEach((i2) => {
+      n2[i2] && a2(n2[i2], [...s2, "0"]);
+    }) : n2._meta?.hasOwnProperty("value") || Object.keys(n2).forEach((i2) => {
+      i2 !== "_meta" && a2(n2[i2], [...s2, i2]);
+    });
+  }
+  a2(t, []);
+}
+function z2(u3) {
+  let o2 = u3;
+  for (; o2; ) {
+    const e = o2.def || o2._def, t = e?.typeName || e?.type || o2._type;
+    if (t === "ZodOptional" || t === "optional" || t === "ZodNullable" || t === "nullable" || t === "ZodDefault" || t === "default" || t === "ZodEffects" || t === "effects")
+      o2 = e.innerType || e.schema || o2._inner || o2.unwrap?.();
+    else
+      break;
+  }
+  return o2;
+}
+function j(u3, o2) {
+  if (!u3) return null;
+  if (o2.length === 0) return u3;
+  let e = u3;
+  for (const t of o2) {
+    const a2 = z2(e);
+    if (!a2) return null;
+    const n2 = a2.def || a2._def, s2 = n2?.typeName || n2?.type || a2._type;
+    if (s2 === "ZodObject" || s2 === "object")
+      e = (n2?.shape || a2.shape || a2._shape)?.[t];
+    else if (s2 === "ZodArray" || s2 === "array")
+      e = a2.element || n2?.type;
+    else
+      return null;
+    if (!e)
+      return null;
+  }
+  return e;
+}
+var h = /* @__PURE__ */ new Map();
+var D = 0;
+var V = Date.now().toString(36);
+function M(u3) {
+  return `id:local_${V}_${(D++).toString(36)}`;
+}
+var $ = A((u3, o2) => ({
+  getPluginMetaDataMap: (e, t) => o2().getShadowMetadata(e, t)?.pluginMetaData,
+  setPluginMetaData: (e, t, a2, n2) => {
+    const s2 = o2().getShadowMetadata(e, t) || {}, r2 = new Map(s2.pluginMetaData || []), i2 = r2.get(a2) || {};
+    r2.set(a2, { ...i2, ...n2 }), o2().setShadowMetadata(e, t, { ...s2, pluginMetaData: r2 }), o2().notifyPathSubscribers([e, ...t].join("."), {
+      type: "METADATA_UPDATE"
+    });
+  },
+  removePluginMetaData: (e, t, a2) => {
+    const n2 = o2().getShadowMetadata(e, t);
+    if (!n2?.pluginMetaData) return;
+    const s2 = new Map(n2.pluginMetaData);
+    s2.delete(a2), o2().setShadowMetadata(e, t, { ...n2, pluginMetaData: s2 });
+  },
+  setTransformCache: (e, t, a2, n2) => {
+    const s2 = o2().getShadowMetadata(e, t) || {};
+    s2.transformCaches || (s2.transformCaches = /* @__PURE__ */ new Map()), s2.transformCaches.set(a2, n2), o2().setShadowMetadata(e, t, {
+      transformCaches: s2.transformCaches
+    });
+  },
+  // Replace your entire `initializeAndMergeShadowState` function with this one.
+  initializeAndMergeShadowState: (e, t) => {
+    const n2 = t?._meta?.arrayKeys !== void 0 ? `[${e}` : e, s2 = h.get(n2) || h.get(e) || h.get(`[${e}`);
+    let r2 = {};
+    if (s2?._meta) {
+      const {
+        components: f3,
+        features: p2,
+        lastServerSync: y2,
+        stateSource: m4,
+        baseServerState: d3,
+        pathComponents: S2,
+        signals: b3,
+        validation: g2
+      } = s2._meta;
+      f3 && (r2.components = f3), p2 && (r2.features = p2), y2 && (r2.lastServerSync = y2), m4 && (r2.stateSource = m4), d3 && (r2.baseServerState = d3), S2 && (r2.pathComponents = S2), b3 && (r2.signals = b3), g2 && (r2.validation = g2);
+    }
+    function i2(f3, p2) {
+      if (p2._meta || f3._meta) {
+        const d3 = f3._meta || {}, S2 = p2._meta || {}, b3 = { ...d3, ...S2 };
+        d3.typeInfo?.schema && !S2.typeInfo?.schema && (b3.typeInfo = d3.typeInfo), d3.validation && !S2.validation && (b3.validation = d3.validation), d3.components && (b3.components = d3.components), f3._meta = b3;
+      }
+      if (p2._meta?.hasOwnProperty("value")) {
+        for (const d3 in f3)
+          d3 !== "_meta" && delete f3[d3];
+        return;
+      }
+      const y2 = new Set(
+        Object.keys(p2).filter((d3) => d3 !== "_meta")
+      ), m4 = new Set(
+        Object.keys(f3).filter((d3) => d3 !== "_meta")
+      );
+      for (const d3 of m4)
+        y2.has(d3) || delete f3[d3];
+      for (const d3 of y2) {
+        const S2 = p2[d3], b3 = f3[d3];
+        b3 && typeof b3 == "object" && S2 && typeof S2 == "object" ? i2(b3, S2) : f3[d3] = S2;
+      }
+    }
+    s2 ? (i2(s2, t), s2._meta || (s2._meta = {}), Object.assign(s2._meta, r2), h.set(n2, s2)) : (r2 && Object.keys(r2).length > 0 && (t._meta || (t._meta = {}), Object.assign(t._meta, r2)), h.set(n2, t));
+    const c = o2().getInitialOptions(e);
+    (c?.validation?.zodSchemaV4 || c?.validation?.zodSchemaV3) && (c.validation?.zodSchemaV4 ? N(e, c.validation.zodSchemaV4, "zod4") : c.validation?.zodSchemaV3 && N(e, c.validation.zodSchemaV3, "zod3")), n2 === e ? h.delete(`[${e}`) : h.delete(e);
+  },
+  initializeShadowState: (e, t) => {
+    const a2 = h.get(e) || h.get(`[${e}`);
+    let n2 = {};
+    if (a2?._meta) {
+      const {
+        components: f3,
+        features: p2,
+        lastServerSync: y2,
+        stateSource: m4,
+        baseServerState: d3
+      } = a2._meta;
+      f3 && (n2.components = f3), p2 && (n2.features = p2), y2 && (n2.lastServerSync = y2), m4 && (n2.stateSource = m4), d3 && (n2.baseServerState = d3);
+    }
+    h.delete(e), h.delete(`[${e}`);
+    const s2 = o2().getInitialOptions(e), r2 = o2().getInitialOptions("__syncSchemas"), i2 = {
+      stateKey: e,
+      path: [],
+      schemas: {
+        sync: r2,
+        zodV4: s2?.validation?.zodSchemaV4,
+        zodV3: s2?.validation?.zodSchemaV3
+      }
+    }, c = _(e, t, i2);
+    c._meta || (c._meta = {}), Object.assign(c._meta, n2);
+    const l3 = Array.isArray(t) ? `[${e}` : e;
+    h.set(l3, c);
+  },
+  getShadowNode: (e, t) => {
+    let a2 = h.get(e) || h.get(`[${e}`);
+    if (a2) {
+      if (t.length === 0) return a2;
+      for (const n2 of t)
+        if (typeof a2 != "object" || a2 === null || (a2 = a2[n2], a2 === void 0)) return;
+      return a2;
+    }
+  },
+  getShadowMetadata: (e, t) => o2().getShadowNode(e, t)?._meta,
+  setShadowMetadata: (e, t, a2) => {
+    const n2 = h.has(`[${e}`) ? `[${e}` : e;
+    let s2 = h.get(n2);
+    if (!s2) {
+      s2 = { _meta: a2 }, h.set(n2, s2);
+      return;
+    }
+    let r2 = s2;
+    for (const i2 of t)
+      r2[i2] || (r2[i2] = {}), r2 = r2[i2];
+    r2._meta || (r2._meta = {}), Object.assign(r2._meta, a2);
+  },
+  getShadowValue: (e, t, a2) => {
+    const n2 = o2().getShadowNode(e, t);
+    if (!n2)
+      return;
+    const s2 = {}, r2 = [
+      [n2, s2, "final"]
+    ];
+    for (; r2.length > 0; ) {
+      const [i2, c, l3] = r2.pop();
+      if (i2._meta?.hasOwnProperty("value")) {
+        c[l3] = i2._meta.value;
+        continue;
+      }
+      if (i2._meta?.arrayKeys) {
+        const y2 = a2 || i2._meta.arrayKeys, m4 = [];
+        c[l3] = m4;
+        for (let d3 = y2.length - 1; d3 >= 0; d3--) {
+          const S2 = y2[d3];
+          i2[S2] && r2.push([i2[S2], m4, d3]);
+        }
+        continue;
+      }
+      const f3 = {};
+      c[l3] = f3;
+      const p2 = Object.keys(i2);
+      for (const y2 of p2)
+        y2 !== "_meta" && r2.push([i2[y2], f3, y2]);
+    }
+    return s2.final;
+  },
+  updateShadowAtPath: (e, t, a2) => {
+    const n2 = h.has(`[${e}`) ? `[${e}` : e;
+    let s2 = h.get(n2);
+    if (!s2) return;
+    let r2 = s2;
+    for (let l3 = 0; l3 < t.length - 1; l3++)
+      r2[t[l3]] || (r2[t[l3]] = {}), r2 = r2[t[l3]];
+    const i2 = t.length === 0 ? r2 : r2[t[t.length - 1]];
+    function c(l3, f3, p2) {
+      if (typeof f3 != "object" || f3 === null || f3 instanceof Date) {
+        const m4 = l3._meta || {};
+        for (const d3 in l3)
+          d3 !== "_meta" && delete l3[d3];
+        l3._meta = { ...m4, value: f3 };
+        return;
+      }
+      if (Array.isArray(f3)) {
+        l3._meta || (l3._meta = {}), l3._meta.arrayKeys || (l3._meta.arrayKeys = []);
+        const m4 = l3._meta.arrayKeys, d3 = f3, S2 = [];
+        for (let b3 = 0; b3 < d3.length; b3++) {
+          const g2 = d3[b3];
+          if (b3 < m4.length) {
+            const w3 = m4[b3];
+            c(l3[w3], g2, [
+              ...p2,
+              w3
+            ]), S2.push(w3);
+          } else {
+            const w3 = M(), K2 = o2().getInitialOptions(e), v = {
+              stateKey: e,
+              path: [...p2, "0"],
+              // Use '0' for array element schema lookup
+              schemas: {
+                zodV4: K2?.validation?.zodSchemaV4,
+                zodV3: K2?.validation?.zodSchemaV3
+              }
+            };
+            l3[w3] = _(
+              e,
+              g2,
+              v
+            ), S2.push(w3);
+          }
+        }
+        m4.length > d3.length && m4.slice(d3.length).forEach((g2) => {
+          delete l3[g2];
+        }), l3._meta.arrayKeys = S2;
+        return;
+      }
+      const y2 = new Set(Object.keys(f3));
+      l3._meta?.hasOwnProperty("value") && delete l3._meta.value;
+      for (const m4 of y2) {
+        const d3 = f3[m4];
+        if (l3[m4])
+          c(l3[m4], d3, [
+            ...p2,
+            m4
+          ]);
+        else {
+          const S2 = o2().getInitialOptions(e), b3 = {
+            stateKey: e,
+            path: [...p2, m4],
+            schemas: {
+              zodV4: S2?.validation?.zodSchemaV4,
+              zodV3: S2?.validation?.zodSchemaV3
+            }
+          };
+          l3[m4] = _(e, d3, b3);
+        }
+      }
+      for (const m4 in l3)
+        m4 === "_meta" || !Object.prototype.hasOwnProperty.call(l3, m4) || y2.has(m4) || delete l3[m4];
+    }
+    i2 ? c(i2, a2, t) : r2[t[t.length - 1]] = _(e, a2), o2().notifyPathSubscribers([e, ...t].join("."), {
+      type: "UPDATE",
+      newValue: a2
+    });
+  },
+  addItemsToArrayNode: (e, t, a2) => {
+    const n2 = h.has(`[${e}`) ? `[${e}` : e;
+    let s2 = h.get(n2);
+    if (!s2) {
+      console.error("Root not found for state key:", e);
+      return;
+    }
+    let r2 = s2;
+    for (const i2 of t)
+      r2[i2] || (r2[i2] = {}), r2 = r2[i2];
+    Object.assign(r2, a2);
+  },
+  insertShadowArrayElement: (e, t, a2, n2, s2) => {
+    const r2 = o2().getShadowNode(e, t);
+    if (!r2?._meta?.arrayKeys)
+      throw new Error(
+        `Array not found at path: ${[e, ...t].join(".")}`
+      );
+    const i2 = s2 || `${M()}`;
+    r2[i2] = _(e, a2);
+    const c = r2._meta.arrayKeys, l3 = n2 !== void 0 && n2 >= 0 && n2 <= c.length ? n2 : c.length;
+    l3 >= c.length ? c.push(i2) : c.splice(l3, 0, i2);
+    const f3 = [e, ...t].join(".");
+    return o2().notifyPathSubscribers(f3, {
+      type: "INSERT",
+      path: f3,
+      itemKey: `${f3}.${i2}`,
+      index: l3
+    }), i2;
+  },
+  insertManyShadowArrayElements: (e, t, a2, n2) => {
+    if (!a2 || a2.length === 0)
+      return;
+    const s2 = o2().getShadowNode(e, t);
+    if (!s2?._meta?.arrayKeys) {
+      console.error(
+        `Array not found at path: ${[e, ...t].join(".")}`
+      );
+      return;
+    }
+    const r2 = [];
+    a2.forEach((f3) => {
+      const p2 = `${M()}`;
+      r2.push(p2), s2[p2] = _(e, f3);
+    });
+    const i2 = s2._meta.arrayKeys, c = n2 !== void 0 && n2 >= 0 && n2 <= i2.length ? n2 : i2.length;
+    c >= i2.length ? i2.push(...r2) : i2.splice(c, 0, ...r2);
+    const l3 = [e, ...t].join(".");
+    o2().notifyPathSubscribers(l3, {
+      type: "INSERT_MANY",
+      path: l3,
+      count: a2.length,
+      index: c
+    });
+  },
+  removeShadowArrayElement: (e, t) => {
+    if (t.length === 0) return;
+    const a2 = t.slice(0, -1), n2 = t[t.length - 1];
+    if (!n2?.startsWith("id:")) return;
+    const s2 = o2().getShadowNode(e, a2);
+    if (!s2?._meta?.arrayKeys) return;
+    const r2 = s2._meta.arrayKeys, i2 = r2.indexOf(n2);
+    if (i2 === -1) return;
+    i2 === r2.length - 1 ? r2.pop() : i2 === 0 ? r2.shift() : r2.splice(i2, 1), delete s2[n2];
+    const c = [e, ...a2].join(".");
+    o2().notifyPathSubscribers(c, {
+      type: "REMOVE",
+      path: c,
+      itemKey: `${c}.${n2}`
+    });
+  },
+  registerComponent: (e, t, a2) => {
+    const n2 = o2().getShadowMetadata(e, []) || {}, s2 = new Map(n2.components);
+    s2.set(t, a2), o2().setShadowMetadata(e, [], { components: s2 });
+  },
+  unregisterComponent: (e, t) => {
+    const a2 = o2().getShadowMetadata(e, []);
+    if (!a2?.components) return;
+    const n2 = new Map(a2.components);
+    n2.delete(t) && o2().setShadowMetadata(e, [], { components: n2 });
+  },
+  addPathComponent: (e, t, a2) => {
+    const n2 = o2().getShadowMetadata(e, t) || {}, s2 = new Set(n2.pathComponents);
+    s2.add(a2), o2().setShadowMetadata(e, t, {
+      pathComponents: s2
+    });
+    const r2 = o2().getShadowMetadata(e, []);
+    if (r2?.components) {
+      const i2 = r2.components.get(a2);
+      if (i2) {
+        const c = [e, ...t].join("."), l3 = new Set(i2.paths);
+        l3.add(c);
+        const f3 = { ...i2, paths: l3 }, p2 = new Map(r2.components);
+        p2.set(a2, f3), o2().setShadowMetadata(e, [], { components: p2 });
+      }
+    }
+  },
+  markAsDirty: (e, t, a2 = { bubble: true }) => {
+    let n2 = o2().getShadowNode(e, []);
+    if (!n2) return;
+    let s2 = n2;
+    for (const i2 of t)
+      if (s2 = s2[i2], !s2) return;
+    if (s2._meta || (s2._meta = {}), s2._meta.isDirty = true, !a2.bubble) return;
+    let r2 = n2;
+    for (let i2 = 0; i2 < t.length; i2++) {
+      if (r2._meta?.isDirty)
+        return;
+      r2._meta || (r2._meta = {}), r2._meta.isDirty = true, r2 = r2[t[i2]];
+    }
+  },
+  // Keep these in Zustand as they need React reactivity
+  serverStateUpdates: /* @__PURE__ */ new Map(),
+  setServerStateUpdate: (e, t) => {
+    u3((a2) => ({
+      serverStateUpdates: new Map(a2.serverStateUpdates).set(
+        e,
+        t
+      )
+    })), o2().notifyPathSubscribers(e, {
+      type: "SERVER_STATE_UPDATE",
+      serverState: t
+    });
+  },
+  pathSubscribers: /* @__PURE__ */ new Map(),
+  subscribeToPath: (e, t) => {
+    const a2 = o2().pathSubscribers, n2 = a2.get(e) || /* @__PURE__ */ new Set();
+    return n2.add(t), a2.set(e, n2), () => {
+      const s2 = o2().pathSubscribers.get(e);
+      s2 && (s2.delete(t), s2.size === 0 && o2().pathSubscribers.delete(e));
+    };
+  },
+  notifyPathSubscribers: (e, t) => {
+    const n2 = o2().pathSubscribers.get(e);
+    n2 && n2.forEach((s2) => s2(t));
+  },
+  selectedIndicesMap: /* @__PURE__ */ new Map(),
+  getSelectedIndex: (e, t) => {
+    const a2 = o2().selectedIndicesMap.get(e);
+    if (!a2) return -1;
+    const n2 = o2().getShadowMetadata(
+      e.split(".")[0],
+      e.split(".").slice(1)
+    ), s2 = t || n2?.arrayKeys;
+    return s2 ? s2.indexOf(a2) : -1;
+  },
+  setSelectedIndex: (e, t) => {
+    u3((a2) => {
+      const n2 = new Map(a2.selectedIndicesMap);
+      return t === void 0 ? n2.delete(e) : (n2.has(e) && o2().notifyPathSubscribers(n2.get(e), {
+        type: "THIS_UNSELECTED"
+      }), n2.set(e, t), o2().notifyPathSubscribers(t, { type: "THIS_SELECTED" })), o2().notifyPathSubscribers(e, { type: "GET_SELECTED" }), {
+        ...a2,
+        selectedIndicesMap: n2
+      };
+    });
+  },
+  clearSelectedIndex: ({ arrayKey: e }) => {
+    u3((t) => {
+      const a2 = new Map(t.selectedIndicesMap), n2 = a2.get(e);
+      return n2 && o2().notifyPathSubscribers(n2, {
+        type: "CLEAR_SELECTION"
+      }), a2.delete(e), o2().notifyPathSubscribers(e, {
+        type: "CLEAR_SELECTION"
+      }), {
+        ...t,
+        selectedIndicesMap: a2
+      };
+    });
+  },
+  clearSelectedIndexesForState: (e) => {
+    u3((t) => {
+      const a2 = new Map(t.selectedIndicesMap);
+      let n2 = false;
+      for (const s2 of a2.keys())
+        (s2 === e || s2.startsWith(e + ".")) && (a2.delete(s2), n2 = true);
+      return n2 ? { selectedIndicesMap: a2 } : {};
+    });
+  },
+  initialStateOptions: {},
+  stateLog: /* @__PURE__ */ new Map(),
+  initialStateGlobal: {},
+  addStateLog: (e) => {
+    !e || e.length === 0 || u3((t) => {
+      const a2 = new Map(t.stateLog), n2 = /* @__PURE__ */ new Map();
+      for (const s2 of e) {
+        const r2 = n2.get(s2.stateKey) || [];
+        r2.push(s2), n2.set(s2.stateKey, r2);
+      }
+      for (const [s2, r2] of n2.entries()) {
+        const i2 = new Map(a2.get(s2));
+        for (const c of r2)
+          i2.set(JSON.stringify(c.path), { ...c });
+        a2.set(s2, i2);
+      }
+      return { stateLog: a2 };
+    });
+  },
+  getInitialOptions: (e) => o2().initialStateOptions[e],
+  setInitialStateOptions: (e, t) => {
+    u3((a2) => ({
+      initialStateOptions: { ...a2.initialStateOptions, [e]: t }
+    }));
+  },
+  updateInitialStateGlobal: (e, t) => {
+    u3((a2) => ({
+      initialStateGlobal: { ...a2.initialStateGlobal, [e]: t }
+    }));
+  },
+  syncInfoStore: /* @__PURE__ */ new Map(),
+  setSyncInfo: (e, t) => u3((a2) => {
+    const n2 = new Map(a2.syncInfoStore);
+    return n2.set(e, t), { syncInfoStore: n2 };
+  }),
+  getSyncInfo: (e) => o2().syncInfoStore.get(e) || null
+}));
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/plugins.js
+var f = () => l2.object({
+  __key: l2.literal("keyed"),
+  map: l2.any()
+});
+function m(e) {
+  return {
+    initialiseState: (t) => {
+      e.$update(t);
+    },
+    initialiseShadowState: (t) => {
+      e.$initializeAndMergeShadowState(t);
+    },
+    applyOperation: (t, a2) => e.$applyOperation(t, a2),
+    addZodErrors: (t) => e.$addZodValidation(t),
+    getState: () => e.$get(),
+    setOptions: (t) => {
+      e.$setOptions(t);
+    }
+  };
+}
+function S(e, t) {
+  return {
+    getPluginMetaData: () => $.getState().getPluginMetaDataMap(e, [])?.get(t),
+    setPluginMetaData: (a2) => $.getState().setPluginMetaData(e, [], t, a2),
+    removePluginMetaData: () => $.getState().removePluginMetaData(e, [], t),
+    getFieldMetaData: (a2) => $.getState().getPluginMetaDataMap(e, a2)?.get(t),
+    setFieldMetaData: (a2, i2) => $.getState().setPluginMetaData(e, a2, t, i2),
+    removeFieldMetaData: (a2) => $.getState().removePluginMetaData(e, a2, t)
+  };
+}
+function O2(e, t, a2) {
+  const i2 = S(
+    e,
+    t
+  );
+  return {
+    // Return the global methods for plugin metadata
+    ...i2,
+    // Override the field methods with new, path-scoped versions
+    getFieldMetaData: () => i2.getFieldMetaData(a2),
+    setFieldMetaData: (n2) => i2.setFieldMetaData(a2, n2),
+    removeFieldMetaData: () => i2.removeFieldMetaData(a2)
+  };
+}
+function b2(e) {
+  function t(a2) {
+    const i2 = (o2, r2, g2, c) => ({
+      name: a2,
+      useHook: o2,
+      transformState: r2,
+      onUpdate: g2,
+      onFormUpdate: c
+    });
+    function n2(o2, r2, g2, c) {
+      const D2 = i2(
+        o2,
+        r2,
+        g2,
+        c
+      ), s2 = {};
+      return r2 || (s2.transformState = (M3) => n2(o2, M3, g2, c)), g2 || (s2.onUpdate = (M3) => n2(o2, r2, M3, c)), c || (s2.onFormUpdate = (M3) => n2(
+        o2,
+        r2,
+        g2,
+        M3
+      )), Object.assign(D2, s2);
+    }
+    return Object.assign(
+      n2(),
+      {
+        useHook(o2) {
+          return n2(o2);
+        }
+      }
+    );
+  }
+  return { createPlugin: t };
+}
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/Components.js
+import O3, { memo as $2, useState as E2, useRef as P, useCallback as N2, useEffect as W, useLayoutEffect as Q, useMemo as X } from "react";
+
+// ../../node_modules/.pnpm/react-intersection-observer@9.16.0_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/react-intersection-observer/dist/index.mjs
+import * as React from "react";
+import * as React2 from "react";
+var observerMap = /* @__PURE__ */ new Map();
+var RootIds = /* @__PURE__ */ new WeakMap();
+var rootId = 0;
+var unsupportedValue = void 0;
+function getRootId(root) {
+  if (!root) return "0";
+  if (RootIds.has(root)) return RootIds.get(root);
+  rootId += 1;
+  RootIds.set(root, rootId.toString());
+  return RootIds.get(root);
+}
+function optionsToId(options) {
+  return Object.keys(options).sort().filter(
+    (key) => options[key] !== void 0
+  ).map((key) => {
+    return `${key}_${key === "root" ? getRootId(options.root) : options[key]}`;
+  }).toString();
+}
+function createObserver(options) {
+  const id = optionsToId(options);
+  let instance = observerMap.get(id);
+  if (!instance) {
+    const elements = /* @__PURE__ */ new Map();
+    let thresholds;
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        var _a;
+        const inView = entry.isIntersecting && thresholds.some((threshold) => entry.intersectionRatio >= threshold);
+        if (options.trackVisibility && typeof entry.isVisible === "undefined") {
+          entry.isVisible = inView;
+        }
+        (_a = elements.get(entry.target)) == null ? void 0 : _a.forEach((callback) => {
+          callback(inView, entry);
+        });
+      });
+    }, options);
+    thresholds = observer.thresholds || (Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);
+    instance = {
+      id,
+      observer,
+      elements
+    };
+    observerMap.set(id, instance);
+  }
+  return instance;
+}
+function observe(element, callback, options = {}, fallbackInView = unsupportedValue) {
+  if (typeof window.IntersectionObserver === "undefined" && fallbackInView !== void 0) {
+    const bounds = element.getBoundingClientRect();
+    callback(fallbackInView, {
+      isIntersecting: fallbackInView,
+      target: element,
+      intersectionRatio: typeof options.threshold === "number" ? options.threshold : 0,
+      time: 0,
+      boundingClientRect: bounds,
+      intersectionRect: bounds,
+      rootBounds: bounds
+    });
+    return () => {
+    };
+  }
+  const { id, observer, elements } = createObserver(options);
+  const callbacks = elements.get(element) || [];
+  if (!elements.has(element)) {
+    elements.set(element, callbacks);
+  }
+  callbacks.push(callback);
+  observer.observe(element);
+  return function unobserve() {
+    callbacks.splice(callbacks.indexOf(callback), 1);
+    if (callbacks.length === 0) {
+      elements.delete(element);
+      observer.unobserve(element);
+    }
+    if (elements.size === 0) {
+      observer.disconnect();
+      observerMap.delete(id);
+    }
+  };
+}
+function useInView({
+  threshold,
+  delay,
+  trackVisibility,
+  rootMargin,
+  root,
+  triggerOnce,
+  skip,
+  initialInView,
+  fallbackInView,
+  onChange
+} = {}) {
+  var _a;
+  const [ref, setRef] = React2.useState(null);
+  const callback = React2.useRef(onChange);
+  const [state, setState] = React2.useState({
+    inView: !!initialInView,
+    entry: void 0
+  });
+  callback.current = onChange;
+  React2.useEffect(
+    () => {
+      if (skip || !ref) return;
+      let unobserve;
+      unobserve = observe(
+        ref,
+        (inView, entry) => {
+          setState({
+            inView,
+            entry
+          });
+          if (callback.current) callback.current(inView, entry);
+          if (entry.isIntersecting && triggerOnce && unobserve) {
+            unobserve();
+            unobserve = void 0;
+          }
+        },
+        {
+          root,
+          rootMargin,
+          threshold,
+          // @ts-ignore
+          trackVisibility,
+          // @ts-ignore
+          delay
+        },
+        fallbackInView
+      );
+      return () => {
+        if (unobserve) {
+          unobserve();
+        }
+      };
+    },
+    // We break the rule here, because we aren't including the actual `threshold` variable
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      // If the threshold is an array, convert it to a string, so it won't change between renders.
+      Array.isArray(threshold) ? threshold.toString() : threshold,
+      ref,
+      root,
+      rootMargin,
+      triggerOnce,
+      skip,
+      trackVisibility,
+      fallbackInView,
+      delay
+    ]
+  );
+  const entryTarget = (_a = state.entry) == null ? void 0 : _a.target;
+  const previousEntryTarget = React2.useRef(void 0);
+  if (!ref && entryTarget && !triggerOnce && !skip && previousEntryTarget.current !== entryTarget) {
+    previousEntryTarget.current = entryTarget;
+    setState({
+      inView: !!initialInView,
+      entry: void 0
+    });
+  }
+  const result = [setRef, state.inView, state.entry];
+  result.ref = result[0];
+  result.inView = result[1];
+  result.entry = result[2];
+  return result;
+}
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/Components.js
+var {
+  getInitialOptions: V2,
+  getShadowMetadata: gt,
+  setShadowMetadata: ft,
+  getShadowValue: z3,
+  registerComponent: K,
+  unregisterComponent: tt,
+  notifyPathSubscribers: pt,
+  subscribeToPath: et
+} = $.getState();
+var { stateHandlers: St, notifyFormUpdate: L } = b.getState();
+var vt = $2(
+  ot,
+  (e, t) => e.itemPath.join(".") === t.itemPath.join(".") && e.stateKey === t.stateKey && e.itemComponentId === t.itemComponentId && e.localIndex === t.localIndex
+);
+function ot({
+  stateKey: e,
+  itemComponentId: t,
+  itemPath: o2,
+  localIndex: c,
+  arraySetter: p2,
+  rebuildStateShape: S2,
+  renderFn: i2
+}) {
+  const [, u3] = E2({}), { ref: m4, inView: M3 } = useInView(), D2 = P(null), r2 = [e, ...o2].join(".");
+  B(e, t, u3);
+  const l3 = N2(
+    (s2) => {
+      D2.current = s2, m4(s2);
+    },
+    [m4]
+  );
+  W(() => {
+    const s2 = et(r2, (T2) => {
+      u3({});
+    });
+    return () => s2();
+  }, [r2]);
+  const a2 = z3(e, o2);
+  if (a2 === void 0) return null;
+  const A3 = S2({
+    currentState: a2,
+    path: o2,
+    componentId: t
+  }), g2 = i2(A3, c, p2);
+  return O3.isValidElement(g2) ? O3.cloneElement(g2, {
+    ref: (s2) => {
+      l3(s2);
+      const { ref: T2 } = g2;
+      typeof T2 == "function" ? T2(s2) : T2 && "current" in T2 && (T2.current = s2);
+    }
+  }) : /* @__PURE__ */ I2("div", { ref: l3, children: g2 });
+}
+function B(e, t, o2) {
+  const c = `${e}////${t}`;
+  Q(() => (K(e, c, {
+    forceUpdate: () => o2({}),
+    paths: /* @__PURE__ */ new Set(),
+    reactiveType: ["component"]
+  }), () => {
+    tt(e, c);
+  }), [e, c]);
+}
+$2(function({
+  children: t,
+  stateKey: o2,
+  path: c,
+  pluginName: p2,
+  wrapperDepth: S2
+}) {
+  const [, i2] = E2({});
+  W(() => {
+    const A3 = [o2, ...c].join(".");
+    return $.getState().subscribeToPath(A3, () => {
+      i2({});
+    });
+  }, [o2, c]);
+  const u3 = b.getState().registeredPlugins.find((A3) => A3.name === p2), m4 = b.getState().stateHandlers.get(o2), M3 = $.getState().getShadowNode(o2, c)?._meta?.typeInfo, D2 = b.getState().pluginOptions.get(o2)?.get(p2), r2 = b.getState().getHookResult(o2, p2);
+  if (!u3?.formWrapper || !m4)
+    return /* @__PURE__ */ I2(U, { children: t });
+  const l3 = m(m4), a2 = O2(
+    o2,
+    u3.name,
+    c
+  );
+  return u3.formWrapper({
+    element: t,
+    path: c,
+    stateKey: o2,
+    pluginName: u3.name,
+    ...l3,
+    ...a2,
+    options: D2,
+    hookData: r2,
+    fieldType: M3?.type,
+    wrapperDepth: S2
+  });
+});
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/double-indexed-kv.js
+var DoubleIndexedKV = class {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map();
+    this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.keyToValue.set(key, value);
+    this.valueToKey.set(value, key);
+  }
+  getByKey(key) {
+    return this.keyToValue.get(key);
+  }
+  getByValue(value) {
+    return this.valueToKey.get(value);
+  }
+  clear() {
+    this.keyToValue.clear();
+    this.valueToKey.clear();
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/registry.js
+var Registry = class {
+  constructor(generateIdentifier) {
+    this.generateIdentifier = generateIdentifier;
+    this.kv = new DoubleIndexedKV();
+  }
+  register(value, identifier) {
+    if (this.kv.getByValue(value)) {
+      return;
+    }
+    if (!identifier) {
+      identifier = this.generateIdentifier(value);
+    }
+    this.kv.set(identifier, value);
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(value) {
+    return this.kv.getByValue(value);
+  }
+  getValue(identifier) {
+    return this.kv.getByKey(identifier);
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/class-registry.js
+var ClassRegistry = class extends Registry {
+  constructor() {
+    super((c) => c.name);
+    this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(value, options) {
+    if (typeof options === "object") {
+      if (options.allowProps) {
+        this.classToAllowedProps.set(value, options.allowProps);
+      }
+      super.register(value, options.identifier);
+    } else {
+      super.register(value, options);
+    }
+  }
+  getAllowedProps(value) {
+    return this.classToAllowedProps.get(value);
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/util.js
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  const values = [];
+  for (const key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  const values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  const valuesNotNever = values;
+  for (let i2 = 0; i2 < valuesNotNever.length; i2++) {
+    const value = valuesNotNever[i2];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (let i2 = 0; i2 < record.length; i2++) {
+    const value = record[i2];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/custom-transformer-registry.js
+var CustomTransformerRegistry = class {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(transformer) {
+    this.transfomers[transformer.name] = transformer;
+  }
+  findApplicable(v) {
+    return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+  }
+  findByName(name) {
+    return this.transfomers[name];
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/is.js
+var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+var isUndefined = (payload) => typeof payload === "undefined";
+var isNull = (payload) => payload === null;
+var isPlainObject = (payload) => {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  if (payload === Object.prototype)
+    return false;
+  if (Object.getPrototypeOf(payload) === null)
+    return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+var isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
+var isArray = (payload) => Array.isArray(payload);
+var isString = (payload) => typeof payload === "string";
+var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+var isBoolean = (payload) => typeof payload === "boolean";
+var isRegExp = (payload) => payload instanceof RegExp;
+var isMap = (payload) => payload instanceof Map;
+var isSet = (payload) => payload instanceof Set;
+var isSymbol = (payload) => getType(payload) === "Symbol";
+var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+var isError = (payload) => payload instanceof Error;
+var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+var isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+var isBigint = (payload) => typeof payload === "bigint";
+var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+var isURL = (payload) => payload instanceof URL;
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/pathstringifier.js
+var escapeKey = (key) => key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
+var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+var parsePath = (string, legacyPaths) => {
+  const result = [];
+  let segment = "";
+  for (let i2 = 0; i2 < string.length; i2++) {
+    let char = string.charAt(i2);
+    if (!legacyPaths && char === "\\") {
+      const escaped = string.charAt(i2 + 1);
+      if (escaped === "\\") {
+        segment += "\\";
+        i2++;
+        continue;
+      } else if (escaped !== ".") {
+        throw Error("invalid path");
+      }
+    }
+    const isEscapedDot = char === "\\" && string.charAt(i2 + 1) === ".";
+    if (isEscapedDot) {
+      segment += ".";
+      i2++;
+      continue;
+    }
+    const isEndOfSegment = char === ".";
+    if (isEndOfSegment) {
+      result.push(segment);
+      segment = "";
+      continue;
+    }
+    segment += char;
+  }
+  const lastSegment = segment;
+  result.push(lastSegment);
+  return result;
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/transformer.js
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var simpleRules = [
+  simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+  simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    console.error("Please add a BigInt polyfill.");
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+  simpleTransformation(isError, "Error", (v, superJson) => {
+    const baseError = {
+      name: v.name,
+      message: v.message
+    };
+    if ("cause" in v) {
+      baseError.cause = v.cause;
+    }
+    superJson.allowedErrorProps.forEach((prop) => {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, (v, superJson) => {
+    const e = new Error(v.message, { cause: v.cause });
+    e.name = v.name;
+    e.stack = v.stack;
+    superJson.allowedErrorProps.forEach((prop) => {
+      e[prop] = v[prop];
+    });
+    return e;
+  }),
+  simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+    const body = regex.slice(1, regex.lastIndexOf("/"));
+    const flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (v) => [...v.values()],
+    (v) => new Set(v)
+  ),
+  simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+  simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var symbolRule = compositeTransformation((s2, superJson) => {
+  if (isSymbol(s2)) {
+    const isRegistered = !!superJson.symbolRegistry.getIdentifier(s2);
+    return isRegistered;
+  }
+  return false;
+}, (s2, superJson) => {
+  const identifier = superJson.symbolRegistry.getIdentifier(s2);
+  return ["symbol", identifier];
+}, (v) => v.description, (_2, a2, superJson) => {
+  const value = superJson.symbolRegistry.getValue(a2[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+var constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((obj, ctor) => {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a2) => {
+  const ctor = constructorToName[a2[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass?.constructor) {
+    const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+  const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, (clazz, superJson) => {
+  const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return { ...clazz };
+  }
+  const result = {};
+  allowedProps.forEach((prop) => {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, (v, a2, superJson) => {
+  const clazz = superJson.classRegistry.getValue(a2[1]);
+  if (!clazz) {
+    throw new Error(`Trying to deserialize unknown class '${a2[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+var customRule = compositeTransformation((value, superJson) => {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, (value, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, (v, a2, superJson) => {
+  const transformer = superJson.customTransformerRegistry.findByName(a2[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+var transformValue = (value, superJson) => {
+  const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+var simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+var untransformValue = (json, type, superJson) => {
+  if (isArray(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    const transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/accessDeep.js
+var getNthKey = (value, n2) => {
+  if (n2 > value.size)
+    throw new Error("index out of bounds");
+  const keys = value.keys();
+  while (n2 > 0) {
+    keys.next();
+    n2--;
+  }
+  return keys.next().value;
+};
+function validatePath(path) {
+  if (includes(path, "__proto__")) {
+    throw new Error("__proto__ is not allowed as a property");
+  }
+  if (includes(path, "prototype")) {
+    throw new Error("prototype is not allowed as a property");
+  }
+  if (includes(path, "constructor")) {
+    throw new Error("constructor is not allowed as a property");
+  }
+}
+var getDeep = (object, path) => {
+  validatePath(path);
+  for (let i2 = 0; i2 < path.length; i2++) {
+    const key = path[i2];
+    if (isSet(object)) {
+      object = getNthKey(object, +key);
+    } else if (isMap(object)) {
+      const row = +key;
+      const type = +path[++i2] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(object, row);
+      switch (type) {
+        case "key":
+          object = keyOfRow;
+          break;
+        case "value":
+          object = object.get(keyOfRow);
+          break;
+      }
+    } else {
+      object = object[key];
+    }
+  }
+  return object;
+};
+var setDeep = (object, path, mapper) => {
+  validatePath(path);
+  if (path.length === 0) {
+    return mapper(object);
+  }
+  let parent = object;
+  for (let i2 = 0; i2 < path.length - 1; i2++) {
+    const key = path[i2];
+    if (isArray(parent)) {
+      const index = +key;
+      parent = parent[index];
+    } else if (isPlainObject(parent)) {
+      parent = parent[key];
+    } else if (isSet(parent)) {
+      const row = +key;
+      parent = getNthKey(parent, row);
+    } else if (isMap(parent)) {
+      const isEnd = i2 === path.length - 2;
+      if (isEnd) {
+        break;
+      }
+      const row = +key;
+      const type = +path[++i2] === 0 ? "key" : "value";
+      const keyOfRow = getNthKey(parent, row);
+      switch (type) {
+        case "key":
+          parent = keyOfRow;
+          break;
+        case "value":
+          parent = parent.get(keyOfRow);
+          break;
+      }
+    }
+  }
+  const lastKey = path[path.length - 1];
+  if (isArray(parent)) {
+    parent[+lastKey] = mapper(parent[+lastKey]);
+  } else if (isPlainObject(parent)) {
+    parent[lastKey] = mapper(parent[lastKey]);
+  }
+  if (isSet(parent)) {
+    const oldValue = getNthKey(parent, +lastKey);
+    const newValue = mapper(oldValue);
+    if (oldValue !== newValue) {
+      parent.delete(oldValue);
+      parent.add(newValue);
+    }
+  }
+  if (isMap(parent)) {
+    const row = +path[path.length - 2];
+    const keyToRow = getNthKey(parent, row);
+    const type = +lastKey === 0 ? "key" : "value";
+    switch (type) {
+      case "key": {
+        const newKey = mapper(keyToRow);
+        parent.set(newKey, parent.get(keyToRow));
+        if (newKey !== keyToRow) {
+          parent.delete(keyToRow);
+        }
+        break;
+      }
+      case "value": {
+        parent.set(keyToRow, mapper(parent.get(keyToRow)));
+        break;
+      }
+    }
+  }
+  return object;
+};
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/plainer.js
+var enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker2, version, origin = []) {
+  if (!tree) {
+    return;
+  }
+  const legacyPaths = enableLegacyPaths(version);
+  if (!isArray(tree)) {
+    forEach(tree, (subtree, key) => traverse(subtree, walker2, version, [
+      ...origin,
+      ...parsePath(key, legacyPaths)
+    ]));
+    return;
+  }
+  const [nodeValue, children] = tree;
+  if (children) {
+    forEach(children, (child, key) => {
+      traverse(child, walker2, version, [
+        ...origin,
+        ...parsePath(key, legacyPaths)
+      ]);
+    });
+  }
+  walker2(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, version, superJson) {
+  traverse(annotations, (type, path) => {
+    plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+  }, version);
+  return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations, version) {
+  const legacyPaths = enableLegacyPaths(version);
+  function apply(identicalPaths, path) {
+    const object = getDeep(plain, parsePath(path, legacyPaths));
+    identicalPaths.map((path2) => parsePath(path2, legacyPaths)).forEach((identicalObjectPath) => {
+      plain = setDeep(plain, identicalObjectPath, () => object);
+    });
+  }
+  if (isArray(annotations)) {
+    const [root, other] = annotations;
+    root.forEach((identicalPath) => {
+      plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
+    });
+    if (other) {
+      forEach(other, apply);
+    }
+  } else {
+    forEach(annotations, apply);
+  }
+  return plain;
+}
+var isDeep = (object, superJson) => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+  const existingSet = identities.get(object);
+  if (existingSet) {
+    existingSet.push(path);
+  } else {
+    identities.set(object, [path]);
+  }
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+  const result = {};
+  let rootEqualityPaths = void 0;
+  identitites.forEach((paths) => {
+    if (paths.length <= 1) {
+      return;
+    }
+    if (!dedupe) {
+      paths = paths.map((path) => path.map(String)).sort((a2, b3) => a2.length - b3.length);
+    }
+    const [representativePath, ...identicalPaths] = paths;
+    if (representativePath.length === 0) {
+      rootEqualityPaths = identicalPaths.map(stringifyPath);
+    } else {
+      result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+    }
+  });
+  if (rootEqualityPaths) {
+    if (isEmptyObject(result)) {
+      return [rootEqualityPaths];
+    } else {
+      return [rootEqualityPaths, result];
+    }
+  } else {
+    return isEmptyObject(result) ? void 0 : result;
+  }
+}
+var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+  const primitive = isPrimitive(object);
+  if (!primitive) {
+    addIdentity(object, path, identities);
+    const seen = seenObjects.get(object);
+    if (seen) {
+      return dedupe ? {
+        transformedValue: null
+      } : seen;
+    }
+  }
+  if (!isDeep(object, superJson)) {
+    const transformed2 = transformValue(object, superJson);
+    const result2 = transformed2 ? {
+      transformedValue: transformed2.value,
+      annotations: [transformed2.type]
+    } : {
+      transformedValue: object
+    };
+    if (!primitive) {
+      seenObjects.set(object, result2);
+    }
+    return result2;
+  }
+  if (includes(objectsInThisPath, object)) {
+    return {
+      transformedValue: null
+    };
+  }
+  const transformationResult = transformValue(object, superJson);
+  const transformed = transformationResult?.value ?? object;
+  const transformedValue = isArray(transformed) ? [] : {};
+  const innerAnnotations = {};
+  forEach(transformed, (value, index) => {
+    if (index === "__proto__" || index === "constructor" || index === "prototype") {
+      throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+    }
+    const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (isArray(recursiveResult.annotations)) {
+      innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
+    } else if (isPlainObject(recursiveResult.annotations)) {
+      forEach(recursiveResult.annotations, (tree, key) => {
+        innerAnnotations[escapeKey(index) + "." + key] = tree;
+      });
+    }
+  });
+  const result = isEmptyObject(innerAnnotations) ? {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type] : void 0
+  } : {
+    transformedValue,
+    annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+  };
+  if (!primitive) {
+    seenObjects.set(object, result);
+  }
+  return result;
+};
+
+// ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/getType.js
+function getType2(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+
+// ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isArray.js
+function isArray2(payload) {
+  return getType2(payload) === "Array";
+}
+
+// ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isPlainObject.js
+function isPlainObject2(payload) {
+  if (getType2(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+
+// ../../node_modules/.pnpm/copy-anything@4.0.5/node_modules/copy-anything/dist/index.js
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (includeNonenumerable && propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function copy(target, options = {}) {
+  if (isArray2(target)) {
+    return target.map((item) => copy(item, options));
+  }
+  if (!isPlainObject2(target)) {
+    return target;
+  }
+  const props = Object.getOwnPropertyNames(target);
+  const symbols = Object.getOwnPropertySymbols(target);
+  return [...props, ...symbols].reduce((carry, key) => {
+    if (key === "__proto__")
+      return carry;
+    if (isArray2(options.props) && !options.props.includes(key)) {
+      return carry;
+    }
+    const val = target[key];
+    const newVal = copy(val, options);
+    assignProp(carry, key, newVal, target, options.nonenumerable);
+    return carry;
+  }, {});
+}
+
+// ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/index.js
+var SuperJSON = class {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe = false } = {}) {
+    this.classRegistry = new ClassRegistry();
+    this.symbolRegistry = new Registry((s2) => s2.description ?? "");
+    this.customTransformerRegistry = new CustomTransformerRegistry();
+    this.allowedErrorProps = [];
+    this.dedupe = dedupe;
+  }
+  serialize(object) {
+    const identities = /* @__PURE__ */ new Map();
+    const output = walker(object, identities, this, this.dedupe);
+    const res = {
+      json: output.transformedValue
+    };
+    if (output.annotations) {
+      res.meta = {
+        ...res.meta,
+        values: output.annotations
+      };
+    }
+    const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+    if (equalityAnnotations) {
+      res.meta = {
+        ...res.meta,
+        referentialEqualities: equalityAnnotations
+      };
+    }
+    if (res.meta)
+      res.meta.v = 1;
+    return res;
+  }
+  deserialize(payload, options) {
+    const { json, meta } = payload;
+    let result = options?.inPlace ? json : copy(json);
+    if (meta?.values) {
+      result = applyValueAnnotations(result, meta.values, meta.v ?? 0, this);
+    }
+    if (meta?.referentialEqualities) {
+      result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, meta.v ?? 0);
+    }
+    return result;
+  }
+  stringify(object) {
+    return JSON.stringify(this.serialize(object));
+  }
+  parse(string) {
+    return this.deserialize(JSON.parse(string), { inPlace: true });
+  }
+  registerClass(v, options) {
+    this.classRegistry.register(v, options);
+  }
+  registerSymbol(v, identifier) {
+    this.symbolRegistry.register(v, identifier);
+  }
+  registerCustom(transformer, name) {
+    this.customTransformerRegistry.register({
+      name,
+      ...transformer
+    });
+  }
+  allowErrorProps(...props) {
+    this.allowedErrorProps.push(...props);
+  }
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+var serialize = SuperJSON.serialize;
+var deserialize = SuperJSON.deserialize;
+var stringify = SuperJSON.stringify;
+var parse = SuperJSON.parse;
+var registerClass = SuperJSON.registerClass;
+var registerCustom = SuperJSON.registerCustom;
+var registerSymbol = SuperJSON.registerSymbol;
+var allowErrorProps = SuperJSON.allowErrorProps;
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/CogsStateClient.js
+import { jsx as n } from "react/jsx-runtime";
+import { createContext as s, useContext as i } from "react";
+var r = {
+  sessionId: void 0
+};
+var o = s(r);
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/CogsState.js
+var {
+  getInitialOptions: C,
+  updateInitialStateGlobal: he,
+  getShadowMetadata: V3,
+  setShadowMetadata: B2,
+  getShadowValue: I3,
+  initializeShadowState: Z,
+  initializeAndMergeShadowState: _e,
+  updateShadowAtPath: Oe,
+  insertShadowArrayElement: je,
+  insertManyShadowArrayElements: ve,
+  removeShadowArrayElement: Ne,
+  setInitialStateOptions: de,
+  setServerStateUpdate: ge,
+  markAsDirty: ae,
+  addPathComponent: Ue,
+  clearSelectedIndexesForState: Fe,
+  addStateLog: ze,
+  clearSelectedIndex: Re,
+  getSyncInfo: Le,
+  notifyPathSubscribers: We,
+  getPluginMetaDataMap: Be,
+  setPluginMetaData: Ge,
+  removePluginMetaData: qe
+} = $.getState();
+var { notifyUpdate: xe } = b.getState();
+
+// ../../node_modules/.pnpm/cogsbox-state@0.5.476_@trpc+next@11.10.0_@tanstack+react-query@5.90.21_react@19.2.4__@t_2ea54f427ca0966c855f98d25ac3767f/node_modules/cogsbox-state/dist/PluginRunner.js
+import { jsxs as F, Fragment as C2, jsx as P2 } from "react/jsx-runtime";
+import T, { useState as R, useMemo as M2, useEffect as m2, useRef as x, useReducer as N3 } from "react";
+var { setHookResult: O5, removeHookResult: I4 } = b.getState();
+var $4 = T.memo(
+  ({
+    stateKey: r2,
+    plugin: e,
+    options: t,
+    stateHandler: d3
+  }) => {
+    const [b3, a2] = R(true), c = M2(
+      () => S(r2, e.name),
+      [r2, e.name]
+    ), o2 = M2(
+      () => m(d3),
+      [d3]
+    ), i2 = M2(
+      () => ({
+        stateKey: r2,
+        pluginName: e.name,
+        isInitialMount: b3,
+        options: t,
+        ...o2,
+        ...c
+      }),
+      [
+        r2,
+        e.name,
+        b3,
+        t,
+        o2,
+        c
+      ]
+    ), s2 = e.useHook ? e.useHook(i2) : void 0;
+    m2(() => {
+      a2(false);
+    }, []), m2(() => (e.useHook ? O5(r2, e.name, s2) : I4(r2, e.name), () => I4(r2, e.name)), [r2, e.name, !!e.useHook, s2]);
+    const u3 = x(), [h3, D2] = R(true);
+    m2(() => {
+      e.transformState && (d(t, u3.current) || (e.transformState({
+        stateKey: r2,
+        pluginName: e.name,
+        options: t,
+        hookData: s2,
+        isInitialTransform: h3,
+        ...o2,
+        ...c
+      }), u3.current = t, D2(false)));
+    }, [
+      r2,
+      e,
+      t,
+      s2,
+      h3,
+      o2,
+      c
+    ]);
+    const k = x(s2);
+    return k.current = s2, m2(() => {
+      if (!e.onUpdate) return;
+      const S2 = (n2) => {
+        if (n2.stateKey === r2) {
+          const U2 = O2(
+            r2,
+            e.name,
+            n2.path
+          );
+          e.onUpdate({
+            stateKey: r2,
+            pluginName: e.name,
+            update: n2,
+            path: n2.path,
+            options: t,
+            hookData: k.current,
+            ...o2,
+            ...U2
+            // <-- Use the new scoped context
+          });
+        }
+      };
+      return b.getState().subscribeToUpdates(S2);
+    }, [r2, e, t, o2]), m2(() => {
+      if (!e.onFormUpdate) return;
+      const S2 = (n2) => {
+        if (n2.stateKey === r2) {
+          const U2 = O2(
+            r2,
+            e.name,
+            n2.path
+          );
+          e.onFormUpdate({
+            stateKey: r2,
+            pluginName: e.name,
+            path: n2.path,
+            event: n2,
+            options: t,
+            hookData: k.current,
+            ...o2,
+            ...U2
+            // <-- Use the new scoped context
+          });
+        }
+      };
+      return b.getState().subscribeToFormUpdates(S2);
+    }, [r2, e, t, o2]), null;
+  }
+);
+
+// src/syncPlugin.ts
+import z4 from "zod";
+function createSyncPlugin(syncSchema) {
+  const { createPlugin } = b2({
+    options: z4.object({
+      stateRoom: z4.string(),
+      apiParams: f()
+    }),
+    pluginMetaData: z4.object({
+      sessionId: z4.string(),
+      stateVersion: z4.string()
+    }),
+    fieldMetaData: z4.any()
+  });
+  const syncPlugin = createPlugin("syncPlugin").useHook(
+    ({
+      stateKey,
+      options,
+      setPluginMetaData,
+      getPluginMetaData,
+      setFieldMetaData,
+      setOptions,
+      initialiseShadowState,
+      applyOperation,
+      getState
+    }) => {
+      const schemaForKey = syncSchema.clientSchemas[stateKey];
+      setOptions({
+        validation: {
+          zodSchemaV4: schemaForKey
+        }
+      });
+      const {
+        onStateRequest,
+        reportClientActivity,
+        onClientActivity,
+        onInitialState,
+        requestState,
+        onPatch,
+        sessionId,
+        sendUpdate
+      } = useSync({
+        stateKey,
+        stateRoom: options.stateRoom,
+        apiParams: options.apiParams
+      });
+      setPluginMetaData({ sessionId });
+      onInitialState((data, version) => {
+        setPluginMetaData({ stateVersion: version });
+        initialiseShadowState({ ...data });
+      });
+      onPatch((patch, patchSessionId, version) => {
+        const { stateVersion: lastKnownVersion } = getPluginMetaData() || {};
+        const lastCounter = Number((lastKnownVersion || ":0").split(":")[1]);
+        const newCounter = Number((version || ":0").split(":")[1]);
+        console.log(
+          "onPatch",
+          patch,
+          patchSessionId,
+          version,
+          lastKnownVersion
+        );
+        if (newCounter === lastCounter + 1) {
+          setPluginMetaData({ stateVersion: version });
+          applyOperation(patch, { dontUpdate: true });
+        } else {
+          requestState();
+        }
+      });
+      onStateRequest(() => getState());
+      onClientActivity(({ clientId, event, metaData }) => {
+        if ("path" in event && event.path) {
+          setFieldMetaData(event.path, {
+            ...metaData,
+            clientActivity: event
+          });
+        }
+      });
+      return {
+        sessionId,
+        updateState: sendUpdate,
+        reportClientActivity
+      };
+    }
+  ).onUpdate(({ update, hookData }) => {
+    hookData?.updateState?.(update);
+  }).onFormUpdate(({ hookData, event }) => {
+    hookData?.reportClientActivity?.(event);
+  });
+  return syncPlugin;
+}
+export {
+  SyncProvider,
+  createNotificationHook,
+  createSyncPlugin,
+  useNotificationStore,
+  useNotifications,
+  useSync
+};