react_on_rails_pro 16.2.0.beta.12 → 16.2.0.beta.13

data/app/helpers/react_on_rails_pro_helper.rb

@@ -128,7 +128,11 @@ module ReactOnRailsProHelper
     # Because setting prerender to false is equivalent to calling react_component with prerender: false
     options[:prerender] = true
     options = options.merge(immediate_hydration: true) unless options.key?(:immediate_hydration)
-    run_stream_inside_fiber do
+
+    # Extract streaming-specific callback
+    on_complete = options.delete(:on_complete)
+
+    consumer_stream_async(on_complete: on_complete) do
       internal_stream_react_component(component_name, options)
     end
   end
@@ -185,7 +189,11 @@ module ReactOnRailsProHelper
     # rsc_payload_react_component doesn't have the prerender option
     # Because setting prerender to false will not do anything
     options[:prerender] = true
-    run_stream_inside_fiber do
+
+    # Extract streaming-specific callback
+    on_complete = options.delete(:on_complete)
+
+    consumer_stream_async(on_complete: on_complete) do
       internal_rsc_payload_react_component(component_name, options)
     end
   end
@@ -209,6 +217,63 @@ module ReactOnRailsProHelper
     end
   end
 
+  # Renders a React component asynchronously, returning an AsyncValue immediately.
+  # Multiple async_react_component calls will execute their HTTP rendering requests
+  # concurrently instead of sequentially.
+  #
+  # Requires the controller to include ReactOnRailsPro::AsyncRendering and call
+  # enable_async_react_rendering.
+  #
+  # @param component_name [String] Name of your registered component
+  # @param options [Hash] Same options as react_component
+  # @return [ReactOnRailsPro::AsyncValue] Call .value to get the rendered HTML
+  #
+  # @example
+  #   <% header = async_react_component("Header", props: @header_props) %>
+  #   <% sidebar = async_react_component("Sidebar", props: @sidebar_props) %>
+  #   <%= header.value %>
+  #   <%= sidebar.value %>
+  #
+  def async_react_component(component_name, options = {})
+    unless defined?(@react_on_rails_async_barrier) && @react_on_rails_async_barrier
+      raise ReactOnRailsPro::Error,
+            "async_react_component requires AsyncRendering concern. " \
+            "Include ReactOnRailsPro::AsyncRendering in your controller and call enable_async_react_rendering."
+    end
+
+    task = @react_on_rails_async_barrier.async do
+      react_component(component_name, options)
+    end
+
+    ReactOnRailsPro::AsyncValue.new(task: task)
+  end
+
+  # Renders a React component asynchronously with caching support.
+  # Cache lookup is synchronous - cache hits return immediately without async.
+  # Cache misses trigger async render and cache the result on completion.
+  #
+  # All the same options as cached_react_component apply:
+  # 1. You must pass the props as a block (evaluated only on cache miss)
+  # 2. Provide the cache_key option
+  # 3. Optionally provide :cache_options for Rails.cache (expires_in, etc.)
+  # 4. Provide :if or :unless for conditional caching
+  #
+  # @param component_name [String] Name of your registered component
+  # @param options [Hash] Options including cache_key and cache_options
+  # @yield Block that returns props (evaluated only on cache miss)
+  # @return [ReactOnRailsPro::AsyncValue, ReactOnRailsPro::ImmediateAsyncValue]
+  #
+  # @example
+  #   <% card = cached_async_react_component("ProductCard", cache_key: @product) { @product.to_props } %>
+  #   <%= card.value %>
+  #
+  def cached_async_react_component(component_name, raw_options = {}, &block)
+    ReactOnRailsPro::Utils.with_trace(component_name) do
+      check_caching_options!(raw_options, block)
+      fetch_async_react_component(component_name, raw_options, &block)
+    end
+  end
+
   if defined?(ScoutApm)
     include ScoutApm::Tracer
     instrument_method :cached_react_component, type: "ReactOnRails", name: "cached_react_component"
@@ -246,30 +311,29 @@ module ReactOnRailsProHelper
     load_pack_for_generated_component(component_name, render_options)
 
     initial_result, *rest_chunks = cached_chunks
-    hit_fiber = Fiber.new do
-      rest_chunks.each { |chunk| Fiber.yield(chunk) }
-      nil
+
+    # Enqueue remaining chunks asynchronously
+    @async_barrier.async do
+      rest_chunks.each { |chunk| @main_output_queue.enqueue(chunk) }
     end
-    @rorp_rendering_fibers << hit_fiber
+
+    # Return first chunk directly
     initial_result
   end
 
   def handle_stream_cache_miss(component_name, raw_options, auto_load_bundle, view_cache_key, &block)
-    # Kick off the normal streaming helper to get the initial result and the original fiber
-    initial_result = render_stream_component_with_props(component_name, raw_options, auto_load_bundle, &block)
-    original_fiber = @rorp_rendering_fibers.pop
-
-    buffered_chunks = [initial_result]
-    wrapper_fiber = Fiber.new do
-      while (chunk = original_fiber.resume)
-        buffered_chunks << chunk
-        Fiber.yield(chunk)
-      end
-      Rails.cache.write(view_cache_key, buffered_chunks, raw_options[:cache_options] || {})
-      nil
-    end
-    @rorp_rendering_fibers << wrapper_fiber
-    initial_result
+    cache_aware_options = raw_options.merge(
+      on_complete: lambda { |chunks|
+        Rails.cache.write(view_cache_key, chunks, raw_options[:cache_options] || {})
+      }
+    )
+
+    render_stream_component_with_props(
+      component_name,
+      cache_aware_options,
+      auto_load_bundle,
+      &block
+    )
   end
 
   def render_stream_component_with_props(component_name, raw_options, auto_load_bundle)
@@ -291,25 +355,117 @@ module ReactOnRailsProHelper
     raise ReactOnRailsPro::Error, "Option 'cache_key' is required for React on Rails caching"
   end
 
-  def run_stream_inside_fiber
-    if @rorp_rendering_fibers.nil?
+  # Async version of fetch_react_component. Handles cache lookup synchronously,
+  # returns ImmediateAsyncValue on hit, AsyncValue on miss.
+  def fetch_async_react_component(component_name, raw_options, &block)
+    unless defined?(@react_on_rails_async_barrier) && @react_on_rails_async_barrier
+      raise ReactOnRailsPro::Error,
+            "cached_async_react_component requires AsyncRendering concern. " \
+            "Include ReactOnRailsPro::AsyncRendering in your controller and call enable_async_react_rendering."
+    end
+
+    # Check conditional caching (:if / :unless options)
+    unless ReactOnRailsPro::Cache.use_cache?(raw_options)
+      return render_async_react_component_uncached(component_name, raw_options, &block)
+    end
+
+    cache_key = ReactOnRailsPro::Cache.react_component_cache_key(component_name, raw_options)
+    cache_options = raw_options[:cache_options] || {}
+    Rails.logger.debug { "React on Rails Pro async cache_key is #{cache_key.inspect}" }
+
+    # Synchronous cache lookup
+    cached_result = Rails.cache.read(cache_key, cache_options)
+    if cached_result
+      Rails.logger.debug { "React on Rails Pro async cache HIT for #{cache_key.inspect}" }
+      render_options = ReactOnRails::ReactComponent::RenderOptions.new(
+        react_component_name: component_name,
+        options: raw_options
+      )
+      load_pack_for_generated_component(component_name, render_options)
+      return ReactOnRailsPro::ImmediateAsyncValue.new(cached_result)
+    end
+
+    Rails.logger.debug { "React on Rails Pro async cache MISS for #{cache_key.inspect}" }
+    render_async_react_component_with_cache(component_name, raw_options, cache_key, cache_options, &block)
+  end
+
+  # Renders async without caching (when :if/:unless conditions disable cache)
+  def render_async_react_component_uncached(component_name, raw_options, &block)
+    options = prepare_async_render_options(raw_options, &block)
+
+    task = @react_on_rails_async_barrier.async do
+      react_component(component_name, options)
+    end
+
+    ReactOnRailsPro::AsyncValue.new(task: task)
+  end
+
+  # Renders async and writes to cache on completion
+  def render_async_react_component_with_cache(component_name, raw_options, cache_key, cache_options, &block)
+    options = prepare_async_render_options(raw_options, &block)
+
+    task = @react_on_rails_async_barrier.async do
+      result = react_component(component_name, options)
+      Rails.cache.write(cache_key, result, cache_options)
+      result
+    end
+
+    ReactOnRailsPro::AsyncValue.new(task: task)
+  end
+
+  def prepare_async_render_options(raw_options)
+    raw_options.merge(
+      props: yield,
+      skip_prerender_cache: true,
+      auto_load_bundle: ReactOnRails.configuration.auto_load_bundle || raw_options[:auto_load_bundle]
+    )
+  end
+
+  def consumer_stream_async(on_complete:)
+    require "async/variable"
+
+    if @async_barrier.nil?
       raise ReactOnRails::Error,
             "You must call stream_view_containing_react_components to render the view containing the react component"
     end
 
-    rendering_fiber = Fiber.new do
+    # Create a variable to hold the first chunk for synchronous return
+    first_chunk_var = Async::Variable.new
+    all_chunks = [] if on_complete # Only collect if callback provided
+
+    # Start an async task on the barrier to stream all chunks
+    @async_barrier.async do
       stream = yield
-      stream.each_chunk do |chunk|
-        Fiber.yield chunk
-      end
+      process_stream_chunks(stream, first_chunk_var, all_chunks)
+      on_complete&.call(all_chunks)
     end
 
-    @rorp_rendering_fibers << rendering_fiber
+    # Wait for and return the first chunk (blocking)
+    first_chunk_var.wait
+    first_chunk_var.value
+  end
+
+  def process_stream_chunks(stream, first_chunk_var, all_chunks)
+    is_first = true
+
+    stream.each_chunk do |chunk|
+      # Check if client disconnected before processing chunk
+      break if response.stream.closed?
+
+      all_chunks&.push(chunk)
+
+      if is_first
+        # Store first chunk in variable for synchronous return
+        first_chunk_var.value = chunk
+        is_first = false
+      else
+        # Enqueue remaining chunks to main output queue
+        @main_output_queue.enqueue(chunk)
+      end
+    end
 
-    # return the first chunk of the fiber
-    # It contains the initial html of the component
-    # all updates will be appended to the stream sent to browser
-    rendering_fiber.resume
+    # Handle case where stream has no chunks
+    first_chunk_var.value = nil if is_first
   end
 
   def internal_stream_react_component(component_name, options = {})

data/eslint.config.mjs

@@ -3,7 +3,6 @@ import { includeIgnoreFile } from '@eslint/compat';
 import js from '@eslint/js';
 import { FlatCompat } from '@eslint/eslintrc';
 import { defineConfig, globalIgnores } from 'eslint/config';
-import importPlugin from 'eslint-plugin-import';
 import jest from 'eslint-plugin-jest';
 import prettierRecommended from 'eslint-plugin-prettier/recommended';
 import globals from 'globals';
@@ -22,8 +21,9 @@ export default defineConfig([
     'spec/react_on_rails/dummy-for-generators',
     // includes some generated code
     'spec/dummy/client/app/packs/server-bundle.js',
-    'packages/node-renderer/lib/',
-    'packages/node-renderer/tests/fixtures',
+    '../packages/react-on-rails/', // Ignore open-source package (has its own linting)
+    '../packages/react-on-rails-pro-node-renderer/lib/',
+    '../packages/react-on-rails-pro-node-renderer/tests/fixtures',
     '**/node_modules/',
     '**/assets/webpack/',
     '**/generated/',
@@ -129,7 +129,7 @@ export default defineConfig([
   },
   {
     files: ['**/*.ts{x,}'],
-    extends: [importPlugin.flatConfigs.typescript, typescriptEslint.configs.strictTypeChecked],
+    extends: [typescriptEslint.configs.strictTypeChecked],
 
     languageOptions: {
       parserOptions: {
@@ -166,7 +166,7 @@ export default defineConfig([
     },
   },
   {
-    files: ['packages/node-renderer/tests/**', '**/*.test.{js,jsx,ts,tsx}'],
+    files: ['../packages/react-on-rails-pro-node-renderer/tests/**', '**/*.test.{js,jsx,ts,tsx}'],
 
     extends: [jest.configs['flat/recommended'], jest.configs['flat/style']],
 
@@ -183,8 +183,8 @@ export default defineConfig([
     },
   },
   {
-    files: ['packages/node-renderer/src/integrations/**'],
-    ignores: ['packages/node-renderer/src/integrations/api.ts'],
+    files: ['../packages/react-on-rails-pro-node-renderer/src/integrations/**'],
+    ignores: ['../packages/react-on-rails-pro-node-renderer/src/integrations/api.ts'],
 
     rules: {
       // Integrations should only use the public integration API
@@ -214,6 +214,25 @@ export default defineConfig([
       'react-hooks/rules-of-hooks': ['off'],
     },
   },
+  {
+    // Dummy apps have dependencies managed separately and may not be installed
+    files: ['spec/dummy/**/*', 'spec/execjs-compatible-dummy/**/*'],
+    rules: {
+      'import/no-unresolved': 'off',
+      'import/named': 'off',
+    },
+  },
+  {
+    // Pro packages use monorepo workspace imports that ESLint can't resolve
+    // TypeScript compiler validates these imports
+    files: ['../packages/react-on-rails-pro/**/*', '../packages/react-on-rails-pro-node-renderer/**/*'],
+    rules: {
+      'import/named': 'off',
+      'import/no-unresolved': 'off',
+      'import/no-cycle': 'off',
+      'import/extensions': 'off',
+    },
+  },
   // must be the last config in the array
   // https://github.com/prettier/eslint-plugin-prettier?tab=readme-ov-file#configuration-new-eslintconfigjs
   prettierRecommended,

data/lib/react_on_rails_pro/async_value.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  # AsyncValue wraps an Async task to provide a simple interface for
+  # retrieving the result of an async react_component render.
+  #
+  # @example
+  #   async_value = async_react_component("MyComponent", props: { name: "World" })
+  #   # ... do other work ...
+  #   html = async_value.value  # blocks until result is ready
+  #
+  class AsyncValue
+    def initialize(task:)
+      @task = task
+    end
+
+    # Blocks until result is ready, returns HTML string.
+    # If the async task raised an exception, it will be re-raised here.
+    def value
+      @task.wait
+    end
+
+    def resolved?
+      @task.finished?
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    def html_safe
+      value.html_safe
+    end
+  end
+end

data/lib/react_on_rails_pro/concerns/async_rendering.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  # AsyncRendering enables concurrent rendering of multiple React components.
+  # When enabled, async_react_component calls will execute their HTTP requests
+  # in parallel instead of sequentially.
+  #
+  # @example Enable for all actions
+  #   class ProductsController < ApplicationController
+  #     include ReactOnRailsPro::AsyncRendering
+  #     enable_async_react_rendering
+  #   end
+  #
+  # @example Enable for specific actions only
+  #   class ProductsController < ApplicationController
+  #     include ReactOnRailsPro::AsyncRendering
+  #     enable_async_react_rendering only: [:show, :index]
+  #   end
+  #
+  # @example Enable for all except specific actions
+  #   class ProductsController < ApplicationController
+  #     include ReactOnRailsPro::AsyncRendering
+  #     enable_async_react_rendering except: [:create, :update]
+  #   end
+  #
+  module AsyncRendering
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Enables async React component rendering for controller actions.
+      # Accepts standard Rails filter options like :only and :except.
+      #
+      # @param options [Hash] Options passed to around_action (e.g., only:, except:)
+      def enable_async_react_rendering(**options)
+        around_action :wrap_in_async_react_context, **options
+      end
+    end
+
+    private
+
+    def wrap_in_async_react_context
+      require "async"
+      require "async/barrier"
+
+      Sync do
+        @react_on_rails_async_barrier = Async::Barrier.new
+        yield
+        check_for_unresolved_async_components
+      ensure
+        @react_on_rails_async_barrier&.stop
+        @react_on_rails_async_barrier = nil
+      end
+    end
+
+    def check_for_unresolved_async_components
+      return if @react_on_rails_async_barrier.nil?
+
+      pending_tasks = @react_on_rails_async_barrier.size
+      return if pending_tasks.zero?
+
+      Rails.logger.error(
+        "[React on Rails Pro] #{pending_tasks} async component(s) were started but never resolved. " \
+        "Make sure to call .value on all AsyncValue objects returned by async_react_component " \
+        "or cached_async_react_component. Unresolved tasks will be stopped."
+      )
+    end
+  end
+end

data/lib/react_on_rails_pro/concerns/stream.rb

@@ -31,72 +31,85 @@ module ReactOnRailsPro
     #
     # @see ReactOnRails::Helper#stream_react_component
     def stream_view_containing_react_components(template:, close_stream_at_end: true, **render_options)
-      @rorp_rendering_fibers = []
-      template_string = render_to_string(template: template, **render_options)
-      # View may contain extra newlines, chunk already contains a newline
-      # Having multiple newlines between chunks causes hydration errors
-      # So we strip extra newlines from the template string and add a single newline
-      response.stream.write(template_string)
-
-      begin
-        drain_streams_concurrently
-      ensure
-        response.stream.close if close_stream_at_end
-      end
-    end
-
-    private
-
-    def drain_streams_concurrently
       require "async"
+      require "async/barrier"
       require "async/limited_queue"
 
-      return if @rorp_rendering_fibers.empty?
-
-      Sync do |parent|
-        # To avoid memory bloat, we use a limited queue to buffer chunks in memory.
+      Sync do |parent_task|
+        # Initialize async primitives for concurrent component streaming
+        @async_barrier = Async::Barrier.new
         buffer_size = ReactOnRailsPro.configuration.concurrent_component_streaming_buffer_size
-        queue = Async::LimitedQueue.new(buffer_size)
+        @main_output_queue = Async::LimitedQueue.new(buffer_size)
 
-        writer = build_writer_task(parent: parent, queue: queue)
-        tasks = build_producer_tasks(parent: parent, queue: queue)
+        # Render template - components will start streaming immediately
+        template_string = render_to_string(template: template, **render_options)
+        # View may contain extra newlines, chunk already contains a newline
+        # Having multiple newlines between chunks causes hydration errors
+        # So we strip extra newlines from the template string and add a single newline
+        response.stream.write(template_string)
 
-        # This structure ensures that even if a producer task fails, we always
-        # signal the writer to stop and then wait for it to finish draining
-        # any remaining items from the queue before propagating the error.
         begin
-          tasks.each(&:wait)
-        ensure
-          # `close` signals end-of-stream; when writer tries to dequeue, it will get nil, so it will exit.
-          queue.close
-          writer.wait
+          drain_streams_concurrently(parent_task)
+          # Do not close the response stream in an ensure block.
+          # If an error occurs we may need the stream open to send diagnostic/error details
+          # (for example, ApplicationController#rescue_from in the dummy app).
+          response.stream.close if close_stream_at_end
         end
       end
     end
 
-    def build_producer_tasks(parent:, queue:)
-      @rorp_rendering_fibers.each_with_index.map do |fiber, idx|
-        parent.async do
-          loop do
-            chunk = fiber.resume
-            break unless chunk
+    private
 
-            # Will be blocked if the queue is full until a chunk is dequeued
-            queue.enqueue([idx, chunk])
-          end
+    # Drains all streaming tasks concurrently using a producer-consumer pattern.
+    #
+    # Producer tasks: Created by consumer_stream_async in the helper, each streams
+    # chunks from the renderer and enqueues them to @main_output_queue.
+    #
+    # Consumer task: Single writer dequeues chunks and writes to response stream.
+    #
+    # Client disconnect handling:
+    # - If client disconnects (IOError/Errno::EPIPE), writer stops gracefully
+    # - Barrier is stopped to cancel all producer tasks, preventing wasted work
+    # - No exception propagates to the controller for client disconnects
+    def drain_streams_concurrently(parent_task)
+      client_disconnected = false
+
+      writing_task = parent_task.async do
+        # Drain all remaining chunks from the queue to the response stream
+        while (chunk = @main_output_queue.dequeue)
+          response.stream.write(chunk)
         end
+      rescue IOError, Errno::EPIPE => e
+        # Client disconnected - stop writing gracefully
+        client_disconnected = true
+        log_client_disconnect("writer", e)
       end
+
+      # Wait for all component streaming tasks to complete
+      begin
+        @async_barrier.wait
+      rescue StandardError => e
+        @async_barrier.stop
+        raise e
+      end
+    ensure
+      # Close the queue first to unblock writing_task (it may be waiting on dequeue)
+      @main_output_queue.close
+
+      # Wait for writing_task to ensure client_disconnected flag is set
+      # before we check it (fixes race condition where ensure runs before
+      # writing_task's rescue block sets the flag)
+      writing_task.wait
+
+      # If client disconnected, stop all producer tasks to avoid wasted work
+      @async_barrier.stop if client_disconnected
     end
 
-    def build_writer_task(parent:, queue:)
-      parent.async do
-        loop do
-          pair = queue.dequeue
-          break if pair.nil?
+    def log_client_disconnect(context, exception)
+      return unless ReactOnRails.configuration.logging_on_server
 
-          _idx_from_queue, item = pair
-          response.stream.write(item)
-        end
+      Rails.logger.debug do
+        "[React on Rails Pro] Client disconnected during streaming (#{context}): #{exception.class}"
       end
     end
   end

data/lib/react_on_rails_pro/configuration.rb

@@ -70,7 +70,26 @@ module ReactOnRailsPro
                   :renderer_request_retry_limit, :throw_js_errors, :ssr_timeout,
                   :profile_server_rendering_js_code, :raise_non_shell_server_rendering_errors, :enable_rsc_support,
                   :rsc_payload_generation_url_path, :rsc_bundle_js_file, :react_client_manifest_file,
-                  :react_server_client_manifest_file, :concurrent_component_streaming_buffer_size
+                  :react_server_client_manifest_file
+
+    attr_reader :concurrent_component_streaming_buffer_size
+
+    # Sets the buffer size for concurrent component streaming.
+    #
+    # This value controls how many chunks can be buffered in memory during
+    # concurrent streaming operations. When producers generate chunks faster
+    # than they can be written to the client, this buffer prevents unbounded
+    # memory growth by blocking producers when the buffer is full.
+    #
+    # @param value [Integer] A positive integer specifying the buffer size
+    # @raise [ReactOnRailsPro::Error] if value is not a positive integer
+    def concurrent_component_streaming_buffer_size=(value)
+      unless value.is_a?(Integer) && value.positive?
+        raise ReactOnRailsPro::Error,
+              "config.concurrent_component_streaming_buffer_size must be a positive integer"
+      end
+      @concurrent_component_streaming_buffer_size = value
+    end
 
     def initialize(renderer_url: nil, renderer_password: nil, server_renderer: nil, # rubocop:disable Metrics/AbcSize
                    renderer_use_fallback_exec_js: nil, prerender_caching: nil,
@@ -118,7 +137,6 @@ module ReactOnRailsPro
       validate_remote_bundle_cache_adapter
       setup_renderer_password
       setup_assets_to_copy
-      validate_concurrent_component_streaming_buffer_size
       setup_execjs_profiler_if_needed
       check_react_on_rails_support_for_rsc
     end
@@ -210,14 +228,6 @@ module ReactOnRailsPro
       end
     end
 
-    def validate_concurrent_component_streaming_buffer_size
-      return if concurrent_component_streaming_buffer_size.is_a?(Integer) &&
-                concurrent_component_streaming_buffer_size.positive?
-
-      raise ReactOnRailsPro::Error,
-            "config.concurrent_component_streaming_buffer_size must be a positive integer"
-    end
-
     def setup_renderer_password
       return if renderer_password.present?
 

data/lib/react_on_rails_pro/immediate_async_value.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  # ImmediateAsyncValue is returned when a cached_async_react_component call
+  # has a cache hit. It provides the same interface as AsyncValue but returns
+  # the cached value immediately without any async operations.
+  #
+  class ImmediateAsyncValue
+    def initialize(value)
+      @value = value
+    end
+
+    attr_reader :value
+
+    def resolved?
+      true
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+    def html_safe
+      @value.html_safe
+    end
+  end
+end

data/lib/react_on_rails_pro/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module ReactOnRailsPro
-  VERSION = "16.2.0.beta.12"
+  VERSION = "16.2.0.beta.13"
   PROTOCOL_VERSION = "2.0.0"
 end

data/lib/react_on_rails_pro.rb

@@ -20,4 +20,7 @@ require "react_on_rails_pro/assets_precompile"
 require "react_on_rails_pro/prepare_node_renderer_bundles"
 require "react_on_rails_pro/concerns/stream"
 require "react_on_rails_pro/concerns/rsc_payload_renderer"
+require "react_on_rails_pro/concerns/async_rendering"
+require "react_on_rails_pro/async_value"
+require "react_on_rails_pro/immediate_async_value"
 require "react_on_rails_pro/routes"