@noya-app/noya-multiplayer-react 0.1.65 → 0.1.67

package/dist/index.mjs

@@ -3982,6 +3982,7 @@ var activityEventSchema = Type.Object({
 // ../noya-schemas/src/asset.ts
 var assetSchema = Type.Object({
   id: Type.String(),
+  stableId: Type.String(),
   url: Type.String(),
   createdAt: Type.String(),
   size: Type.Number(),
@@ -4487,6 +4488,26 @@ var flatResourceSchema = Type.Object({
   fileId: Nullable(Type.String()),
   resourceId: Nullable(Type.String())
 });
+function getChangedResourceProperties({
+  oldResource,
+  newResource,
+  oldPath,
+  newPath
+}) {
+  const changed = {};
+  if (newPath !== void 0 && (oldPath ?? oldResource.path) !== newPath) {
+    changed.path = newPath;
+  }
+  const oldAssetId = oldResource.type === "asset" ? oldResource.assetId : void 0;
+  const newAssetId = newResource.type === "asset" ? newResource.assetId : void 0;
+  if (oldAssetId !== newAssetId) {
+    changed.assetId = newAssetId;
+  }
+  if (newResource.type === "asset" && newResource.asset !== void 0) {
+    changed.asset = newResource.asset;
+  }
+  return changed;
+}
 function diffResourceMaps(resourceMap, newResourceMap, idProperty) {
   const oldIdToPathMap = new Map(
     Object.entries(resourceMap).map(([path2, entity]) => [
@@ -4513,7 +4534,7 @@ function diffResourceMaps(resourceMap, newResourceMap, idProperty) {
   const removedResources = Object.values(resourceMap).filter(
     (entity) => !newIds.has(entity[idProperty])
   );
-  const modifiedResources = [...sameIds].flatMap((id) => {
+  const sameIdModifiedResources = [...sameIds].flatMap((id) => {
     const oldResource = Object.values(resourceMap).find(
       (resource) => resource[idProperty] === id
     );
@@ -4523,17 +4544,54 @@ function diffResourceMaps(resourceMap, newResourceMap, idProperty) {
     if (!oldResource || !newResource) return [];
     const oldPath = oldIdToPathMap.get(id);
     const newPath = newIdToPathMap.get(id);
-    const oldAssetId = oldResource.type === "asset" ? oldResource.assetId : void 0;
-    const newAssetId = newResource.type === "asset" ? newResource.assetId : void 0;
-    const changedProperties = {
-      ...oldPath !== newPath ? { path: newPath } : {},
-      ...oldAssetId !== newAssetId ? { assetId: newAssetId } : {},
-      ...newResource.type === "asset" && newResource.asset !== void 0 ? { asset: newResource.asset } : {}
-    };
+    const changedProperties = getChangedResourceProperties({
+      oldResource,
+      newResource,
+      oldPath,
+      newPath
+    });
     if (Object.keys(changedProperties).length === 0) return [];
     return [{ id, stableId: newResource.stableId, ...changedProperties }];
   });
-  return { addedResources, removedResources, modifiedResources };
+  const removedResourcesByPath = new Map(
+    removedResources.map((resource) => [resource.path, resource])
+  );
+  const swappedPaths = /* @__PURE__ */ new Set();
+  const swappedModifiedResources = [];
+  for (const addedResource of addedResources) {
+    const existingResource = removedResourcesByPath.get(addedResource.path);
+    if (!existingResource) continue;
+    if (existingResource.type !== addedResource.type) continue;
+    if (existingResource[idProperty] === addedResource[idProperty]) continue;
+    swappedPaths.add(addedResource.path);
+    const changedProperties = getChangedResourceProperties({
+      oldResource: existingResource,
+      newResource: addedResource,
+      oldPath: existingResource.path,
+      newPath: addedResource.path
+    });
+    if (Object.keys(changedProperties).length === 0) continue;
+    const id = existingResource[idProperty];
+    swappedModifiedResources.push({
+      id,
+      stableId: existingResource.stableId,
+      ...changedProperties
+    });
+  }
+  const filteredAddedResources = addedResources.filter(
+    (resource) => !swappedPaths.has(resource.path)
+  );
+  const filteredRemovedResources = removedResources.filter(
+    (resource) => !swappedPaths.has(resource.path)
+  );
+  return {
+    addedResources: filteredAddedResources,
+    removedResources: filteredRemovedResources,
+    modifiedResources: [
+      ...sameIdModifiedResources,
+      ...swappedModifiedResources
+    ]
+  };
 }
 
 // ../noya-schemas/src/resourceTree.ts
@@ -4554,7 +4612,7 @@ import {
   Observable
 } from "@noya-app/observable";
 import { useJsonMemo, useStableCallback } from "@noya-app/react-utils";
-import React16, {
+import React17, {
   createContext,
   useCallback as useCallback3,
   useContext,
@@ -4568,6 +4626,7 @@ import {
   createOrCastValue,
   isEmbeddedApp,
   localStorageSync,
+  NoyaManager as NoyaManager3,
   parentFrameSync,
   stubSync as stubSync2,
   TypeGuard,
@@ -4714,6 +4773,26 @@ var FILE_TYPE_TO_EXTENSION = {
 };
 var FILE_EXTENSION_TO_TYPE = invert(FILE_TYPE_TO_EXTENSION);
 
+// ../noya-utils/src/memoize.ts
+function memoize(f) {
+  const intermediateCache = /* @__PURE__ */ new Map();
+  const cache = /* @__PURE__ */ new Map();
+  let intermediateCacheIndex = 0;
+  return (...values) => {
+    let key = "";
+    for (const value of values) {
+      if (!intermediateCache.has(value)) {
+        intermediateCache.set(value, `${intermediateCacheIndex++}`);
+      }
+      key += intermediateCache.get(value) + ":";
+    }
+    if (!cache.has(key)) {
+      cache.set(key, f(...values));
+    }
+    return cache.get(key);
+  };
+}
+
 // ../noya-utils/src/memoizeDeep.ts
 var TOKEN_OBJECT = Symbol("object");
 var TOKEN_ARRAY = Symbol("array");
@@ -5940,19 +6019,17 @@ async function importAll(buffer, noyaManager, {
   }
   if (assets.length) {
     await Promise.all(
-      noyaManager.assetManager.assets$.get().map((asset) => noyaManager.assetManager.delete(asset.id))
+      noyaManager.assetManager.assets$.get().map((asset) => noyaManager.assetManager.delete(asset.stableId))
     );
-    const idPairs = await Promise.all(
+    await Promise.all(
       assets.map(async (asset) => {
-        const newAsset = await noyaManager.assetManager.create({
+        await noyaManager.assetManager.create({
           data: assetMap[asset.id],
-          contentType: asset.contentType
+          contentType: asset.contentType,
+          stableId: asset.stableId
         });
-        return [asset.id, newAsset.id];
       })
     );
-    const replacementMap = Object.fromEntries(idPairs);
-    state = replaceDeep(state, replacementMap);
   }
   noyaManager.initialState = state;
   noyaManager.forceInit();
@@ -6468,7 +6545,14 @@ var StateInspector = memoGeneric(function StateInspector2({
           "Upload"
         ))
       },
-      /* @__PURE__ */ React14.createElement(StateInspectorDisclosureRowInner, null, assets.map((asset) => /* @__PURE__ */ React14.createElement(StateInspectorRow, { key: asset.id, colorScheme }, /* @__PURE__ */ React14.createElement(ObjectInspector4, { name: asset.id, data: asset, theme }), /* @__PURE__ */ React14.createElement(
+      /* @__PURE__ */ React14.createElement(StateInspectorDisclosureRowInner, null, assets.map((asset) => /* @__PURE__ */ React14.createElement(StateInspectorRow, { key: asset.id, colorScheme }, /* @__PURE__ */ React14.createElement(
+        ObjectInspector4,
+        {
+          name: asset.id,
+          data: truncateAsset(asset),
+          theme
+        }
+      ), /* @__PURE__ */ React14.createElement(
         StateInspectorButton,
         {
           theme,
@@ -6493,10 +6577,8 @@ var StateInspector = memoGeneric(function StateInspector2({
                 "Are you sure you want to delete all resources?"
               );
               if (!ok) return;
-              await Promise.all(
-                resources.map(
-                  (resource) => resourceManager.deleteResource({ id: resource.id })
-                )
+              await resourceManager.deleteResource(
+                resources.map((resource) => ({ id: resource.id }))
               );
             }
           },
@@ -6709,6 +6791,12 @@ var StateInspector = memoGeneric(function StateInspector2({
     )
   );
 });
+var truncateAsset = memoize((asset) => {
+  if (asset.url.startsWith("data:") || asset.url.startsWith("blob:")) {
+    return { ...asset, url: ellipsis(asset.url, 40) };
+  }
+  return asset;
+});
 
 // src/inspector/useStateInspector.tsx
 function createShadowRootElement() {
@@ -6719,6 +6807,17 @@ function createShadowRootElement() {
   shadowRoot.appendChild(container);
   return { host, container };
 }
+function createStateInspectorRoot() {
+  const { host, container } = createShadowRootElement();
+  const root = createRoot(container);
+  document.body.appendChild(host);
+  return {
+    root,
+    unmount: () => {
+      document.body.removeChild(host);
+    }
+  };
+}
 function useStateInspector({
   noyaManager,
   disabled = false,
@@ -6728,13 +6827,9 @@ function useStateInspector({
   const [root, setRoot] = React15.useState(null);
   useIsomorphicLayoutEffect(() => {
     if (disabled) return;
-    const { host, container } = createShadowRootElement();
-    const root2 = createRoot(container);
-    document.body.appendChild(host);
+    const { root: root2, unmount } = createStateInspectorRoot();
     setRoot(root2);
-    return () => {
-      document.body.removeChild(host);
-    };
+    return unmount;
   }, [disabled]);
   useIsomorphicLayoutEffect(() => {
     if (!root) return;
@@ -6752,22 +6847,18 @@ function useStateInspector({
 }
 
 // src/hooks.ts
-function useSyncStateManager(stateManager, path2) {
-  const getSnapshot = useCallback2(
-    () => typeof path2 === "string" ? stateManager.getState(path2) : stateManager.getState(),
-    [stateManager, path2]
+function useManagedState(createInitialState, options) {
+  const [stateManager] = useState2(
+    () => new StateManager(createInitialState(), options)
   );
-  return useSyncExternalStore2(
+  const getSnapshot = useCallback2(() => {
+    return stateManager.getState();
+  }, [stateManager]);
+  const state = useSyncExternalStore2(
     stateManager.addListener,
     getSnapshot,
     getSnapshot
   );
-}
-function useManagedState(createInitialState, options) {
-  const [stateManager] = useState2(
-    () => new StateManager(createInitialState(), options)
-  );
-  const state = useSyncStateManager(stateManager);
   const setState = useCallback2(
     (...args) => {
       const [metadata, action] = args.length === 1 ? [void 0, args[0]] : args;
@@ -6810,15 +6901,7 @@ function useManagedHistory(stateManager) {
     stateManager.getHistorySnapshot
   );
 }
-function useMultiplayerState(initialState, options) {
-  const {
-    sync = stubSync(),
-    inspector,
-    ...rest
-  } = options ?? {};
-  const [noyaManager] = useState2(
-    () => new NoyaManager2(initialState, rest)
-  );
+function useBindNoyaManager(noyaManager, options) {
   const state = useObservable(
     noyaManager.multiplayerStateManager.optimisticState$
   );
@@ -6842,7 +6925,7 @@ function useMultiplayerState(initialState, options) {
       assets
     };
   }, [noyaManager, assets]);
-  const syncRef = useRef2(sync);
+  const syncRef = useRef2(options?.sync);
   useEffect3(() => {
     if (syncRef.current) {
       return syncRef.current({ noyaManager });
@@ -6851,11 +6934,22 @@ function useMultiplayerState(initialState, options) {
   useErrorOverlay(noyaManager);
   useStateInspector({
     noyaManager,
-    disabled: !inspector,
-    ...typeof inspector === "object" && inspector
+    disabled: !options?.inspector,
+    ...typeof options?.inspector === "object" && options?.inspector
   });
   return [state, noyaManager.multiplayerStateManager.setState, extras];
 }
+function useMultiplayerState(initialState, options) {
+  const {
+    sync = stubSync(),
+    inspector,
+    ...rest
+  } = options ?? {};
+  const [noyaManager] = useState2(
+    () => new NoyaManager2(initialState, rest)
+  );
+  return useBindNoyaManager(noyaManager, { sync, inspector });
+}
 function useErrorOverlay(noyaManager) {
   const unrecoverableError = useObservable(noyaManager.unrecoverableError);
   useEffect3(() => {
@@ -6911,7 +7005,11 @@ function getAppData(initialState, schema, options) {
   appData.initialState = enforceSchema(appData.initialState, schema);
   return appData;
 }
-function useNoyaState(...args) {
+function getSyncAdapter(params) {
+  const { multiplayerUrl, offlineStorageKey, debug } = params ?? {};
+  return isEmbeddedApp() ? parentFrameSync({ debug }) : multiplayerUrl ? webSocketSync({ url: multiplayerUrl, debug }) : offlineStorageKey ? localStorageSync({ key: offlineStorageKey }) : stubSync2();
+}
+function useNoyaStateInternal(...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 [
     {
@@ -6927,13 +7025,16 @@ function useNoyaState(...args) {
     });
   });
   const sync = useMemo3(() => {
-    return isEmbeddedApp() ? parentFrameSync({ debug: options?.debug }) : multiplayerUrl ? webSocketSync({
-      url: multiplayerUrl,
+    return getSyncAdapter({
+      multiplayerUrl,
+      offlineStorageKey: options?.offlineStorageKey,
       debug: options?.debug
-    }) : options?.offlineStorageKey ? localStorageSync({ key: options.offlineStorageKey }) : stubSync2();
+    });
   }, [multiplayerUrl, options?.offlineStorageKey, options?.debug]);
-  const result = useMultiplayerState(noyaAppInitialState, {
-    ...options,
+  const [noyaManager] = useState3(
+    () => new NoyaManager3(noyaAppInitialState, options)
+  );
+  const result = useBindNoyaManager(noyaManager, {
     inspector: options?.inspector ?? inspector,
     sync: options?.sync ?? sync
   });
@@ -6944,11 +7045,166 @@ function useNoyaState(...args) {
   return [result[0], result[1], mergedExtras];
 }
 
+// src/singleton.tsx
+import {
+  NoyaManager as NoyaManager4
+} from "@noya-app/state-manager";
+import React16 from "react";
+var noyaManagerSingleton;
+var noyaSingletonBindings;
+function initializeNoyaSingleton(options) {
+  if (noyaManagerSingleton) {
+    throw new Error(
+      "Noya has already been initialized. Call `useNoyaState` instead."
+    );
+  }
+  const {
+    initialState,
+    sync,
+    inspector,
+    theme,
+    viewType,
+    offlineStorageKey,
+    multiplayerUrl,
+    ...managerOptions
+  } = options ?? {};
+  const appData = getAppData(
+    initialState ?? null,
+    managerOptions?.schema,
+    { overrideExistingState: managerOptions?.overrideExistingState }
+  );
+  noyaManagerSingleton = new NoyaManager4(
+    appData.initialState,
+    managerOptions
+  );
+  const resolvedSync = sync ?? getSyncAdapter({
+    multiplayerUrl: multiplayerUrl ?? appData.multiplayerUrl,
+    offlineStorageKey,
+    debug: managerOptions?.debug
+  });
+  try {
+    resolvedSync({ noyaManager: noyaManagerSingleton });
+  } catch (error) {
+    console.warn("Failed to activate sync", error);
+  }
+  const resolvedInspector = inspector ?? appData.inspector;
+  const resolvedTheme = theme ?? appData.theme ?? "light";
+  const resolvedViewType = viewType ?? appData.viewType ?? "editable";
+  if (resolvedInspector) {
+    const { root } = createStateInspectorRoot();
+    root.render(
+      /* @__PURE__ */ React16.createElement(
+        StateInspector,
+        {
+          noyaManager: noyaManagerSingleton,
+          colorScheme: resolvedInspector === true ? resolvedTheme : resolvedInspector.colorScheme,
+          anchor: resolvedInspector === true ? "bottom right" : resolvedInspector.anchor
+        }
+      )
+    );
+  }
+  noyaSingletonBindings = {
+    sync: resolvedSync,
+    inspector: resolvedInspector,
+    theme: resolvedTheme,
+    viewType: resolvedViewType
+  };
+}
+function getNoyaManagerSingleton() {
+  if (!noyaManagerSingleton || !noyaSingletonBindings) {
+    throw new Error(
+      "Noya has not been initialized. Call initializeNoya once before using Noya hooks."
+    );
+  }
+  return noyaManagerSingleton;
+}
+function getNoyaSingletonBindings() {
+  return noyaSingletonBindings;
+}
+function deleteNoyaSingleton() {
+  noyaManagerSingleton = void 0;
+  noyaSingletonBindings = void 0;
+}
+
 // src/NoyaStateContext.tsx
+function resourceToCreateParameters(resource) {
+  switch (resource.type) {
+    case "directory":
+      return {
+        path: resource.path,
+        type: "directory"
+      };
+    case "asset":
+      return {
+        path: resource.path,
+        type: "asset",
+        assetId: resource.assetId,
+        asset: resource.asset
+      };
+    case "file":
+      return {
+        path: resource.path,
+        type: "file",
+        fileId: resource.fileId
+      };
+    case "resource":
+      return {
+        path: resource.path,
+        type: "resource",
+        fileId: resource.fileId,
+        resourceId: resource.resourceId
+      };
+    default:
+      throw new Error(`Unknown resource type: ${resource.type}`);
+  }
+}
+function buildCreateResourcePayload({
+  addedResources,
+  modifiedResources,
+  newResourceMap,
+  resourceMap
+}) {
+  const toCreateParameters = resourceToCreateParameters;
+  const resourcesById = new Map(
+    Object.values(resourceMap).map((resource) => [resource.id, resource])
+  );
+  const payload = [
+    ...addedResources.map(toCreateParameters)
+  ];
+  const handledModifiedResourceIds = [];
+  const assetReplacements = modifiedResources.filter(
+    (resource) => resource.assetId !== void 0 || resource.asset !== void 0
+  ).map((resource) => {
+    const previousResource = resourcesById.get(resource.id);
+    const path2 = resource.path ?? previousResource?.path;
+    if (!path2) return void 0;
+    const updated = newResourceMap[path2];
+    if (!updated || updated.type !== "asset") return void 0;
+    handledModifiedResourceIds.push(resource.id);
+    return toCreateParameters(updated);
+  }).filter(
+    (resource) => resource !== void 0
+  );
+  const deduped = new Map(
+    [...payload, ...assetReplacements].map((item) => [item.path, item])
+  );
+  return {
+    payload: Array.from(deduped.values()),
+    consumedModifiedResourceIds: [...new Set(handledModifiedResourceIds)]
+  };
+}
 var AnyNoyaStateContext = createContext(void 0);
 function useAnyNoyaStateContext() {
   const value = useContext(AnyNoyaStateContext);
   if (!value) {
+    const bindings = getNoyaSingletonBindings();
+    if (bindings) {
+      return {
+        noyaManager: getNoyaManagerSingleton(),
+        theme: bindings.theme,
+        viewType: bindings.viewType
+      };
+    }
     throw new Error(
       "useNoyaStateContext must be used within a NoyaStateProvider"
     );
@@ -6975,7 +7231,7 @@ function useAsset(id) {
   const { noyaManager } = useAnyNoyaStateContext();
   const observable = useMemo4(
     () => noyaManager.assetManager.assets$.map(
-      (assets) => assets.find((a) => a.id === id)
+      (assets) => assets.find((a) => a.stableId === id) ?? assets.find((a) => a.id === id)
     ),
     [noyaManager, id]
   );
@@ -7055,9 +7311,9 @@ function usePipelineManager() {
   const { noyaManager } = useAnyNoyaStateContext();
   return noyaManager.pipelineManager;
 }
-var ConnectedUsersContext = createContext(void 0);
 function useConnectedUsersManager() {
-  return useContext(ConnectedUsersContext);
+  const { noyaManager } = useAnyNoyaStateContext();
+  return noyaManager.connectedUsersManager;
 }
 function useConnectedUsers() {
   const connectedUsersManager = useConnectedUsersManager();
@@ -7078,9 +7334,9 @@ function useConnectedUser(userId) {
     )
   );
 }
-var AnyEphemeralUserDataManagerContext = createContext(void 0);
 function useAnyEphemeralUserData() {
-  return useContext(AnyEphemeralUserDataManagerContext);
+  const { noyaManager } = useAnyNoyaStateContext();
+  return noyaManager.ephemeralUserDataManager;
 }
 function useCurrentUserId() {
   const connectedUsersManager = useConnectedUsersManager();
@@ -7090,6 +7346,19 @@ function useIsProcessing() {
   const { noyaManager } = useAnyNoyaStateContext();
   return useObservable(noyaManager.isProcessing$);
 }
+function useFileName() {
+  const { noyaManager } = useAnyNoyaStateContext();
+  return useObservable(noyaManager.filePropertyManager.optimisticValue$);
+}
+function useFilePropertyManager() {
+  const { noyaManager } = useAnyNoyaStateContext();
+  return noyaManager.filePropertyManager;
+}
+function useSetFileNameState() {
+  const fileName = useFileName();
+  const filePropertyManager = useFilePropertyManager();
+  return [fileName, filePropertyManager.updateName];
+}
 function useResourceManager() {
   const { noyaManager } = useAnyNoyaStateContext();
   return noyaManager.resourceManager;
@@ -7121,59 +7390,38 @@ function useResources({
     async (action) => {
       const newResourceMap = action instanceof Function ? action(resourceMap) : action;
       const { addedResources, removedResources, modifiedResources } = diffResourceMaps(resourceMap, newResourceMap, "id");
-      if (addedResources.length > 0) {
-        const payload = addedResources.map((resource) => {
-          switch (resource.type) {
-            case "directory":
-              return {
-                path: resource.path,
-                type: "directory"
-              };
-            case "asset":
-              return {
-                path: resource.path,
-                type: "asset",
-                assetId: resource.assetId,
-                asset: resource.asset
-              };
-            case "file":
-              return {
-                path: resource.path,
-                type: "file",
-                fileId: resource.fileId
-              };
-            case "resource":
-              return {
-                path: resource.path,
-                type: "resource",
-                fileId: resource.fileId,
-                resourceId: resource.resourceId
-              };
-            default:
-              throw new Error(
-                `Unknown resource type: ${resource.type}`
-              );
-          }
-        });
-        await resourceManager.createResource(payload);
+      const { payload: createPayload, consumedModifiedResourceIds } = buildCreateResourcePayload({
+        addedResources,
+        modifiedResources,
+        newResourceMap,
+        resourceMap
+      });
+      if (createPayload.length > 0) {
+        await resourceManager.createResource(createPayload);
       }
-      for (const resource of removedResources) {
-        await resourceManager.deleteResource({ id: resource.id });
-        if (shouldDeleteAssets && resource.type === "asset") {
-          try {
+      const consumedModifiedResourceIdsSet = new Set(
+        consumedModifiedResourceIds
+      );
+      const remainingModifiedResources = modifiedResources.filter(
+        (resource) => !consumedModifiedResourceIdsSet.has(resource.id)
+      );
+      await resourceManager.deleteResource(
+        removedResources.map((resource) => ({ id: resource.id }))
+      );
+      if (shouldDeleteAssets) {
+        for (const resource of removedResources) {
+          if (resource.type === "asset") {
             await assetManager.delete(resource.assetId);
-          } catch (error) {
-            console.error("Failed to delete asset:", error);
           }
         }
       }
       await Promise.all(
-        modifiedResources.map(
+        remainingModifiedResources.map(
           ({ id, path: path2, assetId, asset }) => resourceManager.updateResource({
             id,
             path: path2,
             assetId,
-            asset
+            ...assetId ? {} : asset ? { asset } : {}
           })
         )
       );
@@ -7220,41 +7468,25 @@ function createNoyaContext({
   safeEval
 }) {
   const NoyaStateContext = AnyNoyaStateContext;
-  const EphemeralUserDataManagerContext = AnyEphemeralUserDataManagerContext;
   function NoyaContextProvider({
     children,
     contextValue
   }) {
-    return /* @__PURE__ */ React16.createElement(AnyNoyaStateContext.Provider, { value: contextValue }, /* @__PURE__ */ React16.createElement(
-      ConnectedUsersContext.Provider,
-      {
-        value: contextValue.noyaManager.connectedUsersManager
-      },
-      /* @__PURE__ */ React16.createElement(
-        EphemeralUserDataManagerContext.Provider,
-        {
-          value: contextValue.noyaManager.ephemeralUserDataManager
-        },
-        children
-      )
-    ));
+    return /* @__PURE__ */ React17.createElement(AnyNoyaStateContext.Provider, { value: contextValue }, children);
   }
   function NoyaStateProvider({
     children,
     initialState,
     ...options
   }) {
-    const [, , { noyaManager, theme, viewType }] = useNoyaState(
-      initialState,
-      {
-        schema,
-        mergeHistoryEntries,
-        outputTransforms,
-        inputs,
-        safeEval,
-        ...options
-      }
-    );
+    const [, , { noyaManager, theme, viewType }] = useNoyaStateInternal(initialState, {
+      schema,
+      mergeHistoryEntries,
+      outputTransforms,
+      inputs,
+      safeEval,
+      ...options
+    });
     const contextValue = useMemo4(
       () => ({
         noyaManager,
@@ -7263,7 +7495,7 @@ function createNoyaContext({
       }),
       [noyaManager, theme, viewType]
     );
-    return /* @__PURE__ */ React16.createElement(NoyaContextProvider, { contextValue }, options.fallback !== void 0 ? /* @__PURE__ */ React16.createElement(FallbackUntilInitialized, { fallback: options.fallback }, children) : children);
+    return /* @__PURE__ */ React17.createElement(NoyaContextProvider, { contextValue }, options.fallback !== void 0 ? /* @__PURE__ */ React17.createElement(FallbackUntilInitialized, { fallback: options.fallback }, children) : children);
   }
   function useValue(path2, options) {
     const { noyaManager } = useAnyNoyaStateContext();
@@ -7305,13 +7537,8 @@ function createNoyaContext({
     return noyaManager.multiplayerStateManager;
   }
   function useEphemeralUserDataManager() {
-    const ephemeralUserData = useContext(EphemeralUserDataManagerContext);
-    if (!ephemeralUserData) {
-      throw new Error(
-        "useEphemeralUserData must be used within a NoyaStateProvider"
-      );
-    }
-    return ephemeralUserData;
+    const { noyaManager } = useAnyNoyaStateContext();
+    return noyaManager.ephemeralUserDataManager;
   }
   function useNoyaManager() {
     return useAnyNoyaStateContext().noyaManager;
@@ -7393,7 +7620,7 @@ function useCallableAITools() {
 // src/components/UserPointersOverlay.tsx
 import { Observable as Observable2 } from "@noya-app/observable";
 import { memoGeneric as memoGeneric2 } from "@noya-app/react-utils";
-import React17, { useEffect as useEffect6, useMemo as useMemo5, useState as useState5 } from "react";
+import React18, { useEffect as useEffect6, useMemo as useMemo5, useState as useState5 } from "react";
 function shouldShow(hideAfter, updatedAt) {
   return !!updatedAt && Date.now() - updatedAt < hideAfter;
 }
@@ -7436,9 +7663,9 @@ var UserPointersOverlay = memoGeneric2(function UserPointers({
 }) {
   const currentUserId = useObservable(ephemeralUserDataManager.currentUserId$);
   const connectedUsers = useObservable(connectedUsersManager.connectedUsers$);
-  return /* @__PURE__ */ React17.createElement(React17.Fragment, null, connectedUsers.map((user) => {
+  return /* @__PURE__ */ React18.createElement(React18.Fragment, null, connectedUsers.map((user) => {
     if (user.id === currentUserId) return null;
-    return /* @__PURE__ */ React17.createElement(
+    return /* @__PURE__ */ React18.createElement(
       UserPointerInternal,
       {
         key: user.id,
@@ -7531,24 +7758,30 @@ var WebSocketConnection = class {
   }
 };
 export {
-  AnyEphemeralUserDataManagerContext,
   AnyNoyaStateContext,
-  ConnectedUsersContext,
   FallbackUntilInitialized,
   StateInspector,
   UserPointersOverlay,
   WebSocketConnection,
+  buildCreateResourcePayload,
   createDefaultAppData,
   createNoyaContext,
+  createStateInspectorRoot,
   decodeAll,
+  deleteNoyaSingleton,
   encodeAll,
   enforceSchema,
   exportAll,
   fetchAssetMap,
   getAppData,
+  getNoyaManagerSingleton,
+  getNoyaSingletonBindings,
+  getSyncAdapter,
   importAll,
+  initializeNoyaSingleton,
   parseAppDataParameter,
   replaceDeep,
+  resourceToCreateParameters,
   resourceToMediaItem,
   useAIManager,
   useActivityEvents,
@@ -7559,12 +7792,15 @@ export {
   useAsset,
   useAssetManager,
   useAssets,
+  useBindNoyaManager,
   useCallableAITools,
   useColorScheme,
   useConnectedUser,
   useConnectedUsers,
   useConnectedUsersManager,
   useCurrentUserId,
+  useFileName,
+  useFilePropertyManager,
   useIOManager,
   useInputs,
   useIsInitialized,
@@ -7572,7 +7808,7 @@ export {
   useManagedHistory,
   useManagedState,
   useMultiplayerState,
-  useNoyaState,
+  useNoyaStateInternal,
   useObservable,
   useOutputTransforms,
   usePipelineManager,
@@ -7583,8 +7819,8 @@ export {
   useSecret,
   useSecretManager,
   useSecrets,
+  useSetFileNameState,
   useStateInspector,
-  useSyncStateManager,
   useViewType
 };
 //# sourceMappingURL=index.mjs.map