feat: make signals Serializable (#23400)

Makes serializable local signals: ValueSignal and ListSignal. Serializable ComponentEffect and ComputedSignal.
Adds unit test for basic case: serialize and deserialize session with one UI instance and ensure that ComponentEffect in a Component is still executed when ValueSignal's value is changed.
Same unit tests for Element bindText, bindProperty, bindAttribute, bindEnabled, bindVisible, Signal.computed(), Signal.map.

Part of #22843

Author: tltv

flow-server/src/main/java/com/vaadin/flow/component/ComponentEffect.java

@@ -28,6 +28,7 @@
 import com.vaadin.flow.dom.ElementEffect;
 import com.vaadin.flow.function.SerializableBiConsumer;
 import com.vaadin.flow.function.SerializableFunction;
+import com.vaadin.flow.function.SerializableRunnable;
 import com.vaadin.flow.shared.Registration;
 import com.vaadin.signals.Signal;
 import com.vaadin.signals.function.EffectAction;
@@ -47,10 +48,10 @@
  */
 public final class ComponentEffect implements Serializable {
 
-    private transient ElementEffect elementEffect;
+    private ElementEffect elementEffect;
 
     private <C extends Component> ComponentEffect(C owner,
-            Runnable effectFunction) {
+            SerializableRunnable effectFunction) {
         this.elementEffect = new ElementEffect(owner.getElement(),
                 effectFunction);
     }
@@ -83,7 +84,7 @@ private <C extends Component> ComponentEffect(C owner,
      *         function
      */
     public static <C extends Component> Registration effect(C owner,
-            Runnable effectFunction) {
+            SerializableRunnable effectFunction) {
         ComponentEffect effect = new ComponentEffect(owner, effectFunction);
         return effect::close;
     }

flow-server/src/main/java/com/vaadin/flow/dom/ElementEffect.java

@@ -23,6 +23,7 @@
 import com.vaadin.flow.component.UI;
 import com.vaadin.flow.component.UIDetachedException;
 import com.vaadin.flow.function.SerializableBiConsumer;
+import com.vaadin.flow.function.SerializableRunnable;
 import com.vaadin.flow.server.ErrorEvent;
 import com.vaadin.flow.shared.Registration;
 import com.vaadin.signals.Signal;
@@ -43,12 +44,12 @@
  * @since 25.0
  */
 public final class ElementEffect implements Serializable {
-    private transient final Runnable effectFunction;
+    private final SerializableRunnable effectFunction;
     private boolean closed = false;
-    private transient Effect effect = null;
+    private Effect effect = null;
     private Registration detachRegistration;
 
-    public ElementEffect(Element owner, Runnable effectFunction) {
+    public ElementEffect(Element owner, SerializableRunnable effectFunction) {
         Objects.requireNonNull(owner, "Owner element cannot be null");
         Objects.requireNonNull(effectFunction,
                 "Effect function cannot be null");
@@ -99,7 +100,8 @@ public ElementEffect(Element owner, Runnable effectFunction) {
      * @return a {@link Registration} that can be used to remove the effect
      *         function
      */
-    public static Registration effect(Element owner, Runnable effectFunction) {
+    public static Registration effect(Element owner,
+            SerializableRunnable effectFunction) {
         ElementEffect effect = new ElementEffect(owner, effectFunction);
         return effect::close;
     }

flow-server/src/test/java/com/vaadin/tests/server/component/FlowClassesSerializableTest.java

@@ -16,23 +16,39 @@
 package com.vaadin.tests.server.component;
 
 import java.io.OutputStream;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.mockito.Mockito;
 
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.component.HtmlComponent;
 import com.vaadin.flow.component.HtmlContainer;
 import com.vaadin.flow.component.UI;
 import com.vaadin.flow.dom.Element;
+import com.vaadin.flow.internal.CurrentInstance;
+import com.vaadin.flow.internal.nodefeature.ElementPropertyMap;
+import com.vaadin.flow.internal.nodefeature.PropertyChangeDeniedException;
 import com.vaadin.flow.server.Command;
+import com.vaadin.flow.server.MockVaadinServletService;
+import com.vaadin.flow.server.MockVaadinSession;
 import com.vaadin.flow.server.StreamReceiver;
 import com.vaadin.flow.server.StreamVariable;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.server.VaadinSession;
+import com.vaadin.flow.server.WrappedSession;
+import com.vaadin.flow.server.startup.ApplicationConfiguration;
 import com.vaadin.flow.testutil.ClassesSerializableTest;
+import com.vaadin.signals.local.ValueSignal;
+import com.vaadin.tests.util.MockUI;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 public class FlowClassesSerializableTest extends ClassesSerializableTest {
 
@@ -78,6 +94,128 @@ public void streamResource() throws Throwable {
         }
     }
 
+    @Test
+    public void componentEffectSerializable() {
+        CurrentInstance.clearAll();
+        var service = new MockVaadinServletService() {
+            private final Lock lock = new ReentrantLock();
+            {
+                lock.lock();
+            }
+
+            @Override
+            protected Lock getSessionLock(WrappedSession wrappedSession) {
+                return lock;
+            }
+
+            @Override
+            public void init() {
+                super.init();
+
+                ApplicationConfiguration configuration = Mockito
+                        .mock(ApplicationConfiguration.class);
+                Mockito.when(configuration.isProductionMode()).thenReturn(
+                        getDeploymentConfiguration().isProductionMode());
+                Mockito.when(
+                        configuration.isDevModeSessionSerializationEnabled())
+                        .thenReturn(true);
+                getContext().setAttribute(ApplicationConfiguration.class,
+                        configuration);
+            }
+        };
+        VaadinService.setCurrent(service);
+        var session = new MockVaadinSession(service);
+        session.lock();
+        session.refreshTransients(null, service);
+        MockUI ui = new MockUI(session);
+        ui.doInit(null, 42, "foo");
+        session.addUI(ui);
+
+        ValueSignal<String> signal = new ValueSignal<>("initial");
+        SerializedComponent component = new SerializedComponent(signal);
+        ui.add(component);
+        Assert.assertEquals(1, component.effectExecutionCounter);
+
+        // verify that signal works before serialization
+        signal.value("changed");
+        Assert.assertEquals(2, component.effectExecutionCounter);
+
+        SerializedComponent deserializedComponent;
+        VaadinSession deserializedSession = null;
+        session.unlock(); // serialization happens for unlocked session
+        try {
+            deserializedSession = serializeAndDeserialize(session);
+            assertNotNull(deserializedSession);
+            assertNotSame(deserializedSession, session);
+        } catch (Throwable e) {
+            fail("ComponentEffect should be serializable: " + e.getClass()
+                    + ": " + e.getMessage());
+        }
+        deserializedSession.refreshTransients(null, service);
+        deserializedSession.lock();
+
+        UI deserializedUi = deserializedSession.getUIs().iterator().next();
+        deserializedComponent = deserializedUi.getChildren()
+                .filter(SerializedComponent.class::isInstance)
+                .map(SerializedComponent.class::cast).findFirst()
+                .orElseThrow(() -> new AssertionError(
+                        "SerializedComponent has not been deserialized"));
+        assertNotSame(deserializedComponent, component);
+
+        UI.setCurrent(deserializedUi);
+        deserializedComponent.signal.value("changed after deserialization");
+        Assert.assertEquals(3, deserializedComponent.effectExecutionCounter);
+        deserializedComponent.signal.value("changed");
+        Assert.assertEquals(4, deserializedComponent.effectExecutionCounter);
+
+        signal.value("changed in original signal");
+        // original signal change should not affect deserialized component
+        Assert.assertEquals(4, deserializedComponent.effectExecutionCounter);
+
+        // remove registration and verify that effect is not called anymore
+        deserializedComponent.registration.remove();
+        deserializedComponent.signal.value("foo");
+        Assert.assertEquals(4, deserializedComponent.effectExecutionCounter);
+
+        // verify various bindX methods
+        Assert.assertEquals("foo",
+                deserializedComponent.getElement().getText());
+        Assert.assertEquals("foo",
+                deserializedComponent.getElement().getAttribute("attr"));
+        Assert.assertEquals("foo",
+                deserializedComponent.getElement().getProperty("prop"));
+        Assert.assertEquals("foo!!!",
+                deserializedComponent.getElement().getProperty("two-way-prop"));
+        // verify that two-way-binding works
+        emulateClientUpdate(deserializedComponent.getElement(), "two-way-prop",
+                "bar!!!");
+        Assert.assertEquals("bar!!!",
+                deserializedComponent.getElement().getProperty("two-way-prop"));
+        Assert.assertEquals("bar", deserializedComponent.signal.peek());
+
+        // verify mapped and computed signals with bindEnabled and bindVisible
+        Assert.assertTrue(deserializedComponent.getElement().isEnabled());
+        Assert.assertTrue(deserializedComponent.getElement().isVisible());
+        deserializedComponent.signal.value(null);
+        Assert.assertFalse(deserializedComponent.getElement().isEnabled());
+        Assert.assertFalse(deserializedComponent.getElement().isVisible());
+
+        deserializedSession.unlock();
+        VaadinService.setCurrent(null);
+    }
+
+    private void emulateClientUpdate(Element element, String property,
+            String value) {
+        ElementPropertyMap childModel = ElementPropertyMap
+                .getModel(element.getNode());
+        try {
+            childModel.deferredUpdateFromClient(property, value);
+        } catch (PropertyChangeDeniedException e) {
+            Assert.fail(
+                    "Failed to update property from client: " + e.getMessage());
+        }
+    }
+
     private static class MyStreamVariable implements StreamVariable {
         @Override
         public OutputStream getOutputStream() {

flow-server/src/test/java/com/vaadin/tests/server/component/SerializedComponent.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.tests.server.component;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.ComponentEffect;
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.shared.Registration;
+import com.vaadin.signals.Signal;
+import com.vaadin.signals.local.ValueSignal;
+
+/**
+ * Serializable test component using ComponentEffect.
+ */
+@Tag("div")
+class SerializedComponent extends Component {
+    int effectExecutionCounter = 0;
+    ValueSignal<String> signal;
+    Registration registration;
+
+    SerializedComponent(ValueSignal<String> signal) {
+        this.signal = signal;
+
+        registration = ComponentEffect.effect(this, () -> {
+            signal.value();
+            effectExecutionCounter++;
+        });
+
+        getElement().bindText(signal);
+        getElement().bindAttribute("attr", signal);
+        getElement().bindProperty("prop", signal);
+        getElement().bindEnabled(
+                signal.map(value -> value != null && !value.isEmpty()));
+        getElement().bindVisible(Signal.computed(() -> signal.value() != null));
+
+        getElement().bindProperty("two-way-prop", signal.map(str -> str + "!!!",
+                (str, value) -> value.replace("!!!", "")));
+
+        // sync property from the client
+        getElement().addPropertyChangeListener("two-way-prop",
+                "two-way-prop-changed", e -> {
+                });
+    }
+
+}

signals/src/main/java/com/vaadin/signals/Id.java

@@ -15,6 +15,7 @@
  */
 package com.vaadin.signals;
 
+import java.io.Serializable;
 import java.math.BigInteger;
 import java.util.Base64;
 import java.util.Base64.Encoder;
@@ -36,7 +37,7 @@
  * @param value
  *            the id value as a 64-bit integer
  */
-public record Id(long value) implements Comparable<Id> {
+public record Id(long value) implements Comparable<Id>, Serializable {
     /**
      * Default or initial id in various contexts. Always used for the root node
      * in a signal hierarchy. The zero id is frequently used and has a custom

signals/src/main/java/com/vaadin/signals/Node.java

@@ -15,6 +15,7 @@
  */
 package com.vaadin.signals;
 
+import java.io.Serializable;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -39,7 +40,7 @@
         @Type(value = Node.Alias.class, name = "a")
 
 })
-public sealed interface Node {
+public sealed interface Node extends Serializable {
 
     /**
      * An empty data node without parent, scope owner, value or children and the

signals/src/main/java/com/vaadin/signals/Signal.java

@@ -15,6 +15,7 @@
  */
 package com.vaadin.signals;
 
+import java.io.Serializable;
 import java.util.Objects;
 
 import com.vaadin.signals.function.CleanupCallback;
@@ -49,7 +50,7 @@
  *            the signal value type
  */
 @FunctionalInterface
-public interface Signal<T> {
+public interface Signal<T> extends Serializable {
     /**
      * Gets the current value of this signal. The value is read in a way that
      * takes the current transaction into account and in the case of clustering

signals/src/main/java/com/vaadin/signals/SignalCommand.java

@@ -15,6 +15,7 @@
  */
 package com.vaadin.signals;
 
+import java.io.Serializable;
 import java.util.List;
 import java.util.Map;
 
@@ -55,7 +56,7 @@
         @Type(value = SignalCommand.SnapshotCommand.class, name = "snapshot"),
 
 })
-public sealed interface SignalCommand {
+public sealed interface SignalCommand extends Serializable {
     /**
      * A signal command that sets the value of a signal.
      */

signals/src/main/java/com/vaadin/signals/function/CleanupCallback.java

@@ -15,6 +15,8 @@
  */
 package com.vaadin.signals.function;
 
+import java.io.Serializable;
+
 import com.vaadin.signals.Signal;
 
 /**
@@ -28,7 +30,7 @@
  * @see Signal#effect(EffectAction)
  */
 @FunctionalInterface
-public interface CleanupCallback {
+public interface CleanupCallback extends Serializable {
     /**
      * Performs cleanup operations such as unregistering listeners or disposing
      * resources.

signals/src/main/java/com/vaadin/signals/function/CommandValidator.java

@@ -15,6 +15,7 @@
  */
 package com.vaadin.signals.function;
 
+import java.io.Serializable;
 import java.util.Objects;
 
 import com.vaadin.signals.SignalCommand;
@@ -28,7 +29,7 @@
  * require multiple validation rules to pass.
  */
 @FunctionalInterface
-public interface CommandValidator {
+public interface CommandValidator extends Serializable {
     /**
      * A validator that accepts all commands without restriction.
      */