diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/BavetConstraintSessionFactory.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/BavetConstraintSessionFactory.java
index 1670d44378..d9127373b5 100644
--- a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/BavetConstraintSessionFactory.java
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/BavetConstraintSessionFactory.java
@@ -11,12 +11,15 @@
 import java.util.SortedMap;
 import java.util.TreeMap;
 
+import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
 import ai.timefold.solver.constraint.streams.bavet.common.AbstractIfExistsNode;
 import ai.timefold.solver.constraint.streams.bavet.common.AbstractJoinNode;
 import ai.timefold.solver.constraint.streams.bavet.common.AbstractNode;
 import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetConcatConstraintStream;
 import ai.timefold.solver.constraint.streams.bavet.common.BavetIfExistsConstraintStream;
 import ai.timefold.solver.constraint.streams.bavet.common.BavetJoinConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetStreamBinaryOperation;
 import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
 import ai.timefold.solver.constraint.streams.bavet.common.PropagationQueue;
 import ai.timefold.solver.constraint.streams.bavet.common.Propagator;
@@ -134,19 +137,14 @@ private long determineLayerIndex(AbstractNode node, NodeBuildHelper<Score_> buil
         if (node instanceof AbstractForEachUniNode<?>) { // ForEach nodes, and only they, are in layer 0.
             return 0;
         } else if (node instanceof AbstractJoinNode<?, ?, ?> joinNode) {
-            var nodeCreator = (BavetJoinConstraintStream<?>) buildHelper.getNodeCreatingStream(joinNode);
-            var leftParent = nodeCreator.getLeftParent();
-            var rightParent = nodeCreator.getRightParent();
-            var leftParentNode = buildHelper.findParentNode(leftParent);
-            var rightParentNode = buildHelper.findParentNode(rightParent);
-            return Math.max(leftParentNode.getLayerIndex(), rightParentNode.getLayerIndex()) + 1;
+            return determineLayerIndexOfBinaryOperation(
+                    (BavetJoinConstraintStream<?>) buildHelper.getNodeCreatingStream(joinNode), buildHelper);
+        } else if (node instanceof AbstractConcatNode<?> concatNode) {
+            return determineLayerIndexOfBinaryOperation(
+                    (BavetConcatConstraintStream<?>) buildHelper.getNodeCreatingStream(concatNode), buildHelper);
         } else if (node instanceof AbstractIfExistsNode<?, ?> ifExistsNode) {
-            var nodeCreator = (BavetIfExistsConstraintStream<?>) buildHelper.getNodeCreatingStream(ifExistsNode);
-            var leftParent = nodeCreator.getLeftParent();
-            var rightParent = nodeCreator.getRightParent();
-            var leftParentNode = buildHelper.findParentNode(leftParent);
-            var rightParentNode = buildHelper.findParentNode(rightParent);
-            return Math.max(leftParentNode.getLayerIndex(), rightParentNode.getLayerIndex()) + 1;
+            return determineLayerIndexOfBinaryOperation(
+                    (BavetIfExistsConstraintStream<?>) buildHelper.getNodeCreatingStream(ifExistsNode), buildHelper);
         } else {
             var nodeCreator = (BavetAbstractConstraintStream<?>) buildHelper.getNodeCreatingStream(node);
             var parentNode = buildHelper.findParentNode(nodeCreator.getParent());
@@ -154,4 +152,13 @@ private long determineLayerIndex(AbstractNode node, NodeBuildHelper<Score_> buil
         }
     }
 
+    private long determineLayerIndexOfBinaryOperation(BavetStreamBinaryOperation<?> nodeCreator,
+            NodeBuildHelper<Score_> buildHelper) {
+        var leftParent = nodeCreator.getLeftParent();
+        var rightParent = nodeCreator.getRightParent();
+        var leftParentNode = buildHelper.findParentNode(leftParent);
+        var rightParentNode = buildHelper.findParentNode(rightParent);
+        return Math.max(leftParentNode.getLayerIndex(), rightParentNode.getLayerIndex()) + 1;
+    }
+
 }
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetAbstractBiConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetAbstractBiConstraintStream.java
index a725fbef27..83e55e260d 100644
--- a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetAbstractBiConstraintStream.java
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetAbstractBiConstraintStream.java
@@ -359,6 +359,19 @@ public BiConstraintStream<A, B> distinct() {
         }
     }
 
+    @Override
+    public BiConstraintStream<A, B> concat(BiConstraintStream<A, B> otherStream) {
+        var other = (BavetAbstractBiConstraintStream<Solution_, A, B>) otherStream;
+        var leftBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, this);
+        var rightBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, other);
+        var concatStream = new BavetConcatBiConstraintStream<>(constraintFactory, leftBridge, rightBridge);
+        return constraintFactory.share(concatStream, concatStream_ -> {
+            // Connect the bridges upstream
+            getChildStreamList().add(leftBridge);
+            other.getChildStreamList().add(rightBridge);
+        });
+    }
+
     @Override
     public <ResultA_> UniConstraintStream<ResultA_> map(BiFunction<A, B, ResultA_> mapping) {
         var stream = shareAndAddChild(new BavetUniMapBiConstraintStream<>(constraintFactory, this, mapping));
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetBiConcatNode.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetBiConcatNode.java
new file mode 100644
index 0000000000..395d2e3546
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetBiConcatNode.java
@@ -0,0 +1,25 @@
+package ai.timefold.solver.constraint.streams.bavet.bi;
+
+import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+
+public final class BavetBiConcatNode<A, B> extends AbstractConcatNode<BiTuple<A, B>> {
+
+    BavetBiConcatNode(TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int inputStoreIndexLeftOutTupleList,
+            int inputStoreIndexRightOutTupleList,
+            int outputStoreSize) {
+        super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
+    }
+
+    @Override
+    protected BiTuple<A, B> getOutTuple(BiTuple<A, B> inTuple) {
+        return new BiTuple<>(inTuple.factA, inTuple.factB, outputStoreSize);
+    }
+
+    @Override
+    protected void updateOutTuple(BiTuple<A, B> inTuple, BiTuple<A, B> outTuple) {
+        outTuple.factA = inTuple.factA;
+        outTuple.factB = inTuple.factB;
+    }
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetConcatBiConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetConcatBiConstraintStream.java
new file mode 100644
index 0000000000..fdd08c8259
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/bi/BavetConcatBiConstraintStream.java
@@ -0,0 +1,104 @@
+package ai.timefold.solver.constraint.streams.bavet.bi;
+
+import java.util.Objects;
+import java.util.Set;
+
+import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetConcatConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
+import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+import ai.timefold.solver.core.api.score.Score;
+
+public final class BavetConcatBiConstraintStream<Solution_, A, B> extends BavetAbstractBiConstraintStream<Solution_, A, B>
+        implements BavetConcatConstraintStream<Solution_> {
+
+    private final BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent;
+    private final BavetForeBridgeBiConstraintStream<Solution_, A, B> rightParent;
+
+    public BavetConcatBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
+            BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
+            BavetForeBridgeBiConstraintStream<Solution_, A, B> rightParent) {
+        super(constraintFactory, leftParent.getRetrievalSemantics());
+        this.leftParent = leftParent;
+        this.rightParent = rightParent;
+    }
+
+    @Override
+    public boolean guaranteesDistinct() {
+        return false;
+    }
+
+    // ************************************************************************
+    // Node creation
+    // ************************************************************************
+
+    @Override
+    public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
+        leftParent.collectActiveConstraintStreams(constraintStreamSet);
+        rightParent.collectActiveConstraintStreams(constraintStreamSet);
+        constraintStreamSet.add(this);
+    }
+
+    @Override
+    public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
+        TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
+        int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
+        int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
+        int outputStoreSize = buildHelper.extractTupleStoreSize(this);
+        var node = new BavetBiConcatNode<>(downstream,
+                leftCloneStoreIndex,
+                rightCloneStoreIndex,
+                outputStoreSize);
+        buildHelper.addNode(node, this, leftParent, rightParent);
+    }
+
+    // ************************************************************************
+    // Equality for node sharing
+    // ************************************************************************
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        BavetConcatBiConstraintStream<?, ?, ?> other = (BavetConcatBiConstraintStream<?, ?, ?>) o;
+        /*
+         * Bridge streams do not implement equality because their equals() would have to point back to this stream,
+         * resulting in StackOverflowError.
+         * Therefore we need to check bridge parents to see where this concat node comes from.
+         */
+        return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
+                && Objects.equals(rightParent.getParent(), other.rightParent.getParent());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(leftParent.getParent(), rightParent.getParent());
+    }
+
+    @Override
+    public String toString() {
+        return "Concat() with " + childStreamList.size() + " children";
+    }
+
+    // ************************************************************************
+    // Getters/setters
+    // ************************************************************************
+
+    @Override
+    public BavetAbstractConstraintStream<Solution_> getLeftParent() {
+        return leftParent;
+    }
+
+    @Override
+    public BavetAbstractConstraintStream<Solution_> getRightParent() {
+        return rightParent;
+    }
+
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/AbstractConcatNode.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/AbstractConcatNode.java
new file mode 100644
index 0000000000..9d4f251a01
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/AbstractConcatNode.java
@@ -0,0 +1,134 @@
+package ai.timefold.solver.constraint.streams.bavet.common;
+
+import static ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleState.ABORTING;
+import static ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleState.CREATING;
+import static ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleState.DYING;
+import static ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleState.UPDATING;
+
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.AbstractTuple;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.LeftTupleLifecycle;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.RightTupleLifecycle;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleState;
+
+/**
+ * Implements the concat operation. Concat cannot be implemented as a pass-through operation because of two caveats:
+ *
+ * <ul>
+ * <li>It is possible to have the same {@link TupleSource} for both parent streams,
+ * in which case the exact same tuple can be inserted twice. Such a tuple
+ * should be counted twice downstream, and thus need to be cloned.
+ * </li>
+ *
+ * <li>Because concat has two parent nodes, it must be a {@link TupleSource} (since
+ * all nodes have exactly one {@link TupleSource}, and the source tuple can come from
+ * either parent). {@link TupleSource} must produce new tuples and not reuse them, since
+ * if tuples are reused, the stores inside them get corrupted.
+ * </li>
+ * </ul>
+ *
+ * The {@link AbstractConcatNode} works by creating a copy of the source tuple and putting it into
+ * the tuple's store. If the same tuple is inserted twice (i.e. when the left and right parent
+ * have the same {@link TupleSource}), it creates another clone.
+ */
+public abstract class AbstractConcatNode<Tuple_ extends AbstractTuple>
+        extends AbstractNode
+        implements LeftTupleLifecycle<Tuple_>, RightTupleLifecycle<Tuple_> {
+    private final int leftSourceTupleCloneStoreIndex;
+    private final int rightSourceTupleCloneStoreIndex;
+    protected final int outputStoreSize;
+    private final StaticPropagationQueue<Tuple_> propagationQueue;
+
+    protected AbstractConcatNode(TupleLifecycle<Tuple_> nextNodesTupleLifecycle,
+            int leftSourceTupleCloneStoreIndex,
+            int rightSourceTupleCloneStoreIndex,
+            int outputStoreSize) {
+        this.propagationQueue = new StaticPropagationQueue<>(nextNodesTupleLifecycle);
+        this.leftSourceTupleCloneStoreIndex = leftSourceTupleCloneStoreIndex;
+        this.rightSourceTupleCloneStoreIndex = rightSourceTupleCloneStoreIndex;
+        this.outputStoreSize = outputStoreSize;
+    }
+
+    /**
+     * Creates a copy of the inTuple with the same fact (and new store/state).
+     */
+    protected abstract Tuple_ getOutTuple(Tuple_ inTuple);
+
+    /**
+     * Updates outTuple to contain the same facts as inTuple.
+     */
+    protected abstract void updateOutTuple(Tuple_ inTuple, Tuple_ outTuple);
+
+    private void insert(Tuple_ tuple, int storeIndex) {
+        Tuple_ outTuple = getOutTuple(tuple);
+        tuple.setStore(storeIndex, outTuple);
+        propagationQueue.insert(outTuple);
+    }
+
+    private void update(Tuple_ tuple, int storeIndex) {
+        Tuple_ outTuple = tuple.getStore(storeIndex);
+        if (outTuple == null) {
+            // No fail fast if null because we don't track which tuples made it through the filter predicate(s)
+            insert(tuple, storeIndex);
+            return;
+        }
+
+        updateOutTuple(tuple, outTuple);
+        // Even if the facts of tuple do not change, an update MUST be done so
+        // downstream nodes get notified of updates in planning variables.
+        TupleState previousState = outTuple.state;
+        if (previousState == CREATING || previousState == UPDATING) {
+            return;
+        }
+        propagationQueue.update(outTuple);
+    }
+
+    private void retract(Tuple_ tuple, int storeIndex) {
+        Tuple_ outTuple = tuple.getStore(storeIndex);
+        if (outTuple == null) {
+            // No fail fast if null because we don't track which tuples made it through the filter predicate(s)
+            return;
+        }
+        TupleState state = outTuple.state;
+        if (!state.isActive()) {
+            throw new IllegalStateException("Impossible state: The tuple (" + outTuple.state + ") in node (" + this
+                    + ") is in an unexpected state (" + outTuple.state + ").");
+        }
+        propagationQueue.retract(outTuple, state == CREATING ? ABORTING : DYING);
+    }
+
+    @Override
+    public final void insertLeft(Tuple_ tuple) {
+        insert(tuple, leftSourceTupleCloneStoreIndex);
+    }
+
+    @Override
+    public final void updateLeft(Tuple_ tuple) {
+        update(tuple, leftSourceTupleCloneStoreIndex);
+    }
+
+    @Override
+    public final void retractLeft(Tuple_ tuple) {
+        retract(tuple, leftSourceTupleCloneStoreIndex);
+    }
+
+    @Override
+    public final void insertRight(Tuple_ tuple) {
+        insert(tuple, rightSourceTupleCloneStoreIndex);
+    }
+
+    @Override
+    public final void updateRight(Tuple_ tuple) {
+        update(tuple, rightSourceTupleCloneStoreIndex);
+    }
+
+    @Override
+    public final void retractRight(Tuple_ tuple) {
+        retract(tuple, rightSourceTupleCloneStoreIndex);
+    }
+
+    @Override
+    public Propagator getPropagator() {
+        return propagationQueue;
+    }
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetConcatConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetConcatConstraintStream.java
new file mode 100644
index 0000000000..d46217b49f
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetConcatConstraintStream.java
@@ -0,0 +1,6 @@
+package ai.timefold.solver.constraint.streams.bavet.common;
+
+public interface BavetConcatConstraintStream<Solution_>
+        extends BavetStreamBinaryOperation<Solution_>, TupleSource {
+
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetIfExistsConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetIfExistsConstraintStream.java
index ef466636de..08561fe1e6 100644
--- a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetIfExistsConstraintStream.java
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetIfExistsConstraintStream.java
@@ -1,15 +1,5 @@
 package ai.timefold.solver.constraint.streams.bavet.common;
 
-import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
-
-public interface BavetIfExistsConstraintStream<Solution_> {
-
-    BavetAbstractConstraintStream<Solution_> getLeftParent();
-
-    /**
-     *
-     * @return An instance of {@link BavetForeBridgeUniConstraintStream}.
-     */
-    BavetAbstractConstraintStream<Solution_> getRightParent();
+public interface BavetIfExistsConstraintStream<Solution_> extends BavetStreamBinaryOperation<Solution_> {
 
 }
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetJoinConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetJoinConstraintStream.java
index adb21f51e1..05b90482e5 100644
--- a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetJoinConstraintStream.java
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetJoinConstraintStream.java
@@ -3,7 +3,7 @@
 import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
 
 public interface BavetJoinConstraintStream<Solution_>
-        extends TupleSource {
+        extends BavetStreamBinaryOperation<Solution_>, TupleSource {
 
     /**
      *
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetStreamBinaryOperation.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetStreamBinaryOperation.java
new file mode 100644
index 0000000000..aba1e38425
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/BavetStreamBinaryOperation.java
@@ -0,0 +1,16 @@
+package ai.timefold.solver.constraint.streams.bavet.common;
+
+import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
+
+public interface BavetStreamBinaryOperation<Solution_> {
+    /**
+     * @return An instance of {@link BavetForeBridgeUniConstraintStream}.
+     */
+    BavetAbstractConstraintStream<Solution_> getLeftParent();
+
+    /**
+     * @return An instance of {@link BavetForeBridgeUniConstraintStream}.
+     */
+    BavetAbstractConstraintStream<Solution_> getRightParent();
+
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetForeBridgeQuadConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetForeBridgeQuadConstraintStream.java
new file mode 100644
index 0000000000..77b8f30bb3
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetForeBridgeQuadConstraintStream.java
@@ -0,0 +1,34 @@
+package ai.timefold.solver.constraint.streams.bavet.common.bridge;
+
+import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
+import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
+import ai.timefold.solver.constraint.streams.bavet.quad.BavetAbstractQuadConstraintStream;
+import ai.timefold.solver.core.api.score.Score;
+
+public final class BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D>
+        extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
+
+    public BavetForeBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
+            BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent) {
+        super(constraintFactory, parent);
+    }
+
+    // ************************************************************************
+    // Node creation
+    // ************************************************************************
+
+    @Override
+    public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
+        // Do nothing. The child stream builds everything.
+    }
+
+    @Override
+    public String toString() {
+        return "Generic bridge";
+    }
+
+    // ************************************************************************
+    // Getters/setters
+    // ************************************************************************
+
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetAbstractQuadConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetAbstractQuadConstraintStream.java
index 71cc3ba05f..7684ba04aa 100644
--- a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetAbstractQuadConstraintStream.java
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetAbstractQuadConstraintStream.java
@@ -14,6 +14,7 @@
 import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
 import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
 import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
 import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
 import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
 import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
@@ -347,6 +348,19 @@ public QuadConstraintStream<A, B, C, D> distinct() {
         }
     }
 
+    @Override
+    public QuadConstraintStream<A, B, C, D> concat(QuadConstraintStream<A, B, C, D> otherStream) {
+        var other = (BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>) otherStream;
+        var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
+        var rightBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, other);
+        var concatStream = new BavetConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge);
+        return constraintFactory.share(concatStream, concatStream_ -> {
+            // Connect the bridges upstream
+            getChildStreamList().add(leftBridge);
+            other.getChildStreamList().add(rightBridge);
+        });
+    }
+
     @Override
     public <ResultA_> UniConstraintStream<ResultA_> map(QuadFunction<A, B, C, D, ResultA_> mapping) {
         var stream = shareAndAddChild(new BavetUniMapQuadConstraintStream<>(constraintFactory, this, mapping));
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetConcatQuadConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetConcatQuadConstraintStream.java
new file mode 100644
index 0000000000..c7da61cf51
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetConcatQuadConstraintStream.java
@@ -0,0 +1,105 @@
+package ai.timefold.solver.constraint.streams.bavet.quad;
+
+import java.util.Objects;
+import java.util.Set;
+
+import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetConcatConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
+import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+import ai.timefold.solver.core.api.score.Score;
+
+public final class BavetConcatQuadConstraintStream<Solution_, A, B, C, D>
+        extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
+        implements BavetConcatConstraintStream<Solution_> {
+
+    private final BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent;
+    private final BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent;
+
+    public BavetConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
+            BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
+            BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent) {
+        super(constraintFactory, leftParent.getRetrievalSemantics());
+        this.leftParent = leftParent;
+        this.rightParent = rightParent;
+    }
+
+    @Override
+    public boolean guaranteesDistinct() {
+        return false;
+    }
+
+    // ************************************************************************
+    // Node creation
+    // ************************************************************************
+
+    @Override
+    public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
+        leftParent.collectActiveConstraintStreams(constraintStreamSet);
+        rightParent.collectActiveConstraintStreams(constraintStreamSet);
+        constraintStreamSet.add(this);
+    }
+
+    @Override
+    public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
+        TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
+        int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
+        int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
+        int outputStoreSize = buildHelper.extractTupleStoreSize(this);
+        var node = new BavetQuadConcatNode<>(downstream,
+                leftCloneStoreIndex,
+                rightCloneStoreIndex,
+                outputStoreSize);
+        buildHelper.addNode(node, this, leftParent, rightParent);
+    }
+
+    // ************************************************************************
+    // Equality for node sharing
+    // ************************************************************************
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        BavetConcatQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetConcatQuadConstraintStream<?, ?, ?, ?, ?>) o;
+        /*
+         * Bridge streams do not implement equality because their equals() would have to point back to this stream,
+         * resulting in StackOverflowError.
+         * Therefore we need to check bridge parents to see where this concat node comes from.
+         */
+        return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
+                && Objects.equals(rightParent.getParent(), other.rightParent.getParent());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(leftParent.getParent(), rightParent.getParent());
+    }
+
+    @Override
+    public String toString() {
+        return "Concat() with " + childStreamList.size() + " children";
+    }
+
+    // ************************************************************************
+    // Getters/setters
+    // ************************************************************************
+
+    @Override
+    public BavetAbstractConstraintStream<Solution_> getLeftParent() {
+        return leftParent;
+    }
+
+    @Override
+    public BavetAbstractConstraintStream<Solution_> getRightParent() {
+        return rightParent;
+    }
+
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetQuadConcatNode.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetQuadConcatNode.java
new file mode 100644
index 0000000000..fa9603a7d1
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/quad/BavetQuadConcatNode.java
@@ -0,0 +1,26 @@
+package ai.timefold.solver.constraint.streams.bavet.quad;
+
+import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+
+public final class BavetQuadConcatNode<A, B, C, D> extends AbstractConcatNode<QuadTuple<A, B, C, D>> {
+
+    BavetQuadConcatNode(TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
+            int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList, int outputStoreSize) {
+        super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
+    }
+
+    @Override
+    protected QuadTuple<A, B, C, D> getOutTuple(QuadTuple<A, B, C, D> inTuple) {
+        return new QuadTuple<>(inTuple.factA, inTuple.factB, inTuple.factC, inTuple.factD, outputStoreSize);
+    }
+
+    @Override
+    protected void updateOutTuple(QuadTuple<A, B, C, D> inTuple, QuadTuple<A, B, C, D> outTuple) {
+        outTuple.factA = inTuple.factA;
+        outTuple.factB = inTuple.factB;
+        outTuple.factC = inTuple.factC;
+        outTuple.factD = inTuple.factD;
+    }
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetAbstractTriConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetAbstractTriConstraintStream.java
index b97e3c73c2..5812b8dd69 100644
--- a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetAbstractTriConstraintStream.java
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetAbstractTriConstraintStream.java
@@ -370,6 +370,19 @@ public TriConstraintStream<A, B, C> distinct() {
         }
     }
 
+    @Override
+    public TriConstraintStream<A, B, C> concat(TriConstraintStream<A, B, C> otherStream) {
+        var other = (BavetAbstractTriConstraintStream<Solution_, A, B, C>) otherStream;
+        var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
+        var rightBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, other);
+        var concatStream = new BavetConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge);
+        return constraintFactory.share(concatStream, concatStream_ -> {
+            // Connect the bridges upstream
+            getChildStreamList().add(leftBridge);
+            other.getChildStreamList().add(rightBridge);
+        });
+    }
+
     @Override
     public <ResultA_> UniConstraintStream<ResultA_> map(TriFunction<A, B, C, ResultA_> mapping) {
         var stream = shareAndAddChild(new BavetUniMapTriConstraintStream<>(constraintFactory, this, mapping));
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetConcatTriConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetConcatTriConstraintStream.java
new file mode 100644
index 0000000000..1191f1977d
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetConcatTriConstraintStream.java
@@ -0,0 +1,105 @@
+package ai.timefold.solver.constraint.streams.bavet.tri;
+
+import java.util.Objects;
+import java.util.Set;
+
+import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetConcatConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
+import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+import ai.timefold.solver.core.api.score.Score;
+
+public final class BavetConcatTriConstraintStream<Solution_, A, B, C>
+        extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
+        implements BavetConcatConstraintStream<Solution_> {
+
+    private final BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent;
+    private final BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent;
+
+    public BavetConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
+            BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
+            BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent) {
+        super(constraintFactory, leftParent.getRetrievalSemantics());
+        this.leftParent = leftParent;
+        this.rightParent = rightParent;
+    }
+
+    @Override
+    public boolean guaranteesDistinct() {
+        return false;
+    }
+
+    // ************************************************************************
+    // Node creation
+    // ************************************************************************
+
+    @Override
+    public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
+        leftParent.collectActiveConstraintStreams(constraintStreamSet);
+        rightParent.collectActiveConstraintStreams(constraintStreamSet);
+        constraintStreamSet.add(this);
+    }
+
+    @Override
+    public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
+        TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
+        int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
+        int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
+        int outputStoreSize = buildHelper.extractTupleStoreSize(this);
+        var node = new BavetTriConcatNode<>(downstream,
+                leftCloneStoreIndex,
+                rightCloneStoreIndex,
+                outputStoreSize);
+        buildHelper.addNode(node, this, leftParent, rightParent);
+    }
+
+    // ************************************************************************
+    // Equality for node sharing
+    // ************************************************************************
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        BavetConcatTriConstraintStream<?, ?, ?, ?> other = (BavetConcatTriConstraintStream<?, ?, ?, ?>) o;
+        /*
+         * Bridge streams do not implement equality because their equals() would have to point back to this stream,
+         * resulting in StackOverflowError.
+         * Therefore we need to check bridge parents to see where this concat node comes from.
+         */
+        return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
+                && Objects.equals(rightParent.getParent(), other.rightParent.getParent());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(leftParent.getParent(), rightParent.getParent());
+    }
+
+    @Override
+    public String toString() {
+        return "Concat() with " + childStreamList.size() + " children";
+    }
+
+    // ************************************************************************
+    // Getters/setters
+    // ************************************************************************
+
+    @Override
+    public BavetAbstractConstraintStream<Solution_> getLeftParent() {
+        return leftParent;
+    }
+
+    @Override
+    public BavetAbstractConstraintStream<Solution_> getRightParent() {
+        return rightParent;
+    }
+
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetTriConcatNode.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetTriConcatNode.java
new file mode 100644
index 0000000000..acf052d660
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/tri/BavetTriConcatNode.java
@@ -0,0 +1,26 @@
+package ai.timefold.solver.constraint.streams.bavet.tri;
+
+import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+
+public final class BavetTriConcatNode<A, B, C> extends AbstractConcatNode<TriTuple<A, B, C>> {
+
+    BavetTriConcatNode(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int inputStoreIndexLeftOutTupleList,
+            int inputStoreIndexRightOutTupleList,
+            int outputStoreSize) {
+        super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
+    }
+
+    @Override
+    protected TriTuple<A, B, C> getOutTuple(TriTuple<A, B, C> inTuple) {
+        return new TriTuple<>(inTuple.factA, inTuple.factB, inTuple.factC, outputStoreSize);
+    }
+
+    @Override
+    protected void updateOutTuple(TriTuple<A, B, C> inTuple, TriTuple<A, B, C> outTuple) {
+        outTuple.factA = inTuple.factA;
+        outTuple.factB = inTuple.factB;
+        outTuple.factC = inTuple.factC;
+    }
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetAbstractUniConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetAbstractUniConstraintStream.java
index 3591139d50..5b9bd01569 100644
--- a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetAbstractUniConstraintStream.java
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetAbstractUniConstraintStream.java
@@ -361,6 +361,19 @@ public UniConstraintStream<A> distinct() {
         }
     }
 
+    @Override
+    public UniConstraintStream<A> concat(UniConstraintStream<A> otherStream) {
+        var other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
+        var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
+        var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
+        var concatStream = new BavetConcatUniConstraintStream<>(constraintFactory, leftBridge, rightBridge);
+        return constraintFactory.share(concatStream, concatStream_ -> {
+            // Connect the bridges upstream
+            getChildStreamList().add(leftBridge);
+            other.getChildStreamList().add(rightBridge);
+        });
+    }
+
     @Override
     public <ResultA_> UniConstraintStream<ResultA_> map(Function<A, ResultA_> mapping) {
         var stream = shareAndAddChild(new BavetUniMapUniConstraintStream<>(constraintFactory, this, mapping));
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetConcatUniConstraintStream.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetConcatUniConstraintStream.java
new file mode 100644
index 0000000000..c8576c1fb8
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetConcatUniConstraintStream.java
@@ -0,0 +1,104 @@
+package ai.timefold.solver.constraint.streams.bavet.uni;
+
+import java.util.Objects;
+import java.util.Set;
+
+import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.BavetConcatConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
+import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
+import ai.timefold.solver.core.api.score.Score;
+
+public final class BavetConcatUniConstraintStream<Solution_, A> extends BavetAbstractUniConstraintStream<Solution_, A>
+        implements BavetConcatConstraintStream<Solution_> {
+
+    private final BavetForeBridgeUniConstraintStream<Solution_, A> leftParent;
+    private final BavetForeBridgeUniConstraintStream<Solution_, A> rightParent;
+
+    public BavetConcatUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
+            BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
+            BavetForeBridgeUniConstraintStream<Solution_, A> rightParent) {
+        super(constraintFactory, leftParent.getRetrievalSemantics());
+        this.leftParent = leftParent;
+        this.rightParent = rightParent;
+    }
+
+    @Override
+    public boolean guaranteesDistinct() {
+        return false;
+    }
+
+    // ************************************************************************
+    // Node creation
+    // ************************************************************************
+
+    @Override
+    public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
+        leftParent.collectActiveConstraintStreams(constraintStreamSet);
+        rightParent.collectActiveConstraintStreams(constraintStreamSet);
+        constraintStreamSet.add(this);
+    }
+
+    @Override
+    public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
+        TupleLifecycle<UniTuple<A>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
+        int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
+        int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
+        int outputStoreSize = buildHelper.extractTupleStoreSize(this);
+        var node = new BavetUniConcatNode<>(downstream,
+                leftCloneStoreIndex,
+                rightCloneStoreIndex,
+                outputStoreSize);
+        buildHelper.addNode(node, this, leftParent, rightParent);
+    }
+
+    // ************************************************************************
+    // Equality for node sharing
+    // ************************************************************************
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        BavetConcatUniConstraintStream<?, ?> other = (BavetConcatUniConstraintStream<?, ?>) o;
+        /*
+         * Bridge streams do not implement equality because their equals() would have to point back to this stream,
+         * resulting in StackOverflowError.
+         * Therefore we need to check bridge parents to see where this concat node comes from.
+         */
+        return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
+                && Objects.equals(rightParent.getParent(), other.rightParent.getParent());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(leftParent.getParent(), rightParent.getParent());
+    }
+
+    @Override
+    public String toString() {
+        return "Concat() with " + childStreamList.size() + " children";
+    }
+
+    // ************************************************************************
+    // Getters/setters
+    // ************************************************************************
+
+    @Override
+    public BavetAbstractConstraintStream<Solution_> getLeftParent() {
+        return leftParent;
+    }
+
+    @Override
+    public BavetAbstractConstraintStream<Solution_> getRightParent() {
+        return rightParent;
+    }
+
+}
diff --git a/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetUniConcatNode.java b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetUniConcatNode.java
new file mode 100644
index 0000000000..14faae40c0
--- /dev/null
+++ b/core/constraint-streams/src/main/java/ai/timefold/solver/constraint/streams/bavet/uni/BavetUniConcatNode.java
@@ -0,0 +1,25 @@
+package ai.timefold.solver.constraint.streams.bavet.uni;
+
+import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
+import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
+
+public final class BavetUniConcatNode<A> extends AbstractConcatNode<UniTuple<A>> {
+
+    BavetUniConcatNode(TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int inputStoreIndexLeftOutTupleList,
+            int inputStoreIndexRightOutTupleList,
+            int outputStoreSize) {
+        super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList,
+                outputStoreSize);
+    }
+
+    @Override
+    protected UniTuple<A> getOutTuple(UniTuple<A> inTuple) {
+        return new UniTuple<>(inTuple.factA, outputStoreSize);
+    }
+
+    @Override
+    protected void updateOutTuple(UniTuple<A> inTuple, UniTuple<A> outTuple) {
+        outTuple.factA = inTuple.factA;
+    }
+}
diff --git a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/ConstraintStreamFunctionalTest.java b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/ConstraintStreamFunctionalTest.java
index ee22d25902..2557bc5943 100644
--- a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/ConstraintStreamFunctionalTest.java
+++ b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/ConstraintStreamFunctionalTest.java
@@ -99,7 +99,7 @@ default void joinAfterGroupBy() {
     void groupBy_4Mapping0Collector();
 
     // ************************************************************************
-    // Map/expand/flatten/distinct
+    // Map/expand/flatten/distinct/concat
     // ************************************************************************
 
     void distinct();
@@ -118,6 +118,16 @@ default void joinAfterGroupBy() {
 
     void mapToQuad();
 
+    void concatWithoutValueDuplicates();
+
+    void concatAndDistinctWithoutValueDuplicates();
+
+    void concatWithValueDuplicates();
+
+    void concatAndDistinctWithValueDuplicates();
+
+    void concatAfterGroupBy();
+
     default void expandToBi() {
         // Only Uni can be expanded to Bi, so don't force it.
     }
diff --git a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/bi/AbstractBiConstraintStreamTest.java b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/bi/AbstractBiConstraintStreamTest.java
index 363b6d9ba4..b735c98e7f 100644
--- a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/bi/AbstractBiConstraintStreamTest.java
+++ b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/bi/AbstractBiConstraintStreamTest.java
@@ -1344,7 +1344,7 @@ public void groupBy_4Mapping0Collector() {
     }
 
     // ************************************************************************
-    // Map/flatten/distinct
+    // Map/flatten/distinct/concat
     // ************************************************************************
 
     @Override
@@ -1793,6 +1793,294 @@ public void flattenLastAndDistinctWithoutDuplicates() {
                 assertMatch(entity2, group1));
     }
 
+    @Override
+    @TestTemplate
+    public void concatWithoutValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3)))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2),
+                assertMatch(entity2, entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2),
+                assertMatch(entity1, entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity3, entity2),
+                assertMatch(entity2, entity1));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatWithValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1 || entity.getValue() == value2)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2 || entity.getValue() == value3))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3)))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2),
+                assertMatch(entity1, entity3),
+                assertMatch(entity2, entity3),
+                assertMatch(entity2, entity2),
+                assertMatch(entity2, entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2),
+                assertMatch(entity1, entity2),
+                assertMatch(entity2, entity2),
+                assertMatch(entity3, entity3),
+                assertMatch(entity1, entity3),
+                assertMatch(entity2, entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity3, entity2),
+                assertMatch(entity3, entity1),
+                assertMatch(entity2, entity1),
+                assertMatch(entity2, entity1),
+                assertMatch(entity2, entity2));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAndDistinctWithoutValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3)))
+                        .distinct()
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2),
+                assertMatch(entity2, entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2),
+                assertMatch(entity1, entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity3, entity2),
+                assertMatch(entity2, entity1));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAndDistinctWithValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1 || entity.getValue() == value2)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2 || entity.getValue() == value3))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3)))
+                        .distinct()
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2),
+                assertMatch(entity1, entity3),
+                assertMatch(entity2, entity2),
+                assertMatch(entity2, entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2),
+                assertMatch(entity1, entity2),
+                assertMatch(entity2, entity2),
+                assertMatch(entity3, entity3),
+                assertMatch(entity1, entity3),
+                assertMatch(entity2, entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity3, entity2),
+                assertMatch(entity3, entity1),
+                assertMatch(entity2, entity1),
+                assertMatch(entity2, entity2));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAfterGroupBy() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .join(TestdataLavishEntity.class)
+                        .filter((e1, e2) -> e1.getValue() == value1 && e2.getValue() == value2)
+                        .groupBy((e1, e2) -> e1.getValue(),
+                                (e1, e2) -> e2.getValue(),
+                                ConstraintCollectors.countBi())
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .join(TestdataLavishEntity.class)
+                                .filter((e1, e2) -> e1.getValue() == value2 && e2.getValue() == value3)
+                                .groupBy((e1, e2) -> e1.getValue(),
+                                        (e1, e2) -> e2.getValue(),
+                                        ConstraintCollectors.countBi()))
+                        .penalize(SimpleScore.ONE, (v1, v2, count) -> count)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, value2, 1),
+                assertMatchWithScore(-1, value2, value3, 1));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatchWithScore(-2, value1, value2, 2));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, value2, 1),
+                assertMatchWithScore(-1, value2, value3, 1));
+    }
+
     // ************************************************************************
     // Penalize/reward
     // ************************************************************************
diff --git a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/quad/AbstractQuadConstraintStreamTest.java b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/quad/AbstractQuadConstraintStreamTest.java
index 0164550f22..606547b690 100644
--- a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/quad/AbstractQuadConstraintStreamTest.java
+++ b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/quad/AbstractQuadConstraintStreamTest.java
@@ -1423,6 +1423,285 @@ public void flattenLastAndDistinctWithoutDuplicates() {
         assertScore(scoreDirector);
     }
 
+    @Override
+    @TestTemplate
+    public void concatWithoutValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value3))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value1))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value1))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value2)))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2, entity3, entity1),
+                assertMatch(entity2, entity3, entity1, entity2));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+
+        scoreDirector.beforeVariableChanged(entity2, "value");
+        entity2.setValue(value3);
+        scoreDirector.afterVariableChanged(entity2, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity3, entity2, entity1),
+                assertMatch(entity3, entity2, entity1, entity3));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatWithValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value3))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value1))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value1)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value2))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value1)))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2, entity3, entity1),
+                assertMatch(entity1, entity2, entity3, entity1));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+
+        scoreDirector.beforeVariableChanged(entity2, "value");
+        entity2.setValue(value3);
+        scoreDirector.afterVariableChanged(entity2, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity3, entity2, entity1),
+                assertMatch(entity1, entity3, entity2, entity1));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAndDistinctWithoutValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value3))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value1))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value1))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value2)))
+                        .distinct()
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2, entity3, entity1),
+                assertMatch(entity2, entity3, entity1, entity2));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+
+        scoreDirector.beforeVariableChanged(entity2, "value");
+        entity2.setValue(value3);
+        scoreDirector.afterVariableChanged(entity2, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity3, entity2, entity1),
+                assertMatch(entity3, entity2, entity1, entity3));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAndDistinctWithValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value3))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value1))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value1)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value2))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value1)))
+                        .distinct()
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2, entity3, entity1));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+
+        scoreDirector.beforeVariableChanged(entity2, "value");
+        entity2.setValue(value3);
+        scoreDirector.afterVariableChanged(entity2, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity3, entity2, entity1));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAfterGroupBy() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .join(TestdataLavishEntity.class)
+                        .join(TestdataLavishEntity.class)
+                        .join(TestdataLavishEntity.class)
+                        .filter((e1, e2, e3, e4) -> e1.getValue() == value1 && e2.getValue() == value2
+                                && e3.getValue() == value3 && e4.getValue() == value1)
+                        .groupBy((e1, e2, e3, e4) -> e1.getValue(),
+                                (e1, e2, e3, e4) -> e2.getValue(),
+                                (e1, e2, e3, e4) -> e3.getValue().getCode() + e4.getValue().getCode(),
+                                ConstraintCollectors.countQuad())
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .join(TestdataLavishEntity.class)
+                                .join(TestdataLavishEntity.class)
+                                .join(TestdataLavishEntity.class)
+                                .filter((e1, e2, e3, e4) -> e1.getValue() == value3 && e2.getValue() == value2
+                                        && e3.getValue() == value1 && e4.getValue() == value3)
+                                .groupBy((e1, e2, e3, e4) -> e1.getValue(),
+                                        (e1, e2, e3, e4) -> e2.getValue(),
+                                        (e1, e2, e3, e4) -> e3.getValue().getCode() + e4.getValue().getCode(),
+                                        ConstraintCollectors.countQuad()))
+                        .penalize(SimpleScore.ONE, (v1, v2, v3, count) -> count)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, value2, value3.getCode() + value1.getCode(), 1),
+                assertMatchWithScore(-1, value3, value2, value1.getCode() + value3.getCode(), 1));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector);
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, value2, value3.getCode() + value1.getCode(), 1),
+                assertMatchWithScore(-1, value3, value2, value1.getCode() + value3.getCode(), 1));
+    }
+
     // ************************************************************************
     // Penalize/reward
     // ************************************************************************
diff --git a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/tri/AbstractTriConstraintStreamTest.java b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/tri/AbstractTriConstraintStreamTest.java
index a9fa5280d3..354ea0b20e 100644
--- a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/tri/AbstractTriConstraintStreamTest.java
+++ b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/tri/AbstractTriConstraintStreamTest.java
@@ -1745,6 +1745,266 @@ public void flattenLastAndDistinctWithoutDuplicates() {
         assertScore(scoreDirector);
     }
 
+    @Override
+    @TestTemplate
+    public void concatWithoutValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value3))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value1)))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2, entity3),
+                assertMatch(entity2, entity3, entity1));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+
+        scoreDirector.beforeVariableChanged(entity2, "value");
+        entity2.setValue(value3);
+        scoreDirector.afterVariableChanged(entity2, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity3, entity2),
+                assertMatch(entity1, entity3, entity2));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatWithValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value3))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value1)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value2))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3)))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2, entity3),
+                assertMatch(entity1, entity2, entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+
+        scoreDirector.beforeVariableChanged(entity2, "value");
+        entity2.setValue(value3);
+        scoreDirector.afterVariableChanged(entity2, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity3, entity2),
+                assertMatch(entity1, entity3, entity2));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAndDistinctWithoutValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value3))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value1)))
+                        .distinct()
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2, entity3),
+                assertMatch(entity2, entity3, entity1));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+
+        scoreDirector.beforeVariableChanged(entity2, "value");
+        entity2.setValue(value3);
+        scoreDirector.afterVariableChanged(entity2, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity3, entity2),
+                assertMatch(entity1, entity3, entity2));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAndDistinctWithValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .join(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value3))
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value1)
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value2))
+                                .join(factory.forEach(TestdataLavishEntity.class)
+                                        .filter(entity -> entity.getValue() == value3)))
+                        .distinct()
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity2, entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+
+        scoreDirector.beforeVariableChanged(entity2, "value");
+        entity2.setValue(value3);
+        scoreDirector.afterVariableChanged(entity2, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1, entity3, entity2));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAfterGroupBy() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .join(TestdataLavishEntity.class)
+                        .join(TestdataLavishEntity.class)
+                        .filter((e1, e2, e3) -> e1.getValue() == value1 && e2.getValue() == value2 && e3.getValue() == value3)
+                        .groupBy((e1, e2, e3) -> e1.getValue(),
+                                (e1, e2, e3) -> e2.getValue(),
+                                (e1, e2, e3) -> e3.getValue(),
+                                ConstraintCollectors.countTri())
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .join(TestdataLavishEntity.class)
+                                .join(TestdataLavishEntity.class)
+                                .filter((e1, e2, e3) -> e1.getValue() == value3 && e2.getValue() == value2
+                                        && e3.getValue() == value1)
+                                .groupBy((e1, e2, e3) -> e1.getValue(),
+                                        (e1, e2, e3) -> e2.getValue(),
+                                        (e1, e2, e3) -> e3.getValue(),
+                                        ConstraintCollectors.countTri()))
+                        .penalize(SimpleScore.ONE, (v1, v2, v3, count) -> count)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, value2, value3, 1),
+                assertMatchWithScore(-1, value3, value2, value1, 1));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector);
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, value2, value3, 1),
+                assertMatchWithScore(-1, value3, value2, value1, 1));
+    }
+
     // ************************************************************************
     // Penalize/reward
     // ************************************************************************
diff --git a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/uni/AbstractUniConstraintStreamTest.java b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/uni/AbstractUniConstraintStreamTest.java
index 45aa51b546..0913c21e0f 100644
--- a/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/uni/AbstractUniConstraintStreamTest.java
+++ b/core/constraint-streams/src/test/java/ai/timefold/solver/constraint/streams/common/uni/AbstractUniConstraintStreamTest.java
@@ -1687,7 +1687,7 @@ public void groupBy_4Mapping0Collector() {
     }
 
     // ************************************************************************
-    // Map/flatten/distinct
+    // Map/flatten/distinct/concat
     // ************************************************************************
 
     @Override
@@ -2149,6 +2149,367 @@ public void flattenLastAndDistinctWithoutDuplicates() {
                 assertMatch(group2));
     }
 
+    @Override
+    @TestTemplate
+    public void concatWithoutValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity2),
+                assertMatch(entity3));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatWithValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1 || entity.getValue() == value3)
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .map(Function.identity()) // This map make the tuples not reference equal
+                                .filter(entity -> entity.getValue() == value2 || entity.getValue() == value3))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3),
+                assertMatch(entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+    }
+
+    @TestTemplate
+    public void concatWithReferenceDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1 || entity.getValue() == value3)
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                // The tuples are reference equal since filter is not a TupleSource
+                                .filter(entity -> entity.getValue() == value2 || entity.getValue() == value3))
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3),
+                assertMatch(entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+    }
+
+    @TestTemplate
+    public void concatWithReferenceDuplicatesGroupBy() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1 || entity.getValue() == value3)
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                // The tuples are reference equal since filter is not a TupleSource
+                                .filter(entity -> entity.getValue() == value2 || entity.getValue() == value3))
+                        .groupBy(ConstraintCollectors.count())
+                        .penalize(SimpleScore.ONE, count -> count)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatchWithScore(-4, 4));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatchWithScore(-3, 3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatchWithScore(-4, 4));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAndDistinctWithoutValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2))
+                        .distinct()
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity2),
+                assertMatch(entity3));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAndDistinctWithValueDuplicates() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1 || entity.getValue() == value3)
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2 || entity.getValue() == value3))
+                        .distinct()
+                        .penalize(SimpleScore.ONE)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatch(entity1),
+                assertMatch(entity2),
+                assertMatch(entity3));
+    }
+
+    @Override
+    @TestTemplate
+    public void concatAfterGroupBy() {
+        TestdataLavishSolution solution = TestdataLavishSolution.generateSolution(2, 5, 1, 1);
+        TestdataLavishValue value1 = solution.getFirstValue();
+        TestdataLavishValue value2 = new TestdataLavishValue("MyValue 2", solution.getFirstValueGroup());
+        TestdataLavishValue value3 = new TestdataLavishValue("MyValue 3", solution.getFirstValueGroup());
+        TestdataLavishEntity entity1 = solution.getFirstEntity();
+        TestdataLavishEntity entity2 = new TestdataLavishEntity("MyEntity 2", solution.getFirstEntityGroup(),
+                value2);
+        solution.getEntityList().add(entity2);
+        TestdataLavishEntity entity3 = new TestdataLavishEntity("MyEntity 3", solution.getFirstEntityGroup(),
+                value3);
+        solution.getEntityList().add(entity3);
+
+        InnerScoreDirector<TestdataLavishSolution, SimpleScore> scoreDirector =
+                buildScoreDirector(factory -> factory.forEach(TestdataLavishEntity.class)
+                        .filter(entity -> entity.getValue() == value1)
+                        .groupBy(TestdataLavishEntity::getValue, ConstraintCollectors.count())
+                        .concat(factory.forEach(TestdataLavishEntity.class)
+                                .filter(entity -> entity.getValue() == value2)
+                                .groupBy(TestdataLavishEntity::getValue, ConstraintCollectors.count()))
+                        .penalize(SimpleScore.ONE, (value, count) -> count)
+                        .asConstraint(TEST_CONSTRAINT_NAME));
+
+        // From scratch
+        scoreDirector.setWorkingSolution(solution);
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, 1),
+                assertMatchWithScore(-1, value2, 1));
+
+        // Incremental
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value2);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, 1),
+                assertMatchWithScore(-2, value2, 2));
+
+        // Incremental for which the first change matches a join that doesn't survive the second change
+        scoreDirector.beforeVariableChanged(entity1, "value");
+        entity1.setValue(value3);
+        scoreDirector.afterVariableChanged(entity1, "value");
+        scoreDirector.beforeVariableChanged(entity3, "value");
+        entity3.setValue(value1);
+        scoreDirector.afterVariableChanged(entity3, "value");
+        assertScore(scoreDirector,
+                assertMatchWithScore(-1, value1, 1),
+                assertMatchWithScore(-1, value2, 1));
+    }
+
     // ************************************************************************
     // Penalize/reward
     // ************************************************************************
diff --git a/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/bi/BiConstraintStream.java b/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/bi/BiConstraintStream.java
index f88d1aa245..e9640a4cd1 100644
--- a/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/bi/BiConstraintStream.java
+++ b/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/bi/BiConstraintStream.java
@@ -1055,6 +1055,21 @@ <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_
      */
     BiConstraintStream<A, B> distinct();
 
+    /**
+     * Returns a new {@link BiConstraintStream} containing all the tuples of both this {@link BiConstraintStream} and the
+     * provided {@link BiConstraintStream}. Tuples in both this {@link BiConstraintStream} and the provided
+     * {@link BiConstraintStream} will appear at least twice.
+     *
+     * <p>
+     * For instance, if this stream consists of {@code [(A, 1), (B, 2), (C, 3)]} and the other stream consists of
+     * {@code [(C, 3), (D, 4), (E, 5)]}, {@code this.concat(other)} will consist of
+     * {@code [(A, 1), (B, 2), (C, 3), (C, 3), (D, 4), (E, 5)]}. This operation can be thought of as an or between streams.
+     *
+     * @param otherStream
+     * @return
+     */
+    BiConstraintStream<A, B> concat(BiConstraintStream<A, B> otherStream);
+
     // ************************************************************************
     // Other operations
     // ************************************************************************
diff --git a/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/quad/QuadConstraintStream.java b/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/quad/QuadConstraintStream.java
index ca8d19e2da..65d16b701f 100644
--- a/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/quad/QuadConstraintStream.java
+++ b/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/quad/QuadConstraintStream.java
@@ -837,6 +837,22 @@ <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_
      */
     QuadConstraintStream<A, B, C, D> distinct();
 
+    /**
+     * Returns a new {@link QuadConstraintStream} containing all the tuples of both this {@link QuadConstraintStream} and the
+     * provided {@link QuadConstraintStream}. Tuples in both this {@link QuadConstraintStream} and the provided
+     * {@link QuadConstraintStream} will appear at least twice.
+     *
+     * <p>
+     * For instance, if this stream consists of {@code [(A, 1, -1, a), (B, 2, -2, b), (C, 3, -3, c)]} and the other stream
+     * consists of {@code [(C, 3, -3, c), (D, 4, -4, d), (E, 5, -5, e)]}, {@code this.concat(other)} will consist of
+     * {@code [(A, 1, -1, a), (B, 2, -2, b), (C, 3, -3, c), (C, 3, -3, c), (D, 4, -4, d), (E, 5, -5,e)]}. This operation can be
+     * thought of as an or between streams.
+     *
+     * @param otherStream
+     * @return
+     */
+    QuadConstraintStream<A, B, C, D> concat(QuadConstraintStream<A, B, C, D> otherStream);
+
     // ************************************************************************
     // Penalize/reward
     // ************************************************************************
diff --git a/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/tri/TriConstraintStream.java b/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/tri/TriConstraintStream.java
index 0c11950615..b1b152dee8 100644
--- a/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/tri/TriConstraintStream.java
+++ b/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/tri/TriConstraintStream.java
@@ -1049,6 +1049,22 @@ <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_
      */
     TriConstraintStream<A, B, C> distinct();
 
+    /**
+     * Returns a new {@link TriConstraintStream} containing all the tuples of both this {@link TriConstraintStream} and the
+     * provided {@link TriConstraintStream}. Tuples in both this {@link TriConstraintStream} and the provided
+     * {@link TriConstraintStream} will appear at least twice.
+     *
+     * <p>
+     * For instance, if this stream consists of {@code [(A, 1, -1), (B, 2, -2), (C, 3, -3)]} and the other stream consists of
+     * {@code [(C, 3, -3), (D, 4, -4), (E, 5, -5)]}, {@code this.concat(other)} will consist of
+     * {@code [(A, 1, -1), (B, 2, -2), (C, 3, -3), (C, 3, -3), (D, 4, -4), (E, 5, -5)]}. This operation can be thought of as an
+     * or between streams.
+     *
+     * @param otherStream
+     * @return
+     */
+    TriConstraintStream<A, B, C> concat(TriConstraintStream<A, B, C> otherStream);
+
     // ************************************************************************
     // Other operations
     // ************************************************************************
diff --git a/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/uni/UniConstraintStream.java b/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/uni/UniConstraintStream.java
index b22f8067c9..e3627d7663 100644
--- a/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/uni/UniConstraintStream.java
+++ b/core/core-impl/src/main/java/ai/timefold/solver/core/api/score/stream/uni/UniConstraintStream.java
@@ -1482,6 +1482,21 @@ <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_
      */
     UniConstraintStream<A> distinct();
 
+    /**
+     * Returns a new {@link UniConstraintStream} containing all the tuples of both this {@link UniConstraintStream} and the
+     * provided {@link UniConstraintStream}. Tuples in both this {@link UniConstraintStream} and the provided
+     * {@link UniConstraintStream} will appear at least twice.
+     *
+     * <p>
+     * For instance, if this stream consists of {@code [A, B, C]} and the other stream consists of {@code [C, D, E]},
+     * {@code this.concat(other)} will consist of {@code [A, B, C, C, D, E]}. This operation can be thought of as an or between
+     * streams.
+     *
+     * @param otherStream
+     * @return
+     */
+    UniConstraintStream<A> concat(UniConstraintStream<A> otherStream);
+
     // ************************************************************************
     // Other operations
     // ************************************************************************
diff --git a/docs/src/modules/ROOT/images/constraints-and-score/constraintStreamConcat.png b/docs/src/modules/ROOT/images/constraints-and-score/constraintStreamConcat.png
new file mode 100644
index 0000000000..c4ef1d2d72
Binary files /dev/null and b/docs/src/modules/ROOT/images/constraints-and-score/constraintStreamConcat.png differ
diff --git a/docs/src/modules/ROOT/images/constraints-and-score/constraintStreamConcat.svg b/docs/src/modules/ROOT/images/constraints-and-score/constraintStreamConcat.svg
new file mode 100644
index 0000000000..3af70fba93
--- /dev/null
+++ b/docs/src/modules/ROOT/images/constraints-and-score/constraintStreamConcat.svg
@@ -0,0 +1,1114 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="800"
+   height="600"
+   id="svg2"
+   version="1.1"
+   inkscape:version="1.3 (0e150ed6c4, 2023-07-21)"
+   sodipodi:docname="constraintStreamConcat.svg"
+   inkscape:export-filename="constraintStreamConcat.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:dc="http://purl.org/dc/elements/1.1/">
+  <defs
+     id="defs4"><marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0.0"
+   refX="0.0"
+   id="marker5265"
+   style="overflow:visible;"
+   inkscape:isstock="true"
+   viewBox="0 0 17.77385393 10.15648796"
+   markerWidth="17.7738533"
+   markerHeight="10.1564876"
+   preserveAspectRatio="xMidYMid">
+  <path
+     id="path5267"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     style="fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1;fill:#555753;fill-opacity:1"
+     transform="scale(0.8) rotate(180) translate(12.5,0)" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0.0"
+   refX="0.0"
+   id="marker5129"
+   style="overflow:visible;"
+   inkscape:isstock="true">
+  <path
+     id="path5131"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     style="fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1;fill:#555753;fill-opacity:1"
+     transform="scale(0.8) rotate(180) translate(12.5,0)" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0.0"
+   refX="0.0"
+   id="marker4999"
+   style="overflow:visible;"
+   inkscape:isstock="true">
+  <path
+     id="path5001"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     style="fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1;fill:#555753;fill-opacity:1"
+     transform="scale(0.8) rotate(180) translate(12.5,0)" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0.0"
+   refX="0.0"
+   id="marker4875"
+   style="overflow:visible;"
+   inkscape:isstock="true">
+  <path
+     id="path4877"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     style="fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1;fill:#555753;fill-opacity:1"
+     transform="scale(0.8) rotate(180) translate(12.5,0)" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0.0"
+   refX="0.0"
+   id="marker19925"
+   style="overflow:visible;"
+   inkscape:isstock="true">
+  <path
+     id="path19927"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     style="fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1;fill:#555753;fill-opacity:1"
+     transform="scale(0.8) rotate(180) translate(12.5,0)" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0.0"
+   refX="0.0"
+   id="marker17859"
+   style="overflow:visible;"
+   inkscape:isstock="true">
+  <path
+     id="path17861"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     style="fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1;fill:#555753;fill-opacity:1"
+     transform="scale(0.8) rotate(180) translate(12.5,0)" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0.0"
+   refX="0.0"
+   id="marker17771"
+   style="overflow:visible;"
+   inkscape:isstock="true">
+  <path
+     id="path17773"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     style="fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1;fill:#555753;fill-opacity:1"
+     transform="scale(0.8) rotate(180) translate(12.5,0)" />
+</marker>
+<marker
+   inkscape:isstock="true"
+   style="overflow:visible;"
+   id="marker11237"
+   refX="0.0"
+   refY="0.0"
+   orient="auto"
+   inkscape:stockid="Arrow1Lend">
+  <path
+     transform="scale(0.8) rotate(180) translate(12.5,0)"
+     style="fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1;fill:#555753;fill-opacity:1"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     id="path11239" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lstart"
+   orient="auto"
+   refY="0.0"
+   refX="0.0"
+   id="marker4650"
+   style="overflow:visible"
+   inkscape:isstock="true">
+  <path
+     id="path4652"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     style="fill-rule:evenodd;stroke:#ef2929;stroke-width:1pt;stroke-opacity:1;fill:#ef2929;fill-opacity:1"
+     transform="scale(0.8) translate(12.5,0)" />
+</marker>
+<marker
+   inkscape:isstock="true"
+   style="overflow:visible"
+   id="marker7822"
+   refX="0.0"
+   refY="0.0"
+   orient="auto"
+   inkscape:stockid="Arrow1Lstart">
+  <path
+     transform="scale(0.8) translate(12.5,0)"
+     style="fill-rule:evenodd;stroke:#ef2929;stroke-width:1pt;stroke-opacity:1;fill:#ef2929;fill-opacity:1"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     id="path7824" />
+</marker>
+<marker
+   inkscape:isstock="true"
+   style="overflow:visible"
+   id="marker5765"
+   refX="0.0"
+   refY="0.0"
+   orient="auto"
+   inkscape:stockid="Arrow1Lstart">
+  <path
+     transform="scale(0.8) translate(12.5,0)"
+     style="fill-rule:evenodd;stroke:#ef2929;stroke-width:1pt;stroke-opacity:1;fill:#ef2929;fill-opacity:1"
+     d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
+     id="path5767" />
+</marker>
+&#10;&#10;&#10;&#10;&#10;&#10;&#10;&#10;&#10;&#10;&#10;&#10;&#10;&#10;    inkscape:perspective&#10;       sodipodi:type=&quot;inkscape:persp3d&quot;&#10;       inkscape:vp_x=&quot;0 : 526.18109 : 1&quot;&#10;       inkscape:vp_y=&quot;0 : 1000 : 0&quot;&#10;       inkscape:vp_z=&quot;744.09448 : 526.18109 : 1&quot;&#10;       inkscape:persp3d-origin=&quot;372.04724 : 350.78739 : 1&quot;&#10;       id=&quot;perspective10&quot; /&gt;&#10;    <inkscape:perspective
+   id="perspective3633"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3633-0"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3633-4"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3633-6"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3702"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3740"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3775"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3775-7"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3775-4"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3775-75"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3896"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3896-4"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3927"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3927-3"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3927-8"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4002"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4002-7"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4002-2"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4077"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4077-4"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4077-46"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4152"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4152-7"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4152-0"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4227"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4227-1"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective4227-3"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective2987"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3018"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<inkscape:perspective
+   id="perspective3049"
+   inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
+   inkscape:vp_z="1 : 0.5 : 1"
+   inkscape:vp_y="0 : 1000 : 0"
+   inkscape:vp_x="0 : 0.5 : 1"
+   sodipodi:type="inkscape:persp3d" />
+<marker
+   inkscape:isstock="true"
+   style="overflow:visible"
+   id="marker5765-0"
+   refX="0"
+   refY="0"
+   orient="auto"
+   inkscape:stockid="Arrow1Lstart">
+  <path
+     inkscape:connector-curvature="0"
+     transform="matrix(0.8,0,0,0.8,10,0)"
+     style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1"
+     d="M 0,0 5,-5 -12.5,0 5,5 0,0 Z"
+     id="path5767-0" />
+</marker>
+<marker
+   inkscape:isstock="true"
+   style="overflow:visible"
+   id="marker7822-2"
+   refX="0"
+   refY="0"
+   orient="auto"
+   inkscape:stockid="Arrow1Lstart">
+  <path
+     inkscape:connector-curvature="0"
+     transform="matrix(0.8,0,0,0.8,10,0)"
+     style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1"
+     d="M 0,0 5,-5 -12.5,0 5,5 0,0 Z"
+     id="path7824-8" />
+</marker>
+<marker
+   inkscape:isstock="true"
+   style="overflow:visible"
+   id="marker11237-4"
+   refX="0"
+   refY="0"
+   orient="auto"
+   inkscape:stockid="Arrow1Lend">
+  <path
+     inkscape:connector-curvature="0"
+     transform="matrix(-0.8,0,0,-0.8,-10,0)"
+     style="fill:#555753;fill-opacity:1;fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1"
+     d="M 0,0 5,-5 -12.5,0 5,5 0,0 Z"
+     id="path11239-5" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0"
+   refX="0"
+   id="marker17771-8"
+   style="overflow:visible"
+   inkscape:isstock="true">
+  <path
+     inkscape:connector-curvature="0"
+     id="path17773-8"
+     d="M 0,0 5,-5 -12.5,0 5,5 0,0 Z"
+     style="fill:#555753;fill-opacity:1;fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1"
+     transform="matrix(-0.8,0,0,-0.8,-10,0)" />
+</marker>
+<marker
+   inkscape:stockid="Arrow1Lend"
+   orient="auto"
+   refY="0"
+   refX="0"
+   id="marker17859-4"
+   style="overflow:visible"
+   inkscape:isstock="true">
+  <path
+     inkscape:connector-curvature="0"
+     id="path17861-9"
+     d="M 0,0 5,-5 -12.5,0 5,5 0,0 Z"
+     style="fill:#555753;fill-opacity:1;fill-rule:evenodd;stroke:#555753;stroke-width:1pt;stroke-opacity:1"
+     transform="matrix(-0.8,0,0,-0.8,-10,0)" />
+</marker>
+</defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="1"
+     inkscape:pageshadow="2"
+     inkscape:zoom="1.245"
+     inkscape:cx="400"
+     inkscape:cy="300"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="true"
+     width="800px"
+     borderlayer="true"
+     gridtolerance="10"
+     inkscape:window-width="1920"
+     inkscape:window-height="1011"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:snap-grids="true"
+     inkscape:snap-bbox="true"
+     showguides="false"
+     inkscape:guide-bbox="true"
+     inkscape:object-paths="true"
+     inkscape:object-nodes="true"
+     inkscape:snap-smooth-nodes="true"
+     inkscape:snap-nodes="true"
+     inkscape:snap-intersection-paths="true"
+     inkscape:bbox-nodes="true"
+     inkscape:snap-bbox-edge-midpoints="true"
+     inkscape:snap-bbox-midpoints="true"
+     inkscape:bbox-paths="true"
+     inkscape:snap-center="true"
+     inkscape:snap-object-midpoints="true"
+     inkscape:snap-global="true"
+     inkscape:document-rotation="0"
+     inkscape:pagecheckerboard="0"
+     inkscape:showpageshadow="2"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:export-bgcolor="#ffffffff">
+    <inkscape:grid
+       empspacing="10"
+       visible="true"
+       enabled="true"
+       snapvisiblegridlinesonly="true"
+       spacingx="10"
+       spacingy="10"
+       dotted="true"
+       type="xygrid"
+       id="grid2845"
+       originx="0"
+       originy="0"
+       units="px" />
+  </sodipodi:namedview>
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:language>en</dc:language>
+        <cc:license
+           rdf:resource="https://timefold.ai/product/license/" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="forEach Shift"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(0,-452.36218)"
+     style="display:inline">
+    <g
+       id="g3709"
+       transform="translate(0,19.999997)" />
+    <flowRoot
+       xml:space="preserve"
+       id="flowRoot4302"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:37.3333px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;display:inline;fill:#000000;fill-opacity:1;stroke:none"
+       transform="translate(-19.999997,252.36213)"><flowRegion
+         id="flowRegion4304"
+         style="font-size:37.3333px"><rect
+           id="rect4306"
+           width="760"
+           height="90.000008"
+           x="40"
+           y="220.00005"
+           style="font-size:37.33333206px;text-align:center;text-anchor:middle" /></flowRegion><flowPara
+         id="flowPara3847"
+         style="font-size:37.3333px;line-height:1.25">Constraint Streams: concat</flowPara></flowRoot>
+    <flowRoot
+       transform="translate(-19.999997,372.36182)"
+       xml:space="preserve"
+       id="flowRoot4302-6"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;display:inline;fill:#000000;fill-opacity:1;stroke:none"><flowRegion
+         id="flowRegion4304-7"
+         style="font-size:16px"><rect
+           id="rect4306-3"
+           width="740.00006"
+           height="29.999973"
+           x="50"
+           y="150.00014"
+           style="font-size:16px;text-align:center;text-anchor:middle" /></flowRegion><flowPara
+         id="flowPara4308-6"
+         style="font-size:16px;line-height:1.25">Similar to an SQL UNION ALL. If tuples are repeated, they appear twice.</flowPara></flowRoot>
+    <flowRoot
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:21.3333px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:start;writing-mode:lr-tb;text-anchor:start;display:inline;fill:#000000;fill-opacity:1;stroke:none"
+       id="flowRoot2685"
+       xml:space="preserve"
+       transform="translate(-310.50716,420.26327)"><flowRegion
+         style="font-size:21.3333px;text-align:start;text-anchor:start"
+         id="flowRegion2681"><rect
+           style="font-size:21.3333px;text-align:start;text-anchor:start"
+           y="152.09956"
+           x="330.20508"
+           height="26.646585"
+           width="237.93298"
+           id="rect2679" /></flowRegion><flowPara
+         id="flowPara2683"
+         style="font-size:21.3333px;line-height:1.25;text-align:start;text-anchor:start">forEach(<flowSpan
+   style="fill:#4e9a06"
+   id="flowSpan2695">Employee</flowSpan>.class)</flowPara></flowRoot>
+    <flowRoot
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:21.3333px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:start;writing-mode:lr-tb;text-anchor:start;display:inline;fill:#000000;fill-opacity:1;stroke:none"
+       id="flowRoot2685-7"
+       xml:space="preserve"
+       transform="translate(-310.50716,836.50482)"><flowRegion
+         style="font-size:21.3333px;text-align:start;text-anchor:start"
+         id="flowRegion2681-6"><rect
+           style="font-size:21.3333px;text-align:start;text-anchor:start"
+           y="152.09956"
+           x="330.20508"
+           height="26.646585"
+           width="237.93298"
+           id="rect2679-5" /></flowRegion><flowPara
+         id="flowPara2683-6"
+         style="font-size:21.3333px;line-height:1.25;text-align:start;text-anchor:start">forEach(<flowSpan
+   style="fill:#204a87"
+   id="flowSpan2695-9">Employee</flowSpan>.class)</flowPara></flowRoot>
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#204a87;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 149.5,836.86218 151.4319,63.40788"
+       id="path3"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#204a87;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 149.5,806.86218 151.4319,62.66604"
+       id="path4"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#4e9a06;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M 149.7496,776.87787 300.5,706.86218"
+       id="path5"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#4e9a06;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M 149.5,836.86218 300.9319,737.58256"
+       id="path6"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <flowRoot
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:21.3333px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:start;writing-mode:lr-tb;text-anchor:start;display:inline;fill:#000000;fill-opacity:1;stroke:none"
+       id="flowRoot2685-3"
+       xml:space="preserve"
+       transform="translate(-100.50716,506.50482)"><flowRegion
+         style="font-size:21.3333px;text-align:start;text-anchor:start"
+         id="flowRegion2681-7"><rect
+           style="font-size:21.3333px;text-align:start;text-anchor:start"
+           y="152.09956"
+           x="330.20508"
+           height="33.757797"
+           width="380.30209"
+           id="rect2679-4" /></flowRegion><flowPara
+         id="flowPara2683-5"
+         style="font-size:21.3333px;line-height:1.25;text-align:start;text-anchor:start">.filter(<flowSpan
+   style="font-size:16px;fill:#4e9a06"
+   id="flowSpan6">employee</flowSpan><flowSpan
+   style="font-size:16px"
+   id="flowSpan8"> -&gt; </flowSpan><flowSpan
+   style="font-size:16px;fill:#4e9a06"
+   id="flowSpan7">employee</flowSpan><flowSpan
+   style="font-size:16px"
+   id="flowSpan9">.hasDog()</flowSpan>)</flowPara></flowRoot>
+    <flowRoot
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:21.3333px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:start;writing-mode:lr-tb;text-anchor:start;display:inline;fill:#000000;fill-opacity:1;stroke:none"
+       id="flowRoot2685-3-5"
+       xml:space="preserve"
+       transform="translate(-100.50716,772.65505)"><flowRegion
+         style="font-size:21.3333px;text-align:start;text-anchor:start"
+         id="flowRegion2681-7-4"><rect
+           style="font-size:21.3333px;text-align:start;text-anchor:start"
+           y="152.09956"
+           x="330.20508"
+           height="33.757797"
+           width="380.30209"
+           id="rect2679-4-7" /></flowRegion><flowPara
+         id="flowPara2683-5-4"
+         style="font-size:21.3333px;line-height:1.25;text-align:start;text-anchor:start">.filter(<flowSpan
+   style="font-size:16px;fill:#204a87"
+   id="flowSpan6-4">employee</flowSpan><flowSpan
+   style="font-size:16px"
+   id="flowSpan8-3"> -&gt; </flowSpan><flowSpan
+   style="font-size:16px;fill:#204a87"
+   id="flowSpan7-0">employee</flowSpan><flowSpan
+   style="font-size:16px"
+   id="flowSpan9-7">.hasCat()</flowSpan>)</flowPara></flowRoot>
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#204a87;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 160,992.36218 69.69792,-48.39146"
+       id="path10"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#4e9a06;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 160,602.36218 70,70"
+       id="path11"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0" />
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer2"
+     inkscape:label="forEach DayOff"
+     style="display:inline">
+    <g
+       id="g1790-3-0"
+       transform="translate(-579.7504,-562.84649)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9"
+         style="fill:#8ae234;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6">Ann</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-9"
+       transform="translate(-580,-532.86218)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-2"
+         style="fill:#8ae234;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-0"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-2"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-3"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-7">Beth</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-5"
+       transform="translate(-580,-502.86218)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-9"
+         style="fill:#8ae234;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-2"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-28"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-9"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-73">Carl</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-6"
+       transform="translate(-330,-632.86218)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-1"
+         style="fill:#8ae234;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-29"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-3"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-1"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-9">Ann</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-5-4"
+       transform="translate(-329.5681,-602.1418)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-9-7"
+         style="fill:#8ae234;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-2-8"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-28-4"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-9-5"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-73-0">Carl</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-9-3"
+       transform="translate(-329.5681,-470.19614)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-2-6"
+         style="fill:#729fcf;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-0-1"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-2-0"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-3-6"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-7-3">Beth</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-5-2"
+       transform="translate(-329.5681,-439.4543)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-9-0"
+         style="fill:#729fcf;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-2-6"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-28-1"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-9-55"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-73-4">Carl</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-6-8"
+       transform="translate(-60,-503.36218)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-1-6"
+         style="fill:#8ae234;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-29-8"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-3-8"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-1-4"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-9-3">Ann</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-5-4-1"
+       transform="translate(-60,-472.30548)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-9-7-4"
+         style="fill:#8ae234;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-2-8-9"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-28-4-2"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-9-5-0"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-73-0-6">Carl</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-9-3-8"
+       transform="translate(-60,-441.24878)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-2-6-9"
+         style="fill:#729fcf;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-0-1-2"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-2-0-6"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-3-6-6"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-7-3-4">Beth</flowPara></flowRoot>
+    </g>
+    <g
+       id="g1790-3-0-5-2-9"
+       transform="translate(-60,-410.19208)"
+       style="display:inline">
+      <rect
+         ry="5"
+         rx="4.999999"
+         y="872.86218"
+         x="630.5"
+         height="29"
+         width="99"
+         id="rect1780-6-9-9-0-5"
+         style="fill:#729fcf;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none" />
+      <flowRoot
+         xml:space="preserve"
+         id="flowRoot1788-7-3-2-6-0"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12.8755px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:center;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none"
+         transform="matrix(1.6568991,0,0,1.6568991,169.60592,754.1611)"><flowRegion
+           id="flowRegion1784-5-6-28-1-4"
+           style="font-size:12.8755px"><rect
+             id="rect1782-3-0-9-55-8"
+             width="60.051933"
+             height="17.320974"
+             x="278.16666"
+             y="72.123871"
+             style="font-size:12.87545681px" /></flowRegion><flowPara
+           style="font-size:12.8755px;line-height:1.25"
+           id="flowPara1786-5-6-73-4-7">Carl</flowPara></flowRoot>
+    </g>
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#4e9a06;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M 399.5,254.5 570.5,384"
+       id="path15"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#4e9a06;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M 399.9319,285.22038 570.5,415.0567"
+       id="path16"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#204a87;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M 399.9319,417.16604 570.5,446.1134"
+       id="path17"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#204a87;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 400,450 170,30"
+       id="path18"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer5"
+     inkscape:label="join"
+     style="display:inline">
+    <flowRoot
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:21.3333px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:start;writing-mode:lr-tb;text-anchor:start;display:inline;fill:#000000;fill-opacity:1;stroke:none"
+       id="flowRoot2662"
+       xml:space="preserve"
+       transform="translate(235.50552,173.72084)"><flowRegion
+         style="font-size:21.3333px;text-align:start;text-anchor:start"
+         id="flowRegion2654"><rect
+           style="font-size:21.33333397px;text-align:start;text-anchor:start"
+           y="152.09956"
+           x="330.20508"
+           height="90"
+           width="200.00002"
+           id="rect2652" /></flowRegion><flowPara
+         id="flowPara2660"
+         style="font-size:21.3333px;line-height:1.25;text-align:start;text-anchor:start">.concat()</flowPara></flowRoot>
+    <flowRoot
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:32px;line-height:0.01%;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans, Normal';text-align:start;writing-mode:lr-tb;text-anchor:start;display:inline;fill:#000000;fill-opacity:1;stroke:none"
+       id="flowRoot2662-2"
+       xml:space="preserve"
+       transform="translate(413.59801,160.30288)"><flowRegion
+         style="text-align:start;text-anchor:start"
+         id="flowRegion2654-2"><rect
+           style="text-align:start;text-anchor:start"
+           y="152.09956"
+           x="330.20508"
+           height="90"
+           width="200.00002"
+           id="rect2652-6" /></flowRegion><flowPara
+         id="flowPara2660-1"
+         style="font-size:32px;line-height:1.25;text-align:start;text-anchor:start">...</flowPara></flowRoot>
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 650,340 h 90"
+       id="path19"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0" />
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer4"
+     inkscape:label="filter"
+     style="display:inline">
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#204a87;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M 520,490 565.7106,345.03651"
+       id="path12"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#4e9a06;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 525.4129,219.93749 40.2977,125.09902"
+       id="path14"
+       inkscape:connector-type="polyline"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer6"
+     inkscape:label="warning"
+     style="display:inline" />
+</svg>
diff --git a/docs/src/modules/ROOT/pages/constraints-and-score/constraints-and-score.adoc b/docs/src/modules/ROOT/pages/constraints-and-score/constraints-and-score.adoc
index a0afb8841d..5b2cbfb6f9 100644
--- a/docs/src/modules/ROOT/pages/constraints-and-score/constraints-and-score.adoc
+++ b/docs/src/modules/ROOT/pages/constraints-and-score/constraints-and-score.adoc
@@ -1511,6 +1511,57 @@ the tuple `(SomePerson, USER)` is sent downstream twice.
 See <<constraintStreamsDealingWithDuplicateTuplesUsingDistinct,`distinct()`>> for how to deal with duplicate tuples.
 ====
 
+[[constraintStreamsConcat]]
+==== Concat
+
+The `concat` building block allows you to create a constraint stream containing tuples of two constraint streams of the same <<constraintStreamsCardinality,cardinality>>.
+If <<constraintStreamsJoin,join>> acts like a cartesian product of two lists, `concat` acts like a concatenation of two lists.
+Unlike union of sets, concatenation of lists repeats duplicated elements.
+If the two constraint stream parents share tuples, which happens eg. when the streams being concatenated come from the same source of data, the tuples will be repeated downstream.
+If this is undesired, use the <<constraintStreamsDealingWithDuplicateTuplesUsingDistinct,`distinct` building block>>.
+
+image::constraints-and-score/constraintStreamConcat.png[align="center"]
+
+For example, to ensure each employee has a minimum number of assigned shifts:
+
+[source,java,options="nowrap"]
+----
+    private Constraint ensureEachEmployeeHasAtLeastTwoShifts(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(Employee.class)
+         .join(Shift.class, equal(Function.identity(), Shift::getEmployee))
+         .concat(
+             constraintFactory.forEach(Employee.class)
+               .ifNotExists(Shift.class, equal(Function.identity(), Shift::getEmployee))
+               .expand(employee -> (Shift) null)
+         )
+         .groupBy((employee, shift) -> employee,
+                   conditionally((employee, shift) -> shift != null,
+                                 countBi())
+         )
+         .filter((employee, shiftCount) -> shiftCount < employee.minimumAssignedShifts)
+         .penalize(HardSoftScore.ONE_SOFT, (employee, shiftCount) -> employee.minimumAssignedShifts - shiftCount)
+         .asConstraint("Minimum number of assigned shifts");
+    }
+----
+
+This correctly counts the number of shifts each Employee has, *even when the Employee has no shifts*.
+If it was implemented without `concat` like this:
+
+[source,java,options="nowrap"]
+----
+    private Constraint incorrectEnsureEachEmployeeHasAtLeastTwoShifts(ConstraintFactory constraintFactory) {
+        return constraintFactory.forEach(Employee.class)
+         .join(Shift.class, equal(Function.identity(), Shift::getEmployee))
+         .groupBy((employee, shift) -> employee,
+                  countBi())
+         )
+         .filter((employee, shiftCount) -> shiftCount < employee.minimumAssignedShifts)
+         .penalize(HardSoftScore.ONE_SOFT, (employee, shiftCount) -> employee.minimumAssignedShifts - shiftCount)
+         .asConstraint("Minimum number of assigned shifts (incorrect)");
+    }
+----
+
+An employee with no assigned shifts _will not be penalized because no tuples were passed to the `groupBy` building block_.
 
 [[constraintStreamsTesting]]
 === Testing a constraint stream
@@ -2525,4 +2576,4 @@ The sum of all the `Indictment.getScoreTotal()` differs from the overall score,
 <<constraintStreams,Constraint streams>> support constraint matches automatically,
 but <<incrementalJavaScoreCalculation,incremental Java score calculation>> requires
 <<constraintMatchAwareIncrementalScoreCalculator,implementing an extra interface>>.
-====
\ No newline at end of file
+====
diff --git a/examples/src/main/java/ai/timefold/solver/examples/nurserostering/score/NurseRosteringConstraintProvider.java b/examples/src/main/java/ai/timefold/solver/examples/nurserostering/score/NurseRosteringConstraintProvider.java
index 7cc1305939..d2d5898654 100644
--- a/examples/src/main/java/ai/timefold/solver/examples/nurserostering/score/NurseRosteringConstraintProvider.java
+++ b/examples/src/main/java/ai/timefold/solver/examples/nurserostering/score/NurseRosteringConstraintProvider.java
@@ -14,6 +14,9 @@
 import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
 import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
 import ai.timefold.solver.core.api.score.stream.Joiners;
+import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
+import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
+import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
 import ai.timefold.solver.examples.common.experimental.ExperimentalConstraintCollectors;
 import ai.timefold.solver.examples.common.experimental.api.ConsecutiveInfo;
 import ai.timefold.solver.examples.common.util.Pair;
@@ -43,7 +46,6 @@ public Constraint[] defineConstraints(ConstraintFactory constraintFactory) {
         return new Constraint[] {
                 oneShiftPerDay(constraintFactory),
                 minimumAndMaximumNumberOfAssignments(constraintFactory),
-                minimumNumberOfAssignmentsNoAssignments(constraintFactory),
                 consecutiveWorkingDays(constraintFactory),
                 consecutiveFreeDays(constraintFactory),
                 maximumConsecutiveFreeDaysNoAssignments(constraintFactory),
@@ -78,16 +80,27 @@ Constraint oneShiftPerDay(ConstraintFactory constraintFactory) {
     // ############################################################################
     // Soft constraints
     // ############################################################################
+    @SafeVarargs
+    private static <A, B, C> TriConstraintStream<A, B, C> outerJoin(BiConstraintStream<A, B> source,
+            Class<C> joinedClass, TriJoiner<A, B, C>... joiners) {
+        return source.join(joinedClass, joiners).concat(
+                source.ifNotExists(joinedClass, joiners).expand((ingoredA, ingoredB) -> null));
+    }
+
     Constraint minimumAndMaximumNumberOfAssignments(ConstraintFactory constraintFactory) {
-        return constraintFactory.forEach(MinMaxContractLine.class)
-                .filter(minMaxContractLine -> minMaxContractLine.getContractLineType() == ContractLineType.TOTAL_ASSIGNMENTS &&
-                        minMaxContractLine.isEnabled())
-                .join(constraintFactory.forEach(ShiftAssignment.class)
-                        .filter(shift -> shift.getEmployee() != null),
-                        Joiners.equal(ContractLine::getContract, ShiftAssignment::getContract))
-                .groupBy((line, shift) -> shift.getEmployee(),
-                        (line, shift) -> line,
-                        ConstraintCollectors.countBi())
+        return outerJoin(
+                constraintFactory
+                        .forEach(MinMaxContractLine.class)
+                        .filter(minMaxContractLine -> minMaxContractLine
+                                .getContractLineType() == ContractLineType.TOTAL_ASSIGNMENTS && minMaxContractLine.isEnabled())
+                        .join(Employee.class, Joiners.equal(ContractLine::getContract, Employee::getContract)),
+                ShiftAssignment.class,
+                Joiners.equal((contractLine, employee) -> employee, ShiftAssignment::getEmployee))
+                .groupBy((line, employee, shift) -> employee,
+                        (line, employee, shift) -> line,
+                        ConstraintCollectors.conditionally(
+                                (line, employee, shift) -> shift != null,
+                                ConstraintCollectors.countTri()))
                 .map((employee, contract, shiftCount) -> employee,
                         (employee, contract, shiftCount) -> contract,
                         (employee, contract, shiftCount) -> contract.getViolationAmount(shiftCount))
@@ -97,21 +110,6 @@ Constraint minimumAndMaximumNumberOfAssignments(ConstraintFactory constraintFact
                 .asConstraint("Minimum and maximum number of assignments");
     }
 
-    Constraint minimumNumberOfAssignmentsNoAssignments(ConstraintFactory constraintFactory) {
-        return constraintFactory.forEach(MinMaxContractLine.class)
-                .filter(minMaxContractLine -> minMaxContractLine.getContractLineType() == ContractLineType.TOTAL_ASSIGNMENTS &&
-                        minMaxContractLine.isEnabled())
-                .join(Employee.class,
-                        Joiners.equal(MinMaxContractLine::getContract, Employee::getContract))
-                .ifNotExists(ShiftAssignment.class,
-                        Joiners.equal((contractLine, employee) -> employee, ShiftAssignment::getEmployee))
-                .expand((contract, employee) -> contract.getViolationAmount(0))
-                .filter((contract, employee, violationAmount) -> violationAmount != 0)
-                .penalize(HardSoftScore.ONE_SOFT, (contract, employee, violationAmount) -> violationAmount)
-                .indictWith((contract, employee, violationAmount) -> Arrays.asList(employee, contract))
-                .asConstraint("Minimum and maximum number of assignments (no assignments)");
-    }
-
     // Min/Max consecutive working days
     Constraint consecutiveWorkingDays(ConstraintFactory constraintFactory) {
         return constraintFactory.forEach(MinMaxContractLine.class)
diff --git a/examples/src/test/java/ai/timefold/solver/examples/nurserostering/score/NurseRosteringConstraintProviderTest.java b/examples/src/test/java/ai/timefold/solver/examples/nurserostering/score/NurseRosteringConstraintProviderTest.java
index 6ee982dc2c..6bb29c6b3d 100644
--- a/examples/src/test/java/ai/timefold/solver/examples/nurserostering/score/NurseRosteringConstraintProviderTest.java
+++ b/examples/src/test/java/ai/timefold/solver/examples/nurserostering/score/NurseRosteringConstraintProviderTest.java
@@ -347,6 +347,10 @@ void minimumAndMaximumNumberOfAssignments(
         minimumAndMaximumNumberOfAssignmentsConstraint.given(contract.getFirstConstractLine(), employee, shift1)
                 .penalizesBy(2);
 
+        minimumAndMaximumNumberOfAssignmentsConstraint
+                .given(contract.getFirstConstractLine(), employee)
+                .penalizesBy(4);
+
         minimumAndMaximumNumberOfAssignmentsConstraint
                 .given(contract.getFirstConstractLine(), employee, shift1, shift2, shift3)
                 .penalizesBy(0);
@@ -355,26 +359,6 @@ void minimumAndMaximumNumberOfAssignments(
                 .penalizesBy(0);
     }
 
-    @ConstraintProviderTest
-    void minimumNumberOfAssignmentsNoAssignments(
-            ConstraintVerifier<NurseRosteringConstraintProvider, NurseRoster> constraintVerifier) {
-        Contract contract = new MinMaxContractBuilder(ContractLineType.TOTAL_ASSIGNMENTS)
-                .withMinimum(2)
-                .withMinimumWeight(5)
-                .build();
-
-        Employee employeeNoShifts = getEmployee(contract);
-        Employee employeeWithShifts = getEmployee(contract);
-
-        ShiftAssignment shift = getShiftAssignment(0, employeeWithShifts);
-
-        constraintVerifier.verifyThat(NurseRosteringConstraintProvider::minimumNumberOfAssignmentsNoAssignments)
-                .given(contract.getFirstConstractLine(),
-                        employeeNoShifts, employeeWithShifts,
-                        shift)
-                .penalizesBy(10);
-    }
-
     @ConstraintProviderTest
     void consecutiveWorkingDays(ConstraintVerifier<NurseRosteringConstraintProvider, NurseRoster> constraintVerifier) {
         Contract contract = new MinMaxContractBuilder(ContractLineType.CONSECUTIVE_WORKING_DAYS)