parse-stack-next 5.6.0 → 5.7.0

data/lib/parse/embeddings/jina.rb

@@ -63,36 +63,36 @@ module Parse
       class RateLimitError < Error; end
       class TransientError < Error; end
 
-      DEFAULT_BASE_URL    = "https://api.jina.ai/v1"
-      DEFAULT_MODEL       = "jina-embeddings-v3"
-      DEFAULT_TIMEOUT     = 30
+      DEFAULT_BASE_URL = "https://api.jina.ai/v1"
+      DEFAULT_MODEL = "jina-embeddings-v3"
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
       DEFAULT_MAX_RETRIES = 3
-      DEFAULT_BATCH_SIZE  = 100
-      MAX_RESPONSE_BYTES  = 16 * 1024 * 1024
+      DEFAULT_BATCH_SIZE = 100
+      MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
       # Native vector widths. The Matryoshka-capable rows allow the
       # caller to truncate via the `dimensions:` kwarg.
       MODEL_DEFAULT_DIMENSIONS = {
         "jina-embeddings-v5-omni-small" => 1024,
-        "jina-embeddings-v5-omni-nano"  => 512,
+        "jina-embeddings-v5-omni-nano" => 512,
         "jina-embeddings-v5-text-small" => 1024,
-        "jina-embeddings-v5-text-nano"  => 512,
-        "jina-embeddings-v4"            => 2048,
-        "jina-embeddings-v3"            => 1024,
-        "jina-code-embeddings-1.5b"     => 1024,
-        "jina-code-embeddings-0.5b"     => 1024,
+        "jina-embeddings-v5-text-nano" => 512,
+        "jina-embeddings-v4" => 2048,
+        "jina-embeddings-v3" => 1024,
+        "jina-code-embeddings-1.5b" => 1024,
+        "jina-code-embeddings-0.5b" => 1024,
       }.freeze
 
       MODEL_MAX_INPUT_TOKENS = {
         "jina-embeddings-v5-omni-small" => 32_000,
-        "jina-embeddings-v5-omni-nano"  => 32_000,
+        "jina-embeddings-v5-omni-nano" => 32_000,
         "jina-embeddings-v5-text-small" => 32_000,
-        "jina-embeddings-v5-text-nano"  => 32_000,
-        "jina-embeddings-v4"            => 32_000,
-        "jina-embeddings-v3"            => 8_192,
-        "jina-code-embeddings-1.5b"     => 32_000,
-        "jina-code-embeddings-0.5b"     => 32_000,
+        "jina-embeddings-v5-text-nano" => 32_000,
+        "jina-embeddings-v4" => 32_000,
+        "jina-embeddings-v3" => 8_192,
+        "jina-code-embeddings-1.5b" => 32_000,
+        "jina-code-embeddings-0.5b" => 32_000,
       }.freeze
 
       # Models that accept the Matryoshka `dimensions` field. Other
@@ -108,10 +108,10 @@ module Parse
 
       # Map SDK-canonical input_type symbols to Jina `task` strings.
       INPUT_TYPE_WIRE_VALUES = {
-        search_query:    "retrieval.query",
+        search_query: "retrieval.query",
         search_document: "retrieval.passage",
-        classification:  "classification",
-        clustering:      "separation",
+        classification: "classification",
+        clustering: "separation",
       }.freeze
 
       # @param api_key [String] required. Sent as `Authorization: Bearer …`.
@@ -352,7 +352,7 @@ module Parse
       end
 
       def backoff_seconds(attempt)
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)

data/lib/parse/embeddings/local_http.rb

@@ -78,11 +78,11 @@ module Parse
       class RateLimitError < Error; end
       class TransientError < Error; end
 
-      DEFAULT_TIMEOUT      = 30
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
-      DEFAULT_MAX_RETRIES  = 3
-      DEFAULT_BATCH_SIZE   = 32
-      MAX_RESPONSE_BYTES   = 16 * 1024 * 1024
+      DEFAULT_MAX_RETRIES = 3
+      DEFAULT_BATCH_SIZE = 32
+      MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
       # @param base_url [String] required. Must be http(s):// with a host.
       # @param model [String] required. Identifier the local server expects
@@ -353,7 +353,7 @@ module Parse
       end
 
       def backoff_seconds(attempt)
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)
@@ -414,8 +414,7 @@ module Parse
         # Empty-resolution under allow_private_endpoint is treated as
         # private for the http:// scheme gate below, since the operator
         # has already asserted local-class trust.
-        is_private =
-          if resolved.empty?
+        is_private = if resolved.empty?
             allow_private_endpoint
           else
             resolved.any? { |ip| Parse::File::BLOCKED_CIDRS.any? { |cidr| cidr.include?(ip) } }

data/lib/parse/embeddings/media_file.rb

@@ -55,14 +55,14 @@ module Parse
           mime = ImageFetch.sniff_mime(header)
           if mime.nil?
             raise ImageFetch::InvalidImageType.new(:unknown_magic,
-              "Parse::Embeddings::MediaFile.image: #{path} matches no supported image " \
-              "format (JPEG/PNG/GIF/WebP).")
+                                                   "Parse::Embeddings::MediaFile.image: #{path} matches no supported image " \
+                                                   "format (JPEG/PNG/GIF/WebP).")
           end
           allowed = Parse::Embeddings.allowed_image_types
           unless allowed.include?(mime)
             raise ImageFetch::InvalidImageType.new(:type_not_allowed,
-              "Parse::Embeddings::MediaFile.image: sniffed type #{mime.inspect} is not in " \
-              "Parse::Embeddings.allowed_image_types (#{allowed.inspect}).")
+                                                   "Parse::Embeddings::MediaFile.image: sniffed type #{mime.inspect} is not in " \
+                                                   "Parse::Embeddings.allowed_image_types (#{allowed.inspect}).")
           end
           new(path: path, mime_type: mime, kind: :image)
         end
@@ -130,6 +130,7 @@ module Parse
         "#<Parse::Embeddings::MediaFile kind=#{@kind} mime_type=#{@mime_type.inspect} " \
         "bytes=#{@byte_size} path=#{@path.inspect}>"
       end
+
       alias_method :to_s, :inspect
     end
   end

data/lib/parse/embeddings/openai.rb

@@ -49,12 +49,12 @@ module Parse
       class RateLimitError < Error; end
       class TransientError < Error; end
 
-      DEFAULT_BASE_URL    = "https://api.openai.com/v1"
-      DEFAULT_MODEL       = "text-embedding-3-small"
-      DEFAULT_TIMEOUT     = 30
+      DEFAULT_BASE_URL = "https://api.openai.com/v1"
+      DEFAULT_MODEL = "text-embedding-3-small"
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
       DEFAULT_MAX_RETRIES = 3
-      DEFAULT_BATCH_SIZE  = 100
+      DEFAULT_BATCH_SIZE = 100
 
       # Hard ceiling on the response body we'll parse. A legitimate
       # OpenAI embeddings response for the worst-case configuration
@@ -397,7 +397,7 @@ module Parse
       # synchronize the retry storm exponentially.
       def backoff_seconds(attempt)
         # 0.5, 1.0, 2.0, 4.0, 8.0 …  capped at 30s
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)

data/lib/parse/embeddings/provider.rb

@@ -245,7 +245,7 @@ module Parse
       def inspect_attrs
         out = {}
         out[:model] = safe_call(:model_name)
-        out[:dim]   = safe_call(:dimensions)
+        out[:dim] = safe_call(:dimensions)
         out.compact
       end
 

data/lib/parse/embeddings/qwen.rb

@@ -60,27 +60,27 @@ module Parse
       # Default to the international compatible-mode host. Operators
       # in mainland China should override to
       # `https://dashscope.aliyuncs.com/compatible-mode/v1`.
-      DEFAULT_BASE_URL    = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-      DEFAULT_MODEL       = "qwen3-embedding-8b"
-      DEFAULT_TIMEOUT     = 30
+      DEFAULT_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+      DEFAULT_MODEL = "qwen3-embedding-8b"
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
       DEFAULT_MAX_RETRIES = 3
       # DashScope's compatible endpoint caps embedding requests at 25
       # inputs per call (smaller than OpenAI's 2048). Default below
       # the cap so callers don't have to tune.
-      DEFAULT_BATCH_SIZE  = 10
-      MAX_RESPONSE_BYTES  = 16 * 1024 * 1024
+      DEFAULT_BATCH_SIZE = 10
+      MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
       MODEL_DEFAULT_DIMENSIONS = {
         "qwen3-embedding-0.6b" => 1024,
-        "qwen3-embedding-4b"   => 2560,
-        "qwen3-embedding-8b"   => 4096,
+        "qwen3-embedding-4b" => 2560,
+        "qwen3-embedding-8b" => 4096,
       }.freeze
 
       MODEL_MAX_INPUT_TOKENS = {
         "qwen3-embedding-0.6b" => 32_000,
-        "qwen3-embedding-4b"   => 32_000,
-        "qwen3-embedding-8b"   => 32_000,
+        "qwen3-embedding-4b" => 32_000,
+        "qwen3-embedding-8b" => 32_000,
       }.freeze
 
       # Every Qwen3-Embedding row is Matryoshka-capable. Kept as an
@@ -329,7 +329,7 @@ module Parse
       end
 
       def backoff_seconds(attempt)
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)

data/lib/parse/embeddings/spend_cap.rb

@@ -118,8 +118,7 @@ module Parse
             end
           end
           mutex.synchronize do
-            limits[key] =
-              if limit_tokens.nil?
+            limits[key] = if limit_tokens.nil?
                 nil
               else
                 cfg = { limit: Integer(limit_tokens), window: w }
@@ -357,7 +356,7 @@ module Parse
         # must not serialize every other tenant's charge).
         def emit_soft_cap_warning(payload)
           return unless defined?(ActiveSupport::Notifications)
-          ActiveSupport::Notifications.instrument(AS_NOTIFICATION_NAME, payload) {}
+          ActiveSupport::Notifications.instrument(AS_NOTIFICATION_NAME, payload) { }
         rescue StandardError
           # A raising subscriber must not turn a successful (admitted)
           # charge into a caller-visible failure.

data/lib/parse/embeddings/streaming_body.rb

@@ -69,6 +69,7 @@ module Parse
           seg.is_a?(String) ? seg.bytesize : 4 * ((seg[:size] + 2) / 3)
         end
       end
+
       alias_method :length, :size
 
       # @param len [Integer, nil] bytes wanted; nil reads to the end
@@ -83,8 +84,7 @@ module Parse
           return len.nil? ? "" : nil
         end
 
-        chunk =
-          if len.nil?
+        chunk = if len.nil?
             b = @buffer
             @buffer = +""
             b
@@ -137,16 +137,16 @@ module Parse
           end
 
           @io ||= begin
-            f = ::File.open(seg[:path], "rb")
-            actual = f.size
-            if actual != seg[:size]
-              f.close
-              raise SizeMismatch,
-                    "Parse::Embeddings::StreamingBody: #{seg[:path]} is #{actual} bytes but " \
-                    "#{seg[:size]} was declared; the file changed underneath the request."
+              f = ::File.open(seg[:path], "rb")
+              actual = f.size
+              if actual != seg[:size]
+                f.close
+                raise SizeMismatch,
+                      "Parse::Embeddings::StreamingBody: #{seg[:path]} is #{actual} bytes but " \
+                      "#{seg[:size]} was declared; the file changed underneath the request."
+              end
+              f
             end
-            f
-          end
 
           data = @io.read(READ_CHUNK)
           if data.nil? || data.empty?

data/lib/parse/embeddings/video_source.rb

@@ -31,6 +31,7 @@ module Parse
       class InvalidVideoType < Parse::Embeddings::Error
         # @return [Symbol] failure-mode tag.
         attr_reader :reason
+
         def initialize(reason, message)
           @reason = reason
           super(message)
@@ -98,20 +99,20 @@ module Parse
       def verify!(bytes)
         if bytes.nil? || bytes.empty?
           raise InvalidVideoType.new(:empty,
-            "Parse::Embeddings::VideoSource: video payload is empty.")
+                                     "Parse::Embeddings::VideoSource: video payload is empty.")
         end
         mime = sniff_mime(bytes)
         if mime.nil?
           raise InvalidVideoType.new(:unknown_magic,
-            "Parse::Embeddings::VideoSource: leading bytes match no supported video " \
-            "container (MP4/QuickTime/WebM). The Content-Type header is not consulted — " \
-            "unrecognized content is refused outright.")
+                                     "Parse::Embeddings::VideoSource: leading bytes match no supported video " \
+                                     "container (MP4/QuickTime/WebM). The Content-Type header is not consulted — " \
+                                     "unrecognized content is refused outright.")
         end
         allowed = Parse::Embeddings.allowed_video_types
         unless allowed.include?(mime)
           raise InvalidVideoType.new(:type_not_allowed,
-            "Parse::Embeddings::VideoSource: sniffed type #{mime.inspect} is not in " \
-            "Parse::Embeddings.allowed_video_types (#{allowed.inspect}).")
+                                     "Parse::Embeddings::VideoSource: sniffed type #{mime.inspect} is not in " \
+                                     "Parse::Embeddings.allowed_video_types (#{allowed.inspect}).")
         end
         mime
       end

data/lib/parse/embeddings/voyage.rb

@@ -109,23 +109,23 @@ module Parse
       class RateLimitError < Error; end
       class TransientError < Error; end
 
-      DEFAULT_BASE_URL    = "https://api.voyageai.com/v1"
+      DEFAULT_BASE_URL = "https://api.voyageai.com/v1"
       # MongoDB's Atlas Embedding and Reranking API re-exposes the same
       # Voyage models under a MongoDB-operated host. The wire contract
       # (request envelopes, response envelopes, error shapes) is
       # identical — only the host and the credential differ.
-      ATLAS_BASE_URL      = "https://ai.mongodb.com/v1"
+      ATLAS_BASE_URL = "https://ai.mongodb.com/v1"
       # Bumped from `voyage-3` in 5.6.0: that model is retired from the
       # Atlas endpoint, so an Atlas key used without naming a model
       # failed at construction. `voyage-3.5` is served by both
       # endpoints and shares the 1024 native width.
-      DEFAULT_MODEL       = "voyage-3.5"
-      DEFAULT_TIMEOUT     = 30
+      DEFAULT_MODEL = "voyage-3.5"
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
       DEFAULT_MAX_RETRIES = 3
       # Voyage's documented per-request cap is 128 inputs.
-      DEFAULT_BATCH_SIZE  = 128
-      MAX_RESPONSE_BYTES  = 16 * 1024 * 1024
+      DEFAULT_BATCH_SIZE = 128
+      MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
       # Default (native) vector width per model — the width returned
       # when `output_dimension` is omitted from the request.
@@ -138,20 +138,20 @@ module Parse
       # Verified against the live API for every model reachable
       # through {ATLAS_BASE_URL}; see {MODEL_SUPPORTED_DIMENSIONS}.
       MODEL_DEFAULT_DIMENSIONS = {
-        "voyage-4-large"        => 1024,
-        "voyage-4"              => 1024,
-        "voyage-4-lite"         => 1024,
-        "voyage-4-nano"         => 1024,
-        "voyage-3-large"        => 1024,
-        "voyage-3.5"            => 1024,
-        "voyage-3.5-lite"       => 1024,
-        "voyage-3"              => 1024,
-        "voyage-3-lite"         => 512,
-        "voyage-code-3"         => 1024,
-        "voyage-code-2"         => 1536,
-        "voyage-finance-2"      => 1024,
-        "voyage-law-2"          => 1024,
-        "voyage-multimodal-3"   => 1024,
+        "voyage-4-large" => 1024,
+        "voyage-4" => 1024,
+        "voyage-4-lite" => 1024,
+        "voyage-4-nano" => 1024,
+        "voyage-3-large" => 1024,
+        "voyage-3.5" => 1024,
+        "voyage-3.5-lite" => 1024,
+        "voyage-3" => 1024,
+        "voyage-3-lite" => 512,
+        "voyage-code-3" => 1024,
+        "voyage-code-2" => 1536,
+        "voyage-finance-2" => 1024,
+        "voyage-law-2" => 1024,
+        "voyage-multimodal-3" => 1024,
         "voyage-multimodal-3.5" => 1024,
       }.freeze
 
@@ -165,20 +165,20 @@ module Parse
       # 256/512/1024/2048 ladder, and `voyage-multimodal-3.5` accepts
       # it too while `voyage-multimodal-3` does not.
       MODEL_SUPPORTED_DIMENSIONS = {
-        "voyage-4-large"        => [256, 512, 1024, 2048],
-        "voyage-4"              => [256, 512, 1024, 2048],
-        "voyage-4-lite"         => [256, 512, 1024, 2048],
-        "voyage-4-nano"         => [256, 512, 1024, 2048],
-        "voyage-3-large"        => [256, 512, 1024, 2048],
-        "voyage-3.5"            => [256, 512, 1024, 2048],
-        "voyage-3.5-lite"       => [256, 512, 1024, 2048],
-        "voyage-3"              => [1024],
-        "voyage-3-lite"         => [512],
-        "voyage-code-3"         => [256, 512, 1024, 2048],
-        "voyage-code-2"         => [1536],
-        "voyage-finance-2"      => [1024],
-        "voyage-law-2"          => [1024],
-        "voyage-multimodal-3"   => [1024],
+        "voyage-4-large" => [256, 512, 1024, 2048],
+        "voyage-4" => [256, 512, 1024, 2048],
+        "voyage-4-lite" => [256, 512, 1024, 2048],
+        "voyage-4-nano" => [256, 512, 1024, 2048],
+        "voyage-3-large" => [256, 512, 1024, 2048],
+        "voyage-3.5" => [256, 512, 1024, 2048],
+        "voyage-3.5-lite" => [256, 512, 1024, 2048],
+        "voyage-3" => [1024],
+        "voyage-3-lite" => [512],
+        "voyage-code-3" => [256, 512, 1024, 2048],
+        "voyage-code-2" => [1536],
+        "voyage-finance-2" => [1024],
+        "voyage-law-2" => [1024],
+        "voyage-multimodal-3" => [1024],
         "voyage-multimodal-3.5" => [256, 512, 1024, 2048],
       }.freeze
 
@@ -189,20 +189,20 @@ module Parse
         MODEL_SUPPORTED_DIMENSIONS.select { |_m, dims| dims.length > 1 }.keys.freeze
 
       MODEL_MAX_INPUT_TOKENS = {
-        "voyage-4-large"        => 32_000,
-        "voyage-4"              => 32_000,
-        "voyage-4-lite"         => 32_000,
-        "voyage-4-nano"         => 32_000,
-        "voyage-3-large"        => 32_000,
-        "voyage-3.5"            => 32_000,
-        "voyage-3.5-lite"       => 32_000,
-        "voyage-3"              => 32_000,
-        "voyage-3-lite"         => 32_000,
-        "voyage-code-3"         => 32_000,
-        "voyage-code-2"         => 16_000,
-        "voyage-finance-2"      => 32_000,
-        "voyage-law-2"          => 16_000,
-        "voyage-multimodal-3"   => 32_000,
+        "voyage-4-large" => 32_000,
+        "voyage-4" => 32_000,
+        "voyage-4-lite" => 32_000,
+        "voyage-4-nano" => 32_000,
+        "voyage-3-large" => 32_000,
+        "voyage-3.5" => 32_000,
+        "voyage-3.5-lite" => 32_000,
+        "voyage-3" => 32_000,
+        "voyage-3-lite" => 32_000,
+        "voyage-code-3" => 32_000,
+        "voyage-code-2" => 16_000,
+        "voyage-finance-2" => 32_000,
+        "voyage-law-2" => 16_000,
+        "voyage-multimodal-3" => 32_000,
         "voyage-multimodal-3.5" => 32_000,
       }.freeze
 
@@ -251,10 +251,10 @@ module Parse
       # Voyage only distinguishes retrieval halves — other intents
       # should receive the unconditioned vector.
       INPUT_TYPE_WIRE_VALUES = {
-        search_query:    "query",
+        search_query: "query",
         search_document: "document",
-        classification:  nil,
-        clustering:      nil,
+        classification: nil,
+        clustering: nil,
       }.freeze
 
       # @param api_key [String] required. Sent as `Authorization: Bearer …`.
@@ -400,8 +400,7 @@ module Parse
         # different request envelope. The response envelope shape is
         # the same (`{ data: [{ embedding, index }], usage: {...} }`)
         # so `extract_vectors!` is reused as-is.
-        body =
-          if MULTIMODAL_MODELS.include?(@model)
+        body = if MULTIMODAL_MODELS.include?(@model)
             build_multimodal_body(strings, wire_input_type)
           else
             build_text_body(strings, wire_input_type)
@@ -630,7 +629,7 @@ module Parse
         end
 
         rows = build_media_rows(
-          sources, kind: kind, allow_insecure: allow_insecure, caller_name: caller_name
+          sources, kind: kind, allow_insecure: allow_insecure, caller_name: caller_name,
         )
         wire_input_type = INPUT_TYPE_WIRE_VALUES[input_type]
 
@@ -907,7 +906,7 @@ module Parse
       end
 
       def backoff_seconds(attempt)
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)
@@ -966,12 +965,11 @@ module Parse
 
         if base_url
           host = begin
-            URI.parse(base_url).host
-          rescue URI::InvalidURIError
-            nil
-          end
-          inferred =
-            case host
+              URI.parse(base_url).host
+            rescue URI::InvalidURIError
+              nil
+            end
+          inferred = case host
             when URI.parse(ATLAS_BASE_URL).host then :atlas
             when URI.parse(DEFAULT_BASE_URL).host then :voyage
             else :custom

data/lib/parse/embeddings.rb

@@ -104,6 +104,7 @@ module Parse
     class InvalidImageURL < Error
       # @return [Symbol] failure-mode tag.
       attr_reader :reason
+
       def initialize(reason, message)
         @reason = reason
         super(message)
@@ -132,6 +133,7 @@ module Parse
         end
         super(name.to_sym, provider)
       end
+
       alias_method :store, :[]=
     end
 
@@ -447,8 +449,7 @@ module Parse
       # @raise [InvalidImageURL] on any other validation failure.
       def validate_image_url!(url, allow_insecure: false, mode: :forward)
         unless mode == :fetch || trust_provider_url_fetch?
-          hint =
-            if allowed_image_hosts.empty?
+          hint = if allowed_image_hosts.empty?
               " First populate Parse::Embeddings.allowed_image_hosts with the CDN " \
               "hostnames you trust (currently empty — every host would be denied " \
               "even after the sentinel is set)."
@@ -463,30 +464,30 @@ module Parse
 
         unless url.is_a?(String) && !url.empty?
           raise InvalidImageURL.new(:parse,
-            "Parse::Embeddings.validate_image_url!: url must be a non-empty String " \
-            "(got #{url.class}).")
+                                    "Parse::Embeddings.validate_image_url!: url must be a non-empty String " \
+                                    "(got #{url.class}).")
         end
 
         uri = begin
-          URI.parse(url)
-        rescue URI::InvalidURIError => e
-          raise InvalidImageURL.new(:parse,
-            "Parse::Embeddings.validate_image_url!: invalid URL (#{e.message}).")
-        end
+            URI.parse(url)
+          rescue URI::InvalidURIError => e
+            raise InvalidImageURL.new(:parse,
+                                      "Parse::Embeddings.validate_image_url!: invalid URL (#{e.message}).")
+          end
 
         valid_schemes = allow_insecure ? %w[http https] : %w[https]
         unless valid_schemes.include?(uri.scheme)
           raise InvalidImageURL.new(:scheme,
-            "Parse::Embeddings.validate_image_url!: scheme must be #{valid_schemes.join(' or ')} " \
-            "(got #{uri.scheme.inspect}). Forwarding non-HTTPS image URLs to a provider " \
-            "leaks any embedded query-string secrets in cleartext.")
+                                    "Parse::Embeddings.validate_image_url!: scheme must be #{valid_schemes.join(" or ")} " \
+                                    "(got #{uri.scheme.inspect}). Forwarding non-HTTPS image URLs to a provider " \
+                                    "leaks any embedded query-string secrets in cleartext.")
         end
 
         if uri.userinfo
           raise InvalidImageURL.new(:userinfo,
-            "Parse::Embeddings.validate_image_url!: URL must not include userinfo " \
-            "credentials. Embedding providers will forward the full URL in their fetch " \
-            "and may log it.")
+                                    "Parse::Embeddings.validate_image_url!: URL must not include userinfo " \
+                                    "credentials. Embedding providers will forward the full URL in their fetch " \
+                                    "and may log it.")
         end
 
         # `uri.hostname` returns the IDNA-decoded form WITHOUT IPv6
@@ -497,7 +498,7 @@ module Parse
         host = uri.hostname
         if host.nil? || host.empty?
           raise InvalidImageURL.new(:parse,
-            "Parse::Embeddings.validate_image_url!: URL is missing a host.")
+                                    "Parse::Embeddings.validate_image_url!: URL is missing a host.")
         end
 
         # Reject non-canonical IPv4 forms (decimal `2130706433`,
@@ -514,9 +515,9 @@ module Parse
         # character).
         if ip_shaped_but_not_canonical?(host)
           raise InvalidImageURL.new(:host_blocked,
-            "Parse::Embeddings.validate_image_url!: host #{host.inspect} is an obfuscated " \
-            "or non-canonical IP literal. Use dotted-quad IPv4 (a.b.c.d) or canonical IPv6. " \
-            "Decimal/octal/hex IP forms are refused to prevent localhost-bypass attempts.")
+                                    "Parse::Embeddings.validate_image_url!: host #{host.inspect} is an obfuscated " \
+                                    "or non-canonical IP literal. Use dotted-quad IPv4 (a.b.c.d) or canonical IPv6. " \
+                                    "Decimal/octal/hex IP forms are refused to prevent localhost-bypass attempts.")
         end
 
         # **Image-host allowlist runs BEFORE the resolver hop.** Round-2
@@ -528,9 +529,9 @@ module Parse
         allowed = allowed_image_hosts
         if allowed.empty?
           raise InvalidImageURL.new(:host_not_allowlisted,
-            "Parse::Embeddings.validate_image_url!: Parse::Embeddings.allowed_image_hosts " \
-            "is empty — every image URL is denied. Add the CDN hostnames you trust before " \
-            "forwarding image URLs to a provider.")
+                                    "Parse::Embeddings.validate_image_url!: Parse::Embeddings.allowed_image_hosts " \
+                                    "is empty — every image URL is denied. Add the CDN hostnames you trust before " \
+                                    "forwarding image URLs to a provider.")
         end
         permitted = allowed.any? do |entry|
           if entry.start_with?(".")
@@ -542,8 +543,8 @@ module Parse
         end
         unless permitted
           raise InvalidImageURL.new(:host_not_allowlisted,
-            "Parse::Embeddings.validate_image_url!: host #{host.inspect} not in " \
-            "Parse::Embeddings.allowed_image_hosts (#{allowed.inspect}).")
+                                    "Parse::Embeddings.validate_image_url!: host #{host.inspect} not in " \
+                                    "Parse::Embeddings.allowed_image_hosts (#{allowed.inspect}).")
         end
 
         # Port allowlist runs after the host allowlist (cheap string
@@ -553,8 +554,8 @@ module Parse
         require_relative "model/file"
         unless Parse::File.allowed_remote_ports.include?(port)
           raise InvalidImageURL.new(:port,
-            "Parse::Embeddings.validate_image_url!: port #{port} not in " \
-            "Parse::File.allowed_remote_ports.")
+                                    "Parse::Embeddings.validate_image_url!: port #{port} not in " \
+                                    "Parse::File.allowed_remote_ports.")
         end
 
         # CIDR + DNS resolution last — most expensive (syscall). An
@@ -567,7 +568,7 @@ module Parse
         rescue ArgumentError => e
           tag = e.message.include?("private/internal address") ? :host_blocked : :parse
           raise InvalidImageURL.new(tag,
-            "Parse::Embeddings.validate_image_url!: #{e.message}")
+                                    "Parse::Embeddings.validate_image_url!: #{e.message}")
         end
 
         # Return the canonicalized URL so callers store/forward