@noya-app/noya-multiplayer-react 0.1.45 → 0.1.46

package/dist/index.mjs

@@ -89,18 +89,12 @@ var UserPointersOverlay = memoGeneric(function UserPointers({
 
 // src/hooks.ts
 import {
-  AIManager,
-  AssetManager,
-  ConnectedUsersManager,
-  EphemeralUserDataManager,
-  MultiplayerStateManager,
-  RPCManager,
+  NoyaManager,
   StateManager,
-  stubSync,
-  WorkflowManager
+  stubSync
 } from "@noya-app/state-manager";
 import {
-  createElement,
+  createElement as createElement2,
   useCallback,
   useEffect as useEffect3,
   useMemo as useMemo2,
@@ -110,25 +104,9 @@ import {
 } from "react";
 import { createRoot as createRoot2 } from "react-dom/client";
 
-// ../noya-state-manager/src/SecretManager.ts
-import { Observable } from "@noya-app/observable";
-var SecretManager = class {
-  constructor(rpcManager) {
-    this.rpcManager = rpcManager;
-  }
-  secrets$ = new Observable([]);
-  isInitialized$ = new Observable(false);
-  async createSecret(name, value) {
-    return await this.rpcManager.request({ type: "createSecret", name, value });
-  }
-  async deleteSecret(name) {
-    return await this.rpcManager.request({ type: "deleteSecret", name });
-  }
-};
-
 // src/components/ErrorOverlay.tsx
-import React2 from "react";
-function ErrorOverlay({
+import * as React2 from "react";
+var ErrorOverlay = React2.memo(function ErrorOverlay2({
   error
 }) {
   return /* @__PURE__ */ React2.createElement(
@@ -198,12 +176,7 @@ function ErrorOverlay({
       "Reload"
     )
   );
-}
-
-// src/globals.ts
-import { Observable as Observable2 } from "@noya-app/observable";
-var shouldTrackEvents$ = new Observable2(false);
-var shouldTrackTasks$ = new Observable2(false);
+});
 
 // src/inspector/useStateInspector.tsx
 import React5, { useLayoutEffect as useLayoutEffect2 } from "react";
@@ -428,21 +401,23 @@ function InspectorRow({
 }
 var HISTORY_ELEMENT_PREFIX = "noya-multiplayer-history-";
 var StateInspector = memoGeneric2(function StateInspector2({
-  state,
-  connectionEvents,
-  tasks,
-  unstyled,
+  noyaManager,
   colorScheme = "light",
-  multiplayerStateManager,
-  assetManager,
-  secretManager,
-  connectedUsersManager,
-  ephemeralUserDataManager,
   anchor = "right",
-  forceInit,
+  unstyled = false,
   ...props
 }) {
+  const {
+    multiplayerStateManager,
+    assetManager,
+    connectedUsersManager,
+    secretManager,
+    ephemeralUserDataManager,
+    connectionEventManager,
+    taskManager
+  } = noyaManager;
   const [didMount, setDidMount] = React4.useState(false);
+  const tasks = useObservable(taskManager.tasks$);
   useLayoutEffect(() => {
     setDidMount(true);
   }, []);
@@ -484,23 +459,24 @@ var StateInspector = memoGeneric2(function StateInspector2({
     "noya-multiplayer-react-show-secrets",
     false
   );
-  useEffect2(() => {
-    shouldTrackEvents$.set(showEvents);
-  }, [showEvents]);
-  useEffect2(() => {
-    shouldTrackTasks$.set(showTasks);
-  }, [showTasks]);
+  const connectionEvents = useObservable(connectionEventManager.events$);
   useEffect2(() => {
     if (eventsContainerRef.current) {
       eventsContainerRef.current.scrollTop = eventsContainerRef.current.scrollHeight;
     }
   }, [connectionEvents]);
+  const multipeerStateInitialized = useObservable(
+    multiplayerStateManager.isInitialized$
+  );
   const ephemeral = useObservable(ephemeralUserDataManager.data$);
   const historySnapshot = useManagedHistory(multiplayerStateManager.sm);
   const assets = useObservable(assetManager.assets$);
+  const assetsInitialized = useObservable(assetManager.isInitialized$);
   const secrets = useObservable(secretManager.secrets$);
+  const secretsInitialized = useObservable(secretManager.isInitialized$);
   const connectedUsers = useObservable(connectedUsersManager.connectedUsers$);
   const userId = useObservable(connectedUsersManager.currentUserId$);
+  const state = useObservable(multiplayerStateManager.optimisticState$);
   useEffect2(() => {
     if (historyContainerRef.current) {
       historyContainerRef.current.scrollTop = historyContainerRef.current.scrollHeight;
@@ -640,7 +616,12 @@ var StateInspector = memoGeneric2(function StateInspector2({
     /* @__PURE__ */ React4.createElement(
       DisclosureSection,
       {
-        title: "Data",
+        title: /* @__PURE__ */ React4.createElement(TitleLabel, null, "Data", /* @__PURE__ */ React4.createElement(
+          ColoredDot,
+          {
+            type: multipeerStateInitialized ? "success" : "error"
+          }
+        )),
         colorScheme,
         setOpen: setShowData,
         open: showData,
@@ -657,7 +638,7 @@ var StateInspector = memoGeneric2(function StateInspector2({
             {
               theme,
               onClick: () => {
-                forceInit();
+                noyaManager.forceInit();
               }
             },
             "Reset"
@@ -821,9 +802,22 @@ var StateInspector = memoGeneric2(function StateInspector2({
       {
         open: showAssets,
         setOpen: setShowAssets,
-        title: "Assets",
+        title: /* @__PURE__ */ React4.createElement(TitleLabel, null, "Assets", /* @__PURE__ */ React4.createElement(ColoredDot, { type: assetsInitialized ? "success" : "error" })),
         colorScheme,
-        right: /* @__PURE__ */ React4.createElement("span", { style: { display: "flex", gap: "4px" } }, /* @__PURE__ */ React4.createElement(
+        right: /* @__PURE__ */ React4.createElement("span", { style: { display: "flex", gap: "10px" } }, /* @__PURE__ */ React4.createElement(
+          SmallButton,
+          {
+            theme,
+            onClick: () => {
+              console.info(
+                "[StateInspector] Reloading assets",
+                noyaManager.id
+              );
+              assetManager.fetch();
+            }
+          },
+          "Reload"
+        ), /* @__PURE__ */ React4.createElement(
           SmallButton,
           {
             theme,
@@ -886,7 +880,7 @@ var StateInspector = memoGeneric2(function StateInspector2({
     /* @__PURE__ */ React4.createElement(
       DisclosureSection,
       {
-        title: "Secrets",
+        title: /* @__PURE__ */ React4.createElement(TitleLabel, null, "Secrets", /* @__PURE__ */ React4.createElement(ColoredDot, { type: secretsInitialized ? "success" : "error" })),
         colorScheme,
         open: showSecrets,
         setOpen: setShowSecrets,
@@ -960,8 +954,7 @@ var StateInspector = memoGeneric2(function StateInspector2({
                 depth,
                 name,
                 data,
-                isNonenumerable,
-                expanded
+                isNonenumerable
               }) => {
                 const direction = event.type === "send" ? "up" : "down";
                 return depth === 0 ? /* @__PURE__ */ React4.createElement(ObjectRootLabel, { direction, data }) : /* @__PURE__ */ React4.createElement(
@@ -1097,6 +1090,24 @@ function SmallButton({
     children
   );
 }
+function ColoredDot({ type }) {
+  return /* @__PURE__ */ React4.createElement(
+    "span",
+    {
+      style: {
+        display: "inline-block",
+        width: 6,
+        height: 6,
+        background: type === "success" ? "rgba(0,200,0,0.8)" : "rgba(200,0,0,0.8)",
+        borderRadius: "50%",
+        verticalAlign: "middle"
+      }
+    }
+  );
+}
+function TitleLabel({ children }) {
+  return /* @__PURE__ */ React4.createElement("span", { style: { display: "flex", alignItems: "center", gap: "4px" } }, children);
+}
 
 // src/inspector/useStateInspector.tsx
 function createShadowRootElement() {
@@ -1108,18 +1119,10 @@ function createShadowRootElement() {
   return { host, container };
 }
 function useStateInspector({
-  state,
-  connectionEvents,
-  tasks,
+  noyaManager,
   disabled = false,
   colorScheme,
-  anchor,
-  multiplayerStateManager,
-  assetManager,
-  secretManager,
-  connectedUsersManager,
-  ephemeralUserDataManager,
-  forceInit
+  anchor
 }) {
   const [root, setRoot] = React5.useState(null);
   useLayoutEffect2(() => {
@@ -1138,34 +1141,13 @@ function useStateInspector({
       /* @__PURE__ */ React5.createElement(
         StateInspector,
         {
-          state,
-          connectionEvents,
-          tasks,
           colorScheme,
           anchor,
-          forceInit,
-          multiplayerStateManager,
-          assetManager,
-          secretManager,
-          ephemeralUserDataManager,
-          connectedUsersManager
+          noyaManager
         }
       )
     );
-  }, [
-    anchor,
-    colorScheme,
-    connectionEvents,
-    root,
-    state,
-    multiplayerStateManager,
-    tasks,
-    forceInit,
-    ephemeralUserDataManager,
-    assetManager,
-    secretManager,
-    connectedUsersManager
-  ]);
+  }, [noyaManager, anchor, colorScheme, root]);
 }
 
 // src/hooks.ts
@@ -1227,170 +1209,81 @@ function useManagedHistory(stateManager) {
     stateManager.getHistorySnapshot
   );
 }
-function useSyncMultiplayerStateManager(multiplayerStateManager) {
-  return useSyncExternalStore2(
-    multiplayerStateManager.addListener,
-    multiplayerStateManager.getOptimisticState,
-    multiplayerStateManager.getOptimisticState
-  );
-}
 var defaultStubSync = stubSync();
 function useMultiplayerState(initialState, options) {
-  const { sync = defaultStubSync, ...rest } = options ?? {};
-  const [rpcManager] = useState2(
-    () => new RPCManager()
-  );
-  const [multiplayerStateManager] = useState2(
-    () => new MultiplayerStateManager(initialState, rest)
+  const {
+    sync = defaultStubSync,
+    inspector,
+    ...rest
+  } = options ?? {};
+  const [noyaManager] = useState2(
+    () => new NoyaManager(initialState, rest)
   );
-  const [assetManager] = useState2(() => new AssetManager());
-  const [aiManager] = useState2(() => new AIManager(rpcManager));
-  const [workflowManager] = useState2(() => new WorkflowManager(rpcManager));
-  const [secretManager] = useState2(() => new SecretManager(rpcManager));
-  const [connectedUsersManager] = useState2(() => new ConnectedUsersManager());
-  const syncRef = useRef(sync);
-  const [connectionEvents, setConnectionEvents] = useState2();
-  const [ephemeralUserDataManager] = useState2(
-    () => new EphemeralUserDataManager()
+  const state = useObservable(
+    noyaManager.multiplayerStateManager.optimisticState$
   );
-  const [tasks, setTasks] = useState2([]);
-  const assets = useObservable(assetManager.assets$);
+  const assets = useObservable(noyaManager.assetManager.assets$);
   const extras = useMemo2(() => {
     return {
-      tasks,
-      connectionEvents,
-      connectedUsersManager,
-      ephemeralUserDataManager,
-      multiplayerStateManager,
-      assets,
-      assetManager,
-      aiManager,
-      rpcManager,
-      workflowManager,
-      secretManager,
-      createAsset: assetManager.create,
-      deleteAsset: assetManager.delete
-      // connectionStatus,
-      // isConnected: connectionStatus === "connected",
+      noyaManager,
+      taskManager: noyaManager.taskManager,
+      connectionEventManager: noyaManager.connectionEventManager,
+      connectedUsersManager: noyaManager.connectedUsersManager,
+      ephemeralUserDataManager: noyaManager.ephemeralUserDataManager,
+      multiplayerStateManager: noyaManager.multiplayerStateManager,
+      assetManager: noyaManager.assetManager,
+      aiManager: noyaManager.aiManager,
+      rpcManager: noyaManager.rpcManager,
+      workflowManager: noyaManager.workflowManager,
+      secretManager: noyaManager.secretManager,
+      menuItemsManager: noyaManager.menuManager,
+      createAsset: noyaManager.assetManager.create,
+      deleteAsset: noyaManager.assetManager.delete,
+      assets
     };
-  }, [
-    tasks,
-    connectionEvents,
-    connectedUsersManager,
-    ephemeralUserDataManager,
-    multiplayerStateManager,
-    assets,
-    assetManager,
-    aiManager,
-    rpcManager,
-    workflowManager,
-    secretManager
-  ]);
-  const globalTrackEvents = useObservable(shouldTrackEvents$);
-  const globalTrackTasks = useObservable(shouldTrackTasks$);
-  const shouldTrackEvents = options?.trackConnectionEvents ?? globalTrackEvents;
-  const shouldTrackTasks = options?.trackTasks ?? globalTrackTasks;
-  const trackEventsCallbackRef = useRef();
-  const trackTasksCallbackRef = useRef();
-  useEffect3(() => {
-    trackEventsCallbackRef.current = shouldTrackEvents ? (e) => setConnectionEvents((events) => {
-      const updated = events ? [...events, e] : [e];
-      return updated.length > 50 ? updated.slice(-50) : updated;
-    }) : void 0;
-  }, [shouldTrackEvents]);
-  useEffect3(() => {
-    trackTasksCallbackRef.current = shouldTrackTasks ? (tasks2) => {
-      setTasks((old) => {
-        const newIds = new Set(tasks2.map((t) => t.id));
-        const unchanged = old.filter((t) => !newIds.has(t.id));
-        return [...unchanged, ...tasks2];
-      });
-    } : void 0;
-  }, [shouldTrackTasks]);
+  }, [noyaManager, assets]);
+  const syncRef = useRef(sync);
   useEffect3(() => {
     if (syncRef.current) {
-      return syncRef.current({
-        ms: multiplayerStateManager,
-        assetManager,
-        workflowManager,
-        secretManager,
-        rpcManager,
-        aiManager,
-        ephemeralUserDataManager,
-        connectedUsersManager,
-        onConnectionEvent: (e) => trackEventsCallbackRef.current?.(e),
-        onChangeTasks: (tasks2) => trackTasksCallbackRef.current?.(tasks2)
-      });
+      return syncRef.current({ noyaManager });
     }
-  }, [
-    assetManager,
-    ephemeralUserDataManager,
-    multiplayerStateManager,
-    workflowManager,
-    secretManager,
-    rpcManager,
-    aiManager,
-    connectedUsersManager
-  ]);
-  const state = useSyncMultiplayerStateManager(multiplayerStateManager);
-  const forceInit = useCallback(() => {
-    const state2 = initialState instanceof Function ? initialState() : initialState;
-    const schema = options?.schema;
-    multiplayerStateManager.sm.clearHistory();
-    multiplayerStateManager.sendInit({ force: true, state: state2, schema });
-  }, [initialState, multiplayerStateManager, options?.schema]);
-  const [unrecoverableError, setUnrecoverableError] = useState2();
-  useEffect3(() => {
-    return multiplayerStateManager.errorEmitter.addListener((error) => {
-      switch (error.reason) {
-        case "invalidDataType":
-        case "schemaMismatch":
-        case "outdatedSchema":
-        case "dataMigrationFailure":
-        case "schemaMigration":
-          setUnrecoverableError(error);
-          break;
-      }
-    });
-  }, [multiplayerStateManager]);
+  }, [noyaManager]);
+  useErrorOverlay(noyaManager);
+  useStateInspector({
+    noyaManager,
+    disabled: !inspector,
+    ...typeof inspector === "object" && inspector
+  });
+  return [state, noyaManager.multiplayerStateManager.setState, extras];
+}
+function useErrorOverlay(noyaManager) {
+  const unrecoverableError = useObservable(noyaManager.unrecoverableError);
   useEffect3(() => {
     if (!unrecoverableError) return;
     const el = document.createElement("div");
     el.id = "noya-multiplayer-react-error-overlay";
     document.body.appendChild(el);
     const root = createRoot2(el);
-    root.render(createElement(ErrorOverlay, { error: unrecoverableError }));
+    root.render(createElement2(ErrorOverlay, { error: unrecoverableError }));
     return () => {
       root.unmount();
       el.remove();
     };
   });
-  useStateInspector({
-    ephemeralUserDataManager,
-    multiplayerStateManager,
-    assetManager,
-    secretManager,
-    state,
-    connectionEvents,
-    connectedUsersManager,
-    tasks,
-    forceInit,
-    disabled: !options?.inspector,
-    ...typeof options?.inspector === "object" && options.inspector
-  });
-  return [state, multiplayerStateManager.setState, extras];
 }
 
 // src/noyaApp.ts
 import {
   createOrCastValue,
   findAllDefs,
+  isEmbeddedApp,
   localStorageSync,
+  parentFrameSync,
   stubSync as stubSync2,
   TypeGuard,
   webSocketSync
 } from "@noya-app/state-manager";
-import { useEffect as useEffect4, useMemo as useMemo3, useState as useState3 } from "react";
+import { useMemo as useMemo3, useState as useState3 } from "react";
 function createDefaultAppData(initialState) {
   return {
     theme: "light",
@@ -1429,43 +1322,6 @@ function getAppData(initialState, schema, options) {
   appData.initialState = enforceSchema(appData.initialState, schema);
   return appData;
 }
-function useBroadcastConnectedUsers(connectedUsersManager) {
-  useEffect4(() => {
-    if (!isEmbeddedApp()) return;
-    const unsubscribe = connectedUsersManager.connectedUsers$.subscribe(
-      (users) => {
-        const message = {
-          type: "multiplayer.setUsers",
-          payload: { users }
-        };
-        parent?.postMessage(message, "*");
-      }
-    );
-    return unsubscribe;
-  }, [connectedUsersManager]);
-}
-function useBroadcastMenuItems(menuItems, handleSelectMenuItem) {
-  useEffect4(() => {
-    if (!isEmbeddedApp()) return;
-    const message = {
-      type: "application.setMenuItems",
-      payload: { menuItems }
-    };
-    parent?.postMessage(message, "*");
-    const listener = (event) => {
-      if (event.data.type === "application.selectMenuItem") {
-        handleSelectMenuItem(event.data.payload.value);
-      }
-    };
-    window.addEventListener("message", listener);
-    return () => {
-      window.removeEventListener("message", listener);
-    };
-  }, [handleSelectMenuItem, menuItems]);
-}
-function isEmbeddedApp() {
-  return window.self !== window.top;
-}
 function useNoyaState(...args) {
   const [initialState, options] = typeof args[0] === "object" && args[0] !== null && "schema" in args[0] && TypeGuard.IsSchema(args[0].schema) ? [null, args[0]] : [args[0], args[1]];
   const [
@@ -1482,15 +1338,14 @@ function useNoyaState(...args) {
     });
   });
   const sync = useMemo3(() => {
-    return multiplayerUrl ? webSocketSync(multiplayerUrl) : options?.offlineStorageKey ? localStorageSync({ key: options.offlineStorageKey }) : stubSync2();
-  }, [multiplayerUrl, options?.offlineStorageKey]);
+    return isEmbeddedApp() ? parentFrameSync({ debug: options?.debug }) : multiplayerUrl ? webSocketSync(multiplayerUrl) : options?.offlineStorageKey ? localStorageSync({ key: options.offlineStorageKey }) : stubSync2();
+  }, [multiplayerUrl, options?.offlineStorageKey, options?.debug]);
   const result = useMultiplayerState(noyaAppInitialState, {
     ...options,
     inspector: options?.inspector ?? inspector,
     sync: options?.sync ?? sync
   });
   const [, , extras] = result;
-  useBroadcastConnectedUsers(extras.connectedUsersManager);
   const mergedExtras = useMemo3(() => {
     return { ...extras, theme, viewType };
   }, [extras, theme, viewType]);
@@ -1499,12 +1354,13 @@ function useNoyaState(...args) {
 
 // src/NoyaStateContext.tsx
 import {
-  Observable as Observable3
+  Observable
 } from "@noya-app/observable";
 import React6, {
   createContext,
   useCallback as useCallback2,
   useContext,
+  useEffect as useEffect4,
   useMemo as useMemo4
 } from "react";
 var AnyNoyaStateContext = createContext(void 0);
@@ -1559,9 +1415,13 @@ function useSecret(name) {
   );
 }
 function useIsInitialized() {
-  const { ms, secretManager, assetManager } = useAnyNoyaStateContext();
+  const {
+    multiplayerStateManager: ms,
+    secretManager,
+    assetManager
+  } = useAnyNoyaStateContext();
   const isInitializedObservable = useMemo4(
-    () => Observable3.combine(
+    () => Observable.combine(
       [
         ms.isInitialized$,
         secretManager.isInitialized$,
@@ -1607,49 +1467,27 @@ function createNoyaContext({
     initialState,
     ...options
   }) {
-    const [
-      ,
-      ,
-      {
-        multiplayerStateManager,
-        assetManager,
-        workflowManager,
-        secretManager,
-        aiManager,
-        ephemeralUserDataManager,
-        connectedUsersManager
-      }
-    ] = useNoyaState(initialState, {
+    const [, , { noyaManager }] = useNoyaState(initialState, {
       ...options,
       schema,
       mergeHistoryEntries
     });
-    const value = useMemo4(
-      () => ({
-        ms: multiplayerStateManager,
-        assetManager,
-        workflowManager,
-        secretManager,
-        aiManager
-      }),
-      [
-        multiplayerStateManager,
-        assetManager,
-        workflowManager,
-        secretManager,
-        aiManager
-      ]
-    );
-    return /* @__PURE__ */ React6.createElement(AnyNoyaStateContext.Provider, { value }, /* @__PURE__ */ React6.createElement(ConnectedUsersContext.Provider, { value: connectedUsersManager }, /* @__PURE__ */ React6.createElement(
-      EphemeralUserDataManagerContext.Provider,
+    return /* @__PURE__ */ React6.createElement(AnyNoyaStateContext.Provider, { value: noyaManager }, /* @__PURE__ */ React6.createElement(
+      ConnectedUsersContext.Provider,
       {
-        value: ephemeralUserDataManager
+        value: noyaManager.connectedUsersManager
       },
-      options.fallback !== void 0 ? /* @__PURE__ */ React6.createElement(FallbackUntilInitialized, { fallback: options.fallback }, children) : children
-    )));
+      /* @__PURE__ */ React6.createElement(
+        EphemeralUserDataManagerContext.Provider,
+        {
+          value: noyaManager.ephemeralUserDataManager
+        },
+        options.fallback !== void 0 ? /* @__PURE__ */ React6.createElement(FallbackUntilInitialized, { fallback: options.fallback }, children) : children
+      )
+    ));
   }
   function useValue(path, options) {
-    const { ms } = useAnyNoyaStateContext();
+    const { multiplayerStateManager: ms } = useAnyNoyaStateContext();
     let actualPath = typeof path === "function" || !path ? "" : path;
     const mappedObservable = useMemo4(() => {
       if (typeof path === "function") {
@@ -1661,12 +1499,11 @@ function createNoyaContext({
     return value;
   }
   function useSetValue(path) {
-    const { ms } = useAnyNoyaStateContext();
+    const { multiplayerStateManager: ms } = useAnyNoyaStateContext();
     const setValue = useCallback2(
       (...args) => {
-        const [metadata, value] = args.length === 2 ? args : [void 0, args[0]];
-        const setStateAtPath = ms.setStateAtPath;
-        setStateAtPath(metadata, path ?? "", value);
+        const [metadata, value] = args.length === 2 ? args : [{}, args[0]];
+        ms.setStateAtPath(metadata, path ?? "", value);
       },
       [ms, path]
     );
@@ -1679,7 +1516,7 @@ function createNoyaContext({
     return [value, setValue];
   }
   function useStateManager() {
-    const { ms } = useAnyNoyaStateContext();
+    const { multiplayerStateManager: ms } = useAnyNoyaStateContext();
     return ms;
   }
   function useEphemeralUserDataManager() {
@@ -1691,6 +1528,27 @@ function createNoyaContext({
     }
     return ephemeralUserData;
   }
+  function useNoyaManager() {
+    return useAnyNoyaStateContext();
+  }
+  function useLeftMenuItems() {
+    const { menuManager } = useNoyaManager();
+    return useObservable(menuManager.leftMenuItems$);
+  }
+  function useRightMenuItems() {
+    const { menuManager } = useNoyaManager();
+    return useObservable(menuManager.rightMenuItems$);
+  }
+  function useHandleMenuItem(callback) {
+    const { menuManager } = useNoyaManager();
+    useEffect4(() => {
+      return menuManager.addListener(callback);
+    }, [menuManager, callback]);
+  }
+  function useOnSelectMenuItemCallback() {
+    const { menuManager } = useNoyaManager();
+    return useCallback2((type) => menuManager.emit(type), [menuManager]);
+  }
   return {
     Context: NoyaStateContext,
     Provider: NoyaStateProvider,
@@ -1698,31 +1556,130 @@ function createNoyaContext({
     useSetValue,
     useValueState,
     useStateManager,
-    useEphemeralUserDataManager
-    // useAssets,
-    // useAssetManager,
-    // useAsset,
+    useEphemeralUserDataManager,
+    useLeftMenuItems,
+    useRightMenuItems,
+    useHandleMenuItem,
+    useOnSelectMenuItemCallback,
+    useNoyaManager
   };
 }
+
+// src/WebSocketConnection.ts
+import {
+  ReconnectingWebSocket,
+  UserActivityDetector
+} from "@noya-app/state-manager";
+var WebSocketConnection = class {
+  constructor(url, options = {}) {
+    this.url = url;
+    this.options = options;
+    this.ws = new ReconnectingWebSocket({
+      debug: options.debug,
+      onopen: this.handleOpen,
+      onmessage: this.handleMessage,
+      onclose: this.handleClose,
+      activityDetector: new UserActivityDetector()
+    });
+  }
+  ws;
+  pingCount = 0;
+  pendingPingId;
+  intervalId;
+  async connect() {
+    this.ws.connect(this.url.toString());
+    this.intervalId = setInterval(() => {
+      if (this.ws.state !== "OPEN") return;
+      if (this.pendingPingId) {
+        this.ws.close();
+        return;
+      }
+      const pingId = (this.pingCount++).toString();
+      const message = {
+        type: "ping",
+        id: pingId
+      };
+      this.pendingPingId = message.id;
+      this.options.onConnectionEvent?.({
+        type: "send",
+        message
+      });
+      this.ws.send(JSON.stringify(message));
+    }, 1e4);
+  }
+  handleOpen = () => {
+    this.pendingPingId = void 0;
+    if (this.options.debug) {
+      console.info("ws connected");
+    }
+    this.options.onConnectionEvent?.({
+      type: "stateChange",
+      state: "OPEN"
+    });
+  };
+  handleMessage = (event) => {
+    if (this.options.debug) {
+      console.info("ws receiving message ", event.data);
+    }
+    const parsed = JSON.parse(event.data);
+    this.options.onConnectionEvent?.({
+      type: "receive",
+      message: parsed
+    });
+    if (parsed.type === "pong" && parsed.id === this.pendingPingId) {
+      this.pendingPingId = void 0;
+    }
+  };
+  handleClose = () => {
+    this.pendingPingId = void 0;
+    if (this.options.debug) {
+      console.info("ws disconnected");
+    }
+    this.options.onConnectionEvent?.({
+      type: "stateChange",
+      state: "CLOSED"
+    });
+  };
+  send(message) {
+    if (this.options.debug) {
+      console.info("ws sending message", message);
+    }
+    this.options.onConnectionEvent?.({
+      type: "send",
+      message
+    });
+    this.ws.send(JSON.stringify(message));
+  }
+  close() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+    this.ws.shutdown();
+  }
+  addListener(listener) {
+    return this.ws.addListener(listener);
+  }
+  removeListener(listener) {
+    return this.ws.removeListener(listener);
+  }
+};
 export {
   AnyEphemeralUserDataManagerContext,
   ConnectedUsersContext,
   FallbackUntilInitialized,
   StateInspector,
   UserPointersOverlay,
+  WebSocketConnection,
   createDefaultAppData,
   createNoyaContext,
   enforceSchema,
   getAppData,
-  isEmbeddedApp,
   parseAppDataParameter,
   useAIManager,
   useAnyEphemeralUserData,
   useAsset,
   useAssetManager,
   useAssets,
-  useBroadcastConnectedUsers,
-  useBroadcastMenuItems,
   useConnectedUsersManager,
   useCurrentUserId,
   useIsInitialized,
@@ -1734,7 +1691,6 @@ export {
   useSecret,
   useSecretManager,
   useSecrets,
-  useSyncMultiplayerStateManager,
   useSyncStateManager,
   useWorkflowManager
 };