react_on_rails_pro 17.0.1 → 17.1.0.rc.0

data/lib/react_on_rails_pro/request.rb

@@ -16,12 +16,16 @@
 require "digest"
 require "io/wait"
 require "uri"
+require_relative "open_telemetry"
 require_relative "renderer_http_client"
 require_relative "stream_request"
 require_relative "async_props_emitter"
 
 module ReactOnRailsPro
   class Request # rubocop:disable Metrics/ClassLength
+    RAW_RENDER_CONTENT_TYPE = "application/vnd.react-on-rails.render-request+javascript"
+    RAW_RENDER_HEADER_PREFIX = "x-react-on-rails-pro-"
+
     class UploadAssetsWaiter
       def initialize
         if Fiber.scheduler
@@ -86,13 +90,15 @@ module ReactOnRailsPro
         end
       end
 
-      def render_code(path, js_code, send_bundle)
+      def render_code(path, js_code, send_bundle, bundle_role: :server, artifacts: nil)
         Rails.logger.info { "[ReactOnRailsPro] Perform rendering request #{path}" }
-        form = form_with_code(js_code, send_bundle)
-        perform_request(path, form:)
+        artifacts = resolve_upload_artifacts(artifacts, action_description: "uploading requested assets") if send_bundle
+        request_path = send_bundle ? retarget_render_path(path, artifacts, bundle_role) : path
+        form = form_with_code(js_code, send_bundle, artifacts:)
+        perform_render_request(request_path, js_code, form:, send_bundle:)
       end
 
-      def render_code_as_stream(path, js_code, is_rsc_payload:, rsc_stream_observability: false)
+      def render_code_as_stream(path, js_code, is_rsc_payload:, rsc_stream_observability: false, artifacts: nil)
         Rails.logger.info { "[ReactOnRailsPro] Perform rendering request as a stream #{path}" }
         if is_rsc_payload && !ReactOnRailsPro.configuration.enable_rsc_support
           raise ReactOnRailsPro::Error,
@@ -102,18 +108,16 @@ module ReactOnRailsPro
         end
 
         warn_cb = ->(request_time) { warn_if_slow_streaming_first_chunk(path, request_time) }
+        bundle_role = is_rsc_payload ? :rsc : :server
         ReactOnRailsPro::StreamRequest.create(first_chunk_warn_callback: warn_cb) do |send_bundle, _tasks|
-          if send_bundle
-            Rails.logger.info { "[ReactOnRailsPro] Sending bundle to the node renderer" }
-            upload_assets
-          end
+          request_path, request_artifacts = prepare_streaming_request(path, send_bundle:, bundle_role:, artifacts:)
 
-          form = form_with_code(js_code, false, rsc_stream_observability:)
-          perform_request(path, form:, stream: true)
+          form = form_with_code(js_code, false, artifacts: request_artifacts, rsc_stream_observability:)
+          perform_render_request(request_path, js_code, form:, send_bundle: false, stream: true)
         end
       end
 
-      # Performs an incremental render request with bidirectional HTTP/2 streaming.
+      # Performs an incremental render request with bidirectional streaming.
       #
       # ARCHITECTURE: This method orchestrates the async props flow:
       #
@@ -130,13 +134,13 @@ module ReactOnRailsPro
       # │                                   │     └── Sends NDJSON: {updateChunk} │
       # │                                   │                                     │
       # │  ... streaming HTML chunks ...    │  4. Block completes                 │
-      # │                                   │     output.close (sends END_STREAM) │
+      # │                                   │     output.close (request EOF)      │
       # └───────────────────────────────────┴─────────────────────────────────────┘
       #
       # WHY async task?
       # - We need to return the response stream immediately so Rails can start sending HTML
       # - The async_props_block runs concurrently, sending props as they become available
-      # - When the block finishes, we close the output (END_STREAM flag)
+      # - When the block finishes, we close the request body
       # - Node's handleRequestClosed then calls asyncPropsManager.endStream()
       #
       def render_code_with_incremental_updates(
@@ -145,51 +149,52 @@ module ReactOnRailsPro
         async_props_block:,
         pull_enabled: false,
         push_props: nil,
-        rsc_stream_observability: false
+        is_rsc_payload: false,
+        rsc_stream_observability: false,
+        artifacts: nil
       )
         Rails.logger.info { "[ReactOnRailsPro] Perform incremental rendering request #{path}" }
 
-        pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
         if !push_props.nil? && !pull_enabled
           raise ArgumentError, "push_props can only be provided when pull_enabled is true"
         end
 
         warn_cb = ->(request_time) { warn_if_slow_streaming_first_chunk(path, request_time) }
+        bundle_role = is_rsc_payload ? :rsc : :server
         ReactOnRailsPro::StreamRequest.create(
           first_chunk_warn_callback: warn_cb,
           pull_enabled:
         ) do |send_bundle, tasks|
-          if send_bundle
-            Rails.logger.info { "[ReactOnRailsPro] Sending bundle to the node renderer" }
-            upload_assets
-          end
+          request_path, request_artifacts = prepare_streaming_request(path, send_bundle:, bundle_role:, artifacts:)
 
-          # Open a bidirectional HTTP/2 stream using async-http's Writable body.
-          # output supports << (alias for write) and close (sends END_STREAM).
+          # Open a bidirectional request using async-http's Writable body.
+          # output supports << (alias for write) and close (signals request EOF).
           output, response = connection.post_bidi(
-            path,
+            request_path,
             headers: [["content-type", "application/x-ndjson"]]
           )
 
-          emitter = ReactOnRailsPro::AsyncPropsEmitter.new(
-            pool.rsc_bundle_hash,
+          emitter = build_incremental_emitter(request_artifacts, output, pull_enabled:)
+          write_initial_incremental_request(
             output,
-            pull_enabled:
-          )
-          initial_data = build_initial_incremental_request(
-            js_code, emitter, pull_enabled:, push_props:, rsc_stream_observability:
+            js_code,
+            emitter,
+            artifacts: request_artifacts,
+            pull_enabled:,
+            push_props:,
+            rsc_stream_observability:
           )
 
-          # Send the initial render request as first NDJSON line
-          output << "#{initial_data.to_json}\n"
-
           # Execute async props block in a separate fiber.
           # This runs concurrently with the response streaming back to the client.
+          parent_context = ReactOnRailsPro::OpenTelemetry.capture_context
           tasks.push(Async::Task.current.async do
-            async_props_block.call(emitter)
+            ReactOnRailsPro::OpenTelemetry.with_context(parent_context) do
+              async_props_block.call(emitter)
+            end
           ensure
             # When the block completes (or raises), close the output.
-            # This sends HTTP/2 END_STREAM flag, triggering Node's handleRequestClosed.
+            # This signals request-body EOF, triggering Node's handleRequestClosed.
             output.close
           end)
 
@@ -197,35 +202,16 @@ module ReactOnRailsPro
         end
       end
 
-      def upload_assets
+      def upload_assets(artifacts: nil)
         Rails.logger.info { "[ReactOnRailsPro] Uploading assets" }
-
-        # Early checks with descriptive messages. add_bundle_to_form(check_bundle: true) also
-        # validates existence, but these provide clearer context for the rake task user.
-        server_bundle_path = ReactOnRails::Utils.server_bundle_js_file_path
-        unless File.exist?(server_bundle_path)
-          raise ReactOnRailsPro::Error, "Server bundle not found at #{server_bundle_path}. " \
-                                        "Please build your bundles before uploading assets."
-        end
-
-        # Create a list of bundle timestamps to send to the node renderer
-        pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
-        target_bundles = [pool.server_bundle_hash]
-
-        # Add RSC bundle if enabled
-        if ReactOnRailsPro.configuration.enable_rsc_support
-          rsc_bundle_path = ReactOnRailsPro::Utils.rsc_bundle_js_file_path
-          unless File.exist?(rsc_bundle_path)
-            raise ReactOnRailsPro::Error, "RSC bundle not found at #{rsc_bundle_path}. " \
-                                          "Please build your bundles before uploading assets."
-          end
-          target_bundles << pool.rsc_bundle_hash
-        end
-
-        assets_to_copy = assets_to_copy_for_upload
-
-        with_asset_upload_single_flight(upload_assets_single_flight_key(target_bundles, assets_to_copy)) do
-          form = form_with_assets_and_bundle(assets_to_copy:)
+        artifacts = resolve_upload_artifacts(artifacts, action_description: "uploading assets")
+        target_bundles = artifacts.map(&:id)
+
+        # Artifact IDs already bind every bundle and companion byte. Keying the
+        # single-flight upload by those IDs avoids re-reading live paths after
+        # the operation-scoped snapshot was constructed.
+        with_asset_upload_single_flight(upload_assets_single_flight_key(target_bundles, [])) do
+          form = form_with_assets_and_bundle(artifacts:)
           # TODO: targetBundles is only kept for backward compatibility with older node renderers
           # (protocol 2.0.0) that require it. The new node renderer derives target directories from
           # the bundle_<hash> form keys and ignores this field. Remove at the next breaking version.
@@ -251,7 +237,8 @@ module ReactOnRailsPro
 
         form_data["targetBundles"] = target_bundles
 
-        response = perform_request("/asset-exists?filename=#{filename}", json: form_data)
+        encoded_filename = URI.encode_www_form_component(filename)
+        response = perform_request("/asset-exists?filename=#{encoded_filename}", json: form_data)
         JSON.parse(response.body)["exists"] == true
       end
 
@@ -288,7 +275,9 @@ module ReactOnRailsPro
       def retry_or_raise_transport_error(error, available_retries, path, error_type)
         if available_retries.zero?
           raise ReactOnRailsPro::Error,
-                "#{error_type} error on renderer request: #{path}.\nOriginal error:\n#{error}\n#{error.backtrace}"
+                "#{error_type} error on renderer request: #{path}.\n" \
+                "#{ReactOnRailsPro::RendererHttpClient.transport_config_description}\n" \
+                "Original error:\n#{error}\n#{error.backtrace}"
         end
         Rails.logger.info do
           "[ReactOnRailsPro] #{error_type} error when making a request to the Node Renderer. " \
@@ -331,103 +320,163 @@ module ReactOnRailsPro
                           "expected at most #{warn_timeout}."
       end
 
-      def form_with_code(js_code, send_bundle, rsc_stream_observability: false)
-        form = common_form_data
+      def form_with_code(js_code, send_bundle, artifacts: nil, rsc_stream_observability: false)
+        artifacts ||= if send_bundle
+                        ReactOnRailsPro::Utils.renderer_artifacts(action_description: "uploading requested assets")
+                      end
+        form = common_form_data(artifacts:)
         form["renderingRequest"] = js_code
         form["rscStreamObservability"] = true if rsc_stream_observability
-        populate_form_with_bundle_and_assets(form, check_bundle: false) if send_bundle
+        populate_form_with_bundle_and_assets(form, check_bundle: false, artifacts:) if send_bundle
         form
       end
 
-      def populate_form_with_bundle_and_assets(form, check_bundle:, assets_to_copy: assets_to_copy_for_upload)
-        pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
+      def perform_render_request(path, js_code, form:, send_bundle:, stream: false)
+        if send_bundle
+          perform_request(path, form:, stream:)
+        else
+          perform_request(path, raw: raw_render_request(js_code, form), stream:)
+        end
+      end
 
-        add_bundle_to_form(
-          form,
-          bundle_path: ReactOnRails::Utils.server_bundle_js_file_path,
-          bundle_file_name: pool.renderer_bundle_file_name,
-          bundle_hash: pool.server_bundle_hash,
-          check_bundle:
-        )
+      # The field list here must stay in sync with common_form_data / form_with_code and
+      # the Node renderer's normalizeRawRenderRequest (node renderer's worker.ts); an
+      # unmapped field raises ArgumentError below. Every value is sanitized because these
+      # body fields become raw HTTP header values.
+      def raw_render_request(js_code, form)
+        metadata = form.except("renderingRequest")
+        headers = [
+          ["content-type", RAW_RENDER_CONTENT_TYPE],
+          ["#{RAW_RENDER_HEADER_PREFIX}protocol-version",
+           sanitize_raw_render_header(metadata.delete("protocolVersion"))],
+          ["#{RAW_RENDER_HEADER_PREFIX}gem-version", sanitize_raw_render_header(metadata.delete("gemVersion"))],
+          ["#{RAW_RENDER_HEADER_PREFIX}rails-env", sanitize_raw_render_header(metadata.delete("railsEnv"))],
+          [
+            "#{RAW_RENDER_HEADER_PREFIX}dependency-bundle-timestamps",
+            sanitize_raw_render_header(JSON.generate(Array(metadata.delete("dependencyBundleTimestamps"))))
+          ]
+        ]
+        password = metadata.delete("password")
+        headers << ["authorization", "Bearer #{sanitize_raw_render_header(password)}"] if password
+        if metadata.key?("rscStreamObservability")
+          observability = sanitize_raw_render_header(metadata.delete("rscStreamObservability"))
+          headers << ["#{RAW_RENDER_HEADER_PREFIX}rsc-stream-observability", observability]
+        end
+        raise ArgumentError, "Unsupported raw render metadata: #{metadata.keys.join(', ')}" unless metadata.empty?
+
+        { headers:, body: js_code }
+      end
 
-        if ReactOnRailsPro.configuration.enable_rsc_support
+      def sanitize_raw_render_header(value)
+        value.to_s.tap do |header_value|
+          raise ArgumentError, "Renderer metadata headers cannot contain newlines" if header_value.match?(/[\r\n]/)
+        end
+      end
+
+      def populate_form_with_bundle_and_assets(form, check_bundle:, artifacts: nil, assets_to_copy: nil)
+        artifacts ||= ReactOnRailsPro::Utils.renderer_artifacts(action_description: "building renderer upload")
+        artifacts.each do |artifact|
           add_bundle_to_form(
             form,
-            bundle_path: ReactOnRailsPro::Utils.rsc_bundle_js_file_path,
-            bundle_file_name: pool.rsc_renderer_bundle_file_name,
-            bundle_hash: pool.rsc_bundle_hash,
-            check_bundle:
+            bundle_path: artifact.bundle,
+            bundle_file_name: "#{artifact.id}.js",
+            bundle_hash: artifact.id,
+            check_bundle:,
+            bundle_body: artifact.bundle_body
           )
         end
 
-        add_assets_to_form(form, assets_to_copy:)
+        if assets_to_copy
+          add_assets_to_form(form, assets_to_copy:)
+        else
+          artifact = artifacts.fetch(0)
+          add_assets_to_form(
+            form,
+            assets_to_copy: artifact.companions,
+            snapshot_bodies: artifact.companion_bodies
+          )
+        end
       end
 
-      def add_bundle_to_form(form, bundle_path:, bundle_file_name:, bundle_hash:, check_bundle:)
-        raise ReactOnRailsPro::Error, "Bundle not found #{bundle_path}" if check_bundle && !File.exist?(bundle_path)
+      def add_bundle_to_form(form, bundle_path:, bundle_file_name:, bundle_hash:, check_bundle:, bundle_body: nil)
+        if check_bundle && bundle_body.nil? && !File.exist?(bundle_path)
+          raise ReactOnRailsPro::Error, "Bundle not found #{bundle_path}"
+        end
 
         form["bundle_#{bundle_hash}"] = {
-          body: get_form_body_for_file(bundle_path),
+          body: bundle_body || get_form_body_for_file(bundle_path),
           content_type: "text/javascript",
           filename: bundle_file_name
         }
       end
 
       def assets_to_copy_for_upload
-        assets_to_copy = (ReactOnRailsPro.configuration.assets_to_copy || []).dup
-        # react_client_manifest and react_server_manifest files are needed to generate react server components payload
-        if ReactOnRailsPro.configuration.enable_rsc_support
-          assets_to_copy << ReactOnRailsPro::Utils.react_client_manifest_file_path
-          assets_to_copy << ReactOnRailsPro::Utils.react_server_client_manifest_file_path
-        end
-
-        assets_to_copy
+        ReactOnRailsPro::Utils
+          .renderer_artifacts(action_description: "collecting renderer upload assets")
+          .fetch(0).companions.values
       end
 
-      def add_assets_to_form(form, assets_to_copy:)
+      def add_assets_to_form(form, assets_to_copy:, snapshot_bodies: nil)
         return form unless assets_to_copy.present?
 
-        assets_to_copy.each_with_index do |asset_path, idx|
-          Rails.logger.info { "[ReactOnRailsPro] Uploading asset #{asset_path}" }
-          unless http_url?(asset_path) || File.exist?(asset_path)
-            warn "Asset not found #{asset_path}"
-            next
-          end
+        assets = assets_to_copy.respond_to?(:each_pair) ? assets_to_copy.to_a : Array(assets_to_copy)
+        assets.each_with_index do |asset, idx|
+          add_asset_to_form(form, asset, idx, snapshot_bodies)
+        end
 
-          content_type = ReactOnRailsPro::Utils.mine_type_from_file_name(asset_path)
+        form
+      end
 
-          begin
-            form["assetsToCopy#{idx}"] = {
-              body: get_form_body_for_file(asset_path),
-              content_type:,
-              filename: File.basename(asset_path)
-            }
-          rescue StandardError => e
-            warn "[ReactOnRailsPro] Error uploading asset #{asset_path}: #{e}"
-          end
+      def add_asset_to_form(form, asset, index, snapshot_bodies)
+        basename, asset_path = asset.is_a?(Array) ? asset : [File.basename(asset.to_s), asset]
+        Rails.logger.info { "[ReactOnRailsPro] Uploading asset #{asset_path}" }
+        snapshot_body = snapshot_bodies&.fetch(basename, nil)
+        unless uploadable_asset?(asset_path, snapshot_body)
+          warn "Asset not found #{asset_path}"
+          return
         end
 
-        form
+        form["assetsToCopy#{index}"] = {
+          body: asset_upload_body(asset_path, snapshot_body),
+          content_type: ReactOnRailsPro::Utils.mine_type_from_file_name(basename),
+          filename: basename
+        }
+      rescue StandardError => e
+        warn "[ReactOnRailsPro] Error uploading asset #{asset_path}: #{e}"
+      end
+
+      def uploadable_asset?(asset_path, snapshot_body)
+        snapshot_body || asset_path.is_a?(RendererArtifact::InlineCompanion) ||
+          http_url?(asset_path) || File.exist?(asset_path)
       end
 
-      def form_with_assets_and_bundle(assets_to_copy: assets_to_copy_for_upload)
-        form = common_form_data
-        populate_form_with_bundle_and_assets(form, check_bundle: true, assets_to_copy:)
+      def asset_upload_body(asset_path, snapshot_body)
+        return snapshot_body if snapshot_body
+        return asset_path.body if asset_path.is_a?(RendererArtifact::InlineCompanion)
+
+        get_form_body_for_file(asset_path)
+      end
+
+      def form_with_assets_and_bundle(artifacts: nil, assets_to_copy: nil)
+        artifacts ||= ReactOnRailsPro::Utils.renderer_artifacts(action_description: "building renderer upload")
+        form = common_form_data(artifacts:)
+        populate_form_with_bundle_and_assets(form, check_bundle: true, artifacts:, assets_to_copy:)
         form
       end
 
-      def common_form_data
-        ReactOnRailsPro::Utils.common_form_data
+      def common_form_data(artifacts: nil)
+        ReactOnRailsPro::Utils.common_form_data(artifacts:)
       end
 
       def build_initial_incremental_request(
         js_code,
         emitter,
+        artifacts: nil,
         pull_enabled: false,
         push_props: nil,
         rsc_stream_observability: false
       )
-        data = common_form_data.merge(
+        data = common_form_data(artifacts:).merge(
           renderingRequest: js_code,
           onRequestClosedUpdateChunk: emitter.end_stream_chunk
         )
@@ -439,6 +488,82 @@ module ReactOnRailsPro
         data
       end
 
+      def build_incremental_emitter(artifacts, output, pull_enabled:)
+        rsc_artifact = artifact_for_role(artifacts, :rsc)
+        pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
+        ReactOnRailsPro::AsyncPropsEmitter.new(
+          rsc_artifact&.id || pool.rsc_bundle_hash,
+          output,
+          pull_enabled:
+        )
+      end
+
+      def write_initial_incremental_request(output, js_code, emitter, **)
+        initial_data = build_initial_incremental_request(js_code, emitter, **)
+        output << "#{initial_data.to_json}\n"
+      end
+
+      def retarget_render_path(path, artifacts, role)
+        match = path.match(%r{\A/bundles/[^/]+/(?<endpoint>render|incremental-render)/})
+        return path unless match
+
+        artifact = artifact_for_role(artifacts, role)
+        unless artifact
+          raise ReactOnRailsPro::Error,
+                "No renderer artifact is configured for role #{role.inspect} while retrying #{match[:endpoint]}"
+        end
+
+        path.sub(%r{\A/bundles/[^/]+/}, "/bundles/#{artifact.id}/")
+      end
+
+      def prepare_streaming_request(path, send_bundle:, bundle_role:, artifacts: nil)
+        return [path, artifacts] unless send_bundle
+
+        Rails.logger.info { "[ReactOnRailsPro] Sending bundle to the node renderer" }
+        artifacts = resolve_upload_artifacts(artifacts, action_description: "uploading requested assets")
+        request_path = retarget_render_path(path, artifacts, bundle_role)
+        upload_assets(artifacts:)
+        [request_path, artifacts]
+      end
+
+      def resolve_upload_artifacts(artifacts, action_description:)
+        return ReactOnRailsPro::Utils.renderer_artifacts(action_description:) unless artifacts
+
+        artifacts = Array(artifacts)
+        expected_ids = expected_artifact_ids(artifacts)
+        return artifacts unless expected_ids
+
+        current_artifacts = ReactOnRailsPro::Utils.renderer_artifacts(
+          action_description:,
+          roles: expected_ids.keys
+        )
+        current_ids = current_artifacts.to_h { |artifact| [artifact.role, artifact.id] }
+        return current_artifacts if current_ids == expected_ids && current_artifacts.length == expected_ids.length
+
+        raise ReactOnRailsPro::Error,
+              "Renderer artifacts changed after this render request was prepared; refusing to upload different bytes"
+      end
+
+      def expected_artifact_ids(artifacts)
+        identities = artifacts.select { |artifact| artifact.is_a?(RendererArtifact::Identity) }
+        return nil if identities.empty?
+
+        unless identities.length == artifacts.length
+          raise ReactOnRailsPro::Error, "Renderer artifact snapshots cannot mix identities and captured bodies"
+        end
+
+        ids_by_role = identities.to_h { |identity| [identity.role, identity.id] }
+        if ids_by_role.length != identities.length
+          raise ReactOnRailsPro::Error, "Renderer artifact snapshot contains duplicate roles"
+        end
+
+        ids_by_role
+      end
+
+      def artifact_for_role(artifacts, role)
+        Array(artifacts).find { |artifact| artifact.role == role }
+      end
+
       def upload_assets_single_flight_key(target_bundles, assets_to_copy)
         [
           "bundles",
@@ -451,6 +576,10 @@ module ReactOnRailsPro
       end
 
       def upload_asset_fingerprint(asset_path)
+        if asset_path.is_a?(RendererArtifact::InlineCompanion)
+          return "inline:#{asset_path.url}:#{Digest::SHA256.hexdigest(asset_path.body)}"
+        end
+
         path = asset_path.to_s
         return "url:#{path}" if http_url?(path)
         return "missing:#{path}" unless File.exist?(path)
@@ -543,7 +672,7 @@ module ReactOnRailsPro
 
       def create_connection
         url = ReactOnRailsPro.configuration.renderer_url
-        Rails.logger.info do
+        Rails.logger.debug do
           "[ReactOnRailsPro] Setting up Node Renderer connection to #{url}"
         end
 
@@ -551,7 +680,8 @@ module ReactOnRailsPro
           origin: url,
           pool_size: ReactOnRailsPro.configuration.renderer_http_pool_size,
           connect_timeout: ReactOnRailsPro.configuration.renderer_http_pool_timeout,
-          read_timeout: ReactOnRailsPro.configuration.ssr_timeout
+          read_timeout: ReactOnRailsPro.configuration.ssr_timeout,
+          force_http2: ReactOnRailsPro.configuration.renderer_http_force_http2
         )
       rescue StandardError => e
         message = <<~MSG
@@ -560,6 +690,7 @@ module ReactOnRailsPro
           renderer_http_pool_timeout = #{ReactOnRailsPro.configuration.renderer_http_pool_timeout}
           renderer_http_pool_warn_timeout = #{ReactOnRailsPro.configuration.renderer_http_pool_warn_timeout}
           renderer_http_keep_alive_timeout = #{ReactOnRailsPro.configuration.renderer_http_keep_alive_timeout}
+          renderer_http_force_http2 = #{ReactOnRailsPro.configuration.renderer_http_force_http2}
           renderer_url = #{url}
           Be sure to use a url that contains the protocol of http or https.
           Original error is

data/lib/react_on_rails_pro/rolling_deploy/tarball.rb

@@ -20,6 +20,7 @@ require "tempfile"
 require "zlib"
 
 require "react_on_rails_pro/error"
+require "react_on_rails_pro/renderer_artifact"
 
 module ReactOnRailsPro
   module RollingDeploy
@@ -51,17 +52,23 @@ module ReactOnRailsPro
       # file doesn't blow heap before the running total trips the size cap.
       EXTRACT_CHUNK_SIZE = 64 * 1024
 
-      # Path-safety regex for tar entries. We require entries to be flat
-      # basenames (no slashes, no `..`, no NUL bytes, no leading dot, no
-      # leading hyphen) so an attacker can never write outside the target
-      # directory or hide files from `ls`. The `./` prefix permitted by tar
-      # is normalised away before this match runs.
-      #
-      # Functionally identical to `ReactOnRailsPro::RollingDeploy::SAFE_HASH_PATTERN`
-      # — kept as a separate constant because tarball entry names and
-      # rolling-deploy hash strings are conceptually distinct: a future
-      # protocol change might tighten one without the other.
-      ENTRY_NAME_PATTERN = /\A[A-Za-z0-9_][A-Za-z0-9_.\-]*\z/
+      # Path-safety regex for tar entries. Reuse RendererArtifact's companion
+      # contract while keeping the transport-specific TarWriter byte limit at
+      # this boundary. The shared pattern rejects
+      # slash, backslash, colon, NUL/ASCII controls, and the special `.` / `..`
+      # directory entries while permitting ordinary filename characters such
+      # as spaces, `@`, `%`, Unicode, and leading dots or hyphens. The `./`
+      # prefix permitted by tar is normalised away before this match runs.
+      # RubyGems TarWriter stores a flat name in a 100-byte header field.
+      ENTRY_NAME_PATTERN = ReactOnRailsPro::RendererArtifact::SAFE_COMPANION_NAME_PATTERN
+      ENTRY_NAME_MAX_BYTES = 100
+
+      def safe_entry_name?(value)
+        name = value.to_s.dup.force_encoding(Encoding::UTF_8)
+        name.valid_encoding? &&
+          name.bytesize <= ENTRY_NAME_MAX_BYTES &&
+          ReactOnRailsPro::RendererArtifact.safe_companion_name?(name)
+      end
 
       # Compose a gzipped tarball from the given entries and yield the
       # resulting Tempfile. The temp file is removed when the block returns.
@@ -158,10 +165,23 @@ module ReactOnRailsPro
 
       def validate_compose_entries!(entries)
         entries.each do |name, path|
-          unless ENTRY_NAME_PATTERN.match?(name.to_s)
+          raw_name = name.to_s
+          utf8_name = raw_name.dup.force_encoding(Encoding::UTF_8)
+          unless utf8_name.valid_encoding?
+            raise ReactOnRailsPro::Error,
+                  "Tarball entry name #{raw_name.inspect} is not valid UTF-8."
+          end
+          if utf8_name.bytesize > ENTRY_NAME_MAX_BYTES
+            raise ReactOnRailsPro::Error,
+                  "Tarball entry name #{raw_name.inspect} exceeds the maximum of " \
+                  "#{ENTRY_NAME_MAX_BYTES} UTF-8 bytes."
+          end
+
+          unless safe_entry_name?(utf8_name)
             raise ReactOnRailsPro::Error,
                   "Tarball entry name #{name.inspect} is not a safe basename. " \
-                  "Allowed: flat alphanumeric basenames (no slashes, no leading dot)."
+                  "Allowed: flat basenames up to #{ENTRY_NAME_MAX_BYTES} UTF-8 bytes without slashes, " \
+                  "backslashes, colons, or control characters."
           end
 
           raise ReactOnRailsPro::Error, "Tarball source path for #{name.inspect} is blank" if path.to_s.empty?
@@ -192,14 +212,24 @@ module ReactOnRailsPro
       def safe_entry_name!(entry)
         # `TarReader` exposes the entry name verbatim; tar archives commonly
         # prefix entries with `./`. Strip that prefix before the pattern check
-        # so a legitimate `./bundle.js` doesn't get rejected, but anything more
-        # exotic (subdir, leading-dot hidden name, traversal) still fails.
+        # so a legitimate `./bundle.js` doesn't get rejected. The shared flat-
+        # basename contract still rejects subdirectories and traversal names.
         raw = entry.full_name.to_s
-        name = raw.delete_prefix("./")
-        unless ENTRY_NAME_PATTERN.match?(name)
+        # Ruby 3.3 tags tar header bytes as ASCII-8BIT even when they contain a
+        # valid UTF-8 filename. The wire contract uses UTF-8 names: retag valid
+        # bytes before matching/writing, and reject malformed input instead of
+        # passing ambiguous bytes to the filesystem.
+        name = raw.dup.force_encoding(Encoding::UTF_8)
+        unless name.valid_encoding?
+          raise ReactOnRailsPro::Error,
+                "Rolling-deploy tarball entry name #{raw.inspect} is not valid UTF-8."
+        end
+        name = name.delete_prefix("./")
+        unless safe_entry_name?(name)
           raise ReactOnRailsPro::Error,
                 "Rolling-deploy tarball entry name #{raw.inspect} is not a safe basename. " \
-                "Allowed: flat alphanumeric basenames (no slashes, no leading dot, no `..`)."
+                "Allowed: flat basenames up to #{ENTRY_NAME_MAX_BYTES} UTF-8 bytes without slashes, " \
+                "backslashes, colons, control characters, or `.` / `..`."
         end
         name
       end