ruact 0.0.20 → 0.0.22

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

@@ -1,7 +1,7 @@
 // The two ways a page is opened read the same way: the rows a document inlined
 // in `__FLIGHT_DATA`, and a fetch body that may end early.
 import { describe, it, expect } from "vitest";
-import { documentRows, openPage } from "./runtime/page-stream.js";
+import { LEAVE_EVENT, documentRows, openPage } from "./runtime/page-stream.js";
 
 const encoder = new TextEncoder();
 
@@ -57,9 +57,14 @@ describe("documentRows", () => {
     return {
       readyState: "loading",
       addEventListener(type, listener) { listeners[type] = listener; },
-      finish() {
-        this.readyState = "interactive";
-        listeners.DOMContentLoaded?.();
+      removeEventListener(type) { delete listeners[type]; },
+      finish(state = "interactive") {
+        this.readyState = state;
+        listeners.readystatechange?.();
+      },
+      leave() {
+        listeners[LEAVE_EVENT]?.();
+        this.finish("complete");
       },
     };
   }
@@ -93,6 +98,26 @@ describe("documentRows", () => {
     expect(closed).toBe(true);
   });
 
+  // Story 19-2 — the router stops a document it leaves while it still loads.
+  it("closes when the document is stopped while loading", async () => {
+    const doc = openDocument();
+    const reader = documentRows(['0:"x"\n'], doc).getReader();
+    await reader.read();
+    doc.finish("complete");
+    await expect(reader.read()).resolves.toMatchObject({ done: true });
+  });
+
+  // Story 19-2 — the router leaving it: the page being left reports nothing,
+  // as for a superseded navigation.
+  it("ends as an aborted navigation when the router leaves the document", async () => {
+    const doc = openDocument();
+    const page = openPage(documentRows(['0:{"later":"$@1"}\n'], doc));
+    const root = await page.root;
+    doc.leave();
+    await expect(root.later).rejects.toMatchObject({ name: "AbortError" });
+    await expect(page.end).rejects.toMatchObject({ name: "AbortError" });
+  });
+
   it("closes at once when the document has already ended", async () => {
     const reader = documentRows(['0:"x"\n'], { readyState: "complete" }).getReader();
     await reader.read();

data/vendor/javascript/vite-plugin-ruact/registry.test.mjs

@@ -20,6 +20,8 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { build } from "vite";
 import {
+  BUILD_KEY,
+  readRuactVersion,
   buildManifest,
   generateRegistrySource,
   REGISTRY_VIRTUAL_ID,
@@ -143,9 +145,13 @@ describe("prod id-match invariant — real vite build (Story 10.1b AC2, LOAD-BEA
     });
 
     // The manifest the gem will read (ids === Flight moduleIds).
-    const manifest = JSON.parse(
+    const written = JSON.parse(
       fs.readFileSync(path.join(dir, "public/react-client-manifest.json"), "utf8")
     );
+    // Story 19-3 — the build's record comes first, and is not a component.
+    const { [BUILD_KEY]: build19_3, ...manifest } = written;
+    expect(Object.keys(written)[0]).toBe(BUILD_KEY);
+    expect(build19_3).toEqual({ version: readRuactVersion() });
     const manifestIds = new Set(Object.values(manifest).map((e) => e.id));
 
     // Prod ids stay source-relative (eager-inlined components → no facade chunk

data/vendor/javascript/vite-plugin-ruact/ruact-router.test.mjs

@@ -14,6 +14,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import fs from "node:fs";
 import path from "node:path";
 import { setupRouter, teardownRouter } from "./runtime/ruact-router.js";
+import { LEAVE_EVENT } from "./runtime/page-stream.js";
 
 const ORIGIN = "http://localhost:3000";
 
@@ -568,3 +569,187 @@ describe("ruact-router — dates and big integers in a navigation (Story 17-0c)"
   });
 });
 
+
+// Story 19-2 — leaving a page whose document is still arriving (a page that
+// streams) stops loading it, so the server starts no further block for it.
+describe("leaving a document that is still loading", () => {
+  let dom;
+
+  beforeEach(() => {
+    dom = installDom();
+    globalThis.fetch = vi.fn().mockResolvedValue(respond({ body: '0:"next"\n' }));
+    globalThis.window.stop = vi.fn();
+    globalThis.__FLIGHT_DATA = Object.assign([], { streaming: true });
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    setupRouter({ onNavigate: vi.fn(), moduleRegistry: {}, onError: vi.fn() });
+  });
+
+  afterEach(() => {
+    teardownRouter();
+    delete globalThis.__FLIGHT_DATA;
+    vi.restoreAllMocks();
+  });
+
+  // A slow network, a long layout: the rest of the document after `#root`
+  // (which a navigation does not replace) still has to arrive.
+  it("leaves a loading document alone when it does not stream, or its rows are all in", async () => {
+    globalThis.document.readyState = "loading";
+    globalThis.__FLIGHT_DATA = [];
+    click(dom.listeners, "/products/2");
+    await settle();
+    globalThis.__FLIGHT_DATA = Object.assign([], { streaming: false });
+    click(dom.listeners, "/products/3");
+    await settle();
+    expect(window.stop).not.toHaveBeenCalled();
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("stops the document before it fetches the next page", async () => {
+    globalThis.document.readyState = "loading";
+    let stoppedBeforeFetch = null;
+    globalThis.fetch.mockImplementation(async () => {
+      stoppedBeforeFetch = window.stop.mock.calls.length === 1;
+      return respond({ body: '0:"next"\n' });
+    });
+    click(dom.listeners, "/products/2");
+    await settle();
+    expect(stoppedBeforeFetch).toBe(true);
+  });
+
+  it("leaves a document that has finished alone", async () => {
+    globalThis.document.readyState = "complete";
+    click(dom.listeners, "/products/2");
+    await settle();
+    expect(window.stop).not.toHaveBeenCalled();
+    expect(fetch).toHaveBeenCalled();
+  });
+
+  it("stops it for a form the router submits", async () => {
+    globalThis.document.readyState = "loading";
+    let stoppedBeforeFetch = null;
+    globalThis.fetch.mockImplementation(async () => {
+      stoppedBeforeFetch = window.stop.mock.calls.length === 1;
+      return respond({ body: '0:"next"\n' });
+    });
+    submit(dom.listeners, new dom.FakeForm({ action: "/people", method: "post" }));
+    await settle();
+    expect(stoppedBeforeFetch).toBe(true);
+  });
+
+  // Review 19-2a R3/R4 — a `#anchor` on the page on screen: the browser
+  // scrolls; nothing is fetched, and the document is not left.
+  it("leaves a popstate that only changes the hash to the browser", async () => {
+    globalThis.document.readyState = "loading";
+    location._set("/products/1#reviews");
+    dom.listeners.window.popstate.forEach((fn) => fn({}));
+    await settle();
+    expect(window.stop).not.toHaveBeenCalled();
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it("leaves a link to this page's #anchor to the browser", async () => {
+    globalThis.document.readyState = "loading";
+    const event = click(dom.listeners, "/products/1#reviews");
+    await settle();
+    expect(event.defaultPrevented).toBe(false);
+    expect(window.stop).not.toHaveBeenCalled();
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  // Review 19-2a R4 — as a browser does: once stopped, the document no longer
+  // loads, so a later navigation does not stop it again.
+  function stopForReal() {
+    globalThis.document.readyState = "loading";
+    window.stop.mockImplementation(() => { globalThis.document.readyState = "complete"; });
+  }
+
+  it("fetches the page again when the navigation that superseded the one that stopped it fails", async () => {
+    stopForReal();
+    const html500 = respond({ status: 500, contentType: "text/html", body: "<p>boom</p>" });
+    globalThis.fetch
+      .mockImplementationOnce((_url, { signal }) => new Promise((_resolve, reject) => {
+        signal.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError")));
+      }))
+      .mockResolvedValueOnce(html500)
+      .mockResolvedValue(respond({ body: '0:"again"\n' }));
+    const form = new dom.FakeForm({ action: "/people", method: "post" });
+    submit(dom.listeners, form);
+    submit(dom.listeners, form);
+    await settle();
+    await settle();
+    expect(window.stop).toHaveBeenCalledTimes(1);
+    expect(fetch.mock.calls.map((call) => call[0])).toEqual(["/people", "/people", "/products/1"]);
+  });
+
+  it("fetches the page again when the redirect a form was answered with fails", async () => {
+    stopForReal();
+    globalThis.fetch
+      .mockResolvedValueOnce(respond({ body: '0:{"redirectUrl":"/people/9","redirectType":"push"}\n' }))
+      .mockRejectedValueOnce(new TypeError("Failed to fetch"))
+      .mockResolvedValue(respond({ body: '0:"again"\n' }));
+    submit(dom.listeners, new dom.FakeForm({ action: "/people", method: "post" }));
+    await settle();
+    await settle();
+    expect(fetch.mock.calls.map((call) => call[0])).toEqual(["/people", "/people/9", "/products/1"]);
+  });
+
+  it("does not fetch the page again once a navigation replaced it", async () => {
+    stopForReal();
+    globalThis.fetch.mockResolvedValue(respond({ body: '0:"next"\n' }));
+    click(dom.listeners, "/products/2");
+    await settle();
+    globalThis.fetch.mockRejectedValue(new TypeError("Failed to fetch"));
+    click(dom.listeners, "/products/3");
+    await settle();
+    await settle();
+    expect(fetch.mock.calls.map((call) => call[0])).toEqual(["/products/2", "/products/3"]);
+  });
+
+  // Review 19-2a R3 — the navigation that stopped the document failed: the user
+  // is still on that page, whose boundaries would keep their fallback.
+  it("fetches the page again when the navigation that stopped it fails", async () => {
+    globalThis.document.readyState = "loading";
+    globalThis.fetch
+      .mockRejectedValueOnce(new TypeError("Failed to fetch"))
+      .mockResolvedValue(respond({ body: '0:"again"\n' }));
+    submit(dom.listeners, new dom.FakeForm({ action: "/people", method: "post" }));
+    await settle();
+    await settle();
+    expect(window.stop).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(fetch.mock.calls[1][0]).toBe("/products/1");
+  });
+
+  it("does not fetch the page again after a failure when nothing was stopped", async () => {
+    globalThis.document.readyState = "complete";
+    globalThis.fetch.mockRejectedValue(new TypeError("Failed to fetch"));
+    submit(dom.listeners, new dom.FakeForm({ action: "/people", method: "post" }));
+    await settle();
+    await settle();
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  // revalidate() stays on the page: stopping the document would also fail the
+  // page's other requests in flight (a server function, a useQuery).
+  it("leaves the document loading for revalidate()", async () => {
+    globalThis.document.readyState = "loading";
+    await globalThis.__ruact_revalidate();
+    expect(window.stop).not.toHaveBeenCalled();
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  // Stopped, the document's rows would read as a response cut short, which
+  // the page being left reports: they are told first.
+  it("tells the document's rows it is left before it stops it", async () => {
+    globalThis.document.readyState = "loading";
+    const told = [];
+    globalThis.document.dispatchEvent = vi.fn((event) => {
+      told.push([event.type, window.stop.mock.calls.length]);
+      return true;
+    });
+    click(dom.listeners, "/products/2");
+    await settle();
+    expect(told).toEqual([[LEAVE_EVENT, 0]]);
+    expect(window.stop).toHaveBeenCalledTimes(1);
+  });
+});

data/vendor/javascript/vite-plugin-ruact/runtime/dev-overlay.js

@@ -9,7 +9,11 @@
 
 const OVERLAY_ID = "ruact-dev-overlay";
 
-/** Shows +error+ over the page; a click closes it. */
+/**
+ * Shows +error+ over the page, under the ones already shown (Story 19-2: one
+ * entry per failed <Suspense>); a click closes the overlay, and the next
+ * failure opens it again.
+ */
 export function showDevOverlay(error, doc = globalThis.document) {
   const cause = error?.cause ?? error;
   let overlay = doc.getElementById(OVERLAY_ID);
@@ -23,17 +27,27 @@ export function showDevOverlay(error, doc = globalThis.document) {
       "font:14px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;padding:32px;overflow:auto;" +
       "white-space:pre-wrap;cursor:pointer";
     overlay.addEventListener("click", () => overlay.remove());
+    const title = doc.createElement("h2");
+    title.dataset.overlayTitle = "";
+    const hint = doc.createElement("p");
+    hint.dataset.overlayHint = "";
+    hint.textContent = "Development only. Click to close.";
+    overlay.append(title, hint);
     (doc.body ?? doc.documentElement).appendChild(overlay);
   }
-  const title = doc.createElement("h2");
-  title.textContent = "[ruact] A <Suspense> failed on the server";
+
+  const entry = doc.createElement("section");
+  entry.dataset.overlayEntry = "";
   const message = doc.createElement("p");
   message.dataset.overlayMessage = "";
   message.textContent = cause?.message ?? String(cause);
   const stack = doc.createElement("pre");
   stack.dataset.overlayStack = "";
   stack.textContent = cause?.stack ?? "";
-  const hint = doc.createElement("p");
-  hint.textContent = "Development only. Click to close.";
-  overlay.replaceChildren(title, message, stack, hint);
+  entry.append(message, stack);
+  overlay.insertBefore(entry, overlay.querySelector("[data-overlay-hint]"));
+
+  const count = overlay.querySelectorAll("[data-overlay-entry]").length;
+  overlay.querySelector("[data-overlay-title]").textContent =
+    count === 1 ? "[ruact] A <Suspense> failed on the server" : `[ruact] ${count} <Suspense> failed on the server`;
 }

data/vendor/javascript/vite-plugin-ruact/runtime/page-stream.js

@@ -8,12 +8,21 @@
 import { createFromReadableStream } from "virtual:ruact/flight-client";
 import { labelledStream } from "./transport.js";
 
+/**
+ * What the router dispatches on the document before it stops one it leaves
+ * while it still loads (Story 19-2).
+ */
+export const LEAVE_EVENT = "ruact:leave";
+
 /**
  * The rows the document pushes onto `__FLIGHT_DATA`, as a byte stream that
  * stays open while the document does (Story 19-1): the rows already in the
  * queue, then each one pushed later — a page that streams pushes one script per
  * `<Suspense>` — until the document has finished loading. A row pushed before
  * this runs is in the queue, and read first.
+ *
+ * A document the router leaves ({@link LEAVE_EVENT}) ends the stream as an
+ * aborted navigation does: the page being left reports no response cut short.
  */
 export function documentRows(queue, doc = globalThis.document) {
   const encoder = new TextEncoder();
@@ -27,12 +36,23 @@ export function documentRows(queue, doc = globalThis.document) {
         if (open) rows.forEach(read);
         return 0;
       };
-      const close = () => {
+      const close = (error) => {
+        if (!open) return;
         open = false;
-        controller.close();
+        doc?.removeEventListener?.("readystatechange", atEnd);
+        doc?.removeEventListener?.(LEAVE_EVENT, left);
+        if (error) controller.error(error);
+        else controller.close();
+      };
+      // Closed when the document stops loading: its end (`interactive`, just
+      // before DOMContentLoaded), or the router stopping it (Story 19-2).
+      const atEnd = () => {
+        if (doc.readyState !== "loading") close();
       };
+      const left = () => close(new DOMException("the page was left while it loaded", "AbortError"));
       if (doc?.readyState === "loading") {
-        doc.addEventListener("DOMContentLoaded", close, { once: true });
+        doc.addEventListener("readystatechange", atEnd);
+        doc.addEventListener(LEAVE_EVENT, left);
       } else {
         close();
       }

data/vendor/javascript/vite-plugin-ruact/runtime/ruact-router.js

@@ -11,7 +11,7 @@
  */
 
 import { setBoundaryErrorHandler } from "./suspense-boundary.js";
-import { openPage } from "./page-stream.js";
+import { LEAVE_EVENT, openPage } from "./page-stream.js";
 
 // Errors already reported once (by a Suspense boundary) that navigate() must
 // not report again on their way out to a revalidate() caller.
@@ -21,6 +21,12 @@ let _onNavigate     = null;
 let _onError        = null;
 let _currentAbort   = null;
 
+// Story 19-2 — whether the page on screen is a document the router stopped
+// and has not replaced yet (a new tree, a full load, a native submit); and the
+// path of the page on screen, which a `#anchor` does not leave.
+let _pageStopped    = false;
+let _renderedPath   = null;
+
 /**
  * @param {object}   opts
  * @param {function} opts.onNavigate     - called with the new React element tree
@@ -33,6 +39,8 @@ let _currentAbort   = null;
 export function setupRouter({ onNavigate, onError = null, onBoundaryError = null }) {
   _onNavigate     = onNavigate;
   _onError        = onError;
+  _pageStopped    = false;
+  _renderedPath   = typeof location === "undefined" ? null : location.pathname + location.search;
   setBoundaryErrorHandler((error) => {
     console.error(error.message);
     onBoundaryError?.(error);
@@ -58,11 +66,15 @@ export function setupRouter({ onNavigate, onError = null, onBoundaryError = null
   // what link clicks and form submits want, but a programmatic
   // `revalidate()` caller HAS to be able to branch on success vs.
   // failure.
+  // `leave: false` (Story 19-2): revalidate() stays on the page, so a
+  // document still streaming is not stopped — stopping it would also fail the
+  // page's other requests in flight (a server function, a useQuery).
   globalThis.__ruact_revalidate = (target) =>
     navigate(target ?? location.pathname + location.search, {
       push: false,
       scroll: false,
       throwOnError: true,
+      leave: false,
     });
 }
 
@@ -112,9 +124,12 @@ function handleClick(event) {
   const anchor = event.target.closest("a[href]");
   if (!shouldIntercept(anchor)) return;
 
-  event.preventDefault();
-
   const url = new URL(anchor.getAttribute("href"), location.href);
+  // Story 19-2 — this page with a `#anchor`: the browser scrolls; nothing to
+  // fetch, and a page still streaming is not left.
+  if (url.hash && url.pathname + url.search === location.pathname + location.search) return;
+
+  event.preventDefault();
   navigate(url.pathname + url.search + url.hash);
 }
 
@@ -304,6 +319,7 @@ function _isFlight(response) {
 // `response.url` never carries the #fragment (Fetch strips it), so the one
 // the link asked for is put back.
 function _fullLoad(response, targetUrl, { replace = false } = {}) {
+  _pageStopped = false;
   const requested = new URL(targetUrl, location.href);
   const destination = new URL(response.url || requested.href);
   if (!destination.hash && requested.hash) destination.hash = requested.hash;
@@ -340,6 +356,7 @@ const _SUBMITTER_OVERRIDES = [
 ];
 
 function _nativeSubmit(form, submitter) {
+  _pageStopped = false;
   const restore = [];
   const added = [];
 
@@ -405,6 +422,7 @@ async function _submitForm(form, submitter = null) {
   // Rails _method hidden field is included in FormData automatically;
   // Rack::MethodOverride reads it and routes to the correct action.
   _currentAbort?.abort();
+  _leaveOpenDocument();
   const controller = (_currentAbort = new AbortController());
 
   const headers = { Accept: "text/x-component", "Ruact-Request": "1" };
@@ -439,6 +457,8 @@ async function _submitForm(form, submitter = null) {
     if (err.name === "AbortError") return;
     console.error("[ruact-router] Form submission error:", err);
     _onError?.(err);
+  } finally {
+    _recoverStoppedPage(controller);
   }
 }
 
@@ -449,6 +469,9 @@ async function _submitForm(form, submitter = null) {
 function handlePopstate() {
   // Story 17.0f — `replace`: if this entry turns out not to be a ruact page, the
   // full load must not push a NEW entry into the history being walked.
+  // Story 19-2 — only the hash changed (a `#anchor`, Back over one): the page
+  // on screen is this one, and the browser scrolls.
+  if (location.pathname + location.search === _renderedPath) return;
   navigate(location.pathname + location.search + location.hash, { push: false, scroll: false, replace: true });
 }
 
@@ -456,6 +479,38 @@ function handlePopstate() {
 // Navigation
 // ---------------------------------------------------------------------------
 
+/**
+ * Story 19-2 — the page being left may be a document still arriving: a page
+ * that streams, whose <Suspense> rows are still to come. Nobody will see them,
+ * so stop loading it: the connection closes, and the server, which asks before
+ * each block, starts no further block for it. Only a document that streams
+ * and has rows still to come (the server marks it, `__FLIGHT_DATA.streaming`):
+ * any other document still being parsed — a slow network, a long layout — is
+ * left to load, the part of its layout after `#root` included.
+ */
+function _leaveOpenDocument() {
+  if (typeof document === "undefined" || document.readyState !== "loading") return;
+  if (globalThis.__FLIGHT_DATA?.streaming !== true) return;
+  // First its rows' stream ends as an aborted navigation: stopped, it would
+  // read as a response cut short, which the page being left reports.
+  if (typeof document.dispatchEvent === "function") document.dispatchEvent(new Event(LEAVE_EVENT));
+  if (typeof window !== "undefined" && typeof window.stop === "function") window.stop();
+  _pageStopped = true;
+}
+
+/**
+ * Story 19-2 — a navigation ended without replacing a page the router had
+ * stopped (a failed fetch, a 403 or a 500 to a form — this navigation's, or a
+ * later one's that superseded the one that stopped it): the user is still on
+ * that page, whose boundaries would keep their fallback. Fetch it again,
+ * without stopping anything, once. Not when a newer navigation took over.
+ */
+function _recoverStoppedPage(controller) {
+  if (!_pageStopped || controller.signal.aborted) return;
+  _pageStopped = false;
+  navigate(location.pathname + location.search, { push: false, scroll: false, leave: false });
+}
+
 /**
  * Story 8.2 review patch R7 (2026-05-17) — `throwOnError` opts a caller
  * out of the swallow-and-forward error mode. The default (false) is the
@@ -465,9 +520,10 @@ function handlePopstate() {
  * REJECTS on a failed Flight fetch — without this, callers cannot
  * branch on success vs. failure of a programmatic refetch.
  */
-async function navigate(url, { push = true, scroll = true, throwOnError = false, replace = false } = {}) {
+async function navigate(url, { push = true, scroll = true, throwOnError = false, replace = false, leave = true } = {}) {
   // Abort any in-flight fetch so we don't apply a stale response
   _currentAbort?.abort();
+  if (leave) _leaveOpenDocument();
   const controller = (_currentAbort = new AbortController());
 
   try {
@@ -504,6 +560,8 @@ async function navigate(url, { push = true, scroll = true, throwOnError = false,
     console.error("[ruact-router] Navigation error:", err);
     _onError?.(err);
     if (throwOnError) throw err;
+  } finally {
+    _recoverStoppedPage(controller);
   }
 }
 
@@ -594,6 +652,8 @@ async function _processFlightResponse(response, {
   }
 
   if (pushEntry) history.pushState(null, "", finalPath);
+  _pageStopped = false;
+  _renderedPath = location.pathname + location.search;
   _onNavigate(root);
   if (scroll) window.scrollTo(0, 0);
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruact
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.22
 platform: ruby
 authors:
 - Luiz Garcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-15 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -43,6 +43,7 @@ files:
 - RELEASING.md
 - SECURITY.md
 - lib/generators/ruact/install/install_generator.rb
+- lib/generators/ruact/install/legacy/vite.config.pinned.js
 - lib/generators/ruact/install/templates/AGENTS.md.tt
 - lib/generators/ruact/install/templates/Procfile.dev.tt
 - lib/generators/ruact/install/templates/dev.tt
@@ -71,6 +72,8 @@ files:
 - lib/generators/ruact/scaffold/templates/views/new.html.erb.tt
 - lib/generators/ruact/scaffold/templates/views/show.html.erb.tt
 - lib/ruact.rb
+- lib/ruact/build_skew.rb
+- lib/ruact/cached_blocks.rb
 - lib/ruact/client_manifest.rb
 - lib/ruact/component_attributes.rb
 - lib/ruact/component_contract.rb
@@ -82,6 +85,7 @@ files:
 - lib/ruact/controller/page_rendering.rb
 - lib/ruact/controller/pages.rb
 - lib/ruact/controller/streaming.rb
+- lib/ruact/declared_content.rb
 - lib/ruact/deferred_render.rb
 - lib/ruact/doctor.rb
 - lib/ruact/erb_preprocessor.rb
@@ -104,6 +108,7 @@ files:
 - lib/ruact/navigation_boundary.rb
 - lib/ruact/packaging.rb
 - lib/ruact/query.rb
+- lib/ruact/query_watch.rb
 - lib/ruact/railtie.rb
 - lib/ruact/redirect_path.rb
 - lib/ruact/render_context.rb
@@ -156,6 +161,7 @@ files:
 - vendor/javascript/ruact-server-functions-runtime/package.json
 - vendor/javascript/ruact-server-functions-runtime/usequery.test.mjs
 - vendor/javascript/vite-plugin-ruact/bootstrap.test.mjs
+- vendor/javascript/vite-plugin-ruact/build-version.test.mjs
 - vendor/javascript/vite-plugin-ruact/flight-conformance.test.mjs
 - vendor/javascript/vite-plugin-ruact/index.js
 - vendor/javascript/vite-plugin-ruact/manifest-contract.test.mjs