react_on_rails_pro 17.0.1 → 17.1.0.rc.0

data/app/helpers/react_on_rails_pro_helper.rb

@@ -18,6 +18,7 @@
 # 2. Keep all #{some_var} fully to the left so that all indentation is done evenly in that var
 
 require "react_on_rails/helper"
+require "react_on_rails_pro/open_telemetry"
 require "async/promise"
 require "digest"
 require "json"
@@ -158,8 +159,13 @@ module ReactOnRailsProHelper
     # Extract streaming-specific callback
     on_complete = options.delete(:on_complete)
 
+    # Optional per-chunk error callback (set by cached_stream_react_component) that
+    # is notified of each chunk's `hasErrors` flag so an error-containing render is
+    # not written to the cache. See https://github.com/shakacode/react_on_rails/issues/4581.
+    on_chunk_errors = options.delete(:on_chunk_errors)
+
     consumer_stream_async(on_complete:) do
-      internal_stream_react_component(component_name, options)
+      internal_stream_react_component(component_name, options, on_chunk_errors:)
     end
   end
 
@@ -175,10 +181,11 @@ module ReactOnRailsProHelper
     end
 
     on_complete = options.delete(:on_complete)
+    on_chunk_errors = options.delete(:on_chunk_errors)
     collect_chunks = on_complete.respond_to?(:call)
     buffer = collect_chunks ? [] : +""
 
-    internal_stream_react_component(component_name, options).each_chunk do |chunk|
+    internal_stream_react_component(component_name, options, on_chunk_errors:).each_chunk do |chunk|
       buffer << chunk.to_s
     end
 
@@ -330,13 +337,12 @@ module ReactOnRailsProHelper
         prerender: true
       )
 
-      cached_result = fetch_react_component(component_name, cache_options) do
-        options = render_options.merge(
-          props: yield,
-          skip_prerender_cache: true
-        )
-        buffered_stream_react_component(component_name, options)
-      end
+      cached_result = render_cached_buffered_stream_react_component(
+        component_name,
+        cache_options,
+        render_options,
+        &block
+      )
       cached_result.html_safe
     end
   end
@@ -391,8 +397,11 @@ module ReactOnRailsProHelper
             "Include ReactOnRailsPro::AsyncRendering in your controller and call enable_async_react_rendering."
     end
 
+    parent_context = ReactOnRailsPro::OpenTelemetry.capture_context
     task = @react_on_rails_async_barrier.async do
-      react_component(component_name, options)
+      ReactOnRailsPro::OpenTelemetry.with_context(parent_context) do
+        react_component(component_name, options)
+      end
     end
 
     ReactOnRailsPro::AsyncValue.new(task:)
@@ -444,30 +453,64 @@ module ReactOnRailsProHelper
 
   private
 
-  def fetch_react_component(component_name, options)
+  def render_cached_buffered_stream_react_component(component_name, cache_options, render_options)
+    stream_has_errors = false
+    fetch_react_component(component_name, cache_options, cache_write_if: -> { !stream_has_errors }) do
+      options = render_options.merge(
+        props: yield,
+        skip_prerender_cache: true,
+        on_chunk_errors: ->(chunk_has_errors) { stream_has_errors ||= chunk_has_errors == true }
+      )
+      buffered_stream_react_component(component_name, options)
+    end
+  end
+
+  def fetch_react_component(component_name, options, cache_write_if: nil)
     return yield unless ReactOnRailsPro::Cache.use_cache?(options)
 
     cache_key = ReactOnRailsPro::Cache.react_component_cache_key(component_name, options)
     Rails.logger.debug { "React on Rails Pro cache_key is #{cache_key.inspect}" }
-    cache_options = ReactOnRailsPro::Cache.cache_write_options(options[:cache_options])
+    cache_write_options = ReactOnRailsPro::Cache.cache_write_options(options[:cache_options])
     if ReactOnRailsPro::Cache.cache_write_expired?(options[:cache_options])
       return add_component_cache_metadata(yield, cache_key, false)
     end
 
-    cache_hit = true
     normalized_cache_tags = []
-    result = Rails.cache.fetch(cache_key, cache_options) do
-      cache_hit = false
+    result, cache_hit, cache_write_skipped = fetch_cache_entry(
+      cache_key,
+      cache_write_options,
+      cache_write_if:
+    ) do
       normalized_cache_tags = ReactOnRailsPro::Cache.normalize_tags(options[:cache_tags])
       yield
     end
-    ReactOnRailsPro::Cache.register_normalized_tags(normalized_cache_tags, cache_key, cache_options) unless cache_hit
+    unless cache_hit || cache_write_skipped
+      ReactOnRailsPro::Cache.register_normalized_tags(normalized_cache_tags, cache_key, cache_write_options)
+    end
     load_pack_for_cached_react_component(component_name, options) if cache_hit
     result = normalize_cached_pro_attribution(result) if cache_hit
 
     add_component_cache_metadata(result, cache_key, cache_hit)
   end
 
+  def fetch_cache_entry(cache_key, cache_write_options, cache_write_if:)
+    cache_hit = true
+    cache_write_skipped = false
+    skip_cache_write = Object.new
+    result = catch(skip_cache_write) do
+      Rails.cache.fetch(cache_key, cache_write_options) do
+        cache_hit = false
+        rendered_result = yield
+        next rendered_result unless cache_write_if && !cache_write_if.call
+
+        cache_write_skipped = true
+        throw(skip_cache_write, rendered_result)
+      end
+    end
+
+    [result, cache_hit, cache_write_skipped]
+  end
+
   def normalize_cached_pro_attribution(result)
     return normalize_cached_pro_attribution_html(result) if result.is_a?(String)
 
@@ -599,21 +642,30 @@ module ReactOnRailsProHelper
   end
 
   def render_cached_static_rsc_component(component_name, cache_options, render_options, diagnostics_context, &block)
+    stream_has_errors = false
     fetch_static_rsc_component(
       component_name,
       cache_options,
       render_options,
       diagnostics_context[:cache],
-      diagnostics_enabled: static_rsc_render_diagnostics_enabled?(diagnostics_context[:config])
+      diagnostics_enabled: static_rsc_render_diagnostics_enabled?(diagnostics_context[:config]),
+      cache_write_if: -> { !stream_has_errors }
     ) do
-      static_rsc_component_cache_miss_html(component_name, render_options, diagnostics_context, &block)
+      static_rsc_component_cache_miss_html(
+        component_name,
+        render_options,
+        diagnostics_context,
+        on_chunk_errors: ->(chunk_has_errors) { stream_has_errors ||= chunk_has_errors == true },
+        &block
+      )
     end
   end
 
-  def static_rsc_component_cache_miss_html(component_name, render_options, diagnostics_context)
+  def static_rsc_component_cache_miss_html(component_name, render_options, diagnostics_context, on_chunk_errors:)
     options = render_options.merge(
       props: yield,
-      skip_prerender_cache: true
+      skip_prerender_cache: true,
+      on_chunk_errors:
     )
     strip_static_rsc_payload_scripts(
       buffered_stream_react_component(component_name, options),
@@ -627,6 +679,7 @@ module ReactOnRailsProHelper
     render_options,
     cache_diagnostics,
     diagnostics_enabled:,
+    cache_write_if:,
     &
   )
     cache_enabled = ReactOnRailsPro::Cache.use_cache?(cache_options)
@@ -652,6 +705,7 @@ module ReactOnRailsProHelper
       render_options,
       cache_diagnostics,
       cache_key,
+      cache_write_if:,
       &
     )
   end
@@ -661,18 +715,21 @@ module ReactOnRailsProHelper
     cache_options,
     render_options,
     cache_diagnostics,
-    cache_key
+    cache_key,
+    cache_write_if:
   )
     cache_write_options = ReactOnRailsPro::Cache.cache_write_options(cache_options[:cache_options])
-    cache_hit = true
     normalized_cache_tags = []
-    result = Rails.cache.fetch(cache_key, cache_write_options) do
-      cache_hit = false
+    result, cache_hit, cache_write_skipped = fetch_cache_entry(
+      cache_key,
+      cache_write_options,
+      cache_write_if:
+    ) do
       normalized_cache_tags = ReactOnRailsPro::Cache.normalize_tags(cache_options[:cache_tags])
       yield
     end
 
-    unless cache_hit
+    unless cache_hit || cache_write_skipped
       ReactOnRailsPro::Cache.register_normalized_tags(normalized_cache_tags, cache_key, cache_write_options)
     end
     load_pack_for_cached_react_component(component_name, render_options) if cache_hit
@@ -1112,14 +1169,17 @@ module ReactOnRailsProHelper
     initial_result = normalize_cached_pro_attribution(cached_chunks.first)
 
     # Enqueue remaining chunks asynchronously
+    parent_context = ReactOnRailsPro::OpenTelemetry.capture_context
     @async_barrier.async do |task|
-      task.yield
+      ReactOnRailsPro::OpenTelemetry.with_context(parent_context) do
+        task.yield
 
-      cached_chunks.each_with_index do |chunk, index|
-        next if index.zero?
-        break if response.stream.closed?
+        cached_chunks.each_with_index do |chunk, index|
+          next if index.zero?
+          break if response.stream.closed?
 
-        @main_output_queue.enqueue(normalize_cached_pro_attribution(chunk))
+          @main_output_queue.enqueue(normalize_cached_pro_attribution(chunk))
+        end
       end
     rescue Async::Queue::ClosedError
       # Queue closed due to error/disconnect in another component — stop enqueuing
@@ -1132,8 +1192,21 @@ module ReactOnRailsProHelper
   def handle_stream_cache_miss(component_name, raw_options, auto_load_bundle, view_cache_key, &)
     normalized_cache_tags = ReactOnRailsPro::Cache.normalize_tags(raw_options[:cache_tags])
     raw_cache_options = raw_options[:cache_options] || {}
+    # Shared between the per-chunk error callback and the on_complete cache write.
+    # Both run in the same async task/fiber, so by the time on_complete fires the
+    # stream is fully consumed and this flag reflects every chunk.
+    stream_has_errors = false
     cache_aware_options = raw_options.merge(
+      on_chunk_errors: ->(chunk_has_errors) { stream_has_errors ||= chunk_has_errors == true },
       on_complete: lambda { |chunks|
+        # Never persist a render that emitted an error chunk. With production
+        # defaults (`raise_non_shell_server_rendering_errors: false`), a stream
+        # whose shell succeeded but whose async boundary errored completes
+        # "normally", so without this guard the broken fragment would be cached
+        # and served to every subsequent visitor until the entry expires.
+        # See https://github.com/shakacode/react_on_rails/issues/4581.
+        next if stream_has_errors
+
         cache_write = ReactOnRailsPro::StreamCacheWrites.build(
           cache_key: view_cache_key,
           chunks:,
@@ -1220,8 +1293,11 @@ module ReactOnRailsProHelper
   def render_async_react_component_uncached(component_name, raw_options, &)
     options = prepare_async_render_options(raw_options, &)
 
+    parent_context = ReactOnRailsPro::OpenTelemetry.capture_context
     task = @react_on_rails_async_barrier.async do
-      react_component(component_name, options)
+      ReactOnRailsPro::OpenTelemetry.with_context(parent_context) do
+        react_component(component_name, options)
+      end
     end
 
     ReactOnRailsPro::AsyncValue.new(task:)
@@ -1238,14 +1314,17 @@ module ReactOnRailsProHelper
     normalized_cache_tags = ReactOnRailsPro::Cache.normalize_tags(raw_options[:cache_tags])
     options = prepare_async_render_options(raw_options, &)
 
+    parent_context = ReactOnRailsPro::OpenTelemetry.capture_context
     task = @react_on_rails_async_barrier.async do
-      result = react_component(component_name, options)
-      unless ReactOnRailsPro::Cache.cache_write_expired?(raw_cache_options)
-        cache_options = ReactOnRailsPro::Cache.cache_write_options(raw_cache_options)
-        Rails.cache.write(cache_key, result, cache_options)
-        ReactOnRailsPro::Cache.register_normalized_tags(normalized_cache_tags, cache_key, cache_options)
+      ReactOnRailsPro::OpenTelemetry.with_context(parent_context) do
+        result = react_component(component_name, options)
+        unless ReactOnRailsPro::Cache.cache_write_expired?(raw_cache_options)
+          cache_options = ReactOnRailsPro::Cache.cache_write_options(raw_cache_options)
+          Rails.cache.write(cache_key, result, cache_options)
+          ReactOnRailsPro::Cache.register_normalized_tags(normalized_cache_tags, cache_key, cache_options)
+        end
+        result
       end
-      result
     end
 
     ReactOnRailsPro::AsyncValue.new(task:)
@@ -1270,13 +1349,16 @@ module ReactOnRailsProHelper
     first_chunk_promise = Async::Promise.new
     all_chunks = [] if on_complete # Only collect if callback provided
     renderer_server_timing_collector = ReactOnRailsPro::Stream.renderer_server_timing_collector
+    parent_context = ReactOnRailsPro::OpenTelemetry.capture_context
 
     # Start an async task on the barrier to stream all chunks
     @async_barrier.async do
-      ReactOnRailsPro::Stream.with_renderer_server_timing_collector(renderer_server_timing_collector) do
-        stream = yield
-        fully_consumed = process_stream_chunks(stream, first_chunk_promise, all_chunks)
-        on_complete&.call(all_chunks) if fully_consumed
+      ReactOnRailsPro::OpenTelemetry.with_context(parent_context) do
+        ReactOnRailsPro::Stream.with_renderer_server_timing_collector(renderer_server_timing_collector) do
+          stream = yield
+          fully_consumed = process_stream_chunks(stream, first_chunk_promise, all_chunks)
+          on_complete&.call(all_chunks) if fully_consumed
+        end
       end
     rescue StandardError => e
       # Propagate the error to the calling fiber via the promise.
@@ -1332,13 +1414,14 @@ module ReactOnRailsProHelper
     true
   end
 
-  def internal_stream_react_component(component_name, options = {})
+  def internal_stream_react_component(component_name, options = {}, on_chunk_errors: nil)
     options = options.merge(render_mode: :html_streaming)
     result = internal_react_component(component_name, options)
     build_react_component_result_for_server_streamed_content(
       rendered_html_stream: result[:result],
       component_specification_tag: result[:tag],
-      render_options: result[:render_options]
+      render_options: result[:render_options],
+      on_chunk_errors:
     )
   end
 
@@ -1354,19 +1437,69 @@ module ReactOnRailsProHelper
       # persist an empty payload and every cache hit would serve zero bytes.
       # See https://github.com/shakacode/react_on_rails/issues/4550.
       html = chunk["html"] || ""
-      metadata = chunk.except("html").to_json
+      metadata = redact_rsc_payload_error_metadata(chunk.except("html")).to_json
       content_bytes = html.bytesize.to_s(16).rjust(8, "0")
       "#{metadata}\t#{content_bytes}\n#{html}".html_safe
     end
   end
 
+  # The fetched (client-navigation) RSC payload crosses the trusted-server -> untrusted-client
+  # boundary, so server-internal error text must not ride along on it.
+  #
+  # This mirrors the fail-closed allowlist in `createRSCDiagnosticScript`
+  # (packages/react-on-rails-pro/src/injectRSCPayload.ts), which redacts the same fields on the
+  # inline payload path: full detail only in development/test, and every other environment --
+  # production, staging, or anything unrecognized -- is redacted.
+  #
+  # Redacting here rather than in the shared producer (`buildRenderMetadata` in
+  # packages/react-on-rails/src/serverRenderUtils.ts) is deliberate. `server_rendered_react_component`
+  # installs a raise-transform that runs BEFORE this one and feeds `renderingError` to
+  # `raise_prerender_error`/`rendering_error_from_result`. Redacting upstream would silently strip
+  # the message and stack out of `PrerenderError` for apps that enable
+  # `raise_non_shell_server_rendering_errors`. This transform is the last hop before the bytes
+  # reach the browser, so the server keeps full detail and only the wire is redacted.
+  #
+  # Returns a new Hash; never mutates the caller's chunk (StreamCache buffers it -- see
+  # https://github.com/shakacode/react_on_rails/issues/4550).
+  def redact_rsc_payload_error_metadata(metadata)
+    return metadata if Rails.env.development? || Rails.env.test?
+
+    error_signal = rsc_payload_rendering_error_signal?(metadata)
+    return metadata unless error_signal || metadata.key?("renderingError")
+
+    # Match the inline path's production allowlist exactly. Error chunks may carry sensitive
+    # details in console replay or future metadata fields, so forwarding every field except the
+    # known renderingError key would fail open as the producer evolves.
+    { "hasErrors" => error_signal }
+  end
+
+  def rsc_payload_rendering_error_signal?(metadata)
+    return true if metadata["hasErrors"] == true
+
+    rendering_error = metadata["renderingError"]
+    return false unless rendering_error.is_a?(Hash)
+
+    non_blank_rsc_metadata_string?(rendering_error["message"]) ||
+      non_blank_rsc_metadata_string?(rendering_error["stack"])
+  end
+
+  def non_blank_rsc_metadata_string?(value)
+    value.is_a?(String) && value.strip.present?
+  end
+
   def build_react_component_result_for_server_streamed_content(
     rendered_html_stream:,
     component_specification_tag:,
-    render_options:
+    render_options:,
+    on_chunk_errors: nil
   )
     is_first_chunk = true
     rendered_html_stream.transform do |chunk_json_result|
+      # Surface the parsed `hasErrors` flag before the chunk is serialized to an
+      # HTML string. Downstream (the on_complete cache write) only sees strings,
+      # so this is the last point where the error flag is still available.
+      # See https://github.com/shakacode/react_on_rails/issues/4581.
+      on_chunk_errors&.call(chunk_json_result["hasErrors"])
       if is_first_chunk
         is_first_chunk = false
         build_react_component_result_for_server_rendered_string(

data/docs/adr/0001-boot-seed-rolling-deploy-bundles.md

@@ -1,15 +1,23 @@
-# Seed rolling-deploy bundles at renderer boot, not only at build
+# Seed rolling-deploy bundles at release time, not only at build
 
 **Status:** accepted
 
-When the production image is produced by **promoting the staging image**
-(`upstream: hichee-staging` in Control Plane), a build-time pre-seed cannot know
-production's live **draining bundle**: it runs in the staging pipeline against a
-staging snapshot, and promotion happens later and is sometimes skipped. We
-therefore have the **node-renderer container pull the target environment's
-actually-live bundle at boot** (`rake react_on_rails_pro:pre_seed_renderer_cache`,
-readiness-gated) as the correctness path, and keep the build-time seed as a
-fallback floor.
+When the production image is produced by **promoting a staging image** (for
+example, through a Control Plane `upstream:` configuration), a build-time
+pre-seed cannot know production's live **draining bundle**: it runs in the
+staging pipeline against a staging snapshot, and promotion happens later and is
+sometimes skipped. We
+therefore run the **Rails/Rake seed task**
+(`bundle exec rake react_on_rails_pro:pre_seed_renderer_cache`) in a
+Ruby-capable release, init, or startup step as the correctness path, and keep
+the build-time seed as a fallback floor. A combined Ruby+Node image can run it
+before Node. A Node-only renderer needs that step to use the promoted app
+artifact/config. The step and renderer must mount the same writable shared volume at
+`RENDERER_SERVER_BUNDLE_CACHE_PATH`, or copy/sync the completed cache into the
+renderer before it starts; gate renderer start/readiness on completion. Without
+a Ruby-capable step that makes the completed cache available to the renderer,
+the Rake seed cannot run for it; use multi-source fallback plus 410 recovery or
+a combined shape.
 
 ## Considered options
 
@@ -28,11 +36,14 @@ fallback floor.
 
 ## Consequences
 
-- Correctness of the boot seed **depends on deploy ordering (R2)**: the renderer
-  must boot before Rails, so the environment's live endpoint still advertises the
-  draining hash. If Rails cut over first, the boot seed would fetch the new hash
-  and miss the draining one.
-- Readiness gates on the boot seed **completing, not succeeding** — a failed seed
-  degrades to the 410 fallback rather than wedging the deploy.
-- Staging seeds production bundles, so staging's own rolling deploys cold-miss.
-  Accepted: staging SSR performance during deploys is not a goal.
+- Correctness of the boot seed **depends on deploy ordering (R2)**: its
+  Ruby-capable step must complete before renderer readiness and Rails cutover, so
+  the environment's live endpoint still advertises the draining hash. If Rails
+  cuts over first, the boot seed would fetch the new hash and miss the draining
+  one.
+- Renderer start/readiness gates on the boot seed **completing, not succeeding**
+  — a failed seed degrades to the 410 fallback rather than wedging the deploy.
+- The build-time fallback seeds from both staging and production, so the image
+  retains each environment's then-live bundle. That keeps staging's own rolling
+  deploys warm while still giving a promoted image a recent production bundle if
+  the boot seed cannot reach the live endpoint.

data/lib/react_on_rails_pro/assets_precompile.rb

@@ -112,31 +112,44 @@ module ReactOnRailsPro
 
       publish_bundles(adapter)
     rescue StandardError => e
-      # Outer rescue catches anything raised by the setup-side calls below
-      # (collect_assets, server_bundle_hash, rsc_bundle_js_file_path). Per the
-      # rolling-deploy contract, a failed upload must degrade the next deploy's
-      # seeding — not fail *this* deploy's assets:precompile.
+      # Role-scoped construction/publication failures are handled inside
+      # publish_artifact so the other role can still publish. Keep this outer
+      # fallback for failures before role isolation (for example, configuration
+      # access) so rolling-deploy publication never fails assets:precompile.
       warn "[ReactOnRailsPro] rolling_deploy_adapter publication failed: #{e.class}: #{e.message}. " \
            "Next deploy's rolling-deploy seeding may degrade; precompile continuing."
     end
 
     def self.publish_bundles(adapter)
-      pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
-      # Companion manifests are generated for the deploy as a whole, so server
-      # and RSC hashes from the same build intentionally share this asset set.
-      assets = filter_existing_assets(ReactOnRailsPro::RendererCacheHelpers.collect_assets.map(&:to_s))
-
-      # Defer the hash computation behind a block: `bundle_hash` reads the bundle
-      # file (`File.mtime` in dev/test, `Digest::MD5.file` for non-content-hashed
-      # names), so evaluating it eagerly as an argument would let a missing
-      # bundle raise and bypass the per-bundle warning path.
-      server_bundle = ReactOnRails::Utils.server_bundle_js_file_path
-      publish_bundle_if_present(adapter, server_bundle, assets, "server") { pool.server_bundle_hash }
-
-      return unless ReactOnRailsPro.configuration.enable_rsc_support
-
-      rsc_bundle = ReactOnRailsPro::Utils.rsc_bundle_js_file_path
-      publish_bundle_if_present(adapter, rsc_bundle, assets, "RSC") { pool.rsc_bundle_hash }
+      roles = [:server]
+      roles << :rsc if ReactOnRailsPro.configuration.enable_rsc_support
+      roles.each { |role| publish_artifact(adapter, role) }
+    end
+
+    def self.publish_artifact(adapter, role)
+      bundle_label = role == :rsc ? "RSC" : "server"
+      artifacts = ReactOnRailsPro::Utils.renderer_artifacts(
+        action_description: "publishing rolling-deploy #{bundle_label} artifact",
+        roles: [role]
+      )
+      artifact = artifacts.find { |candidate| candidate.role == role }
+      unless artifact
+        raise ReactOnRailsPro::Error,
+              "No current renderer artifact is configured for role #{role.inspect}"
+      end
+
+      artifact.with_materialized_files(bundle_name: "#{artifact.id}.js") do |bundle, companions|
+        publish_bundle_if_present(
+          adapter,
+          bundle.to_s,
+          companions.values.map(&:to_s),
+          bundle_label
+        ) { artifact.id }
+      end
+    rescue StandardError => e
+      warn "[ReactOnRailsPro] rolling_deploy_adapter publication failed: #{bundle_label} bundle: " \
+           "#{e.class}: #{e.message}. Next deploy's rolling-deploy seeding for this role may degrade; " \
+           "precompile continuing."
     end
 
     # Some collected companion assets may be absent or point at non-file paths.
@@ -230,6 +243,7 @@ module ReactOnRailsPro
     end
     private_class_method :publish_current_bundle_if_configured,
                          :publish_bundles,
+                         :publish_artifact,
                          :filter_existing_assets,
                          :warn_skipped_invalid_assets,
                          :warn_if_unavailable_required_rsc_assets,

data/lib/react_on_rails_pro/async_props_emitter.rb

@@ -50,16 +50,44 @@ module ReactOnRailsPro
   class AsyncPropsEmitter
     SANITIZED_REJECTION_REASON = "Async prop rejected by server"
 
+    # Socket-level errors that mean the renderer request stream is already gone.
+    # These mirror the family that ReactOnRailsPro::Stream#log_client_disconnect
+    # (concerns/stream.rb) treats as a routine client disconnect, so the two files
+    # classify disconnect races the same way.
+    CLOSED_REQUEST_STREAM_SOCKET_ERRORS = [
+      IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+    ].freeze
+
     attr_reader :pull_requests
 
     def initialize(bundle_timestamp, request_stream, pull_enabled: false)
       @bundle_timestamp = bundle_timestamp
       @request_stream = request_stream
       @pushed_props = Set.new
+      # Latched the first time a write hits a closed request stream, so the rest of
+      # the user's block (which runs in its own fiber and may keep emitting) is
+      # skipped silently instead of logging once per remaining prop.
+      @request_stream_closed = false
       @pull_enabled = pull_enabled
       @pull_requests = PullRequestQueue.new(@pushed_props) if pull_enabled
     end
 
+    # Exception classes that indicate a write landed on an already-closed request
+    # stream. `@request_stream` is a Protocol::HTTP::Body::Writable::Output; writing
+    # after its queue closes raises Protocol::HTTP::Body::Writable::Closed on a clean
+    # close, or the stored socket error (Errno::*/IOError) that tore the stream down
+    # on an aborted one (see async-http Output#passthrough -> Writable#write).
+    #
+    # Resolved at rescue time rather than at load time on purpose: the protocol-http
+    # writable-body class is required lazily (only once streaming starts) and its
+    # Closed constant has moved namespaces across gem versions, so the defined? guard
+    # keeps this file loadable everywhere and picks the class up once it exists.
+    def self.closed_request_stream_errors
+      return CLOSED_REQUEST_STREAM_SOCKET_ERRORS unless defined?(Protocol::HTTP::Body::Writable::Closed)
+
+      CLOSED_REQUEST_STREAM_SOCKET_ERRORS + [Protocol::HTTP::Body::Writable::Closed]
+    end
+
     # Sends an async prop to the Node renderer.
     # The prop value is JSON-serialized and sent as an NDJSON line.
     # On the Node side, this triggers asyncPropsManager.setProp(propName, value).
@@ -92,8 +120,29 @@ module ReactOnRailsPro
     private
 
     def write_settled_chunk(prop_name, action:)
+      # A closed request stream is routine (client disconnect, or the block still
+      # emitting after renderComplete winds the connection down). Once we have seen
+      # it close, skip the remaining writes entirely so a block emitting N more props
+      # does not generate N log lines or N wasted serializations.
+      return if @request_stream_closed
+
       chunk = yield
-      @request_stream << "#{chunk.to_json}\n"
+      serialized_chunk = "#{chunk.to_json}\n"
+
+      # Scope the closed-stream classification to the socket write itself. Building
+      # and serializing the chunk above (including a prop value's own #to_json) can
+      # raise IOError/Errno::* for reasons unrelated to a disconnect; letting those
+      # fall through to the genuine-failure path below keeps them at error level
+      # instead of latching the emitter shut and silently dropping later props.
+      begin
+        @request_stream << serialized_chunk
+      rescue *self.class.closed_request_stream_errors => e
+        # Routine disconnect race, not a genuine failure: keep it quiet, mirroring
+        # ReactOnRailsPro::Stream#log_client_disconnect. The prop is intentionally
+        # not marked pushed, matching the error path below.
+        return handle_closed_request_stream(prop_name, action, e)
+      end
+
       # Once the chunk is written, Ruby treats the prop as settled too.
       # That keeps duplicate pull requests filtered even if the JS manager is recreated.
       @pushed_props.add(prop_name)
@@ -108,6 +157,20 @@ module ReactOnRailsPro
       end
     end
 
+    # Handles a write to an already-closed request stream. Mirrors
+    # ReactOnRailsPro::Stream#log_client_disconnect: quiet (debug, no backtrace) and
+    # gated on logging_on_server. Latches @request_stream_closed so this logs at most
+    # once per stream and the block's remaining emits are skipped without noise.
+    def handle_closed_request_stream(prop_name, action, error)
+      @request_stream_closed = true
+      return unless ReactOnRails.configuration.logging_on_server
+
+      Rails.logger.debug do
+        "[ReactOnRailsPro::AsyncProps] Request stream closed while emitting async prop " \
+          "'#{prop_name}' (#{action}); skipping remaining props: #{error.class}"
+      end
+    end
+
     def generate_update_chunk(prop_name, value)
       {
         bundleTimestamp: @bundle_timestamp,

data/lib/react_on_rails_pro/cache.rb

@@ -189,7 +189,7 @@ module ReactOnRailsPro
 
       def rsc_bundle_cache_key
         ReactOnRailsPro::Utils.rsc_bundle_hash
-      rescue Errno::ENOENT
+      rescue ReactOnRailsPro::MissingRendererBundleError
         RSC_BUNDLE_MISSING_CACHE_KEY
       end
     end