ractor-rails-shim 0.2.0

data/lib/ractor_rails_shim/patches/mattr_accessor.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# Rewrite Module.mattr_accessor (and friends) so the accessor methods
+# route through IsolatedExecutionState. Uses prepend + module_eval with
+# strings to avoid cross-ractor binding issues.
+
+module RactorRailsShim
+  class << self
+    def install_mattr_accessor
+      _register_patch :mattr_accessor, "8.1"
+      return if @mattr_patched
+      @mattr_patched = true
+
+      ::Module.prepend(Module.new {
+        # The prepended module's body is evaluated in the main ractor at
+        # prepend time; the methods it defines are callable from any ractor
+        # because they're defined via string eval (no captured binding).
+        # But mattr_accessor itself runs at app boot in the main ractor, and
+        # the per-accessor redefinition must also use string eval.
+        #
+        # IMPORTANT: Rails' mattr_accessor/cattr_accessor stores values in
+        # CLASS VARIABLES (@@sym), not class instance variables (@sym). The
+        # default value is written via class_variable_set("@@sym", default).
+        # Class variables are also subject to Ractor::IsolationError from
+        # non-main ractors (verified on Ruby 4.0.5), so we route through IES
+        # the same way — but the main-ractor fallback must read @@sym, and
+        # the seed must run in the main ractor at define-time (via super).
+        def mattr_accessor(*syms, instance_reader: true, instance_writer: true,
+                           instance_accessor: true, default: nil, **kwargs, &block)
+          shareable = kwargs[:shareable]
+          mod_name = name
+
+          # Compute the default value the same way Rails does, so we can
+          # seed worker-ractor IES slots with it (workers can't read @@sym).
+          # The block form is evaluated once here (in main ractor) like Rails.
+          sym_default = block_given? && default.nil? ? yield : default
+
+          super # define the methods via the original path (sets @@sym)
+
+          syms.each do |sym|
+            key = :"ractor_rails_shim_mattr_#{mod_name}_#{sym}"
+            key_str = key.inspect
+            cv = "@@#{sym}"
+            cv_str = cv.inspect
+
+            # Register so _build_shareable_fallback! can capture the main-ractor
+            # value (read from @@sym) at prepare_for_ractors! time. The label
+            # is just for diagnostics. The default is stored too so the
+            # fallback builder can use it when the live value can't be shared.
+            RactorRailsShim::CLASS_ATTRIBUTES << [mod_name, sym, key, sym_default]
+            # Store the default in a runtime registry (NOT inlined into the
+            # eval'd method body — arbitrary objects like Logger have invalid
+            # `.inspect` output). The reader looks it up by key.
+            RactorRailsShim::MATTR_DEFAULTS[key] = sym_default
+            # If the default is shareable, add to the shareable subset. We
+            # rebuild the constant as a new frozen shareable Hash each time
+            # (so workers can read the constant even before prepare_for_ractors!
+            # runs — e.g. unit tests). const_set warns "already initialized
+            # constant"; silence it.
+            if sym_default && Ractor.shareable?(sym_default)
+              h = RactorRailsShim::SHAREABLE_MATTR_DEFAULTS.dup
+              h[key] = sym_default
+              h.freeze
+              Ractor.make_shareable(h)
+              verbose, $VERBOSE = $VERBOSE, nil
+              begin
+                RactorRailsShim.const_set(:SHAREABLE_MATTR_DEFAULTS, h)
+              ensure
+                $VERBOSE = verbose
+              end
+            end
+
+            # Redefine the class reader via string eval (no captured binding).
+            # Class variables are only touched from the main ractor; worker
+            # ractors fall back to SHAREABLE_FALLBACK (built from main's @@sym
+            # at prepare_for_ractors! time) when their own IES slot is empty.
+            # NOTE: we deliberately do NOT inline the default value here —
+            # arbitrary objects (e.g. Logger) have invalid `.inspect` output.
+            # The fallback builder captures the live value (which may equal
+            # the default) at prepare time.
+            singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{sym}
+                v = ActiveSupport::IsolatedExecutionState[#{key_str}]
+                return v unless v.nil?
+
+                if #{!!shareable}
+                  if class_variable_defined?(#{cv_str})
+                    class_variable_get(#{cv_str})
+                  end
+                elsif Ractor.main?
+                  if class_variable_defined?(#{cv_str})
+                    class_variable_get(#{cv_str})
+                  else
+                    nil
+                  end
+                else
+                  # Worker: try the shareable fallback (built from main's @@sym
+                  # at prepare_for_ractors! time). If empty, try the
+                  # definition-time default (only the shareable subset — the
+                  # full MATTR_DEFAULTS holds unshareable defaults like Logger
+                  # which workers can't read via the constant).
+                  fb = RactorRailsShim::SHAREABLE_FALLBACK[#{key_str}]
+                  return fb unless fb.nil?
+                  RactorRailsShim::SHAREABLE_MATTR_DEFAULTS[#{key_str}]
+                end
+              end
+
+              def #{sym}=(val)
+                ActiveSupport::IsolatedExecutionState[#{key_str}] = val
+                if Ractor.main?
+                  class_variable_set(#{cv_str}, val) if class_variable_defined?(#{cv_str})
+                  class_variable_set(#{cv_str}, val) unless class_variable_defined?(#{cv_str})
+                end
+                val
+              end
+            RUBY
+
+            # Instance readers/writers route through IES directly (NOT
+            # self.class.#{sym}). Rails' original uses @@sym (a class variable
+            # inherited by including classes); the shim routes through IES,
+            # so the instance reader must also use IES. Using self.class.sym
+            # would fail for mattr_accessor on Modules (e.g.
+            # ActionView::Helpers::FormHelper#form_with_generates_ids):
+            # self.class is the including class (ActionView::Base), which
+            # doesn't have the module's singleton method.
+            # Only redefine if instance_accessor is on (matches Rails).
+            if instance_reader && instance_accessor
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{sym}
+                  v = ActiveSupport::IsolatedExecutionState[#{key_str}]
+                  return v unless v.nil?
+                  if Ractor.main?
+                    self.class.class_variable_defined?(#{cv_str}) ? self.class.class_variable_get(#{cv_str}) : nil
+                  else
+                    RactorRailsShim::SHAREABLE_FALLBACK[#{key_str}]
+                  end
+                end
+              RUBY
+            end
+            if instance_writer && instance_accessor
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{sym}=(val)
+                  ActiveSupport::IsolatedExecutionState[#{key_str}] = val
+                  self.class.class_variable_set(#{cv_str}, val) if Ractor.main? && self.class.class_variable_defined?(#{cv_str})
+                  val
+                end
+              RUBY
+            end
+          end
+        end
+
+        # cattr_accessor is an alias for mattr_accessor in Rails; route it too.
+        if method_defined?(:cattr_accessor, true)
+          alias_method :_unshimmed_cattr_accessor, :cattr_accessor
+          def cattr_accessor(*args, **kwargs, &block)
+            mattr_accessor(*args, **kwargs, &block)
+          end
+        end
+      })
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/openssl.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Patches for OpenSSL digest classes so they can be used from worker Ractors.
+#
+# `openssl/digest.rb` defines each algorithm class (SHA256, etc.) as:
+#
+#   klass = Class.new(self) {
+#     define_method(:initialize, ->(data = nil) { super(name, data) })
+#   }
+#   singleton.class_eval {
+#     define_method(:digest)    { |data| new.digest(data) }
+#     define_method(:hexdigest) { |data| new.hexdigest(data) }
+#   }
+#
+# The `->(data = nil) { ... }` lambda (and the singleton `digest`/`hexdigest`
+# blocks) are compiled in the MAIN Ractor. Instantiating the class from a
+# worker Ractor (`OpenSSL::Digest::SHA256.new`, called e.g. by
+# `ActiveSupport::KeyGenerator#generate_key` -> `OpenSSL::PKCS5.pbkdf2_hmac`
+# -> `@hash_digest_class.new`) invokes that lambda and raises
+# "defined with an un-shareable Proc in a different Ractor". This blocks every
+# request that touches the cookie/session key generator (i.e. all of them).
+#
+# Fix: redefine the methods with string-eval (no captured binding) so they are
+# callable from any Ractor. Behaviour is identical. Applied at
+# prepare_for_ractors! time (after OpenSSL is loaded).
+
+module RactorRailsShim
+  class << self
+    def _install_openssl_digest_patch
+      return if @openssl_digest_patched
+      @openssl_digest_patched = true
+      _register_patch :openssl_digest, "8.1"
+      return unless defined?(::OpenSSL::Digest)
+
+      algos = %w(MD4 MD5 RIPEMD160 SHA1 SHA224 SHA256 SHA384 SHA512)
+      algos.each do |name|
+        klass_name = name.tr("-", "_")
+        next unless ::OpenSSL::Digest.const_defined?(klass_name)
+        klass = ::OpenSSL::Digest.const_get(klass_name)
+        next unless klass.is_a?(::Class)
+
+        # Replace the lambda-based `initialize` (super(name, data)) with a
+        # string-eval'd method that holds no captured Proc.
+        klass.class_eval "def initialize(data = nil); super(#{name.inspect}, data); end"
+
+        # Replace the singleton `digest`/`hexdigest` blocks the same way.
+        klass.singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def digest(data)
+            new.digest(data)
+          end
+          def hexdigest(data)
+            new.hexdigest(data)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/orm_adapter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Patch OrmAdapter::ToAdapter#to_adapter. The original memoizes the adapter on
+# the model CLASS via `@_to_adapter ||= self::OrmAdapter.new(self)`. A worker
+# Ractor cannot set an instance variable on a class/module, so it raises
+# "Ractor::IsolationError: can not set instance variables of classes/modules by
+# non-main Ractors". Route the per-class cache through IsolatedExecutionState,
+# keyed by the class's (stable, shared) object_id. Each Ractor builds its own
+# adapter and caches it locally; the adapter only holds a reference to the
+# (shared) model class, so no cross-boundary objects are involved.
+
+module RactorRailsShim
+  class << self
+    def _install_orm_adapter_patch
+      return if @orm_adapter_patched
+      @orm_adapter_patched = true
+      _register_patch :orm_adapter, "8.1"
+      return unless defined?(::OrmAdapter::ToAdapter)
+
+      ::OrmAdapter::ToAdapter.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def to_adapter
+          key = :"ractor_rails_shim_orm_adapter_\#{object_id}"
+          v = ActiveSupport::IsolatedExecutionState[key]
+          return v unless v.nil?
+          adapter = self::OrmAdapter.new(self)
+          ActiveSupport::IsolatedExecutionState[key] = adapter
+          adapter
+        end
+      RUBY
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/polymorphic_routes.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# Patch ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.
+#
+# Two Ractor-safety problems live here:
+#
+# 1. The class body populates a `CACHE` constant with HelperMethodBuilder
+#    instances that hold un-shareable lambdas (e.g. `->(name) { name.route_key }`).
+#    Because the constant lives on the shared class, a worker Ractor that reads
+#    `CACHE[:path][nil]` touches a main-Ractor-owned object and raises
+#    "defined with an un-shareable Proc in a different Ractor". Fix: stop reading
+#    `CACHE` — build a fresh builder in the *calling* Ractor on every lookup.
+#
+# 2. `HelperMethodBuilder#handle_model_call` calls `polymorphic_mapping`, which
+#    reads `target._routes.polymorphic_mappings` — a shared hash of main-built
+#    Procs. Reading it from a worker raises the same error. Fix: skip the shared
+#    mapping and build the route from the (worker-owned) builder's own logic.
+
+module RactorRailsShim
+  class << self
+    def _install_polymorphic_routes_patch
+      return if @polymorphic_routes_patched
+      @polymorphic_routes_patched = true
+      _register_patch :polymorphic_routes, "8.1"
+      return unless defined?(::ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder)
+      hmb = ::ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder
+      hmb.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def get(action, type)
+          type = type.to_sym
+          build action, type
+        end
+
+        def url
+          build nil, "url"
+        end
+
+        def path
+          build nil, "path"
+        end
+      RUBY
+      hmb.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def handle_model_call(target, record)
+          if mapping = polymorphic_mapping(target, record) rescue nil
+            mapping.call(target, [record], suffix == "path")
+          else
+            method, args = handle_model(record)
+            target.public_send(method, *args)
+          end
+        end
+      RUBY
+
+      # The module-level `polymorphic_path` / `polymorphic_url` (called by
+      # `form_with` when it infers the URL from a model) invoke
+      # `mapping.call` directly. A custom `resolve` mapping Proc is built in
+      # the main Ractor and is un-shareable, so calling it from a worker
+      # Ractor raises "defined with an un-shareable Proc in a different
+      # Ractor". Rescue that and fall through to the (worker-safe)
+      # HelperMethodBuilder path, which derives the route from the record's
+      # model name — the same fallback the original code uses when no mapping
+      # is registered at all.
+      pm = ::ActionDispatch::Routing::PolymorphicRoutes
+      pm.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def polymorphic_path(record_or_hash_or_array, options = {})
+          if ::Hash === record_or_hash_or_array
+            options = record_or_hash_or_array.merge(options)
+            record  = options.delete :id
+            return polymorphic_path record, options
+          end
+
+          if mapping = (polymorphic_mapping(record_or_hash_or_array) rescue nil)
+            begin
+              return mapping.call(self, [record_or_hash_or_array, options], true)
+            rescue ::Ractor::Error
+            end
+          end
+
+          opts   = options.dup
+          action = opts.delete :action
+          type   = :path
+
+          HelperMethodBuilder.polymorphic_method self,
+                                                 record_or_hash_or_array,
+                                                 action,
+                                                 type,
+                                                 opts
+        end
+
+        def polymorphic_url(record_or_hash_or_array, options = {})
+          if ::Hash === record_or_hash_or_array
+            options = record_or_hash_or_array.merge(options)
+            record  = options.delete :id
+            return polymorphic_url record, options
+          end
+
+          if mapping = (polymorphic_mapping(record_or_hash_or_array) rescue nil)
+            begin
+              return mapping.call(self, [record_or_hash_or_array, options], false)
+            rescue ::Ractor::Error
+            end
+          end
+
+          opts   = options.dup
+          action = opts.delete :action
+          type   = opts.delete(:routing_type) || :url
+
+          HelperMethodBuilder.polymorphic_method self,
+                                                 record_or_hash_or_array,
+                                                 action,
+                                                 type,
+                                                 opts
+        end
+      RUBY
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/propshaft.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# Patch for Propshaft (the default Rails 8 asset pipeline). The Assembly and
+# LoadPath memoize their derived values in lazy instance ivars via `||=`:
+#
+#   Propshaft::Assembly#load_path   -> @load_path ||= Propshaft::LoadPath.new(...)
+#   Propshaft::Assembly#compilers   -> @compilers ||= Propshaft::Compilers.new(...)
+#   Propshaft::LoadPath#assets_by_path        -> @cached_assets_by_path ||= ...
+#   Propshaft::LoadPath#asset_paths_by_type   -> (@cached_... ||= Hash.new)[ct] ||= ...
+#   Propshaft::LoadPath#asset_paths_by_glob   -> (@cached_... ||= Hash.new)[g]  ||= ...
+#
+# The Assembly/LoadPath live inside the frozen, shared Rails.application graph
+# (set by the propshaft railtie at boot, then deep-frozen by
+# make_app_shareable!). A worker Ractor calling `||=` to populate these ivars
+# raises FrozenError because the host object is frozen.
+#
+# Fix: warm every Assembly/LoadPath lazy ivar in MAIN (before freezing) so the
+# `||=` short-circuits in workers (the ivar is already set → truthy → no
+# assignment). The two `asset_paths_by_*` methods additionally perform a
+# *write* to their inner Hash even when the key already exists (`h[k] ||= v`
+# is `h[k] = h[k] || v`, which assigns to a frozen Hash). Route those two
+# through IsolatedExecutionState (each Ractor builds its own cache from
+# `assets`, which is already warmed read-only).
+
+module RactorRailsShim
+  class << self
+    def _install_propshaft_patch
+      return if @propshaft_patched
+      @propshaft_patched = true
+      _register_patch :propshaft, "1.3"
+      return unless defined?(::Propshaft::LoadPath)
+
+      lp = ::Propshaft::LoadPath
+      lp.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def asset_paths_by_type(content_type)
+          cache = (ActiveSupport::IsolatedExecutionState[:"ractor_rails_shim_propshaft_type_\#{object_id}"] ||= {})
+          if cache.key?(content_type)
+            cache[content_type]
+          else
+            cache[content_type] = extract_logical_paths_from(assets.select { |a| a.content_type == ::Mime::EXTENSION_LOOKUP[content_type] })
+          end
+        end
+
+        def asset_paths_by_glob(glob)
+          cache = (ActiveSupport::IsolatedExecutionState[:"ractor_rails_shim_propshaft_glob_\#{object_id}"] ||= {})
+          if cache.key?(glob)
+            cache[glob]
+          else
+            cache[glob] = extract_logical_paths_from(assets.select { |a| a.path.fnmatch?(glob) })
+          end
+        end
+      RUBY
+
+      if lp.method_defined?(:asset_paths_by_path)
+        lp.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def asset_paths_by_path(path)
+            cache = (ActiveSupport::IsolatedExecutionState[:"ractor_rails_shim_propshaft_path_\#{object_id}"] ||= {})
+            if cache.key?(path)
+              cache[path]
+            else
+              cache[path] = extract_logical_paths_from(assets.select { |a| a.path.fnmatch?(path) })
+            end
+          end
+        RUBY
+      end
+    end
+
+    # Warm every Propshaft Assembly/LoadPath lazy ivar in MAIN (before the app
+    # is frozen). Warmed ivars are truthy, so the `||=` memoization in workers
+    # short-circuits instead of attempting to assign onto a frozen object.
+    # Assets::by_path is itself memoized; warming `assets` populates it so
+    # workers only read the frozen cache.
+    def _precompute_propshaft!(app)
+      return unless Ractor.main?
+      assets = app.assets rescue nil
+      return unless assets
+      assets.load_path rescue nil
+      assets.compilers rescue nil
+      assets.resolver rescue nil
+      assets.prefix rescue nil
+      assets.processor rescue nil
+      # Build the asset map (LoadPath#assets -> assets_by_path) so the inner
+      # cache is populated and frozen before workers read it. Then warm each
+      # Asset's lazy ivars (@content_type, @digest) in MAIN — they are memoized
+      # via `||=` and the Asset objects live inside the frozen, shared app
+      # graph, so a worker reading them would raise FrozenError. Warming here
+      # (while still mutable) lets the `||=` short-circuit in workers.
+      assets.load_path.assets.each do |asset|
+        asset.content_type rescue nil
+        asset.digest rescue nil
+      end
+      # Warm the resolver manifest cache. Propshaft::Resolver::Static#manifest
+      # memoizes `@manifest ||= Propshaft::Manifest.from_path(...)`; the
+      # resolver is frozen in the shared graph, so without warming, a worker
+      # rendering a `stylesheet_link_tag` (or reading asset integrity) for a
+      # PRECOMPILED manifest raises FrozenError ("can't modify frozen
+      # Propshaft::Resolver::Static"). `#manifest` is private — invoke via
+      # send to trigger the `||=` in MAIN (while still mutable) so workers only
+      # read the frozen, cached value.
+      resolver = assets.resolver rescue nil
+      if resolver.respond_to?(:manifest, true)
+        begin
+          resolver.send(:manifest)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/rack.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+# Patches for Rack: Rack::Request class-level attr_accessors and
+# Rack::Utils singleton attr_accessors.
+
+module RactorRailsShim
+  # Rack constants whose values are mutable and need to be made shareable.
+  SHAREABLE_CONSTANTS.concat([
+    "Rack::Utils::PATH_SEPS",
+    "Rack::Utils::HTTP_STATUS_CODES",
+    "Rack::Utils::COMMON_SEP",
+    "Rack::Utils::STATUS_WITH_NO_ENTITY_BODY",
+    "Rack::Utils::SYMBOL_TO_STATUS_CODE",
+    "Rack::MethodOverride::ALLOWED_METHODS",
+    "Rack::MethodOverride::METHOD_OVERRIDES",
+    "Rack::MethodOverride::HTTP_METHODS",
+    "Rack::Headers::KNOWN_HEADERS",
+    "Rack::Request::Helpers::FORM_DATA_MEDIA_TYPES",
+    "Rack::Request::Helpers::PARSEABLE_DATA_MEDIA_TYPES",
+    "Rack::Request::Helpers::DEFAULT_PORTS",
+    "Rack::Mime::MIME_TYPES",
+    "Rack::Files::ALLOWED_VERBS",
+    "Rack::Files::ALLOW_HEADER",
+    "Rack::Response::STATUS_WITH_NO_ENTITY_BODY",
+    # Multipart file-upload parser constants, read by worker Ractors on every
+    # POST (Rack::Request#POST -> parse_multipart -> Parser.parse). TEMPFILE_FACTORY
+    # is a lambda; EMPTY is a MultipartInfo sentinel instance; REENCODE_DUMMY_
+    # ENCODINGS is a mutable Hash. None are shareable by default.
+    "Rack::Multipart::Parser::TEMPFILE_FACTORY",
+    "Rack::Multipart::Parser::EMPTY",
+      "Rack::Multipart::Parser::REENCODE_DUMMY_ENCODINGS",
+  ])
+
+  # Source-location constant used by make_app_shareable!'s proc-replacement
+  # graph traversal (moved here from make_shareable.rb so the Rack concern's
+  # pieces live together).
+  FILES_LOC = "/rack/files.rb".freeze
+
+  class << self
+    # Patch Rack::Request's class-level attr_accessors (forwarded_priority,
+    # x_forwarded_proto_priority) to not read @ivars from a worker Ractor.
+    # The values are frozen-Symbol Arrays (shareable); route the cache
+    # through IES with the same default in workers. Read per-request via
+    # ActionDispatch::RemoteIp. Applied at prepare_for_ractors! time (after
+    # Rails boots, so Rack is loaded).
+    def _install_rack_request_patch
+      return if @rack_request_patched
+      @rack_request_patched = true
+      _register_patch :rack_request, "8.1"
+      return unless defined?(::Rack::Request)
+      req = ::Rack::Request
+      fp_key = :ractor_rails_shim_rack_forwarded_priority
+      xp_key = :ractor_rails_shim_rack_x_forwarded_proto_priority
+      fp_key_str = fp_key.inspect
+      xp_key_str = xp_key.inspect
+      req.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def forwarded_priority
+          v = ActiveSupport::IsolatedExecutionState[#{fp_key_str}]
+          return v unless v.nil?
+          if Ractor.main? && instance_variable_defined?(:@forwarded_priority)
+            @forwarded_priority
+          else
+            [:forwarded, :x_forwarded]
+          end
+        end
+        def forwarded_priority=(val)
+          ActiveSupport::IsolatedExecutionState[#{fp_key_str}] = val
+          @forwarded_priority = val if Ractor.main?
+          val
+        end
+        def x_forwarded_proto_priority
+          v = ActiveSupport::IsolatedExecutionState[#{xp_key_str}]
+          return v unless v.nil?
+          if Ractor.main? && instance_variable_defined?(:@x_forwarded_proto_priority)
+            @x_forwarded_proto_priority
+          else
+            [:proto, :scheme]
+          end
+        end
+        def x_forwarded_proto_priority=(val)
+          ActiveSupport::IsolatedExecutionState[#{xp_key_str}] = val
+          @x_forwarded_proto_priority = val if Ractor.main?
+          val
+        end
+      RUBY
+    end
+
+    # Patch Rack::Utils singleton attr_accessors (default_query_parser,
+    # multipart_total_part_limit, multipart_file_limit) to not read @ivars
+    # from a worker Ractor. The values are shareable once frozen (QueryParser,
+    # Integers). Route through IES; workers read the shareable fallback.
+    # `default_query_parser` is read per-request during POST parsing.
+    def _install_rack_utils_patch
+      return if @rack_utils_patched
+      @rack_utils_patched = true
+      _register_patch :rack_utils, "8.1"
+      return unless defined?(::Rack::Utils)
+      u = ::Rack::Utils
+      dqp_key = :ractor_rails_shim_rack_utils_default_query_parser
+      mtp_key = :ractor_rails_shim_rack_utils_multipart_total_part_limit
+      mfl_key = :ractor_rails_shim_rack_utils_multipart_file_limit
+      dqp_key_str = dqp_key.inspect
+      mtp_key_str = mtp_key.inspect
+      mfl_key_str = mfl_key.inspect
+      u.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def default_query_parser
+          v = ActiveSupport::IsolatedExecutionState[#{dqp_key_str}]
+          return v unless v.nil?
+          if Ractor.main? && instance_variable_defined?(:@default_query_parser)
+            v = @default_query_parser
+            ActiveSupport::IsolatedExecutionState[#{dqp_key_str}] = v
+            v
+          else
+            RactorRailsShim::SHAREABLE_FALLBACK[#{dqp_key_str}] || ::Rack::QueryParser::QueryParser.make_default(32)
+          end
+        end
+        def multipart_total_part_limit
+          v = ActiveSupport::IsolatedExecutionState[#{mtp_key_str}]
+          return v unless v.nil?
+          if Ractor.main? && instance_variable_defined?(:@multipart_total_part_limit)
+            v = @multipart_total_part_limit
+            ActiveSupport::IsolatedExecutionState[#{mtp_key_str}] = v
+            v
+          else
+            RactorRailsShim::SHAREABLE_FALLBACK[#{mtp_key_str}] || 128
+          end
+        end
+        def multipart_file_limit
+          v = ActiveSupport::IsolatedExecutionState[#{mfl_key_str}]
+          return v unless v.nil?
+          if Ractor.main? && instance_variable_defined?(:@multipart_file_limit)
+            v = @multipart_file_limit
+            ActiveSupport::IsolatedExecutionState[#{mfl_key_str}] = v
+            v
+          else
+            RactorRailsShim::SHAREABLE_FALLBACK[#{mfl_key_str}] || 64
+          end
+        end
+      RUBY
+      CLASS_ATTRIBUTES << ["Rack::Utils", :default_query_parser, dqp_key, nil]
+      CLASS_ATTRIBUTES << ["Rack::Utils", :multipart_total_part_limit, mtp_key, nil]
+      CLASS_ATTRIBUTES << ["Rack::Utils", :multipart_file_limit, mfl_key, nil]
+    end
+
+    # Find the Rack::Files (asset) server in the middleware chain, used by
+    # make_app_shareable! when replacing the Rack::Head#@app lambda (whose
+    # binding receiver is the Rack::Files instance). Moved here from
+    # make_shareable.rb so the Rack concern's pieces live together.
+    def _find_files_server(mw)
+      cur = mw
+      while cur
+        if cur.class.name == "ActionDispatch::Static"
+          return cur.instance_variable_get(:@file_server)
+        end
+        cur = cur.instance_variable_get(:@app) rescue nil
+      end
+      nil
+    end
+  end
+end