fix: clear repeatable read transaction before running access tasks (#24400) (CP: 25.1) (#24426)

This PR cherry-picks changes from the original PR #24400 to branch 25.1.
---
#### Original PR description
> ## Summary
> 
> - Clear the session-scoped transaction **before** running pending
access tasks during session unlock
> - This ensures effects triggered by access tasks see fresh signal
values instead of stale cached values from the repeatable read
transaction
> - Added a unit test to verify that clearing the transaction fallback
allows fresh reads
> 
> ## Details
> 
> When a shared signal is updated concurrently with an ongoing UIDL
request, effects associated with that UI would run with the repeatable
read transaction used for the request. If the transaction cached the old
value, effects would miss the update.
> 
> The fix moves `sessionScopedTransaction = null` to execute before
`runPendingAccessTasks()` instead of after, ensuring access tasks read
fresh values.
> 
> ## Test plan
> 
> - [ ] Existing unit tests pass
> - [ ] New `clearingFallback_allowsFreshReads` test verifies the fix
behavior
> - [ ] Manual test with the reproduction case from the issue
> 
> Fixes #24399
> 
> Slack thread:
https://vaadin.slack.com/archives/C6RAXJATF/p1779368249043829?thread_ts=1779368185.339629&cid=C6RAXJATF
> 
> https://claude.ai/code/session_01QW3F8K4uxGyaUNa9xwoKTR
> 
> ---
> _Generated by [Claude
Code](https://claude.ai/code/session_01QW3F8K4uxGyaUNa9xwoKTR)_

Co-authored-by: Artur Signell <artur@vaadin.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

flow-server/src/main/java/com/vaadin/flow/server/VaadinService.java

@@ -2337,6 +2337,9 @@ public void runPendingAccessTasks(VaadinSession session) {
                 if (!pendingAccess.isCancelled()) {
                     CurrentInstance.clearAll();
                     CurrentInstance.setCurrent(session);
+                    // Clear session-scoped transaction so each task gets fresh
+                    // reads from shared signals instead of stale cached values
+                    session.clearSessionScopedTransaction();
                     pendingAccess.run();
 
                     try {

flow-server/src/main/java/com/vaadin/flow/server/VaadinSession.java

@@ -721,6 +721,17 @@ Transaction getOrCreateSessionScopedTransaction() {
         return sessionScopedTransaction;
     }
 
+    /**
+     * Clears the session-scoped transaction so that the next signal operation
+     * will create a fresh transaction with up-to-date values.
+     * <p>
+     * The session lock must be held when calling this method.
+     */
+    void clearSessionScopedTransaction() {
+        assert hasLock();
+        sessionScopedTransaction = null;
+    }
+
     /**
      * Locks this session to protect its data from concurrent access. Accessing
      * the UI state from outside the normal request handling should always lock

flow-server/src/test/java/com/vaadin/flow/dom/ElementEffectTest.java

@@ -47,6 +47,7 @@
 import com.vaadin.flow.signals.local.ListSignal;
 import com.vaadin.flow.signals.local.ValueSignal;
 import com.vaadin.flow.signals.shared.SharedListSignal;
+import com.vaadin.flow.signals.shared.SharedValueSignal;
 import com.vaadin.tests.util.MockUI;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -456,6 +457,54 @@ void effect_triggeredWithOtherUILocked_effectRunAsynchronously() {
                 "Effect should run with correct UI context");
     }
 
+    @Test
+    void effect_sharedSignalUpdatedOutsideSessionTransaction_reRunsWithFreshValue() {
+        // Reproduces issue #24399: while a UIDL request holds the session
+        // lock, the session's repeatable-read transaction has cached the
+        // current signal value. A concurrent write to that signal — done
+        // outside the session transaction, simulating another session or
+        // a background message handler — must trigger the effect to
+        // re-run with the fresh value, not the stale value cached in the
+        // session transaction.
+        CurrentInstance.clearAll();
+        VaadinService.setCurrent(service);
+
+        var session = new MockVaadinSession(service);
+        session.lock();
+        VaadinSession.setCurrent(session);
+        var ui = new MockUI(session);
+
+        SharedValueSignal<String> signal = new SharedValueSignal<>("initial");
+        List<String> observed = new ArrayList<>();
+        Signal.effect(ui, () -> observed.add(signal.get()));
+
+        // Initial run executes inline (UI.getCurrent() == ui) and reads
+        // through the session-scoped write-through transaction, priming
+        // its repeatable-read cache with "initial".
+        assertEquals(List.of("initial"), observed,
+                "Effect should run once initially");
+
+        // Clear UI thread-local so the effect dispatcher takes the
+        // async path and routes the re-run through ui.access(), which
+        // enqueues a FutureAccess while the session lock is held.
+        UI.setCurrent(null);
+
+        // Update the signal outside the session's repeatable-read
+        // transaction (runWithoutTransaction routes the write through
+        // ROOT). The tree's submitted snapshot becomes "external"
+        // while the session transaction still caches "initial".
+        Signal.runWithoutTransaction(() -> signal.set("external"));
+
+        // Flush the effect dispatcher (queued in TestService's
+        // FlushableExecutor) and then run pending access tasks —
+        // simulating session unlock at the end of a UIDL request.
+        service.flushExecutorAndAccessTasks(session);
+
+        assertEquals(List.of("initial", "external"), observed,
+                "Effect re-run must observe the fresh signal value, not the "
+                        + "stale value cached in the session transaction");
+    }
+
     @Test
     void effect_throwExceptionWhenRunningDirectly_delegatedToErrorHandler() {
         CurrentInstance.clearAll();