diff --git a/lib/schema.ex b/lib/schema.ex
index 24fc239..8a96086 100644
--- a/lib/schema.ex
+++ b/lib/schema.ex
@@ -114,7 +114,7 @@ defmodule Schema do
 
   @spec data_type?(binary(), binary() | list(binary())) :: boolean()
   def data_type?(type, type), do: true
-  
+
   def data_type?(type, base_type) when is_binary(base_type) do
     types = Map.get(Repo.data_types(), :attributes)
 
@@ -153,6 +153,9 @@ defmodule Schema do
     |> apply_profiles(profiles, MapSet.size(profiles))
   end
 
+  @spec all_classes() :: map()
+  def all_classes(), do: Repo.all_classes()
+
   @doc """
     Returns a single event class.
   """
@@ -430,7 +433,7 @@ defmodule Schema do
   # ----------------------------#
 
   def enrich(data, enum_text, observables) do
-  	Schema.Helper.enrich(data, enum_text, observables)
+    Schema.Helper.enrich(data, enum_text, observables)
   end
 
   # -------------------------------#
diff --git a/lib/schema/cache.ex b/lib/schema/cache.ex
index 4473b50..b1725d6 100644
--- a/lib/schema/cache.ex
+++ b/lib/schema/cache.ex
@@ -19,27 +19,29 @@ defmodule Schema.Cache do
 
   require Logger
 
-  @enforce_keys [:version, :profiles, :dictionary, :categories, :base_event, :classes, :objects]
-  defstruct ~w[version profiles dictionary base_event categories classes objects]a
-
-  @spec new(map()) :: __MODULE__.t()
-  def new(version) do
-    %__MODULE__{
-      version: version,
-      profiles: Map.new(),
-      dictionary: Map.new(),
-      categories: Map.new(),
-      base_event: Map.new(),
-      classes: Map.new(),
-      objects: Map.new()
-    }
-  end
+  @enforce_keys [
+    :version,
+    :profiles,
+    :categories,
+    :dictionary,
+    :base_event,
+    :classes,
+    :all_classes,
+    :objects
+  ]
+  defstruct ~w[version profiles dictionary base_event categories classes all_classes objects]a
 
   @type t() :: %__MODULE__{}
   @type class_t() :: map()
   @type object_t() :: map()
   @type category_t() :: map()
   @type dictionary_t() :: map()
+  @type link_t() :: %{
+          group: :common | :class | :object,
+          type: String.t(),
+          caption: String.t(),
+          attribute_keys: nil | MapSet.t(String.t())
+        }
 
   @ocsf_deprecated :"@deprecated"
 
@@ -53,7 +55,7 @@ defmodule Schema.Cache do
     categories = JsonReader.read_categories() |> update_categories()
     dictionary = JsonReader.read_dictionary() |> update_dictionary()
 
-    {base_event, classes} = read_classes(categories[:attributes])
+    {base_event, classes, all_classes} = read_classes(categories[:attributes])
     objects = read_objects()
 
     dictionary = Utils.update_dictionary(dictionary, base_event, classes, objects)
@@ -97,13 +99,16 @@ defmodule Schema.Cache do
       )
     end
 
-    new(version)
-    |> set_profiles(profiles)
-    |> set_categories(categories)
-    |> set_dictionary(dictionary)
-    |> set_base_event(base_event)
-    |> set_classes(classes)
-    |> set_objects(objects)
+    %__MODULE__{
+      version: version,
+      profiles: profiles,
+      categories: categories,
+      dictionary: dictionary,
+      base_event: base_event,
+      classes: classes,
+      all_classes: all_classes,
+      objects: objects
+    }
   end
 
   @doc """
@@ -141,6 +146,9 @@ defmodule Schema.Cache do
   @spec classes(__MODULE__.t()) :: map()
   def classes(%__MODULE__{classes: classes}), do: classes
 
+  @spec all_classes(__MODULE__.t()) :: map()
+  def all_classes(%__MODULE__{all_classes: all_classes}), do: all_classes
+
   @spec export_classes(__MODULE__.t()) :: map()
   def export_classes(%__MODULE__{classes: classes, dictionary: dictionary}) do
     Enum.into(classes, Map.new(), fn {name, class} ->
@@ -321,13 +329,29 @@ defmodule Schema.Cache do
       |> Enum.into(%{}, fn class -> attribute_source(class) end)
       |> extend_type()
 
+    resolved = resolve_extends(classes)
+
     classes =
-      resolve_extends(classes)
+      resolved
       # remove intermediate classes
       |> Stream.filter(fn {key, class} -> Map.has_key?(class, :uid) or key == :base_event end)
       |> Enum.into(%{}, fn class -> enrich_class(class, categories) end)
 
-    {Map.get(classes, :base_event), classes}
+    # all_classes has just enough info to interrogate the complete class hierarchy,
+    # removing most details. It can be used to get the caption and parent (extends) of
+    # any class, including hidden ones (classes without a uid)
+    all_classes =
+      Enum.map(
+        resolved,
+        fn {class_name, class_info} ->
+          {class_name,
+           Map.take(class_info, [:name, :caption, :extends])
+           |> Map.put(:hidden?, class_name != :base_event && !Map.has_key?(class_info, :uid))}
+        end
+      )
+      |> Enum.into(%{})
+
+    {Map.get(classes, :base_event), classes, all_classes}
   end
 
   defp read_objects() do
@@ -666,30 +690,6 @@ defmodule Schema.Cache do
     end
   end
 
-  defp set_profiles(%__MODULE__{} = schema, profiles) do
-    struct(schema, profiles: profiles)
-  end
-
-  defp set_dictionary(%__MODULE__{} = schema, dictionary) do
-    struct(schema, dictionary: dictionary)
-  end
-
-  defp set_categories(%__MODULE__{} = schema, categories) do
-    struct(schema, categories: categories)
-  end
-
-  defp set_base_event(%__MODULE__{} = schema, base_event) do
-    struct(schema, base_event: base_event)
-  end
-
-  defp set_classes(%__MODULE__{} = schema, classes) do
-    struct(schema, classes: classes)
-  end
-
-  defp set_objects(%__MODULE__{} = schema, objects) do
-    struct(schema, objects: objects)
-  end
-
   defp update_observables(objects, dictionary) do
     if Map.has_key?(objects, :observable) do
       observable_types = get_in(dictionary, [:types, :attributes]) |> observables()
@@ -869,10 +869,10 @@ defmodule Schema.Cache do
     end
   end
 
-  defp update_linked_profiles(name, links, object, classes) do
-    Enum.reduce(links, classes, fn {type, key, _}, acc ->
-      if type == name do
-        Map.update!(acc, String.to_atom(key), fn class ->
+  defp update_linked_profiles(group, links, object, classes) do
+    Enum.reduce(links, classes, fn link, acc ->
+      if link[:group] == group do
+        Map.update!(acc, String.to_atom(link[:type]), fn class ->
           Map.put(class, :profiles, merge(class[:profiles], object[:profiles]))
         end)
       else
diff --git a/lib/schema/profiles.ex b/lib/schema/profiles.ex
index a402a5e..e7fa380 100644
--- a/lib/schema/profiles.ex
+++ b/lib/schema/profiles.ex
@@ -48,21 +48,21 @@ defmodule Schema.Profiles do
   @doc """
     Checks classes or objects if all profile attributes are defined.
   """
-  def sanity_check(type, maps, profiles) do
+  def sanity_check(group, maps, profiles) do
     profiles =
       Enum.reduce(maps, profiles, fn {name, map}, acc ->
-        check_profiles(type, name, map, map[:profiles], acc)
+        check_profiles(group, name, map, map[:profiles], acc)
       end)
 
     {maps, profiles}
   end
 
   # Checks if all profile attributes are defined in the given attribute set.
-  defp check_profiles(_type, _name, _map, nil, all_profiles) do
+  defp check_profiles(_group, _name, _map, nil, all_profiles) do
     all_profiles
   end
 
-  defp check_profiles(type, name, map, profiles, all_profiles) do
+  defp check_profiles(group, name, map, profiles, all_profiles) do
     Enum.reduce(profiles, all_profiles, fn p, acc ->
       case acc[p] do
         nil ->
@@ -71,7 +71,7 @@ defmodule Schema.Profiles do
 
         profile ->
           check_profile(name, profile, map[:attributes])
-          link = {type, Atom.to_string(name), map[:caption]}
+          link = %{group: group, type: Atom.to_string(name), caption: map[:caption]}
           profile = Map.update(profile, :_links, [link], fn links -> [link | links] end)
           Map.put(acc, p, profile)
       end
diff --git a/lib/schema/repo.ex b/lib/schema/repo.ex
index b528c77..e3add6f 100644
--- a/lib/schema/repo.ex
+++ b/lib/schema/repo.ex
@@ -119,6 +119,11 @@ defmodule Schema.Repo do
     Agent.get(__MODULE__, fn schema -> Cache.classes(schema) |> filter(extensions) end)
   end
 
+  @spec all_classes() :: map()
+  def all_classes() do
+    Agent.get(__MODULE__, fn schema -> Cache.all_classes(schema) end)
+  end
+
   @spec export_classes() :: map()
   def export_classes() do
     Agent.get(__MODULE__, fn schema -> Cache.export_classes(schema) end)
@@ -248,8 +253,8 @@ defmodule Schema.Repo do
   defp remove_extension_links(nil, _extensions), do: []
 
   defp remove_extension_links(links, extensions) do
-    Enum.filter(links, fn {_, key, _} ->
-      [ext | rest] = String.split(key, "/")
+    Enum.filter(links, fn link ->
+      [ext | rest] = String.split(link[:type], "/")
       rest == [] or MapSet.member?(extensions, ext)
     end)
   end
diff --git a/lib/schema/utils.ex b/lib/schema/utils.ex
index ebdc7a8..ae8a8bb 100644
--- a/lib/schema/utils.ex
+++ b/lib/schema/utils.ex
@@ -83,8 +83,32 @@ defmodule Schema.Utils do
     Enum.filter(dictionary, fn {_name, map} -> Map.get(map, :object_type) == name end)
     |> Enum.map(fn {_, map} -> Map.get(map, :_links) end)
     |> List.flatten()
-    |> Stream.filter(fn links -> links != nil end)
-    |> Stream.uniq()
+    |> Enum.filter(fn links -> links != nil end)
+    # We need to de-duplicate by group and type, and merge the attribute_keys sets for each
+    # First group_by
+    |> Enum.group_by(fn link -> {link[:group], link[:type]} end)
+    # Next use reduce to merge each group
+    |> Enum.reduce(
+      [],
+      fn {_group, group_links}, acc ->
+        group_link =
+          Enum.reduce(
+            group_links,
+            fn link, link_acc ->
+              Map.update(
+                link_acc,
+                :attribute_keys,
+                MapSet.new(),
+                fn attribute_keys ->
+                  MapSet.union(attribute_keys, link[:attribute_keys])
+                end
+              )
+            end
+          )
+
+        [group_link | acc]
+      end
+    )
     |> Enum.to_list()
   end
 
@@ -158,7 +182,7 @@ defmodule Schema.Utils do
   # Adds attribute's used-by links to the dictionary.
   defp add_common_links(dict, class) do
     Map.update!(dict, :attributes, fn attributes ->
-      link = {:common, class[:name], class[:caption]}
+      link = %{group: :common, type: class[:name], caption: class[:caption]}
 
       update_attributes(
         class,
@@ -177,7 +201,7 @@ defmodule Schema.Utils do
           _ -> Atom.to_string(name)
         end
 
-      link = {:class, type, class[:caption] || "*No name*"}
+      link = %{group: :class, type: type, caption: class[:caption] || "*No name*"}
 
       update_attributes(
         class,
@@ -190,14 +214,13 @@ defmodule Schema.Utils do
 
   defp update_dictionary_links(item, link) do
     Map.update(item, :_links, [link], fn links ->
-      [{_, id, _} | _] = links
-      if id > 0, do: [link | links], else: links
+      [link | links]
     end)
   end
 
   defp add_object_links(dict, {name, obj}) do
     Map.update!(dict, :attributes, fn dictionary ->
-      link = {:object, Atom.to_string(name), obj[:caption] || "*No name*"}
+      link = %{group: :object, type: Atom.to_string(name), caption: obj[:caption] || "*No name*"}
       update_attributes(obj, dictionary, link, &update_object_links/2)
     end)
   end
@@ -212,26 +235,39 @@ defmodule Schema.Utils do
     name = item[:caption]
     attributes = item[:attributes]
 
-    Enum.reduce(attributes, dictionary, fn {k, v}, acc ->
-      case find_entity(acc, item, k) do
+    Enum.reduce(attributes, dictionary, fn {attribute_key, attribute_map}, acc ->
+      link =
+        Map.update(
+          link,
+          :attribute_keys,
+          MapSet.new([attribute_key]),
+          fn attribute_keys ->
+            MapSet.put(attribute_keys, attribute_key)
+          end
+        )
+
+      case find_entity(acc, item, attribute_key) do
         {_, nil} ->
-          case String.split(Atom.to_string(v[:_source]), "/") do
+          case String.split(Atom.to_string(attribute_map[:_source]), "/") do
             [ext, _] ->
-              ext_key = String.to_atom("#{ext}/#{k}")
+              ext_key = String.to_atom("#{ext}/#{attribute_key}")
 
               data =
                 case Map.get(acc, ext_key) do
                   nil ->
-                    update_links.(v, link)
+                    update_links.(attribute_map, link)
 
                   attr ->
-                    deep_merge(attr, v) |> update_links.(link)
+                    deep_merge(attr, attribute_map) |> update_links.(link)
                 end
 
               Map.put(acc, ext_key, data)
 
             _ ->
-              Logger.warning("'#{name}' uses undefined attribute: #{k}: #{inspect(v)}")
+              Logger.warning(
+                "'#{name}' uses undefined attribute: #{attribute_key}: #{inspect(attribute_map)}"
+              )
+
               acc
           end
 
diff --git a/lib/schema_web/controllers/schema_controller.ex b/lib/schema_web/controllers/schema_controller.ex
index 0961587..3e9db0a 100644
--- a/lib/schema_web/controllers/schema_controller.ex
+++ b/lib/schema_web/controllers/schema_controller.ex
@@ -81,7 +81,7 @@ defmodule SchemaWeb.SchemaController do
             category(:string, "Class category", required: true)
             category_name(:string, "Class category caption", required: true)
             profiles(:array, "Class profiles", items: %PhoenixSwagger.Schema{type: :string})
-            uid(:integer, "Class unique indentifier", required: true)
+            uid(:integer, "Class unique identifier", required: true)
           end
 
           example([
@@ -168,32 +168,40 @@ defmodule SchemaWeb.SchemaController do
 
   @spec versions(Plug.Conn.t(), any) :: Plug.Conn.t()
   def versions(conn, _params) do
-
     url = Application.get_env(:schema_server, SchemaWeb.Endpoint)[:url]
 
     # The :url key is meant to be set for production, but isn't set for local development
-    base_url = if url == nil do
-      "#{conn.scheme}://#{conn.host}:#{conn.port}"
-    else
-      "#{conn.scheme}://#{Keyword.fetch!(url, :host)}:#{Keyword.fetch!(url, :port)}"
-    end
+    base_url =
+      if url == nil do
+        "#{conn.scheme}://#{conn.host}:#{conn.port}"
+      else
+        "#{conn.scheme}://#{Keyword.fetch!(url, :host)}:#{Keyword.fetch!(url, :port)}"
+      end
 
-    available_versions = Schemas.versions()
-    |> Enum.map(fn {version, _} -> version end)
+    available_versions =
+      Schemas.versions()
+      |> Enum.map(fn {version, _} -> version end)
 
-    default_version = %{:version => Schema.version(), :url => "#{base_url}/#{Schema.version()}/api"}
+    default_version = %{
+      :version => Schema.version(),
+      :url => "#{base_url}/#{Schema.version()}/api"
+    }
 
-    versions_response = case available_versions do
-      [] ->
-        # If there is no response, we only provide a single schema
-        %{:versions => [default_version], :default => default_version}
+    versions_response =
+      case available_versions do
+        [] ->
+          # If there is no response, we only provide a single schema
+          %{:versions => [default_version], :default => default_version}
 
-      [_head | _tail] ->
-        available_versions_objects = available_versions
-        |> Enum.map(fn version -> %{:version => version, :url => "#{base_url}/#{version}/api"} end)
-        %{:versions => available_versions_objects, :default => default_version}
+        [_head | _tail] ->
+          available_versions_objects =
+            available_versions
+            |> Enum.map(fn version ->
+              %{:version => version, :url => "#{base_url}/#{version}/api"}
+            end)
 
-    end
+          %{:versions => available_versions_objects, :default => default_version}
+      end
 
     send_json_resp(conn, versions_response)
   end
@@ -256,6 +264,7 @@ defmodule SchemaWeb.SchemaController do
       Enum.into(get_profiles(params), %{}, fn {k, v} ->
         {k, Schema.delete_links(v)}
       end)
+
     send_json_resp(conn, profiles)
   end
 
@@ -271,7 +280,7 @@ defmodule SchemaWeb.SchemaController do
   @doc """
   Get a profile by name.
   get /api/profiles/:name
-  get /api/profiles/:extention/:name
+  get /api/profiles/:extension/:name
   """
   swagger_path :profile do
     get("/api/profiles/{name}")
@@ -294,13 +303,15 @@ defmodule SchemaWeb.SchemaController do
 
   @spec profile(Plug.Conn.t(), map) :: Plug.Conn.t()
   def profile(conn, %{"id" => id} = params) do
-    name = case params["extension"] do
-      nil -> id
-      extension -> "#{extension}/#{id}"
-    end
+    name =
+      case params["extension"] do
+        nil -> id
+        extension -> "#{extension}/#{id}"
+      end
 
     try do
       data = Schema.profiles()
+
       case Map.get(data, name) do
         nil ->
           send_json_resp(conn, 404, %{error: "Profile #{name} not found"})
@@ -553,7 +564,7 @@ defmodule SchemaWeb.SchemaController do
   @doc """
   Get an object by name.
   get /api/objects/:name
-  get /api/objects/:extention/:name
+  get /api/objects/:extension/:name
   """
   swagger_path :object do
     get("/api/objects/{name}")
@@ -650,7 +661,7 @@ defmodule SchemaWeb.SchemaController do
   swagger_path :export_schema do
     get("/export/schema")
     summary("Export schema")
-    description("Get OCSF schema defintions, including data types, objects, and classes.")
+    description("Get OCSF schema definitions, including data types, objects, and classes.")
     produces("application/json")
     tag("Schema Export")
 
@@ -900,7 +911,9 @@ defmodule SchemaWeb.SchemaController do
         default: false
       )
 
-      data(:body, PhoenixSwagger.Schema.ref(:Event), "The event data to be enriched.", required: true)
+      data(:body, PhoenixSwagger.Schema.ref(:Event), "The event data to be enriched.",
+        required: true
+      )
     end
 
     response(200, "Success")
@@ -978,7 +991,9 @@ defmodule SchemaWeb.SchemaController do
         allowEmptyValue: true
       )
 
-      data(:body, PhoenixSwagger.Schema.ref(:Event), "The event data to be translated", required: true)
+      data(:body, PhoenixSwagger.Schema.ref(:Event), "The event data to be translated",
+        required: true
+      )
     end
 
     response(200, "Success")
@@ -1026,7 +1041,9 @@ defmodule SchemaWeb.SchemaController do
     tag("Tools")
 
     parameters do
-      data(:body, PhoenixSwagger.Schema.ref(:Event), "The event data to be validated", required: true)
+      data(:body, PhoenixSwagger.Schema.ref(:Event), "The event data to be validated",
+        required: true
+      )
     end
 
     response(200, "Success")
@@ -1082,7 +1099,7 @@ defmodule SchemaWeb.SchemaController do
   @doc """
   Returns randomly generated event sample data for the given name.
   get /sample/classes/:name
-  get /sample/classes/:extention/:name
+  get /sample/classes/:extension/:name
   """
   swagger_path :sample_class do
     get("/sample/classes/{name}")
@@ -1144,7 +1161,7 @@ defmodule SchemaWeb.SchemaController do
   @doc """
   Returns randomly generated object sample data for the given name.
   get /sample/objects/:name
-  get /sample/objects/:extention/:name
+  get /sample/objects/:extension/:name
   """
   swagger_path :sample_object do
     get("/sample/objects/{name}")
diff --git a/lib/schema_web/templates/layout/app.html.eex b/lib/schema_web/templates/layout/app.html.eex
index f6969a7..e499ff3 100644
--- a/lib/schema_web/templates/layout/app.html.eex
+++ b/lib/schema_web/templates/layout/app.html.eex
@@ -114,7 +114,7 @@ limitations under the License.
   <a class="navbar-brand" href="#">OCSF Schema</a>
 
   <nav class="navbar navbar-bg collapse navbar-collapse navbar-expand-md navbar-light fixed-left">
-    <a href=<%= Routes.static_path(@conn, "/?extensions=") %> onclick="reset_home_page()" class="navbar-brand ocsf-logo">
+    <a href="<%= Routes.static_path(@conn, "/?extensions=") %>" onclick="reset_home_page()" class="navbar-brand ocsf-logo">
       <img src='<%= Routes.static_path(@conn, "/images/ocsf-logo.png") %>' alt="OCSF"/>
     </a>
     <h6 class="container-fluid version">
diff --git a/lib/schema_web/templates/page/class.html.eex b/lib/schema_web/templates/page/class.html.eex
index 612de1a..b3a291e 100644
--- a/lib/schema_web/templates/page/class.html.eex
+++ b/lib/schema_web/templates/page/class.html.eex
@@ -93,7 +93,7 @@ limitations under the License.
         <% name = Atom.to_string(key) %>
         <tr class="<%= field_classes(field)%>">
           <td class="name"><%= raw format_attribute_caption(name, field) %></td>
-          <td data-toggle="tooltip" title="<%= field[:_source] %>"><%= raw format_attribute_name(name) %></td>
+          <td data-toggle="tooltip" title="<%= format_class_attribute_source(@data[:name], field) %>"><%= raw format_attribute_name(name) %></td>
           <td class="capitalize"><%= field[:group] %></td>
           <td class="capitalize"><%= format_requirement(field) %></td>
           <td class="extensions"><%= raw format_type(@conn, field) %></td>
diff --git a/lib/schema_web/templates/page/dictionary.html.eex b/lib/schema_web/templates/page/dictionary.html.eex
index 40e85ac..ef80a53 100644
--- a/lib/schema_web/templates/page/dictionary.html.eex
+++ b/lib/schema_web/templates/page/dictionary.html.eex
@@ -18,12 +18,19 @@ limitations under the License.
     </div>
   </div>
   <div class="col-md-auto fixed-right mt-2">
-    <div class="form-inline">
-      <ul class="navbar-nav">
-        <li class="nav-item">
-          <input type="text" id="tableSearch" onkeyup="searchInTable()" class="form-control border-dark" placeholder="Search" autofocus>
-        </li>
-      </ul>
+    <div class="navbar-expand-md">
+      <div class="form-inline">
+        <ul class="navbar-nav">
+          <li class="nav-item mr-2">
+            <button class="btn btn-outline-secondary dropdown-toggle" type="button" onclick="$('.multi-collapse').collapse('show');">Expand All</button>
+            <button class="btn btn-outline-secondary dropdown-toggle" type="button" onclick="$('.multi-collapse').collapse('hide');">Collapse All</button>
+            <br><small>Expand All and Collapse All are slow &mdash; be patient</small>
+          </li>
+          <li class="nav-item">
+            <input type="text" id="tableSearch" onkeyup="searchInTable()" class="form-control border-dark" placeholder="Search" autofocus>
+          </li>
+        </ul>
+      </div>
     </div>
   </div>
 </div>
@@ -46,7 +53,7 @@ limitations under the License.
           <td class="name"><%= raw format_caption(name, field) %></td>
           <td><%= format_attribute_name(name) %></td>
           <td class="extensions"><%= raw format_type(@conn, field) %></td>
-          <td class="extensions"><%= raw links(@conn, key, field[:_links]) %></td>
+          <td class="extensions"><%= raw dictionary_links(@conn, key, field[:_links]) %></td>
           <td><%= raw description(field) %></td>
         </tr>
       <% end %>
diff --git a/lib/schema_web/templates/page/object.html.eex b/lib/schema_web/templates/page/object.html.eex
index 3e13d24..a6e2e89 100644
--- a/lib/schema_web/templates/page/object.html.eex
+++ b/lib/schema_web/templates/page/object.html.eex
@@ -102,11 +102,9 @@
 <%= if Enum.empty?(links) do %>
   <div></div>
 <% else %>
-  <div class="links">
-    <h5>Referenced By</h5>
-    <div class="extensions">
-      <%= raw links(@conn, @data[:caption], links) %>
-    </div>
+  <a class="h5 links dropdown-toggle" data-toggle="collapse" data-target="#object-links" aria-expanded="false" aria-controls="object-links">Referenced By</a>
+  <div class="extensions collapse" id="object-links">
+    <%= raw object_links(@conn, @data[:name], links) %>
   </div>
 <% end %>
 <% constraints = @data[:constraints] %>
diff --git a/lib/schema_web/templates/page/objects.html.eex b/lib/schema_web/templates/page/objects.html.eex
index ca0e177..b9e4950 100644
--- a/lib/schema_web/templates/page/objects.html.eex
+++ b/lib/schema_web/templates/page/objects.html.eex
@@ -17,12 +17,18 @@ limitations under the License.
     </div>
   </div>
   <div class="col-md-auto fixed-right mt-2">
-    <div class="form-inline">
-      <ul class="navbar-nav">
-        <li class="nav-item">
-          <input type="text" id="tableSearch" onkeyup="searchInTable()" class="form-control border-dark" placeholder="Search" autofocus>
-        </li>
-      </ul>
+    <div class="navbar-expand-md">
+      <div class="form-inline">
+        <ul class="navbar-nav">
+          <li class="nav-item mr-2">
+            <button class="btn btn-outline-secondary dropdown-toggle" type="button" onclick="$('.multi-collapse').collapse('show');">Expand All</button>
+            <button class="btn btn-outline-secondary dropdown-toggle" type="button" onclick="$('.multi-collapse').collapse('hide');">Collapse All</button>
+          </li>
+          <li class="nav-item">
+            <input type="text" id="tableSearch" onkeyup="searchInTable()" class="form-control border-dark" placeholder="Search" autofocus>
+          </li>
+        </ul>
+      </div>
     </div>
   </div>
 </div>
@@ -44,7 +50,7 @@ limitations under the License.
         <tr class="ocsf-class" <%= raw format_profiles(map[:profiles])%>>
           <td class="name"><%= raw format_attribute_caption(name, map) %></td>
           <td class="extensions"><a href="<%= path %>"><%= name %></a></td>
-          <td class="extensions"><%= raw links(@conn, name, map[:_links]) %></td>
+          <td class="extensions"><%= raw object_links(@conn, map[:name], map[:_links], :collapse) %></td>
           <td><%= raw description(map) %></td>
         </tr>
       <% end %>
diff --git a/lib/schema_web/templates/page/profile.html.eex b/lib/schema_web/templates/page/profile.html.eex
index 6bcd271..07a4e8b 100644
--- a/lib/schema_web/templates/page/profile.html.eex
+++ b/lib/schema_web/templates/page/profile.html.eex
@@ -88,11 +88,9 @@
 <%= if Enum.empty?(links) do %>
   <div></div>
 <% else %>
-  <div class="links">
-    <h5>Referenced By</h5>
-    <div>
-      <%= raw links(@conn, @data[:caption], links) %>
-    </div>
+  <a class="h5 links dropdown-toggle" data-toggle="collapse" data-target="#profile-links" aria-expanded="false" aria-controls="object-links">Referenced By</a>
+  <div class="extensions collapse" id="profile-links">
+    <%= raw profile_links(@conn, @data[:name], links) %>
   </div>
 <% end %>
 <script>
diff --git a/lib/schema_web/templates/page/profiles.html.eex b/lib/schema_web/templates/page/profiles.html.eex
index b5ecb61..cad4100 100644
--- a/lib/schema_web/templates/page/profiles.html.eex
+++ b/lib/schema_web/templates/page/profiles.html.eex
@@ -17,12 +17,18 @@ limitations under the License.
     </div>
   </div>
   <div class="col-md-auto fixed-right mt-2">
-    <div class="form-inline">
-      <ul class="navbar-nav">
-        <li class="nav-item">
-          <input type="text" id="tableSearch" onkeyup="searchInTable()" class="form-control border-dark" placeholder="Search" autofocus>
-        </li>
-      </ul>
+    <div class="navbar-expand-md">
+      <div class="form-inline">
+        <ul class="navbar-nav">
+          <li class="nav-item mr-2">
+            <button class="btn btn-outline-secondary dropdown-toggle" type="button" onclick="$('.multi-collapse').collapse('show');">Expand All</button>
+            <button class="btn btn-outline-secondary dropdown-toggle" type="button" onclick="$('.multi-collapse').collapse('hide');">Collapse All</button>
+          </li>
+          <li class="nav-item">
+            <input type="text" id="tableSearch" onkeyup="searchInTable()" class="form-control border-dark" placeholder="Search" autofocus>
+          </li>
+        </ul>
+      </div>
     </div>
   </div>
 </div>
@@ -43,7 +49,7 @@ limitations under the License.
         <tr>
           <td class="name"><a href="<%= path %>"><%= raw format_caption(name, map) %></a></td>
           <td><a href="<%= path %>"><%= name %></a></td>
-          <td><%= raw links(@conn, name, map[:_links]) %></td>
+          <td><%= raw profile_links(@conn, map[:name], map[:_links], :collapse) %></td>
           <td><%= raw map[:description] %></td>
         </tr>
       <% end %>
diff --git a/lib/schema_web/views/page_view.ex b/lib/schema_web/views/page_view.ex
index 2f8c2d0..fe06e47 100644
--- a/lib/schema_web/views/page_view.ex
+++ b/lib/schema_web/views/page_view.ex
@@ -1,4 +1,5 @@
 defmodule SchemaWeb.PageView do
+  alias SchemaWeb.SchemaController
   use SchemaWeb, :view
 
   require Logger
@@ -52,14 +53,15 @@ defmodule SchemaWeb.PageView do
   end
 
   def class_profiles(conn, class, profiles) do
-    case (class[:profiles] || []) do
+    case class[:profiles] || [] do
       [] ->
         ""
+
       list ->
         [
           "<h5 class='mt-3'>Profiles</h5>",
           "Applicable profiles: ",
-          Stream.filter(list, fn profile -> Map.has_key?(profiles, profile)  end)
+          Stream.filter(list, fn profile -> Map.has_key?(profiles, profile) end)
           |> Enum.map_join(", ", fn name ->
             profile_link(conn, get_in(profiles, [name, :caption]), name)
           end),
@@ -122,6 +124,61 @@ defmodule SchemaWeb.PageView do
     Path.basename(name)
   end
 
+  @spec format_class_attribute_source(String.t(), map()) :: String.t()
+  def format_class_attribute_source(class_name, field) do
+    all_classes = Schema.all_classes()
+    source = field[:_source]
+    {ok, path} = build_class_hierarchy(Schema.Utils.to_uid(class_name), source, all_classes)
+
+    if ok do
+      format_class_hierarchy(path, all_classes)
+    else
+      to_string(source)
+    end
+  end
+
+  # Build a class hierarchy path from class to parent_class.
+  # Returns {true, path} when a path is found, and {false, []} otherwise.
+  @spec build_class_hierarchy(atom(), atom(), map(), list()) :: {boolean(), list()}
+  defp build_class_hierarchy(
+         class,
+         parent_class,
+         all_classes,
+         path_result \\ []
+       ) do
+    cond do
+      class == nil ->
+        {false, []}
+
+      class == parent_class ->
+        {true, [class | path_result]}
+
+      true ->
+        build_class_hierarchy(
+          Schema.Utils.to_uid(all_classes[class][:extends]),
+          parent_class,
+          all_classes,
+          [class | path_result]
+        )
+    end
+  end
+
+  defp format_class_hierarchy(path, all_classes) do
+    Enum.map(
+      path,
+      fn class ->
+        class_info = all_classes[class]
+
+        if class_info[:hidden?] do
+          [all_classes[class][:caption], " (hidden class)"]
+        else
+          all_classes[class][:caption]
+        end
+      end
+    )
+    |> Enum.intersperse(" ← ")
+  end
+
   @spec format_range([nil | number | Decimal.t(), ...]) :: nonempty_binary
   def format_range([min, max]) do
     format_number(min) <> "-" <> format_number(max)
@@ -251,7 +308,7 @@ defmodule SchemaWeb.PageView do
         end
 
       r ->
-        max_len <> "</br>" <> r
+        max_len <> "<br>" <> r
     end
   end
 
@@ -372,16 +429,16 @@ defmodule SchemaWeb.PageView do
     [
       "At least one attribute must be present: <strong>",
       Enum.join(list, ", "),
-      "</strong><br/>" | acc
+      "</strong><br>" | acc
     ]
   end
 
   def constraints(:just_one, list, acc) do
-    ["Only one attribute can be present: <strong>", Enum.join(list, ", "), "</strong><br/>" | acc]
+    ["Only one attribute can be present: <strong>", Enum.join(list, ", "), "</strong><br>" | acc]
   end
 
   def constraints(name, list, acc) do
-    [Atom.to_string(name), ": <strong>", Enum.join(list, ", "), "</strong><br/>" | acc]
+    [Atom.to_string(name), ": <strong>", Enum.join(list, ", "), "</strong><br>" | acc]
   end
 
   def associations(rules) do
@@ -391,91 +448,583 @@ defmodule SchemaWeb.PageView do
   end
 
   def associations(name, list, acc) do
-    [Atom.to_string(name), ": ", Enum.join(list, ", "), "<br/>" | acc]
+    [Atom.to_string(name), ": ", Enum.join(list, ", "), "<br>" | acc]
   end
 
-  def links(_, _, nil), do: ""
-  def links(_, _, []), do: ""
-
-  def links(conn, name, links) do
-    groups =
-      Enum.group_by(
-        links,
-        fn
-          {type, _link, _name} ->
-            type
-
-          nil ->
-            Logger.warning("group-by: found unused attribute of '#{name}' object")
-            nil
-        end
-      )
-
-    join_html(
-      to_html(:commons, conn, groups[:common]),
-      to_html(:classes, conn, groups[:class]),
-      to_html(:objects, conn, groups[:object])
+  defp reverse_sort_links(links) do
+    Enum.sort(
+      links,
+      fn link1, link2 ->
+        link1[:group] >= link2[:group] and link1[:caption] >= link2[:caption]
+      end
     )
   end
 
-  defp join_html(commons, [], []), do: commons
-  defp join_html([], classes, []), do: classes
-  defp join_html(commons, _classes, []), do: commons
-  defp join_html(_, [], objects), do: objects
-  defp join_html([], classes, objects), do: [classes, "<hr/>", objects]
-  defp join_html(commons, _classes, objects), do: [commons, "<hr/>", objects]
+  defp collapse_html(collapse_id, text, items) do
+    [
+      "<a class=\"dropdown-toggle\" data-toggle=\"collapse\" data-target=\"#",
+      collapse_id,
+      "\" aria-expanded=\"false\" aria-controls=\"",
+      collapse_id,
+      "\">",
+      text,
+      "</a><br>",
+      "<div class=\"collapse multi-collapse\" id=\"",
+      collapse_id,
+      "\">",
+      items,
+      "</div>"
+    ]
+  end
 
-  defp to_html(_, _, nil), do: []
+  @spec dictionary_links(any(), String.t(), list(Schema.Cache.link_t())) :: <<>> | list()
+  def dictionary_links(_, _, nil), do: ""
+  def dictionary_links(_, _, []), do: ""
 
-  defp to_html(:commons, conn, classes) do
-    Enum.sort(
-      classes,
-      fn {type1, _, name1}, {type2, _, name2} ->
-        type1 >= type2 and name1 >= name2
-      end
-    )
-    |> Enum.reduce(
-      [],
-      fn _, acc ->
-        type_path = SchemaWeb.Router.Helpers.static_path(conn, "/base_event")
-        ["<a href='", type_path, "'>", " Base Event</a>", ", " | acc]
+  def dictionary_links(conn, attribute_name, links) do
+    groups = Enum.group_by(links, fn link -> link[:group] end)
+
+    commons_html = dictionary_links_common_to_html(conn, groups[:common])
+
+    classes_html =
+      if Enum.empty?(commons_html) do
+        dictionary_links_class_to_html(conn, attribute_name, groups[:class])
+      else
+        Enum.intersperse(
+          [
+            "Referenced by all classes",
+            dictionary_links_class_updated_to_html(conn, attribute_name, groups[:class])
+          ],
+          "<br>"
+        )
       end
-    )
-    |> List.delete_at(-1)
+
+    objects_html = links_object_to_html(conn, attribute_name, groups[:object], :collapse)
+
+    Enum.reject([commons_html, classes_html, objects_html], &Enum.empty?/1)
+    |> Enum.intersperse("<hr>")
   end
 
-  defp to_html(:classes, conn, classes) do
-    Enum.sort(
-      classes,
-      fn {type1, _, name1}, {type2, _, name2} ->
-        type1 >= type2 and name1 >= name2
-      end
-    )
+  defp dictionary_links_common_to_html(_, nil), do: []
+
+  defp dictionary_links_common_to_html(conn, linked_classes) do
+    reverse_sort_links(linked_classes)
     |> Enum.reduce(
       [],
-      fn {_type, link, name}, acc ->
-        type_path = SchemaWeb.Router.Helpers.static_path(conn, "/classes/" <> link)
-        ["<a href='", type_path, "'>", name, " Event</a>", ", " | acc]
+      fn _link, acc ->
+        [
+          [
+            "<a href=\"",
+            SchemaWeb.Router.Helpers.static_path(conn, "/base_event"),
+            "\" data-toggle=\"tooltip\ title=\"Directly referenced\">Base Event Class</a>"
+          ]
+          | acc
+        ]
       end
     )
-    |> List.delete_at(-1)
+    |> Enum.intersperse("<br>")
   end
 
-  defp to_html(:objects, conn, objects) do
-    Enum.sort(
-      objects,
-      fn {type1, _, name1}, {type2, _, name2} ->
-        type1 >= type2 and name1 >= name2
-      end
-    )
+  defp dictionary_links_class_to_html(_, _, nil), do: []
+
+  defp dictionary_links_class_to_html(conn, attribute_name, linked_classes) do
+    classes = SchemaController.classes(conn.params())
+    all_classes = Schema.all_classes()
+    attribute_key = Schema.Utils.to_uid(attribute_name)
+
+    html_list =
+      reverse_sort_links(linked_classes)
+      |> Enum.reduce(
+        [],
+        fn link, acc ->
+          type_path = SchemaWeb.Router.Helpers.static_path(conn, "/classes/" <> link[:type])
+          class_key = Schema.Utils.to_uid(link[:type])
+          source = classes[class_key][:attributes][attribute_key][:_source]
+
+          cond do
+            source == nil ->
+              # This means the attribute's :_source is incorrectly missing. Show with warning.
+              [
+                [
+                  "<a href=\"",
+                  type_path,
+                  "\" data-toggle=\"tooltip\" title=\"No source\">",
+                  link[:caption],
+                  " Class</a> <span class=\"bg-warning\">No source</span>"
+                ]
+                | acc
+              ]
+
+            source == class_key ->
+              [
+                [
+                  "<a href=\"",
+                  type_path,
+                  "\" data-toggle=\"tooltip\" title=\"Directly referenced\">",
+                  link[:caption],
+                  " Class</a>"
+                ]
+                | acc
+              ]
+
+            true ->
+              # Any indirect situation, including through hidden classes
+              {ok, path} = build_class_hierarchy(class_key, source, all_classes)
+
+              if ok do
+                [
+                  [
+                    "<a href=\"",
+                    type_path,
+                    "\" data-toggle=\"tooltip\" title=\"Indirectly referenced: ",
+                    format_class_hierarchy(path, all_classes),
+                    "\">",
+                    link[:caption],
+                    " Class</a>"
+                  ]
+                  | acc
+                ]
+              else
+                # This means there's a bad class hierarchy. Show with warning.
+                [
+                  [
+                    "<a href=\"",
+                    type_path,
+                    "\" data-toggle=\"tooltip\" title=\"Referenced via unknown parent\">",
+                    link[:caption],
+                    " Class</a> <span class=\"bg-warning\">Unknown parent</span>"
+                  ]
+                  | acc
+                ]
+              end
+          end
+        end
+      )
+
+    if Enum.empty?(html_list) do
+      []
+    else
+      noun_text = if length(html_list) == 1, do: " class", else: " classes"
+
+      collapse_html(
+        ["class-links-", to_string(attribute_name)],
+        ["Referenced by ", Integer.to_string(length(html_list)), noun_text],
+        Enum.intersperse(html_list, "<br>")
+      )
+    end
+  end
+
+  defp dictionary_links_class_updated_to_html(_, _, nil), do: []
+
+  defp dictionary_links_class_updated_to_html(conn, attribute_name, linked_classes) do
+    classes = SchemaController.classes(conn.params())
+    all_classes = Schema.all_classes()
+    attribute_key = Schema.Utils.to_uid(attribute_name)
+
+    html_list =
+      reverse_sort_links(linked_classes)
+      |> Enum.reduce(
+        [],
+        fn link, acc ->
+          class_key = Schema.Utils.to_uid(link[:type])
+
+          type_path = SchemaWeb.Router.Helpers.static_path(conn, "/classes/" <> link[:type])
+          source = classes[class_key][:attributes][attribute_key][:_source]
+
+          cond do
+            source == nil ->
+              # This means the attribute's :_source is incorrectly missing. Show with warning.
+              [
+                [
+                  "<a href=\"",
+                  type_path,
+                  "\" data-toggle=\"tooltip\" title=\"No source\">",
+                  link[:caption],
+                  " Class</a> <span class=\"bg-warning\">No source</span>"
+                ]
+                | acc
+              ]
+
+            source == :base_event ->
+              # Skip base_event source:
+              #   - Reduces noise
+              #   - It is redundant with showing Base Event Class separately
+              acc
+
+            source == class_key ->
+              [
+                [
+                  "<a href=\"",
+                  type_path,
+                  "\" data-toggle=\"tooltip\" title=\"Directly updated\">",
+                  link[:caption],
+                  " Class</a>"
+                ]
+                | acc
+              ]
+
+            true ->
+              # Any indirect situation, including through hidden classes
+              {ok, path} = build_class_hierarchy(class_key, source, all_classes)
+
+              if ok do
+                [
+                  [
+                    "<a href=\"",
+                    type_path,
+                    "\" data-toggle=\"tooltip\" title=\"Indirectly updated: ",
+                    format_class_hierarchy(path, all_classes),
+                    "\">",
+                    link[:caption],
+                    " Class</a>"
+                  ]
+                  | acc
+                ]
+              else
+                # This means there's a bad class hierarchy. Show with warning.
+                [
+                  [
+                    "<a href=\"",
+                    type_path,
+                    "\" data-toggle=\"tooltip\" title=\"Updated via unknown parent\">",
+                    link[:caption],
+                    " Class</a> <span class=\"bg-warning\">Unknown parent</span>"
+                  ]
+                  | acc
+                ]
+              end
+          end
+        end
+      )
+
+    if Enum.empty?(html_list) do
+      []
+    else
+      noun_text = if length(html_list) == 1, do: " class", else: " classes"
+
+      collapse_html(
+        ["class-links-", to_string(attribute_name)],
+        [
+          "Updated in ",
+          Integer.to_string(length(html_list)),
+          noun_text
+        ],
+        Enum.intersperse(html_list, "<br>")
+      )
+    end
+  end
+
+  # Used by dictionary_links and profile_links
+  defp links_object_to_html(_, _, nil, _), do: []
+
+  defp links_object_to_html(conn, name, linked_objects, list_presentation) do
+    html_list =
+      reverse_sort_links(linked_objects)
+      |> Enum.reduce(
+        [],
+        fn link, acc ->
+          [
+            [
+              "<a href=\"",
+              SchemaWeb.Router.Helpers.static_path(conn, "/objects/" <> link[:type]),
+              "\">",
+              link[:caption],
+              " Object</a>"
+            ]
+            | acc
+          ]
+        end
+      )
+
+    cond do
+      Enum.empty?(html_list) ->
+        []
+
+      list_presentation == :collapse ->
+        noun_text = if length(html_list) == 1, do: " object", else: " objects"
+
+        collapse_html(
+          ["object-links-", to_string(name)],
+          ["Referenced by ", Integer.to_string(length(html_list)), noun_text],
+          Enum.intersperse(html_list, "<br>")
+        )
+
+      true ->
+        Enum.intersperse(html_list, "<br>")
+    end
+  end
+
+  @spec object_links(any(), String.t(), list(Schema.Cache.link_t()), nil | :collapse) ::
+          <<>> | list()
+  def object_links(conn, name, links, list_presentation \\ nil)
+  def object_links(_, _, nil, _), do: ""
+  def object_links(_, _, [], _), do: ""
+
+  def object_links(conn, name, links, list_presentation) do
+    groups = Enum.group_by(links, fn link -> link[:group] end)
+
+    commons_html = object_links_common_to_html(conn, groups[:common], list_presentation)
+    classes_html = object_links_class_to_html(conn, name, groups[:class], list_presentation)
+    objects_html = object_links_object_to_html(conn, name, groups[:object], list_presentation)
+
+    Enum.reject([commons_html, classes_html, objects_html], &Enum.empty?/1)
+    |> Enum.intersperse("<hr>")
+  end
+
+  defp link_attributes(link) do
+    attribute_keys = link[:attribute_keys]
+    attribute_keys_size = if attribute_keys == nil, do: 0, else: MapSet.size(attribute_keys)
+
+    case attribute_keys_size do
+      0 ->
+        "No attributes"
+
+      1 ->
+        ["Attribute: ", to_string(Enum.at(attribute_keys, 0))]
+
+      _ ->
+        ["Attributes: ", Enum.intersperse(Enum.map(attribute_keys, &to_string/1), ", ")]
+    end
+  end
+
+  defp object_links_common_to_html(_, nil, _), do: []
+
+  defp object_links_common_to_html(conn, linked_classes, list_presentation) do
+    html_list =
+      reverse_sort_links(linked_classes)
+      |> Enum.reduce(
+        [],
+        fn link, acc ->
+          type_path =
+            if link[:type] == "base_event" do
+              SchemaWeb.Router.Helpers.static_path(conn, "/base_event")
+            else
+              SchemaWeb.Router.Helpers.static_path(conn, "/classes/" <> link[:type])
+            end
+
+          [
+            if list_presentation == :collapse do
+              [
+                "<a href=\"",
+                type_path,
+                "\" data-toggle=\"tooltip\" title=\"",
+                link_attributes(link),
+                "\">",
+                link[:caption],
+                " Class</a>"
+              ]
+            else
+              [
+                "<dt><a href=\"",
+                type_path,
+                "\">",
+                link[:caption],
+                " Class</a><dd class=\"ml-3\">",
+                link_attributes(link)
+              ]
+            end
+            | acc
+          ]
+        end
+      )
+
+    cond do
+      Enum.empty?(html_list) ->
+        []
+
+      list_presentation == :collapse ->
+        Enum.intersperse(html_list, "<br>")
+
+      true ->
+        ["<dl class=\"m-0\">", html_list, "</dl>"]
+    end
+  end
+
+  defp object_links_class_to_html(_, _, nil, _), do: []
+
+  defp object_links_class_to_html(conn, name, linked_classes, list_presentation) do
+    html_list =
+      reverse_sort_links(linked_classes)
+      |> Enum.reduce(
+        [],
+        fn link, acc ->
+          type_path = SchemaWeb.Router.Helpers.static_path(conn, "/classes/" <> link[:type])
+
+          [
+            if list_presentation == :collapse do
+              [
+                "<a href=\"",
+                type_path,
+                "\" data-toggle=\"tooltip\" title=\"",
+                link_attributes(link),
+                "\">",
+                link[:caption],
+                " Class</a>"
+              ]
+            else
+              [
+                "<dt><a href=\"",
+                type_path,
+                "\">",
+                link[:caption],
+                " Class</a><dd class=\"ml-3\">",
+                link_attributes(link)
+              ]
+            end
+            | acc
+          ]
+        end
+      )
+
+    cond do
+      Enum.empty?(html_list) ->
+        []
+
+      list_presentation == :collapse ->
+        noun_text = if length(html_list) == 1, do: " class", else: " classes"
+
+        collapse_html(
+          ["class-links-", to_string(name)],
+          ["Referenced by ", Integer.to_string(length(html_list)), noun_text],
+          Enum.intersperse(html_list, "<br>")
+        )
+
+      true ->
+        ["<dl class=\"m-0\">", html_list, "</dl>"]
+    end
+  end
+
+  defp object_links_object_to_html(_, _, nil, _), do: []
+
+  defp object_links_object_to_html(conn, name, linked_objects, list_presentation) do
+    html_list =
+      reverse_sort_links(linked_objects)
+      |> Enum.reduce(
+        [],
+        fn link, acc ->
+          type_path = SchemaWeb.Router.Helpers.static_path(conn, "/objects/" <> link[:type])
+
+          [
+            if list_presentation == :collapse do
+              [
+                "<a href=\"",
+                type_path,
+                "\" data-toggle=\"tooltip\" title=\"",
+                link_attributes(link),
+                "\">",
+                link[:caption],
+                " Object</a>"
+              ]
+            else
+              [
+                "<dt><a href=\"",
+                type_path,
+                "\">",
+                link[:caption],
+                " Object</a><dd class=\"ml-3\">",
+                link_attributes(link)
+              ]
+            end
+            | acc
+          ]
+        end
+      )
+
+    cond do
+      Enum.empty?(html_list) ->
+        []
+
+      list_presentation == :collapse ->
+        noun_text = if length(html_list) == 1, do: " object", else: " objects"
+
+        collapse_html(
+          ["object-links-", to_string(name)],
+          ["Referenced by ", Integer.to_string(length(html_list)), noun_text],
+          Enum.intersperse(html_list, "<br>")
+        )
+
+      true ->
+        ["<dl class=\"m-0\">", html_list, "</dl>"]
+    end
+  end
+
+  @spec profile_links(any(), String.t(), list(Schema.Cache.link_t()), nil | :collapse) ::
+          <<>> | list()
+  def profile_links(conn, profile_name, links, list_presentation \\ nil)
+  def profile_links(_, _, nil, _), do: ""
+  def profile_links(_, _, [], _), do: ""
+
+  def profile_links(conn, profile_name, links, list_presentation) do
+    groups = Enum.group_by(links, fn link -> link[:group] end)
+
+    commons_html = profile_links_common_to_html(conn, groups[:common])
+
+    classes_html =
+      profile_links_class_to_html(conn, profile_name, groups[:class], list_presentation)
+
+    objects_html = links_object_to_html(conn, profile_name, groups[:object], list_presentation)
+
+    Enum.reject([commons_html, classes_html, objects_html], &Enum.empty?/1)
+    |> Enum.intersperse("<hr>")
+  end
+
+  defp profile_links_common_to_html(_, nil), do: []
+
+  defp profile_links_common_to_html(conn, linked_classes) do
+    reverse_sort_links(linked_classes)
     |> Enum.reduce(
       [],
-      fn {_type, link, name}, acc ->
-        type_path = SchemaWeb.Router.Helpers.static_path(conn, "/objects/" <> link)
-        ["<a href='", type_path, "'>", name, " Object</a>", ", " | acc]
+      fn _link, acc ->
+        [
+          [
+            "<a href=\"",
+            SchemaWeb.Router.Helpers.static_path(conn, "/base_event"),
+            "\">Base Event Class</a>"
+          ]
+          | acc
+        ]
       end
     )
-    |> List.delete_at(-1)
+    |> Enum.intersperse("<br>")
+  end
+
+  defp profile_links_class_to_html(_, _, nil, _), do: []
+
+  defp profile_links_class_to_html(conn, profile_name, linked_classes, list_presentation) do
+    html_list =
+      reverse_sort_links(linked_classes)
+      |> Enum.reduce(
+        [],
+        fn link, acc ->
+          [
+            [
+              "<a href=\"",
+              SchemaWeb.Router.Helpers.static_path(conn, "/classes/" <> link[:type]),
+              "\">",
+              link[:caption],
+              " Class</a>"
+            ]
+            | acc
+          ]
+        end
+      )
+
+    cond do
+      Enum.empty?(html_list) ->
+        []
+
+      list_presentation == :collapse ->
+        noun_text = if length(html_list) == 1, do: " class", else: " classes"
+
+        collapse_html(
+          ["class-links-", to_string(profile_name)],
+          ["Referenced by ", Integer.to_string(length(html_list)), noun_text],
+          Enum.intersperse(html_list, "<br>")
+        )
+
+      true ->
+        Enum.intersperse(html_list, "<br>")
+    end
   end
 
   defp format_number(n) do
@@ -499,5 +1048,4 @@ defmodule SchemaWeb.PageView do
       Map.get(deprecated, :message)
     ]
   end
-
 end
diff --git a/lib/schemas.ex b/lib/schemas.ex
index 278f387..3a3f5e5 100644
--- a/lib/schemas.ex
+++ b/lib/schemas.ex
@@ -39,9 +39,9 @@ defmodule Schemas do
   @doc """
   Returns a list of schemas is the given directory.
 
-  Returns {:ok, list} in case of success, {:error, reason} otherwise.
+  Returns list of {version, path} tuples in case of success, {:error, reason} otherwise.
   """
-  @spec ls(Path.t()) :: {:ok, list()} | {:error, File.posix()}
+  @spec ls(Path.t()) :: list({String.t(), String.t()}) | {:error, File.posix()}
   def ls(path) do
     with {:ok, list} <- File.ls(path) do
       Stream.map(list, fn name ->
diff --git a/mix.exs b/mix.exs
index 41c900f..f95b0a1 100644
--- a/mix.exs
+++ b/mix.exs
@@ -10,7 +10,7 @@
 defmodule Schema.MixProject do
   use Mix.Project
 
-  @version "2.67.0"
+  @version "2.68.0"
 
   def project do
     build = System.get_env("GITHUB_RUN_NUMBER") || "SNAPSHOT"