Drop redundant isRequestActive gate on in-flight correlation

`_operationExecutions` flips to `'inactive'` while `_state === 'loading_final'`
(with no pending module payloads) — before the network stream completes and
`_inFlightOperationCompletions` is cleared in `cancel()`. Under incremental
delivery, fragments reading during that "final-but-not-complete" window fall
through to partial-data reads instead of suspending on the still-valid
completion promise, defeating this correlation. Gate solely on the completion
map entry's presence (via `getPromiseForInFlightOperation`) — populated in the
Executor constructor and cleared atomically when `_complete` fires — which
IS the correct in-flight signal for this branch.

Adds a test in useFragment-WithOperationTrackerSuspense-test.js exercising the
mid-stream window where isRequestActive returns false while the completion
promise is still valid; the fragment must suspend on that promise.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jonreading81

packages/react-relay/relay-hooks/__tests__/useFragment-WithOperationTrackerSuspense-test.js

@@ -545,4 +545,60 @@ describe('useFragment with Operation Tracker and Suspense behavior', () => {
 
     expect(renderer?.container.textContent).toBe('Alice');
   });
+
+  it('should throw promise via in-flight correlation even when isRequestActive returns false', async () => {
+    // Covers the mid-stream window where isRequestActive can return false
+    // while the operation's completion promise is still in flight (e.g.
+    // `_state === 'loading_final'` before `_complete` fires). The fragment
+    // must still suspend on that promise instead of reading partial data.
+    environment.execute({operation: nodeOperation}).subscribe({});
+
+    const realIsRequestActive =
+      environment.isRequestActive.bind(environment);
+    const isRequestActiveSpy = jest
+      .spyOn(environment, 'isRequestActive')
+      .mockImplementation(id => {
+        if (id === nodeOperation.request.identifier) {
+          return false;
+        }
+        return realIsRequestActive(id);
+      });
+
+    expect(
+      environment.getPromiseForInFlightOperation(
+        nodeOperation.request.identifier,
+      ),
+    ).not.toBeNull();
+    expect(
+      environment.isRequestActive(nodeOperation.request.identifier),
+    ).toBe(false);
+
+    const fragmentRef = {
+      __id: 'user-id-1',
+      __fragments: {
+        useFragmentWithOperationTrackerSuspenseTestFragment: {},
+      },
+      __fragmentOwner: nodeOperation.request,
+    };
+
+    const renderer = await render({userRef: fragmentRef});
+    expect(renderer?.container.textContent).toBe('Singular Fallback');
+
+    isRequestActiveSpy.mockRestore();
+
+    await act(() => {
+      environment.mock.nextValue(nodeOperation, {
+        data: {
+          node: {
+            __typename: 'User',
+            id: 'user-id-1',
+            name: 'Alice',
+          },
+        },
+      });
+      environment.mock.complete(nodeOperation.request.node);
+    });
+
+    expect(renderer?.container.textContent).toBe('Alice');
+  });
 });

packages/relay-runtime/util/getPendingOperationsForFragment.js

@@ -41,8 +41,7 @@ function getPendingOperationsForFragment(
 
   if (
     promise == null &&
-    RelayFeatureFlags.ENABLE_IN_FLIGHT_OPERATION_CORRELATION &&
-    environment.isRequestActive(fragmentOwner.identifier)
+    RelayFeatureFlags.ENABLE_IN_FLIGHT_OPERATION_CORRELATION
   ) {
     const inFlightPromise = environment.getPromiseForInFlightOperation(
       fragmentOwner.identifier,