ruact 0.0.20 → 0.0.22

data/lib/ruact/query_watch.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Ruact
+  # Story 19-2 (AC14) — when a `<Suspense>` runs past `suspense_timeout` with a
+  # query in flight, that query is cancelled on the database server.
+  #
+  # `Timeout` gives the block back at the limit, but a query the driver is
+  # waiting on keeps running on the server, and the connection stays busy with
+  # it: the next query on it — this response's, or the next request's once the
+  # connection is back in the pool — waits for it to end (measured with
+  # PostgreSQL: seconds). Inside a transaction even the unwinding waits, at its
+  # ROLLBACK. So at the limit the queries in flight on the connections the
+  # block's thread holds — or that it already gave back — are cancelled, from
+  # another thread if the block is stuck; the connection is free again within
+  # milliseconds.
+  #
+  # PostgreSQL only: `PG::Connection#cancel` is libpq's PQcancel, made to be
+  # called from another thread. Other adapters are left as they are; the
+  # database's own statement timeout is the limit there.
+  #
+  # Not cancelled: a query `load_async` runs. The async executor's thread holds
+  # its connection, not the block's, and nothing ties that query to the block
+  # that waits for it; it runs to its end. The statement timeout is the limit
+  # for those.
+  #
+  # Internal API: not part of the public compatibility contract.
+  class QueryWatch
+    # Who holds a connection the way Active Record records it: the thread, or
+    # the fiber under `isolation_level = :fiber`.
+    def self.current_owner
+      ::ActiveSupport::IsolatedExecutionState.context
+    end
+
+    # Watches +owner+'s connections for +limit+ seconds; nil when there is
+    # nothing to watch (no Active Record).
+    def self.start(owner, limit)
+      return nil unless defined?(::ActiveRecord::Base) && defined?(::PG::Connection)
+
+      new(owner, limit)
+    end
+
+    def initialize(owner, limit)
+      @lock = Mutex.new
+      @done = false
+      @cancelled = false
+      @watcher = Thread.new do
+        sleep(limit)
+        @lock.synchronize { cancel_queries_of(owner) unless @done }
+      end
+    end
+
+    # The block ran past the limit and was given back: cancel what its owner
+    # still has in flight now, whether or not the watcher got there first.
+    def cancel_now(owner)
+      @lock.synchronize { cancel_queries_of(owner) }
+    end
+
+    # Whether a query was cancelled: the error the block then raises
+    # (`ActiveRecord::QueryCanceled`) is the timeout's, not the content's. The
+    # watcher can get there before `Timeout` does.
+    def cancelled?
+      @cancelled
+    end
+
+    # The block ended (or was ended): nothing to cancel any more. Does not wait
+    # for a cancel under way, which opens a connection to the database.
+    def stop
+      @done = true
+      @watcher.kill
+    end
+
+    private
+
+    # The queries are found under each pool's lock and cancelled outside it: a
+    # cancel opens a connection to the database, and the pool's lock is every
+    # thread's checkout. A connection nobody holds could be handed to another
+    # request in between and have that request's query cancelled; the window
+    # is the time a cancel takes to reach the server, on the timeout path only.
+    def cancel_queries_of(owner)
+      in_flight(owner).each do |raw|
+        raw.cancel
+        @cancelled = true
+      rescue StandardError
+        nil
+      end
+    end
+
+    def in_flight(owner)
+      ::ActiveRecord::Base.connection_handler.connection_pool_list(:all).flat_map do |pool|
+        pool.synchronize { pool.connections.filter_map { |connection| query_of(connection, owner) } }
+      rescue StandardError
+        []
+      end
+    end
+
+    # The owner's own connection, or one already back in the pool: unwinding a
+    # `with_connection` gives the connection back with its query still running.
+    # A query in flight on a connection nobody holds is one nobody waits for.
+    def query_of(connection, owner)
+      return unless connection.owner.nil? || connection.owner.equal?(owner)
+
+      raw = connection.instance_variable_get(:@raw_connection)
+      raw if raw.is_a?(::PG::Connection) && raw.transaction_status == ::PG::PQTRANS_ACTIVE
+    end
+  end
+end

data/lib/ruact/railtie.rb

@@ -80,6 +80,7 @@ module Ruact
 
       if manifest_path.exist?
         Ruact.manifest = Ruact::ClientManifest.load(manifest_path)
+        Ruact::Railtie.note_build_skew!(Ruact.manifest)
       else
         Ruact::Railtie.check_manifest!(manifest_path)
       end
@@ -209,6 +210,19 @@ module Ruact
       false
     end
 
+    # Story 19-3 — the built JavaScript is another ruact's: one error line in
+    # the log, in every environment, once per process for each version the
+    # build recorded (`to_prepare` runs again on every reload in development).
+    # It does not stop the boot: pages without a `<Suspense>` that streams may
+    # well work, and stopping was not decided.
+    #
+    # @param manifest [Ruact::ClientManifest]
+    # @return [void]
+    def self.note_build_skew!(manifest)
+      Ruact::BuildSkew.note(manifest.build_version, logger: Rails.logger, level: :error)
+      nil
+    end
+
     # Checks whether the manifest exists and either warns (dev) or raises (prod).
     # Extracted as a class method for direct testability without a full Rails app.
     def self.check_manifest!(manifest_path)

data/lib/ruact/render_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Ruact
   # Per-render mutable state holding the components encountered during ERB
   # evaluation, and — in an action that streams — the `<Suspense>` blocks whose
@@ -14,13 +16,19 @@ module Ruact
   # Internal API: not part of the public compatibility contract.
   class RenderContext
     # 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)
+    # the block, the template Rails was rendering when it met the tag
+    # (`t(".key")` and error messages read it), and the local variables the
+    # block can see, as they were then (Story 19-2: a `for` loop reuses one
+    # variable, a local can be reassigned below the tag).
+    Block = Struct.new(:view, :block, :virtual_path, :template, :location, :locals)
 
     # @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)
+      # Story 19-2 — every marker this render writes carries it, so a marker a
+      # `cache` block stored in another render never passes for one of this
+      # render's: it would name another component, or another boundary's block.
+      @id = SecureRandom.hex(4)
       @components = []
       @deferring  = deferring
       @blocks     = []
@@ -35,25 +43,29 @@ module Ruact
 
     def register(name, props)
       # Frozen: the converter keys a Hash by it, which would copy an unfrozen one.
-      token = "__RUACT_#{@components.length}__".freeze
+      token = "__RUACT_#{@id}_#{@components.length}__".freeze
       @components << { token: token, name: name, props: props }
       token
     end
 
-    # Keeps a `<Suspense>` block for later and returns its index.
+    # Keeps a `<Suspense>` block for later and returns its key.
     #
     # @param block [Block]
-    # @return [Integer]
+    # @return [String]
     def defer_block(block)
       @blocks << block
-      @blocks.length - 1
+      "#{@id}-#{@blocks.length - 1}".freeze
     end
 
-    # The block registered under +index+.
+    # The block registered under +key+, or nil when the key is not this
+    # render's — a marker that came out of a `cache` block another render wrote.
     #
-    # @return [Block]
-    def block(index)
-      @blocks.fetch(index)
+    # @return [Block, nil]
+    def block(key)
+      id, index = key.to_s.split("-", 2)
+      return nil unless id == @id && index.to_s.match?(/\A\d+\z/)
+
+      @blocks[Integer(index, 10)]
     end
 
     # Whether the development message for a `<Suspense>` in an action that

data/lib/ruact/render_pipeline.rb

@@ -66,7 +66,8 @@ module Ruact
     #
     # @example Pre-rendered HTML, streaming output
     #   ctx = Ruact::RenderContext.new
-    #   pipeline.render({ html: "<!-- __RUACT_0__ -->", render_context: ctx }, mode: :stream)
+    #   html = Ruact::Markers.component(ctx.register("NavBar", {}))
+    #   pipeline.render({ html: html, render_context: ctx }, mode: :stream)
     #   # => #<Enumerator: ...>  (yields Flight rows lazily)
     def render(input, mode: :string)
       validate_mode!(mode)
@@ -232,6 +233,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:)
+      CachedBlocks.report(html, @logger) unless render_context.deferring?
       registry = render_context.resolve(@manifest, controller_path: @controller_path)
       strict     = Ruact.config.strict_serialization
       warning_cb = as_json_warning_callback

data/lib/ruact/version.rb

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

data/lib/ruact/view_helper/suspense.rb

@@ -21,7 +21,7 @@ module Ruact
         ctx = @ruact_render_context
         if ctx&.deferring?
           index = ctx.defer_block(RenderContext::Block.new(self, block, @virtual_path, @current_template,
-                                                           caller_locations(1, 1).first))
+                                                           caller_locations(1, 1).first, __ruact_locals(block)))
           return "#{Markers.suspense_open(fallback, delay, block: index)}#{Markers::SUSPENSE_CLOSE}".html_safe
         end
 
@@ -33,6 +33,14 @@ module Ruact
         "#{Markers.suspense_open(fallback, delay)}#{content}#{Markers::SUSPENSE_CLOSE}".html_safe
       end
 
+      # Story 19-2 (AC8.3) — the local variables +block+ sees, as they are when
+      # the tag is met. The block runs later; without these it would see a local
+      # as it is then — the last item of a `for` loop, a value reassigned below.
+      def __ruact_locals(block)
+        scope = block.binding
+        scope.local_variables.to_h { |name| [name, scope.local_variable_get(name)] }
+      end
+
       # Story 19-1 — a `<Suspense>` in an action that does not stream renders its
       # content before the page is sent, as it always did. Development says so,
       # once per response, with the line that makes the action stream.
@@ -56,7 +64,7 @@ module Ruact
         )
       end
 
-      private :__ruact_note_unstreamed_suspense
+      private :__ruact_note_unstreamed_suspense, :__ruact_locals
     end
   end
 end

data/lib/ruact/view_helper.rb

@@ -235,7 +235,7 @@ module Ruact
     # `</script>`, and its `\e`-style escapes mean something else in JS).
     def ruact_flight_data_script(flight_payload)
       <<~HTML.strip
-        <script>
+        <script#{__ruact_nonce_attr}>
           (function() {
             var d = (self.__FLIGHT_DATA = self.__FLIGHT_DATA || []);
             d.push(#{InlineScript.string_literal(flight_payload)});
@@ -244,6 +244,16 @@ module Ruact
       HTML
     end
 
+    # Story 19-2 (AC21) — the request's CSP nonce as a `<script>` attribute, so
+    # an app whose policy allows scripts by nonce (no `'unsafe-inline'`) runs
+    # the ones ruact writes. Empty without a nonce generator: the bytes are
+    # those of before.
+    def __ruact_nonce_attr
+      source = respond_to?(:request, true) ? request : nil
+      nonce = source.content_security_policy_nonce if source.respond_to?(:content_security_policy_nonce)
+      nonce ? %( nonce="#{ERB::Util.html_escape(nonce)}") : ""
+    end
+
     # The bootstrap entry `<script>` tags — dev serves the virtual module from
     # the Vite dev server (with the react-refresh preamble + `@vite/client`);
     # prod reads the hashed URL from the Vite manifest. Both target the SAME
@@ -255,35 +265,51 @@ module Ruact
     # never show. The bootstrap then reads the rows the document pushes while
     # it is still open.
     def ruact_vite_tags
-      if Rails.env.development? && vite_dev_running?
-        # @vitejs/plugin-react normally injects this preamble by processing index.html.
-        # Since our HTML is generated by Rails (not Vite), we inject it manually.
-        # Without it, every JSX file throws "can't detect preamble" at runtime.
-        # One async module, so the preamble still runs before any component
-        # module: it installs the preamble, then imports the client and the
-        # bootstrap, in that order.
-        dev_server = Ruact.config.vite_dev_server.chomp("/")
-        <<~HTML
-          <script type="module" async>
-            import RefreshRuntime from '#{dev_server}/@react-refresh';
-            RefreshRuntime.injectIntoGlobalHook(window);
-            window.$RefreshReg$ = () => {};
-            window.$RefreshSig$ = () => (type) => type;
-            window.__vite_plugin_react_preamble_installed__ = true;
-            await import('#{dev_server}/@vite/client');
-            await import('#{ruact_bootstrap_dev_url}');
-          </script>
-        HTML
-      else
-        # Production: read the hashed URL from the Vite manifest, keyed on the
-        # virtual entry id (the manifest key Vite emits for the virtual input).
-        entry = vite_manifest_entry(Ruact.bootstrap_virtual_id)
-        src   = entry ? "/assets/#{entry['file']}" : "/assets/application.js"
-        tag   = %(<script type="module" async src="#{src}"></script>)
-        # Story 17-0k — in development with neither the Vite dev server nor a
-        # build, that script 404s and the page stays empty with no error.
-        Rails.env.development? && entry.nil? ? "#{ruact_vite_down_warning}\n#{tag}" : tag
-      end
+      return ruact_build_skew_warning + ruact_vite_dev_tags if Rails.env.development? && vite_dev_running?
+
+      # Production: read the hashed URL from the Vite manifest, keyed on the
+      # virtual entry id (the manifest key Vite emits for the virtual input).
+      entry = vite_manifest_entry(Ruact.bootstrap_virtual_id)
+      src   = entry ? "/assets/#{entry['file']}" : "/assets/application.js"
+      tag   = %(<script type="module" async src="#{src}"#{__ruact_nonce_attr}></script>)
+      return tag unless Rails.env.development?
+
+      # Story 17-0k — in development with neither the Vite dev server nor a
+      # build, that script 404s and the page stays empty with no error. The
+      # component manifest on disk then describes no JavaScript the page runs:
+      # no word of its version (Story 19-3).
+      entry.nil? ? "#{ruact_vite_down_warning}\n#{tag}" : ruact_build_skew_warning + tag
+    end
+
+    # The development entry: the react-refresh preamble, `@vite/client`, then
+    # the bootstrap, from the Vite dev server.
+    def ruact_vite_dev_tags
+      # @vitejs/plugin-react normally injects this preamble by processing index.html.
+      # Since our HTML is generated by Rails (not Vite), we inject it manually.
+      # Without it, every JSX file throws "can't detect preamble" at runtime.
+      # One async module, so the preamble still runs before any component
+      # module: it installs the preamble, then imports the client and the
+      # bootstrap, in that order.
+      dev_server = Ruact.config.vite_dev_server.chomp("/")
+      <<~HTML
+        <script type="module" async#{__ruact_nonce_attr}>
+          import RefreshRuntime from '#{dev_server}/@react-refresh';
+          RefreshRuntime.injectIntoGlobalHook(window);
+          window.$RefreshReg$ = () => {};
+          window.$RefreshSig$ = () => (type) => type;
+          window.__vite_plugin_react_preamble_installed__ = true;
+          await import('#{dev_server}/@vite/client');
+          await import('#{ruact_bootstrap_dev_url}');
+        </script>
+      HTML
+    end
+
+    # Story 19-3 — the page's JavaScript was built by another ruact: the
+    # message the controller kept for this render, on the page
+    # ({Ruact::BuildSkew.banner}). Empty on a page no ruact render produced.
+    def ruact_build_skew_warning
+      message = instance_variable_defined?(:@ruact_build_skew) ? @ruact_build_skew : nil
+      message ? BuildSkew.banner(message) : ""
     end
 
     # Story 17-0k — `bin/rails server` on its own, once Vite has run before:

data/lib/ruact.rb

@@ -18,8 +18,12 @@ require_relative "ruact/render_context"
 require_relative "ruact/html_converter"
 require_relative "ruact/client_manifest"
 require_relative "ruact/manifest_resolver"
+require_relative "ruact/build_skew"
 require_relative "ruact/render_pipeline"
 require_relative "ruact/deferred_render"
+require_relative "ruact/cached_blocks"
+require_relative "ruact/query_watch"
+require_relative "ruact/declared_content"
 require_relative "ruact/view_helper"
 require_relative "ruact/erb_preprocessor_hook"
 require_relative "ruact/server_functions"
@@ -58,8 +62,10 @@ module Ruact
     end
 
     # Returns the absolute path to the Vite plugin bundled inside this gem.
-    # Use this in vite.config.js: import ruact from '<%= Ruact.vite_plugin_path %>'
-    # Re-run `rails generate ruact:install` after gem upgrades to refresh the path.
+    # The vite.config.js `rails generate ruact:install` writes asks for it
+    # through Bundler each time Vite starts (Story 19.4) —
+    # `bundle exec ruby -e "require 'ruact'; print Ruact.vite_plugin_path"` —
+    # so after `bundle update ruact` the next build uses the new gem's plugin.
     #
     # @return [String] absolute path to vendor/javascript/vite-plugin-ruact/index.js
     def vite_plugin_path

data/vendor/javascript/vite-plugin-ruact/build-version.test.mjs

@@ -0,0 +1,101 @@
+// Story 19-3 — the manifest says which ruact built it. Every manifest the
+// plugin writes or serves (the build, the dev server's file, its
+// GET /__ruact/manifest) carries `__ruact__: { version }`, the gem's version read
+// from `lib/ruact/version.rb` beside the plugin; the in-memory manifest the
+// registry is generated from never does.
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import ruact, { BUILD_KEY, readRuactVersion, withBuild, buildManifest, generateRegistrySource } from "./index.js";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const GEM_VERSION = fs
+  .readFileSync(path.resolve(here, "../../../lib/ruact/version.rb"), "utf8")
+  .match(/VERSION = "([^"]+)"/)[1];
+
+let dir;
+beforeEach(() => {
+  dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "ruact-build-version-")));
+  const file = path.join(dir, "app/javascript/components/LikeButton.jsx");
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `"use client";\nexport function LikeButton() { return null; }\n`);
+});
+afterEach(() => fs.rmSync(dir, { recursive: true, force: true }));
+
+function server() {
+  const middlewares = new Map();
+  const handlers = {};
+  return {
+    middlewares: { use: (route, fn) => middlewares.set(route, fn) },
+    moduleGraph: { getModuleById: () => null, invalidateModule: () => {} },
+    ws: { send: () => {} },
+    watcher: { add: () => {}, on: (event, fn) => (handlers[event] ||= []).push(fn) },
+    get(route) {
+      let body = "";
+      middlewares.get(route)({ url: route, method: "GET" }, { setHeader: () => {}, end: (b) => (body = b) }, () => {});
+      return JSON.parse(body);
+    },
+    change(file) {
+      for (const fn of handlers.change) fn(file);
+    },
+  };
+}
+
+async function boot() {
+  const warnings = [];
+  const plugin = ruact();
+  await plugin.configResolved({ root: dir, logger: { info: () => {}, warn: (m) => warnings.push(m) } });
+  await plugin.buildStart({});
+  const dev = server();
+  await plugin.configureServer(dev);
+  return { dev, warnings };
+}
+
+const written = () => JSON.parse(fs.readFileSync(path.join(dir, "public/react-client-manifest.json"), "utf8"));
+
+describe("the build's version in the manifest (Story 19-3)", () => {
+  it("reads the gem's version from lib/ruact/version.rb", () => {
+    expect(readRuactVersion()).toBe(GEM_VERSION);
+  });
+
+  it("is null for a plugin that is not inside a gem", () => {
+    expect(readRuactVersion(path.join(dir, "lib/ruact/version.rb"))).toBeNull();
+    fs.mkdirSync(path.join(dir, "lib/ruact"), { recursive: true });
+    fs.writeFileSync(path.join(dir, "lib/ruact/version.rb"), "module Ruact; end\n");
+    expect(readRuactVersion(path.join(dir, "lib/ruact/version.rb"))).toBeNull();
+  });
+
+  it("the file buildStart writes carries it first", async () => {
+    const { warnings } = await boot();
+    const manifest = written();
+    expect(Object.keys(manifest)).toEqual([BUILD_KEY, "LikeButton"]);
+    expect(manifest[BUILD_KEY]).toEqual({ version: GEM_VERSION });
+    expect(warnings).toEqual([]);
+  });
+
+  it("GET /__ruact/manifest carries it, and the file the watcher rewrites does too", async () => {
+    const { dev } = await boot();
+    expect(dev.get("/__ruact/manifest")[BUILD_KEY]).toEqual({ version: GEM_VERSION });
+
+    const added = path.join(dir, "app/javascript/components/CommentBox.jsx");
+    fs.writeFileSync(added, `"use client";\nexport function CommentBox() { return null; }\n`);
+    dev.change(added);
+    expect(Object.keys(written())).toEqual([BUILD_KEY, "CommentBox", "LikeButton"]);
+    expect(Object.keys(dev.get("/__ruact/manifest"))).toEqual([BUILD_KEY, "CommentBox", "LikeButton"]);
+  });
+
+  it("never reaches the registry", () => {
+    const manifest = buildManifest(path.join(dir, "app/javascript/components"));
+    expect(manifest).not.toHaveProperty(BUILD_KEY);
+    expect(generateRegistrySource(manifest)).not.toContain(BUILD_KEY);
+  });
+
+  it("without a version, the manifest is the components only", () => {
+    const manifest = { LikeButton: { id: "/LikeButton.jsx", name: "LikeButton", chunks: [] } };
+    expect(withBuild(manifest, null)).toBe(manifest);
+    expect(Object.keys(withBuild(manifest, "1.2.3"))).toEqual([BUILD_KEY, "LikeButton"]);
+  });
+});

data/vendor/javascript/vite-plugin-ruact/index.js

@@ -69,6 +69,33 @@ const RESOLVED_BOOTSTRAP_ID = "\0" + BOOTSTRAP_VIRTUAL_ID;
 // point at the gem copy, regardless of the app's cwd.
 const RUNTIME_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "runtime");
 
+// Story 19-3 — the build says which ruact built it. The plugin ships inside the
+// gem (`<gem>/vendor/javascript/vite-plugin-ruact/`), so the gem's version is
+// `<gem>/lib/ruact/version.rb`, the one file `bin/release` writes. The manifest
+// carries it under a key no component can have (a component's is PascalCase or
+// `folder/_snake`); the server compares it with its own and says so loudly when
+// the page's JavaScript is another release's.
+export const BUILD_KEY = "__ruact__";
+const GEM_VERSION_FILE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../lib/ruact/version.rb");
+
+// The gem version beside this plugin, or null when the plugin is not inside a
+// gem (a copy elsewhere): the manifest then records none, and the server takes
+// the build for an older release's, which is what it is told to warn about.
+export function readRuactVersion(file = GEM_VERSION_FILE) {
+  try {
+    return fs.readFileSync(file, "utf8").match(/VERSION = "([^"]+)"/)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// The manifest as written and served: the build's record first, then the
+// components. The in-memory manifest never holds it — the registry and the
+// build's chunk matching iterate the components only.
+export function withBuild(manifest, version) {
+  return version ? { [BUILD_KEY]: { version }, ...manifest } : manifest;
+}
+
 export default function ruact(options = {}) {
   const {
     componentsDir = "app/javascript/components",
@@ -78,6 +105,7 @@ export default function ruact(options = {}) {
   let root;
   let manifest = {};
   let flightClient; // { source: "app" | "vendored", version, mode }
+  let ruactVersion = null;
 
   return installServerFunctionsHooks({
     name: "vite-plugin-ruact",
@@ -94,6 +122,13 @@ export default function ruact(options = {}) {
       flightClient = resolveFlightClient(root, config.isProduction ? "production" : "development");
       // Dev server and build alike, so a build log shows it too.
       config.logger?.info?.(`[ruact] Flight client: ${describeFlightClient(flightClient)}`);
+      ruactVersion = readRuactVersion();
+      if (!ruactVersion) {
+        config.logger?.warn?.(
+          `[ruact] could not read the ruact version from ${GEM_VERSION_FILE}: the manifest will not say which ` +
+            "ruact built it, and the server will warn that this build is another release's.",
+        );
+      }
     },
 
     // Story 10.1b / 14.2 — resolve ruact's virtual module ids.
@@ -121,7 +156,7 @@ export default function ruact(options = {}) {
     // During dev: build the manifest from source files
     buildStart() {
       manifest = buildManifest(path.resolve(root, componentsDir));
-      writeManifest(path.resolve(root, manifestOutput), manifest);
+      writeManifest(path.resolve(root, manifestOutput), withBuild(manifest, ruactVersion));
     },
 
     // During build: update with hashed chunk URLs from the bundle
@@ -180,7 +215,7 @@ export default function ruact(options = {}) {
         delete entry._sourceFile;
       }
 
-      writeManifest(path.resolve(root, manifestOutput), final);
+      writeManifest(path.resolve(root, manifestOutput), withBuild(final, ruactVersion));
     },
 
     // Dev server: watch components dir and rebuild manifest on change. Story
@@ -207,13 +242,13 @@ export default function ruact(options = {}) {
           out[name] = rest;
         }
         res.setHeader("Content-Type", "application/json");
-        res.end(JSON.stringify(out));
+        res.end(JSON.stringify(withBuild(out, ruactVersion)));
       });
 
       const rebuild = (file) => {
         if (!file.startsWith(dir)) return;
         manifest = buildManifest(dir);
-        writeManifest(path.resolve(root, manifestOutput), manifest);
+        writeManifest(path.resolve(root, manifestOutput), withBuild(manifest, ruactVersion));
         const mod = server.moduleGraph.getModuleById(RESOLVED_REGISTRY_ID);
         if (mod) {
           server.moduleGraph.invalidateModule(mod);

data/vendor/javascript/vite-plugin-ruact/page-mount.test.mjs

@@ -56,12 +56,20 @@ describe("showDevOverlay", () => {
     expect(document.getElementById("ruact-dev-overlay")).toBeNull();
   });
 
-  it("shows the latest failure in the one overlay", () => {
+  // Story 19-2 (AC7) — every failure, in the one overlay.
+  it("shows each failure in the one overlay, and opens again after it was closed", () => {
     showDevOverlay(new Error("first"));
     showDevOverlay(new Error("second"));
     const overlays = document.querySelectorAll("#ruact-dev-overlay");
     expect(overlays).toHaveLength(1);
-    expect(overlays[0].querySelector("[data-overlay-message]").textContent).toBe("second");
+    const messages = [...overlays[0].querySelectorAll("[data-overlay-message]")].map((el) => el.textContent);
+    expect(messages).toEqual(["first", "second"]);
+    expect(overlays[0].querySelector("[data-overlay-title]").textContent).toBe("[ruact] 2 <Suspense> failed on the server");
     overlays[0].click();
+
+    showDevOverlay(new Error("third"));
+    const reopened = document.getElementById("ruact-dev-overlay");
+    expect([...reopened.querySelectorAll("[data-overlay-message]")].map((el) => el.textContent)).toEqual(["third"]);
+    reopened.click();
   });
 });