Only compare httpd or node state for deciding to run `checkState` — radicle-explorer

Also adds a e2e test that allows us to avoid running into this race condition again.

 <script lang="ts">
   import type { Node } from "@httpd-client";
   import type { HttpdNodeState } from "@app/lib/httpd";
   import { capitalize } from "lodash";

   import Popover from "@app/components/Popover.svelte";
   import ScopePolicyExplainer from "@app/components/ScopePolicyExplainer.svelte";
   export let node: Node;
   export let node: HttpdNodeState;
 </script>
 <style>

         Your node is running and syncing with the network.
       </div>
       {#if node.config?.scope && node.config?.policy}
       {#if node.scope && node.policy}
         <div class="scope-policy">
           <div style:display="flex">
             Seeding Policy: <span style:margin-left="auto" class="txt-semibold">
               {capitalize(node.config.policy)}
               {capitalize(node.policy)}
             </span>
           </div>
           <div style:display="flex" style:margin-bottom="1rem">
             Scope:
             <span style:margin-left="auto" class="txt-semibold">
               {capitalize(node.config.scope)}
               {capitalize(node.scope)}
             </span>
           </div>
           <ScopePolicyExplainer
             scope={node.config.scope}
             policy={node.config.policy} />
           <ScopePolicyExplainer scope={node.scope} policy={node.policy} />
         </div>
       {/if}
       <div class="label">

 import type { Node } from "@httpd-client";
 import type { Node, Policy, Scope } from "@httpd-client";
 import { get, writable } from "svelte/store";
 import { withTimeout, Mutex, E_CANCELED, E_TIMEOUT } from "async-mutex";

   alias: string;
 }
 export interface HttpdNodeState {
   id: Node["id"];
   state: Node["state"];
   policy: Policy | undefined;
   scope: Scope | undefined;
 }
 export type HttpdState =
   | { state: "stopped" }
   | { state: "running"; node: Node }
   | {
       state: "running";
       node: HttpdNodeState;
     }
   | {
       state: "authenticated";
       session: Session;
       node: Node;
       node: HttpdNodeState;
     };
 const HTTPD_STATE_STORAGE_KEY = "httpdState";

         sig: params.signature,
         pk: params.publicKey,
       });
       const node = await api.getNode();
       const { id, state, config } = await api.getNode();
       const sess = await api.session.getById(params.id);
       update({
         state: "authenticated",

           publicKey: params.publicKey,
           alias: sess.alias,
         },
         node,
         node: { id, state, policy: config?.policy, scope: config?.scope },
       });
       return true;
     } catch (error) {

   await stateMutex
     .runExclusive(async () => {
       try {
         const node = await api.getNode();
         const { id, state, config } = await api.getNode();
         const node = {
           id,
           state,
           policy: config?.policy,
           scope: config?.scope,
         };
         if (httpdState && httpdState.state !== "stopped") {
           httpdState.node = node;