html2rss 0.30.0 → 0.31.0

data/lib/html2rss/mcp/server/tools.rb

@@ -4,25 +4,37 @@ module Html2rss
   module MCP
     module Server
       ##
-      # MCP tool registration and outcome mapping over public html2rss APIs.
+      # MCP tool registry: typed {Tool} values over public html2rss APIs.
       module Tools # rubocop:disable Metrics/ModuleLength -- declarative registry + substantive handlers
-        # Declarative MCP tool registrations consumed by {register_all}.
+        Tool = Data.define(:name, :title, :description, :input_schema, :annotations, :call)
+
+        ##
+        # One published MCP tool. +call+ is a lambda with explicit keyword defaults.
+        # +annotations+ is {Contract::ANNOTATIONS_OPEN_WORLD} unless a tool overrides it.
+        class Tool # rubocop:disable Lint/EmptyClass -- Data members only; handlers are +call+ lambdas
+        end
+
+        # Published MCP tools consumed by {Server.register_tools}.
         TOOLS = [
-          {
+          Tool.new(
             name: 'scrape',
-            kind: :url,
+            title: 'Scrape',
             description: 'One-shot article extraction as JSON Feed items. ' \
                          'Use when you need articles now without a saved config. ' \
                          'strategy "auto" triggers fallback chain (default → botasaurus) for JS-rendered sites.',
             input_schema: Contract::SCRAPE_INPUT_SCHEMA,
-            handler: :scrape_outcome
-          },
-          {
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |url:, strategy: 'auto', limit: 25, items_selector: nil, **|
+              scrape_outcome(url:, strategy:, limit:, items_selector:)
+            }
+          ),
+          Tool.new(
             name: 'inspect',
-            kind: :url,
+            title: 'Inspect',
             description: 'Diagnostic page analysis (scrapers, SST, segments, final URL, status, ' \
                          'rel=alternate feeds). Use recon for BUILD/DEFER/DROP verdict and native_feed preference.',
             input_schema: Contract::INSPECT_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |url:, strategy: 'auto', **|
               Outcome.inspect(
                 report: PageRecon::Diagnostics.call(
@@ -30,45 +42,60 @@ module Html2rss
                 )
               )
             }
-          },
-          {
+          ),
+          Tool.new(
             name: 'recon',
-            kind: :url,
+            title: 'Recon',
             description: 'Curation verdict and native_feed preference for a URL. ' \
                          'Use after inspect when alternates warrant deeper recon, or when you need BUILD/DEFER/DROP.',
             input_schema: Contract::RECON_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |url:, strategy: 'auto', **|
               Outcome.recon(result: Html2rss.recon(url, strategy: Runtime.coerce_strategy(strategy)))
             }
-          },
-          {
+          ),
+          Tool.new(
             name: 'batch_scrape',
-            kind: :batch,
-            batch_method: :batch_scrape,
-            limit_default: 10,
+            title: 'Batch scrape',
             description: 'Scrape multiple URLs in parallel with per-URL error isolation. ' \
                          'Returns structured JSON Feed items and extraction counts.',
-            input_schema: Contract::BATCH_SCRAPE_INPUT_SCHEMA
-          },
-          {
+            input_schema: Contract::BATCH_SCRAPE_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, limit: 10, **|
+              Outcome.batch_scrape(
+                Batch.batch_scrape(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:, limit:)
+              )
+            }
+          ),
+          Tool.new(
             name: 'batch_inspect',
-            kind: :batch,
-            batch_method: :batch_inspect,
+            title: 'Batch inspect',
             description: 'Inspect multiple URLs in parallel with per-URL error isolation. ' \
                          'Returns final redirected URLs, status codes, and rel="alternate" feeds.',
-            input_schema: Contract::BATCH_INSPECT_INPUT_SCHEMA
-          },
-          {
+            input_schema: Contract::BATCH_INSPECT_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, **|
+              Outcome.batch_inspect(
+                Batch.batch_inspect(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:)
+              )
+            }
+          ),
+          Tool.new(
             name: 'batch_recon',
-            kind: :batch,
-            batch_method: :batch_recon,
+            title: 'Batch recon',
             description: 'Run recon across multiple URLs in parallel with per-URL error isolation. ' \
                          'Returns verdict, native_feed, and surface classification per URL.',
-            input_schema: Contract::BATCH_RECON_INPUT_SCHEMA
-          },
-          {
+            input_schema: Contract::BATCH_RECON_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, **|
+              Outcome.batch_recon(
+                Batch.batch_recon(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:)
+              )
+            }
+          ),
+          Tool.new(
             name: 'capture',
-            kind: :capture,
+            title: 'Capture',
             description: 'Derive a reusable html2rss feed config from a URL. ' \
                          'Use when the goal is a durable YAML (then test → apply). ' \
                          'Returns YAML inside payload.yaml (same serializer as CLI capture). ' \
@@ -76,134 +103,65 @@ module Html2rss
                          'enhance defaults from admission evidence (false when chrome drops are high). ' \
                          'Full schema options live in resource html2rss://schema.',
             input_schema: Contract::CAPTURE_INPUT_SCHEMA,
-            handler: :capture_outcome
-          },
-          {
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |url:, strategy: 'auto', items_selector: nil, force: false, topics: nil, title: nil,
+                              summary: nil, enhance: nil, limit: nil, max_redirects: nil, max_requests: nil, **|
+              capture_outcome(url:, strategy:, items_selector:, force:, topics:, title:, summary:,
+                              enhance:, limit:, max_redirects:, max_requests:)
+            }
+          ),
+          Tool.new(
             name: 'validate',
-            kind: :config_xor,
+            title: 'Validate',
             description: 'Validate a feed config hash XOR yaml string against the html2rss JSON schema. ' \
-                         'Call before test. Failures return isError with payload.errors. ' \
+                         'Call before test. Failures return isError with payload.issues. ' \
                          'Full schema lives in resource html2rss://schema.',
             input_schema: Contract::CONFIG_XOR_SCHEMA,
             annotations: Contract::ANNOTATIONS_VALIDATE,
             call: lambda { |config: nil, yaml: nil, **|
-              validation = Html2rss::Config.validate(ConfigArgument.parse(config:, yaml:).config)
-              Outcome.validate(errors: validation.success? ? nil : validation.errors.to_h)
+              Outcome.validate(report: Html2rss::Config.validate(ConfigArgument.parse(config:, yaml:).config))
             }
-          },
-          {
+          ),
+          Tool.new(
             name: 'test',
-            kind: :config_xor,
+            title: 'Test',
             description: 'Validate schema and execute live extraction (asserting >= min_items items). ' \
                          'Call after capture or validate; on success next_step is apply. ' \
                          'Returns test summary in payload with sample items, timing, failure_kind, ' \
                          'and quality_report (warnings for duplicate URLs, junk titles, native feed). ' \
                          'Set strict_quality to fail on duplicate URLs, >50% junk titles, or short titles.',
             input_schema: Contract::TEST_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |config: nil, yaml: nil, min_items: 1, strict_quality: false,
                               compare_enhance: false, **kwargs|
               feed_config = ConfigArgument.parse(config:, yaml:).config
               test_args = { min_items:, strict_quality:, compare_enhance: }
               test_args[:strategy] = Runtime.coerce_strategy(kwargs[:strategy]) if kwargs.key?(:strategy)
-              test_result = Html2rss.test(feed_config, **test_args)
-              Outcome.test(test_result)
+              Outcome.test(Html2rss.test(feed_config, **test_args))
             }
-          },
-          {
+          ),
+          Tool.new(
             name: 'apply',
-            kind: :config_xor,
+            title: 'Apply',
             description: 'Apply a validated feed config (hash XOR yaml) and return RSS XML in payload.rss. ' \
                          'isError when the feed has zero items (ship gate). payload.item_count is RSS item count. ' \
                          'Use after test succeeds.',
             input_schema: Contract::APPLY_INPUT_SCHEMA,
-            handler: :apply_outcome
-          }
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |url:, config: nil, yaml: nil, **|
+              apply_outcome(url:, config:, yaml:)
+            }
+          )
         ].freeze
 
-        class << self # rubocop:disable Metrics/ClassLength -- registration engine + handlers
+        class << self
           ##
-          # Registers all MCP tools on +server+ via +registrar+ (Server.define_envelope_tool).
-          #
-          # @param server [::MCP::Server]
-          # @param registrar [Proc]
-          # @return [void]
-          def register_all(server, registrar:)
-            TOOLS.each { |entry| register_tool(server, registrar, entry) }
-          end
-
-          private
-
-          def register_tool(server, registrar, entry)
-            case entry[:kind]
-            when :url then register_url_tool(server, registrar, entry)
-            when :batch then register_batch_tool(server, registrar, entry)
-            when :config_xor then register_config_xor_tool(server, registrar, entry)
-            when :capture then register_capture_tool(server, registrar, entry)
-            else raise ArgumentError, "unknown tool kind: #{entry[:kind].inspect}"
-            end
-          end
-
-          def register_url_tool(server, registrar, entry)
-            handler = entry[:handler] ? method(entry[:handler]) : entry[:call]
-            registrar.call(
-              server,
-              name: entry[:name],
-              description: entry[:description],
-              input_schema: entry[:input_schema],
-              annotations: entry.fetch(:annotations, Contract::ANNOTATIONS_OPEN_WORLD)
-            ) do |**kwargs|
-              handler.call(**tool_kwargs(kwargs))
-            end
-          end
-
-          def register_batch_tool(server, registrar, entry) # rubocop:disable Metrics/MethodLength
-            name = entry[:name]
-            batch_method = entry[:batch_method]
-            limit_default = entry[:limit_default]
-            registrar.call(
-              server,
-              name:,
-              description: entry[:description],
-              input_schema: entry[:input_schema]
-            ) do |urls:, strategy: 'auto', **kwargs|
-              concurrency = kwargs.fetch(:concurrency, Batch::DEFAULT_CONCURRENCY)
-              batch_args = { urls:, strategy: Runtime.coerce_strategy(strategy), concurrency: }
-              batch_args[:limit] = kwargs.fetch(:limit, limit_default) unless limit_default.nil?
-              Outcome.public_send(name, Batch.public_send(batch_method, **batch_args))
-            end
-          end
-
-          def register_config_xor_tool(server, registrar, entry)
-            handler = entry[:handler] ? method(entry[:handler]) : entry[:call]
-            registrar.call(
-              server,
-              name: entry[:name],
-              description: entry[:description],
-              input_schema: entry[:input_schema],
-              annotations: entry.fetch(:annotations, Contract::ANNOTATIONS_OPEN_WORLD)
-            ) do |**kwargs|
-              handler.call(**tool_kwargs(kwargs))
-            end
-          end
-
-          def register_capture_tool(server, registrar, entry)
-            handler = method(entry[:handler])
-            registrar.call(
-              server,
-              name: entry[:name],
-              description: entry[:description],
-              input_schema: entry[:input_schema]
-            ) do |**kwargs|
-              handler.call(**tool_kwargs(kwargs))
-            end
-          end
-
-          def tool_kwargs(inputs)
-            args = inputs.dup
-            args.delete(:server_context)
-            args
-          end
-
+          # @api private
+          # @param url [String]
+          # @param strategy [String, Symbol]
+          # @param limit [Integer]
+          # @param items_selector [String, nil]
+          # @return [Outcome]
           def scrape_outcome(url:, strategy: 'auto', limit: 25, items_selector: nil)
             wire = Batch.scrape_wire(url:, strategy: Runtime.coerce_strategy(strategy), limit:, items_selector:)
             Outcome.scrape(
@@ -215,6 +173,20 @@ module Html2rss
             )
           end
 
+          ##
+          # @api private
+          # @param url [String]
+          # @param strategy [String, Symbol]
+          # @param items_selector [String, nil]
+          # @param force [Boolean]
+          # @param topics [Array<String>, nil]
+          # @param title [String, nil]
+          # @param summary [String, nil]
+          # @param enhance [Boolean, nil]
+          # @param limit [Integer, nil]
+          # @param max_redirects [Integer, nil]
+          # @param max_requests [Integer, nil]
+          # @return [Outcome]
           def capture_outcome(url:, strategy: 'auto', items_selector: nil, force: false, topics: nil, title: nil, # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
                               summary: nil, enhance: nil, limit: nil, max_redirects: nil, max_requests: nil)
             plan = Runtime.coerce_strategy(strategy)
@@ -245,6 +217,12 @@ module Html2rss
             )
           end
 
+          ##
+          # @api private
+          # @param url [String]
+          # @param config [Hash, nil]
+          # @param yaml [String, nil]
+          # @return [Outcome]
           def apply_outcome(url:, config: nil, yaml: nil)
             feed_config = HashUtil.deep_dup(ConfigArgument.parse(config:, yaml:).config)
             feed_config[:channel] ||= {}
@@ -253,12 +231,14 @@ module Html2rss
             apply_feed_outcome(feed_config, feed_result, outcome)
           end
 
+          private
+
           def apply_feed_outcome(feed_config, feed_result, outcome) # rubocop:disable Metrics/MethodLength -- quality_report + RSS payload
             rss = feed_result.to_rss
             quality_report = Html2rss::Test.quality_report_for(
               rss.items,
               channel_url: feed_config.dig(:channel, :url).to_s,
-              raw_config: feed_config,
+              config: Html2rss::Config.from_hash(feed_config),
               feed_result:,
               pipeline_outcome: outcome,
               probe_native_feed: false

data/lib/html2rss/mcp/server.rb

@@ -20,6 +20,9 @@ module Html2rss
       # Loopback bind for HTTP transport (local use only).
       HTTP_BIND_HOST = '127.0.0.1'
 
+      # Supported transport names.
+      TRANSPORTS = Set[:stdio, :http].freeze
+
       # Declarative MCP resource registrations consumed by {register_resources}.
       RESOURCES = [
         {
@@ -29,7 +32,7 @@ module Html2rss
           mime_type: 'application/json',
           body: lambda {
             [{ uri: 'html2rss://schema', mimeType: 'application/json',
-               text: Html2rss::Config.json_schema_json(pretty: true) }]
+               text: Html2rss::Config::Schema.json_schema_json(pretty: true) }]
           }
         },
         {
@@ -93,7 +96,7 @@ module Html2rss
         # @param transport [Symbol] +:stdio+ or +:http+
         # @param port [Integer] port for HTTP transport
         def start(transport: :stdio, port: 8080)
-          raise ArgumentError, "Unknown transport: #{transport.inspect}" unless %i[stdio http].include?(transport)
+          raise ArgumentError, "Unknown transport: #{transport.inspect}" unless TRANSPORTS.include?(transport)
 
           configure_daemon_logging!
           app = build
@@ -137,8 +140,12 @@ module Html2rss
 
         def protocol_configuration
           ::MCP::Configuration.new.tap do |config|
-            config.exception_reporter = method(:report_protocol_exception)
-            config.around_request = method(:around_protocol_request)
+            config.exception_reporter = lambda { |error, server_context|
+              report_protocol_exception(error, server_context)
+            }
+            config.around_request = lambda { |data, &block|
+              around_protocol_request(data, &block)
+            }
             config.validate_tool_call_results = true
           end
         end
@@ -217,26 +224,27 @@ module Html2rss
           tool_error_response(error)
         end
 
+        def register_tools(server)
+          Tools::TOOLS.each { |tool| register_envelope_tool(server, tool) }
+        end
+
         # rubocop:disable-next Metrics/MethodLength -- listing fields stay together
-        def define_envelope_tool(server, name:, description:, input_schema:,
-                                 annotations: Contract::ANNOTATIONS_OPEN_WORLD)
-          run = method(:handle_tool_call)
+        def register_envelope_tool(server, tool)
+          invoke = ->(&block) { handle_tool_call(&block) }
           server.define_tool(
-            name:,
-            title: Contract::TITLES.fetch(name.to_sym),
-            description:,
-            annotations:,
-            input_schema:,
+            name: tool.name,
+            title: tool.title,
+            description: tool.description,
+            annotations: tool.annotations,
+            input_schema: tool.input_schema,
             output_schema: Contract.output_schema
           ) do |**kwargs|
-            run.call { yield(**kwargs) }
+            args = kwargs.dup
+            args.delete(:server_context)
+            invoke.call { tool.call.call(**args) }
           end
         end
 
-        def register_tools(server)
-          Tools.register_all(server, registrar: method(:define_envelope_tool))
-        end
-
         def register_resources(server)
           RESOURCES.each do |entry|
             server.define_resource(
@@ -251,7 +259,7 @@ module Html2rss
         end
 
         def register_prompts(server) # rubocop:disable Metrics/MethodLength -- prompt argument mapping
-          to_result = method(:prompt_result)
+          to_result = ->(text) { prompt_result(text) }
           PROMPTS.each do |entry|
             arguments = entry[:arguments].map do |spec|
               ::MCP::Prompt::Argument.new(name: spec[:name], description: spec[:description],

data/lib/html2rss/page_recon/README.md

@@ -13,7 +13,7 @@
 | `alternate_feeds`  | `rel=alternate` RSS/Atom links found in HTML                                |
 | `surface_category` | AutoSource surface class (`high_entropy_surface`, `unsupported_surface`, …) |
 | `articles_count`   | Cheap AutoSource extract (limit 10) — diagnostic only, not ship quality     |
-| `strategy`         | Concrete transport used (`inspect` maps `auto` → Faraday)                   |
+| `strategy`         | Concrete transport used (`inspect` maps `auto` → default (HTTPX))           |
 
 CLI text output omits `requested_url`; it prints the requested URL as the card title. The `Final:` line appears **only when** `final_url` differs from `requested_url`:
 
@@ -39,16 +39,16 @@ bin/html2rss inspect https://www.example
 # high_entropy_surface, articles (no Final: line — requested equals final)
 ```
 
-Cross-host redirects (e.g. `apex.example` → `www.example`) no longer pin a stale `Host` header from the entry URL. `Config::RequestHeaders` omits `Host` by default; Faraday/Net::HTTP sets it per hop from the current request URL.
+Cross-host redirects (e.g. `apex.example` → `www.example`) no longer pin a stale `Host` header from the entry URL. `Config::RequestHeaders` omits `Host` by default; HTTPX sets it per hop from the current request URL.
 
-When the first streamed fetch loses the redirect payload (empty body at the final URL), `FaradayStrategy` retries once without streaming so inspect/recon see the same HTML as a direct canonical URL fetch.
+When the first streamed fetch loses the redirect payload (empty body at the final URL), `HttpxStrategy` retries once without streaming so inspect/recon see the same HTML as a direct canonical URL fetch.
 
 ### What to do
 
 1. **Prefer the canonical URL** — if you know the site lives on `www`, pass that URL to inspect, recon, capture, and scrape.
 2. **Read the `Final:` line** — when `final_url` differs from what you typed and status is 4xx, retry inspect on `final_url` before assuming the site is unreachable.
 3. **Do not treat apex 403 as “redirect skipped”** — check JSON output (`--format json`) for `requested_url` vs `final_url` when text output is ambiguous.
-4. **Blocked surfaces** — if the canonical URL still fails, try `strategy: botasaurus` on inspect (MCP) or escalate to recon/capture with browser strategy; Faraday-only inspect is intentionally cheap.
+4. **Blocked surfaces** — if the canonical URL still fails, try `strategy: botasaurus` on inspect (MCP) or escalate to recon/capture with browser strategy; default (HTTPX)-only inspect is intentionally cheap.
 
 ## inspect ≠ recon
 
@@ -65,5 +65,5 @@ Follow golden-path `next_step` from MCP envelopes; do not call recon when inspec
 | ----------------------------------- | -------------------------------------------------------------------- |
 | Diagnostic fetch + assess           | `PageRecon::Diagnostics` → `PageRecon.probe`                         |
 | Surface class + cheap article count | `PageRecon::Assessment`                                              |
-| Redirect follow + terminal retry    | `RequestService::FaradayStrategy`                                    |
+| Redirect follow + terminal retry    | `RequestService::HttpxStrategy`                                      |
 | Outbound header normalization       | `Config::RequestHeaders` (no default `Host`; explicit override only) |

data/lib/html2rss/page_recon/diagnostics.rb

@@ -6,9 +6,11 @@ module Html2rss
     # Diagnostic inspect path (not Capture or Recon ownership). Fetches via {.probe},
     # then adds scraper/XHR diagnostics for curation inspect surfaces.
     module Diagnostics # rubocop:disable Metrics/ModuleLength -- diagnostic wire fields stay co-located
+      Report = Data.define(:data)
+
       ##
       # Typed diagnostic report for inspect wire payloads and Outcome policy.
-      Report = Data.define(:data) do
+      class Report
         ##
         # @return [Boolean]
         def alternate_feeds?
@@ -115,97 +117,85 @@ module Html2rss
         end
       end
 
-      def build_data(probe, recon, response)
-        data = recon.to_h.merge(
-          strategy: probe.strategy,
-          scraper_eligibility: scraper_info(safe_parsed_body(response)),
-          html_present: html_present?(recon, response),
-          likely_js_shell: likely_js_shell?(recon, response),
-          redirect_summary: redirect_summary(recon)
-        )
-        data[:xhr_capture] = xhr_capture_info(response) if probe.strategy == :botasaurus
-        log_js_shell(data, response.body&.bytesize.to_i) if data[:likely_js_shell]
-        data
-      end
-      module_function :build_data
-      private_class_method :build_data
+      class << self
+        private
+
+        def build_data(probe, recon, response)
+          data = recon.to_h.merge(
+            strategy: probe.strategy,
+            scraper_eligibility: scraper_info(safe_parsed_body(response)),
+            html_present: html_present?(recon, response),
+            likely_js_shell: likely_js_shell?(recon, response),
+            redirect_summary: redirect_summary(recon)
+          )
+          data[:xhr_capture] = xhr_capture_info(response) if probe.strategy == :botasaurus
+          log_js_shell(data, response.body&.bytesize.to_i) if data[:likely_js_shell]
+          data
+        end
 
-      def resolve_inspect_strategy(strategy, deep:)
-        name = (strategy || :auto).to_sym
-        return :botasaurus if deep && name == :auto && MCP::Runtime.botasaurus_configured?
+        def resolve_inspect_strategy(strategy, deep:)
+          name = (strategy || :auto).to_sym
+          return :botasaurus if deep && name == :auto && MCP::Runtime.botasaurus_configured?
 
-        name
-      end
-      module_function :resolve_inspect_strategy
-      private_class_method :resolve_inspect_strategy
+          name
+        end
 
-      def html_present?(recon, response)
-        recon.html_response && !response.body.to_s.empty?
-      end
-      module_function :html_present?
-      private_class_method :html_present?
+        def html_present?(recon, response)
+          recon.html_response && !response.body.to_s.empty?
+        end
 
-      def likely_js_shell?(recon, response)
-        return false unless html_present?(recon, response)
-        return false if recon.articles_count.positive?
-        return false if recon.blocked_surface || recon.surface_category == :blocked_surface
+        def likely_js_shell?(recon, response)
+          return false unless html_present?(recon, response)
+          return false if recon.articles_count.positive?
+          return false if recon.blocked_surface || recon.surface_category == :blocked_surface
 
-        return true if recon.surface_category == :app_shell
+          return true if recon.surface_category == :app_shell
 
-        response.body.bytesize >= JS_SHELL_MIN_BODY_BYTES &&
-          SurfaceCategory.coerce(recon.surface_category).weak?
-      end
-      module_function :likely_js_shell?
-      private_class_method :likely_js_shell?
+          response.body.bytesize >= JS_SHELL_MIN_BODY_BYTES &&
+            SurfaceCategory[recon.surface_category].weak?
+        end
 
-      def redirect_summary(recon)
-        {
-          requested_url: recon.requested_url,
-          final_url: recon.final_url,
-          status: recon.status,
-          scheme_downgrade: recon.scheme_downgrade
-        }
-      end
-      module_function :redirect_summary
-      private_class_method :redirect_summary
+        def redirect_summary(recon)
+          {
+            requested_url: recon.requested_url,
+            final_url: recon.final_url,
+            status: recon.status,
+            scheme_downgrade: recon.scheme_downgrade
+          }
+        end
 
-      def log_js_shell(data, body_bytesize)
-        Log.debug(
-          "Diagnostics js_shell: bytesize=#{body_bytesize} surface_category=#{data[:surface_category]}"
-        )
-      end
-      module_function :log_js_shell
-      private_class_method :log_js_shell
+        def log_js_shell(data, body_bytesize)
+          Log.debug(
+            "Diagnostics js_shell: bytesize=#{body_bytesize} surface_category=#{data[:surface_category]}"
+          )
+        end
 
-      def safe_parsed_body(response)
-        return unless response.html_response?
+        def safe_parsed_body(response)
+          return unless response.html_response?
 
-        response.parsed_body
-      rescue RequestService::UnsupportedResponseContentType
-        nil
-      end
-      module_function :safe_parsed_body
-      private_class_method :safe_parsed_body
-
-      def error_report(url, error) # rubocop:disable Metrics/MethodLength -- error hash mirrors success report shape
-        Report.new(
-          data: {
-            requested_url: url.to_s,
-            final_url: url.to_s,
-            status: nil,
-            scheme_downgrade: false,
-            alternate_feeds: [],
-            surface_category: :unsupported_surface,
-            articles_count: 0,
-            html_response: false,
-            content_type: nil,
-            strategy: nil,
-            scraper_eligibility: { error: "#{error.class} - #{error.message}" }
-          }
-        )
+          response.parsed_body
+        rescue RequestService::UnsupportedResponseContentType
+          nil
+        end
+
+        def error_report(url, error) # rubocop:disable Metrics/MethodLength -- error hash mirrors success report shape
+          Report.new(
+            data: {
+              requested_url: url.to_s,
+              final_url: url.to_s,
+              status: nil,
+              scheme_downgrade: false,
+              alternate_feeds: [],
+              surface_category: :unsupported_surface,
+              articles_count: 0,
+              html_response: false,
+              content_type: nil,
+              strategy: nil,
+              scraper_eligibility: { error: "#{error.class} - #{error.message}" }
+            }
+          )
+        end
       end
-      module_function :error_report
-      private_class_method :error_report
     end
   end
 end