@xyo-network/os-react-runtime 2.3.0

package/src/hooks/DappIntentResourceHooks.ts

@@ -0,0 +1,35 @@
+import { usePromise } from '@xylabs/react-promise'
+import type { XyOsContext } from '@xyo-network/os-model'
+import type { DappIntentViews } from '@xyo-network/os-runtime'
+import { DappIntentResource } from '@xyo-network/os-runtime'
+
+import { ResourceHooks } from './ResourceHooks.ts'
+import { useCleanUpResource } from './useCleanup.tsx'
+import { useSyncExternalPayloadStore } from './useSyncExternalPayloadStore.tsx'
+
+export const useBuildIntentResource = (context?: XyOsContext | null) => {
+  const resource = usePromise(async () => {
+    if (context) {
+      const resource = new DappIntentResource(context)
+      await resource.start()
+      return resource
+    }
+  }, [context])
+
+  useCleanUpResource(resource[0])
+
+  return resource
+}
+
+export const useIntentResourceViews = (resource?: DappIntentResource) => {
+  const allDappIntents = useSyncExternalPayloadStore('allDappIntents', resource)
+  const latestDappIntent = useSyncExternalPayloadStore('latestDappIntent', resource)
+
+  return {
+    allDappIntents,
+    latestDappIntent,
+    resource,
+  }
+}
+
+export const DappIntentResourceHooks = new ResourceHooks<DappIntentViews, DappIntentResource>(useBuildIntentResource, useIntentResourceViews)

package/src/hooks/NameServiceRegistrationHooks.ts

@@ -0,0 +1,36 @@
+import { usePromise } from '@xylabs/react-promise'
+import type { XyOsContext } from '@xyo-network/os-model'
+import type { XnsRegistrationsViews } from '@xyo-network/os-runtime'
+import { XnsRegistrationsResource } from '@xyo-network/os-runtime'
+
+import { ResourceHooks } from './ResourceHooks.ts'
+import { useCleanUpResource } from './useCleanup.tsx'
+import { useSyncExternalPayloadStore } from './useSyncExternalPayloadStore.tsx'
+
+export const useBuildNameServiceRegistrationsResource = (context?: XyOsContext | null, pathPrefix?: string) => {
+  const result = usePromise(async () => {
+    if (context) {
+      const xnsRegistrationsResource = new XnsRegistrationsResource(context, pathPrefix)
+      await xnsRegistrationsResource.start()
+      return xnsRegistrationsResource
+    }
+  }, [context, pathPrefix])
+
+  useCleanUpResource(result[0])
+
+  return result
+}
+
+export const useBuildNameServiceRegistrationsResourceViews = (resource?: XnsRegistrationsResource) => {
+  const allRegistrations = useSyncExternalPayloadStore<XnsRegistrationsResource, XnsRegistrationsViews>('allRegistrations', resource)
+
+  return {
+    allRegistrations,
+    resource,
+  }
+}
+
+export const NameServiceRegistrationHooks = new ResourceHooks<XnsRegistrationsViews, XnsRegistrationsResource>(
+  useBuildNameServiceRegistrationsResource,
+  useBuildNameServiceRegistrationsResourceViews,
+)

package/src/hooks/ResourceHooks.ts

@@ -0,0 +1,39 @@
+import type { State } from '@xylabs/react-promise'
+import type { XyOsContext } from '@xyo-network/os-model'
+import type { ResourceStore } from '@xyo-network/os-runtime'
+
+import { useXyOsUiContext } from '../modules/index.ts'
+
+export class ResourceHooks<Views extends string, T extends ResourceStore<Views>> {
+  constructor(
+    private buildResource: (context?: XyOsContext | null, pathPrefix?: string) => [T | undefined, Error | undefined, State | undefined],
+    private buildViews: (resource?: T) => { [K in Views]: ReturnType<T['views'][K]> | undefined } | (undefined & Record<'resource', T | undefined>),
+  ) {}
+
+  useBuildResourceFromProvidedNode = (pathPrefix?: string) => {
+    const xyOs = useXyOsUiContext()
+    return this.buildResource(xyOs, pathPrefix)
+  }
+
+  useResourceViewsFromContext = (context?: XyOsContext | null, pathPrefix?: string) => {
+    const [resource, resourceError] = this.buildResource(context, pathPrefix)
+    const views = this.buildViews(resource)
+
+    return {
+      ...views,
+      resource,
+      resourceError,
+    }
+  }
+
+  useResourceViewsFromProvidedNode = (pathPrefix?: string) => {
+    const [resource, resourceError] = this.useBuildResourceFromProvidedNode(pathPrefix)
+    const views = this.buildViews(resource)
+
+    return {
+      ...views,
+      resource,
+      resourceError,
+    }
+  }
+}

package/src/hooks/access-requests/index.ts

@@ -0,0 +1 @@
+export * from './useBuildDappAccessRequestResource.js'

package/src/hooks/access-requests/useBuildDappAccessRequestResource.ts

@@ -0,0 +1,38 @@
+import { usePromise } from '@xylabs/react-promise'
+import type { XyOsContext } from '@xyo-network/os-model'
+import type { DappAccessRequestViews } from '@xyo-network/os-runtime'
+import { DappAccessRequestResource } from '@xyo-network/os-runtime'
+
+import { ResourceHooks } from '../ResourceHooks.ts'
+import { useCleanUpResource } from '../useCleanup.tsx'
+import { useSyncExternalPayloadStore } from '../useSyncExternalPayloadStore.tsx'
+
+export const useBuildDappAccessRequestResource = (context?: XyOsContext | null) => {
+  const resource = usePromise(async () => {
+    if (context) {
+      const resource = new DappAccessRequestResource(context)
+      await resource.start()
+      return resource
+    }
+  }, [context])
+
+  useCleanUpResource(resource[0])
+
+  return resource
+}
+
+export const useDappAccessRequestResourceViews = (resource?: DappAccessRequestResource) => {
+  const accessRequests = useSyncExternalPayloadStore('accessRequests', resource)
+  const registeredInterfaces = useSyncExternalPayloadStore('registeredInterfaces', resource)
+
+  return {
+    accessRequests,
+    registeredInterfaces,
+    resource,
+  }
+}
+
+export const DappAccessRequestResourceHooks = new ResourceHooks<DappAccessRequestViews, DappAccessRequestResource>(
+  useBuildDappAccessRequestResource,
+  useDappAccessRequestResourceViews,
+)

package/src/hooks/bios/index.ts

@@ -0,0 +1,2 @@
+export * from './useBios.js'
+export * from './useKernel.js'

package/src/hooks/bios/useBios.ts

@@ -0,0 +1,26 @@
+import { usePromise } from '@xylabs/react-promise'
+import { boot } from '@xyo-network/bios-browser'
+import type { BiosExternalInterface } from '@xyo-network/bios-model'
+import { useEffect } from 'react'
+
+let biosBoot: Promise<BiosExternalInterface>
+
+export const useBios = () => {
+  const [biosExternalInterface, biosError] = usePromise(async () => {
+    // If we've already booted the bios, await it's boot
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    if (biosBoot) return await biosBoot
+    // Otherwise, boot the bios
+    biosBoot = boot()
+    // and await it's boot
+    return await biosBoot
+  }, [])
+
+  // Bring any async BIOS errors from usePromise back
+  // within react error boundaries
+  useEffect(() => {
+    if (biosError) throw biosError
+  }, [biosError])
+
+  return biosExternalInterface
+}

package/src/hooks/bios/useKernel.ts

@@ -0,0 +1,36 @@
+import { usePromise } from '@xylabs/react-promise'
+import { Kernel } from '@xyo-network/kernel'
+import type { KernelBootParams, KernelExternal } from '@xyo-network/kernel-model'
+import type { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import { useEffect } from 'react'
+
+import { useBios } from './useBios.js'
+
+let kernelBoot: Promise<KernelExternal> | undefined
+
+export const useKernel = (locator: ModuleFactoryLocator, params: KernelBootParams) => {
+  const bios = useBios()
+  const [kernelExternalInterface, kernelError] = usePromise(async () => {
+    // If we've already booted the kernel, await it's boot
+    if (kernelBoot) return await kernelBoot
+    if (bios) {
+      // Otherwise, boot the kernel
+      kernelBoot = (async function () {
+        const kernel = new Kernel()
+
+        await kernel.boot(bios, { locator, ...params })
+        return kernel
+      })()
+      // and await it's boot
+      return await kernelBoot
+    }
+  }, [bios])
+
+  // Bring any async BIOS errors from usePromise back
+  // within react error boundaries
+  useEffect(() => {
+    if (kernelError) throw kernelError
+  }, [kernelError])
+
+  return kernelExternalInterface
+}

package/src/hooks/index.ts

@@ -0,0 +1,20 @@
+export * from './access-requests/index.ts'
+export * from './bios/index.ts'
+export * from './DappIntentResourceHooks.ts'
+export * from './intent/index.ts'
+export * from './menu/index.ts'
+export * from './NameServiceRegistrationHooks.js'
+export * from './os/index.ts'
+export * from './ResourceHooks.js'
+export * from './useAccountArchivist.js'
+export * from './useCleanup.js'
+export * from './useDappCaller.js'
+export * from './useDappIntentCaller.jsx'
+export * from './useDebugClick.js'
+export * from './useDetectCustomer.js'
+export * from './useExposedNode.js'
+export * from './useOsSettingsCaller.js'
+export * from './usePhraseFile.js'
+export * from './useStackReady.tsx'
+export * from './useSyncExternalPayloadStore.js'
+export * from './useTabs.js'

package/src/hooks/intent/index.ts

@@ -0,0 +1,5 @@
+export * from './useClearIntents.js'
+export * from './useDappIntentListener.js'
+export * from './useDappIntentListener2.js'
+export * from './useNavigateIntent.js'
+export * from './useSendDappIntent.js'

package/src/hooks/intent/useClearIntents.tsx

@@ -0,0 +1,14 @@
+import { useAsyncEffect } from '@xylabs/react-async-effect'
+import { useWeakArchivistFromNode } from '@xyo-network/react-archivist'
+
+export const useClearIntents = () => {
+  const [intentArchivist] = useWeakArchivistFromNode('IntentArchivist')
+  // For now, clear the archivist to avoid bloating
+  useAsyncEffect(
+    async () => {
+      const intentArchivistInstance = intentArchivist?.deref()
+      if (intentArchivistInstance) await intentArchivistInstance.clear?.()
+    },
+    [intentArchivist],
+  )
+}

package/src/hooks/intent/useDappIntentListener.tsx

@@ -0,0 +1,49 @@
+import type { ArchivistModuleEventData } from '@xyo-network/archivist-model'
+import type { DappIntent } from '@xyo-network/os-model'
+import {
+  DappIntentTypes, DappMode, isDappIntentWithMeta,
+} from '@xyo-network/os-model'
+import { useWeakArchivistFromNode } from '@xyo-network/react-archivist'
+import { useEffect, useState } from 'react'
+
+/** watch payloads going into the intent archivist to figure out what if the current state of the passed in dappId */
+export const useDappIntentListener = (dappName?: string | null, targetMode = DappMode.Window) => {
+  const [dappIntentType, setDappIntentType] = useState<DappIntentTypes>(DappIntentTypes.Close)
+  const [intentPayload, setIntentPayload] = useState<DappIntent>()
+  const [intentArchivist] = useWeakArchivistFromNode('IntentArchivist')
+
+  useEffect(() => {
+    const listener = ({ payloads }: ArchivistModuleEventData['inserted']) => {
+      const filteredPayloads = payloads.filter(isDappIntentWithMeta)
+      for (const payload of filteredPayloads) {
+        if (payload.targetDappId === dappName && payload.targetMode === targetMode) {
+          setIntentPayload(payload)
+          switch (payload.intent) {
+            case DappIntentTypes.Close: {
+              setDappIntentType(DappIntentTypes.Close)
+              break
+            }
+            case DappIntentTypes.Launch: {
+              setDappIntentType(DappIntentTypes.Launch)
+              break
+            }
+            case DappIntentTypes.Minimize: {
+              setDappIntentType(DappIntentTypes.Minimize)
+              break
+            }
+            default: {
+              console.warn('Unrecognized DappIntentType:', payload)
+            }
+          }
+        }
+      }
+    }
+    intentArchivist?.deref()?.on('inserted', listener)
+
+    return () => {
+      intentArchivist?.deref()?.off('inserted', listener)
+    }
+  }, [dappName, intentArchivist, targetMode])
+
+  return { dappIntentType, intentPayload }
+}

package/src/hooks/intent/useDappIntentListener2.tsx

@@ -0,0 +1,48 @@
+import { DappIntentTypes, DappMode } from '@xyo-network/os-model'
+import { useEffect, useState } from 'react'
+
+import { DappIntentResourceHooks } from '../DappIntentResourceHooks.js'
+
+/**
+ * Note: This is a modified version of the original useDappIntentListener hook.
+ * This version uses the DappIntentResourceHooks instead of the useArchivistFromNode hook.
+ * Sadly, it appears to be much slower than the original version.  It might be because the resource
+ * uses useExternalStoreSync under the hood, which might be the cause :shrug:
+ */
+
+/** watch payloads going into the intent archivist to figure out what if the current state of the passed in dappId */
+/** @deprecated - use the original version - useDappIntentListener till performance issues are ironed out */
+export const useDappIntentListener2 = (dappName?: string | null, sourceMode = DappMode.Window) => {
+  const { latestDappIntent } = DappIntentResourceHooks.useResourceViewsFromProvidedNode()
+  const [dappIntentType, setDappIntentType] = useState<DappIntentTypes>(DappIntentTypes.Close)
+
+  useEffect(() => {
+    if (sourceMode === DappMode.Window) {
+      for (const payload of latestDappIntent ?? []) {
+        if (payload.targetDappId === dappName) {
+          switch (payload.intent) {
+            case DappIntentTypes.Close: {
+              setDappIntentType(DappIntentTypes.Close)
+              break
+            }
+            case DappIntentTypes.Launch: {
+              setDappIntentType(DappIntentTypes.Launch)
+              break
+            }
+            case DappIntentTypes.Minimize: {
+              setDappIntentType(DappIntentTypes.Minimize)
+              break
+            }
+            default: {
+              console.warn('Unrecognized DappIntentType:', payload)
+            }
+          }
+        }
+      }
+    } else {
+      console.warn('Intent sent from unrecognized mode', sourceMode)
+    }
+  }, [dappName, latestDappIntent, sourceMode])
+
+  return dappIntentType
+}

package/src/hooks/intent/useNavigateIntent.tsx

@@ -0,0 +1,51 @@
+import type { DappIntent } from '@xyo-network/os-model'
+import { DappIntentTypes } from '@xyo-network/os-model'
+import { NameTransforms } from '@xyo-network/os-runtime'
+import { useCallback } from 'react'
+import { useNavigate, useParams } from 'react-router-dom'
+
+export type UpdateRouteParamOptions = {
+  // skip the navigate call to allow intents to be processed without updating the route
+  skipNavigate?: boolean
+}
+
+const rootRoute = '/'
+
+/** update url based off passed intents */
+export const useNavigateIntent = () => {
+  const navigate = useNavigate()
+  const { dappName: dappNameParam } = useParams()
+
+  const updateRouteParam = useCallback(
+    (dappIntent: DappIntent, { skipNavigate }: UpdateRouteParamOptions = {}) => {
+      if (dappIntent && dappIntent.targetDappId) {
+        const {
+          targetDappId: dappName, intent: intentType, params: intentParams,
+        } = dappIntent
+        const slug = new NameTransforms(dappName).slug()
+        switch (intentType) {
+          case DappIntentTypes.Launch: {
+            const dappNameDeSlugged = dappNameParam ? new NameTransforms(dappNameParam).deSlug() : null
+            if (dappNameDeSlugged !== dappName) {
+              // navigating from the root to allow overwriting duplicate slugs
+              const slugFromRoot = `${rootRoute}${slug}${intentParams ? `/${intentParams}` : ''}`
+              if (!skipNavigate) navigate(slugFromRoot)
+            }
+            break
+          }
+          case DappIntentTypes.Minimize: {
+            if (!skipNavigate)navigate(rootRoute)
+            break
+          }
+          case DappIntentTypes.Close: {
+            if (!skipNavigate) navigate(rootRoute)
+            break
+          }
+        }
+      }
+    },
+    [dappNameParam, navigate],
+  )
+
+  return updateRouteParam
+}

package/src/hooks/intent/useSendDappIntent.tsx

@@ -0,0 +1,38 @@
+import type { DappIntent } from '@xyo-network/os-model'
+import { useWeakArchivistFromNode } from '@xyo-network/react-archivist'
+import { useCallback } from 'react'
+
+import type { UpdateRouteParamOptions } from './useNavigateIntent.js'
+import { useNavigateIntent } from './useNavigateIntent.js'
+
+/** Returns a function that resolves the IntentArchivist and inserts an intent payload */
+export const useSendDappIntent = () => {
+  const [intentArchivist] = useWeakArchivistFromNode('IntentArchivist')
+  const navigate = useNavigateIntent()
+
+  const sendIntent = useCallback(
+    async (dappIntent: DappIntent, options: UpdateRouteParamOptions = {}) => {
+      const intentArchivistInstance = intentArchivist?.deref()
+      if (!intentArchivistInstance) {
+        console.error('unable to find IntentArchivist')
+        return
+      }
+      if (dappIntent) {
+        try {
+          await intentArchivistInstance.insert([dappIntent])
+        } catch (e) {
+          console.error('error sending intent to archivist', e)
+        }
+        // sync the route with the intent
+        navigate(dappIntent, options)
+      } else {
+        console.warn('tried to send intent but intent payload')
+      }
+    },
+    // Disabling because navigate changes references and causes additional renders
+
+    [intentArchivist],
+  )
+
+  return intentArchivist ? sendIntent : null
+}

package/src/hooks/menu/index.ts

@@ -0,0 +1,3 @@
+export * from './useAddDappMenuItems.js'
+export * from './useBuildDappMenuResource.js'
+export * from './useDappMenuCaller.js'

package/src/hooks/menu/useAddDappMenuItems.tsx

@@ -0,0 +1,25 @@
+import { usePromise } from '@xylabs/react-promise'
+import type { Payload } from '@xyo-network/payload-model'
+
+import { useXyOsUiContext } from '../../modules/index.ts'
+import { DappMenuResourceHooks } from './useBuildDappMenuResource.js'
+import { useDappMenuCaller } from './useDappMenuCaller.js'
+
+export const useAddDappMenuItems = (payloads: Payload[]) => {
+  const xyOs = useXyOsUiContext()
+  const {
+    menuItemSelections, menuConfigs, resourceError,
+  } = DappMenuResourceHooks.useResourceViewsFromContext(xyOs)
+  const dappMenuCaller = useDappMenuCaller()
+
+  const [, addMenuItemsError] = usePromise(async () => {
+    await dappMenuCaller?.add(payloads)
+  }, [payloads, dappMenuCaller])
+
+  return {
+    addMenuItemsError,
+    menuConfig: menuConfigs?.[0],
+    path: menuItemSelections?.[0],
+    error: resourceError,
+  }
+}

package/src/hooks/menu/useBuildDappMenuResource.ts

@@ -0,0 +1,39 @@
+import { usePromise } from '@xylabs/react-promise'
+import type { XyOsContext } from '@xyo-network/os-model'
+import type { DappMenuResourceViews } from '@xyo-network/os-runtime'
+import { DappMenuResource } from '@xyo-network/os-runtime'
+
+import { ResourceHooks } from '../ResourceHooks.js'
+import { useCleanUpResource } from '../useCleanup.js'
+import { useSyncExternalPayloadStore } from '../useSyncExternalPayloadStore.js'
+
+export const useBuildDappMenuResource = (xyOsContext?: XyOsContext | null) => {
+  const resource = usePromise(async () => {
+    if (xyOsContext) {
+      const resource = new DappMenuResource(xyOsContext)
+      await resource.start()
+      return resource
+    }
+  }, [xyOsContext])
+
+  useCleanUpResource(resource[0])
+
+  return resource
+}
+
+export const useMenuResourceViews = (resource?: DappMenuResource) => {
+  const menuItemSelections = useSyncExternalPayloadStore('menuItemSelections', resource)
+  const menuConfigs = useSyncExternalPayloadStore('menuConfigs', resource)
+  const menuItems = useSyncExternalPayloadStore('menuItems', resource)
+  const menuItemsVisible = useSyncExternalPayloadStore('menuItemsVisible', resource)
+
+  return {
+    menuConfigs,
+    menuItemSelections,
+    menuItems,
+    menuItemsVisible,
+    resource,
+  }
+}
+
+export const DappMenuResourceHooks = new ResourceHooks<DappMenuResourceViews, DappMenuResource>(useBuildDappMenuResource, useMenuResourceViews)

package/src/hooks/menu/useDappMenuCaller.tsx

@@ -0,0 +1,22 @@
+import { assertEx } from '@xylabs/assert'
+import type { XyOsContext } from '@xyo-network/os-model'
+import { DappMenuCaller } from '@xyo-network/os-runtime'
+import { useMemo } from 'react'
+
+import { useXyOsUiContext } from '../../modules/index.ts'
+
+type DappMenuCallerHookOptions = {
+  ignoreProvidedNode?: boolean
+}
+
+export const useDappMenuCaller = (context?: XyOsContext | null, { ignoreProvidedNode }: DappMenuCallerHookOptions = {}) => {
+  const xyOs = useXyOsUiContext()
+
+  return useMemo(() => {
+    const resolvedProvidedNode = ignoreProvidedNode ? null : xyOs
+    if (context || resolvedProvidedNode) {
+      const finalContext = assertEx(context ?? xyOs, () => 'no node was found in context or passed as argument')
+      return new DappMenuCaller(finalContext)
+    }
+  }, [ignoreProvidedNode, context, xyOs])
+}

package/src/hooks/os/index.ts

@@ -0,0 +1,5 @@
+export * from './useDappContextCreator.js'
+export * from './useDappRegistrationResults.js'
+export * from './useDappRegistry.js'
+export * from './useDappSeedPhraseRepository.js'
+export * from './useWidgetDapps.js'

package/src/hooks/os/useDappContextCreator.tsx

@@ -0,0 +1,84 @@
+import { useAsyncEffect } from '@xylabs/react-async-effect'
+import type { RegisteredDapp, WindowDappNodeSet } from '@xyo-network/os-model'
+import { DappIntentTypes } from '@xyo-network/os-model'
+import { DappContextCreator, RunningDappCache } from '@xyo-network/os-runtime'
+import {
+  useCallback, useEffect, useRef, useState,
+} from 'react'
+
+import { useXyOsUiContext } from '../../modules/index.ts'
+import { useDappIntentListener } from '../intent/index.ts'
+
+/**
+ * Creates a dapp node for the provided dapp and name
+ *
+ * @param dapp - The dapp to create the node for
+ */
+export const useDappContextCreator = (
+  xnsNodeUrl: string | undefined,
+  xnsNetwork: string | undefined,
+  dapp?: RegisteredDapp,
+  allowedNames?: string[],
+  createOnMount = false,
+): WindowDappNodeSet & {
+  nodeCreateError?: Error
+} => {
+  const context = useXyOsUiContext()
+  const [windowDappNodeSet, setWindowDappNodeSet] = useState<WindowDappNodeSet>({ context: undefined, dappWallet: undefined })
+  const [dappWindowNodeError, setDappWindowNodeError] = useState<Error>()
+  const { dappIntentType: intentType } = useDappIntentListener(dapp?.config.name)
+
+  // Keep a ref of the windowDappNodeSet to use in effect hooks without needing it as a dependency
+  const windowDappNodeSetRef = useRef<WindowDappNodeSet>(windowDappNodeSet)
+  useEffect(() => {
+    windowDappNodeSetRef.current = windowDappNodeSet
+  }, [windowDappNodeSet])
+
+  const createNode = useCallback(async () => {
+    if (dapp && context) {
+      try {
+        const windowDappNodeSet = await RunningDappCache.findOrCreate(dapp, context, allowedNames ?? [], xnsNodeUrl, xnsNetwork)
+        setWindowDappNodeSet(windowDappNodeSet)
+      } catch (e) {
+        setDappWindowNodeError(e as Error)
+      }
+    }
+  }, [dapp, context, allowedNames])
+
+  useEffect(() => {
+    if (createOnMount) {
+      void (async () => {
+        await createNode()
+      })()
+    }
+  }, [createOnMount, createNode])
+
+  // Watch the intents to determine if the dappWindowNode should be built
+  useAsyncEffect(
+
+    async () => {
+      switch (intentType) {
+        case DappIntentTypes.Launch: {
+          await createNode()
+          break
+        }
+        case DappIntentTypes.Close: {
+          if (windowDappNodeSetRef.current.context) {
+            // In case a cached dapp was closed, clear its Dapp Archivist to allow for a fresh start upon next launch
+            await DappContextCreator.resetDappArchivist(windowDappNodeSetRef.current.context)
+            setWindowDappNodeSet({ context: null, dappWallet: undefined })
+          }
+          break
+        }
+        case DappIntentTypes.Minimize:
+        // do nothing
+      }
+    },
+    [createNode, intentType],
+  )
+
+  return {
+    ...windowDappNodeSet,
+    nodeCreateError: dappWindowNodeError,
+  }
+}