gemstar 1.0.4 → 1.1

data/lib/gemstar/web/app.rb

@@ -13,6 +13,7 @@ module Gemstar
   module Web
     class App < Roda
       MISSING_METADATA = Object.new
+      CACHE_VERSION = "v6"
 
       class << self
         def build(projects:, config_home:, cache_warmer: nil)
@@ -44,6 +45,16 @@ module Gemstar
           end
         end
 
+        r.get "favicon.svg" do
+          response["Content-Type"] = "image/svg+xml; charset=utf-8"
+          favicon_svg
+        end
+
+        r.get "favicon.ico" do
+          response["Content-Type"] = "image/svg+xml; charset=utf-8"
+          favicon_svg
+        end
+
         r.get "detail" do
           request_cache_key = detail_request_cache_key(r.params)
           request_cache = self.class.opts[:detail_request_cache]
@@ -62,7 +73,7 @@ module Gemstar
           project_index = selected_project_index(r.params["project"])
           project = @projects[project_index]
           response.status = 404
-          next "Gemfile not found" unless project && File.file?(project.gemfile_path)
+          next "Gemfile not found" unless project&.gemfile?
 
           response["Content-Type"] = "text/plain; charset=utf-8"
           File.read(project.gemfile_path)
@@ -86,23 +97,39 @@ module Gemstar
         project = @projects[project_index]
         return nil unless project
 
-        lockfile_stamp =
-          if File.file?(project.lockfile_path)
-            File.mtime(project.lockfile_path).to_i
-          else
-            0
-          end
+        lockfile_stamp = File.file?(project.lockfile_path) ? File.mtime(project.lockfile_path).to_i : 0
+        importmap_stamp = File.file?(project.importmap_path) ? File.mtime(project.importmap_path).to_i : 0
+        importmap_vendor_stamp = importmap_vendor_mtime(project)
+        package_lock_stamp = File.file?(project.package_lock_path) ? File.mtime(project.package_lock_path).to_i : 0
 
         [
+          CACHE_VERSION,
           project_index,
           params["from"],
           params["to"],
           params["filter"],
-          params["gem"],
-          lockfile_stamp
+          params["scope"],
+          package_param(params),
+          lockfile_stamp,
+          importmap_stamp,
+          importmap_vendor_stamp,
+          package_lock_stamp
         ]
       end
 
+      def importmap_vendor_mtime(project)
+        return 0 unless project&.importmap?
+
+        project.current_importmap.specs.values.filter_map do |target|
+          next unless target.to_s.end_with?(".js", ".mjs")
+
+          path = File.join(project.directory, "vendor", "javascript", target.to_s)
+          File.mtime(path).to_i if File.file?(path)
+        end.max || 0
+      rescue StandardError
+        0
+      end
+
       def page_title
         return "Gemstar" unless @selected_project
 
@@ -117,9 +144,15 @@ module Gemstar
         @selected_from_revision_id = selected_from_revision_id(params["from"])
         @selected_to_revision_id = selected_to_revision_id(@selected_to_revision_id)
         @gem_states = @selected_project ? @selected_project.gem_states(from_revision_id: @selected_from_revision_id, to_revision_id: @selected_to_revision_id) : []
-        @requested_gem_name = params["gem"]
-        @selected_filter = selected_filter(params["filter"], params["gem"])
-        @selected_gem = selected_gem_state(params["gem"])
+        requested_package_name = package_param(params)
+        @requested_gem_name = requested_package_name
+        @selected_package_scope = selected_package_scope(params["scope"], requested_package_name)
+        @selected_filter = selected_filter(params["filter"], requested_package_name)
+        @selected_gem = selected_gem_state(requested_package_name)
+      end
+
+      def package_param(params)
+        params["package"] || params["gem"]
       end
 
       def prioritize_selected_gem
@@ -167,10 +200,24 @@ module Gemstar
         @gem_states.any? { |gem| gem[:status] != :unchanged } ? "updated" : "all"
       end
 
+      def selected_package_scope(raw_scope, raw_gem_name)
+        return "all" if @gem_states.empty?
+
+        available_scopes = available_package_scopes
+        default_scope = available_scopes == ["gems"] ? "gems" : "all"
+        return raw_scope if raw_scope == "all" || available_scopes.include?(raw_scope)
+
+        selected_gem = @gem_states.find { |gem| gem[:name] == raw_gem_name }
+        return selected_gem[:package_scope] if selected_gem
+
+        default_scope
+      end
+
       def selected_gem_state(raw_gem_name)
         return nil if @gem_states.empty?
 
-        exact_match = @gem_states.find { |gem| gem[:name] == raw_gem_name }
+        exact_match = @gem_states.find { |gem| gem[:name] == raw_gem_name && gem_visible_in_selected_scope?(gem) }
+        exact_match ||= @gem_states.find { |gem| gem[:name] == raw_gem_name }
         return exact_match if exact_match
 
         @gem_states.find { |gem| gem_visible_in_selected_filter?(gem) && gem[:status] != :unchanged } ||
@@ -180,11 +227,20 @@ module Gemstar
       end
 
       def gem_visible_in_selected_filter?(gem_state)
+        return false unless gem_visible_in_selected_scope?(gem_state)
         return true if @selected_filter != "updated"
 
         gem_state[:status] != :unchanged
       end
 
+      def gem_visible_in_selected_scope?(gem_state)
+        @selected_package_scope == "all" || gem_state[:package_scope] == @selected_package_scope
+      end
+
+      def available_package_scopes
+        @selected_project ? @selected_project.package_scope_options.map { |option| option[:id] } : []
+      end
+
       def render_shell
         return render_empty_workspace if @projects.empty?
 
@@ -322,7 +378,7 @@ module Gemstar
             #{render_toolbar}
             <div class="workspace-body">
               #{render_sidebar}
-              #{render_detail}
+              #{render_initial_detail}
             </div>
           </main>
         HTML
@@ -332,7 +388,7 @@ module Gemstar
         <<~HTML
           <section class="toolbar">
             <div class="toolbar-meta">
-              <strong>#{@gem_states.count}</strong> gems
+              <strong>#{@gem_states.count}</strong> #{h(@selected_project&.package_collection_label&.downcase || "packages")}
               <span>·</span>
               <strong>#{@gem_states.count { |gem| gem[:status] != :unchanged }}</strong> changes from #{h(selected_from_revision_label)} to #{h(selected_to_revision_label)}
             </div>
@@ -357,17 +413,18 @@ module Gemstar
           <aside class="sidebar" data-sidebar-panel tabindex="0">
             <div class="sidebar-header">
               <div class="sidebar-header-row">
-                <h2>Gems</h2>
+                <h2>#{h(@selected_project&.package_collection_label || "Packages")}</h2>
                 <div class="list-filters" data-list-filters>
                   <button type="button" class="list-filter-button#{' is-active' if @selected_filter == "updated"}" data-filter-button="updated">Updated</button>
                   <button type="button" class="list-filter-button#{' is-active' if @selected_filter == "all"}" data-filter-button="all">All</button>
                 </div>
               </div>
+              #{render_package_scope_filters}
               <input
                 type="search"
                 class="gem-search"
                 data-gem-search
-                placeholder="Filter gems"
+                placeholder="Search"
                 autocomplete="off"
                 spellcheck="false"
               >
@@ -380,7 +437,7 @@ module Gemstar
       def render_gem_list
         return <<~HTML if @gem_states.empty?
           <section class="empty-panel">
-            <p>No gems found in the current lockfile.</p>
+            <p>No #{h(@selected_project&.package_collection_label&.downcase || "packages")} found in the current lockfile.</p>
           </section>
         HTML
 
@@ -388,19 +445,23 @@ module Gemstar
           selected = gem[:name] == @selected_gem[:name] ? " is-selected" : ""
           status_class = " status-#{gem[:status]}"
           updated = gem[:status] != :unchanged
-          hidden = @selected_filter == "updated" && !updated && gem[:name] != @requested_gem_name ? ' hidden="hidden"' : ""
+          hidden = (!gem_visible_in_selected_scope?(gem) || (@selected_filter == "updated" && !updated && gem[:name] != @requested_gem_name)) ? ' hidden="hidden"' : ""
           <<~HTML
             <a
               class="gem-row#{selected}#{status_class}"
-              href="#{project_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, gem: gem[:name])}"
+              href="#{project_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: gem[:name])}"
               data-gem-link="true"
               data-gem-name="#{h(gem[:name])}"
               data-gem-updated="#{updated}"
-              data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, gem: gem[:name]))}"
+              data-package-scope="#{h(gem[:package_scope])}"
+              data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: gem[:name]))}"
               #{hidden}
             >
               <span class="gem-name-row">
-                <span class="gem-name">#{h(gem[:name])}</span>
+                <span class="gem-name-lockup">
+                  <span class="gem-name">#{h(gem[:name])}</span>
+                  <span class="package-type-tag">#{h(gem[:package_type_label])}</span>
+                </span>
                 #{updated ? '<span class="gem-updated-dot" aria-label="Updated"></span>' : ""}
               </span>
               <span class="gem-version">#{h(gem[:version_label])}</span>
@@ -413,7 +474,7 @@ module Gemstar
             #{items}
           </nav>
           <section class="empty-panel gem-list-empty" data-gem-list-empty hidden="hidden">
-            <p>No updated gems in this revision range.</p>
+            <p>No updated #{h(@selected_project&.package_collection_label&.downcase || "packages")} in this revision range.</p>
           </section>
         HTML
       end
@@ -421,25 +482,32 @@ module Gemstar
       def render_detail
         return empty_detail_html unless @selected_gem
 
+        metadata = metadata_for(@selected_gem, refresh_if_missing: true)
         cache_key = [
+          CACHE_VERSION,
           @selected_project_index,
           @selected_from_revision_id,
           @selected_to_revision_id,
           @selected_filter,
+          @selected_package_scope,
           @selected_gem[:name],
+          @selected_gem[:package_scope],
+          @selected_gem[:package_source_file],
           @selected_gem[:old_version],
           @selected_gem[:new_version],
+          @selected_gem[:raw_old_version],
+          @selected_gem[:raw_new_version],
+          effective_package_version(@selected_gem, metadata || {}),
           @selected_gem[:status]
         ]
         detail_cache = self.class.opts[:detail_html_cache]
         return detail_cache[cache_key] if detail_cache.key?(cache_key)
 
-        metadata = metadata_for(@selected_gem[:name], refresh_if_missing: true)
         groups = grouped_change_sections(@selected_gem)
         detail_pending = detail_pending?(@selected_gem[:name], metadata, groups)
 
         detail_html = <<~HTML
-          <section class="detail" data-detail-panel tabindex="0" data-detail-pending="#{detail_pending}" data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, gem: @selected_gem[:name]))}">
+          <section class="detail" data-detail-panel tabindex="0" data-detail-pending="#{detail_pending}" data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: @selected_gem[:name]))}">
             #{render_detail_hero(metadata)}
             #{render_detail_loading_notice if detail_pending}
             #{render_detail_revision_panel(groups)}
@@ -450,12 +518,33 @@ module Gemstar
         detail_html
       end
 
-      def empty_detail_html
+      def render_initial_detail
+        return empty_detail_html(loading: true) unless @selected_gem
+
+        detail_url = detail_query(
+          project: @selected_project_index,
+          from: @selected_from_revision_id,
+          to: @selected_to_revision_id,
+          filter: @selected_filter,
+          scope: @selected_package_scope,
+          package: @selected_gem[:name]
+        )
+
+        <<~HTML
+          <section class="detail" data-detail-panel tabindex="0" data-detail-pending="false" data-detail-deferred="true" data-detail-url="#{h(detail_url)}">
+            <div class="detail-loading-shell" aria-hidden="true">
+              <div class="detail-loading-spinner"></div>
+            </div>
+          </section>
+        HTML
+      end
+
+      def empty_detail_html(loading: false)
         <<~HTML
           <section class="detail" data-detail-panel tabindex="0">
             <div class="empty-panel">
-              <h2>No gem selected</h2>
-              <p>Choose a gem from the list to inspect its current version and changelog revisions.</p>
+              <h2>#{loading ? "Loading details" : "No gem selected"}</h2>
+              <p>#{loading ? "Preparing the selected gem details." : "Choose a gem from the list to inspect its current version and changelog revisions."}</p>
             </div>
           </section>
         HTML
@@ -465,10 +554,10 @@ module Gemstar
         description = metadata&.dig("info")
         bundle_origins = Array(@selected_gem[:bundle_origins])
         requirement_names = selected_gem_requirements
-        bundled_version = @selected_gem[:new_version]
+        bundled_version = detail_bundled_version(metadata)
         added_on = selected_gem_added_on
         title_url = metadata&.dig("homepage_uri")
-        title_url = Gemstar::RubyGemsMetadata.new(@selected_gem[:name]).repo_uri(cache_only: true) if title_url.to_s.empty?
+        title_url = repo_url_for(@selected_gem, metadata: metadata) if title_url.to_s.empty?
         title_markup = if title_url.to_s.empty?
           h(@selected_gem[:name])
         else
@@ -484,13 +573,24 @@ module Gemstar
                 </div>
                 #{render_detail_links(metadata)}
               </div>
-              <p class="detail-subtitle">#{description ? h(description) : "Metadata will appear here when RubyGems information is available."}</p>
+              <div class="detail-subtitle">#{render_detail_subtitle(description)}</div>
               #{render_dependency_details(bundle_origins, requirement_names, added_on)}
             </div>
           </section>
         HTML
       end
 
+      def render_detail_subtitle(description)
+        text = description.to_s.strip
+        return "<p>Metadata will appear here when package information is available.</p>" if text.empty?
+
+        options = { hard_wrap: false }
+        options[:input] = "GFM" if defined?(Kramdown::Parser::GFM)
+        with_external_links(Kramdown::Document.new(text, options).to_html)
+      rescue Kramdown::Error
+        "<p>#{h(text)}</p>"
+      end
+
       def render_added_on(added_on)
         return "" unless added_on
 
@@ -522,12 +622,16 @@ module Gemstar
       end
 
       def render_detail_links(metadata)
-        repo_url = metadata ? Gemstar::RubyGemsMetadata.new(@selected_gem[:name]).repo_uri(cache_only: true) : nil
+        repo_url = repo_url_for(@selected_gem, metadata: metadata)
         homepage_url = metadata&.dig("homepage_uri")
-        rubygems_url = "https://rubygems.org/gems/#{URI.encode_www_form_component(@selected_gem[:name])}"
 
         buttons = []
-        buttons << icon_button("RubyGems", rubygems_url, icon_type: :rubygems)
+        if @selected_gem[:package_scope] == "gems"
+          rubygems_url = "https://rubygems.org/gems/#{URI.encode_www_form_component(@selected_gem[:name])}"
+          buttons << icon_button("RubyGems", rubygems_url, icon_type: :rubygems)
+        elsif homepage_url && !homepage_url.empty? && (!repo_url || homepage_url != repo_url)
+          buttons << icon_button("Source", homepage_url, icon_type: :home)
+        end
         buttons << icon_button("GitHub", repo_url, icon_type: :github) if repo_url && !repo_url.empty?
         buttons << icon_button("Homepage", homepage_url, icon_type: :home) if homepage_url && !homepage_url.empty?
 
@@ -575,6 +679,8 @@ module Gemstar
       end
 
       def selected_gem_requirements
+        return [] unless @selected_gem[:package_scope] == "gems"
+
         lockfile = if @selected_gem[:new_version]
           @selected_project&.lockfile_for_revision(@selected_to_revision_id)
         else
@@ -586,7 +692,12 @@ module Gemstar
 
       def selected_gem_added_on
         revision_id = @selected_gem[:new_version] ? @selected_to_revision_id : @selected_from_revision_id
-        @selected_project&.gem_added_on(@selected_gem[:name], revision_id: revision_id)
+        @selected_project&.package_added_on(
+          @selected_gem[:name],
+          package_scope: @selected_gem[:package_scope],
+          source_file: @selected_gem[:package_source_file],
+          revision_id: revision_id
+        )
       end
 
       def selected_gem_platform_items
@@ -617,6 +728,31 @@ module Gemstar
         when :rubygems
           remote = source[:remote]
           [remote.to_s.empty? ? "RubyGems" : "RubyGems (#{h(remote)})"]
+        when :importmap
+          remote = source[:remote]
+          package_name = source[:package_name]
+          package_version = source[:package_version]
+          label =
+            if package_name && package_version
+              "Importmap (#{h(package_name)} @ #{h(package_version)})"
+            elsif package_name
+              "Importmap (#{h(package_name)})"
+            elsif remote.to_s.empty?
+              "Importmap"
+            else
+              "Importmap (#{h(remote)})"
+            end
+          [label]
+        when :npm
+          remote = source[:remote]
+          registry_url = source[:registry_url]
+          if remote.to_s.empty? && registry_url.to_s.empty?
+            ["npm"]
+          elsif remote.to_s.empty?
+            ["npm (#{h(registry_url)})"]
+          else
+            ["npm (#{h(remote)})"]
+          end
         else
           []
         end
@@ -645,7 +781,8 @@ module Gemstar
           from: @selected_from_revision_id,
           to: @selected_to_revision_id,
           filter: @selected_filter,
-          gem: name
+          scope: @selected_package_scope,
+          package: name
         )
 
         %(<a href="#{h(href)}" data-gem-link-inline="true">#{h(name)}</a>)
@@ -664,7 +801,7 @@ module Gemstar
       def render_detail_loading_notice
         <<~HTML
           <section class="empty-panel">
-            <p>Loading gem metadata and changelog in the background...</p>
+            <p>Loading package metadata and changelog in the background...</p>
           </section>
         HTML
       end
@@ -732,17 +869,31 @@ module Gemstar
       end
 
       def change_sections(gem_state)
-        cache_key = [gem_state[:name], gem_state[:old_version], gem_state[:new_version], gem_state[:status]]
+        metadata_hash = metadata_for(gem_state) || {}
+        current_version = effective_package_version(gem_state, metadata_hash)
+        cache_key = [
+          CACHE_VERSION,
+          gem_state[:name],
+          gem_state[:package_scope],
+          gem_state[:package_source_file],
+          gem_state[:old_version],
+          gem_state[:new_version],
+          gem_state[:raw_old_version],
+          gem_state[:raw_new_version],
+          current_version,
+          gem_state[:status]
+        ]
         change_sections_cache = self.class.opts[:change_sections_cache]
         return change_sections_cache[cache_key] if change_sections_cache.key?(cache_key)
 
-        return [] if gem_state[:new_version].nil? && gem_state[:old_version].nil?
-
-        metadata = Gemstar::RubyGemsMetadata.new(gem_state[:name])
+        return [] if gem_state[:new_version].nil? &&
+          gem_state[:old_version].nil? &&
+          (current_version.nil? || current_version.to_s.empty?)
+        metadata = metadata_adapter_for(gem_state)
+        return change_sections_cache[cache_key] = [] unless metadata
         sections = resolved_sections(metadata, gem_state)
         return change_sections_cache[cache_key] = [] if sections.nil? || sections.empty?
 
-        current_version = gem_state[:new_version] || gem_state[:old_version]
         previous_version = gem_state[:old_version]
 
         rendered_sections = sections.keys.filter_map do |version|
@@ -769,18 +920,35 @@ module Gemstar
         cached_sections = changelog.sections(cache_only: true) || {}
         return cached_sections unless selected_gem_requires_refresh?(gem_state, cached_sections)
 
-        @metadata_cache.delete(gem_state[:name])
+        @metadata_cache.delete([gem_state[:package_scope], gem_state[:name]])
         metadata.meta(cache_only: false, force_refresh: true)
         metadata.repo_uri(cache_only: false, force_refresh: true)
-        Gemstar::ChangeLog.new(metadata).sections(cache_only: false, force_refresh: true) || cached_sections
+        refreshed_sections = metadata.changelog_sections(
+          versions: relevant_package_versions(gem_state, metadata),
+          cache_only: false,
+          force_refresh: true
+        )
+        cached_sections.merge(refreshed_sections || {})
+      end
+
+      def relevant_package_versions(gem_state, metadata)
+        metadata_hash = metadata_for(gem_state) || {}
+        [
+          gem_state[:old_version],
+          gem_state[:new_version],
+          gem_state[:raw_old_version],
+          gem_state[:raw_new_version],
+          gem_state.dig(:source, :package_version),
+          metadata_hash["version"]
+        ].compact
       end
 
       def selected_gem_requires_refresh?(gem_state, cached_sections)
         return false unless @selected_gem && gem_state[:name] == @selected_gem[:name]
 
-        bundled_version = gem_state[:new_version] || gem_state[:old_version]
-        return false if bundled_version.nil?
-        metadata = metadata_for(gem_state[:name]) || {}
+        metadata = metadata_for(gem_state) || {}
+        bundled_version = effective_package_version(gem_state, metadata)
+        return false if bundled_version.nil? || bundled_version.to_s.empty?
         has_upstream_release_source =
           !metadata["changelog_uri"].to_s.empty? ||
           !metadata["source_code_uri"].to_s.empty? ||
@@ -801,6 +969,7 @@ module Gemstar
       def section_kind(version, previous_version, current_version, status)
         return :future if compare_versions(version, current_version) == 1
         return :current if status == :added && compare_versions(version, current_version) <= 0
+        return :current if previous_version.nil? && current_version && compare_versions(version, current_version) == 0
 
         lower_bound = previous_version || current_version
         if compare_versions(version, lower_bound) == 1 && compare_versions(version, current_version) <= 0
@@ -836,7 +1005,7 @@ module Gemstar
         return { title: heading_version.to_s, html: "<p>No changelog text available.</p>" } if text.strip.empty?
 
         if heading_version
-          text = text.sub(/\A\s*#+\s*v?#{Regexp.escape(heading_version)}\s*\n+/i, "")
+          text = strip_leading_version_heading(text, heading_version)
         end
 
         options = { hard_wrap: false }
@@ -863,29 +1032,135 @@ module Gemstar
         { title: title, html: fragment.to_html }
       end
 
+      def strip_leading_version_heading(text, heading_version)
+        stripped = text.sub(/\A\s*#+\s*v?#{Regexp.escape(heading_version)}\s*\n+/i, "")
+        return strip_leading_hash_separator(stripped) unless stripped == text
+
+        lines = text.lines
+        return text if lines.empty?
+
+        first_line = lines.first.to_s
+        heading_like =
+          first_line.match?(/\A\s*v?#{Regexp.escape(heading_version)}\b/i) ||
+          first_line.match?(/\A\s*[\[(]?v?#{Regexp.escape(heading_version)}\b/i)
+
+        return text unless heading_like
+
+        remaining = lines.drop(1)
+        remaining.shift while remaining.first&.strip&.empty?
+        strip_leading_hash_separator(remaining.join)
+      end
+
+      def strip_leading_hash_separator(text)
+        text.sub(/\A\s*#{Regexp.escape("#")}{4,}\s*\n+/, "")
+      end
+
       def compare_versions(left, right)
         Gem::Version.new(left.to_s.gsub(/-[\w\-]+$/, "")) <=> Gem::Version.new(right.to_s.gsub(/-[\w\-]+$/, ""))
       rescue ArgumentError
         left.to_s <=> right.to_s
       end
 
-      def metadata_for(gem_name, refresh_if_missing: false)
-        cached = @metadata_cache[gem_name]
+      def metadata_for(package_state_or_name, refresh_if_missing: false)
+        package_state = package_state_or_name.is_a?(Hash) ? package_state_or_name : { name: package_state_or_name, package_scope: "gems" }
+        gem_name = package_state[:name]
+        cache_key = [package_state[:package_scope], gem_name]
+        cached = @metadata_cache[cache_key]
         return nil if cached.equal?(MISSING_METADATA)
         return cached if cached
 
+        if package_state[:package_scope] != "gems"
+          metadata = local_package_metadata(package_state)
+          adapter = metadata_adapter_for(package_state)
+          remote_metadata = adapter&.meta(cache_only: true)
+          remote_metadata = adapter&.meta(cache_only: false, force_refresh: true) if remote_metadata.nil? && refresh_if_missing
+          metadata = metadata.compact.merge(remote_metadata || {})
+          @metadata_cache[cache_key] = metadata || MISSING_METADATA
+          return metadata
+        end
+
         metadata = Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: true)
         if metadata.nil? && refresh_if_missing
           metadata = Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: false, force_refresh: true)
         end
 
-        @metadata_cache[gem_name] = metadata || MISSING_METADATA
+        @metadata_cache[cache_key] = metadata || MISSING_METADATA
         metadata
       rescue StandardError
-        @metadata_cache[gem_name] = MISSING_METADATA
+        @metadata_cache[cache_key] = MISSING_METADATA
         nil
       end
 
+      def local_package_metadata(package_state)
+        source = package_state[:source] || {}
+        remote = source[:remote].to_s
+        repo_url = source[:repo_url].to_s
+        package_name = source[:package_name].to_s
+        package_version = source[:package_version].to_s
+        registry_url = source[:registry_url].to_s
+        provider_gem = source[:provider_gem].to_s
+        package_name = package_state[:name].to_s if package_name.empty? && source[:type] == :npm
+        package_version = (package_state[:new_version] || package_state[:old_version]).to_s if package_version.empty? && source[:type] == :npm
+        registry_url = "https://www.npmjs.com/package/#{package_name}" if registry_url.empty? && !package_name.empty?
+        info = if package_name.empty?
+          "JavaScript package pinned in config/importmap.rb"
+        elsif !provider_gem.empty? && !package_version.empty?
+          "JavaScript package `#{package_name}` provided by the `#{provider_gem}` gem at version `#{package_version}`"
+        elsif !provider_gem.empty?
+          "JavaScript package `#{package_name}` provided by the `#{provider_gem}` gem"
+        elsif source[:type] == :npm && !package_version.empty?
+          "JavaScript package `#{package_name}` locked to `#{package_version}` in package-lock.json"
+        elsif package_version.empty?
+          "JavaScript package `#{package_name}` pinned in config/importmap.rb"
+        else
+          "JavaScript package `#{package_name}` pinned to `#{package_version}` in config/importmap.rb"
+        end
+
+        {
+          "info" => info,
+          "project_uri" => registry_url.empty? ? nil : registry_url,
+          "homepage_uri" => absolute_url?(remote) ? remote : nil,
+          "source_code_uri" => repo_url.empty? ? nil : repo_url
+        }
+      end
+
+      def repo_url_for(package_state, metadata: nil)
+        return nil unless package_state
+        if package_state[:package_scope] != "gems"
+          url = package_state.dig(:source, :repo_url) || metadata&.dig("source_code_uri")
+          return normalize_repo_url(url)
+        end
+
+        normalize_repo_url(Gemstar::RubyGemsMetadata.new(package_state[:name]).repo_uri(cache_only: true))
+      end
+
+      def normalize_repo_url(url)
+        value = url.to_s
+        return nil if value.empty?
+
+        value = value.sub(/\Agit\+/, "")
+        value = value.sub(/\Agit:\/\//, "https://")
+        value = value.gsub(/\.git\z/, "")
+        value
+      end
+
+      def metadata_adapter_for(package_state)
+        return Gemstar::RubyGemsMetadata.new(package_state[:name]) if package_state[:package_scope] == "gems"
+        return nil unless package_state[:package_scope] == "js"
+
+        provider_gem = package_state.dig(:source, :provider_gem)
+        return Gemstar::RubyGemsMetadata.new(provider_gem) unless provider_gem.to_s.empty?
+
+        package_name = package_state.dig(:source, :package_name) || package_state[:name]
+        return nil if package_name.to_s.empty?
+
+        Gemstar::NpmMetadata.new(package_name)
+      end
+
+      def absolute_url?(value)
+        value.to_s.match?(%r{\Ahttps?://}i)
+      end
+
       def detail_pending?(gem_name, metadata, groups)
         false
       end
@@ -940,7 +1215,7 @@ module Gemstar
       end
 
       def revision_card_links(section)
-        repo_url = Gemstar::RubyGemsMetadata.new(@selected_gem[:name]).repo_uri(cache_only: true)
+        repo_url = repo_url_for(@selected_gem)
         return [] if repo_url.to_s.empty?
 
         links = []
@@ -953,25 +1228,33 @@ module Gemstar
       end
 
       def fallback_current_section(gem_state, previous_sections, latest_sections)
-        version = gem_state[:new_version] || gem_state[:old_version]
+        metadata = metadata_for(gem_state) || {}
+        version = effective_package_version(gem_state, metadata)
         return nil if version.nil?
         return nil if previous_sections.any? { |section| section[:version] == version }
         return nil if latest_sections.any? { |section| section[:version] == version }
 
-        metadata = metadata_for(gem_state[:name]) || {}
-        repo_url = Gemstar::RubyGemsMetadata.new(gem_state[:name]).repo_uri(cache_only: true)
+        repo_url = repo_url_for(gem_state, metadata: metadata)
         fallback_url =
           if !repo_url.to_s.empty?
             repo_url
           elsif metadata["project_uri"]
             metadata["project_uri"]
+          elsif metadata["source_code_uri"]
+            metadata["source_code_uri"]
+          elsif metadata["homepage_uri"]
+            metadata["homepage_uri"]
           else
             metadata["documentation_uri"]
           end
         fallback_label = if repo_url.to_s.empty?
-          metadata["project_uri"] ? "the RubyGems page" : "the gem documentation"
+          if gem_state[:package_scope] == "gems"
+            metadata["project_uri"] ? "the RubyGems page" : "the gem documentation"
+          else
+            fallback_url == metadata["documentation_uri"] ? "the package documentation" : "the package source"
+          end
         else
-          "the gem repository"
+          gem_state[:package_scope] == "gems" ? "the gem repository" : "the package repository"
         end
         fallback_link = if fallback_url.to_s.empty?
           fallback_label
@@ -995,6 +1278,16 @@ module Gemstar
         nil
       end
 
+      def detail_bundled_version(metadata)
+        effective_package_version(@selected_gem, metadata || {})
+      end
+
+      def effective_package_version(package_state, metadata)
+        package_state[:new_version] ||
+          package_state[:old_version] ||
+          (package_state[:package_scope] == "js" ? metadata["version"] : nil)
+      end
+
       def github_compare_url(repo_url, previous_version, current_version)
         return nil unless repo_url.include?("github.com")
         return nil if previous_version.nil? || current_version.nil?
@@ -1024,17 +1317,18 @@ module Gemstar
         html
       end
 
-      def detail_query(project:, from:, to:, filter:, gem:)
-        "/detail?#{URI.encode_www_form(project: project, from: from, to: to, filter: filter, gem: gem)}"
+      def detail_query(project:, from:, to:, filter:, scope:, package:)
+        "/detail?#{URI.encode_www_form(project: project, from: from, to: to, filter: filter, scope: scope, package: package)}"
       end
 
-      def project_query(project:, from:, to:, filter:, gem:)
+      def project_query(project:, from:, to:, filter:, scope:, package:)
         params = {
           project: project,
           from: from,
           to: to,
           filter: filter,
-          gem: gem
+          scope: scope,
+          package: package
         }.compact
 
         "/?#{URI.encode_www_form(params)}"
@@ -1044,21 +1338,18 @@ module Gemstar
         render_template(
           "page.html.erb",
           title: h(title),
-          favicon_data_uri: favicon_data_uri,
           styles_css: template_source("app.css"),
           body_html: yield
         )
       end
 
-      def favicon_data_uri
-        svg = <<~SVG
+      def favicon_svg
+        <<~SVG
           <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
             <rect width="64" height="64" rx="14" fill="#b44d25"/>
             <text x="32" y="44" text-anchor="middle" font-family="Avenir Next, Helvetica Neue, Segoe UI, sans-serif" font-size="34" font-weight="700" fill="#ffffff">G</text>
           </svg>
         SVG
-
-        "data:image/svg+xml,#{URI.encode_www_form_component(svg)}"
       end
 
       def render_behavior_script
@@ -1066,6 +1357,7 @@ module Gemstar
           "app.js.erb",
           empty_detail_html_json: empty_detail_html.dump,
           selected_filter_json: @selected_filter.dump,
+          selected_package_scope_json: @selected_package_scope.dump,
           selected_project_index: @selected_project_index || 0
         )
 
@@ -1091,6 +1383,24 @@ module Gemstar
       def h(value)
         CGI.escapeHTML(value.to_s)
       end
+
+      def render_package_scope_filters
+        options = @selected_project&.package_scope_options || []
+        return "" if options.size <= 1
+
+        buttons = []
+        buttons << %(<button type="button" class="list-filter-button#{' is-active' if @selected_package_scope == "all"}" data-ecosystem-button="all">All</button>)
+
+        buttons.concat(options.map do |option|
+          %(<button type="button" class="list-filter-button#{' is-active' if @selected_package_scope == option[:id]}" data-ecosystem-button="#{h(option[:id])}">#{h(option[:label])}</button>)
+        end)
+
+        <<~HTML
+          <div class="list-filters list-filters-secondary" data-ecosystem-filters>
+            #{buttons.join}
+          </div>
+        HTML
+      end
     end
   end
 end