parse-stack-next 5.8.2 → 5.8.4

data/lib/parse/query/constraints.rb

@@ -576,22 +576,115 @@ module Parse
       end
       private :literal_char
 
+      # Shorthand classes the membership check understands, as ASCII sets.
+      # Characters outside ASCII never reach this check: {#literal_char}
+      # only yields ASCII punctuation, letters, and digits.
+      SHORTHAND_CLASSES = {
+        "d" => ->(c) { c.match?(/\A[0-9]\z/) },
+        "w" => ->(c) { c.match?(/\A[A-Za-z0-9_]\z/) },
+        "s" => ->(c) { c.match?(/\A[ \t\r\n\f\v]\z/) },
+      }.freeze
+
       # @!visibility private
       # Whether an atom (ignoring its quantifier) can match `ch` in either
       # case. Anything that cannot be checked counts as a match.
+      #
+      # The pattern text is never compiled with Ruby's Regexp: the caller's
+      # pattern is meant for MongoDB's PCRE engine, and compiling attacker
+      # text with Onigmo exposes the regexp-compiler memory-safety bugs
+      # fixed in Ruby 3.3.13, 3.4.12, and 4.0.9 (GitLab CVE-2026-89078 and
+      # related). Membership is decided from the parsed atom instead: a
+      # literal, a `\<punct>` escape, `\d \w \s` and their negations, or
+      # a character class built from those and ranges.
       def atom_matches?(item, ch)
         atom = item[:atom]
-        return true unless atom == [:char] || atom == [:dot]
-        re = begin
-            Regexp.new(atom == [:dot] ? "." : item[:text].to_s)
-          rescue RegexpError, ArgumentError
-            nil
-          end
-        return true if re.nil?
-        [ch, ch.swapcase, ch.downcase(:fold), ch.upcase].uniq.any? { |c| re.match?(c) }
+        return true if atom == [:dot]
+        return true unless atom == [:char]
+        variants = [ch, ch.swapcase, ch.downcase(:fold), ch.upcase].uniq
+        text = item[:text].to_s
+        if text.start_with?("[")
+          class_matches?(text, variants)
+        else
+          single = single_matcher(text)
+          single.nil? || variants.any? { |c| single.call(c) }
+        end
       end
       private :atom_matches?
 
+      # @!visibility private
+      # A predicate for one non-class atom's text, or nil when it cannot be
+      # checked (the caller then counts it as a match).
+      def single_matcher(text)
+        if text.length == 1 && !"\\.[]()|?*+{}^$".include?(text)
+          ->(c) { c == text }
+        elsif text.length == 2 && text.start_with?("\\")
+          code = text[1]
+          if SHORTHAND_CLASSES.key?(code)
+            SHORTHAND_CLASSES[code]
+          elsif SHORTHAND_CLASSES.key?(code.downcase)
+            ->(c) { !SHORTHAND_CLASSES[code.downcase].call(c) }
+          elsif !code.match?(/[A-Za-z0-9]/)
+            ->(c) { c == code }
+          end
+        end
+      end
+      private :single_matcher
+
+      # @!visibility private
+      # Whether a `[...]` class can match any of `variants`. Members are
+      # literals, `\<punct>` escapes, `\d \w \s` (and negations), and
+      # `a-z` ranges; any other construct (POSIX classes, `\p{...}`, nested
+      # sets) makes the class count as a match.
+      def class_matches?(text, variants)
+        body = text[1...-1].to_s
+        negated = body.start_with?("^")
+        body = body[1..] if negated
+        members = []
+        i = 0
+        while i < body.length
+          c = body[i]
+          if c == "\\"
+            code = body[i + 1]
+            return true if code.nil?
+            if SHORTHAND_CLASSES.key?(code.downcase)
+              members << single_matcher("\\#{code}")
+              i += 2
+              next
+            end
+            return true if code.match?(/[A-Za-z0-9]/)
+            lo = code
+            i += 2
+          elsif c == "["
+            return true
+          else
+            lo = c
+            i += 1
+          end
+          if body[i] == "-" && i + 1 < body.length
+            hi = body[i + 1]
+            return true if hi == "\\" || hi == "["
+            # Members are plain data, not closures: a lambda built inside
+            # this loop would close over the loop's variables and see only
+            # their last values.
+            members << [:range, lo, hi]
+            i += 2
+          else
+            members << [:literal, lo]
+          end
+        end
+        member = lambda do |v|
+          members.any? do |m|
+            case m
+            when Proc then m.call(v)
+            when Array
+              m[0] == :range ? (v >= m[1] && v <= m[2]) : v == m[1]
+            end
+          end
+        end
+        negated ? !variants.all?(&member) : variants.any?(&member)
+      end
+      private :class_matches?
+
       # @!visibility private
       # A repeated group body that cannot split its input more than one way
       # per repeat, so repeating it is safe:

data/lib/parse/query/cursor.rb

@@ -197,10 +197,53 @@ module Parse
       }
     end
 
+    # Maximum JSON nesting accepted when parsing a serialized cursor.
+    MAX_JSON_NESTING = 20
+
+    # Envelope version for signed cursor tokens.
+    SIGNED_VERSION = 2
+
+    class << self
+      # Secret used to HMAC-sign serialized cursors. When set, {#serialize}
+      # emits a signed token and {.deserialize} refuses any token without a
+      # valid signature. A per-call `secret:` argument overrides it. The
+      # secret must be a String of at least {MIN_SECRET_BYTES} bytes;
+      # anything else raises ArgumentError, since a blank or short key is
+      # guessable and would make signed tokens forgeable.
+      #
+      # The length check cannot tell a random key from a long guessable one.
+      # Generate the secret from a cryptographic random source, store it with
+      # your other application secrets, and keep it out of source control:
+      #
+      #   ruby -rsecurerandom -e 'puts SecureRandom.hex(32)'   # 32 random bytes, 64 hex characters
+      #
+      #   Parse::Cursor.signing_secret = ENV.fetch("PARSE_CURSOR_SECRET")
+      #
+      # Rotating the secret invalidates every token signed with the old one.
+      # @return [String, nil]
+      attr_reader :signing_secret
+
+      # @param value [String, nil]
+      def signing_secret=(value)
+        @signing_secret = value.nil? ? nil : validate_secret!(value)
+      end
+    end
+
+    # Shortest signing secret accepted, in bytes (the HMAC-SHA256 block
+    # recommendation for a random key is at least 32 bytes).
+    MIN_SECRET_BYTES = 32
+
     # Serialize the cursor state to a JSON string for persistence.
     # Useful for background jobs that may be interrupted and resumed.
     #
+    # The token contains the class name and the full query constraints.
+    # Without a secret it is plain JSON that anyone holding it can edit. When
+    # a secret is configured (via {.signing_secret} or `secret:`), the state
+    # is wrapped in an envelope with an HMAC-SHA256 signature that
+    # {.deserialize} verifies before rebuilding the query.
+    #
     # @example Save cursor state for later
+    #   Parse::Cursor.signing_secret = ENV["CURSOR_SECRET"]
     #   cursor = Song.cursor(limit: 100)
     #   cursor.next_page
     #   state = cursor.serialize
@@ -208,11 +251,12 @@ module Parse
     #
     # @example Resume in a background job
     #   state = redis.get("cursor:#{job_id}")
-    #   cursor = Parse::Cursor.deserialize(state)
+    #   cursor = Parse::Cursor.deserialize(state, expected_class: Song)
     #   cursor.each_page { |page| process(page) }
     #
+    # @param secret [String, nil] signing secret; defaults to {.signing_secret}
     # @return [String] JSON string containing cursor state
-    def serialize
+    def serialize(secret: self.class.signing_secret)
       require "json"
       state = {
         class_name: @query.table,
@@ -228,27 +272,78 @@ module Parse
         order_direction: @order_direction,
         version: 1,  # For future compatibility
       }
-      JSON.generate(state)
+      payload = JSON.generate(state)
+      return payload if secret.nil?
+
+      JSON.generate(v: SIGNED_VERSION, state: payload, sig: self.class.sign(payload, secret))
     end
 
     # Alias for serialize
+    # @param secret [String, nil] signing secret; defaults to {.signing_secret}
     # @return [String] JSON string containing cursor state
-    def to_json
-      serialize
+    def to_json(*_args, secret: self.class.signing_secret)
+      serialize(secret: secret)
     end
 
     # Deserialize a cursor from a previously serialized state.
     #
+    # The state names the class to query and the constraints to apply, so a
+    # token from an untrusted source (a client, a URL parameter) can query any
+    # class with any constraints unless it is signed. Configure a secret and
+    # pass `expected_class:` before accepting a token from outside the
+    # process.
+    #
+    # - With a secret (from `secret:` or {.signing_secret}), the token must be
+    #   a signed envelope whose HMAC matches; the comparison is constant-time.
+    #   Unsigned or tampered tokens raise ArgumentError.
+    # - Without a secret, an unsigned token is accepted only as trusted
+    #   persistence: state the process wrote itself and stored where clients
+    #   cannot change it (a job queue, a server-side table). Pass
+    #   `trusted: true` to say so. Without it, an unsigned token is still
+    #   accepted in this release with a one-time warning; a future minor
+    #   release will require `trusted: true`. Never use this mode on
+    #   client-supplied tokens.
+    #
     # @param json_string [String] the serialized cursor state
+    # @param secret [String, nil] signing secret; defaults to {.signing_secret}
+    # @param expected_class [Class, String, nil] refuse tokens for any other
+    #   Parse class
+    # @param trusted [Boolean] the caller asserts an unsigned token came from
+    #   trusted persistence; ignored when a secret is in effect
     # @return [Parse::Cursor] a cursor restored to the saved state
-    # @raise [ArgumentError] if the JSON is invalid or missing required fields
+    # @raise [ArgumentError] if the JSON is invalid, missing required fields,
+    #   fails signature verification, or names a different class
     #
     # @example Resume a cursor
-    #   cursor = Parse::Cursor.deserialize(saved_state)
+    #   cursor = Parse::Cursor.deserialize(saved_state, expected_class: Song)
     #   cursor.each_page { |page| process(page) }
-    def self.deserialize(json_string)
+    def self.deserialize(json_string, secret: signing_secret, expected_class: nil, trusted: false)
       require "json"
-      state = JSON.parse(json_string, symbolize_names: true)
+      require "active_support/security_utils"
+      raise ArgumentError, "Invalid cursor state: expected a String" unless json_string.is_a?(String)
+      secret = validate_secret!(secret) unless secret.nil?
+
+      state = parse_state(json_string)
+      signed = state.is_a?(Hash) && state.key?(:sig) && state.key?(:state)
+
+      if signed
+        if secret.nil?
+          raise ArgumentError, "Signed cursor state requires a signing secret to verify"
+        end
+        payload = state[:state]
+        sig = state[:sig]
+        unless payload.is_a?(String) && sig.is_a?(String) &&
+               ActiveSupport::SecurityUtils.secure_compare(sign(payload, secret), sig)
+          raise ArgumentError, "Invalid cursor state: signature mismatch"
+        end
+        state = parse_state(payload)
+      elsif secret
+        raise ArgumentError, "Invalid cursor state: unsigned cursor refused while a signing secret is configured"
+      else
+        warn_unsigned_once unless trusted
+      end
+
+      raise ArgumentError, "Invalid cursor state: expected a JSON object" unless state.is_a?(Hash)
 
       # Validate required fields
       required = [:class_name, :page_size, :order_field, :order_direction]
@@ -257,6 +352,13 @@ module Parse
         raise ArgumentError, "Invalid cursor state: missing #{missing.join(", ")}"
       end
 
+      if expected_class
+        expected_name = expected_class.respond_to?(:parse_class) ? expected_class.parse_class : expected_class.to_s
+        unless state[:class_name].to_s == expected_name
+          raise ArgumentError, "Cursor state is for class #{state[:class_name].to_s.inspect}, expected #{expected_name.inspect}"
+        end
+      end
+
       # Get the model class
       klass = Parse::Model.find_class(state[:class_name])
       unless klass
@@ -286,9 +388,53 @@ module Parse
 
     # Alias for deserialize
     # @param json_string [String] the serialized cursor state
+    # @param kwargs [Hash] `secret:`, `expected_class:`, and `trusted:`, as for {.deserialize}
     # @return [Parse::Cursor] a cursor restored to the saved state
-    def self.from_json(json_string)
-      deserialize(json_string)
+    def self.from_json(json_string, **kwargs)
+      deserialize(json_string, **kwargs)
+    end
+
+    # HMAC-SHA256 of a serialized cursor payload, hex encoded.
+    # @!visibility private
+    def self.sign(payload, secret)
+      require "openssl"
+      OpenSSL::HMAC.hexdigest("SHA256", validate_secret!(secret), payload)
+    end
+
+    # The secret, when it is a String of at least {MIN_SECRET_BYTES} bytes
+    # that is not only whitespace.
+    # @!visibility private
+    # @raise [ArgumentError]
+    def self.validate_secret!(secret)
+      unless secret.is_a?(String) && !secret.strip.empty? && secret.bytesize >= MIN_SECRET_BYTES
+        raise ArgumentError,
+              "Parse::Cursor signing secret must be a String of at least #{MIN_SECRET_BYTES} " \
+              "bytes (got #{secret.class}#{secret.is_a?(String) ? ", #{secret.bytesize} bytes" : ""})."
+      end
+      secret
+    end
+
+    # @!visibility private
+    def self.parse_state(json)
+      JSON.parse(json, symbolize_names: true, max_nesting: MAX_JSON_NESTING)
+    rescue JSON::ParserError => e
+      raise ArgumentError, "Invalid cursor state: #{e.message}"
+    end
+
+    # @!visibility private
+    def self.warn_unsigned_once
+      return if @warned_unsigned
+      @warned_unsigned = true
+      warn "[Parse::Cursor] Deserializing an unsigned cursor. Unsigned cursor state can " \
+           "name any class and constraints; never accept it from a client. Set " \
+           "Parse::Cursor.signing_secret to sign and verify cursors, or pass trusted: true " \
+           "for state the process stored itself. A future minor release will require one of them."
+    end
+
+    # Reset the one-time unsigned warning. Test-only.
+    # @!visibility private
+    def self.reset_unsigned_warning!
+      @warned_unsigned = false
     end
 
     private
@@ -307,8 +453,10 @@ module Parse
 
     # Deserialize a value from JSON storage
     def self.deserialize_value(value)
-      return value unless value.is_a?(Hash) && value["__type"] == "Date"
-      DateTime.parse(value["iso"])
+      return value unless value.is_a?(Hash)
+      type = value["__type"] || value[:__type]
+      return value unless type == "Date"
+      DateTime.parse(value["iso"] || value[:iso])
     end
 
     # Set up the ordering for cursor pagination.

data/lib/parse/query.rb

@@ -4463,6 +4463,18 @@ module Parse
       # every document silently satisfied the constraint.
       return field_str if field_str.start_with?("_")
 
+      # A name the model declares, either its Ruby property name or its
+      # declared server name (`belongs_to :owner_ref, field: "OwnerRef"`
+      # takes both `owner_ref` and `OwnerRef`), resolves to the declared
+      # column whether or not a query's field alias scope is active. Left
+      # to the formatter, an unscoped `OwnerRef` columnizes to `ownerRef`,
+      # which no property declares, so it passed through as `OwnerRef`
+      # instead of `_p_OwnerRef`, and a `$ne` / `$nin` / `$exists: false`
+      # on that missing column matched every row. Undeclared names (the
+      # pipeline-local aliases described below) are not affected.
+      declared = declared_column_for_direct_mongodb(field_str)
+      return declared if declared
+
       # Apply field formatting for regular fields
       formatted = Query.format_field(field)
 
@@ -4525,6 +4537,36 @@ module Parse
       end
     end
 
+    # The storage column for a name the query's model declares, by its Ruby
+    # property name or its declared server name, or nil for any other name.
+    # A pointer resolves to `_p_<server name>`. Built-in system fields and
+    # server names that start with `_` are left to the default handling.
+    #
+    # @param field_str [String]
+    # @return [String, nil]
+    # @api private
+    def declared_column_for_direct_mongodb(field_str)
+      return nil if field_str.empty? || field_str.include?(".")
+      klass = table_model_class
+      return nil unless klass.respond_to?(:field_map) && klass.respond_to?(:fields)
+      fmap = klass.field_map
+      sym = field_str.to_sym
+      local = if fmap.key?(sym)
+          sym
+        else
+          fmap.find { |_k, remote| remote.to_s == field_str }&.first
+        end
+      return nil if local.nil?
+      return nil if Query::FIELD_ALIAS_BUILTINS.include?(local.to_s)
+      remote = fmap[local].to_s
+      return nil if remote.empty? || remote.start_with?("_")
+      return nil if %w[objectId createdAt updatedAt ACL].include?(remote)
+      type = klass.fields[local] || klass.fields[remote.to_sym]
+      type == :pointer ? "_p_#{remote}" : remote
+    rescue NameError
+      nil
+    end
+
     # Convert a value for direct MongoDB execution.
     # @param field [String] the field name (for context)
     # @param value [Object] the value to convert

data/lib/parse/retrieval/agent_tool.rb

@@ -123,6 +123,10 @@ module Parse
 
         klass = Parse::Agent::MetadataRegistry.resolve_searchable!(class_name)
         cname = klass.parse_class
+        # The same class gate every other read tool runs: the per-agent
+        # `classes:` allowlist and the CLP `find` check for scoped agents.
+        # resolve_searchable! only consults the global hidden flag.
+        Parse::Agent::Tools.assert_class_accessible!(cname, agent: agent, op: :find)
 
         unless query.is_a?(String) && !query.strip.empty?
           raise Parse::Agent::ValidationError, "semantic_search: `query` must be a non-empty String."
@@ -155,6 +159,10 @@ module Parse
         end
         assert_filter_fields_allowed!(filter, allowed)
         assert_filter_fields_allowed!(vector_filter, allowed)
+        # The operator's per-agent filter (`filters: { Class => {...} }`) is
+        # ANDed into the post-search match after the caller's filter has been
+        # checked, so it is unconditional, as on every other read tool.
+        filter = compose_per_agent_filter(agent, klass, cname, filter)
 
         # Tenant scope (nil for unscoped classes / bypassed admins; raises
         # AccessDenied for an un-bound agent on a scoped class).
@@ -271,6 +279,80 @@ module Parse
         envelope
       end
 
+      # @!visibility private
+      # The caller's post-search filter with the agent's per-agent filter for
+      # `cname` ANDed in. The per-agent filter is converted to storage form
+      # against the class's declared fields (see {.per_agent_storage_filter}).
+      # The caller's filter gets the pointer conversion
+      # Parse::Retrieval.retrieve would have applied, since retrieve converts
+      # only top-level keys and both sides end up nested under `$and`.
+      def compose_per_agent_filter(agent, klass, cname, filter)
+        per_agent = agent.respond_to?(:filter_for) ? agent.filter_for(cname) : nil
+        return filter if per_agent.nil? || per_agent.empty?
+        scoped = per_agent_storage_filter(klass, per_agent)
+        return scoped if filter.nil? || filter.empty?
+        caller_filter = Parse::Retrieval.send(:translate_pointer_filter_values, klass, filter)
+        { "$and" => [scoped, caller_filter] }
+      end
+
+      # Built-in columns a per-agent filter may name, with their stored names.
+      PER_AGENT_BUILTIN_COLUMNS = {
+        "objectId" => "_id", "createdAt" => "_created_at", "updatedAt" => "_updated_at",
+      }.freeze
+
+      # @!visibility private
+      # A REST-form per-agent filter rewritten for a post-search `$match`.
+      # Each field is resolved through the class's declared properties, by
+      # its Ruby name or its declared server name (`PublicState` stays
+      # `PublicState`), so it addresses the stored column exactly; pointer
+      # fields use their `_p_` column and storage-form values, and Date and
+      # pointer values are converted. A field the class does not declare is
+      # refused: guessing its column could aim a negative operator such as
+      # `$ne` at a column that does not exist, which matches every row.
+      def per_agent_storage_filter(klass, node)
+        case node
+        when Array
+          node.map { |child| per_agent_storage_filter(klass, child) }
+        when Hash
+          node.each_with_object({}) do |(key, value), out|
+            k = key.to_s
+            if %w[$and $or $nor].include?(k)
+              # A single Hash is one clause; Array(hash) would split it into
+              # key/value pairs.
+              clauses = value.is_a?(Hash) ? [value] : Array(value)
+              out[k] = per_agent_storage_filter(klass, clauses)
+            elsif k.start_with?("$")
+              raise Parse::Agent::ValidationError,
+                    "semantic_search: per-agent filter operator #{k} is not supported on this tool."
+            else
+              column, pointer = per_agent_column(klass, k)
+              converted = klass.query.send(:convert_value_for_direct_mongodb, k, value)
+              out[pointer ? "_p_#{column}" : column] = converted
+            end
+          end
+        else
+          node
+        end
+      end
+
+      # @!visibility private
+      # [stored column, pointer?] for a per-agent filter field.
+      def per_agent_column(klass, name)
+        return [PER_AGENT_BUILTIN_COLUMNS[name], false] if PER_AGENT_BUILTIN_COLUMNS.key?(name)
+        fmap = klass.respond_to?(:field_map) ? klass.field_map : {}
+        local = if klass.fields.key?(name.to_sym)
+            name.to_sym
+          else
+            fmap.find { |_l, remote| remote.to_s == name }&.first
+          end
+        if local.nil?
+          raise Parse::Agent::ValidationError,
+                "semantic_search: per-agent filter field #{name.inspect} is not a declared " \
+                "property of #{klass.parse_class}."
+        end
+        [(fmap[local] || local).to_s, klass.fields[local] == :pointer]
+      end
+
       # @!visibility private
       # A profile's hybrid settings with the lexical branch restricted to the
       # text sources the agent may read. Without this the lexical search runs

data/lib/parse/retrieval/retriever.rb

@@ -264,9 +264,12 @@ module Parse
       # contract. `merge_filters` is last-wins, so ordering the tenant
       # constraint LAST guarantees its key survives any caller collision:
       # callers can narrow the result set but never escape their tenant.
-      lexical[:filter] = merge_filters(filter, lexical[:filter], tenant_filter_hash(klass, tenant_scope))
+      # `filter` may hold an operator-imposed constraint (the agent tool's
+      # per-agent filter), so a hybrid config's own lexical filter is ANDed
+      # with it rather than merged over it.
+      lexical[:filter] = merge_filters(and_filters(filter, lexical[:filter]), tenant_filter_hash(klass, tenant_scope))
       vector[:field] ||= field unless field.nil?
-      vector[:filter] = merge_filters(vector[:filter], filter)
+      vector[:filter] = and_filters(vector[:filter], filter)
       vector[:vector_filter] = merge_filters(vector[:vector_filter], merged_vector_filter)
 
       klass.hybrid_search(
@@ -391,6 +394,15 @@ module Parse
       { wire_name(klass, field) => value }
     end
 
+    # @!visibility private
+    # AND non-empty filter hashes together. Returns nil when nothing is
+    # left to apply, and a single filter unwrapped.
+    def and_filters(*filters)
+      present = filters.reject { |f| f.nil? || (f.respond_to?(:empty?) && f.empty?) }
+      return nil if present.empty?
+      present.length == 1 ? present.first : { "$and" => present }
+    end
+
     # @!visibility private
     # Shallow-merge non-empty filter hashes (left-to-right; later keys
     # win). Returns nil when nothing is left to apply.

data/lib/parse/stack/generators/templates/parse.rb

@@ -8,5 +8,5 @@ Parse.setup app_id: ENV["PARSE_SERVER_APPLICATION_ID"],
             server_url: "https://localhost:1337/parse"
 # optional
 #    logging: false,
-#      cache: Moneta.new(:File, dir: 'tmp/cache'),
+#      cache: Parse::Cache::Redis.new(url: ENV['REDIS_URL']),
 #    expires: 1 # cache ttl 1 second

data/lib/parse/stack/rack_advisory.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  module Stack
+    # Load-time check for Rack releases affected by the 2026-04 Rack
+    # advisories. The fixes are per branch (2.2.23, 3.1.21, 3.2.6, with no
+    # fixed 3.0 release). The gemspec floor covers the 2.2 line; RubyGems
+    # limits a requirement string to 255 characters, which is too short to
+    # exclude each vulnerable 3.x release by name, so a vulnerable 3.x
+    # release is reported here instead of being refused at install time.
+    module RackAdvisory
+      # Lowest fixed release per Rack 3.x minor line; nil means no fix exists
+      # on that line.
+      FIXED_3X = { "3.0" => nil, "3.1" => "3.1.21", "3.2" => "3.2.6" }.freeze
+
+      module_function
+
+      # Whether a Rack version is on a 3.x line with a known-vulnerable
+      # release below its fix.
+      # @param version [String, Gem::Version]
+      # @return [Boolean]
+      def vulnerable?(version)
+        v = Gem::Version.new(version.to_s)
+        return false unless v.segments.first == 3
+        line = v.segments.first(2).join(".")
+        return false unless FIXED_3X.key?(line)
+        fixed = FIXED_3X[line]
+        fixed.nil? || v < Gem::Version.new(fixed)
+      end
+
+      # Warn once when the loaded Rack release is vulnerable.
+      # @param version [String, Gem::Version, nil] defaults to the activated
+      #   rack gem's version.
+      # @return [Boolean] true when a warning was printed
+      def check!(version = nil)
+        version ||= Gem.loaded_specs["rack"]&.version
+        return false if version.nil? || @warned
+        return false unless vulnerable?(version)
+        @warned = true
+        warn "[parse-stack-next] Rack #{version} is affected by the 2026-04 Rack " \
+             "security advisories. Upgrade to Rack 3.2.6 or later (or 3.1.21 or later " \
+             "on the 3.1 line; the 3.0 line has no fixed release)."
+        true
+      end
+
+      # @!visibility private
+      def reset!
+        @warned = false
+      end
+    end
+  end
+end

data/lib/parse/stack/version.rb

@@ -6,6 +6,6 @@ module Parse
   # The Parse Server SDK for Ruby
   module Stack
     # The current version.
-    VERSION = "5.8.2"
+    VERSION = "5.8.4"
   end
 end