diff --git a/Library/Homebrew/livecheck.rb b/Library/Homebrew/livecheck.rb
index efdf5339feba9..10e7a91f99024 100644
--- a/Library/Homebrew/livecheck.rb
+++ b/Library/Homebrew/livecheck.rb
@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "livecheck/constants"
+require "livecheck/options"
 require "cask/cask"
 
 # The {Livecheck} class implements the DSL methods used in a formula's, cask's
@@ -15,6 +16,10 @@
 class Livecheck
   extend Forwardable
 
+  # Options to modify livecheck's behavior.
+  sig { returns(Homebrew::Livecheck::Options) }
+  attr_reader :options
+
   # A very brief description of why the formula/cask/resource is skipped (e.g.
   # `No longer developed or maintained`).
   sig { returns(T.nilable(String)) }
@@ -24,13 +29,10 @@ class Livecheck
   sig { returns(T.nilable(Proc)) }
   attr_reader :strategy_block
 
-  # Options used by `Strategy` methods to modify `curl` behavior.
-  sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
-  attr_reader :url_options
-
   sig { params(package_or_resource: T.any(Cask::Cask, T.class_of(Formula), Resource)).void }
   def initialize(package_or_resource)
     @package_or_resource = package_or_resource
+    @options = T.let(Homebrew::Livecheck::Options.new, Homebrew::Livecheck::Options)
     @referenced_cask_name = T.let(nil, T.nilable(String))
     @referenced_formula_name = T.let(nil, T.nilable(String))
     @regex = T.let(nil, T.nilable(Regexp))
@@ -40,7 +42,6 @@ def initialize(package_or_resource)
     @strategy_block = T.let(nil, T.nilable(Proc))
     @throttle = T.let(nil, T.nilable(Integer))
     @url = T.let(nil, T.any(NilClass, String, Symbol))
-    @url_options = T.let(nil, T.nilable(T::Hash[Symbol, T.untyped]))
   end
 
   # Sets the `@referenced_cask_name` instance variable to the provided `String`
@@ -169,16 +170,18 @@ def throttle(rate = T.unsafe(nil))
   sig {
     params(
       # URL to check for version information.
-      url:       T.any(String, Symbol),
-      post_form: T.nilable(T::Hash[Symbol, String]),
-      post_json: T.nilable(T::Hash[Symbol, String]),
+      url:           T.any(String, Symbol),
+      homebrew_curl: T.nilable(T::Boolean),
+      post_form:     T.nilable(T::Hash[Symbol, String]),
+      post_json:     T.nilable(T::Hash[Symbol, String]),
     ).returns(T.nilable(T.any(String, Symbol)))
   }
-  def url(url = T.unsafe(nil), post_form: nil, post_json: nil)
+  def url(url = T.unsafe(nil), homebrew_curl: nil, post_form: nil, post_json: nil)
     raise ArgumentError, "Only use `post_form` or `post_json`, not both" if post_form && post_json
 
-    options = { post_form:, post_json: }.compact
-    @url_options = options if options.present?
+    @options.homebrew_curl = homebrew_curl unless homebrew_curl.nil?
+    @options.post_form = post_form unless post_form.nil?
+    @options.post_json = post_json unless post_json.nil?
 
     case url
     when nil
@@ -190,6 +193,7 @@ def url(url = T.unsafe(nil), post_form: nil, post_json: nil)
     end
   end
 
+  delegate url_options: :@options
   delegate version: :@package_or_resource
   delegate arch: :@package_or_resource
   private :version, :arch
@@ -198,15 +202,15 @@ def url(url = T.unsafe(nil), post_form: nil, post_json: nil)
   sig { returns(T::Hash[String, T.untyped]) }
   def to_hash
     {
-      "cask"        => @referenced_cask_name,
-      "formula"     => @referenced_formula_name,
-      "regex"       => @regex,
-      "skip"        => @skip,
-      "skip_msg"    => @skip_msg,
-      "strategy"    => @strategy,
-      "throttle"    => @throttle,
-      "url"         => @url,
-      "url_options" => @url_options,
+      "options"  => @options.to_hash,
+      "cask"     => @referenced_cask_name,
+      "formula"  => @referenced_formula_name,
+      "regex"    => @regex,
+      "skip"     => @skip,
+      "skip_msg" => @skip_msg,
+      "strategy" => @strategy,
+      "throttle" => @throttle,
+      "url"      => @url,
     }
   end
 end
diff --git a/Library/Homebrew/livecheck/livecheck.rb b/Library/Homebrew/livecheck/livecheck.rb
index d6be1c623cb49..52654a2d84869 100644
--- a/Library/Homebrew/livecheck/livecheck.rb
+++ b/Library/Homebrew/livecheck/livecheck.rb
@@ -34,6 +34,13 @@ module Livecheck
       @livecheck_strategy_names[strategy_class] ||= Utils.demodulize(strategy_class.name)
     end
 
+    sig { params(strategy_class: T::Class[T.anything]).returns(T::Array[Symbol]) }
+    private_class_method def self.livecheck_find_versions_parameters(strategy_class)
+      @livecheck_find_versions_parameters ||= T.let({}, T.nilable(T::Hash[T::Class[T.anything], T::Array[Symbol]]))
+      @livecheck_find_versions_parameters[strategy_class] ||=
+        T::Utils.signature_for_method(strategy_class.method(:find_versions)).parameters.map(&:second)
+    end
+
     # Uses `formulae_and_casks_to_check` to identify taps in use other than
     # homebrew/core and homebrew/cask and loads strategies from them.
     sig { params(formulae_and_casks_to_check: T::Array[T.any(Formula, Cask::Cask)]).void }
@@ -613,8 +620,9 @@ def self.latest_version(
       livecheck = formula_or_cask.livecheck
       referenced_livecheck = referenced_formula_or_cask&.livecheck
 
+      livecheck_options = livecheck.options || referenced_livecheck&.options
+      livecheck_url_options = livecheck_options.url_options.compact
       livecheck_url = livecheck.url || referenced_livecheck&.url
-      livecheck_url_options = livecheck.url_options || referenced_livecheck&.url_options
       livecheck_regex = livecheck.regex || referenced_livecheck&.regex
       livecheck_strategy = livecheck.strategy || referenced_livecheck&.strategy
       livecheck_strategy_block = livecheck.strategy_block || referenced_livecheck&.strategy_block
@@ -676,8 +684,8 @@ def self.latest_version(
           elsif original_url.present? && original_url != "None"
             puts "URL:              #{original_url}"
           end
-          puts "URL Options:      #{livecheck_url_options}" if livecheck_url_options.present?
           puts "URL (processed):  #{url}" if url != original_url
+          puts "URL Options:      #{livecheck_url_options}" if livecheck_url_options.present?
           if strategies.present? && verbose
             puts "Strategies:       #{strategies.map { |s| livecheck_strategy_names(s) }.join(", ")}"
           end
@@ -697,23 +705,25 @@ def self.latest_version(
 
         next if strategy.blank?
 
-        homebrew_curl = case strategy_name
-        when "PageMatch", "HeaderMatch"
-          use_homebrew_curl?(referenced_package, url)
+        if (livecheck_homebrew_curl = livecheck_options.homebrew_curl).nil?
+          case strategy_name
+          when "PageMatch", "HeaderMatch"
+            if (homebrew_curl = use_homebrew_curl?(referenced_package, url))
+              livecheck_options = livecheck_options.merge({ homebrew_curl: })
+              livecheck_homebrew_curl = homebrew_curl
+            end
+          end
         end
-        puts "Homebrew curl?:   Yes" if debug && homebrew_curl.present?
-
-        strategy_args = {
-          regex:         livecheck_regex,
-          url_options:   livecheck_url_options,
-          homebrew_curl:,
-        }
-        # TODO: Set `cask`/`url` args based on the presence of the keyword arg
-        # in the strategy's `#find_versions` method once we figure out why
-        # `strategy.method(:find_versions).parameters` isn't working as
-        # expected.
-        strategy_args[:cask] = cask if strategy_name == "ExtractPlist" && cask.present?
-        strategy_args[:url] = url
+        puts "Homebrew curl?:   #{livecheck_homebrew_curl ? "Yes" : "No"}" if debug && !livecheck_homebrew_curl.nil?
+
+        # Only use arguments that the strategy's `#find_versions` method
+        # supports
+        find_versions_parameters = livecheck_find_versions_parameters(strategy)
+        strategy_args = {}
+        strategy_args[:cask] = cask if find_versions_parameters.include?(:cask)
+        strategy_args[:url] = url if find_versions_parameters.include?(:url)
+        strategy_args[:regex] = livecheck_regex if find_versions_parameters.include?(:regex)
+        strategy_args[:options] = livecheck_options if find_versions_parameters.include?(:options)
         strategy_args.compact!
 
         strategy_data = strategy.find_versions(**strategy_args, &livecheck_strategy_block)
@@ -813,7 +823,6 @@ def self.latest_version(
             end
             version_info[:meta][:url][:final] = strategy_data[:final_url] if strategy_data[:final_url]
             version_info[:meta][:url][:options] = livecheck_url_options if livecheck_url_options.present?
-            version_info[:meta][:url][:homebrew_curl] = homebrew_curl if homebrew_curl.present?
           end
           version_info[:meta][:strategy] = strategy_name if strategy.present?
           version_info[:meta][:strategies] = strategies.map { |s| livecheck_strategy_names(s) } if strategies.present?
@@ -860,9 +869,10 @@ def self.resource_version(
       resource_version_info = {}
 
       livecheck = resource.livecheck
+      livecheck_options = livecheck.options
+      livecheck_url_options = livecheck_options.url_options.compact
       livecheck_reference = livecheck.formula
       livecheck_url = livecheck.url
-      livecheck_url_options = livecheck.url_options
       livecheck_regex = livecheck.regex
       livecheck_strategy = livecheck.strategy
       livecheck_strategy_block = livecheck.strategy_block
@@ -902,8 +912,8 @@ def self.resource_version(
           elsif original_url.present? && original_url != "None"
             puts "URL:              #{original_url}"
           end
-          puts "URL Options:      #{livecheck_url_options}" if livecheck_url_options.present?
           puts "URL (processed):  #{url}" if url != original_url
+          puts "URL Options:      #{livecheck_url_options}" if livecheck_url_options.present?
           if strategies.present? && verbose
             puts "Strategies:       #{strategies.map { |s| livecheck_strategy_names(s) }.join(", ")}"
           end
@@ -926,16 +936,22 @@ def self.resource_version(
         puts if debug && strategy.blank? && livecheck_reference != :parent
         next if strategy.blank? && livecheck_reference != :parent
 
+        if debug && !(livecheck_homebrew_curl = livecheck_options.homebrew_curl).nil?
+          puts "Homebrew curl?:   #{livecheck_homebrew_curl ? "Yes" : "No"}"
+        end
+
         if livecheck_reference == :parent
           match_version_map = { formula_latest => Version.new(formula_latest) }
           cached = true
         else
-          strategy_args = {
-            url:,
-            regex:         livecheck_regex,
-            url_options:   livecheck_url_options,
-            homebrew_curl: false,
-          }.compact
+          # Only use arguments that the strategy's `#find_versions` method
+          # supports
+          find_versions_parameters = livecheck_find_versions_parameters(strategy)
+          strategy_args = {}
+          strategy_args[:url] = url if find_versions_parameters.include?(:url)
+          strategy_args[:regex] = livecheck_regex if find_versions_parameters.include?(:regex)
+          strategy_args[:options] = livecheck_options if find_versions_parameters.include?(:options)
+          strategy_args.compact!
 
           strategy_data = strategy.find_versions(**strategy_args, &livecheck_strategy_block)
           match_version_map = strategy_data[:matches]
diff --git a/Library/Homebrew/livecheck/options.rb b/Library/Homebrew/livecheck/options.rb
new file mode 100644
index 0000000000000..307d393b14c1c
--- /dev/null
+++ b/Library/Homebrew/livecheck/options.rb
@@ -0,0 +1,105 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Homebrew
+  module Livecheck
+    # Options to modify livecheck's behavior. These primarily come from
+    # `livecheck` blocks but they can also be set by livecheck at runtime.
+    #
+    # Option values use a `nil` default to indicate that the value has not been
+    # set.
+    class Options < T::Struct
+      # Whether to use brewed curl.
+      prop :homebrew_curl, T.nilable(T::Boolean)
+
+      # Form data to use when making a `POST` request.
+      prop :post_form, T.nilable(T::Hash[Symbol, String])
+
+      # JSON data to use when making a `POST` request.
+      prop :post_json, T.nilable(T::Hash[Symbol, String])
+
+      # Returns a `Hash` of options that are provided as arguments to `url`.
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def url_options
+        {
+          homebrew_curl:,
+          post_form:,
+          post_json:,
+        }
+      end
+
+      # Returns a `Hash` of all instance variables, using `String` keys.
+      sig { returns(T::Hash[String, T.untyped]) }
+      def to_hash
+        T.let(serialize, T::Hash[String, T.untyped])
+      end
+
+      # Returns a `Hash` of all instance variables, using `Symbol` keys.
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def to_h = to_hash.transform_keys(&:to_sym)
+
+      # Returns a new object formed by merging `other` values with a copy of
+      # `self`.
+      #
+      # `nil` values are removed from `other` before merging if it is an
+      # `Options` object, as these are unitiailized values. This ensures that
+      # existing values in `self` aren't unexpectedly overwritten with defaults.
+      sig { params(other: T.any(Options, T::Hash[Symbol, T.untyped])).returns(Options) }
+      def merge(other)
+        return dup if other.empty?
+
+        this_hash = to_h
+        other_hash = other.is_a?(Options) ? other.to_h : other
+        return dup if this_hash == other_hash
+
+        new_options = this_hash.merge(other_hash)
+        Options.new(**new_options)
+      end
+
+      # Merges values from `other` into `self` and returns `self`.
+      #
+      # `nil` values are removed from `other` before merging if it is an
+      # `Options` object, as these are unitiailized values. This ensures that
+      # existing values in `self` aren't unexpectedly overwritten with defaults.
+      sig { params(other: T.any(Options, T::Hash[Symbol, T.untyped])).returns(Options) }
+      def merge!(other)
+        return self if other.empty?
+
+        if other.is_a?(Options)
+          return self if self == other
+
+          other.instance_variables.each do |ivar|
+            next if (v = T.let(other.instance_variable_get(ivar), Object)).nil?
+
+            instance_variable_set(ivar, v)
+          end
+        else
+          other.each do |k, v|
+            cmd = :"#{k}="
+            send(cmd, v) if respond_to?(cmd)
+          end
+        end
+
+        self
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        return false unless other.is_a?(Options)
+
+        @homebrew_curl == other.homebrew_curl &&
+          @post_form == other.post_form &&
+          @post_json == other.post_json
+      end
+      alias eql? ==
+
+      # Whether the object has only default values.
+      sig { returns(T::Boolean) }
+      def empty? = to_hash.empty?
+
+      # Whether the object has any non-default values.
+      sig { returns(T::Boolean) }
+      def present? = !empty?
+    end
+  end
+end
diff --git a/Library/Homebrew/livecheck/strategy.rb b/Library/Homebrew/livecheck/strategy.rb
index d591a7b7e9690..56d0ecb16839c 100644
--- a/Library/Homebrew/livecheck/strategy.rb
+++ b/Library/Homebrew/livecheck/strategy.rb
@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "utils/curl"
+require "livecheck/options"
 
 module Homebrew
   module Livecheck
@@ -193,23 +194,16 @@ def self.post_args(post_form: nil, post_json: nil)
       # collected into an array of hashes.
       #
       # @param url [String] the URL to fetch
-      # @param url_options [Hash] options to modify curl behavior
-      # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+      # @param options [Options] options to modify behavior
       # @return [Array]
-      sig {
-        params(
-          url:           String,
-          url_options:   T::Hash[Symbol, T.untyped],
-          homebrew_curl: T::Boolean,
-        ).returns(T::Array[T::Hash[String, String]])
-      }
-      def self.page_headers(url, url_options: {}, homebrew_curl: false)
+      sig { params(url: String, options: Options).returns(T::Array[T::Hash[String, String]]) }
+      def self.page_headers(url, options: Options.new)
         headers = []
 
-        if url_options[:post_form].present? || url_options[:post_json].present?
+        if options.post_form || options.post_json
           curl_post_args = ["--request", "POST", *post_args(
-            post_form: url_options[:post_form],
-            post_json: url_options[:post_json],
+            post_form: options.post_form,
+            post_json: options.post_json,
           )]
         end
 
@@ -221,7 +215,7 @@ def self.page_headers(url, url_options: {}, homebrew_curl: false)
               MAX_REDIRECTIONS.to_s,
               url,
               wanted_headers:    ["location", "content-disposition"],
-              use_homebrew_curl: homebrew_curl,
+              use_homebrew_curl: options.homebrew_curl || false,
               user_agent:,
               **DEFAULT_CURL_OPTIONS,
             )
@@ -242,21 +236,14 @@ def self.page_headers(url, url_options: {}, homebrew_curl: false)
       # array with the error message instead.
       #
       # @param url [String] the URL of the content to check
-      # @param url_options [Hash] options to modify curl behavior
-      # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+      # @param options [Options] options to modify behavior
       # @return [Hash]
-      sig {
-        params(
-          url:           String,
-          url_options:   T::Hash[Symbol, T.untyped],
-          homebrew_curl: T::Boolean,
-        ).returns(T::Hash[Symbol, T.untyped])
-      }
-      def self.page_content(url, url_options: {}, homebrew_curl: false)
-        if url_options[:post_form].present? || url_options[:post_json].present?
+      sig { params(url: String, options: Options).returns(T::Hash[Symbol, T.untyped]) }
+      def self.page_content(url, options: Options.new)
+        if options.post_form || options.post_json
           curl_post_args = ["--request", "POST", *post_args(
-            post_form: url_options[:post_form],
-            post_json: url_options[:post_json],
+            post_form: options.post_form,
+            post_json: options.post_json,
           )]
         end
 
@@ -266,7 +253,9 @@ def self.page_content(url, url_options: {}, homebrew_curl: false)
             *curl_post_args,
             *PAGE_CONTENT_CURL_ARGS, url,
             **DEFAULT_CURL_OPTIONS,
-            use_homebrew_curl: homebrew_curl || !curl_supports_fail_with_body?,
+            use_homebrew_curl: options.homebrew_curl ||
+                               !curl_supports_fail_with_body? ||
+                               false,
             user_agent:
           )
           next unless status.success?
diff --git a/Library/Homebrew/livecheck/strategy.rbi b/Library/Homebrew/livecheck/strategy.rbi
deleted file mode 100644
index 218530f2c3c75..0000000000000
--- a/Library/Homebrew/livecheck/strategy.rbi
+++ /dev/null
@@ -1,9 +0,0 @@
-# typed: strict
-
-module Homebrew
-  module Livecheck
-    module Strategy
-      include Kernel
-    end
-  end
-end
diff --git a/Library/Homebrew/livecheck/strategy/apache.rb b/Library/Homebrew/livecheck/strategy/apache.rb
index 9c3554d3983a0..f42c50495cbb5 100644
--- a/Library/Homebrew/livecheck/strategy/apache.rb
+++ b/Library/Homebrew/livecheck/strategy/apache.rb
@@ -85,19 +85,25 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
-          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(
+            url:     generated[:url],
+            regex:   regex || generated[:regex],
+            options:,
+            &block
+          )
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/bitbucket.rb b/Library/Homebrew/livecheck/strategy/bitbucket.rb
index 56a53b18c579b..47928faf59205 100644
--- a/Library/Homebrew/livecheck/strategy/bitbucket.rb
+++ b/Library/Homebrew/livecheck/strategy/bitbucket.rb
@@ -93,19 +93,25 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
-          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(
+            url:     generated[:url],
+            regex:   regex || generated[:regex],
+            options:,
+            &block
+          )
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/cpan.rb b/Library/Homebrew/livecheck/strategy/cpan.rb
index 828e4034d3384..528817e911fad 100644
--- a/Library/Homebrew/livecheck/strategy/cpan.rb
+++ b/Library/Homebrew/livecheck/strategy/cpan.rb
@@ -72,19 +72,25 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
-          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(
+            url:     generated[:url],
+            regex:   regex || generated[:regex],
+            options:,
+            &block
+          )
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/crate.rb b/Library/Homebrew/livecheck/strategy/crate.rb
index e37e3da27d6e5..fbe7a862faf8e 100644
--- a/Library/Homebrew/livecheck/strategy/crate.rb
+++ b/Library/Homebrew/livecheck/strategy/crate.rb
@@ -73,19 +73,18 @@ def self.generate_input_values(url)
         # @param regex [Regexp, nil] a regex for matching versions in content
         # @param provided_content [String, nil] content to check instead of
         #   fetching
-        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:              String,
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
-            homebrew_curl:    T::Boolean,
-            unused:           T.untyped,
+            options:          Options,
             block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **unused, &block)
+        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
           match_data = { matches: {}, regex:, url: }
           match_data[:cached] = true if provided_content.is_a?(String)
 
@@ -97,13 +96,7 @@ def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: f
           content = if provided_content
             provided_content
           else
-            match_data.merge!(
-              Strategy.page_content(
-                match_data[:url],
-                url_options:   unused.fetch(:url_options, {}),
-                homebrew_curl:,
-              ),
-            )
+            match_data.merge!(Strategy.page_content(match_data[:url], options:))
             match_data[:content]
           end
           return match_data unless content
diff --git a/Library/Homebrew/livecheck/strategy/electron_builder.rb b/Library/Homebrew/livecheck/strategy/electron_builder.rb
index ef1c935c58225..b499ac892b3d2 100644
--- a/Library/Homebrew/livecheck/strategy/electron_builder.rb
+++ b/Library/Homebrew/livecheck/strategy/electron_builder.rb
@@ -34,17 +34,18 @@ def self.match?(url)
         # @param regex [Regexp, nil] a regex used for matching versions
         # @param provided_content [String, nil] content to use in place of
         #   fetching via `Strategy#page_content`
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:              String,
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
-            unused:           T.untyped,
+            options:          Options,
             block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
           if regex.present? && block.blank?
             raise ArgumentError,
                   "#{Utils.demodulize(name)} only supports a regex when using a `strategy` block"
@@ -54,7 +55,7 @@ def self.find_versions(url:, regex: nil, provided_content: nil, **unused, &block
             url:,
             regex:,
             provided_content:,
-            **unused,
+            options:,
             &block || proc { |yaml| yaml["version"] }
           )
         end
diff --git a/Library/Homebrew/livecheck/strategy/extract_plist.rb b/Library/Homebrew/livecheck/strategy/extract_plist.rb
index be35992c4cd70..c35217a9db13e 100644
--- a/Library/Homebrew/livecheck/strategy/extract_plist.rb
+++ b/Library/Homebrew/livecheck/strategy/extract_plist.rb
@@ -79,17 +79,18 @@ def self.versions_from_items(items, regex = nil, &block)
         # @param url [String, nil] an alternative URL to check for version
         #   information
         # @param regex [Regexp, nil] a regex for use in a strategy block
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             cask:    Cask::Cask,
             url:     T.nilable(String),
             regex:   T.nilable(Regexp),
-            _unused: T.untyped,
+            options: Options,
             block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(cask:, url: nil, regex: nil, **_unused, &block)
+        def self.find_versions(cask:, url: nil, regex: nil, options: Options.new, &block)
           if regex.present? && block.blank?
             raise ArgumentError,
                   "#{Utils.demodulize(name)} only supports a regex when using a `strategy` block"
diff --git a/Library/Homebrew/livecheck/strategy/git.rb b/Library/Homebrew/livecheck/strategy/git.rb
index b263404888cfc..3af4e8f2c178f 100644
--- a/Library/Homebrew/livecheck/strategy/git.rb
+++ b/Library/Homebrew/livecheck/strategy/git.rb
@@ -186,16 +186,17 @@ def self.versions_from_tags(tags, regex = nil, &block)
         #
         # @param url [String] the URL of the Git repository to check
         # @param regex [Regexp, nil] a regex used for matching versions
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:     String,
             regex:   T.nilable(Regexp),
-            _unused: T.untyped,
+            options: Options,
             block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **_unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           match_data = { matches: {}, regex:, url: }
 
           tags_data = tag_info(url, regex)
diff --git a/Library/Homebrew/livecheck/strategy/github_latest.rb b/Library/Homebrew/livecheck/strategy/github_latest.rb
index 4655ce1d1faed..387239cae0b72 100644
--- a/Library/Homebrew/livecheck/strategy/github_latest.rb
+++ b/Library/Homebrew/livecheck/strategy/github_latest.rb
@@ -70,16 +70,17 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:     String,
             regex:   Regexp,
-            _unused: T.untyped,
+            options: Options,
             block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: GithubReleases::DEFAULT_REGEX, **_unused, &block)
+        def self.find_versions(url:, regex: GithubReleases::DEFAULT_REGEX, options: Options.new, &block)
           match_data = { matches: {}, regex:, url: }
 
           generated = generate_input_values(url)
diff --git a/Library/Homebrew/livecheck/strategy/github_releases.rb b/Library/Homebrew/livecheck/strategy/github_releases.rb
index a37b3a561152f..aec819f2fb12e 100644
--- a/Library/Homebrew/livecheck/strategy/github_releases.rb
+++ b/Library/Homebrew/livecheck/strategy/github_releases.rb
@@ -124,16 +124,17 @@ def self.versions_from_content(content, regex, &block)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:     String,
             regex:   Regexp,
-            _unused: T.untyped,
+            options: Options,
             block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: DEFAULT_REGEX, **_unused, &block)
+        def self.find_versions(url:, regex: DEFAULT_REGEX, options: Options.new, &block)
           match_data = { matches: {}, regex:, url: }
 
           generated = generate_input_values(url)
diff --git a/Library/Homebrew/livecheck/strategy/gnome.rb b/Library/Homebrew/livecheck/strategy/gnome.rb
index 9a8828d9922ba..dd3a83e46e99c 100644
--- a/Library/Homebrew/livecheck/strategy/gnome.rb
+++ b/Library/Homebrew/livecheck/strategy/gnome.rb
@@ -74,22 +74,23 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
           version_data = PageMatch.find_versions(
-            url:   generated[:url],
-            regex: regex || generated[:regex],
-            **unused,
+            url:     generated[:url],
+            regex:   regex || generated[:regex],
+            options:,
             &block
           )
 
diff --git a/Library/Homebrew/livecheck/strategy/gnu.rb b/Library/Homebrew/livecheck/strategy/gnu.rb
index 027c689506d32..3abd9bc15fc30 100644
--- a/Library/Homebrew/livecheck/strategy/gnu.rb
+++ b/Library/Homebrew/livecheck/strategy/gnu.rb
@@ -84,19 +84,25 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
-          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(
+            url:     generated[:url],
+            regex:   regex || generated[:regex],
+            options:,
+            &block
+          )
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/hackage.rb b/Library/Homebrew/livecheck/strategy/hackage.rb
index fea597c1a036e..21143f7cf10f0 100644
--- a/Library/Homebrew/livecheck/strategy/hackage.rb
+++ b/Library/Homebrew/livecheck/strategy/hackage.rb
@@ -70,19 +70,25 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
-          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(
+            url:     generated[:url],
+            regex:   regex || generated[:regex],
+            options:,
+            &block
+          )
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/header_match.rb b/Library/Homebrew/livecheck/strategy/header_match.rb
index e6f2c3a3aa579..b64e7810568a0 100644
--- a/Library/Homebrew/livecheck/strategy/header_match.rb
+++ b/Library/Homebrew/livecheck/strategy/header_match.rb
@@ -67,25 +67,20 @@ def self.versions_from_headers(headers, regex = nil, &block)
         #
         # @param url [String] the URL to fetch
         # @param regex [Regexp, nil] a regex used for matching versions
-        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:           String,
-            regex:         T.nilable(Regexp),
-            homebrew_curl: T::Boolean,
-            unused:        T.untyped,
-            block:         T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, homebrew_curl: false, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           match_data = { matches: {}, regex:, url: }
 
-          headers = Strategy.page_headers(
-            url,
-            url_options:   unused.fetch(:url_options, {}),
-            homebrew_curl:,
-          )
+          headers = Strategy.page_headers(url, options:)
 
           # Merge the headers from all responses into one hash
           merged_headers = headers.reduce(&:merge)
diff --git a/Library/Homebrew/livecheck/strategy/json.rb b/Library/Homebrew/livecheck/strategy/json.rb
index af681d9730573..546bb3814d82c 100644
--- a/Library/Homebrew/livecheck/strategy/json.rb
+++ b/Library/Homebrew/livecheck/strategy/json.rb
@@ -94,19 +94,18 @@ def self.versions_from_content(content, regex = nil, &block)
         # @param regex [Regexp, nil] a regex used for matching versions
         # @param provided_content [String, nil] page content to use in place of
         #   fetching via `Strategy#page_content`
-        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:              String,
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
-            homebrew_curl:    T::Boolean,
-            unused:           T.untyped,
+            options:          Options,
             block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **unused, &block)
+        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
           raise ArgumentError, "#{Utils.demodulize(name)} requires a `strategy` block" if block.blank?
 
           match_data = { matches: {}, regex:, url: }
@@ -116,13 +115,7 @@ def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: f
             match_data[:cached] = true
             provided_content
           else
-            match_data.merge!(
-              Strategy.page_content(
-                url,
-                url_options:   unused.fetch(:url_options, {}),
-                homebrew_curl:,
-              ),
-            )
+            match_data.merge!(Strategy.page_content(url, options:))
             match_data[:content]
           end
           return match_data if content.blank?
diff --git a/Library/Homebrew/livecheck/strategy/launchpad.rb b/Library/Homebrew/livecheck/strategy/launchpad.rb
index 8fc33cfea198b..c47679b856b71 100644
--- a/Library/Homebrew/livecheck/strategy/launchpad.rb
+++ b/Library/Homebrew/livecheck/strategy/launchpad.rb
@@ -67,19 +67,25 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  Regexp,
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   Regexp,
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: DEFAULT_REGEX, **unused, &block)
+        def self.find_versions(url:, regex: DEFAULT_REGEX, options: Options.new, &block)
           generated = generate_input_values(url)
 
-          PageMatch.find_versions(url: generated[:url], regex:, **unused, &block)
+          PageMatch.find_versions(
+            url:     generated[:url],
+            regex:,
+            options:,
+            &block
+          )
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/npm.rb b/Library/Homebrew/livecheck/strategy/npm.rb
index b020e6a48ead9..8f12088d29e69 100644
--- a/Library/Homebrew/livecheck/strategy/npm.rb
+++ b/Library/Homebrew/livecheck/strategy/npm.rb
@@ -65,19 +65,25 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
-          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(
+            url:     generated[:url],
+            regex:   regex || generated[:regex],
+            options:,
+            &block
+          )
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/page_match.rb b/Library/Homebrew/livecheck/strategy/page_match.rb
index 36397cd387004..601930ba84a06 100644
--- a/Library/Homebrew/livecheck/strategy/page_match.rb
+++ b/Library/Homebrew/livecheck/strategy/page_match.rb
@@ -77,19 +77,18 @@ def self.versions_from_content(content, regex, &block)
         # @param regex [Regexp, nil] a regex used for matching versions
         # @param provided_content [String, nil] page content to use in place of
         #   fetching via `Strategy#page_content`
-        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:              String,
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
-            homebrew_curl:    T::Boolean,
-            unused:           T.untyped,
+            options:          Options,
             block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **unused, &block)
+        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
           if regex.blank? && block.blank?
             raise ArgumentError, "#{Utils.demodulize(name)} requires a regex or `strategy` block"
           end
@@ -101,13 +100,7 @@ def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: f
             match_data[:cached] = true
             provided_content
           else
-            match_data.merge!(
-              Strategy.page_content(
-                url,
-                url_options:   unused.fetch(:url_options, {}),
-                homebrew_curl:,
-              ),
-            )
+            match_data.merge!(Strategy.page_content(url, options:))
             match_data[:content]
           end
           return match_data if content.blank?
diff --git a/Library/Homebrew/livecheck/strategy/pypi.rb b/Library/Homebrew/livecheck/strategy/pypi.rb
index 8711a2264a539..b13042abe83a2 100644
--- a/Library/Homebrew/livecheck/strategy/pypi.rb
+++ b/Library/Homebrew/livecheck/strategy/pypi.rb
@@ -79,17 +79,18 @@ def self.generate_input_values(url)
         # @param regex [Regexp] a regex used for matching versions in content
         # @param provided_content [String, nil] content to check instead of
         #   fetching
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:              String,
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
-            unused:           T.untyped,
+            options:          Options,
             block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
           match_data = { matches: {}, regex:, url: }
 
           generated = generate_input_values(url)
@@ -99,7 +100,7 @@ def self.find_versions(url:, regex: nil, provided_content: nil, **unused, &block
             url:              generated[:url],
             regex:,
             provided_content:,
-            **unused,
+            options:,
             &block || DEFAULT_BLOCK
           )
         end
diff --git a/Library/Homebrew/livecheck/strategy/sourceforge.rb b/Library/Homebrew/livecheck/strategy/sourceforge.rb
index 539000b4f210c..9096ae8629bf1 100644
--- a/Library/Homebrew/livecheck/strategy/sourceforge.rb
+++ b/Library/Homebrew/livecheck/strategy/sourceforge.rb
@@ -84,22 +84,23 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
 
           PageMatch.find_versions(
-            url:   generated[:url] || url,
-            regex: regex || generated[:regex],
-            **unused,
+            url:     generated[:url] || url,
+            regex:   regex || generated[:regex],
+            options:,
             &block
           )
         end
diff --git a/Library/Homebrew/livecheck/strategy/sparkle.rb b/Library/Homebrew/livecheck/strategy/sparkle.rb
index fac81a6a79763..051880d3209c7 100644
--- a/Library/Homebrew/livecheck/strategy/sparkle.rb
+++ b/Library/Homebrew/livecheck/strategy/sparkle.rb
@@ -214,18 +214,17 @@ def self.versions_from_content(content, regex = nil, &block)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp, nil] a regex for use in a strategy block
-        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:           String,
-            regex:         T.nilable(Regexp),
-            homebrew_curl: T::Boolean,
-            unused:        T.untyped,
-            block:         T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, homebrew_curl: false, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           if regex.present? && block.blank?
             raise ArgumentError,
                   "#{Utils.demodulize(name)} only supports a regex when using a `strategy` block"
@@ -233,13 +232,7 @@ def self.find_versions(url:, regex: nil, homebrew_curl: false, **unused, &block)
 
           match_data = { matches: {}, regex:, url: }
 
-          match_data.merge!(
-            Strategy.page_content(
-              url,
-              url_options:   unused.fetch(:url_options, {}),
-              homebrew_curl:,
-            ),
-          )
+          match_data.merge!(Strategy.page_content(url, options:))
           content = match_data.delete(:content)
           return match_data if content.blank?
 
diff --git a/Library/Homebrew/livecheck/strategy/xml.rb b/Library/Homebrew/livecheck/strategy/xml.rb
index 08096a5102977..2971014b876f7 100644
--- a/Library/Homebrew/livecheck/strategy/xml.rb
+++ b/Library/Homebrew/livecheck/strategy/xml.rb
@@ -134,19 +134,18 @@ def self.versions_from_content(content, regex = nil, &block)
         # @param regex [Regexp, nil] a regex used for matching versions
         # @param provided_content [String, nil] page content to use in place of
         #   fetching via `Strategy#page_content`
-        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:              String,
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
-            homebrew_curl:    T::Boolean,
-            unused:           T.untyped,
+            options:          Options,
             block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **unused, &block)
+        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
           raise ArgumentError, "#{Utils.demodulize(name)} requires a `strategy` block" if block.blank?
 
           match_data = { matches: {}, regex:, url: }
@@ -156,13 +155,7 @@ def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: f
             match_data[:cached] = true
             provided_content
           else
-            match_data.merge!(
-              Strategy.page_content(
-                url,
-                url_options:   unused.fetch(:url_options, {}),
-                homebrew_curl:,
-              ),
-            )
+            match_data.merge!(Strategy.page_content(url, options:))
             match_data[:content]
           end
           return match_data if content.blank?
diff --git a/Library/Homebrew/livecheck/strategy/xorg.rb b/Library/Homebrew/livecheck/strategy/xorg.rb
index ab5f4cef66e3d..ac93e2726ba0b 100644
--- a/Library/Homebrew/livecheck/strategy/xorg.rb
+++ b/Library/Homebrew/livecheck/strategy/xorg.rb
@@ -109,16 +109,17 @@ def self.generate_input_values(url)
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.untyped,
-            block:  T.nilable(Proc),
+            url:     String,
+            regex:   T.nilable(Regexp),
+            options: Options,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: nil, options: Options.new, &block)
           generated = generate_input_values(url)
           generated_url = generated[:url]
 
@@ -128,7 +129,7 @@ def self.find_versions(url:, regex: nil, **unused, &block)
             url:              generated_url,
             regex:            regex || generated[:regex],
             provided_content: cached_content,
-            **unused,
+            options:,
             &block
           )
 
diff --git a/Library/Homebrew/livecheck/strategy/yaml.rb b/Library/Homebrew/livecheck/strategy/yaml.rb
index 0c89a14e175d8..e791cd81e2549 100644
--- a/Library/Homebrew/livecheck/strategy/yaml.rb
+++ b/Library/Homebrew/livecheck/strategy/yaml.rb
@@ -94,19 +94,18 @@ def self.versions_from_content(content, regex = nil, &block)
         # @param regex [Regexp, nil] a regex used for matching versions
         # @param provided_content [String, nil] page content to use in place of
         #   fetching via `Strategy#page_content`
-        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @param options [Options] options to modify behavior
         # @return [Hash]
         sig {
           params(
             url:              String,
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
-            homebrew_curl:    T::Boolean,
-            unused:           T.untyped,
+            options:          Options,
             block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **unused, &block)
+        def self.find_versions(url:, regex: nil, provided_content: nil, options: Options.new, &block)
           raise ArgumentError, "#{Utils.demodulize(name)} requires a `strategy` block" if block.blank?
 
           match_data = { matches: {}, regex:, url: }
@@ -116,13 +115,7 @@ def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: f
             match_data[:cached] = true
             provided_content
           else
-            match_data.merge!(
-              Strategy.page_content(
-                url,
-                url_options:   unused.fetch(:url_options, {}),
-                homebrew_curl:,
-              ),
-            )
+            match_data.merge!(Strategy.page_content(url, options:))
             match_data[:content]
           end
           return match_data if content.blank?
diff --git a/Library/Homebrew/test/livecheck/livecheck_spec.rb b/Library/Homebrew/test/livecheck/livecheck_spec.rb
index c28ff3e59260e..eab430f208d00 100644
--- a/Library/Homebrew/test/livecheck/livecheck_spec.rb
+++ b/Library/Homebrew/test/livecheck/livecheck_spec.rb
@@ -86,6 +86,22 @@
     end
   end
 
+  describe "::livecheck_find_versions_parameters" do
+    context "when provided with a strategy class" do
+      it "returns demodulized class name" do
+        page_match_parameters = T::Utils.signature_for_method(
+          Homebrew::Livecheck::Strategy::PageMatch.method(:find_versions),
+        ).parameters.map(&:second)
+
+        # We run this twice with the same argument to exercise the caching logic
+        expect(livecheck.send(:livecheck_find_versions_parameters, Homebrew::Livecheck::Strategy::PageMatch))
+          .to eq(page_match_parameters)
+        expect(livecheck.send(:livecheck_find_versions_parameters, Homebrew::Livecheck::Strategy::PageMatch))
+          .to eq(page_match_parameters)
+      end
+    end
+  end
+
   describe "::resolve_livecheck_reference" do
     context "when a formula/cask has a `livecheck` block without formula/cask methods" do
       it "returns [nil, []]" do
diff --git a/Library/Homebrew/test/livecheck/options_spec.rb b/Library/Homebrew/test/livecheck/options_spec.rb
new file mode 100644
index 0000000000000..468deb6f4e246
--- /dev/null
+++ b/Library/Homebrew/test/livecheck/options_spec.rb
@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "livecheck/options"
+
+RSpec.describe Homebrew::Livecheck::Options do
+  subject(:options) { described_class }
+
+  let(:post_hash) do
+    {
+      empty:   "",
+      boolean: "true",
+      number:  "1",
+      string:  "a + b = c",
+    }
+  end
+  let(:args) do
+    {
+      homebrew_curl: true,
+      post_form:     post_hash,
+      post_json:     post_hash,
+    }
+  end
+  let(:other_args) do
+    {
+      post_form: { something: "else" },
+    }
+  end
+  let(:merged_hash) { args.merge(other_args) }
+
+  let(:base_options) { options.new(**args) }
+  let(:other_options) { options.new(**other_args) }
+  let(:merged_options) { options.new(**merged_hash) }
+
+  describe "#url_options" do
+    it "returns a Hash of the options that are provided as arguments to the `url` DSL method" do
+      expect(options.new.url_options).to eq({
+        homebrew_curl: nil,
+        post_form:     nil,
+        post_json:     nil,
+      })
+    end
+  end
+
+  describe "#to_h" do
+    it "returns a Hash of all instance variables" do
+      # `T::Struct.serialize` omits `nil` values
+      expect(options.new.to_h).to eq({})
+
+      expect(options.new(**args).to_h).to eq(args)
+    end
+  end
+
+  describe "#to_hash" do
+    it "returns a Hash of all instance variables, using String keys" do
+      # `T::Struct.serialize` omits `nil` values
+      expect(options.new.to_hash).to eq({})
+
+      expect(options.new(**args).to_hash).to eq(args.transform_keys(&:to_s))
+    end
+  end
+
+  describe "#merge" do
+    it "returns an Options object with merged values" do
+      expect(options.new(**args).merge(other_args))
+        .to eq(options.new(**merged_hash))
+      expect(options.new(**args).merge(options.new(**other_args)))
+        .to eq(options.new(**merged_hash))
+      expect(options.new(**args).merge(args))
+        .to eq(options.new(**args))
+      expect(options.new(**args).merge({}))
+        .to eq(options.new(**args))
+    end
+  end
+
+  describe "#merge!" do
+    it "merges values from `other` into `self` and returns `self`" do
+      o1 = options.new(**args)
+      expect(o1.merge!(other_options)).to eq(merged_options)
+      expect(o1).to eq(merged_options)
+
+      o2 = options.new(**args)
+      expect(o2.merge!(other_args)).to eq(merged_options)
+      expect(o2).to eq(merged_options)
+
+      o3 = options.new(**args)
+      expect(o3.merge!(base_options)).to eq(base_options)
+      expect(o3).to eq(base_options)
+
+      o4 = options.new(**args)
+      expect(o4.merge!(args)).to eq(base_options)
+      expect(o4).to eq(base_options)
+
+      o5 = options.new(**args)
+      expect(o5.merge!(options.new)).to eq(base_options)
+      expect(o5).to eq(base_options)
+
+      o6 = options.new(**args)
+      expect(o6.merge!({})).to eq(base_options)
+      expect(o6).to eq(base_options)
+    end
+
+    it "skips over hash values without a corresponding Options value" do
+      o1 = options.new(**args)
+      expect(o1.merge!({ nonexistent: true })).to eq(base_options)
+      expect(o1).to eq(base_options)
+    end
+  end
+
+  describe "#==" do
+    it "returns true if all instance variables are the same" do
+      obj_with_args1 = options.new(**args)
+      obj_with_args2 = options.new(**args)
+      expect(obj_with_args1 == obj_with_args2).to be true
+
+      default_obj1 = options.new
+      default_obj2 = options.new
+      expect(default_obj1 == default_obj2).to be true
+    end
+
+    it "returns false if any instance variables differ" do
+      expect(options.new == options.new(**args)).to be false
+    end
+
+    it "returns false if other object is not the same class" do
+      expect(options.new == :other).to be false
+    end
+  end
+
+  describe "#empty?" do
+    it "returns true if object has only default values" do
+      expect(options.new.empty?).to be true
+    end
+
+    it "returns false if object has any non-default values" do
+      expect(options.new(**args).empty?).to be false
+    end
+  end
+
+  describe "#present?" do
+    it "returns false if object has only default values" do
+      expect(options.new.present?).to be false
+    end
+
+    it "returns true if object has any non-default values" do
+      expect(options.new(**args).present?).to be true
+    end
+  end
+end
diff --git a/Library/Homebrew/test/livecheck/strategy_spec.rb b/Library/Homebrew/test/livecheck/strategy_spec.rb
index bb701e3b43783..4ef416c33106d 100644
--- a/Library/Homebrew/test/livecheck/strategy_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy_spec.rb
@@ -181,8 +181,12 @@
     it "handles `post_form` `url` options" do
       allow(strategy).to receive(:curl_headers).and_return({ responses:, body: })
 
-      expect(strategy.page_headers(url, url_options: { post_form: post_hash }))
-        .to eq([responses.first[:headers]])
+      expect(
+        strategy.page_headers(
+          url,
+          options: Homebrew::Livecheck::Options.new(post_form: post_hash),
+        ),
+      ).to eq([responses.first[:headers]])
     end
 
     it "returns an empty array if `curl_headers` only raises an `ErrorDuringExecution` error" do
@@ -207,14 +211,24 @@
       allow_any_instance_of(Utils::Curl).to receive(:curl_version).and_return(curl_version)
       allow(strategy).to receive(:curl_output).and_return([response_text[:ok], nil, success_status])
 
-      expect(strategy.page_content(url, url_options: { post_form: post_hash })).to eq({ content: body })
+      expect(
+        strategy.page_content(
+          url,
+          options: Homebrew::Livecheck::Options.new(post_form: post_hash),
+        ),
+      ).to eq({ content: body })
     end
 
     it "handles `post_json` `url` option" do
       allow_any_instance_of(Utils::Curl).to receive(:curl_version).and_return(curl_version)
       allow(strategy).to receive(:curl_output).and_return([response_text[:ok], nil, success_status])
 
-      expect(strategy.page_content(url, url_options: { post_json: post_hash })).to eq({ content: body })
+      expect(
+        strategy.page_content(
+          url,
+          options: Homebrew::Livecheck::Options.new(post_json: post_hash),
+        ),
+      ).to eq({ content: body })
     end
 
     it "returns error `messages` from `stderr` in the return hash on failure when `stderr` is not `nil`" do
diff --git a/Library/Homebrew/test/livecheck_spec.rb b/Library/Homebrew/test/livecheck_spec.rb
index e52fd76265020..ba5bde56e0f28 100644
--- a/Library/Homebrew/test/livecheck_spec.rb
+++ b/Library/Homebrew/test/livecheck_spec.rb
@@ -156,10 +156,17 @@
       expect(livecheck_c.url).to eq(:url)
     end
 
-    it "sets `url_options` when provided" do
-      post_args = { post_form: post_hash }
-      livecheck_f.url(url_string, **post_args)
-      expect(livecheck_f.url_options).to eq(post_args)
+    it "sets `url` options when provided" do
+      # This test makes sure that we can set multiple options at once and
+      # options from subsequent `url` calls are merged with existing values
+      # (i.e. existing values aren't reset to `nil`). [We only call `url` once
+      # in a `livecheck` block but this should technically work due to how it's
+      # implemented.]
+      livecheck_f.url(url_string, homebrew_curl: true, post_form: post_hash)
+      livecheck_f.url(url_string, post_json: post_hash)
+      expect(livecheck_f.options.homebrew_curl).to be(true)
+      expect(livecheck_f.options.post_form).to eq(post_hash)
+      expect(livecheck_f.options.post_json).to eq(post_hash)
     end
 
     it "raises an ArgumentError if the argument isn't a valid Symbol" do
@@ -179,15 +186,15 @@
     it "returns a Hash of all instance variables" do
       expect(livecheck_f.to_hash).to eq(
         {
-          "cask"        => nil,
-          "formula"     => nil,
-          "regex"       => nil,
-          "skip"        => false,
-          "skip_msg"    => nil,
-          "strategy"    => nil,
-          "throttle"    => nil,
-          "url"         => nil,
-          "url_options" => nil,
+          "options"  => Homebrew::Livecheck::Options.new.to_hash,
+          "cask"     => nil,
+          "formula"  => nil,
+          "regex"    => nil,
+          "skip"     => false,
+          "skip_msg" => nil,
+          "strategy" => nil,
+          "throttle" => nil,
+          "url"      => nil,
         },
       )
     end