ractor-rails-shim 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a4b7ce968f90326f2b476d713b7fab6c524f8f7b111f60a2ae582d1e162de88
-  data.tar.gz: c144478be527ff98804db48add54d67edb4124514fba3670b970990ef09e36c0
+  metadata.gz: 21002fee5a30f663904441d8c016c035564095bf456048a25917657e9adab5fc
+  data.tar.gz: dcb6764139de152ae7b958112503efc7951d59ae211c04ee268da6bf63a2be51
 SHA512:
-  metadata.gz: 55cc0fb00ebd523182cb66f8ae7a9f270bf33bcaaf928af79d291edf3eeb0248246f956e082200ab74563c7afceee8520336f53373ed9d54ff73f4db9ce05f40
-  data.tar.gz: b19280d1985a1e8b456a6a13750e277a49c5123998a4f7fab587518d3d6a717249d9490cfbe6d32751483d9c5e622373d861fbed9ce50d8daeabb09578b897e9
+  metadata.gz: 28cf75ae0f4972142cee3965d5c68fd8b70c09b901dc60c186f178ac403fc7695c3f7e2e77e4591c9aa6aa0fc9c6d1ba5eafa8e3c64d5abad545b50159159d6c
+  data.tar.gz: b1bf30685c4b7082c5930a63693571e4d3affff2fa0b530fd355aaf5a57f5cf42280ff5a590f099705e8af573ae953d654ace88fbb813dc05e463379fa0c09c7

data/CHANGELOG.md

@@ -7,6 +7,163 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0]
+
+### Changed — breaking (public API)
+- **`worker_app` renamed to `worker_app!`.** The factory freezes +
+  `Ractor.make_shareable`s the `WorkerApp` — a destructive build — so it
+  now carries the bang the naming convention reserves for "mutates /
+  produces a frozen shareable." Callers following the README's
+  `Ractor.new(worker_app) { |a| a.call(env) }` example must update to
+  `worker_app!`. The old name is gone. (`patches/core.rb`)
+
+- **`fix_url_helpers_singleton_routes` renamed to
+  `fix_url_helpers_singleton_routes!`.** Mutates the global routes
+  singleton; now bang-suffixed per the convention documented at the top
+  of `patches.rb`. (`patches/route_helpers.rb`)
+
+- **Tightened `activesupport` dependency to `>= 8.1`.** The gemspec
+  previously declared `>= 7.0`, but the shim only supports Rails 8.1
+  (per `Version::TESTED_RAILS` / `SUPPORTED_RAILS`). The looser bound let
+  Bundler resolve against AS 7.x where the class-layout patches
+  (`class_attribute`, `Callbacks`, `PathRegistry`, …) would silently miss
+  blockers or redefine the wrong methods. Bound at `>= 8.1` so Bundler
+  fails fast on an unsupported Rails. (`ractor-rails-shim.gemspec`)
+
+### Fixed
+- **`_apply_shareable_constants!` set the done-flag on undefined
+  constants.** It set `@shareable_constants_done = true` after the first
+  run unconditionally, even when registered constants didn't exist yet
+  (`make_constant_shareable` returned `false`). A later call (from
+  `make_app_shareable!` or `prepare_for_ractors!`) short-circuited on the
+  flag and never retried the now-loadable constants — workers then hit
+  `Ractor::IsolationError` on unshareable values (e.g.
+  `Rack::Utils::PATH_SEPS`, a Regexp not deep-frozen until
+  `make_shareable` runs on it). The flag now sets only when every
+  registered constant was made shareable; any `false` return leaves it
+  unset so the next call retries. Caught by the integration spec (boots
+  a real Rails 8.1 app, dispatches `GET /up` in a worker Ractor); pinned
+  by `apply_shareable_constants_retry_spec.rb`.
+
+- **ActionFilter private ivar reads now gated through the `_swallow`
+  debug funnel.** The eval'd `set_callback` interceptor inlined
+  `af.instance_variable_get(:@conditional_key) rescue nil`, but
+  `instance_variable_get` returns nil for a missing ivar *without*
+  raising — the rescue never fired, and a silent Rails internal rename
+  (`@conditional_key` / `@actions`) would leave `only`/`except` nil,
+  making callbacks run for actions they shouldn't (security-relevant)
+  with no visible cause. New `_read_action_filter_constraints(af)` checks
+  `instance_variable_defined?` and emits a labeled
+  `[ractor_rails_shim] action filter constraints: missing ivar …`
+  warning under `debug=true`. Returns `[nil, nil]` for a bare object,
+  `[key, symbols]` when the ivars are present.
+
+- **Dead ternary in thread-mode `class_attribute` reader.** The reader
+  carried `:__class_attr___callbacks == :__callbacks ? {} : nil`, but
+  the namespaced name is always `__class_attr_<name>` (never `<name>`),
+  so the check was always false — dead code that allocated a `Symbol`
+  via `inspect` on every read AND never delivered the intended `{}`
+  default for `__callbacks` (callers index the result, so `nil` would
+  `NoMethodError`). Replaced with a static decision based on the public
+  name, inlining the shared frozen `EMPTY_CALLBACKS_HASH` constant.
+
+- **Redundant `class_variable_set` pair in `mattr_accessor` writer.**
+  The shim-generated writer had two complementary guarded lines
+  (`set if defined?` + `set unless defined?`) that together were one
+  unconditional set, with a wasted `class_variable_defined?` per write.
+  Replaced with a single `class_variable_set(cv, val) if Ractor.main?`.
+
+- **`WorkerApp#setup_once!` race-spec cleanup leak.** The race spec's
+  `ensure` block restored `Thread::Mutex.new` via
+  `define_method { orig_new.call }`, leaving a block that captures a
+  main-Ractor-bound `Method`. When a later spec's worker Ractor called
+  `Thread::Mutex.new` it raised `IsolationError` (flaky
+  `WorkerAppSpec#test_0002`). Replaced with `remove_method(:new)` so the
+  call falls back to the class-defined `new` (no captured binding).
+
+### Changed
+- **Centralized `const_set`-with-suppressed-`$VERBOSE` into
+  `_reassign_shareable_const(name, value)`.** `SHAREABLE_FALLBACK`,
+  `SHAREABLE_MATTR_DEFAULTS`, `SHAREABLE_APP`, and
+  `SHAREABLE_DECLARED_CALLBACKS` were each rebuilt + reassigned via an
+  inlined `$VERBOSE = nil … const_set … ensure $VERBOSE = …` dance. The
+  dance now lives in one helper on `RactorRailsShim`; all rebuild sites
+  (including the 6 `activerecord.rb` sites + 1 `kaminari.rb` site) call
+  it. The constants stay frozen shareable `Hash`es (always readable from
+  any Ractor) — a mutable-then-frozen registry would not be shareable
+  until `freeze!`, breaking workers that read early.
+
+- **Callable/lock object model extracted to `patches/callables.rb`.**
+  `NoOpProc` / `Callable` / `CallableConst` / `DeviseMappingSnapshot` /
+  `NoOpLock` / `NoOpLogDev` + the `_devise_mapping_snapshot` helper moved
+  out of the 964-line `make_shareable.rb` into their own file. Plain
+  class definitions replace the string-eval indirection (the eval was
+  stylistic, not behavioral). `make_shareable.rb`: 964 → 822 lines.
+
+- **`VersionPolicy` module extracted from the `RactorRailsShim` god
+  module.** The version-policy + patch-registry concern (`:warn` /
+  `:strict` / `:off` switch, `PATCH_VERSIONS`, `_register_patch` /
+  `applicable_patches` / `_version_mismatch`) moved from the
+  `RactorRailsShim` singleton in `core.rb` to
+  `RactorRailsShim::VersionPolicy` (`version_policy.rb`). `core.rb` keeps
+  the public facade (`RactorRailsShim.version_policy`, `.applicable_patches`,
+  `::PATCH_VERSIONS`, `::UnsupportedVersionError`) delegating to the
+  module. Orthogonal to the already-extracted `RactorRailsShim::Version`
+  (detection).
+
+- **`mattr_accessor` split into single-responsibility helpers.** The
+  per-symbol body did four things (call super, push to `CLASS_ATTRIBUTES`,
+  seed the default + rebuild the shareable constant, redefine the
+  reader/writer). Extracted `_seed_mattr_default(key, default)` and
+  `_register_for_fallback(mod_name, sym, key, default)`; `mattr_accessor`
+  now reads `super, register, seed, redefine`.
+
+- **Thread-mode vs Ractor-mode `class_attribute` heredocs de-duplicated.**
+  Each branch inlined a near-identical ~25-line reader/writer heredoc,
+  differing only in the method name. Extracted
+  `_class_attr_thread_methods` / `_class_attr_ractor_methods` (each builds
+  one reader+writer pair); `redefine` calls the helper twice. One source
+  of truth per mode. Also fixed a misaligned `else` (12-space indent in a
+  10-space block). `class_attribute.rb`: 232 → 224 lines.
+
+- **Freeze-path bare rescues routed through the `_swallow` debug funnel.**
+  `_freeze_shareable_class_ivars!`, `_freeze_declared_callbacks!`,
+  `_collect_controller_classes`, `_replace_locks_and_concurrent_maps!`,
+  `_replace_one_proc`, `_neutralize_logger_io!`,
+  `DeviseMappingSnapshot`, `_devise_mapping_snapshot`, `_warm_journey_routes`,
+  url-helper freeze, `DUMMY_END_NODE`, `MimeNegotiation`, AR db-config
+  handlers, AR query transformers, devise mappings, and the view-context
+  fallback now emit a labeled `[ractor_rails_shim] <label>: …` line to
+  `$stderr` under `debug=true` instead of bare `rescue; nil`. Silent by
+  default (backward compatible).
+
+- **`fallback_ies.rb` moved into the `RactorRailsShim` namespace.** It
+  previously defined `ActiveSupport::IsolatedExecutionState` directly
+  inside the `ActiveSupport` namespace (guarded by `defined?`). Defining
+  an upstream-namespaced constant from a third-party gem is a
+  namespace-patch smell — if a future AS lazy-loads IES, load order
+  decides which definition wins. The fallback now lives at
+  `RactorRailsShim::FallbackIES` and is aliased onto
+  `ActiveSupport::IsolatedExecutionState` only when the real AS IES is
+  absent. The ~270 string-eval'd references across the patch files
+  resolve to the alias when AS is absent and to the real one when present.
+
+- **Stream-of-consciousness comments trimmed to one-line invariants.**
+  Working-notes-style comments that narrated history ("actually it IS a
+  constant holding…", "Pre-fix the traversals only handled…") replaced
+  with one-line invariant statements. The history is in git.
+
+### Documentation
+- **`WorkerApp#setup_once!` race comment corrected (again).** A prior
+  0.2.6 entry claimed `Ractor.current[:key] ||= Thread::Mutex.new` is
+  atomic in Ruby 4.0.6. It is NOT — `||=` is a read-then-write, and N
+  racing threads produce N distinct mutexes (verified by spec under a
+  widened window). The code is saved by (1) MRI's GIL serializing the
+  flag check inside `synchronize` and (2) `rebind_constants` /
+  `init_worker_ar_connections!` both being idempotent. Comment now states
+  the real contract + the escape hatch if either property changes. Two
+  specs pin the idempotency contract.
+
 ## [0.2.6]
 
 ### Fixed

data/lib/ractor_rails_shim/fallback_ies.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
 # Fallback IsolatedExecutionState when ActiveSupport is not available.
-# This is a simple thread-local storage that mimics the ActiveSupport API
-# enough for the shim to work. In production (with Rails loaded), the real
-# ActiveSupport::IsolatedExecutionState is used instead.
-module ActiveSupport
-  module IsolatedExecutionState
+#
+# The shim's string-eval'd patch methods reference the literal constant
+# `ActiveSupport::IsolatedExecutionState` (no captured binding → callable
+# from any Ractor). To avoid opening the ActiveSupport namespace from a
+# third-party gem, the fallback is defined in the shim's own namespace
+# (RactorRailsShim::FallbackIES) and aliased onto
+# ActiveSupport::IsolatedExecutionState only when the real AS IES is absent.
+# When AS is loaded, the real one wins untouched and no alias is created.
+module RactorRailsShim
+  module FallbackIES
     KEY = :active_support_execution_state_fallback
 
     class << self
@@ -30,4 +35,13 @@ module ActiveSupport
       end
     end
   end
-end unless defined?(ActiveSupport::IsolatedExecutionState)
+end
+
+# Alias onto ActiveSupport::IsolatedExecutionState only when the real AS IES
+# is absent, so the shim's string-eval'd references resolve to the fallback
+# without the shim opening the ActiveSupport namespace to define a module.
+unless defined?(ActiveSupport::IsolatedExecutionState)
+  module ActiveSupport
+    IsolatedExecutionState = RactorRailsShim::FallbackIES
+  end
+end

data/lib/ractor_rails_shim/patches/action_dispatch.rb

@@ -293,7 +293,7 @@ module RactorRailsShim
       # while the objects are still mutable) populates the ivars so the frozen,
       # shared copies already hold the values and workers only read them.
       if Ractor.main? && defined?(::Rails) && ::Rails.application
-        begin
+        _swallow("warm journey routes") do
           rset = ::Rails.application.routes
           all = []
           all.concat(rset.named_routes.send(:routes).values) rescue nil
@@ -310,8 +310,6 @@ module RactorRailsShim
             p.required_names rescue nil
             p.optional_names rescue nil
           end
-        rescue
-          nil
         end
       end
       # Capture the (shareable) RouteSet so workers can build URLs without
@@ -422,15 +420,15 @@ module RactorRailsShim
         nrc.alias_method(:define_url_helper_without_shim, :define_url_helper)
       end
       nrc.define_method(:define_url_helper) do |mod, name, helper, url_strategy|
-        begin
-          # Detach the helper from the live route object before deep-freezing
-          # it for cross-Ractor sharing. The non-optimized UrlHelper#call only
-          # needs @options / @segment_keys / @route_name to build the options
-          # hash and then delegates to `t._routes.url_for(route_name, ...)`,
-          # which looks the route up in the (shareable) RouteSet by name. The
-          # @route reference would pull the whole route graph into the freeze,
-          # freezing objects that make_app_shareable! must still be able to
-          # mutate (e.g. Devise route constraints) -> FrozenError.
+        # Detach the helper from the live route object before deep-freezing
+        # it for cross-Ractor sharing. The non-optimized UrlHelper#call only
+        # needs @options / @segment_keys / @route_name to build the options
+        # hash and then delegates to `t._routes.url_for(route_name, ...)`,
+        # which looks the route up in the (shareable) RouteSet by name. The
+        # @route reference would pull the whole route graph into the freeze,
+        # freezing objects that make_app_shareable! must still be able to
+        # mutate (e.g. Devise route constraints) -> FrozenError.
+        RactorRailsShim._swallow("freeze url helper") do
           if helper.respond_to?(:instance_variable_get)
             helper.instance_variable_set(:@route, nil) rescue nil
             opts = helper.instance_variable_get(:@options)
@@ -439,8 +437,6 @@ module RactorRailsShim
             helper.instance_variable_set(:@segment_keys, segs.dup.freeze) rescue nil
           end
           helper = Ractor.make_shareable(helper)
-        rescue
-          nil
         end
         RactorRailsShim::URL_HELPERS[name] = helper
         strategy_const = url_strategy.equal?(::ActionDispatch::Routing::RouteSet::PATH) ?
@@ -705,7 +701,7 @@ module RactorRailsShim
       if defined?(::ActionDispatch::Journey::GTG::Builder) &&
          ::ActionDispatch::Journey::GTG::Builder.const_defined?(:DUMMY_END_NODE)
         node = ::ActionDispatch::Journey::GTG::Builder.const_get(:DUMMY_END_NODE)
-        Ractor.make_shareable(node) rescue nil
+        _swallow("make journey dummy end node shareable") { Ractor.make_shareable(node) }
       end
     end
 
@@ -787,7 +783,7 @@ module RactorRailsShim
         next unless c.is_a?(::Array) || c.is_a?(::Hash)
         next if c.frozen?
         c.freeze
-        ::Ractor.make_shareable(c) rescue nil
+        _swallow("make mime negotiation constant shareable") { ::Ractor.make_shareable(c) }
       end
     rescue => e
       warn "[ractor-rails-shim] _freeze_mime_negotiation!: #{e.class}: #{e.message}"

data/lib/ractor_rails_shim/patches/action_view.rb

@@ -244,7 +244,7 @@ module RactorRailsShim
           (defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application) ? ::Rails.application.routes : nil,
           nil
         )
-        Ractor.make_shareable(fallback) rescue nil
+        fallback = _swallow("make view context fallback shareable") { Ractor.make_shareable(fallback) }
         self._view_context_fallback = fallback
       end
 

data/lib/ractor_rails_shim/patches/activerecord.rb

@@ -199,12 +199,7 @@ module RactorRailsShim
         end
         snapshot.freeze
         Ractor.make_shareable(snapshot)
-        verbose, $VERBOSE = $VERBOSE, nil
-        begin
-          const_set(:AR_CONFIGURATIONS_SNAPSHOT, snapshot)
-        ensure
-          $VERBOSE = verbose
-        end
+        _reassign_shareable_const(:AR_CONFIGURATIONS_SNAPSHOT, snapshot)
       rescue => e
         # Best-effort; if we can't capture configs, workers won't be able
         # to auto-init connections. They can call init_worker_ar_connections!
@@ -459,12 +454,7 @@ module RactorRailsShim
           pk_map[n] = pk if pk
         end
         shareable = Ractor.make_shareable(pk_map)
-        verbose, $VERBOSE = $VERBOSE, nil
-        begin
-          const_set(:AR_PRIMARY_KEYS_SHAREABLE, shareable)
-        ensure
-          $VERBOSE = verbose
-        end
+        _reassign_shareable_const(:AR_PRIMARY_KEYS_SHAREABLE, shareable)
       rescue => e
         # best-effort
       end
@@ -916,12 +906,7 @@ module RactorRailsShim
           cfg = ::ActiveRecord::Base.configurations
           cfg = Ractor.make_shareable(cfg) if cfg
           if cfg
-            verbose, $VERBOSE = $VERBOSE, nil
-            begin
-              const_set(:AR_CONFIGURATIONS_SHAREABLE, cfg)
-            ensure
-              $VERBOSE = verbose
-            end
+            _reassign_shareable_const(:AR_CONFIGURATIONS_SHAREABLE, cfg)
           end
         rescue => e
           # best-effort
@@ -977,14 +962,9 @@ module RactorRailsShim
           handlers = ::ActiveRecord::DatabaseConfigurations.db_config_handlers
           # Make each handler Proc shareable (freezes its binding). A shareable
           # Proc is callable from any Ractor.
-          handlers.each { |h| Ractor.make_shareable(h) rescue nil }
+          handlers.each { |h| _swallow("make ar db config handler shareable") { Ractor.make_shareable(h) } }
           shareable = Ractor.make_shareable(handlers.dup)
-          verbose, $VERBOSE = $VERBOSE, nil
-          begin
-            const_set(:AR_DB_CONFIG_HANDLERS_SHAREABLE, shareable)
-          ensure
-            $VERBOSE = verbose
-          end
+          _reassign_shareable_const(:AR_DB_CONFIG_HANDLERS_SHAREABLE, shareable)
         rescue => e
           # best-effort
         end
@@ -1031,14 +1011,9 @@ module RactorRailsShim
       if Ractor.main?
         begin
           transformers = ::ActiveRecord.query_transformers
-          transformers.each { |t| Ractor.make_shareable(t) rescue nil }
+          transformers.each { |t| _swallow("make ar query transformer shareable") { Ractor.make_shareable(t) } }
           shareable = Ractor.make_shareable(transformers.dup)
-          verbose, $VERBOSE = $VERBOSE, nil
-          begin
-            const_set(:AR_QUERY_TRANSFORMERS_SHAREABLE, shareable)
-          ensure
-            $VERBOSE = verbose
-          end
+          _reassign_shareable_const(:AR_QUERY_TRANSFORMERS_SHAREABLE, shareable)
         rescue => e
           # best-effort
         end
@@ -1085,12 +1060,7 @@ module RactorRailsShim
           begin
             val = ::ActiveRecord.public_send(method_name)
             shareable = Ractor.make_shareable(val.is_a?(::Array) ? val.dup : val)
-            verbose, $VERBOSE = $VERBOSE, nil
-            begin
-              const_set(const_name, shareable)
-            ensure
-              $VERBOSE = verbose
-            end
+            _reassign_shareable_const(const_name, shareable)
           rescue => e
             # best-effort
           end

data/lib/ractor_rails_shim/patches/callables.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+# Callable / lock-replacement object model. These classes are shareable
+# stand-ins for unshareable Rails internals (self-capturing Procs, Mutexes,
+# IO-backed log devices) that make_app_shareable! swaps into the app graph
+# before Ractor.make_shareable. Extracted from make_shareable.rb so the
+# object model has its own home.
+#
+# Defined on RactorRailsShim's singleton class (the same access path the rest
+# of the codebase uses: RactorRailsShim.singleton_class.const_get(:NoOpProc)).
+
+module RactorRailsShim
+  class << self
+    class NoOpProc
+      def call(*_); nil; end
+      # A NoOpProc is a shareable stand-in for an arbitrary Proc in the app
+      # graph. Some Rails code passes such values through `&block`, which
+      # calls `#to_proc` and then requires the result to be a real Proc.
+      # Return a frozen no-op lambda so the implicit conversion succeeds and
+      # the (side-effect-free) call is a true no-op, matching `#call`.
+      #
+      # The lambda is a shareable constant (frozen at class load), NOT
+      # memoized on `@_to_proc`: NoOpProc instances are deep-frozen by
+      # `Ractor.make_shareable` during `make_app_shareable!`, so an
+      # `@_to_proc ||= ...` write would raise FrozenError on the frozen
+      # instance. A constant avoids the write entirely and is safe to share.
+      NO_OP_LAMBDA = ->(*) { nil }.freeze
+      Ractor.make_shareable(NO_OP_LAMBDA)
+      def to_proc
+        NO_OP_LAMBDA
+      end
+    end
+
+    class Callable
+      def initialize(target, method_name)
+        @target = target
+        @method_name = method_name
+      end
+      def call(*args)
+        @target.__send__(@method_name, *args)
+      end
+    end
+
+    class CallableConst
+      def initialize(value); @value = value; end
+      def call(*_); @value; end
+    end
+
+    # Shareable snapshot of a Devise::Mapping. The real Mapping holds an
+    # unshareable lambda (failure_app) plus a default-proc Hash (controllers),
+    # so it can't be Ractor.make_shareable'd. Request-time code only reads a
+    # handful of attributes (name, to/class, router_name, controllers, ...),
+    # which are all shareable values. We copy those now (in main) into a
+    # frozen Plain Old Object that plays the role of the Mapping in workers.
+    class DeviseMappingSnapshot
+      def initialize(mapping)
+        @name         = mapping.name
+        @klass        = mapping.to
+        @router_name  = mapping.instance_variable_get(:@router_name)
+        @singular     = mapping.instance_variable_get(:@singular)
+        @scoped_path  = mapping.instance_variable_get(:@scoped_path)
+        @path         = mapping.instance_variable_get(:@path)
+        @path_prefix  = mapping.instance_variable_get(:@path_prefix)
+        @format       = mapping.instance_variable_get(:@format)
+        @sign_out_via = mapping.instance_variable_get(:@sign_out_via)
+        @modules      = mapping.modules
+        @strategies   = mapping.strategies
+        @routes       = mapping.routes
+        @used_helpers = mapping.used_helpers
+        # controllers is a Hash with a default proc (unshareable) — copy the
+        # entries into a plain frozen Hash.
+        h = {}
+        RactorRailsShim._swallow("devise mapping controllers") do
+          mapping.controllers.each { |k, v| h[k] = v }
+        end
+        @controllers = h.freeze
+        # failure_app is either Devise::FailureApp (a shareable class) or a
+        # lambda (when configured as a String) — keep only the shareable class.
+        fa = mapping.instance_variable_get(:@failure_app)
+        fa = ::Devise::FailureApp unless fa.is_a?(Class)
+        @failure_app = fa
+        freeze
+      end
+
+      def name; @name; end
+      def to; @klass; end
+      def router_name; @router_name; end
+      def singular; @singular; end
+      def scoped_path; @scoped_path; end
+      def path; @path; end
+      def path_prefix; @path_prefix; end
+      def format; @format; end
+      def sign_out_via; @sign_out_via; end
+      def modules; @modules; end
+      def strategies; @strategies; end
+      def routes; @routes; end
+      def used_helpers; @used_helpers; end
+      def controllers; @controllers; end
+      def failure_app; @failure_app; end
+      def authenticatable?; @modules.any? { |m| m.to_s =~ /authenticatable/ }; end
+      def no_input_strategies; @strategies & Devise::NO_INPUT; end
+      def fullpath; "/#{@path_prefix}/#{@path}".squeeze("/"); end
+      # Devise::Mapping defines one `x?` predicate per Devise module
+      # (confirmable?, rememberable?, registerable?, ...) via `add_module`.
+      # Rather than enumerate them, fall back for any `x?` predicate to
+      # checking @modules — matching the generated behaviour.
+      def respond_to_missing?(method, _)
+        method.to_s.end_with?("?") || super
+      end
+
+      def method_missing(method, *args)
+        s = method.to_s
+        if s.end_with?("?") && args.empty?
+          @modules.include?(s.chomp("?").to_sym)
+        else
+          super
+        end
+      end
+    end
+
+    def _devise_mapping_snapshot(mapping)
+      _swallow("devise mapping snapshot") { DeviseMappingSnapshot.new(mapping) }
+    end
+
+    class NoOpLock
+      def synchronize; yield; end
+      def mon_synchronize; yield; end
+      def lock; self; end
+      def unlock; self; end
+      def locked?; false; end
+      def mon_enter; end
+      def mon_exit; end
+      def mon_locked?; false; end
+      def try_lock; true; end
+      def new_cond; Struct.new(:wait, :signal, :broadcast).new(-> {}, -> {}, -> {}); end
+    end
+
+    # No-op log device sink: a frozen, shareable stand-in for an IO, swapped
+    # in for $stdout/$stderr in the app's logger before make_shareable so
+    # the real IOs aren't frozen. Responds to the write methods a
+    # Logger::LogDevice might call.
+    class NoOpLogDev
+      def write(*_); self; end
+      def <<(*_); self; end
+      def puts(*_); self; end
+      def print(*_); self; end
+      def flush; self; end
+      def close; self; end
+      def sync=(*_); self; end
+      def binmode; self; end
+      def tty?; false; end
+      def closed?; false; end
+    end
+  end
+end