snap_diff-capybara 2.0.0.beta1 → 2.0.0.beta2

data/lib/snap_diff/dsl.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 # No require of "capybara_screenshot_diff" here: every Capybara::Screenshot
-# / CapybaraScreenshotDiff reference below is inside a method body, resolved
-# lazily at call time, not at this file's own load time -- so this unit has
-# no eager dependency on the umbrella entry point, and requiring it here
-# would create a require cycle back to capybara_screenshot_diff.rb (which
-# requires this file's old-path forwarder).
+# reference below is inside a method body, resolved lazily at call time, not
+# at this file's own load time -- so this unit has no eager dependency on
+# the umbrella entry point, and requiring it here would create a require
+# cycle back to capybara_screenshot_diff.rb (which requires this file's
+# old-path forwarder).
 # DSL includes Capybara::DSL directly below, so it needs the base gem
 # loaded regardless of what pulled this file in.
 require "capybara/dsl"
@@ -59,14 +59,14 @@ module SnapDiff
     # @option options [Numeric] :area_size_limit Maximum allowed difference area size in pixels.
     # @option options [Symbol] :driver (:auto) The image processing driver to use (:auto, :chunky_png, :vips).
     # @return [Boolean] True if the screenshot was successfully captured and processed.
-    # @raise [CapybaraScreenshotDiff::ExpectationNotMet] If comparison fails and immediate validation is enabled.
-    # @raise [CapybaraScreenshotDiff::UnstableImage] If the image comparison is unstable.
-    # @raise [CapybaraScreenshotDiff::WindowSizeMismatchError] If the window size doesn't match expectations.
+    # @raise [SnapDiff::ExpectationNotMet] If comparison fails and immediate validation is enabled.
+    # @raise [SnapDiff::UnstableImage] If the image comparison is unstable.
+    # @raise [SnapDiff::WindowSizeMismatchError] If the window size doesn't match expectations.
     def assert_matches_screenshot(name, skip_stack_frames: 0, **options)
       return false unless Capybara::Screenshot.active?
 
       # Get the full name with section and group information
-      full_name = CapybaraScreenshotDiff.screenshot_namer.full_name(name)
+      full_name = SnapDiff.session.screenshot_namer.full_name(name)
 
       # Build the screenshot assertion
       assertion = build_screenshot_assertion(full_name, options, skip_stack_frames: skip_stack_frames + 1)
@@ -77,7 +77,7 @@ module SnapDiff
       delayed = options.fetch(:delayed, Capybara::Screenshot::Diff.delayed)
 
       if delayed
-        CapybaraScreenshotDiff.add_assertion(assertion)
+        SnapDiff.session.add_assertion(assertion)
       else
         assertion.validate!
       end
@@ -104,7 +104,7 @@ module SnapDiff
     def capture_screenshot(name, **options)
       return false unless Capybara::Screenshot.active?
 
-      full_name = CapybaraScreenshotDiff.screenshot_namer.full_name(name)
+      full_name = SnapDiff.session.screenshot_namer.full_name(name)
       SnapDiff::ScreenshotMatcher.new(full_name, options).capture
 
       true
@@ -137,7 +137,7 @@ module SnapDiff
     end
 
     def screenshot_namer
-      CapybaraScreenshotDiff.screenshot_namer
+      SnapDiff.session.screenshot_namer
     end
   end
 end

data/lib/snap_diff/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "snap_diff/error_with_filtered_backtrace"
+
+# ADR-008 step 2: the gem's error classes live under SnapDiff. The old
+# CapybaraScreenshotDiff names (capybara_screenshot_diff.rb) are EAGER
+# same-object aliases of these classes -- deliberately not const_missing
+# shims, because rescue clauses and defined?/const_defined? feature
+# detection in adopter code must keep behaving exactly as before
+# (const_defined? never triggers const_missing).
+module SnapDiff
+  class Error < ErrorWithFilteredBacktrace; end
+
+  class ExpectationNotMet < Error; end
+
+  class UnstableImage < Error; end
+
+  class WindowSizeMismatchError < ErrorWithFilteredBacktrace; end
+end

data/lib/snap_diff/integrations/cucumber.rb

@@ -2,7 +2,8 @@
 
 # See the matching comment in integrations/minitest.rb.
 require_relative "../dsl"
-require "capybara_screenshot_diff/screenshot_assertion"
+require "snap_diff/screenshot_assertion"
+require "snap_diff/reporting"
 
 World(::SnapDiff::DSL)
 
@@ -12,11 +13,11 @@ Before do
 end
 
 After do |scenario|
-  if !scenario.failed? && (msg = CapybaraScreenshotDiff.pending_screenshots_message)
+  if !scenario.failed? && (msg = SnapDiff.pending_screenshots_message)
     skip_this_scenario(msg)
   end
 ensure
-  CapybaraScreenshotDiff.reset
+  SnapDiff.reset
 end
 
-AfterAll { CapybaraScreenshotDiff.finalize_reporters! }
+AfterAll { SnapDiff::Reporting.finalize! }

data/lib/snap_diff/integrations/minitest.rb

@@ -2,12 +2,11 @@
 
 require "minitest"
 require_relative "../dsl"
-# The CapybaraScreenshotDiff.verify/.reset/.pending_screenshots_message/
-# .finalize_reporters! calls below need the registry singleton machinery,
-# which lives in the *old* capybara_screenshot_diff/screenshot_assertion.rb
-# file (deliberately not moved -- see that file's own comment) and is no
-# longer pulled in transitively by requiring dsl.rb alone.
-require "capybara_screenshot_diff/screenshot_assertion"
+# SnapDiff.session/.reset/.pending_screenshots_message live in
+# snap_diff/screenshot_assertion, SnapDiff::Reporting.finalize! in
+# snap_diff/reporting -- neither is pulled in by requiring dsl.rb alone.
+require "snap_diff/screenshot_assertion"
+require "snap_diff/reporting"
 
 used_deprecated_entrypoint = caller.any? do |path|
   path.include?("capybara-screenshot-diff.rb") || path.include?("capybara/screenshot/diff.rb")
@@ -29,7 +28,7 @@ module SnapDiff
         self.assertions += 1
 
         super(*args, skip_stack_frames: skip_stack_frames + 1, **opts)
-      rescue ::CapybaraScreenshotDiff::ExpectationNotMet => e
+      rescue ::SnapDiff::ExpectationNotMet => e
         raise ::Minitest::Assertion, e.message
       end
 
@@ -40,18 +39,18 @@ module SnapDiff
 
       def before_teardown
         super
-        CapybaraScreenshotDiff.verify
+        SnapDiff.session.verify
 
         # Computed here (before teardown/reset), but the actual `skip` is
         # deferred to `after_teardown` so a real error raised by the user's
         # `teardown` isn't masked by a pending skip recorded before it ran.
-        @capybara_screenshot_diff_pending_message = CapybaraScreenshotDiff.pending_screenshots_message
-      rescue CapybaraScreenshotDiff::ExpectationNotMet => e
+        @capybara_screenshot_diff_pending_message = SnapDiff.pending_screenshots_message
+      rescue SnapDiff::ExpectationNotMet => e
         assertion = ::Minitest::Assertion.new(e)
         assertion.set_backtrace(e.backtrace)
         failures << assertion
       ensure
-        CapybaraScreenshotDiff.reset
+        SnapDiff.reset
       end
 
       def after_teardown
@@ -67,4 +66,4 @@ module SnapDiff
   end
 end
 
-::Minitest.after_run { CapybaraScreenshotDiff.finalize_reporters! } if ::Minitest.respond_to?(:after_run)
+::Minitest.after_run { SnapDiff::Reporting.finalize! } if ::Minitest.respond_to?(:after_run)

data/lib/snap_diff/integrations/rspec.rb

@@ -3,7 +3,8 @@
 require "rspec/core"
 require_relative "../dsl"
 # See the matching comment in integrations/minitest.rb.
-require "capybara_screenshot_diff/screenshot_assertion"
+require "snap_diff/screenshot_assertion"
+require "snap_diff/reporting"
 
 RSpec::Matchers.define :match_screenshot do |name, **options|
   description { "match screenshot '#{name}'" }
@@ -45,7 +46,7 @@ RSpec.configure do |config|
   config.append_after do |example|
     if self.class.include?(SnapDiff::DSL)
       begin
-        CapybaraScreenshotDiff.verify
+        SnapDiff.session.verify
 
         # Never mask a real failure with a pending marker. Kept as
         # defense-in-depth: `append_after` observes failures from plain
@@ -53,16 +54,16 @@ RSpec.configure do |config|
         # so a user `append_after` registered after this gem still runs
         # later than us — RSpec has no "run absolutely last" construct.
         # Mitigation for such consumers: require this gem last.
-        if example.exception.nil? && (msg = CapybaraScreenshotDiff.pending_screenshots_message)
+        if example.exception.nil? && (msg = SnapDiff.pending_screenshots_message)
           skip(msg)
         end
-      rescue CapybaraScreenshotDiff::ExpectationNotMet => e
+      rescue SnapDiff::ExpectationNotMet => e
         raise RSpec::Expectations::ExpectationNotMetError.new(e.message).tap { |ex| ex.set_backtrace(e.backtrace) }
       ensure
-        CapybaraScreenshotDiff.reset
+        SnapDiff.reset
       end
     end
   end
 
-  config.after(:suite) { CapybaraScreenshotDiff.finalize_reporters! }
+  config.after(:suite) { SnapDiff::Reporting.finalize! }
 end

data/lib/snap_diff/legacy_shims.rb

@@ -24,6 +24,14 @@ require "snap_diff/drivers"
 #   shared SnapDiff::Drivers module (the Drivers alias is same-object by
 #   contract), so const_missing can never fire for the leaf names;
 #   resolving them through the old path still warns for ...::Drivers.
+# - Diff::LOADED_DRIVERS: user code registers custom drivers by mutating
+#   this hash in place, so it must be the exact same object as the
+#   canonical SnapDiff::Drivers.loaded -- a lazy warn-once shim could not
+#   keep a mutable alias, and warning on a supported registration surface
+#   would be noise. Assigned eagerly below.
+# - Diff::AVAILABLE_DRIVERS: stays a real constant defined by
+#   config_legacy.rb (detection runs at that load moment);
+#   SnapDiff::Drivers.available is the canonical reader.
 module SnapDiff
   # @api private
   module LegacyShims
@@ -47,6 +55,11 @@ end
 module Capybara
   module Screenshot
     module Diff
+      # EAGER same-object alias of the canonical driver cache (see header).
+      LOADED_DRIVERS = SnapDiff::Drivers.loaded
+
+      module Reporters
+      end
     end
   end
 end
@@ -71,9 +84,14 @@ SnapDiff::LegacyShims.install(Capybara::Screenshot::Diff, "Capybara::Screenshot:
   ScreenshotMatcher: "SnapDiff::ScreenshotMatcher",
   Drivers: "SnapDiff::Drivers",
   ImageCompare: "SnapDiff::Comparison",
+  Comparison: "SnapDiff::Comparison::Images",
   Difference: "SnapDiff::ComparisonResult"
 }.freeze)
 
+SnapDiff::LegacyShims.install(Capybara::Screenshot::Diff::Reporters, "Capybara::Screenshot::Diff::Reporters", {
+  Default: "SnapDiff::Reporters::Default"
+}.freeze)
+
 SnapDiff::LegacyShims.install(CapybaraScreenshotDiff, "CapybaraScreenshotDiff", {
   RED_RGBA: "SnapDiff::RED_RGBA",
   ORANGE_RGBA: "SnapDiff::ORANGE_RGBA",

data/lib/snap_diff/region.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module SnapDiff
+  class Region
+    attr_accessor :x, :y, :width, :height
+
+    def initialize(x, y, width, height)
+      @x, @y, @width, @height = x, y, width, height
+    end
+
+    def self.from_edge_coordinates(left, top, right, bottom)
+      return nil unless left && top && right && bottom
+      return nil if right < left || bottom < top
+
+      Region.new(left, top, right - left, bottom - top)
+    end
+
+    def to_edge_coordinates
+      [left, top, right, bottom]
+    end
+
+    def to_top_left_corner_coordinates
+      [x, y, width, height]
+    end
+
+    def top
+      y
+    end
+
+    def bottom
+      y + height
+    end
+
+    def left
+      x
+    end
+
+    def right
+      x + width
+    end
+
+    def size
+      return 0 if width < 0 || height < 0
+
+      result = width * height
+      result.zero? ? 1 : result
+    end
+
+    def to_a
+      [@x, @y, @width, @height]
+    end
+
+    def find_intersect_with(region)
+      return nil unless intersect?(region)
+
+      new_left = [x, region.x].max
+      new_top = [y, region.y].max
+
+      Region.new(new_left, new_top, [right, region.right].min - new_left, [bottom, region.bottom].min - new_top)
+    end
+
+    def intersect?(region)
+      left <= region.right && right >= region.left && top <= region.bottom && bottom >= region.top
+    end
+
+    def move_by(right_by, down_by)
+      Region.new(x + right_by, y + down_by, width, height)
+    end
+
+    def find_relative_intersect(region)
+      intersect = find_intersect_with(region)
+      return nil unless intersect
+
+      intersect.move_by(-x, -y)
+    end
+
+    def cover?(x, y)
+      x.between?(left, right) && y.between?(top, bottom)
+    end
+
+    def empty?
+      width.zero? || height.zero?
+    end
+
+    def blank?
+      empty?
+    end
+
+    def present?
+      !empty?
+    end
+
+    def inspect
+      "Region(x: #{x}, y: #{y}, width: #{width}, height: #{height})"
+    end
+
+    # need to add this method to make it work with assert_equal
+    def ==(other)
+      case other
+      when Region
+        x == other.x && y == other.y && width == other.width && height == other.height
+      when Array
+        to_a == other
+      else
+        false
+      end
+    end
+  end
+end
+
+# Compatibility alias -- EAGER and same-object on purpose, mirroring the
+# ADR-008 step 2 rationale: user configs construct skip_area entries with
+# top-level `Region.new(...)` and SnapDiff internals check
+# `is_a?(SnapDiff::Region)`, so both names must be the exact same class;
+# and `defined?(Region)` feature detection must be truthy as soon as this
+# file loads (a lazy const_missing shim would return nil there).
+Region = SnapDiff::Region

data/lib/snap_diff/reporters/default.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "snap_diff/annotation_service"
+
+module SnapDiff
+  module Reporters
+    class Default
+      attr_reader :difference
+
+      def initialize(difference)
+        @difference = difference
+        @annotation_service = SnapDiff::AnnotationService.new(difference)
+      end
+
+      def annotated_image_path
+        annotation_service.annotated_image_path
+      end
+
+      def annotated_base_image_path
+        annotation_service.annotated_base_image_path
+      end
+
+      def heatmap_diff_path
+        annotation_service.heatmap_diff_path
+      end
+
+      def generate
+        if difference.equal?
+          # NOTE: Delete previous run runtime files
+          clean_tmp_files
+          return nil
+        end
+
+        if difference.failed? && difference.failed_by[:different_dimensions]
+          return build_error_for_different_dimensions
+        end
+
+        annotate_and_save_images
+        build_error_message
+      end
+
+      def clean_tmp_files
+        annotation_service.clean_tmp_files
+      end
+
+      def annotate_and_save_images
+        annotation_service.annotate_and_save_images
+      end
+
+      def save_annotation_for(image, image_path)
+        annotation_service.save_annotation_for(image, image_path)
+      end
+
+      def annotate_difference(image, region)
+        annotation_service.annotate_difference(image, region)
+      end
+
+      def annotate_skip_areas(image, skip_areas)
+        annotation_service.annotate_skip_areas(image, skip_areas)
+      end
+
+      def save(image, image_path)
+        annotation_service.save(image, image_path)
+      end
+
+      def build_error_for_different_dimensions
+        change_msg = [comparison.base_image, comparison.new_image]
+          .map { |image| driver.dimension(image).join("x") }
+          .join(" => ")
+
+        "Dimensions have changed: #{change_msg}\n#{base_image_path.to_path}\n#{image_path.to_path}"
+      end
+
+      NEW_LINE = "\n"
+
+      def build_error_message
+        [
+          "(#{difference.to_h.to_json})",
+          image_path.to_path,
+          annotated_base_image_path.to_path,
+          annotated_image_path.to_path,
+          heatmap_diff_path.to_path
+        ].join(NEW_LINE)
+      end
+
+      private
+
+      attr_reader :annotation_service
+
+      def base_image_path
+        comparison.base_image_path
+      end
+
+      def image_path
+        comparison.new_image_path
+      end
+
+      def driver
+        @_driver ||= comparison.driver
+      end
+
+      def comparison
+        @_comparison ||= difference.comparison
+      end
+    end
+  end
+end

data/lib/snap_diff/reporters/html.rb

@@ -5,11 +5,9 @@ require "erb"
 require "fileutils"
 require "pathname"
 require "json"
-# The auto-registration block at the bottom of this file calls
-# CapybaraScreenshotDiff.reporters, which needs the registry singleton
-# machinery in the *old* capybara_screenshot_diff/screenshot_assertion.rb
-# file (deliberately not moved -- see that file's own comment).
-require "capybara_screenshot_diff/screenshot_assertion"
+# The auto-registration block at the bottom of this file registers with
+# SnapDiff::Reporting.
+require "snap_diff/reporting"
 require "capybara/screenshot/diff/config_legacy"
 
 module SnapDiff
@@ -136,8 +134,8 @@ module SnapDiff
 end
 
 # Auto-register reporter.
-# Framework adapters (Minitest, RSpec, Cucumber) call finalize_reporters! via native hooks.
-# For custom frameworks, call CapybaraScreenshotDiff.finalize_reporters! manually.
-unless CapybaraScreenshotDiff.reporters.any?(SnapDiff::Reporters::HTML)
-  CapybaraScreenshotDiff.reporters << SnapDiff::Reporters::HTML.new(embed_images: !!ENV["CI"])
+# Framework adapters (Minitest, RSpec, Cucumber) call SnapDiff::Reporting.finalize! via native hooks.
+# For custom frameworks, call SnapDiff::Reporting.finalize! manually.
+unless SnapDiff::Reporting.reporters.any?(SnapDiff::Reporters::HTML)
+  SnapDiff::Reporting.register(SnapDiff::Reporters::HTML.new(embed_images: !!ENV["CI"]))
 end

data/lib/snap_diff/reporting.rb

@@ -5,10 +5,9 @@ module SnapDiff
   # end-of-suite finalization. One list of reporters for the whole process,
   # guarded by one mutex.
   #
-  # Deliberately separate from the per-test session lifecycle (the
-  # thread-local AssertionRegistry reached through
-  # CapybaraScreenshotDiff.registry): reporters outlive any single test,
-  # the registry does not. CapybaraScreenshotDiff keeps its public
+  # Deliberately separate from the per-test session lifecycle
+  # (SnapDiff.session): reporters outlive any single test, the session does
+  # not. CapybaraScreenshotDiff keeps its public
   # reporters/reporters_mutex/finalize_reporters! methods as thin shims
   # over this module.
   module Reporting
@@ -18,6 +17,16 @@ module SnapDiff
     class << self
       attr_reader :reporters, :mutex
 
+      # Registers a reporter for the rest of the process. The canonical way
+      # in: the append happens under the mutex, so concurrent registrations
+      # cannot lose one (issue #217 item 2). `reporters` stays public and
+      # mutable for compatibility -- appending to it directly still works,
+      # it just skips the lock.
+      def register(reporter)
+        @mutex.synchronize { @reporters << reporter }
+        reporter
+      end
+
       # Delivers a finished test's assertions to every registered reporter.
       # Iterates over a snapshot so a reporter mutating the list mid-notify
       # cannot affect the current round. A raising reporter is warned about

data/lib/snap_diff/screenshot_assertion.rb

@@ -2,8 +2,42 @@
 
 require "fileutils"
 require_relative "screenshot_namer"
+require_relative "reporting"
 
 module SnapDiff
+  # --- Session lifecycle (per-test) ---
+  #
+  # The canonical home of the per-test session: the AssertionRegistry
+  # holding the assertions and new-screenshot names of the test running
+  # here. CapybaraScreenshotDiff.registry / .reset /
+  # .pending_screenshots_message are thin forwarders over these.
+  #
+  # Note: Thread.current[] is *fiber*-local, so a session is per fiber, not
+  # per thread. That is pre-existing, documented behaviour (issue #217);
+  # ADR-008 step 6 relocates the accessor without touching the semantics.
+  def self.session
+    Thread.current[:capybara_screenshot_diff_registry] ||= AssertionRegistry.new
+  end
+
+  # Ends a test: hands the finished session's assertions to the reporters,
+  # then clears it. The one deliberate bridge between the process-global
+  # reporter lifecycle (SnapDiff::Reporting) and the per-test session.
+  def self.reset
+    Reporting.notify(session.assertions)
+    session.reset
+  end
+
+  # Message to skip the test with when a new screenshot has no baseline yet
+  # and `pending_if_new` is enabled. Adapters call this after verifying
+  # screenshots, and skip the test with the returned message when present.
+  #
+  # @return [String, nil] the pending message, or nil when there is nothing to report
+  def self.pending_screenshots_message
+    return unless ::Capybara::Screenshot::Diff.pending_if_new && session.new_screenshots_present?
+
+    "No baseline for: #{session.new_screenshots.join(", ")}. Commit the captured screenshots to record them."
+  end
+
   class ScreenshotAssertion
     attr_reader :name, :args
     attr_accessor :compare, :caller
@@ -52,7 +86,7 @@ module SnapDiff
       error_msg = validate
 
       if error_msg
-        raise CapybaraScreenshotDiff::ExpectationNotMet.new(error_msg, caller)
+        raise SnapDiff::ExpectationNotMet.new(error_msg, caller)
       end
     end
 
@@ -118,15 +152,14 @@ module SnapDiff
       !@new_screenshots.empty?
     end
 
-    def verify(screenshots = CapybaraScreenshotDiff.assertions)
+    def verify(screenshots = assertions)
       return unless ::Capybara::Screenshot.active? && ::Capybara::Screenshot::Diff.fail_on_difference
 
-      failed_assertions = CapybaraScreenshotDiff.registry.failed_assertions
       failed_screenshot = failed_assertions.first
       result = ScreenshotAssertion.verify_screenshots!(screenshots)
 
       if result
-        raise CapybaraScreenshotDiff::ExpectationNotMet.new(result.join("\n\n"), failed_screenshot.caller)
+        raise SnapDiff::ExpectationNotMet.new(result.join("\n\n"), failed_screenshot.caller)
       end
     end
 

data/lib/snap_diff/screenshot_matcher.rb

@@ -21,7 +21,7 @@ module SnapDiff
     end
 
     def build_screenshot_assertion(skip_stack_frames: 0)
-      Capture::Viewport.prepare!(Capybara::Screenshot.window_size, anchor: nil)
+      Capture::Viewport.prepare!(Capybara::Screenshot.window_size)
       prepare_screenshot_options
       check_base_screenshot
 
@@ -32,7 +32,7 @@ module SnapDiff
       # Pre-computation: No need to compare without base screenshot
       # NOTE: Consider to return PreValid Assertion Value Object with hard coded valid result
       unless need_to_compare?
-        CapybaraScreenshotDiff.record_new_screenshot(screenshot_full_name)
+        SnapDiff.session.record_new_screenshot(screenshot_full_name)
         return
       end
 
@@ -41,7 +41,7 @@ module SnapDiff
 
     # Captures a screenshot without comparing it to a baseline.
     def capture
-      Capture::Viewport.prepare!(Capybara::Screenshot.window_size, anchor: nil)
+      Capture::Viewport.prepare!(Capybara::Screenshot.window_size)
       prepare_screenshot_options
 
       capture_options, comparison_options = extract_capture_and_comparison_options(driver_options)
@@ -68,7 +68,7 @@ module SnapDiff
       @snapshot.checkout_base_screenshot
 
       if Capybara::Screenshot::Diff.fail_if_new && !@snapshot.base_path.exist?
-        raise CapybaraScreenshotDiff::ExpectationNotMet.new(<<~ERROR.chomp, caller)
+        raise SnapDiff::ExpectationNotMet.new(<<~ERROR.chomp, caller)
           No existing screenshot found for #{@snapshot.base_path}!
           To record baselines: RECORD_SCREENSHOTS=1 bundle exec rake test
           To allow new screenshots: Capybara::Screenshot::Diff.fail_if_new = false

data/lib/snap_diff/screenshoter.rb

@@ -88,7 +88,7 @@ module SnapDiff
         break unless pending_image
 
         if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline_at
-          raise CapybaraScreenshotDiff::ExpectationNotMet.new("Images have not been loaded after #{timeout}s: #{pending_image.inspect}", caller)
+          raise SnapDiff::ExpectationNotMet.new("Images have not been loaded after #{timeout}s: #{pending_image.inspect}", caller)
         end
 
         sleep 0.025

data/lib/snap_diff/snap_manager.rb

@@ -3,7 +3,6 @@
 require "fileutils"
 
 require_relative "vcs"
-require "active_support/core_ext/module/attribute_accessors"
 
 require_relative "snap"
 
@@ -100,7 +99,7 @@ module SnapDiff
     # manager class or screenshot root changes (tests re-root per example).
     #
     # Thread.current[] is fiber-local — same construct as
-    # CapybaraScreenshotDiff.registry; both split per fiber and must migrate
+    # SnapDiff.session; both split per fiber and must migrate
     # together if async support ever lands.
     #
     # Scope of the fix: default-root unit tests and before_setup re-rooters