react-on-rails-pro 17.0.0-rc.8 → 17.0.0-rc.9

package/lib/RSCProvider.d.ts

@@ -24,17 +24,21 @@ type RSCContextType = {
  * This factory function accepts an environment-specific getServerComponent implementation,
  * allowing it to work correctly in both client and server environments.
  *
- * @param railsContext - Context for the current request
  * @param getServerComponent - Environment-specific function for fetching server components
+ * @param domNodeId - Optional root id used to locate embedded browser payloads
+ * @param retryRejectedPayloads - Whether to perform and retain the bounded rejected-payload retry.
+ * Official wrappers pass this explicitly; the environment check is only a compatibility fallback
+ * for direct callers of this internal factory.
  * @returns A provider component that wraps children with RSC context
  *
  * @important This is an internal function. End users should not use this directly.
  * Instead, use wrapServerComponentRenderer from 'react-on-rails/wrapServerComponentRenderer/client'
  * for client-side rendering or 'react-on-rails/wrapServerComponentRenderer/server' for server-side rendering.
  */
-export declare const createRSCProvider: ({ getServerComponent, domNodeId, }: {
+export declare const createRSCProvider: ({ getServerComponent, domNodeId, retryRejectedPayloads, }: {
     getServerComponent: (props: ClientGetReactServerComponentProps) => Promise<ReactNode>;
     domNodeId?: string;
+    retryRejectedPayloads?: boolean;
 }) => ({ children }: {
     children: ReactNode;
 }) => import("react/jsx-runtime").JSX.Element;

package/lib/RSCProvider.js

@@ -15,7 +15,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useContext, useMemo, useRef, useState, useTransition, } from 'react';
-import { BoundedLRU, RSC_EVICTED_SUCCESS_MARKER_MAX_ENTRIES, RSC_PAYLOAD_CACHE_MAX_ENTRIES, } from "./RSCProviderCache.js";
+import { BoundedLRU, RSC_EVICTED_SUCCESS_MARKER_MAX_ENTRIES, RSC_PAYLOAD_CACHE_MAX_ENTRIES, RSC_PAYLOAD_FAILURE_RETENTION_MS, } from "./RSCProviderCache.js";
 import { consumePrefetchedServerComponent } from "./RSCPrefetchStore.js";
 import { createRSCPayloadKey, hasEmbeddedRSCPayload } from "./utils.js";
 const RSCContext = createContext(undefined);
@@ -32,6 +32,30 @@ const dropVersionStateKey = (prev, key) => {
 // rejected promises so they funnel through RSCRoute's error boundary the same
 // way async fetch failures do (#4372).
 const rejectWithError = (error) => Promise.reject(error instanceof Error ? error : new Error(String(error)));
+const MAX_ERROR_CAUSE_DEPTH = 5;
+const isRetryableRSCPayloadError = (error) => {
+    try {
+        let current = error;
+        for (let depth = 0; depth < MAX_ERROR_CAUSE_DEPTH && current != null; depth += 1) {
+            if (typeof current === 'object' &&
+                'name' in current &&
+                current.name === 'AbortError') {
+                return false;
+            }
+            const { status } = current;
+            if (typeof status === 'number') {
+                return status >= 500 || status === 408 || status === 429;
+            }
+            if (!(current instanceof Error))
+                break;
+            current = current.cause;
+        }
+    }
+    catch {
+        return false;
+    }
+    return true;
+};
 /**
  * Creates a provider context for React Server Components.
  *
@@ -43,15 +67,18 @@ const rejectWithError = (error) => Promise.reject(error instanceof Error ? error
  * This factory function accepts an environment-specific getServerComponent implementation,
  * allowing it to work correctly in both client and server environments.
  *
- * @param railsContext - Context for the current request
  * @param getServerComponent - Environment-specific function for fetching server components
+ * @param domNodeId - Optional root id used to locate embedded browser payloads
+ * @param retryRejectedPayloads - Whether to perform and retain the bounded rejected-payload retry.
+ * Official wrappers pass this explicitly; the environment check is only a compatibility fallback
+ * for direct callers of this internal factory.
  * @returns A provider component that wraps children with RSC context
  *
  * @important This is an internal function. End users should not use this directly.
  * Instead, use wrapServerComponentRenderer from 'react-on-rails/wrapServerComponentRenderer/client'
  * for client-side rendering or 'react-on-rails/wrapServerComponentRenderer/server' for server-side rendering.
  */
-export const createRSCProvider = ({ getServerComponent, domNodeId, }) => {
+export const createRSCProvider = ({ getServerComponent, domNodeId, retryRejectedPayloads = typeof window !== 'undefined', }) => {
     return ({ children }) => {
         // Companion bookkeeping keyed by the same RSC payload key as the promise
         // cache. These are dropped in lockstep when a key is evicted from the LRU so
@@ -228,12 +255,14 @@ export const createRSCProvider = ({ getServerComponent, domNodeId, }) => {
             if (cached !== undefined) {
                 return cached;
             }
-            // Pin the key for the duration of the initial in-flight load so that
-            // a burst of 50+ other keys loading before this one settles cannot
-            // evict it. Without this pin, `markSuccessfulPromise`'s `peek` guard
+            // Pin the key for the logical load. Browser failures keep this pin
+            // through their retention window so LRU pressure cannot reopen the request
+            // budget before React consumes the rejection. Without the initial pin,
+            // `markSuccessfulPromise`'s `peek` guard
             // would see a stale (evicted) entry and skip recording last-successful,
             // leaving `recoverOnError` with nothing to restore after a failed
-            // refetch. Unpinned in `.finally()` once the initial fetch settles.
+            // refetch. Successful loads release the pin after settling; terminal
+            // browser failures retain it through the window below.
             //
             // `setPinned` inserts and pins atomically (pin registered before
             // eviction): when 51+ initial loads start before any settle, a plain
@@ -278,82 +307,62 @@ export const createRSCProvider = ({ getServerComponent, domNodeId, }) => {
                 }
                 return payload;
             };
-            // When the underlying fetch REJECTS (as opposed to resolving with an
-            // `Error` value), the single-argument `.then` below would leave the
-            // rejected promise cached under `key`, so every later same-key
-            // `getComponent` returns that same rejection and a transient
-            // renderer/network/deploy failure stays wedged until an explicit
-            // refetch or reload (#3929). Evict the rejected entry so the next
-            // same-key `getComponent` starts a fresh fetch.
-            //
-            // Deferred past the first macrotask (`setTimeout(0)`, not
-            // `queueMicrotask`) so React's Suspense machinery observes the
-            // rejection on the cached promise before the entry is removed; a
-            // microtask could interleave with React's own queue and evict before
-            // Suspense reads it. The extra macrotask also lets the `.finally`
-            // below release the in-flight pin before the key becomes available for
-            // a fresh same-key `getComponent`; otherwise a repeated failing request
-            // can replace the rejected promise with a new pending promise before
-            // the user ErrorBoundary commits its fallback (#4522). Guarded on
-            // promise identity so a newer same-key promise (such as
-            // `refetchComponent`) installed during that window is not evicted by
-            // this stale failure.
-            //
-            // NOTE: payloads that RESOLVE with an `Error` value are intentionally
-            // left cached here; whether those should also retry is a separate
-            // `getServerComponent` contract decision tracked apart from #3929.
-            let payloadRejected = false;
-            const evictPromiseIfRejected = (error) => {
-                payloadRejected = true;
-                setTimeout(() => {
-                    setTimeout(() => {
-                        if (fetchRSCPromises.get(key, false) === promise) {
-                            fetchRSCPromises.deleteWithoutEvict(key);
-                        }
-                    }, 0);
-                }, 0);
-                throw error;
+            const fetchPayload = (enforceRefetch = false) => {
+                try {
+                    return getServerComponent(enforceRefetch
+                        ? { componentName, componentProps, enforceRefetch: true }
+                        : { componentName, componentProps });
+                }
+                catch (error) {
+                    return rejectWithError(error);
+                }
             };
-            let serverComponentPromise;
+            let firstAttempt;
             const preferEmbeddedPayload = hasEmbeddedRSCPayload(componentName, componentProps, domNodeId);
             const prefetchedServerComponentPromise = preferEmbeddedPayload
                 ? undefined
                 : consumePrefetchedServerComponent(key, providerCacheIdentityRef.current);
             if (prefetchedServerComponentPromise) {
-                serverComponentPromise = prefetchedServerComponentPromise;
+                firstAttempt = prefetchedServerComponentPromise;
             }
             else {
-                try {
-                    serverComponentPromise = getServerComponent({ componentName, componentProps });
+                firstAttempt = fetchPayload();
+            }
+            let terminalFailureRetained = false;
+            // React sees one cached promise for the entire logical load. A browser
+            // retry happens inside that promise instead of depending on a retry
+            // render to create another request.
+            promise = firstAttempt
+                .catch((error) => {
+                if (fetchRSCPromises.get(key, false) !== promise ||
+                    !retryRejectedPayloads ||
+                    !isRetryableRSCPayloadError(error)) {
+                    throw error;
                 }
-                catch (error) {
-                    // A synchronous producer throw behaves exactly like an immediately
-                    // rejected fetch: the rejection flows through the standard
-                    // `evictPromiseIfRejected` + `.finally()` bookkeeping below, which
-                    // settles the evicted-success latch and evicts the cached rejection.
-                    serverComponentPromise = rejectWithError(error);
+                return fetchPayload(true);
+            })
+                .then(markPayloadIfSuccessful, (error) => {
+                if (retryRejectedPayloads && fetchRSCPromises.get(key, false) === promise) {
+                    terminalFailureRetained = true;
                 }
-            }
-            promise = serverComponentPromise.then(markPayloadIfSuccessful, evictPromiseIfRejected).finally(() => {
+                throw error;
+            })
+                .finally(() => {
                 if (notifyRoutesOnSuccess && !payloadSucceeded && releaseInFlightEvictedSuccessLatch()) {
                     evictedSuccessfulPayloadKeys.set(key, true);
                 }
-                // Defer the initial-load pin release so a route whose promise just
-                // resolved can commit and install its mounted retain before over-cap
-                // reconciliation runs. Without this handoff, 51+ simultaneously
-                // resolving mounted routes can evict early visible keys before their
-                // layout effects get to pin them as mounted.
+                // Successful and stale loads release their initial pin after the
+                // route can install its mounted retain. A terminal browser failure
+                // keeps the same rejected promise pinned until its retention ends.
                 setTimeout(() => {
-                    if (payloadRejected) {
-                        // The rejected entry is already scheduled for deletion in the
-                        // next macrotask. Releasing its pin must not reconcile over-cap
-                        // eviction against healthy entries during this short grace
-                        // window.
+                    if (terminalFailureRetained && fetchRSCPromises.get(key, false) === promise) {
+                        fetchRSCPromises.deletePreservingPins(key);
                         fetchRSCPromises.unpinWithoutEvict(key);
+                        scheduleAbsentKeyVersionCleanup(key);
                         return;
                     }
                     fetchRSCPromises.unpin(key);
-                }, 0);
+                }, terminalFailureRetained ? RSC_PAYLOAD_FAILURE_RETENTION_MS : 0);
             });
             fetchRSCPromises.setPinned(key, promise);
             if (notifyRoutesOnSuccess) {
@@ -367,6 +376,7 @@ export const createRSCProvider = ({ getServerComponent, domNodeId, }) => {
             fetchRSCPromises,
             inFlightEvictedSuccessfulPayloadCounts,
             markSuccessfulPromise,
+            scheduleAbsentKeyVersionCleanup,
         ]);
         const refetchComponent = useCallback((componentName, componentProps, recoverOnError) => {
             let key;

package/lib/RSCProviderCache.d.ts

@@ -6,8 +6,14 @@
  * along with all of its companion bookkeeping (last-successful promise and
  * refetch version). The common case — a small, stable set of routes — never
  * hits the cap, so cache hits, refetch, and recoverOnError restore are
- * unaffected. This cap is intentionally not configurable through
- * `createRSCProvider` today. See
+ * unaffected.
+ *
+ * The cap is soft while entries are pinned. Besides in-flight and mounted
+ * payloads, a terminal browser rejection stays pinned for its short retention
+ * window so LRU pressure cannot erase its retry limit and reopen a request
+ * loop. A high-cardinality outage can therefore keep more than 50 failures
+ * briefly; each is removed and unpinned when that window ends. This cap is
+ * intentionally not configurable through `createRSCProvider` today. See
  * https://github.com/shakacode/react_on_rails/issues/3564.
  *
  * NOTE: the per-key `useSyncExternalStore` subscription/fan-out optimization
@@ -18,6 +24,8 @@
  * need to tune the cap for unusually high-cardinality RSC routes.
  */
 export declare const RSC_PAYLOAD_CACHE_MAX_ENTRIES = 50;
+/** How long a terminal browser rejection remains protected from render-driven reloads. */
+export declare const RSC_PAYLOAD_FAILURE_RETENTION_MS = 5000;
 /**
  * Evicted-success markers need a wider window than the primary payload cache:
  * primary-cache churn can evict many successful keys before a mounted route asks
@@ -50,13 +58,17 @@ export declare const RSC_EVICTED_SUCCESS_MARKER_MAX_ENTRIES: number;
  * 3. Mounted `<RSCRoute>` entries retain their payload keys so provider-wide
  *    refreshes do not make visible routes miss and refetch just because the
  *    provider cache contains more mounted routes than the soft cap.
+ * 4. Terminal browser failures retain their rejected promise briefly so cache
+ *    pressure cannot give the same failing key a fresh request budget before
+ *    React consumes the rejection.
  *
  * Inserting an in-flight promise uses `setPinned`, which pins BEFORE running
  * eviction so the just-inserted key can never be chosen as the eviction victim
  * even when every other key is already pinned (a pure `set` then `pin` would
  * let `evictIfNeeded` drop the new unpinned key first). When every key is
- * pinned the map is allowed to temporarily exceed `maxEntries`; the matching
- * `unpin` reconciles it.
+ * pinned the map is allowed to temporarily exceed `maxEntries`; matching
+ * releases reconcile it, while terminal failures remove themselves at the end
+ * of their retention window.
  *
  * No external LRU dependency exists for this synchronous provider cache (the
  * repo's `InMemoryLRUCacheHandler` is an async `CacheHandler` tied to

package/lib/RSCProviderCache.js

@@ -20,8 +20,14 @@
  * along with all of its companion bookkeeping (last-successful promise and
  * refetch version). The common case — a small, stable set of routes — never
  * hits the cap, so cache hits, refetch, and recoverOnError restore are
- * unaffected. This cap is intentionally not configurable through
- * `createRSCProvider` today. See
+ * unaffected.
+ *
+ * The cap is soft while entries are pinned. Besides in-flight and mounted
+ * payloads, a terminal browser rejection stays pinned for its short retention
+ * window so LRU pressure cannot erase its retry limit and reopen a request
+ * loop. A high-cardinality outage can therefore keep more than 50 failures
+ * briefly; each is removed and unpinned when that window ends. This cap is
+ * intentionally not configurable through `createRSCProvider` today. See
  * https://github.com/shakacode/react_on_rails/issues/3564.
  *
  * NOTE: the per-key `useSyncExternalStore` subscription/fan-out optimization
@@ -32,6 +38,8 @@
  * need to tune the cap for unusually high-cardinality RSC routes.
  */
 export const RSC_PAYLOAD_CACHE_MAX_ENTRIES = 50;
+/** How long a terminal browser rejection remains protected from render-driven reloads. */
+export const RSC_PAYLOAD_FAILURE_RETENTION_MS = 5000;
 /**
  * Evicted-success markers need a wider window than the primary payload cache:
  * primary-cache churn can evict many successful keys before a mounted route asks
@@ -64,13 +72,17 @@ export const RSC_EVICTED_SUCCESS_MARKER_MAX_ENTRIES = RSC_PAYLOAD_CACHE_MAX_ENTR
  * 3. Mounted `<RSCRoute>` entries retain their payload keys so provider-wide
  *    refreshes do not make visible routes miss and refetch just because the
  *    provider cache contains more mounted routes than the soft cap.
+ * 4. Terminal browser failures retain their rejected promise briefly so cache
+ *    pressure cannot give the same failing key a fresh request budget before
+ *    React consumes the rejection.
  *
  * Inserting an in-flight promise uses `setPinned`, which pins BEFORE running
  * eviction so the just-inserted key can never be chosen as the eviction victim
  * even when every other key is already pinned (a pure `set` then `pin` would
  * let `evictIfNeeded` drop the new unpinned key first). When every key is
- * pinned the map is allowed to temporarily exceed `maxEntries`; the matching
- * `unpin` reconciles it.
+ * pinned the map is allowed to temporarily exceed `maxEntries`; matching
+ * releases reconcile it, while terminal failures remove themselves at the end
+ * of their retention window.
  *
  * No external LRU dependency exists for this synchronous provider cache (the
  * repo's `InMemoryLRUCacheHandler` is an async `CacheHandler` tied to

package/lib/cache/manifestLoader.d.ts

@@ -1,5 +1,7 @@
-import { buildClientRenderer } from 'react-on-rails-rsc/client.node';
+import type { buildClientRenderer as buildClientRendererType } from 'react-on-rails-rsc/client.node';
+type ClientRenderer = ReturnType<typeof buildClientRendererType>;
 export declare function setManifestFileNames(clientManifest: string, serverClientManifest: string): void;
 export declare function getClientManifestFileName(): string | undefined;
-export declare function getClientRenderer(): Promise<ReturnType<typeof buildClientRenderer>>;
+export declare function getClientRenderer(): Promise<ClientRenderer>;
+export {};
 //# sourceMappingURL=manifestLoader.d.ts.map

package/lib/cache/manifestLoader.js

@@ -12,7 +12,6 @@
  * For licensing terms:
  * https://github.com/shakacode/react_on_rails/blob/main/REACT-ON-RAILS-PRO-LICENSE.md
  */
-import { buildClientRenderer } from 'react-on-rails-rsc/client.node';
 import loadJsonFile from "../loadJsonFile.js";
 let clientManifestFileName;
 let serverClientManifestFileName;
@@ -35,8 +34,9 @@ export function getClientRenderer() {
         clientRendererPromise = Promise.all([
             loadJsonFile(serverFile),
             loadJsonFile(clientFile),
+            import('react-on-rails-rsc/client.node'),
         ])
-            .then(([reactServerManifest, reactClientManifest]) => buildClientRenderer(reactClientManifest, reactServerManifest))
+            .then(([reactServerManifest, reactClientManifest, { buildClientRenderer }]) => buildClientRenderer(reactClientManifest, reactServerManifest))
             .catch((err) => {
             clientRendererPromise = undefined;
             throw err;

package/lib/cache/manifestLoaderServer.d.ts

@@ -1,3 +1,8 @@
-import { buildServerRenderer } from 'react-on-rails-rsc/server.node';
-export declare function getServerRenderer(): Promise<ReturnType<typeof buildServerRenderer>>;
+import type { BundleManifest } from 'react-on-rails-rsc';
+import type { buildServerRenderer as buildServerRendererType } from 'react-on-rails-rsc/server.node';
+type ServerRenderer = ReturnType<typeof buildServerRendererType>;
+export declare function collectRSCClientManifestStylesheetHrefs(reactClientManifest: BundleManifest): ReadonlySet<string>;
+export declare function getServerRenderer(): Promise<ServerRenderer>;
+export declare function getRSCClientManifestStylesheetHrefs(clientManifest: string): Promise<ReadonlySet<string>>;
+export {};
 //# sourceMappingURL=manifestLoaderServer.d.ts.map

package/lib/cache/manifestLoaderServer.js

@@ -12,20 +12,51 @@
  * For licensing terms:
  * https://github.com/shakacode/react_on_rails/blob/main/REACT-ON-RAILS-PRO-LICENSE.md
  */
-import { buildServerRenderer } from 'react-on-rails-rsc/server.node';
 import loadJsonFile from "../loadJsonFile.js";
 import { getClientManifestFileName } from "./manifestLoader.js";
+const reactClientManifestPromises = new Map();
 let serverRendererPromise;
-// eslint-disable-next-line import/prefer-default-export -- named export for consistency with manifestLoader
+const rscClientManifestStylesheetHrefsPromises = new Map();
+function normalizeStylesheetHref(href) {
+    try {
+        return new URL(href, 'http://react-on-rails.local').pathname;
+    }
+    catch {
+        return href.split(/[?#]/, 1)[0];
+    }
+}
+export function collectRSCClientManifestStylesheetHrefs(reactClientManifest) {
+    const stylesheetHrefs = new Set();
+    Object.values(reactClientManifest.filePathToModuleMetadata).forEach(({ css = [] }) => {
+        css.forEach((href) => stylesheetHrefs.add(normalizeStylesheetHref(href)));
+    });
+    return stylesheetHrefs;
+}
+function requireClientManifestFileName() {
+    const clientManifest = getClientManifestFileName();
+    if (!clientManifest) {
+        throw new Error('Manifest file names not set. Ensure setManifestFileNames() is called before getServerRenderer(). ' +
+            'This is done automatically during the first RSC render request.');
+    }
+    return clientManifest;
+}
+function getReactClientManifest(clientManifest = requireClientManifestFileName()) {
+    const cachedPromise = reactClientManifestPromises.get(clientManifest);
+    if (cachedPromise)
+        return cachedPromise;
+    const promise = loadJsonFile(clientManifest);
+    reactClientManifestPromises.set(clientManifest, promise);
+    void promise.catch(() => {
+        if (reactClientManifestPromises.get(clientManifest) === promise) {
+            reactClientManifestPromises.delete(clientManifest);
+        }
+    });
+    return promise;
+}
 export function getServerRenderer() {
     if (!serverRendererPromise) {
-        const clientManifest = getClientManifestFileName();
-        if (!clientManifest) {
-            throw new Error('Manifest file names not set. Ensure setManifestFileNames() is called before getServerRenderer(). ' +
-                'This is done automatically during the first RSC render request.');
-        }
-        serverRendererPromise = loadJsonFile(clientManifest)
-            .then((reactClientManifest) => buildServerRenderer(reactClientManifest))
+        serverRendererPromise = Promise.all([getReactClientManifest(), import('react-on-rails-rsc/server.node')])
+            .then(([reactClientManifest, { buildServerRenderer }]) => buildServerRenderer(reactClientManifest))
             .catch((err) => {
             serverRendererPromise = undefined;
             throw err;
@@ -33,4 +64,17 @@ export function getServerRenderer() {
     }
     return serverRendererPromise;
 }
+export function getRSCClientManifestStylesheetHrefs(clientManifest) {
+    const cachedPromise = rscClientManifestStylesheetHrefsPromises.get(clientManifest);
+    if (cachedPromise)
+        return cachedPromise;
+    const promise = getReactClientManifest(clientManifest).then(collectRSCClientManifestStylesheetHrefs);
+    rscClientManifestStylesheetHrefsPromises.set(clientManifest, promise);
+    void promise.catch(() => {
+        if (rscClientManifestStylesheetHrefsPromises.get(clientManifest) === promise) {
+            rscClientManifestStylesheetHrefsPromises.delete(clientManifest);
+        }
+    });
+    return promise;
+}
 //# sourceMappingURL=manifestLoaderServer.js.map

package/lib/getReactServerComponent.client.js

@@ -36,6 +36,7 @@ const replayConsole = (consoleReplayScript, nonce) => {
         document.body.appendChild(el);
     }
 };
+const buildRSCPayloadHttpError = (message, status) => Object.assign(new Error(message), { name: 'RSCPayloadHttpError', status });
 /**
  * Parses a length-prefixed RSC fetch response stream.
  *
@@ -49,7 +50,7 @@ const createFromFetch = async (fetchPromise, { componentName, cspNonce, replayCo
         const statusDescription = response.statusText
             ? `${response.status} ${response.statusText}`
             : `${response.status}`;
-        throw new Error(`RSC payload request for component "${componentName}" from ${sourceDescription} failed with HTTP ${statusDescription}.`);
+        throw buildRSCPayloadHttpError(`RSC payload request for component "${componentName}" from ${sourceDescription} failed with HTTP ${statusDescription}.`, response.status);
     }
     const { body } = response;
     if (!body) {

package/lib/injectRSCPayload.d.ts

@@ -4,6 +4,7 @@ import RSCRequestTracker from './RSCRequestTracker.ts';
 type RSCClientChunkStylesheetHrefsByChunkName = Map<string, string[]>;
 export declare function resolveLoadableStatsModuleDirectory(commonJsModuleDirectory: string | undefined, stack?: unknown): string;
 type InjectRSCPayloadOptions = {
+    rscClientManifestStylesheetHrefs?: ReadonlySet<string>;
     rscClientChunkStylesheetHrefsByChunkName?: RSCClientChunkStylesheetHrefsByChunkName;
     rscStreamObservability?: boolean;
 };

package/lib/injectRSCPayload.js

@@ -146,17 +146,23 @@ function getQuotedAttribute(tag, attributeName) {
     const attributeMatch = tag.match(new RegExp(`\\s${escapeRegExpLiteral(attributeName)}=(["'])(.*?)\\1`, 'i'));
     return attributeMatch?.[2];
 }
-function isRSCClientChunkStylesheetHref(href) {
+function normalizeStylesheetHref(href) {
     try {
-        return RSC_CLIENT_CHUNK_STYLESHEET_PATH.test(new URL(href, 'http://react-on-rails.local').pathname);
+        return new URL(href, 'http://react-on-rails.local').pathname;
     }
     catch {
-        return RSC_CLIENT_CHUNK_STYLESHEET_PATH.test(href.split(/[?#]/, 1)[0]);
+        return href.split(/[?#]/, 1)[0];
     }
 }
-function shouldPromoteStylesheetPreloadTag(linkTag) {
+function isRSCClientChunkStylesheetHref(href) {
+    return RSC_CLIENT_CHUNK_STYLESHEET_PATH.test(normalizeStylesheetHref(href));
+}
+function shouldPromoteStylesheetPreloadTag(linkTag, rscClientManifestStylesheetHrefs) {
     const href = getQuotedAttribute(linkTag, 'href');
-    return href ? isRSCClientChunkStylesheetHref(href) : false;
+    return href
+        ? rscClientManifestStylesheetHrefs.has(normalizeStylesheetHref(href)) ||
+            isRSCClientChunkStylesheetHref(href)
+        : false;
 }
 function assetHref(assetPath, publicPath) {
     if (/^(?:[a-z][a-z\d+.-]*:)?\/\//i.test(assetPath) || assetPath.startsWith('/')) {
@@ -1167,7 +1173,7 @@ function findIncompleteUTF8TailStartIndex(buffer) {
     }
     return tailStart;
 }
-function applyStreamedStylesheetPreloadGating(html, incompleteHtmlTailMode, retainedTailScanState) {
+function applyStreamedStylesheetPreloadGating(html, incompleteHtmlTailMode, rscClientManifestStylesheetHrefs, retainedTailScanState) {
     let stringSafeHtmlBuffer = html;
     let incompleteUTF8TailBuffer = Buffer.alloc(0);
     if (incompleteHtmlTailMode !== 'none') {
@@ -1202,7 +1208,9 @@ function applyStreamedStylesheetPreloadGating(html, incompleteHtmlTailMode, reta
             } = splitTrailingIncompleteHtmlTagTail(completeHtml));
         }
     }
-    const gatedHtml = completeHtml.replace(/<link\b(?=[^>]*\brel=(["'])(?:(?!\1).)*\bpreload\b(?:(?!\1).)*\1)(?=[^>]*\bas=(["'])style\2)(?=[^>]*\bhref=(["'])(?:(?!\3).)+\3)[^>]*\/?>/gi, (linkTag) => shouldPromoteStylesheetPreloadTag(linkTag) ? promoteStylesheetPreloadTag(linkTag) : linkTag);
+    const gatedHtml = completeHtml.replace(/<link\b(?=[^>]*\brel=(["'])(?:(?!\1).)*\bpreload\b(?:(?!\1).)*\1)(?=[^>]*\bas=(["'])style\2)(?=[^>]*\bhref=(["'])(?:(?!\3).)+\3)[^>]*\/?>/gi, (linkTag) => shouldPromoteStylesheetPreloadTag(linkTag, rscClientManifestStylesheetHrefs)
+        ? promoteStylesheetPreloadTag(linkTag)
+        : linkTag);
     const completeHtmlByteLength = Buffer.byteLength(completeHtml, 'utf8');
     const completeHtmlBuffer = completeHtmlByteLength === html.length ? html : stringSafeHtmlBuffer.subarray(0, completeHtmlByteLength);
     const incompleteHtmlTailBuffer = Buffer.concat([
@@ -1242,7 +1250,7 @@ function applyStreamedStylesheetPreloadGating(html, incompleteHtmlTailMode, reta
  * @returns A combined stream with embedded RSC payloads
  */
 export default function injectRSCPayload(pipeableHtmlStream, rscRequestTracker, domNodeId, cspNonce, options = {}) {
-    const { rscClientChunkStylesheetHrefsByChunkName = loadRSCClientChunkStylesheetHrefsByChunkName(), rscStreamObservability = false, } = options;
+    const { rscClientManifestStylesheetHrefs = new Set(), rscClientChunkStylesheetHrefsByChunkName = loadRSCClientChunkStylesheetHrefsByChunkName(), rscStreamObservability = false, } = options;
     const sanitizedNonce = sanitizeNonce(cspNonce);
     const htmlStream = new PassThrough();
     const resultStream = new PassThrough();
@@ -1320,7 +1328,7 @@ export default function injectRSCPayload(pipeableHtmlStream, rscRequestTracker,
         // Calculate total buffer size for efficient memory allocation
         const rscInitializationSize = rscInitializationBuffers.reduce((sum, buf) => sum + buf.length, 0);
         const htmlBuffer = Buffer.concat(htmlBuffers);
-        const { gatedHtmlBuffer, incompleteHtmlTailBuffer, incompleteHtmlTailScanState: nextRetainedHtmlTailScanState, } = applyStreamedStylesheetPreloadGating(htmlBuffer, incompleteHtmlTailMode, retainedHtmlTailScanState);
+        const { gatedHtmlBuffer, incompleteHtmlTailBuffer, incompleteHtmlTailScanState: nextRetainedHtmlTailScanState, } = applyStreamedStylesheetPreloadGating(htmlBuffer, incompleteHtmlTailMode, rscClientManifestStylesheetHrefs, retainedHtmlTailScanState);
         const shouldDeferRevealHtml = rscPromise &&
             shouldInferRSCClientStylesheets &&
             pendingRSCClientStylesheetInferenceStreams > 0 &&

package/lib/registerDefaultRSCProvider.client.js

@@ -20,6 +20,7 @@ if (typeof window !== 'undefined') {
     setDefaultRSCProviderFactory(({ reactElement, railsContext, domNodeId }) => {
         const RSCProvider = createRSCProvider({
             domNodeId,
+            retryRejectedPayloads: true,
             getServerComponent: async (args) => {
                 // Keep the RSC browser runtime visible to the RSC Webpack plugin while still loading it lazily.
                 await import('react-on-rails-rsc/client.browser');

package/lib/streamServerRenderedReactComponent.js

@@ -18,6 +18,7 @@ import captureReactOwnerStack from 'react-on-rails/captureReactOwnerStack';
 import { convertToError } from 'react-on-rails/serverRenderUtils';
 import { assertRailsContextWithServerStreamingCapabilities, } from 'react-on-rails/types';
 import injectRSCPayload from "./injectRSCPayload.js";
+import { getRSCClientManifestStylesheetHrefs } from "./cache/manifestLoaderServer.js";
 import { isRSCRouteSSRFalseBailoutError } from "./RSCRouteSSRFalseBailoutError.js";
 import { streamServerRenderedComponent, transformRenderStreamChunksToResultObject, } from "./streamingUtils.js";
 import handleError from "./handleError.js";
@@ -115,6 +116,12 @@ const streamRenderReactComponent = (reactRenderingResult, options, streamingTrac
         return ownerStack ? `${error.stack}${OWNER_STACK_MARKER}${ownerStack}` : undefined;
     };
     assertRailsContextWithServerStreamingCapabilities(railsContext);
+    const { reactClientManifestFileName } = railsContext;
+    // Manifest-backed promotion is additive. If a build does not ship the manifest,
+    // preserve the existing filename-regex fallback in injectRSCPayload.
+    const rscClientManifestStylesheetHrefsPromise = Promise.resolve()
+        .then(() => getRSCClientManifestStylesheetHrefs(reactClientManifestFileName))
+        .catch(() => new Set());
     Promise.resolve(reactRenderingResult)
         .then((reactRenderedElement) => {
         if (typeof reactRenderedElement === 'string') {
@@ -160,7 +167,14 @@ const streamRenderReactComponent = (reactRenderingResult, options, streamingTrac
             },
             onShellReady() {
                 renderState.isShellReady = true;
-                pipeToTransform(injectRSCPayload(renderingStream, streamingTrackers.rscRequestTracker, domNodeId, railsContext.cspNonce, { rscStreamObservability: railsContext.rscStreamObservability }));
+                void rscClientManifestStylesheetHrefsPromise.then((rscClientManifestStylesheetHrefs) => {
+                    if (isConsumerAborted())
+                        return;
+                    pipeToTransform(injectRSCPayload(renderingStream, streamingTrackers.rscRequestTracker, domNodeId, railsContext.cspNonce, {
+                        rscClientManifestStylesheetHrefs,
+                        rscStreamObservability: railsContext.rscStreamObservability,
+                    }));
+                });
             },
             onError(e) {
                 const error = convertToError(e);

package/lib/wrapServerComponentRenderer/client.js

@@ -94,6 +94,7 @@ const wrapServerComponentRenderer = (componentOrRenderFunction, componentName =
         const RSCProvider = createRSCProvider({
             getServerComponent: getReactServerComponent(domNodeId, railsContext),
             domNodeId,
+            retryRejectedPayloads: true,
         });
         const shouldHydrate = !!domNode.innerHTML;
         const componentElement = _jsx(Component, { ...props });

package/lib/wrapServerComponentRenderer/server.js

@@ -71,6 +71,7 @@ const wrapServerComponentRenderer = (componentOrRenderFunction, componentName =
         }
         const RSCProvider = createRSCProvider({
             getServerComponent: getReactServerComponent(railsContext),
+            retryRejectedPayloads: false,
         });
         return () => (_jsx(RSCProvider, { children: _jsx(React.Suspense, { fallback: null, children: _jsx(Component, { ...props }) }) }));
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-on-rails-pro",
-  "version": "17.0.0-rc.8",
+  "version": "17.0.0-rc.9",
   "description": "React on Rails Pro package with React Server Components support",
   "main": "lib/ReactOnRails.full.js",
   "type": "module",
@@ -67,12 +67,12 @@
     "./ServerComponentFetchError": "./lib/ServerComponentFetchError.js"
   },
   "dependencies": {
-    "react-on-rails": "17.0.0-rc.8"
+    "react-on-rails": "17.0.0-rc.9"
   },
   "peerDependencies": {
     "react": ">= 16",
     "react-dom": ">= 16",
-    "react-on-rails-rsc": ">=19.2.1-rc.0 <20.0.0",
+    "react-on-rails-rsc": ">=19.2.1-rc.1 <20.0.0",
     "@tanstack/react-router": ">=1.139.0 <2.0.0",
     "ioredis": ">= 5"
   },
@@ -103,7 +103,7 @@
     "mock-fs": "^5.5.0",
     "react": "~19.2.7",
     "react-dom": "~19.2.7",
-    "react-on-rails-rsc": "19.2.1-rc.0",
+    "react-on-rails-rsc": "19.2.1-rc.1",
     "ioredis": "5.11.1"
   },
   "scripts": {