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

package/lib/RSCProvider.js

@@ -286,24 +286,31 @@ export const createRSCProvider = ({ getServerComponent, domNodeId, }) => {
             // refetch or reload (#3929). Evict the rejected entry so the next
             // same-key `getComponent` starts a fresh fetch.
             //
-            // Deferred one 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. Guarded on
-            // promise identity so a newer same-key promise (a fresh `getComponent`
-            // or a `refetchComponent`) installed during that window is not evicted
-            // by this stale failure. Pins are preserved because the `.finally`
-            // below still owns the matching `unpin` (mirrors the delete +
-            // deferred-unpin handoff in `restoreLastSuccessfulPromise`).
+            // 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(() => {
-                    if (fetchRSCPromises.get(key, false) === promise) {
-                        fetchRSCPromises.deletePreservingPins(key);
-                    }
+                    setTimeout(() => {
+                        if (fetchRSCPromises.get(key, false) === promise) {
+                            fetchRSCPromises.deleteWithoutEvict(key);
+                        }
+                    }, 0);
                 }, 0);
                 throw error;
             };
@@ -337,6 +344,14 @@ export const createRSCProvider = ({ getServerComponent, domNodeId, }) => {
                 // resolving mounted routes can evict early visible keys before their
                 // layout effects get to pin them as mounted.
                 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.
+                        fetchRSCPromises.unpinWithoutEvict(key);
+                        return;
+                    }
                     fetchRSCPromises.unpin(key);
                 }, 0);
             });

package/lib/RSCProviderCache.d.ts

@@ -96,6 +96,8 @@ export declare class BoundedLRU<V> {
     deleteWithoutEvict(key: string, preservePins?: boolean): void;
     deletePreservingPins(key: string): void;
     unpin(key: string): void;
+    unpinWithoutEvict(key: string): void;
+    private releasePin;
     /**
      * Evict least-recently-used unpinned keys until the map is back within
      * `maxEntries`. `preventEvictingKey`, when given, is treated as un-evictable

package/lib/RSCProviderCache.js

@@ -160,6 +160,12 @@ export class BoundedLRU {
         this.deleteWithoutEvict(key, true);
     }
     unpin(key) {
+        this.releasePin(key, true);
+    }
+    unpinWithoutEvict(key) {
+        this.releasePin(key, false);
+    }
+    releasePin(key, reconcileEviction) {
         this.assertNotEvicting('unpin');
         const count = this.pins.get(key);
         if (count === undefined) {
@@ -170,6 +176,9 @@ export class BoundedLRU {
             return;
         }
         this.pins.delete(key);
+        if (!reconcileEviction) {
+            return;
+        }
         // The in-flight operation that held this pin just settled, so the key is
         // now the most-recently-used. `get` promotes only when the key is still
         // present; a key already deleted, e.g. by `restoreLastSuccessfulPromise`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-on-rails-pro",
-  "version": "17.0.0-rc.7",
+  "version": "17.0.0-rc.8",
   "description": "React on Rails Pro package with React Server Components support",
   "main": "lib/ReactOnRails.full.js",
   "type": "module",
@@ -67,7 +67,7 @@
     "./ServerComponentFetchError": "./lib/ServerComponentFetchError.js"
   },
   "dependencies": {
-    "react-on-rails": "17.0.0-rc.7"
+    "react-on-rails": "17.0.0-rc.8"
   },
   "peerDependencies": {
     "react": ">= 16",