ruact 0.0.1 → 0.0.3

data/lib/generators/ruact/install/install_generator.rb

@@ -61,6 +61,49 @@ module Ruact
           File.exist?(destination_root.join("app/javascript/components/.keep"))
       end
 
+      # Story 8.0a — scaffold the directory the codegen writes into and add the
+      # generated artifacts to .gitignore. The TS module is regenerated on every
+      # boot from the action and query registries, so it should never be
+      # version-controlled; same for the bridge JSON under tmp/cache/.
+      def create_server_functions_directory
+        empty_directory "app/javascript/.ruact"
+        create_file "app/javascript/.ruact/.gitkeep" unless
+          File.exist?(destination_root.join("app/javascript/.ruact/.gitkeep"))
+      end
+
+      def append_gitignore_entries
+        gitignore = destination_root.join(".gitignore")
+        return unless gitignore.exist?
+
+        entries = [
+          "app/javascript/.ruact/server-functions.ts",
+          # Story 9.3 — the route-driven (v2) parallel inspection target is also
+          # generated output, never source.
+          "app/javascript/.ruact/server-functions.next.ts",
+          "tmp/cache/ruact/"
+        ]
+        # Substring matches (`existing.include?(entry)`) were unsafe — they
+        # would skip "tmp/cache/ruact/" when the file already contained
+        # "tmp/cache/ruact/some-cache.bin", leaving the directory itself
+        # un-ignored. Match by exact normalized line instead.
+        existing_lines = File.read(gitignore).each_line.to_set { |line| line.chomp.strip }
+        new_entries = entries.reject { |e| existing_lines.include?(e) }
+        return if new_entries.empty?
+
+        append_to_file ".gitignore", "\n# ruact (Story 8.0a — auto-generated server-functions module)\n"
+        new_entries.each { |entry| append_to_file ".gitignore", "#{entry}\n" }
+      end
+
+      # Invokes `ruact:server_functions:generate` so a fresh install completes
+      # with the AC8-required empty-but-valid generated module on disk.
+      # Failures (a NameBridge violation, a collision, an unwritable
+      # `tmp/cache/ruact/` directory) propagate intentionally — silencing
+      # them via a rescue would let an install finish in a broken state, which
+      # is the bug the Re-run review caught.
+      def prime_server_functions_codegen
+        rake "ruact:server_functions:generate"
+      end
+
       def create_vite_config
         vite_config_file = destination_root.join("vite.config.js")
 

data/lib/generators/ruact/install/templates/application.jsx.tt

@@ -1,7 +1,7 @@
 import { createRoot } from 'react-dom/client';
 import { useState, useEffect } from 'react';
 import { createFromFlightPayload } from './flight-client.js';
-import { setupRouter, teardownRouter } from './rsc-router.js';
+import { setupRouter, teardownRouter } from './ruact-router.js';
 
 // MODULE_REGISTRY maps react-client-manifest "id" values to component exports.
 // Add each "use client" component here as you create it.

data/lib/generators/ruact/install/templates/initializer.rb.tt

@@ -5,7 +5,7 @@ Ruact.configure do |config|
   # Defaults to Rails.root.join("public/react-client-manifest.json").
   # config.manifest_path = Rails.root.join("public", "react-client-manifest.json")
 
-  # When true, objects without explicit rsc_props declaration raise
+  # When true, objects without explicit ruact_props declaration raise
   # Ruact::SerializationError instead of falling back to as_json.
   # Recommended: true in production to prevent accidental attribute exposure.
   # config.strict_serialization = Rails.env.production?

data/lib/ruact/client_manifest.rb

@@ -43,19 +43,22 @@ module Ruact
     #
     # Returns the same object for repeated calls with the same resolved key
     # (needed for dedup by object_id in Flight::Serializer).
-    # Raises if the resolved name is not found in the manifest.
+    #
+    # Raises +Ruact::ManifestError+ when the resolved name is not found. The
+    # error message includes a Damerau-Levenshtein closest-match suggestion
+    # (Story 7.4) when a manifest entry within distance 2 exists, or a
+    # file-path hint suggesting where to add the missing component otherwise.
+    # When +controller_path+ is given the closest-match scan biases toward
+    # co-located keys so a typo inside +posts/show.html.erb+ surfaces the
+    # +posts/_like_button+ suggestion before the shared +LikeButton+ entry.
     def reference_for(name, controller_path: nil)
       @reference_cache ||= {}
       key = resolve_key(name, controller_path)
       @reference_cache[key] ||= begin
         entry = entries_by_name[key]
-        unless entry
-          raise ManifestError,
-                "Component #{name.inspect} not found in manifest — " \
-                "Did you run the Vite build? Run 'npm run build' or start the Vite dev server."
-        end
+        raise ManifestError, build_unknown_component_message(name, controller_path) unless entry
 
-        Flight::ClientReference.new(module_id: entry["id"], export_name: name)
+        Flight::ClientReference.new(module_id: entry["id"], export_name: entry["name"])
       end
     end
 
@@ -73,39 +76,149 @@ module Ruact
     end
 
     # Build from an already-parsed Hash (useful in tests).
+    # The +@reference_cache+ ivar is initialized eagerly so the freeze +
+    # first-lookup path works even when +data+ is empty (otherwise
+    # +reference_for+ would raise +FrozenError+ trying to memoize on a
+    # frozen instance).
     def self.from_hash(data)
       manifest = new
       manifest.instance_variable_set(:@data, data)
+      manifest.instance_variable_set(:@reference_cache, {})
       manifest
     end
 
     private
 
+    # Story 7.4: build the ManifestError message for a missing component,
+    # using the AC3 verbatim multi-line "ruact:" shape with a Damerau-
+    # Levenshtein closest-match suggestion (or a file-path fallback hint).
+    def build_unknown_component_message(name, controller_path = nil)
+      suggestion = closest_match_for(name, entries_by_name.keys, controller_path)
+      hint = if suggestion
+               %(Did you mean "#{suggestion}"?)
+             else
+               "Did you mean to add app/javascript/components/#{name}.jsx and rebuild Vite?"
+             end
+
+      <<~MSG.strip
+        ruact: Component #{name.inspect} not found in manifest.
+          #{hint}
+          Did you run the Vite build? Run 'npm run build' or start the Vite dev server.
+      MSG
+    end
+
+    # Returns the manifest key whose comparable name is within Damerau-
+    # Levenshtein distance 2 of +name+ (case-insensitive), preferring the
+    # smallest distance. Returns +nil+ if no key qualifies.
+    #
+    # Comparison-key normalization (so a typo like "LikeButtoon" can match
+    # the co-located key "posts/_like_button"):
+    #
+    # - Shared PascalCase keys (e.g. "LikeButton") compare as-is.
+    # - Co-located keys (e.g. "posts/_like_button") compare as the basename
+    #   in PascalCase ("LikeButton"); the original key is what gets returned
+    #   so the developer sees the actual manifest entry name.
+    #
+    # When +controller_path+ is given, the matching logic prefers keys
+    # scoped to that path (e.g. "posts/_*") so a typo inside posts/show
+    # surfaces "posts/_like_button" before the shared "LikeButton" — even
+    # if both tie at the same distance.
+    def closest_match_for(name, pool, controller_path = nil)
+      target = name.downcase
+      best_key = nil
+      best_distance = 3 # threshold + 1
+      best_in_scope = false
+
+      pool.each do |key|
+        comparable = comparable_name_for(key).downcase
+        distance = self.class.send(:damerau_levenshtein_distance, target, comparable)
+        next if distance > 2
+
+        in_scope = controller_path && key.start_with?("#{controller_path}/")
+        next unless distance < best_distance || (distance == best_distance && in_scope && !best_in_scope)
+
+        best_distance = distance
+        best_key = key
+        best_in_scope = in_scope
+      end
+
+      best_key
+    end
+
+    # Normalize a manifest key for comparison purposes. Co-located keys
+    # ("posts/_like_button") collapse to their PascalCase basename
+    # ("LikeButton"); shared keys are returned as-is.
+    def comparable_name_for(key)
+      return key unless key.include?("/")
+
+      basename = key.split("/").last.delete_prefix("_")
+      basename.split("_").map(&:capitalize).join
+    end
+
+    # Damerau-Levenshtein distance — like classic Levenshtein but treats
+    # an adjacent transposition (e.g. "ke"↔"ek") as a single edit. Component
+    # names are short (≤ 30 chars in practice) so the full O(m·n) DP table
+    # is fine; the readability win over the two-row Levenshtein trick is
+    # worth the extra ~30 cells of allocation in the failure path.
+    # rubocop:disable Metrics/AbcSize
+    def self.damerau_levenshtein_distance(left, right)
+      return right.length if left.empty?
+      return left.length if right.empty?
+
+      m = left.length
+      n = right.length
+      d = Array.new(m + 1) { Array.new(n + 1, 0) }
+      (0..m).each { |i| d[i][0] = i }
+      (0..n).each { |j| d[0][j] = j }
+
+      (1..m).each do |i|
+        (1..n).each do |j|
+          cost = left[i - 1] == right[j - 1] ? 0 : 1
+          d[i][j] = [
+            d[i - 1][j] + 1,        # deletion
+            d[i][j - 1] + 1,        # insertion
+            d[i - 1][j - 1] + cost  # substitution
+          ].min
+          if i > 1 && j > 1 && left[i - 1] == right[j - 2] && left[i - 2] == right[j - 1]
+            d[i][j] = [d[i][j], d[i - 2][j - 2] + cost].min
+          end
+        end
+      end
+
+      d[m][n]
+    end
+    # rubocop:enable Metrics/AbcSize
+    private_class_method :damerau_levenshtein_distance
+
     # Returns the manifest key to use for +name+ given an optional +controller_path+.
     # Co-located key format: "<controller_path>/_<underscored_name>" (e.g. "posts/_like_button").
     # Co-located takes precedence when both keys exist.
     def resolve_key(name, controller_path)
       return name unless controller_path
 
-      co_located = "#{controller_path}/_#{rsc_underscore(name)}"
+      co_located = "#{controller_path}/_#{pascal_to_snake_case(name)}"
       include?(co_located) ? co_located : name
     end
 
     # Converts PascalCase component names to snake_case without requiring ActiveSupport.
     # Equivalent to ActiveSupport::Inflector.underscore for PascalCase inputs.
-    def rsc_underscore(name)
+    def pascal_to_snake_case(name)
       name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
           .downcase
     end
 
     def data
-      @data ||= {}
+      @data || {}
     end
 
-    # Index by component name for fast lookup
+    # Index by component name. Today the manifest hash is already keyed by
+    # name, so this is a thin alias rather than a new index. Avoid lazy
+    # memoization here because the manifest is frozen after +load+ — any
+    # +@entries_by_name ||= ...+ assignment on a frozen instance would
+    # raise +FrozenError+.
     def entries_by_name
-      @entries_by_name ||= data
+      data
     end
 
     def by_module_id(id)

data/lib/ruact/configuration.rb

@@ -2,31 +2,272 @@
 
 module Ruact
   # Holds gem-wide configuration. Instantiated once via Ruact.config.
-  # Configure via Ruact.configure { |c| c.attr = value } in an initializer.
+  # Configure via `Ruact.configure { |c| c.attr = value }` in an initializer.
+  #
+  # Frozen after `Ruact.configure` returns (Story 7.3) — direct post-boot
+  # mutation (`Ruact.config.attr = value` outside the block) raises
+  # `Ruact::ConfigurationError` with the offending attribute, the caller's
+  # file:line, and the suggested fix. Re-calling `Ruact.configure` after boot
+  # replaces the configuration atomically and emits a `[ruact]` warning.
   class Configuration
-    # @return [String, nil] Path to react-client-manifest.json.
-    #   Defaults to Rails.root.join("public/react-client-manifest.json") when nil.
-    attr_accessor :manifest_path
-
-    # @return [Boolean] When true, objects without explicit rsc_props declaration
-    #   raise Ruact::SerializationError. Defaults to false in development, true in production.
-    attr_accessor :strict_serialization
-
-    # @return [Float] Seconds before a deferred Suspense chunk times out. Default: 5.0.
-    attr_accessor :suspense_timeout
-
-    # @return [String] Base URL of the Vite dev server. Default: "http://localhost:5173".
-    attr_accessor :vite_dev_server
-
-    def initialize
-      @manifest_path        = nil
-      @strict_serialization = begin
-        Rails.env.production?
-      rescue StandardError
-        false
+    # The set of public attributes; new attributes added here automatically
+    # inherit the freeze contract via the `define_method` writer below.
+    ATTRIBUTES = %i[
+      manifest_path
+      strict_serialization
+      suspense_timeout
+      vite_dev_server
+      current_user_resolver
+      dev_error_payload_enabled
+      max_upload_bytes
+      query_route_prefix
+      query_parent_controller
+    ].freeze
+
+    # @!attribute [r] manifest_path
+    #   @return [String, nil] Path to react-client-manifest.json.
+    #     Defaults to Rails.root.join("public/react-client-manifest.json") when nil.
+    #
+    # @!attribute [r] strict_serialization
+    #   @return [Boolean] When true, objects without explicit ruact_props declaration
+    #     raise Ruact::SerializationError. Defaults to false in development, true in production.
+    #
+    # @!attribute [r] suspense_timeout
+    #   @return [Float] Seconds before a deferred Suspense chunk times out. Default: 5.0.
+    #
+    # @!attribute [r] vite_dev_server
+    #   @return [String] Base URL of the Vite dev server. Default: "http://localhost:5173".
+    #
+    # @!attribute [r] current_user_resolver
+    #   @return [Proc, nil] Story 8.3 — Lambda invoked by the standalone
+    #     server-action dispatcher when a block reads `current_user`. Receives
+    #     `request.env` (Hash) and returns the authenticated user (or nil).
+    #     Memoized per-dispatch; left nil by default so apps that don't use
+    #     standalone actions never get a phantom `current_user` resolver.
+    #   @example Devise
+    #     Ruact.configure { |c| c.current_user_resolver = ->(env) { env['warden']&.user } }
+    #   @example Hand-rolled session
+    #     Ruact.configure { |c| c.current_user_resolver = ->(env) { User.find_by(id: env['rack.session'][:user_id]) } }
+    #
+    # @!attribute [r] dev_error_payload_enabled
+    #   @return [Boolean, nil] Story 8.4 — When true, server-action failures
+    #     respond with a verbose JSON payload (action name, error class,
+    #     message, split backtrace, contextual suggestion, validation errors).
+    #     When false, the wire body carries only the four baseline fields
+    #     (`_ruact_server_action_error`, `action_name`, `error_class`,
+    #     `message`) so React components can render their own UI without
+    #     accidental backtrace leakage. Default `nil` — the endpoint
+    #     controller resolves nil to `Rails.env.development? || Rails.env.test?`,
+    #     keeping the Configuration trivially constructible in non-Rails specs.
+    #   @example Force production-shape errors in development
+    #     Ruact.configure { |c| c.dev_error_payload_enabled = false }
+    #
+    # @!attribute [r] max_upload_bytes
+    #   @return [Integer, nil] Story 8.5 — upper bound (in bytes) on the
+    #     `Content-Length` of `multipart/form-data` and
+    #     `application/x-www-form-urlencoded` requests dispatched through
+    #     `POST /__ruact/fn/:name`. When the inbound `Content-Length` exceeds
+    #     this value, the endpoint controller raises
+    #     `Ruact::UploadTooLargeError` BEFORE Rack's multipart parser runs,
+    #     producing a 413 with the Story 8.4 structured error body.
+    #     Default: `10 * 1024 * 1024` (10 MB). Set to `nil` to disable the
+    #     gem-side guard — typical when a reverse proxy (`client_max_body_size`)
+    #     or host middleware already owns the operational cap. Chunked-transfer
+    #     requests (no `Content-Length` header) bypass the guard regardless of
+    #     this setting; the action body is responsible for any belt-and-suspenders
+    #     check via `params[:file].size` / `params[:file].byte_size` in that case.
+    #   @note This is a controller-level "fail fast at the boundary" knob, not
+    #     a stream-safety guarantee — Rack's multipart parser will still buffer
+    #     bodies up to its own limits before the guard rejects. For very large
+    #     uploads route through Active Storage Direct Upload or a presigned S3
+    #     URL; see `website/docs/api/server-actions.md` "File uploads" section.
+    #   @example Raise the limit to 25 MB
+    #     Ruact.configure { |c| c.max_upload_bytes = 25 * 1024 * 1024 }
+    #   @example Disable the gem-side guard (reverse proxy owns the cap)
+    #     Ruact.configure { |c| c.max_upload_bytes = nil }
+    #
+    # @!attribute [r] query_route_prefix
+    #   @return [String] Story 9.4 — URL prefix under which the `ruact_queries`
+    #     routing macro draws one named GET route per public query method
+    #     (default `"/q"` → `GET /q/<jsIdentifier>`). Must be a String starting
+    #     with `/` and without a trailing slash (the macro joins prefix and
+    #     identifier with `/`). Changing the prefix is configuration, never code.
+    #   @example Mount queries under /api/queries
+    #     Ruact.configure { |c| c.query_route_prefix = "/api/queries" }
+    #
+    # @!attribute [r] query_parent_controller
+    #   @return [String] Story 9.4 — class NAME of the controller the gem's
+    #     internal query dispatch controller inherits from (default
+    #     `"ApplicationController"` — the Devise `parent_controller` pattern).
+    #     Kept as a String and constantized lazily at route-draw time, NOT at
+    #     configure time: `ApplicationController` does not exist when the gem
+    #     loads. The host's REAL callback chain (`authenticate_user!`, tenant
+    #     scoping, Pundit) runs before any query class is instantiated (FR89).
+    #   @example Dispatch queries through an API base controller
+    #     Ruact.configure { |c| c.query_parent_controller = "Api::BaseController" }
+    ATTRIBUTES.each do |attr|
+      attr_reader attr
+
+      define_method("#{attr}=") do |value|
+        if frozen?
+          location = caller_locations(1, 1).first
+          raise Ruact::ConfigurationError, build_error_message(attr, location)
+        end
+        validate_attribute_value!(attr, value)
+        instance_variable_set("@#{attr}", value)
+      end
+    end
+
+    # Build a fresh Configuration. When +template+ is given, dup every public
+    # attribute from it so the draft is mutable — used by `Ruact.configure` for
+    # atomic-replacement cloning. The dup is required because the template is
+    # always a published (frozen) Configuration with deep-frozen attribute
+    # values, and AC1 requires the DSL inside the configure block to behave
+    # identically regardless of whether this is the first call or a later one
+    # (including idiomatic in-place mutation of inherited values).
+    #
+    # `dup` is safe for every supported attribute type: Strings produce an
+    # unfrozen copy; nil/true/false/Numerics/Symbols dup to themselves (they
+    # are inherently immutable, so the dup is a no-op).
+    #
+    # @param template [Ruact::Configuration, nil] optional source to clone from
+    def initialize(template: nil)
+      if template
+        ATTRIBUTES.each do |attr|
+          value = template.public_send(attr)
+          # Procs are immutable from the outside (Story 8.3 — current_user_resolver).
+          # Duping creates a different Proc instance, breaking identity comparisons
+          # across re-configurations. Procs are inherently re-entrant safe (no
+          # mutable internal state surface) so the dup is unnecessary; the freeze
+          # at seal! time is enough.
+          cloned = value.is_a?(Proc) ? value : value.dup
+          instance_variable_set("@#{attr}", cloned)
+        end
+      else
+        @manifest_path        = nil
+        @strict_serialization = begin
+          Rails.env.production?
+        rescue StandardError
+          false
+        end
+        @suspense_timeout     = 5.0
+        @vite_dev_server      = "http://localhost:5173"
+        @current_user_resolver = nil
+        @dev_error_payload_enabled = nil
+        @max_upload_bytes = 10 * 1024 * 1024
+        @query_route_prefix = "/q"
+        @query_parent_controller = "ApplicationController"
+      end
+    end
+
+    private
+
+    # Internal — called by `Ruact.configure` and `Ruact.config` (via
+    # `__send__(:seal!)`) immediately before publication. Deep-freezes every
+    # attribute value so the shallow `Object#freeze` on the Configuration
+    # cannot be bypassed by in-place mutation of an attribute value (e.g.
+    # `Ruact.config.manifest_path.replace`) after publication. Returns self
+    # (frozen).
+    #
+    # Values remain mutable inside the `Ruact.configure` block (AC1: the DSL
+    # inside the block is unchanged; the freeze happens after the block
+    # returns, not before). Only on `seal!` are values deep-frozen.
+    #
+    # Defined as `private` so it does not appear on the public API surface
+    # of `Ruact::Configuration` (AC1/AC7/AC9: public API surface unchanged).
+    # External callers reaching into `Ruact.config.seal!` get a NoMethodError.
+    #
+    # @api private
+    # @return [Ruact::Configuration] self, frozen
+    def seal!
+      ATTRIBUTES.each do |attr|
+        value = public_send(attr)
+        next if value.nil? || value.frozen?
+
+        # Story 8.3 review — Procs CAN be frozen (`.freeze` flips the frozen
+        # flag; no operational effect on `.call`). Freezing in place preserves
+        # object identity (vital for code that compares the resolver across
+        # re-configurations) AND keeps the deep-freeze contract honest —
+        # `Ruact.config.current_user_resolver.freeze` later would otherwise
+        # silently no-op an already-frozen reference, but a caller probing
+        # `frozen?` would see the right answer.
+        if value.is_a?(Proc)
+          value.freeze
+        else
+          instance_variable_set("@#{attr}", value.dup.freeze)
+        end
+      end
+      freeze
+    end
+
+    # Story 8.5 review patch — attribute-specific writer-time validation. The
+    # generic writer otherwise stores any value, which then surfaces as a
+    # generic 500 (`Integer <= String` etc.) on the FIRST in-flight request
+    # instead of a configuration-time error. Limit the surface to attributes
+    # whose runtime contract is narrower than "any value" — currently only
+    # `max_upload_bytes` (must be nil or a non-negative Integer). Other
+    # attributes keep their pre-existing "store any value" contract.
+    #
+    # Negative integers would otherwise turn into a global 413 — every
+    # request with a Content-Length above zero exceeds the configured limit.
+    # Booleans, Strings, Floats, Symbols turn into a non-comparable type
+    # error at request time. Both cases land here at boot/configure time
+    # with a legible message pointing at the offending value.
+    def validate_attribute_value!(attr, value)
+      case attr
+      when :max_upload_bytes        then validate_max_upload_bytes!(value)
+      when :query_route_prefix      then validate_query_route_prefix!(value)
+      when :query_parent_controller then validate_query_parent_controller!(value)
       end
-      @suspense_timeout     = 5.0
-      @vite_dev_server      = "http://localhost:5173"
+    end
+
+    def validate_max_upload_bytes!(value)
+      return if value.nil?
+      return if value.is_a?(Integer) && value >= 0
+
+      raise Ruact::ConfigurationError,
+            "Ruact::Configuration#max_upload_bytes must be nil or a non-negative Integer; " \
+            "got #{value.inspect} (#{value.class.name}). " \
+            "Set to nil to disable the gem-side guard, or pass a positive Integer (bytes)."
+    end
+
+    # Story 9.4 — the prefix is joined with the jsIdentifier as
+    # `"#{prefix}/#{js}"` at route-draw time, so a missing leading slash would
+    # draw a relative path and a trailing slash would draw `//`. Both are
+    # configuration-time errors, not first-request 500s.
+    def validate_query_route_prefix!(value)
+      unless value.is_a?(String) && value.start_with?("/")
+        raise Ruact::ConfigurationError,
+              "Ruact::Configuration#query_route_prefix must be a String starting with \"/\"; " \
+              "got #{value.inspect} (#{value.class.name})."
+      end
+      return unless value.length > 1 && value.end_with?("/")
+
+      raise Ruact::ConfigurationError,
+            "Ruact::Configuration#query_route_prefix must not end with \"/\" " \
+            "(the ruact_queries macro joins the prefix and the query identifier with \"/\"); " \
+            "got #{value.inspect}."
+    end
+
+    # Story 9.4 — kept as a String on purpose: the name is constantized lazily
+    # at route-draw time (`ApplicationController` does not exist when the gem
+    # loads or when the initializer runs).
+    def validate_query_parent_controller!(value)
+      return if value.is_a?(String) && !value.empty?
+
+      raise Ruact::ConfigurationError,
+            "Ruact::Configuration#query_parent_controller must be a non-empty String " \
+            "(the controller class NAME, constantized lazily at route-draw time); " \
+            "got #{value.inspect} (#{value.class.name})."
+    end
+
+    def build_error_message(attr, location)
+      <<~MSG.strip
+        ruact: cannot mutate Ruact::Configuration##{attr} after initialization.
+          Attempted at: #{location.path}:#{location.lineno}
+          Wrap the change in Ruact.configure { |c| c.#{attr} = ... } in config/initializers/ruact.rb and restart the process.
+          Why: Ruact::Configuration is frozen after initialization (Story 7.3) so that runtime config drift cannot cause environment-dependent behavior.
+      MSG
     end
   end
 end