ruact 0.0.19 → 0.0.20

data/lib/ruact/html_converter.rb

@@ -52,7 +52,9 @@ module Ruact
     end
 
     def initialize(component_registry)
-      @registry = component_registry
+      # Indexed once by token: each marker in the HTML is one lookup. Built
+      # without a pair array per entry (the render allocation guard counts them).
+      @registry = component_registry.each_with_object({}) { |entry, by_token| by_token[entry[:token]] = entry } # rubocop:disable Style/ReduceToHash
     end
 
     # Convert an HTML string into a ReactElement tree (instance form).
@@ -163,8 +165,8 @@ module Ruact
 
       when Nokogiri::XML::Node::COMMENT_NODE
         # Check if this is a Ruact component placeholder
-        token = node.content.strip
-        entry = @registry.find { |c| c[:token] == token }
+        token = Markers.comment_token(node)
+        entry = @registry[token]
         return nil unless entry
 
         Flight::ReactElement.new(
@@ -181,8 +183,8 @@ module Ruact
 
     def convert_element(node)
       tag = node.name.downcase
-      return convert_suspense_element(node) if tag == "ruact-suspense"
-      return convert_component_with_children(node) if tag == ErbPreprocessor::WRAPPER_TAG
+      return convert_suspense_element(node) if tag == Markers::SUSPENSE_TAG
+      return convert_component_with_children(node) if tag == Markers::WRAPPER_TAG
 
       props = build_props(node, tag)
       children = convert_children(node)
@@ -196,8 +198,8 @@ module Ruact
     # component's `children` prop, converted like any element's; an empty pair
     # passes none, like `<Card />`.
     def convert_component_with_children(node)
-      token = node["data-ruact-token"]
-      entry = @registry.find { |c| c[:token] == token }
+      token = Markers.wrapper_token(node)
+      entry = @registry[token]
       raise Ruact::HtmlConverterError, "ruact: no component registered for #{token.inspect}" unless entry
 
       props = entry[:props]
@@ -209,38 +211,28 @@ module Ruact
     end
 
     def convert_suspense_element(node)
-      fallback_text = node["data-ruact-fallback"] || ""
+      fallback_text = Markers.suspense_fallback(node)
       fallback = if fallback_text.empty?
                    nil
                  else
                    Flight::ReactElement.new(type: "p", key: nil, props: { "children" => fallback_text })
                  end
 
-      child_nodes = convert_children(node)
-      children = child_nodes.length == 1 ? child_nodes.first : child_nodes
-
       # Optional `delay="2.5"` from the ERB → SuspenseElement#delay (the
-      # server-side wait, in seconds, before the deferred chunk streams). When
-      # absent, blank, unparseable, or non-finite, SuspenseElement falls back to
-      # its default.
-      delay_attr = node["data-ruact-delay"]
-      delay = begin
-        if delay_attr && !delay_attr.to_s.strip.empty?
-          # A string overflow like "1e309" parses to Infinity (Float() does not
-          # raise) — guard finiteness so a non-finite delay can't reach the
-          # renderer's sleep(delay) and raise RangeError.
-          parsed = Float(delay_attr)
-          parsed.finite? ? parsed : nil
-        end
-      rescue ArgumentError, TypeError
-        nil
-      end
+      # server-side wait, in seconds, before the deferred row streams); nil
+      # when absent or unusable.
+      delay = Markers.suspense_delay(node)
+      Flight::SuspenseElement.new(fallback: fallback, children: suspense_children(node), delay: delay)
+    end
 
-      if delay
-        Flight::SuspenseElement.new(fallback: fallback, children: children, delay: delay)
-      else
-        Flight::SuspenseElement.new(fallback: fallback, children: children)
-      end
+    # The content of a Suspense wrapper: its converted children, or — when its
+    # block is rendered later — a reference to that block.
+    def suspense_children(node)
+      block = Markers.suspense_block(node)
+      return Flight::DeferredContent.new(block) if block
+
+      child_nodes = convert_children(node)
+      child_nodes.length == 1 ? child_nodes.first : child_nodes
     end
 
     def convert_children(node)

data/lib/ruact/inline_script.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ruact
+  # Internal — data written inside an inline `<script>` element.
+  #
+  # The Flight payload carries application data (props, record content), so it
+  # is embedded as a JSON string literal with `<`, `>`, `&`, U+2028 and U+2029
+  # escaped as `\uXXXX`. No byte of the payload can then close the `<script>` —
+  # `</SCRIPT>`, `</script >` and `<!--` included — and every character reaches
+  # JavaScript intact.
+  module InlineScript
+    UNSAFE = /[<>&\u2028\u2029]/
+
+    # A JSON string literal for +string+ that is safe inside a `<script>`.
+    # The payload is UTF-8 by construction (the serializer normalizes every
+    # string); a binary-tagged buffer is retagged, not transcoded.
+    def self.string_literal(string)
+      utf8 = string.encoding == Encoding::UTF_8 ? string : string.dup.force_encoding(Encoding::UTF_8)
+      JSON.generate(utf8).gsub(UNSAFE) { |char| format("\\u%04x", char.ord) }
+    end
+  end
+end

data/lib/ruact/load_async_note.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ruact
+  # Story 19-1 (ADR D1) — in development, a `load_async` that cannot run in
+  # the background says so, once per process.
+  #
+  # `load_async` is how a page starts its queries early, so they finish while
+  # the shell is sent. Without `config.active_record.async_query_executor` —
+  # the default of a new Rails app — Active Record has no thread to run the
+  # query in and loads it where `load_async` is called, waiting for it, with no
+  # sign that it did. The note sits in `load_async` itself, not in every
+  # `<Suspense>`: an app that never calls it has nothing to fix.
+  #
+  # The other cases where Rails loads synchronously with the executor set
+  # (inside a transaction, a full queue) are in the guide, not here.
+  module LoadAsyncNote
+    MESSAGE = "[ruact] load_async ran its query where it was called and waited for it: " \
+              "config.active_record.async_query_executor is not set, so Active Record has no thread to run " \
+              "it in. Set `config.active_record.async_query_executor = :global_thread_pool` " \
+              "(config/application.rb) so a page's queries start early and finish while its shell is sent. " \
+              "(Said once.)"
+
+    # Prepended to ActiveRecord::Relation in development by the Railtie.
+    module Relation
+      def load_async
+        LoadAsyncNote.note(::ActiveRecord.async_query_executor)
+        super
+      end
+    end
+
+    # Logs {MESSAGE} the first time it is asked with no executor.
+    #
+    # @param executor [Symbol, nil] `ActiveRecord.async_query_executor`
+    # @return [void]
+    def self.note(executor)
+      return unless executor.nil?
+      return if @noted
+
+      @noted = true
+      Rails.logger&.warn(MESSAGE)
+      nil
+    end
+
+    # Forgets that it logged (specs).
+    #
+    # @api private
+    def self.reset!
+      @noted = false
+    end
+  end
+end

data/lib/ruact/markers.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Ruact
+  # Internal — what an evaluated template leaves in its HTML for
+  # {HtmlConverter} to turn into React elements: the protocol between
+  # evaluating a template and converting it.
+  #
+  # Three markers:
+  #
+  # - a client component: an HTML comment holding the token its
+  #   {RenderContext} entry was registered under — `<!-- __RUACT_0__ -->`;
+  # - a client component with children: an element wrapped around the
+  #   children's HTML — `<ruact-component data-ruact-token="__RUACT_0__">…`;
+  # - a Suspense boundary: an element wrapped around its content, carrying the
+  #   fallback text and the optional delay —
+  #   `<ruact-suspense data-ruact-fallback="Loading…">…</ruact-suspense>`. A
+  #   boundary whose content is rendered later is empty and carries the index
+  #   of its block in the {RenderContext} instead (`data-ruact-block="0"`).
+  #
+  # {ErbPreprocessor} writes the ERB that produces them, the view helpers
+  # ({ViewHelper}, and {RenderPipeline} for a plain-ERB render) write the
+  # component markers, {HtmlConverter} reads all three. None of them spells
+  # these strings itself.
+  module Markers
+    # The element a paired component's content is wrapped in.
+    WRAPPER_TAG = "ruact-component"
+    WRAPPER_CLOSE = "</#{WRAPPER_TAG}>".freeze
+
+    # The element a Suspense boundary's content is wrapped in.
+    SUSPENSE_TAG = "ruact-suspense"
+    SUSPENSE_CLOSE = "</#{SUSPENSE_TAG}>".freeze
+
+    TOKEN_ATTR    = "data-ruact-token"
+    FALLBACK_ATTR = "data-ruact-fallback"
+    DELAY_ATTR    = "data-ruact-delay"
+    BLOCK_ATTR    = "data-ruact-block"
+
+    # The marker for a client component, by its render-context token.
+    def self.component(token)
+      "<!-- #{token} -->"
+    end
+
+    # The opening of a client component with children; {WRAPPER_CLOSE} ends it.
+    def self.component_open(token)
+      %(<#{WRAPPER_TAG} #{TOKEN_ATTR}="#{token}">)
+    end
+
+    # The opening of a Suspense boundary, from the `fallback` and `delay`
+    # attribute values as written in the template. Only `"` is escaped: the
+    # rest of the text stays as the template wrote it (entities included, which
+    # the HTML parser then decodes). The preprocessor refuses ERB in either.
+    # +block+ is the index of the boundary's content in the render context,
+    # when that content is rendered later.
+    def self.suspense_open(fallback, delay, block: nil)
+      delay_attr = delay ? %( #{DELAY_ATTR}="#{delay.gsub('"', '&quot;')}") : ""
+      block_attr = block ? %( #{BLOCK_ATTR}="#{block}") : ""
+      %(<#{SUSPENSE_TAG} #{FALLBACK_ATTR}="#{fallback.gsub('"', '&quot;')}"#{delay_attr}#{block_attr}>)
+    end
+
+    # The token a component marker (an HTML comment node) carries.
+    def self.comment_token(node)
+      node.content.strip
+    end
+
+    # The token a component-with-children wrapper carries.
+    def self.wrapper_token(node)
+      node[TOKEN_ATTR]
+    end
+
+    # The fallback text of a Suspense wrapper ("" when there is none).
+    def self.suspense_fallback(node)
+      node[FALLBACK_ATTR] || ""
+    end
+
+    # The index of the block a Suspense wrapper's content is rendered from
+    # later, or nil when the content is in the wrapper.
+    def self.suspense_block(node)
+      value = node[BLOCK_ATTR]
+      value && Integer(value, 10)
+    end
+
+    # The delay of a Suspense wrapper, in seconds, or nil when it is absent,
+    # blank, unparseable or not finite (`"1e309"` parses to Infinity without
+    # raising, and must not reach a `sleep`).
+    def self.suspense_delay(node)
+      value = node[DELAY_ATTR]
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      parsed = Float(value)
+      parsed.finite? ? parsed : nil
+    rescue ArgumentError, TypeError
+      nil
+    end
+  end
+end

data/lib/ruact/navigation_boundary.rb

@@ -37,7 +37,7 @@ module Ruact
       end
 
       def call(env)
-        return @app.call(env) unless env["HTTP_RUACT_REQUEST"] == "1"
+        return @app.call(env) unless RequestKind.from_router?(env)
         return native_response if @classifier.classify(env) == :native
 
         @app.call(env)
@@ -60,7 +60,7 @@ module Ruact
         headers[HEADER] = NATIVE
         headers["content-type"] = "text/plain; charset=utf-8"
         headers["cache-control"] = "no-store"
-        headers["vary"] = "Ruact-Request"
+        headers["vary"] = RequestKind::ROUTER_HEADER
         headers
       end
     end

data/lib/ruact/railtie.rb

@@ -46,6 +46,18 @@ module Ruact
       app.config.middleware.use Ruact::NavigationBoundary::Middleware
     end
 
+    # Story 19-1 (ADR D1) — in development, a `load_async` that cannot run in
+    # the background says so (Ruact::LoadAsyncNote). Nothing in production, and
+    # nothing at all without Active Record.
+    initializer "ruact.load_async_note" do
+      next unless Rails.env.development?
+
+      ActiveSupport.on_load(:active_record) do
+        require_relative "load_async_note"
+        ActiveRecord::Relation.prepend(Ruact::LoadAsyncNote::Relation)
+      end
+    end
+
     rake_tasks { load File.expand_path("../tasks/ruact.rake", __dir__) }
 
     # Load the client manifest at boot (and on each code reload in development).

data/lib/ruact/render_context.rb

@@ -2,8 +2,10 @@
 
 module Ruact
   # Per-render mutable state holding the components encountered during ERB
-  # evaluation. One instance is allocated by the controller per render, passed
-  # explicitly through the pipeline, and discarded when the response is sent.
+  # evaluation, and — in an action that streams — the `<Suspense>` blocks whose
+  # content is rendered after the shell is sent. One instance is allocated by
+  # the controller per render, passed explicitly through the pipeline, and
+  # discarded when the response is sent.
   #
   # No shared state, no thread-local lookup — the instance lives only as long
   # as the render call. Satisfies NFR8 and the `Ruact/NoSharedState` cop with
@@ -11,20 +13,73 @@ module Ruact
   #
   # Internal API: not part of the public compatibility contract.
   class RenderContext
-    def initialize
+    # A `<Suspense>` block waiting to be rendered: the view it was written in,
+    # the block, and the template Rails was rendering when it met the tag
+    # (`t(".key")` and error messages read it).
+    Block = Struct.new(:view, :block, :virtual_path, :template, :location)
+
+    # @param deferring [Boolean] whether a `<Suspense>`'s content is rendered
+    #   after the shell (an action that streams) instead of in place
+    def initialize(deferring: false)
       @components = []
+      @deferring  = deferring
+      @blocks     = []
     end
 
     attr_reader :components
 
+    # Whether a `<Suspense>`'s content is rendered after the shell.
+    def deferring?
+      @deferring
+    end
+
     def register(name, props)
-      token = "__RUACT_#{@components.length}__"
+      # Frozen: the converter keys a Hash by it, which would copy an unfrozen one.
+      token = "__RUACT_#{@components.length}__".freeze
       @components << { token: token, name: name, props: props }
       token
     end
 
-    def by_token(token)
-      @components.find { |c| c[:token] == token }
+    # Keeps a `<Suspense>` block for later and returns its index.
+    #
+    # @param block [Block]
+    # @return [Integer]
+    def defer_block(block)
+      @blocks << block
+      @blocks.length - 1
+    end
+
+    # The block registered under +index+.
+    #
+    # @return [Block]
+    def block(index)
+      @blocks.fetch(index)
+    end
+
+    # Whether the development message for a `<Suspense>` in an action that
+    # does not stream was given in this render: once per response.
+    def unstreamed_suspense_noted?
+      @unstreamed_suspense_noted == true
+    end
+
+    def note_unstreamed_suspense!
+      @unstreamed_suspense_noted = true
+    end
+
+    # The registered components with the client reference +manifest+ gives
+    # each, in the shape {HtmlConverter} reads:
+    # `[{ token:, name:, ref:, props: }, ...]`. Raises what the manifest raises
+    # for a component it does not have. +from+ skips the first components (the
+    # ones a previous call resolved).
+    def resolve(manifest, controller_path: nil, from: 0)
+      entries = from.zero? ? @components : @components.drop(from)
+      entries.map { |entry| resolve_entry(entry, manifest, controller_path: controller_path) }
+    end
+
+    # One registered component, resolved as {#resolve} does.
+    def resolve_entry(entry, manifest, controller_path: nil)
+      ref = manifest.reference_for(entry[:name], controller_path: controller_path)
+      { token: entry[:token], name: entry[:name], ref: ref, props: entry[:props] }
     end
   end
 end

data/lib/ruact/render_pipeline.rb

@@ -55,6 +55,8 @@ module Ruact
     #   - `:erb` or `:html` is not a `String`,
     #   - `input` contains extra keys beyond the documented shapes,
     #   - `mode` is not in {VALID_MODES}.
+    #   - (`:erb` input) the template holds a `<Suspense>`: its content is a block only ActionView
+    #     renders. Raised when the Enumerator is consumed.
     #   All `ArgumentError` messages name the offending input and reference
     #   `RenderPipeline#render` for the canonical contract.
     #
@@ -72,6 +74,20 @@ module Ruact
       mode == :string ? enum.to_a.join : enum
     end
 
+    # What the render reads — for a {DeferredRender} built on it.
+    attr_reader :manifest, :controller_path, :logger, :development
+
+    # The warning for a value serialized through `as_json`, logged; nil without
+    # a logger.
+    def as_json_warning_callback
+      return nil if @logger.nil?
+
+      lambda do |class_name, attrs|
+        @logger.warn("[ruact] WARNING: #{class_name} serialized via as_json — ALL attributes exposed to client: " \
+                     "#{attrs}. Use `include Ruact::Serializable` with `ruact_props` for explicit control")
+      end
+    end
+
     private
 
     ALLOWED_INPUT_KEYS = %i[erb binding html render_context].freeze
@@ -142,6 +158,16 @@ module Ruact
             "ruact: render input :binding must be a Binding; got #{bnd.class} (#{DOCSTRING_REF})"
     end
 
+    # A `<Suspense>`'s content is the body of a helper block, and only
+    # ActionView's `capture` renders one.
+    def refuse_suspense!(transformed)
+      return unless transformed.include?("__ruact_suspense__(")
+
+      raise ArgumentError,
+            "ruact: render input :erb cannot hold a <Suspense>: its content is a block, which only " \
+            "ActionView's `capture` can render. Render the template through ActionView (#{DOCSTRING_REF})"
+    end
+
     def validate_html_shape!(input)
       html = input[:html]
       unless html.is_a?(String)
@@ -179,6 +205,7 @@ module Ruact
         # so passing nil is byte-for-byte equivalent while avoiding any dev HTTP
         # fetch / test-double dispatch inside callers that measure this path.
         transformed    = ErbPreprocessor.transform(erb_source, registry: nil)
+        refuse_suspense!(transformed)
         receiver       = binding_context.eval("self")
         prev_ctx       = receiver.instance_variable_get(:@__ruact_render_context__)
         inject_helper!(binding_context, render_context)
@@ -189,11 +216,7 @@ module Ruact
             receiver.instance_variable_set(:@__ruact_render_context__, prev_ctx)
           end
 
-        registry = render_context.components.map do |entry|
-          ref = @manifest.reference_for(entry[:name], controller_path: @controller_path)
-          { token: entry[:token], name: entry[:name], ref: ref, props: entry[:props] }
-        end
-
+        registry = render_context.resolve(@manifest, controller_path: @controller_path)
         root_element = HtmlConverter.convert(html, registry)
 
         Flight::Renderer.each(root_element, @manifest,
@@ -209,10 +232,7 @@ module Ruact
     # the caller may discard the RenderContext immediately after `render` returns — the
     # returned Enumerator does not reference the RenderContext.
     def render_html_enum(html, render_context, streaming:)
-      registry = render_context.components.map do |entry|
-        ref = @manifest.reference_for(entry[:name], controller_path: @controller_path)
-        { token: entry[:token], name: entry[:name], ref: ref, props: entry[:props] }
-      end
+      registry = render_context.resolve(@manifest, controller_path: @controller_path)
       strict     = Ruact.config.strict_serialization
       warning_cb = as_json_warning_callback
 
@@ -226,18 +246,6 @@ module Ruact
       end
     end
 
-    def as_json_warning_callback
-      return nil if @logger.nil?
-
-      lambda do |class_name, attrs|
-        @logger.warn(
-          "[ruact] WARNING: #{class_name} serialized via as_json — " \
-          "ALL attributes exposed to client: #{attrs}. " \
-          "Use `include Ruact::Serializable` with `ruact_props` for explicit control"
-        )
-      end
-    end
-
     # Install __ruact_component__ on the binding's receiver and stash the active
     # render context on the receiver as @__ruact_render_context__. The singleton
     # method reads the ivar dynamically, so nested renders sharing the same

data/lib/ruact/request_kind.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ruact
+  # Internal — how a request says what it wants from ruact. Two questions, with
+  # different answers on purpose:
+  #
+  # - {.flight?} — does the client want a Flight body back rather than an HTML
+  #   document? Either header says so: `Accept: text/x-component` (any Flight
+  #   client) or `Ruact-Request: 1` (ruact's router, which sends both).
+  # - {.from_router?} — did ruact's own router send it? Only `Ruact-Request: 1`
+  #   says that; {NavigationBoundary} answers router navigations to pages that
+  #   are not ruact's, and must not answer anyone else.
+  module RequestKind
+    # The Flight media type, as requested and as answered.
+    FLIGHT_MIME = "text/x-component"
+    # The header ruact's router adds to every request it makes.
+    ROUTER_HEADER = "Ruact-Request"
+    ROUTER_ENV = "HTTP_RUACT_REQUEST"
+
+    # @param request [ActionDispatch::Request]
+    def self.flight?(request)
+      request.headers["Accept"]&.include?(FLIGHT_MIME) || request.headers[ROUTER_HEADER] == "1"
+    end
+
+    # @param env [Hash] the Rack env (it runs before Rails builds a request)
+    def self.from_router?(env)
+      env[ROUTER_ENV] == "1"
+    end
+
+    # Which header made {.flight?} true, as the request sent it — for a log
+    # line that names it.
+    def self.flight_signal(request)
+      request.headers["Accept"].to_s.include?(FLIGHT_MIME) ? "Accept: #{FLIGHT_MIME}" : "#{ROUTER_HEADER}: 1"
+    end
+  end
+end

data/lib/ruact/server.rb

@@ -407,7 +407,7 @@ module Ruact
     # Classify the negotiated response shape from the request signals
     # (`__ruact_function_call?`, Accept, verb) and the ruact-owned outcome flags
     # (`@__ruact_function_redirect` set by the Bucket-2 {#redirect_to};
-    # `@__ruact_negotiated_page` set by {Ruact::Controller#emit_ruact_response} /
+    # `@__ruact_negotiated_page` set by {Ruact::Controller::Delivery#emit_ruact_response} /
     # its Flight `redirect_to`). Returns nil when ruact did not negotiate the
     # response, so the log stays silent on plain Rails actions.
     #
@@ -441,7 +441,7 @@ module Ruact
     end
 
     # The page-render (Bucket-1 / HTML-shell) shape, keyed on the flag
-    # {Ruact::Controller#emit_ruact_response} set when ruact rendered the page.
+    # {Ruact::Controller::Delivery#emit_ruact_response} set when ruact rendered the page.
     # nil for a plain Rails render (the flag was never set) → the log stays
     # silent on a non-negotiated response.
     def __ruact_page_shape_and_signal
@@ -458,11 +458,7 @@ module Ruact
     # The Flight deciding signal, faithful to how the request announced itself:
     # the `Accept: text/x-component` header, or the `Ruact-Request: 1` header.
     def __ruact_flight_signal
-      if request.headers["Accept"].to_s.include?("text/x-component")
-        "Accept: text/x-component"
-      else
-        "Ruact-Request: 1"
-      end
+      RequestKind.flight_signal(request)
     end
 
     # @return [Boolean] true only in a real Rails development environment

data/lib/ruact/testing/flight_extractor.rb

@@ -15,7 +15,8 @@ module Ruact
     #
     #   1. a raw `text/x-component` body (RSC/navigation request), OR
     #   2. a full HTML document embedding the payload in the `__FLIGHT_DATA`
-    #      bootstrap `<script>` (a plain browser GET).
+    #      bootstrap `<script>` (a plain browser GET) — and, in a page that
+    #      streams, in the script each `<Suspense>`'s rows are pushed in.
     #
     # A `Ruact::Server` function-call/query answer is plain JSON, not Flight —
     # feeding it here raises {NotAFlightResponseError} pointing at `JSON.parse`,
@@ -36,6 +37,16 @@ module Ruact
         \)\s*;
       /mx
 
+      # Story 19-1 — in a page that streams, each `<Suspense>`'s rows arrive
+      # later, in a script of their own pushed onto the same queue
+      # (`Ruact::Controller::Delivery#__ruact_flight_push`). Read after the
+      # bootstrap script, in document order.
+      STREAMED_PUSH = /
+        \(self\.__FLIGHT_DATA=self\.__FLIGHT_DATA\|\|\[\]\)\.push\(
+        (?<literal>"(?:\\.|[^"\\])*")
+        \)
+      /x
+
       # A Flight wire body always starts with a row header: `<hex>:` (id + colon)
       # or a hint row `:H`. JSON bodies start with `{`/`[`/`"`; HTML with `<`.
       FLIGHT_ROW_START = /\A\s*(?:\h+:|:H)/
@@ -133,9 +144,15 @@ module Ruact
                   "This response did not render a ruact component (no Flight data was inlined)."
           end
 
-          literal = match[:literal]
-          # The literal is JSON (ruact >= 0.0.15). The Ruby-literal decoder stays
-          # for documents captured from earlier versions.
+          # The streamed pushes are JSON literals ({InlineScript}), written
+          # after the bootstrap script.
+          later = html[match.end(0)..].scan(STREAMED_PUSH).map { |(streamed)| JSON.parse(streamed) }
+          decode_literal(match[:literal]) + later.join
+        end
+
+        # The literal is JSON (ruact >= 0.0.15). The Ruby-literal decoder stays
+        # for documents captured from earlier versions.
+        def decode_literal(literal)
           JSON.parse(literal)
         rescue JSON::ParserError
           decode_ruby_string_literal(literal)

data/lib/ruact/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruact
-  VERSION = "0.0.19"
+  VERSION = "0.0.20"
 end