react_on_rails_pro 16.6.0 → 16.7.0.rc.0

data/lib/react_on_rails_pro/renderer_cache_helpers.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "securerandom"
+require "pathname"
+require "set"
+
+require "react_on_rails_pro/error"
+
+module ReactOnRailsPro
+  # Shared helpers for staging the Node Renderer bundle cache. Used by both
+  # PreSeedRendererCache (copies files for Docker images) and
+  # PrepareNodeRenderBundles (symlinks for same-filesystem workflows).
+  module RendererCacheHelpers
+    LOADABLE_STATS_ASSET_NAME = "loadable-stats.json"
+
+    module_function
+
+    def collect_assets_with_required_paths
+      config = ReactOnRailsPro.configuration
+      # assets_to_copy may include nil entries (user-configured, optional);
+      # those are silently dropped by `.compact`. RSC manifests, by contrast,
+      # are required, so resolve them separately and fail loudly if either
+      # resolves to nil rather than letting `.compact` swallow the gap.
+      assets = Array(config.assets_to_copy).compact
+      loadable_stats_path = loadable_stats_asset_path
+      assets << loadable_stats_path if loadable_stats_path
+
+      if config.enable_rsc_support
+        rsc_manifests = rsc_manifest_paths
+        assets.concat(rsc_manifests)
+      else
+        rsc_manifests = []
+      end
+
+      unique = assets.uniq(&:to_s)
+      warn_on_duplicate_basenames(unique)
+      [unique, required_rsc_asset_paths(rsc_manifests)]
+    end
+
+    # Convenience for callers that only need the asset list and intentionally
+    # discard the rsc_required_paths Set returned by
+    # collect_assets_with_required_paths. If you need to enforce required-RSC
+    # availability (raising loudly when a required manifest is missing), use
+    # collect_assets_with_required_paths and pass both into each_stageable_asset
+    # — `nil`-or-empty here would silently skip the required-paths check.
+    def collect_assets
+      collect_assets_with_required_paths.first
+    end
+
+    def required_rsc_asset_basenames
+      required_rsc_asset_paths_for_current_config.map { |path| File.basename(path) }
+    end
+
+    # No-arg companion to `required_rsc_asset_paths` for callers (rolling-deploy
+    # adapter publication, payload validation) that don't already hold the
+    # resolved manifest list. Centralising the rsc_manifest_paths lookup avoids
+    # call-site drift if the manifest sources change.
+    def required_rsc_asset_paths_for_current_config
+      return Set.new unless ReactOnRailsPro.configuration.enable_rsc_support
+
+      required_rsc_asset_paths(rsc_manifest_paths)
+    end
+
+    def rsc_manifest_paths
+      manifests = {
+        react_client_manifest_file_path: ReactOnRailsPro::Utils.react_client_manifest_file_path,
+        react_server_client_manifest_file_path: ReactOnRailsPro::Utils.react_server_client_manifest_file_path
+      }
+      nil_manifest_names = manifests.select { |_name, path| path.nil? }.keys
+      unless nil_manifest_names.empty?
+        raise ReactOnRailsPro::Error,
+              "RSC manifest path resolved to nil for #{nil_manifest_names.join(', ')}. " \
+              "Check react_client_manifest_file and react_server_client_manifest_file configuration."
+      end
+
+      manifests.values
+    end
+
+    # `stage_assets` writes each asset into `bundle_dir` using only its basename,
+    # so two distinct assets with the same basename (e.g. `/path/a/manifest.json`
+    # and `/path/b/manifest.json`) silently overwrite one another. Uniq-by-path
+    # cannot detect this; warn so the user notices the misconfiguration.
+    def warn_on_duplicate_basenames(assets)
+      basenames = assets.reject { |a| http_url?(a) }.map { |a| File.basename(a.to_s) }
+      duplicates = basenames.tally.select { |_, count| count > 1 }.keys
+      return if duplicates.empty?
+
+      warn "[ReactOnRailsPro] Duplicate asset basenames in assets_to_copy / RSC manifests: " \
+           "#{duplicates.join(', ')}. Only the last entry per basename will be staged."
+    end
+
+    def loadable_stats_asset_path
+      path = ReactOnRails::PackerUtils.asset_uri_from_packer(LOADABLE_STATS_ASSET_NAME)
+      File.exist?(path.to_s) ? path : nil
+    rescue KeyError, TypeError, Errno::ENOENT
+      # Narrow to errors PackerUtils.asset_uri_from_packer can plausibly raise
+      # (missing manifest key, nil path, manifest file absent). Unexpected bugs
+      # like NoMethodError or NameError should surface so operators can see them
+      # rather than being silently swallowed.
+      nil
+    end
+
+    # Required assets are matched by expanded path rather than basename so a
+    # same-named unrelated entry in assets_to_copy cannot trigger a false-
+    # positive "required" error. Expand against Rails.root to match how
+    # required_rsc_asset_paths builds its Set.
+    #
+    # URL-backed assets (returned by `asset_uri_from_packer` while the dev
+    # server is running) cannot be staged into the local cache; skip them with
+    # a warning so the renderer falls back to fetching them at request time
+    # rather than aborting the entire pre-seed.
+    def each_stageable_asset(assets, rsc_required_paths, action_description)
+      assets.each do |asset_path|
+        if http_url?(asset_path)
+          warn "[ReactOnRailsPro] Skipping URL-backed asset #{asset_path} while " \
+               "#{action_description} the renderer cache; the dev server is serving " \
+               "this asset, so the renderer will fetch it on first request."
+          next
+        end
+
+        expanded =
+          begin
+            File.expand_path(asset_path.to_s, Rails.root)
+          rescue ArgumentError => e
+            warn "[ReactOnRailsPro] Asset not found #{asset_label(asset_path)} (invalid path: #{e.message})"
+            next
+          end
+
+        unless File.file?(expanded)
+          if rsc_required_paths.include?(expanded)
+            raise ReactOnRailsPro::Error, "Required RSC asset not found or not a file: #{asset_path}. " \
+                                          "Build your bundles before #{action_description} the renderer cache."
+          end
+          warn "[ReactOnRailsPro] Asset not found #{asset_label(asset_path)} (missing or not a file)"
+          next
+        end
+
+        yield expanded
+      end
+    end
+
+    def copy_file_atomically(src, dest, log_prefix:)
+      FileUtils.mkdir_p(File.dirname(dest))
+      tmp_file = "#{dest}.tmp-#{Process.pid}-#{SecureRandom.hex(6)}"
+      FileUtils.cp(src, tmp_file)
+      File.rename(tmp_file, dest)
+      puts "[ReactOnRailsPro] #{log_prefix}: #{src} -> #{dest}"
+    ensure
+      # Clean up the temp file on failure; rm_f is harmless after a successful rename.
+      FileUtils.rm_f(tmp_file) if tmp_file
+    end
+
+    def asset_label(asset_path)
+      asset_path.to_s.empty? ? "<blank>" : asset_path
+    end
+
+    # Mirrors `Request#http_url?`: detects dev-server-served assets returned
+    # by `ReactOnRails::PackerUtils.asset_uri_from_packer` so the staging
+    # path can skip them instead of treating them as filesystem paths.
+    def http_url?(path)
+      path.to_s.match?(%r{\Ahttps?://})
+    end
+
+    # Must expand against Rails.root so that callers who expand per-asset paths
+    # against the same base produce Set-comparable strings. Without an explicit
+    # base, File.expand_path uses Dir.pwd, which differs in Docker RUN steps
+    # and would make the Set lookup miss.
+    #
+    # URL-backed manifests (dev server) cannot be staged; exclude them so
+    # `each_stageable_asset` does not see them as "required" and raise.
+    def required_rsc_asset_paths(manifests)
+      return Set.new unless ReactOnRailsPro.configuration.enable_rsc_support
+
+      Set.new(
+        manifests
+          .reject { |path| http_url?(path) }
+          .map { |path| File.expand_path(path.to_s, Rails.root) }
+      )
+    end
+
+    def validate_bundle_exists!(path, action_description)
+      return if File.file?(path)
+
+      raise ReactOnRailsPro::Error,
+            "Bundle not found or not a file at #{path}. " \
+            "Please build your bundles before #{action_description} the renderer cache."
+    end
+
+    # Defense-in-depth against future regressions in the hash-computation path:
+    # `calc_bundle_hash` always returns a non-empty string today, but a blank
+    # value here would cause `File.join(cache_dir, "")` to resolve to `cache_dir`
+    # itself and stage the bundle as `<cache_dir>/.js` — a hidden file the
+    # renderer never reads. Fail loudly instead of silently mis-staging.
+    #
+    # We also reject non-String, non-nil types (e.g. Pathname, Symbol) so a
+    # future pool that returns one fails loudly rather than silently producing
+    # surprising `File.join` results downstream.
+    def validate_bundle_hash!(hash, path)
+      unless hash.nil? || hash.is_a?(String)
+        raise ReactOnRailsPro::Error,
+              "Bundle hash for #{path} must be a String or nil, got #{hash.class}."
+      end
+      return unless hash.to_s.strip.empty?
+
+      raise ReactOnRailsPro::Error,
+            "Bundle hash for #{path} is nil or blank; cannot stage renderer cache."
+    end
+
+    def make_relative_symlink(source, destination, log_prefix:)
+      destination_dir = Pathname.new(destination).dirname
+      FileUtils.mkdir_p(destination_dir)
+
+      source_path = realpath_for_symlink_source(source)
+      destination_dir_real = realpath_for_symlink_destination(destination_dir)
+      relative_source_path = source_path.relative_path_from(destination_dir_real)
+      tmp_link = "#{destination}.tmp-#{Process.pid}-#{SecureRandom.hex(6)}"
+
+      File.symlink(relative_source_path.to_s, tmp_link)
+      File.rename(tmp_link, destination)
+      puts "[ReactOnRailsPro] #{log_prefix}: #{relative_source_path} -> #{destination}"
+    ensure
+      FileUtils.rm_f(tmp_link) if tmp_link
+    end
+
+    def stage_file(src, dest, mode, log_prefix:)
+      if mode == :copy
+        copy_file_atomically(src, dest, log_prefix: log_prefix)
+      else
+        make_relative_symlink(src, dest, log_prefix: log_prefix)
+      end
+    end
+
+    def realpath_for_symlink_source(source)
+      Pathname.new(source).realpath
+    rescue Errno::ENOENT
+      raise ReactOnRailsPro::Error,
+            "Cannot resolve real path for symlink source #{source} — " \
+            "it does not exist or is a dangling symlink. " \
+            "Rebuild your bundles before staging the renderer cache."
+    end
+
+    def realpath_for_symlink_destination(destination_dir)
+      destination_dir.realpath
+    rescue Errno::ENOENT
+      raise ReactOnRailsPro::Error,
+            "Cannot resolve real path for symlink destination dir #{destination_dir} — " \
+            "it may have been removed after mkdir_p (race with an external cleanup)."
+    end
+
+    # Resolves bundle sources as [path, hash] pairs so callers can iterate
+    # without needing to re-call pool methods. `pool` must respond to
+    # `server_bundle_hash` and (when RSC is enabled) `rsc_bundle_hash`.
+    #
+    # Validates each bundle path exists *before* computing its hash, because
+    # `pool.server_bundle_hash` eventually calls `Digest::MD5.file` / `File.mtime`
+    # on the bundle path, which raises raw `Errno::ENOENT` if the file is
+    # missing — bypassing the friendly `ReactOnRailsPro::Error` message.
+    def bundle_sources(pool, action_description)
+      server_bundle_path = ReactOnRails::Utils.server_bundle_js_file_path
+      validate_bundle_exists!(server_bundle_path, action_description)
+      server_hash = pool.server_bundle_hash
+      validate_bundle_hash!(server_hash, server_bundle_path)
+      sources = [[server_bundle_path, server_hash]]
+
+      return sources unless ReactOnRailsPro.configuration.enable_rsc_support
+
+      rsc_bundle_path = ReactOnRailsPro::Utils.rsc_bundle_js_file_path
+      validate_bundle_exists!(rsc_bundle_path, action_description)
+      rsc_hash = pool.rsc_bundle_hash
+      validate_bundle_hash!(rsc_hash, rsc_bundle_path)
+      sources << [rsc_bundle_path, rsc_hash]
+      sources
+    end
+  end
+end

data/lib/react_on_rails_pro/renderer_cache_path.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "react_on_rails_pro/error"
+
+module ReactOnRailsPro
+  # Resolves the Node Renderer server-bundle cache directory from environment
+  # variables, preserving the same precedence and warning behavior as the Node
+  # renderer configuration.
+  module RendererCachePath
+    PREFERRED_ENV_VAR = "RENDERER_SERVER_BUNDLE_CACHE_PATH"
+    LEGACY_ENV_VAR = "RENDERER_BUNDLE_PATH"
+    DEFAULT_CACHE_DIR = ".node-renderer-bundles"
+    LEGACY_ENV_VAR_DEPRECATION_MUTEX = Mutex.new
+
+    private_constant :PREFERRED_ENV_VAR,
+                     :LEGACY_ENV_VAR,
+                     :DEFAULT_CACHE_DIR,
+                     :LEGACY_ENV_VAR_DEPRECATION_MUTEX
+
+    # Module-level instance var read/written by singleton methods under the mutex.
+    @legacy_env_var_deprecation_warned = false
+
+    class << self
+      def resolve
+        preferred = env_value(PREFERRED_ENV_VAR)
+        return preferred if preferred
+
+        legacy = env_value(LEGACY_ENV_VAR)
+        return Rails.root.join(DEFAULT_CACHE_DIR).to_s unless legacy
+
+        warn_legacy_env_var_once
+        legacy
+      end
+
+      private
+
+      # Surrounding whitespace is preserved verbatim because the Node renderer
+      # reads these env vars raw, but it is almost always a misconfigured CI
+      # secret — warn so operators notice.
+      #
+      # The two whitespace guards are intentionally asymmetric:
+      #   * Whitespace-only ("  ") raises because there is no valid
+      #     interpretation, so a misconfigured deploy should fail fast instead
+      #     of silently falling back.
+      #   * Surrounding whitespace ("  /app/bundles  ") only warns because the
+      #     trimmed path could conceivably be intentional. Preserve it and let
+      #     the operator decide.
+      def env_value(name)
+        value = ENV.fetch(name, "")
+        raise ReactOnRailsPro::Error, "#{name} is whitespace-only; set or unset it." if value.match?(/\A\s+\z/)
+
+        if value != value.strip
+          warn "[ReactOnRailsPro] #{name} has surrounding whitespace " \
+               "and will be used verbatim: #{value.inspect}"
+        end
+        value.empty? ? nil : value
+      end
+
+      def warn_legacy_env_var_once
+        LEGACY_ENV_VAR_DEPRECATION_MUTEX.synchronize do
+          unless @legacy_env_var_deprecation_warned
+            warn "[ReactOnRailsPro] #{LEGACY_ENV_VAR} is deprecated. Use #{PREFERRED_ENV_VAR} instead."
+            @legacy_env_var_deprecation_warned = true
+          end
+        end
+      end
+
+      # :nodoc: Test helper for resetting the one-time deprecation-warning guard.
+      def reset_deprecation_warned!
+        LEGACY_ENV_VAR_DEPRECATION_MUTEX.synchronize { @legacy_env_var_deprecation_warned = false }
+      end
+    end
+  end
+end

data/lib/react_on_rails_pro/rendering_strategy/node_strategy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  module RenderingStrategy
+    # Pro rendering strategy wrapping ProRendering, which handles caching,
+    # streaming, and the ExecJS vs Node renderer dispatch.
+    #
+    # Part of the strategy pattern refactoring (see issue #2905).
+    # Currently additive — not yet wired into the main rendering path.
+    class NodeStrategy
+      include ReactOnRails::RenderingStrategy
+
+      def execute(render_request)
+        js_code = render_request.to_js
+        ReactOnRailsPro::ServerRenderingPool::ProRendering
+          .exec_server_render_js(js_code, render_request.render_options)
+      end
+
+      def reset
+        ReactOnRailsPro::ServerRenderingPool::ProRendering.reset_pool
+      end
+
+      def reset_if_bundle_changed
+        ReactOnRailsPro::ServerRenderingPool::ProRendering
+          .reset_pool_if_server_bundle_was_modified
+      end
+    end
+  end
+end

data/lib/react_on_rails_pro/request.rb

@@ -3,6 +3,7 @@
 require "uri"
 require "httpx"
 require_relative "stream_request"
+require_relative "async_props_emitter"
 
 module ReactOnRailsPro
   class Request # rubocop:disable Metrics/ClassLength
@@ -35,12 +36,92 @@ module ReactOnRailsPro
                 "rendering any RSC payload."
         end
 
-        ReactOnRailsPro::StreamRequest.create do |send_bundle|
-          form = form_with_code(js_code, send_bundle)
+        ReactOnRailsPro::StreamRequest.create do |send_bundle, _barrier|
+          if send_bundle
+            Rails.logger.info { "[ReactOnRailsPro] Sending bundle to the node renderer" }
+            upload_assets
+          end
+
+          form = form_with_code(js_code, false)
           perform_request(path, form: form, stream: true)
         end
       end
 
+      # Performs an incremental render request with bidirectional HTTP/2 streaming.
+      #
+      # ARCHITECTURE: This method orchestrates the async props flow:
+      #
+      # ┌─────────────────────────────────────────────────────────────────────────┐
+      # │  Rails Thread (main)              │  Rails Thread (barrier.async)       │
+      # ├───────────────────────────────────┼─────────────────────────────────────┤
+      # │  1. Send initial NDJSON line      │                                     │
+      # │     {renderingRequest, ...}       │                                     │
+      # │                                   │                                     │
+      # │  2. Return response stream        │  3. Execute async_props_block       │
+      # │     (caller processes HTML)       │     emit.call("users", User.all)    │
+      # │                                   │     └── Sends NDJSON: {updateChunk} │
+      # │                                   │     emit.call("posts", Post.all)    │
+      # │                                   │     └── Sends NDJSON: {updateChunk} │
+      # │                                   │                                     │
+      # │  ... streaming HTML chunks ...    │  4. Block completes                 │
+      # │                                   │     request.close (sends END_STREAM)│
+      # └───────────────────────────────────┴─────────────────────────────────────┘
+      #
+      # WHY barrier.async?
+      # - 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 request (END_STREAM flag)
+      # - Node's handleRequestClosed then calls asyncPropsManager.endStream()
+      #
+      def render_code_with_incremental_updates(path, js_code, async_props_block:)
+        Rails.logger.info { "[ReactOnRailsPro] Perform incremental rendering request #{path}" }
+
+        # Determine bundle timestamp based on RSC support
+        pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
+
+        # Incremental rendering goes through the same `streamServerRenderedReactComponent`
+        # transform as one-shot streaming, so each response chunk arrives in the
+        # length-prefixed wire format. `StreamRequest` always parses length-prefixed.
+        ReactOnRailsPro::StreamRequest.create do |send_bundle, barrier|
+          if send_bundle
+            Rails.logger.info { "[ReactOnRailsPro] Sending bundle to the node renderer" }
+            upload_assets
+          end
+
+          # Build bidirectional streaming request using HTTPX's stream_bidi plugin.
+          # This creates an HTTP/2 stream where we can send data while receiving.
+          request = connection.build_request(
+            "POST",
+            path,
+            headers: { "content-type" => "application/x-ndjson" },
+            body: [],
+            stream: true
+          )
+
+          # Create emitter - it will write NDJSON lines to the request stream
+          emitter = ReactOnRailsPro::AsyncPropsEmitter.new(pool.rsc_bundle_hash, request)
+          initial_data = build_initial_incremental_request(js_code, emitter)
+
+          # Start the request - response begins streaming immediately
+          response = connection.request(request, stream: true)
+
+          # Send the initial render request as first NDJSON line
+          request << "#{initial_data.to_json}\n"
+
+          # Execute async props block in a separate fiber via barrier.
+          # This runs concurrently with the response streaming back to the client.
+          barrier.async do
+            async_props_block.call(emitter)
+          ensure
+            # When the block completes (or raises), close the request.
+            # This sends HTTP/2 END_STREAM flag, triggering Node's handleRequestClosed.
+            request.close
+          end
+
+          response
+        end
+      end
+
       def upload_assets
         Rails.logger.info { "[ReactOnRailsPro] Uploading assets" }
 
@@ -108,13 +189,20 @@ module ReactOnRailsPro
         end
       end
 
-      def perform_request(path, **post_options) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+      # Performs HTTP POST requests using the build_request pattern.
+      # This approach is required because when stream_bidi plugin is loaded,
+      # using connection.post with stream: true causes timeouts (the plugin's
+      # empty? method returns false, preventing END_STREAM from being sent).
+      #
+      # For consistency and to share error handling logic, both streaming and
+      # non-streaming requests use build_request with manually encoded bodies.
+      def perform_request(path, form: nil, json: nil, stream: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
         available_retries = ReactOnRailsPro.configuration.renderer_request_retry_limit
         retry_request = true
         while retry_request
           begin
             start_time = Time.now
-            response = connection.post(path, **post_options)
+            response = execute_http_request(path, form: form, json: json, stream: stream)
             raise response.error if response.is_a?(HTTPX::ErrorResponse)
 
             request_time = Time.now - start_time
@@ -138,7 +226,7 @@ module ReactOnRailsPro
             next
           rescue HTTPX::Error => e # Connection errors or other unexpected errors
             # Such errors are handled by ReactOnRailsPro::StreamRequest instead
-            raise if e.is_a?(HTTPX::HTTPError) && post_options[:stream]
+            raise if e.is_a?(HTTPX::HTTPError) && stream
 
             raise ReactOnRailsPro::Error,
                   "Node renderer request failed: #{path}.\nOriginal error:\n#{e}\n#{e.backtrace}"
@@ -155,6 +243,40 @@ module ReactOnRailsPro
         response
       end
 
+      # Executes an HTTP POST request using build_request pattern.
+      # For streaming requests, calls request.close to send END_STREAM flag.
+      def execute_http_request(path, form: nil, json: nil, stream: false)
+        body, content_type = encode_request_body(form: form, json: json)
+
+        request_options = {
+          headers: { "content-type" => content_type },
+          body: body
+        }
+        request_options[:stream] = true if stream
+
+        request = connection.build_request("POST", path, **request_options)
+        request.close if stream # Signal end of request body to send END_STREAM flag
+
+        connection.request(request)
+      end
+
+      # Encodes request body for use with build_request.
+      # Supports both form data (with automatic multipart detection) and JSON data.
+      def encode_request_body(form: nil, json: nil)
+        if form
+          encoder = if HTTPX::Transcoder::Multipart.multipart?(form)
+                      HTTPX::Transcoder::Multipart.encode(form)
+                    else
+                      HTTPX::Transcoder::Form.encode(form)
+                    end
+          [encoder.to_s, encoder.content_type]
+        elsif json
+          [JSON.generate(json), "application/json"]
+        else
+          raise ArgumentError, "Either form: or json: must be provided"
+        end
+      end
+
       def form_with_code(js_code, send_bundle)
         form = common_form_data
         form["renderingRequest"] = js_code
@@ -239,12 +361,18 @@ module ReactOnRailsPro
         ReactOnRailsPro::Utils.common_form_data
       end
 
+      def build_initial_incremental_request(js_code, emitter)
+        common_form_data.merge(
+          renderingRequest: js_code,
+          onRequestClosedUpdateChunk: emitter.end_stream_chunk
+        )
+      end
+
       def create_connection # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         url = ReactOnRailsPro.configuration.renderer_url
         Rails.logger.info do
           "[ReactOnRailsPro] Setting up Node Renderer connection to #{url}"
         end
-
         HTTPX
           # For persistent connections we want retries,
           # so the requests don't just fail if the other side closes the connection
@@ -270,7 +398,6 @@ module ReactOnRailsPro
                                          "of a component.\nOriginal error:\n#{e}\n#{e.backtrace}"
                                        )
                                      end
-
                                      Rails.logger.info do
                                        "[ReactOnRailsPro] An error occurred while making " \
                                          "a request to the Node Renderer.\n" \
@@ -283,7 +410,7 @@ module ReactOnRailsPro
                                      nil
                                    end
           )
-          .plugin(:stream)
+          .plugin(:stream_bidi)
           # See https://www.rubydoc.info/gems/httpx/1.3.3/HTTPX%2FOptions:initialize for the available options
           .with(
             origin: url,