anchor.diff:  
   handle_call({register, Capability, Info}, _From, State) ->
       State2 = register_capability(node(), Capability, Info, State),
  -    State3 = renegotiate_capabilities(State2),
  -    publish_supported(State3),
  -    update_local_cache(State3),
  -    save_registered(State3#state.registered),
  -    {reply, ok, State3};
  +    State3 = update_supported(State2),
  +    State4 = renegotiate_capabilities(State3),
  +    publish_supported(State4),
  +    update_local_cache(State4),
  +    save_registered(State4#state.registered),
  +    {reply, ok, State4};
   
   handle_call({ring_changed, Ring}, _From, State) ->
       State2 = update_supported(Ring, State),
  
positive.code:                             {[], []} ->
                                  add_node(Node, Supported, StateAcc);
                              {[], _} ->
                                  %% While the ring has no knowledge of Node's
                                  %% supported modes, the local view has prior
                                  %% knowledge. Do nothing and continue to use
                                  %% the existing modes.
                                  StateAcc;
                              {Same, Same} ->
                                  StateAcc;
                              {_, _} ->
  
negative.code: %% Determine capabilities of legacy nodes based on app.config settings and
  %% the provided app-var -> mode mapping associated with capabilities when
  %% registered.
  query_capabilities(Node, State=#state{registered=Registered}) ->
      %% Only query results we do not already have local knowledge of
      Known = dict:from_list(get_supported(Node, State)),
      lists:mapfoldl(fun({Capability, Info}, ResolvedAcc) ->
                             {Resv, Cap} = query_capability(Node,
                                                            Known,
                                                            Capability,
                                                            Info#capability.default,
                                                            Info#capability.legacy),
                             {Cap, ResolvedAcc and Resv}
                     end, true, Registered).
  
  query_capability(Node, Known, Capability, DefaultSup, LegacyVar) ->
      case dict:find(Capability, Known) of
          {ok, Supported} ->
              {true, {Capability, Supported}};
          error ->
              query_capability(Node, Capability, DefaultSup, LegacyVar)
      end.
  
  query_capability(_, Capability, DefaultSup, undefined) ->
      Default = {Capability, [DefaultSup]},
  