ractor-rails-shim 0.2.0

data/lib/ractor_rails_shim/patches/rails_module.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+# Patch the Rails module's class-level accessors (Rails.application,
+# Rails.env, Rails.cache, etc.) to route through IsolatedExecutionState.
+# The generic constant-sharing utilities (make_constant_shareable,
+# split_const_path, do_install_shareable_constants, install_shareable_constants,
+# shareable_constants) now live in core.rb (alongside SHAREABLE_CONSTANTS).
+
+module RactorRailsShim
+  class << self
+    # Railties constants (the rest are in their per-concern files: rack.rb,
+    # action_view.rb, action_controller.rb, action_dispatch.rb,
+    # active_support.rb, warden.rb). Each file concats into
+    # RactorRailsShim::SHAREABLE_CONSTANTS (defined empty in core.rb).
+    SHAREABLE_CONSTANTS.concat([
+      "Rails::Railtie::ABSTRACT_RAILTIES",
+      "Rails::AppLoader::EXECUTABLES",
+      "Rails::Command::HELP_MAPPINGS",
+      "Rails::Command::VERSION_MAPPINGS",
+      "Rails::Application::INITIAL_VARIABLES",
+    ])
+
+    # Patch the Rails module's class-level accessors (Rails.application,
+    # Rails.env, Rails.cache, etc.) to route through IsolatedExecutionState.
+    # Defers via a load hook if Rails isn't defined yet (the config/boot.rb case).
+    def install_rails_module
+      _register_patch :rails_module, "8.1"
+      if defined?(::Rails)
+        patch_rails_module!(::Rails)
+      else
+        install_rails_load_hook
+      end
+    end
+
+    # Defer the Rails-module patch until Rails is defined. A TracePoint on
+    # :class fires when `rails.rb` opens `module Rails` (module bodies fire
+    # as :class); once the constant is assigned, we patch once and disable
+    # the hook.
+    def install_rails_load_hook
+      return if @rails_load_hook_installed
+      @rails_load_hook_installed = true
+
+      @rails_tp = TracePoint.new(:class) do |trace|
+        if defined?(::Rails) && !@rails_module_patched
+          @rails_tp.disable
+          patch_rails_module!(::Rails)
+        end
+      end
+      @rails_tp.enable
+    end
+
+    # The actual Rails-module patch. Idempotent. Must be called from the
+    # main Ractor (it prepends onto Rails.singleton_class).
+    def patch_rails_module!(mod)
+      return if @rails_module_patched
+      @rails_module_patched = true
+      do_install_shareable_constants
+      _patch_rails_module_body(mod)
+    end
+
+    def _patch_rails_module_body(mod)
+      k = KEYS
+
+      # Register the Rails module accessors in CLASS_ATTRIBUTES so the
+      # shareable-fallback builder captures their main-ractor values at
+      # prepare_for_ractors! / make_app_shareable! time and exposes them to
+      # worker Ractors (e.g. Rails.logger is read per-request by
+      # Rails::Rack::SilenceRequest). `application` is NOT registered — workers
+      # get the shared app via Ractor.new(app), not via Rails.application.
+      CLASS_ATTRIBUTES << ["Rails", :logger,        k[:logger],        nil]
+      CLASS_ATTRIBUTES << ["Rails", :cache,         k[:cache],         nil]
+      CLASS_ATTRIBUTES << ["Rails", :backtrace_cleaner, k[:backtrace_cleaner], nil]
+      CLASS_ATTRIBUTES << ["Rails", :app_class,     k[:app_class],     nil]
+
+      # We PREPEND a module onto Rails.singleton_class rather than redefine
+      # the methods directly, because Rails defines its own `application`,
+      # `env`, etc. LATER in rails.rb (`class << self; def application; ...`).
+      # A direct module_eval redefinition would be clobbered when Rails'
+      # own `def` runs afterward. A prepended module sits in front of the
+      # singleton class in the method lookup chain and survives a later
+      # `def` on the same class — so our IES-routed reader stays in front.
+      # We call `super` to fall back to Rails' original method for the
+      # main-ractor lazy-init path (which reads the @application ivar —
+      # safe in the main ractor).
+      patch = Module.new
+      patch.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        # application: IES first; main ractor falls back to Rails' own
+        # lazy init via super. Worker ractors return nil (their own IES
+        # slot is empty until they boot their own app).
+        def application
+          v = ActiveSupport::IsolatedExecutionState[#{k[:application].inspect}]
+          return v unless v.nil?
+          if Ractor.main?
+            super
+          else
+            RactorRailsShim.const_defined?(:SHAREABLE_APP) ? RactorRailsShim::SHAREABLE_APP : nil
+          end
+        end
+
+        def application=(val)
+          ActiveSupport::IsolatedExecutionState[#{k[:application].inspect}] = val
+          super if Ractor.main?
+          val
+        end
+
+        # Simple accessors: app_class, cache, logger, backtrace_cleaner.
+        # Workers fall back to the shareable fallback (built from main's
+        # value at make_app_shareable! time) when their own IES slot is empty.
+        def app_class
+          v = ActiveSupport::IsolatedExecutionState[#{k[:app_class].inspect}]
+          return v unless v.nil?
+          return super if Ractor.main?
+          RactorRailsShim::SHAREABLE_FALLBACK[#{k[:app_class].inspect}]
+        end
+        def app_class=(val)
+          ActiveSupport::IsolatedExecutionState[#{k[:app_class].inspect}] = val
+          super if Ractor.main?
+          val
+        end
+
+        def cache
+          v = ActiveSupport::IsolatedExecutionState[#{k[:cache].inspect}]
+          return v unless v.nil?
+          return super if Ractor.main?
+          RactorRailsShim::SHAREABLE_FALLBACK[#{k[:cache].inspect}]
+        end
+        def cache=(val)
+          ActiveSupport::IsolatedExecutionState[#{k[:cache].inspect}] = val
+          super if Ractor.main?
+          val
+        end
+
+        def logger
+          v = ActiveSupport::IsolatedExecutionState[#{k[:logger].inspect}]
+          return v unless v.nil?
+          return super if Ractor.main?
+          # Loggers are intrinsically mutable (formatters hold tag stacks,
+          # logdevs hold IO + Mutex) and can't be shared read-only. Build a
+          # per-worker ActiveSupport::BroadcastLogger (which mixes in
+          # LoggerSilence#silence, used by Rails::Rack::SilenceRequest)
+          # writing to $stderr (each Ractor has its own $stderr stream) and
+          # cache it in IES so subsequent reads return the same instance.
+          built = ActiveSupport::BroadcastLogger.new(Logger.new($stderr))
+          ActiveSupport::IsolatedExecutionState[#{k[:logger].inspect}] = built
+          built
+        end
+        def logger=(val)
+          ActiveSupport::IsolatedExecutionState[#{k[:logger].inspect}] = val
+          super if Ractor.main?
+          val
+        end
+
+        def backtrace_cleaner
+          v = ActiveSupport::IsolatedExecutionState[#{k[:backtrace_cleaner].inspect}]
+          return v unless v.nil?
+          return super if Ractor.main?
+          RactorRailsShim::SHAREABLE_FALLBACK[#{k[:backtrace_cleaner].inspect}]
+        end
+        def backtrace_cleaner=(val)
+          ActiveSupport::IsolatedExecutionState[#{k[:backtrace_cleaner].inspect}] = val
+          super if Ractor.main?
+          val
+        end
+
+        # env: worker ractors build their own EnvironmentInquirer from ENV
+        # (no @ _env ivar to read). Main ractor falls back to super, which
+        # lazily builds and caches in @_env.
+        def env
+          v = ActiveSupport::IsolatedExecutionState[#{k[:env].inspect}]
+          return v unless v.nil?
+          if Ractor.main?
+            super
+          else
+            built = ActiveSupport::EnvironmentInquirer.new(
+              ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence || "development"
+            )
+            ActiveSupport::IsolatedExecutionState[#{k[:env].inspect}] = built
+            built
+          end
+        end
+
+        def env=(val)
+          v = ActiveSupport::EnvironmentInquirer.new(val)
+          ActiveSupport::IsolatedExecutionState[#{k[:env].inspect}] = v
+          super if Ractor.main?
+          v
+        end
+      RUBY
+      mod.singleton_class.prepend(patch)
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/route_helpers.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# Ractor-safe URL helper generation.
+#
+# Rails builds every URL helper method (`posts_path`, `_routes`,
+# `_generate_paths_by_default`, the `direct`/`resolve` helpers, …) with
+# `define_method(&block)` / `redefine_method(&block)`, and uses the
+# `RouteSet::PATH` / `RouteSet::UNKNOWN` lambdas as the `url_strategy` callable.
+# All of those are Procs created in the main Ractor; calling them from a worker
+# Ractor that shares the frozen app graph raises
+# "defined with an un-shareable Proc in a different Ractor".
+#
+# Fixes (must run BEFORE routes are drawn, i.e. before
+# `Rails.application.initialize!`):
+#
+#   * Replace `RouteSet::PATH` / `RouteSet::UNKNOWN` with shareable `Method`
+#     objects (a `Method` is Ractor-shareable, unlike a lambda).
+#   * Regenerate the named helpers and `_routes` / `_generate_paths_by_default`
+#     as compiled `def` methods (shareable) instead of `define_method` blocks.
+#     The per-helper `CustomUrlHelper`/`UrlHelper` object is stored on the
+#     module as a constant and looked up inside the `def`.
+#
+# NOTE: all `module_eval` bodies are built with string *concatenation* (no
+# `#{}` inside string literals) so they are not interpolated at patch-apply
+# time. Method-level `#{}` in symbol literals (e.g. `:"RRS_HELPER_#{name}"`)
+# is ordinary Ruby interpolation evaluated when the generated method runs.
+
+module RactorRailsShim
+  class << self
+    def install_route_helpers_patch
+      return if @route_helpers_patched
+      @route_helpers_patched = true
+      _register_patch :route_helpers, "8.1"
+      return unless defined?(::ActionDispatch::Routing::RouteSet)
+
+      rs = ::ActionDispatch::Routing::RouteSet
+
+      # 1. Replace the PATH / UNKNOWN lambdas with shareable Method objects.
+      begin
+        rs.send(:remove_const, :PATH) if rs.const_defined?(:PATH, false)
+      rescue
+      end
+      rs.const_set(:PATH, ::ActionDispatch::Http::URL.method(:path_for)) rescue nil
+      begin
+        rs.send(:remove_const, :UNKNOWN) if rs.const_defined?(:UNKNOWN, false)
+      rescue
+      end
+      rs.const_set(:UNKNOWN, ::ActionDispatch::Http::URL.method(:url_for)) rescue nil
+
+      # 2. Named route helpers -> compiled `def` (regular `resources` routes).
+      rs.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def define_url_helper(mod, name, helper, url_strategy)
+          const_name = :"RRS_HELPER_\#{name}"
+          mod.const_set(const_name, helper)
+          strategy = url_strategy.equal?(PATH) ? :PATH : :UNKNOWN
+          body = "def " + name.to_s + "(*args)\\n" \
+                 "  last = args.last\\n" \
+                 "  options = case last\\n" \
+                 "    when Hash then args.pop\\n" \
+                 "    when ActionController::Parameters then args.pop.to_h\\n" \
+                 "  end\\n" \
+                 "  ::ActionDispatch::Routing::RouteSet.const_get(" + const_name.inspect + ").call(self, " + name.inspect + ", args, options, ::ActionDispatch::Routing::RouteSet.const_get(" + strategy.inspect + "))\\n" \
+                 "end"
+          mod.module_eval(body, __FILE__, __LINE__ + 1)
+        end
+      RUBY
+
+      # 3. `direct` / `resolve` helpers -> compiled `def`.
+      if defined?(::ActionDispatch::Routing::RouteSet::NamedRouteCollection)
+        ::ActionDispatch::Routing::RouteSet::NamedRouteCollection.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def add_url_helper(name, defaults, &block)
+            helper = CustomUrlHelper.new(name, defaults, &block)
+            path_name = :"\#{name}_path"
+            url_name  = :"\#{name}_url"
+            @path_helpers_module.const_set(:"RRS_HELPER_\#{path_name}", helper)
+            @url_helpers_module.const_set(:"RRS_HELPER_\#{url_name}", helper)
+            pbody = "def " + path_name.to_s + "(*args)\\n  const_get(:\\\"RRS_HELPER_" + path_name.to_s + "\\\").call(self, args, true)\\nend"
+            ubody = "def " + url_name.to_s + "(*args)\\n  const_get(:\\\"RRS_HELPER_" + url_name.to_s + "\\\").call(self, args, false)\\nend"
+            @path_helpers_module.module_eval(pbody, __FILE__, __LINE__ + 1)
+            @url_helpers_module.module_eval(ubody, __FILE__, __LINE__ + 1)
+            @path_helpers << path_name
+            @url_helpers  << url_name
+            self
+          end
+        RUBY
+      end
+
+      # 4. `_routes` / `_generate_paths_by_default` -> compiled `def`.
+      rs.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        alias_method :_rrs_orig_generate_url_helpers, :generate_url_helpers
+        def generate_url_helpers(supports_path)
+          routes = self
+          mod = _rrs_orig_generate_url_helpers(supports_path)
+          mod.module_eval("def _routes\n  @_routes || ::Rails.application.routes\nend", __FILE__, __LINE__ + 1)
+          mod.module_eval("def _generate_paths_by_default\n  " + supports_path.inspect + "\nend", __FILE__, __LINE__ + 1)
+          mod
+        end
+      RUBY
+    end
+
+    # The module-level singleton `_routes` (set via `redefine_singleton_method`
+    # in the gem's `included` block) is still a `define_method` block. It is not
+    # on the request hot-path, but make it shareable anyway. Called after the
+    # module has been included into ActionView/ActionController (i.e. from
+    # `prepare_for_ractors!`).
+    def fix_url_helpers_singleton_routes
+      return unless defined?(::Rails) && ::Rails.application
+      return unless ::Rails.application.routes.respond_to?(:url_helpers)
+      mod = ::Rails.application.routes.url_helpers
+      return unless mod.respond_to?(:singleton_class)
+      mod.singleton_class.class_eval do
+        def _routes
+          ::Rails.application.routes
+        end
+      end
+    rescue
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/rubygems.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Patch RubyGems `Gem.paths` (and thus `Gem.path`) to be Ractor-safe.
+#
+# In development, Propshaft serves assets on the fly and, on every request,
+# runs its cache sweeper. That calls ActiveSupport::FileUpdateChecker which
+# reads `Gem.path` -> `Gem.paths` -> the unshareable `@paths` class ivar on
+# `Gem`. Reading that ivar from a worker Ractor raises Ractor::IsolationError
+# ("can not get unshareable values ... @paths from Gem"). Any other dev code
+# path that reads `Gem.path` from a worker hits the same wall.
+#
+# Fix: in the main Ractor `Gem.paths` behaves exactly as before (aliased to
+# the original). In a worker Ractor we return a shareable snapshot of the
+# main Ractor's gem paths, captured at prepare_for_ractors! time (after
+# Bundler has configured gem paths, so the snapshot is complete).
+
+module RactorRailsShim
+  class << self
+    # Installed at `install` (boot) time. Only redefines the reader; the
+    # snapshot is filled in later by `snapshot_gem_paths!`.
+    def install_rubygems
+      return if @rubygems_patched
+      @rubygems_patched = true
+      _register_patch :rubygems, "all"
+      return unless defined?(::Gem)
+      patch_rubygems!
+    end
+
+    def patch_rubygems!
+      return if @rubygems_method_patched
+      @rubygems_method_patched = true
+      gem = ::Gem
+      unless gem.singleton_class.method_defined?(:__shim_original_gem_paths)
+        gem.singleton_class.alias_method :__shim_original_gem_paths, :paths
+      end
+      # `def` (not `define_method`) so the method has no captured binding and
+      # is callable from any Ractor. `Ractor.main?` + a shareable constant are
+      # both Ractor-safe.
+      gem.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def paths
+          if Ractor.main?
+            __shim_original_gem_paths
+          else
+            ::RactorRailsShim::GEM_PATHS_SNAPSHOT
+          end
+        end
+      RUBY
+    end
+
+    # Called from prepare_for_ractors! (post-boot, main Ractor) so the
+    # snapshot reflects Bundler-configured gem paths. Also called from
+    # install as a safety net so the constant is never undefined.
+    def snapshot_gem_paths!
+      return unless defined?(::Gem)
+      return if defined?(::RactorRailsShim::GEM_PATHS_SNAPSHOT)
+      snap = ::Gem.paths
+      begin
+        Ractor.make_shareable(snap)
+      rescue StandardError
+        snap = Ractor.make_shareable(::Gem.path)
+      end
+      ::RactorRailsShim.const_set(:GEM_PATHS_SNAPSHOT, snap)
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/url_helpers.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Make Rails' URL generation Ractor-safe.
+#
+# Two distinct problems exist in Rails' URL helpers under a frozen, shared
+# (Ractor) graph:
+#
+# 1. Named route helpers, `_routes`, and `_generate_paths_by_default` are all
+#    defined with `define_method(&block)` / `redefine_method(&block)`, so their
+#    bodies are Procs created in the *main* Ractor. Any worker that calls them
+#    raises "defined with an un-shareable Proc in a different Ractor".
+#
+# 2. `RouteSet::PATH` / `RouteSet::UNKNOWN` are lambdas used as the
+#    `url_strategy` callable inside every helper; calling them from a worker is
+#    also un-shareable.
+#
+# These are addressed in `route_helpers.rb` (run *before* routes are drawn):
+# the helper methods are regenerated as compiled `def`s and `PATH`/`UNKNOWN`
+# are replaced with shareable `Method` objects.
+#
+# This file adds a defensive safety net: if any residual un-shareable error
+# slips through, we re-dispatch the same call from this shim-defined method
+# (whose scope is the worker's own Ractor).
+
+module RactorRailsShim
+  class << self
+    def install_url_helpers_patch
+      return if @url_helpers_patched
+      @url_helpers_patched = true
+      _register_patch :url_helpers, "8.1"
+      return unless defined?(::ActiveRecord::Base)
+
+      if defined?(::ActionView::RoutingUrlFor)
+        ::ActionView::RoutingUrlFor.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          alias_method :_rrs_orig_view_url_for, :url_for
+          def url_for(options = nil)
+            _rrs_orig_view_url_for(options)
+          rescue => e
+            raise unless e.message.include?("un-shareable Proc")
+            if options.is_a?(Hash) || options.is_a?(ActionController::Parameters)
+              full_url_for(options)
+            else
+              meth = _generate_paths_by_default ? :path : :url
+              builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.public_send(meth)
+              builder.handle_model_call(self, options)
+            end
+          end
+        RUBY
+      end
+
+      if defined?(::ActionDispatch::Routing::UrlFor)
+        ::ActionDispatch::Routing::UrlFor.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          alias_method :_rrs_orig_full_url_for, :full_url_for
+          def full_url_for(options = nil)
+            _rrs_orig_full_url_for(options)
+          rescue => e
+            raise unless e.message.include?("un-shareable Proc")
+            if options.is_a?(Hash) || options.is_a?(ActionController::Parameters)
+              route_name = options.delete :use_route
+              merged = options.to_h.symbolize_keys.reverse_merge!(url_options)
+              # `self._routes` is an un-shareable `define_method` block in a
+              # worker Ractor, so calling it re-raises the same error. Route the
+              # fallback through the worker-safe shareable RouteSet instead.
+              if RactorRailsShim.const_defined?(:SHAREABLE_ROUTES)
+                RactorRailsShim::SHAREABLE_ROUTES.url_for(merged, route_name)
+              else
+                _routes.url_for(merged, route_name)
+              end
+            else
+              builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.url
+              builder.handle_model_call(self, options)
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/ractor_rails_shim/patches/warden.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+# Patch Warden::Hooks lazy class-ivar accessors (@_on_request ||= [] etc).
+# Warden middleware holds 6 lazy-init class ivars for callback arrays.
+# make_app_shareable! freezes the middleware instance; the ||= lazy init
+# tries to WRITE on the frozen instance → IsolationError in workers.
+# The callbacks (Procs) were registered at boot and already ran in main;
+# workers treat them as empty (correct for a read-only shared app).
+
+module RactorRailsShim
+  # Devise constants that need to be made shareable.
+  SHAREABLE_CONSTANTS.concat([
+    "Devise::ParameterSanitizer::DEFAULT_PERMITTED_ATTRIBUTES",
+    "Devise::Mapping::DEFAULTS",
+    "Devise::DEVS",
+    "Devise::URLS",
+    "Devise::STRATEGIES",
+    "Devise::CONTROLLERS",
+    "Devise::MODULES",
+  ])
+
+  # Source-location constant for the Devise scope constraint Proc (moved from
+  # make_shareable.rb so the Devise-related callable lives with the Devise patch).
+  DEVISE_SCOPE_LOC = "/devise/rails/routes.rb".freeze
+
+  class << self
+    def _install_warden_hooks_patch
+      return if @warden_patched
+      @warden_patched = true
+      _register_patch :warden_hooks, "8.1"
+      return unless defined?(::Warden::Hooks)
+      ::Warden::Hooks.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def _after_set_user
+          if Ractor.main? && instance_variable_defined?(:@_after_set_user)
+            @_after_set_user
+          else
+            []
+          end
+        end
+        def _before_failure
+          if Ractor.main? && instance_variable_defined?(:@_before_failure)
+            @_before_failure
+          else
+            []
+          end
+        end
+        def _after_failed_fetch
+          if Ractor.main? && instance_variable_defined?(:@_after_failed_fetch)
+            @_after_failed_fetch
+          else
+            []
+          end
+        end
+        def _before_logout
+          if Ractor.main? && instance_variable_defined?(:@_before_logout)
+            @_before_logout
+          else
+            []
+          end
+        end
+        def _on_request
+          if Ractor.main? && instance_variable_defined?(:@_on_request)
+            @_on_request
+          else
+            []
+          end
+        end
+      RUBY
+    end
+
+    # Patch Warden::Strategies#_strategies. The strategy registry is a lazy
+    # class ivar (`@strategies ||= {}`) on the Warden::Strategies module; a
+    # worker Ractor reading it raises "can not get unshareable values from
+    # instance variables of classes/modules from non-main Ractors" (Devise's
+    # `current_user` / `user_signed_in?` in a layout hits
+    # Warden::Strategies[label] -> _strategies). Capture the (shareable)
+    # registry in main and expose it via a constant that workers read.
+    def _install_warden_strategies_patch
+      return if @warden_strategies_patched
+      @warden_strategies_patched = true
+      _register_patch :warden_strategies, "8.1"
+      return unless defined?(::Warden::Strategies)
+      ::Warden::Strategies.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def _strategies
+          if Ractor.main?
+            @strategies ||= {}
+          else
+            RactorRailsShim::SHAREABLE_WARDEN_STRATEGIES || {}
+          end
+        end
+      RUBY
+      if Ractor.main?
+        begin
+          strat = ::Warden::Strategies.instance_variable_get(:@strategies)
+          strat = Ractor.make_shareable(strat) if strat && !Ractor.shareable?(strat)
+          RactorRailsShim.const_set(:SHAREABLE_WARDEN_STRATEGIES, strat) unless RactorRailsShim.const_defined?(:SHAREABLE_WARDEN_STRATEGIES)
+        rescue
+          nil
+        end
+      end
+    end
+
+    # Warden registers per-scope session serializers with
+    # `Warden::SessionSerializer.send(:define_method, method_name, &block)`
+    # (warden-1.2.9/lib/warden/manager.rb:71). The block is created while the
+    # app boots in the main Ractor, so the resulting method is Ractor-bound:
+    # invoking it (e.g. `user_serialize`) from a worker Ractor raises
+    # "defined with an un-shareable Proc in a different Ractor".
+    #
+    # Devise's block body is simply `mapping.to.serialize_into_session(record)`.
+    # We re-register the serializers as plain `def` methods (which are NOT
+    # Ractor-bound) that delegate to the model class's own
+    # `serialize_into_session` / `serialize_from_session` class methods — both
+    # worker-safe — so the chain is callable from any worker Ractor.
+    def _install_warden_serializer_patch
+      return if @warden_serializer_patched
+      @warden_serializer_patched = true
+      _register_patch :warden_serializer, "8.1"
+      return unless defined?(::Warden::SessionSerializer)
+
+      if defined?(::Devise) && ::Devise.respond_to?(:mappings)
+        ::Devise.mappings.each do |scope, mapping|
+          model = mapping.to
+          ::Warden::SessionSerializer.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{scope}_serialize(record)
+              #{model}.serialize_into_session(record)
+            end
+
+            def #{scope}_deserialize(*keys)
+              # Devise's serialize_into_session returns [[id], salt]. The key
+              # passed by Warden::SessionSerializer#fetch is that value, but in
+              # the kino :ractor worker the per-request session that Warden's
+              # serializer sees can hold an extra wrapping layer
+              # ([[[id], salt]]). Flatten so serialize_from_session(key, salt)
+              # always receives exactly two arguments.
+              #{model}.serialize_from_session(*keys.flatten)
+            end
+          RUBY
+        end
+      end
+
+      ::Warden::SessionSerializer.class_eval do
+        unless method_defined?(:serialize)
+          def serialize(user)
+            user
+          end
+        end
+
+        unless method_defined?(:deserialize)
+          def deserialize(key)
+            key
+          end
+        end
+      end
+    end
+
+    # --- Devise scope-constraint callable (moved from make_shareable.rb) ---
+    # Defined via string eval on the singleton class so it's referenced the same
+    # way the original code did (RactorRailsShim.singleton_class.const_get).
+    module_eval <<-RUBY, __FILE__, __LINE__ + 1
+      class DeviseMappingCallable
+        def initialize(mapping); @mapping = mapping; end
+        def call(request)
+          request.env["devise.mapping"] = @mapping
+          true
+        end
+      end
+    RUBY
+
+    # Build a shareable replacement for a Devise scope constraint.
+    # The original Proc (devise/rails/routes.rb:363) does:
+    #   request.env["devise.mapping"] = Devise.mappings[scope]
+    #   true
+    # The scope is captured in the Proc's binding. We call the original
+    # Proc once in main with a mock request to capture the mapping, then
+    # make it shareable and wrap it in a DeviseMappingCallable.
+    def _devise_mapping_replacement(proc_obj, _parent)
+      mock_env = { "devise.mapping" => nil }
+      mock_req = Struct.new(:env).new(mock_env)
+      begin
+        proc_obj.call(mock_req)
+      rescue
+      end
+      mapping = mock_env["devise.mapping"]
+      if mapping
+        mapping = _devise_mapping_snapshot(mapping)
+      end
+      if mapping
+        DeviseMappingCallable.new(mapping)
+      else
+        CallableConst.new(true)
+      end
+    end
+  end
+end