coverband 6.2.1 → 6.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c47e38934426a369c81dd7d08e5474ad0d8a784b541975c1aa7ee50fc9e2d1ce
-  data.tar.gz: 346c8263e9c961631bcf4af3019d8473177088c5b9ae3cb3844dc7d86bcd7497
+  metadata.gz: 20188ba8fca24027b2a7bd367ac88586b7dace04a6eadfd9714bdf509849683e
+  data.tar.gz: c2db00de6ffaa32256d083c7d51290a5936f5e2ee46c774eed901f91fa0ba545
 SHA512:
-  metadata.gz: 907a280ce513b23922b81c44674c135ab067e629ae9f8aaec6eb6a667946a52a85fd1e7a0fe17ee9b24c0a6b81b8b22bcb1e1c53e7ce75ccc7a9c3507b6dd183
-  data.tar.gz: 60198f0536094c5505ea532b238d9d38359f936edb6ea21854c946d3a5f63e7e02b66f1240596b787cad898546a3d48d41595d5d4cab28bb09face2a4f405499
+  metadata.gz: 22b5b1281136a3ed3172383d84526f1659568e6b204cc38b636d929c76b8ec84c9b70d20e61a54484cf97d8604e268de9da87cc596bbff2cbb81752c1078ca8b
+  data.tar.gz: aa55b358d2a3a196fd5de29f850ad41a877274649ccf377395a114c6e940bc926424fccbe6a3e7642225eaa81432f73094443b5874c8e79ac75cccb39a6c3422

data/.github/workflows/main.yml

@@ -39,7 +39,7 @@ jobs:
           --health-timeout 5s
           --health-retries 5
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
@@ -49,9 +49,17 @@ jobs:
   starndardrb:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: 3.1
           bundler-cache: true # runs 'bundle install' and caches installed gems automatically
       - run: bundle exec standardrb --format github
+  javascript:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+      - run: node --test test/javascript/*.test.mjs

data/.gitignore

@@ -26,4 +26,5 @@ log/
 test/unique_files
 test/rails7_dummy/tmp
 CLAUDE.md
-.claude/
+.claude/
+scratch/

data/README.md

@@ -309,6 +309,55 @@ When enabled, Coverband subscribes to the `render.view_component` notification a
 
 ![image](https://raw.github.com/danmayer/coverband/main/docs/coverband_view_tracker.png)
 
+### Query Burst Tracking
+
+Coverband includes an optional Query Burst Tracker to monitor SQL activity per request and per background job in production. It helps identify potential N+1 query issues and bursty database behavior.
+
+Enable it in your Coverband configuration:
+
+```ruby
+Coverband.configure do |config|
+  config.track_query_bursts = true
+
+  # Thresholds used to flag heavy requests/jobs
+  config.query_burst_query_count_threshold = 30
+  config.query_burst_sql_time_threshold_ms = 100.0
+end
+```
+
+When enabled, Coverband records stats by execution context (for example controller/action and ActiveJob class) and exposes them in the Query Burst Tracker tab in the web UI.
+
+#### Threshold Settings
+
+- `query_burst_query_count_threshold`:
+  - Max SQL query count allowed for a single tracked execution (one request or one job run).
+  - If query count is greater than or equal to this value, it is counted as a threshold hit.
+- `query_burst_sql_time_threshold_ms`:
+  - Max total SQL time (in milliseconds) allowed for a single tracked execution.
+  - If SQL time is greater than or equal to this value, it is counted as a threshold hit.
+
+Threshold logic is OR-based: Coverband records a threshold hit if either threshold is exceeded.
+
+#### What You See in the UI
+
+For each tracked key, the Query Burst Tracker reports:
+
+- Requests: Number of tracked executions
+- Total SQL Calls: Sum of all SQL calls across executions
+- Total SQL ms: Sum of SQL time across executions
+- Max SQL Calls: Highest query count seen in one execution
+- Max SQL ms: Highest SQL time seen in one execution
+- Threshold Hits: Number of executions that exceeded either threshold
+
+#### How To Tune Thresholds
+
+- Start with defaults (`30` queries, `100.0` ms SQL time).
+- Lower thresholds to detect smaller regressions sooner.
+- Raise thresholds if you see too much noise from expected heavy endpoints/jobs.
+- Tune by endpoint/job behavior: latency-sensitive paths often need stricter limits than batch work.
+
+Tip: use this tracker in production-like traffic, where query patterns are most realistic.
+
 ### Hiding settings
 
 Coverband provides a view of all of its current settings. Sometimes you might want to hide this view,
@@ -317,6 +366,16 @@ You can disable the settings view like so:
 
 `config.hide_settings = true`
 
+### Dead-code review session
+
+The web report includes a client-side "dead-code session" toolbar to help drive code-removal work:
+
+- Hide files or whole folders from the report via the ✕ icon that appears when hovering path segments, or hide everything with runtime % > 0 with one toggle.
+- Mark files or folders for deletion via the 🗑 icon (with an optional comment). Marked items disappear from the view and are listed in the "Marked for deletion" modal.
+- Export the marked list as a CSV (`path,comment,marked_at`) to feed a code-removal PR process.
+
+Session state lives in your browser's localStorage: "Reset session" clears the hidden set; "Start over" (in the modal) clears the marked list.
+
 ### Fixing Coverage Only Shows Loading Hits
 
 If all your coverage is being counted as loading or eager_loading coverage, and nothing is showing as runtime Coverage the initialization hook failed for some reason. The most likely reason for this issue is manually calling `eager_load!` on some Plugin/Gem. If you or a plugin is altering the Rails initialization process, you can manually flip Coverband to runtime coverage by calling these two lines, in an `after_initialize` block, in `application.rb`.

data/Rakefile

@@ -8,7 +8,7 @@ RuboCop::RakeTask.new
 
 task default: %i[test]
 
-task "test:all": %i[test forked_tests benchmarks:memory benchmarks]
+task "test:all": %i[test test:javascript forked_tests benchmarks:memory benchmarks]
 
 task :test
 require "rake/testtask"
@@ -21,6 +21,14 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
+desc "run the web report's javascript unit tests (node --test)"
+task :"test:javascript" do
+  # Pass expanded file paths rather than the bare directory: node's
+  # directory-argument handling for --test is inconsistent across versions
+  # (Node 22 fails to find test/javascript/ as a directory in some CI images).
+  sh "node --test #{FileList["test/javascript/*.test.mjs"].join(" ")}"
+end
+
 Rake::TestTask.new(:forked_tests) do |test|
   if RUBY_PLATFORM == "java"
     puts "forked tests not supported on JRuby"

data/changes.md

@@ -1,3 +1,9 @@
+### 6.2.2
+
+* Feature: Added a dead-code review session to the web report — hide files/folders by hovering any path segment, mark files for deletion with an optional comment, and export marked entries to CSV to drive an out-of-band code-removal process; session state lives in browser localStorage; thanks @obie (#647, #649)
+* Feature: Added `Coverband::Collectors::QueryBurstTracker` to detect N+1/burst SQL patterns per request or job, with configurable query-count and SQL-time thresholds and a new Query Burst Tracker tab in the web UI (#644)
+* Fix: Scoped the `ruby-head` memory-leak benchmark check to only fail on Coverband's own retained objects, fixing CI false positives caused by stdlib/gem string-deduplication artifacts on newer Ruby (#648)
+
 ### 6.2.1
 
 * Fix: Search now includes full filenames hidden by truncation in the web UI; users can search for complete file paths even when displaying truncated versions (#569)

data/lib/coverband/collectors/delta.rb

@@ -59,10 +59,12 @@ module Coverband
 
           # This handles Coverage branch support, setup by default in
           # simplecov 0.18.x
-          arr_line_counts = line_counts.is_a?(Hash) ? line_counts[:lines] : line_counts
+          arr_line_counts = extract_line_counts(file, line_counts)
+          next unless arr_line_counts
+
           new_results[file] = if @@previous_coverage && @@previous_coverage[file]
-            prev_line_counts = @@previous_coverage[file].is_a?(Hash) ? @@previous_coverage[file][:lines] : @@previous_coverage[file]
-            array_diff(arr_line_counts, prev_line_counts)
+            prev_line_counts = extract_line_counts(file, @@previous_coverage[file])
+            prev_line_counts ? array_diff(arr_line_counts, prev_line_counts) : arr_line_counts
           else
             arr_line_counts
           end
@@ -87,13 +89,25 @@ module Coverband
           next unless file.start_with?(@@project_directory) &&
             @@ignore_patterns.none? { |pattern| file.match(pattern) }
 
-          @@stubs[file] ||= ::Coverage.line_stub(file)
-          transformed_line_counts = coverage[:oneshot_lines].each_with_object(@@stubs[file].dup) { |line_number, line_counts|
-            line_counts[line_number - 1] = 1
-          }
+          transformed_line_counts = oneshot_lines_to_line_counts(file, coverage[:oneshot_lines])
           new_results[file] = transformed_line_counts
         end
       end
+
+      def extract_line_counts(file, coverage_data)
+        return coverage_data unless coverage_data.is_a?(Hash)
+
+        coverage_data[:lines] || oneshot_lines_to_line_counts(file, coverage_data[:oneshot_lines])
+      end
+
+      def oneshot_lines_to_line_counts(file, oneshot_lines)
+        return nil unless oneshot_lines
+
+        @@stubs[file] ||= ::Coverage.line_stub(file)
+        oneshot_lines.each_with_object(@@stubs[file].dup) do |line_number, line_counts|
+          line_counts[line_number - 1] = 1
+        end
+      end
     end
   end
 end

data/lib/coverband/collectors/query_burst_tracker.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require "json"
+require "set"
+require "singleton"
+
+module Coverband
+  module Collectors
+    # Lightweight SQL burst tracker for production runtime behavior.
+    # Aggregates per controller action / job class and persists compact stats.
+    class QueryBurstTracker < AbstractTracker
+      REPORT_ROUTE = "query_bursts_tracker"
+      TITLE = "Query Bursts"
+      CONTEXT_STACK_KEY = :coverband_query_burst_context_stack
+      IGNORED_SQL_NAMES = %w[SCHEMA CACHE TRANSACTION].freeze
+
+      def initialize(options = {})
+        super
+        @pending_stats = {}
+      end
+
+      def railtie!
+        ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |_name, _start, _finish, _id, payload|
+          start_context(:controller, controller_key(payload))
+        end
+
+        ActiveSupport::Notifications.subscribe("process_action.action_controller") do |_name, _start, _finish, _id, payload|
+          finish_context(:controller, controller_key(payload))
+        end
+
+        ActiveSupport::Notifications.subscribe("perform_start.active_job") do |_name, _start, _finish, _id, payload|
+          start_context(:job, job_key(payload))
+        end
+
+        ActiveSupport::Notifications.subscribe("perform.active_job") do |_name, _start, _finish, _id, payload|
+          finish_context(:job, job_key(payload))
+        end
+
+        ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, start, finish, _id, payload|
+          next if ignore_sql_event?(payload)
+
+          record_sql_event(duration_ms(start, finish))
+        end
+      end
+
+      def track_key(payload)
+        key = payload[:key] || payload["key"]
+        return unless key
+
+        queries = (payload[:queries] || payload["queries"] || 0).to_i
+        sql_time_ms = (payload[:sql_time_ms] || payload["sql_time_ms"] || 0.0).to_f
+        record_observation(key, queries, sql_time_ms)
+      end
+
+      def used_keys
+        return {} unless redis_store
+
+        stats_hash = redis_store.hgetall(tracker_key)
+        stats_hash.each_with_object({}) do |(key, stats_json), used|
+          stats = parse_stats(stats_json)
+          used[key] = stats["last_seen"].to_i
+        end
+      end
+
+      def used_key_stats
+        return {} unless redis_store
+
+        stats_hash = redis_store.hgetall(tracker_key)
+        stats_hash
+          .transform_values { |stats_json| parse_stats(stats_json) }
+          .sort_by { |key, stats| [-stats["threshold_hits"].to_i, -stats["total_sql_time_ms"].to_f, key] }
+          .to_h
+      end
+
+      def unused_keys(_used_keys = nil)
+        []
+      end
+
+      def all_keys
+        []
+      end
+
+      def as_json
+        {
+          tracking_since: tracking_since,
+          thresholds: {
+            query_count: query_count_threshold,
+            sql_time_ms: sql_time_threshold_ms
+          },
+          used_keys: used_key_stats
+        }.to_json
+      end
+
+      def save_report
+        return unless redis_store
+        return if @pending_stats.empty?
+
+        redis_store.set(tracker_time_key, Time.now.to_i) unless @one_time_timestamp || tracker_time_key_exists?
+        @one_time_timestamp = true
+
+        existing_stats = redis_store.hgetall(tracker_key)
+        merged = @pending_stats.each_with_object({}) do |(key, pending), h|
+          existing = parse_stats(existing_stats[key])
+          h[key] = merge_stats(existing, pending).to_json
+        end
+
+        redis_store.hset(tracker_key, merged) if merged.any?
+        @pending_stats.clear
+      rescue => e
+        logger&.error "Coverband: #{self.class.name} failed to store, error #{e.class.name} info #{e.message}"
+      end
+
+      private
+
+      def start_context(type, key)
+        return unless key
+
+        context_stack << {
+          type: type,
+          key: key,
+          queries: 0,
+          sql_time_ms: 0.0
+        }
+      end
+
+      def finish_context(type, key)
+        context = pop_context(type, key)
+        return unless context
+
+        record_observation(context[:key], context[:queries], context[:sql_time_ms])
+      end
+
+      def pop_context(type, key)
+        index = context_stack.rindex { |context| context[:type] == type && context[:key] == key }
+        return unless index
+
+        context_stack.delete_at(index)
+      end
+
+      def record_sql_event(ms)
+        return if context_stack.empty?
+
+        context = context_stack.last
+        context[:queries] += 1
+        context[:sql_time_ms] += ms
+      end
+
+      def record_observation(key, query_count, sql_time_ms)
+        key = key.to_s
+        stats = @pending_stats[key] || default_stats
+
+        stats["requests"] += 1
+        stats["total_queries"] += query_count
+        stats["total_sql_time_ms"] += sql_time_ms
+        stats["max_queries"] = [stats["max_queries"], query_count].max
+        stats["max_sql_time_ms"] = [stats["max_sql_time_ms"], sql_time_ms].max
+
+        now = Time.now.to_i
+        stats["last_seen"] = now
+        stats["last_event"] = {
+          "queries" => query_count,
+          "sql_time_ms" => sql_time_ms.round(3),
+          "at" => now
+        }
+        stats["threshold_hits"] += 1 if threshold_hit?(query_count, sql_time_ms)
+
+        @pending_stats[key] = stats
+        @logged_keys << key
+      end
+
+      def threshold_hit?(query_count, sql_time_ms)
+        query_count >= query_count_threshold || sql_time_ms >= sql_time_threshold_ms
+      end
+
+      def default_stats
+        {
+          "requests" => 0,
+          "total_queries" => 0,
+          "total_sql_time_ms" => 0.0,
+          "max_queries" => 0,
+          "max_sql_time_ms" => 0.0,
+          "threshold_hits" => 0,
+          "last_seen" => nil,
+          "last_event" => nil
+        }
+      end
+
+      def merge_stats(existing, pending)
+        {
+          "requests" => existing["requests"].to_i + pending["requests"].to_i,
+          "total_queries" => existing["total_queries"].to_i + pending["total_queries"].to_i,
+          "total_sql_time_ms" => existing["total_sql_time_ms"].to_f + pending["total_sql_time_ms"].to_f,
+          "max_queries" => [existing["max_queries"].to_i, pending["max_queries"].to_i].max,
+          "max_sql_time_ms" => [existing["max_sql_time_ms"].to_f, pending["max_sql_time_ms"].to_f].max,
+          "threshold_hits" => existing["threshold_hits"].to_i + pending["threshold_hits"].to_i,
+          "last_seen" => [existing["last_seen"].to_i, pending["last_seen"].to_i].max,
+          "last_event" => latest_event(existing["last_event"], pending["last_event"])
+        }
+      end
+
+      def latest_event(existing_event, pending_event)
+        return pending_event unless existing_event
+        return existing_event unless pending_event
+
+        if existing_event["at"].to_i >= pending_event["at"].to_i
+          existing_event
+        else
+          pending_event
+        end
+      end
+
+      def parse_stats(stats_json)
+        return default_stats unless stats_json
+
+        parsed = JSON.parse(stats_json)
+        default_stats.merge(parsed)
+      rescue JSON::ParserError
+        default_stats
+      end
+
+      def context_stack
+        Thread.current[CONTEXT_STACK_KEY] ||= []
+      end
+
+      def ignore_sql_event?(payload)
+        return true if payload[:cached]
+
+        name = payload[:name].to_s
+        IGNORED_SQL_NAMES.include?(name)
+      end
+
+      def duration_ms(start, finish)
+        (finish - start) * 1000.0
+      end
+
+      def controller_key(payload)
+        controller = payload[:controller] || payload.dig(:params, "controller")
+        action = payload[:action]
+        return unless controller && action
+
+        "controller:#{controller}##{action}"
+      end
+
+      def job_key(payload)
+        job = payload[:job]
+        return unless job
+
+        queue_name = if job.respond_to?(:queue_name)
+          job.queue_name
+        end
+        queue_suffix = queue_name ? " queue:#{queue_name}" : ""
+        "job:#{job.class.name}#{queue_suffix}"
+      end
+
+      def query_count_threshold
+        Coverband.configuration.query_burst_query_count_threshold.to_i
+      end
+
+      def sql_time_threshold_ms
+        Coverband.configuration.query_burst_sql_time_threshold_ms.to_f
+      end
+
+      def concrete_target
+        []
+      end
+    end
+  end
+end

data/lib/coverband/configuration.rb

@@ -14,6 +14,8 @@ module Coverband
       :view_tracker, :defer_eager_loading_data,
       :track_routes, :track_redirect_routes, :route_tracker,
       :track_translations, :translations_tracker,
+      :track_query_bursts, :query_burst_tracker,
+      :query_burst_query_count_threshold, :query_burst_sql_time_threshold_ms,
       :trackers, :csp_policy, :hide_settings,
       :mcp_enabled
 
@@ -81,6 +83,10 @@ module Coverband
       @route_tracker = nil
       @track_translations = false
       @translations_tracker = nil
+      @track_query_bursts = false
+      @query_burst_tracker = nil
+      @query_burst_query_count_threshold = 30
+      @query_burst_sql_time_threshold_ms = 100.0
       @web_debug = false
       @report_on_exit = true
       @use_oneshot_lines_coverage = ENV["ONESHOT"] || false
@@ -140,6 +146,11 @@ module Coverband
         end
         trackers << Coverband.configuration.view_tracker
       end
+
+      if Coverband.configuration.track_query_bursts
+        Coverband.configuration.query_burst_tracker = Coverband::Collectors::QueryBurstTracker.new
+        trackers << Coverband.configuration.query_burst_tracker
+      end
       trackers.each { |tracker| tracker.railtie! }
     rescue Redis::CannotConnectError => e
       Coverband.configuration.logger.info "Redis is not available (#{e}), Coverband not configured"

data/lib/coverband/reporters/web.rb

@@ -153,10 +153,13 @@ module Coverband
       def display_abstract_tracker(tracker)
         notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params["notice"])}<br/>"
         notice = request.params["notice"] ? notice : ""
+        used_keys_sort = tracker_used_keys_sort_mode(tracker)
         options = {
           tracker: tracker,
           notice: notice,
-          base_path: base_path
+          base_path: base_path,
+          used_keys_sort: used_keys_sort,
+          sorted_used_keys: sorted_tracker_used_keys(tracker, used_keys_sort)
         }
         Coverband::Utils::HTMLFormatter.new(nil, options).format_abstract_tracker!
       end
@@ -229,6 +232,27 @@ module Coverband
 
       private
 
+      def tracker_used_keys_sort_mode(tracker)
+        requested_sort = request.params["used_sort"]
+        return requested_sort if %w[alpha last_active].include?(requested_sort)
+
+        views_tracker?(tracker) ? "last_active" : "alpha"
+      end
+
+      def sorted_tracker_used_keys(tracker, used_keys_sort)
+        used_keys = tracker.used_keys
+        sorted_pairs = if used_keys_sort == "last_active"
+          used_keys.sort_by { |_key, time_at| -time_at.to_i }
+        else
+          used_keys.sort_by { |key, _time_at| key.to_s }
+        end
+        sorted_pairs.to_h
+      end
+
+      def views_tracker?(tracker)
+        tracker.route == Coverband::Collectors::ViewTracker::REPORT_ROUTE
+      end
+
       def coverband_headers(content_type: "text/html")
         web_headers = {
           "content-type" => content_type

data/lib/coverband/utils/html_formatter.rb

@@ -13,13 +13,15 @@ require "time"
 module Coverband
   module Utils
     class HTMLFormatter
-      attr_reader :notice, :base_path, :tracker, :page
+      attr_reader :notice, :base_path, :tracker, :page, :used_keys_sort, :sorted_used_keys
 
       def initialize(report, options = {})
         @notice = options.fetch(:notice, nil)
         @base_path = options.fetch(:base_path, "./")
         @tracker = options.fetch(:tracker, nil)
         @page = options.fetch(:page, nil)
+        @used_keys_sort = options.fetch(:used_keys_sort, nil)
+        @sorted_used_keys = options.fetch(:sorted_used_keys, nil)
         @coverage_result = Coverband::Utils::Results.new(report) if report
       end
 

data/lib/coverband/version.rb

@@ -5,5 +5,5 @@
 # use format "4.2.1.rc.1" ~> 4.2.1.rc to prerelease versions like v4.2.1.rc.2 and v4.2.1.rc.3
 ###
 module Coverband
-  VERSION = "6.2.1"
+  VERSION = "6.2.2"
 end

data/lib/coverband.rb

@@ -21,6 +21,7 @@ require "coverband/collectors/view_tracker"
 require "coverband/collectors/view_tracker_service"
 require "coverband/collectors/route_tracker"
 require "coverband/collectors/translation_tracker"
+require "coverband/collectors/query_burst_tracker"
 require "coverband/reporters/base"
 require "coverband/reporters/console_report"
 require "coverband/integrations/background"
@@ -101,14 +102,14 @@ module Coverband
   end
 
   # Track a key with the specified tracker.
-  # @param tracker_type [Symbol] The type of tracker to use (e.g., :view_tracker, :translations_tracker, :routes_tracker)
+  # @param tracker_type [Symbol] The type of tracker to use (e.g., :view_tracker, :translations_tracker, :routes_tracker, :query_burst_tracker)
   # @param key [String] The key to track
   # @return [Boolean] True if tracking was successful, false otherwise
   # @raise [ArgumentError] If the tracker_type is not supported
   def self.track_key(tracker_type, key)
     return false unless key
 
-    supported_trackers = [:view_tracker, :translations_tracker, :routes_tracker]
+    supported_trackers = [:view_tracker, :translations_tracker, :routes_tracker, :query_burst_tracker]
 
     unless supported_trackers.include?(tracker_type)
       raise ArgumentError, "Unsupported tracker type: #{tracker_type}. Must be one of: #{supported_trackers.join(", ")}"

data/public/application.css

@@ -867,3 +867,30 @@ td:has(> span.green) {
   background-color: #fbf0c0; }
 .source_table .skipped:nth-child(even) {
   background-color: #fbffcf; }
+
+/* Dead-code review session */
+#dcs-toolbar { margin: 8px 0 12px 0; padding: 8px 10px; background: #f4f4f4; border: 1px solid #ddd; border-radius: 4px; font-size: 0.85em; }
+#dcs-toolbar label { margin: 0 10px; cursor: pointer; }
+#dcs-toolbar button { margin: 0 4px; cursor: pointer; }
+.dcs-badge { background: #666; color: #fff; border-radius: 8px; padding: 1px 8px; margin: 0 6px; }
+#dcs-chips { margin-top: 6px; display: none; }
+.dcs-chip { display: inline-block; background: #e8e8e8; border: 1px solid #ccc; border-radius: 10px; padding: 1px 6px; margin: 2px; font-family: monospace; }
+.dcs-chip-x { border: none; background: transparent; cursor: pointer; font-weight: bold; margin-left: 4px; }
+.dcs-seg { position: relative; }
+.dcs-actions { display: none; white-space: nowrap; }
+.dcs-seg:hover > .dcs-actions { display: inline; }
+.dcs-actions button { border: none; background: #ddd; border-radius: 3px; cursor: pointer; font-size: 0.85em; padding: 0 3px; margin-left: 2px; line-height: 1.2; }
+.dcs-actions button:hover { background: #bbb; }
+#dcs-mark-popup { position: absolute; z-index: 10000; background: #fff; border: 1px solid #999; border-radius: 4px; box-shadow: 0 2px 8px rgba(0,0,0,0.3); padding: 10px; width: 320px; }
+#dcs-mark-popup .dcs-popup-path { font-family: monospace; font-weight: bold; margin-bottom: 6px; word-break: break-all; }
+#dcs-mark-popup textarea { width: 100%; box-sizing: border-box; }
+#dcs-mark-popup .dcs-popup-actions { margin-top: 6px; text-align: right; }
+#dcs-modal-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.5); z-index: 10001; }
+#dcs-modal { background: #fff; border-radius: 6px; width: 80%; max-width: 900px; max-height: 80%; overflow: auto; margin: 5% auto; padding: 16px; }
+#dcs-modal-head { display: flex; justify-content: space-between; margin-bottom: 10px; }
+#dcs-modal-table { width: 100%; border-collapse: collapse; }
+#dcs-modal-table th, #dcs-modal-table td { border-bottom: 1px solid #eee; padding: 4px 8px; text-align: left; }
+#dcs-modal-foot { margin-top: 12px; text-align: right; }
+#dcs-modal-foot button { margin-left: 8px; }
+.dcs-mono { font-family: monospace; }
+.dcs-comment-edit { width: 100%; box-sizing: border-box; }