fix: emit boolean case values for IF flows

Symptom: MPR validation can report duplicate output variables for values declared in mutually exclusive IF branches after exec builds the graph, even though the source paths are exclusive.

Root cause: IF sequence flows used EnumerationCase values with the strings "true" and "false". Studio Pro accepts the graph shape, but its consistency checker does not treat those flows as proper boolean split branches for variable scoping.

Fix: emit BooleanCase for true/false flow cases and keep EnumerationCase for real enum branch values. Update existing tests to assert boolean cases for boolean split continuations.

Tests: make build, make test, make lint-go.

Author: hjothamendix

mdl/executor/cmd_microflows_builder_enum_split_test.go

@@ -111,7 +111,7 @@ func TestEnumSplitNestedEmptyThenBranchKeepsContinuationCase(t *testing.T) {
 		if flow.OriginID != nestedSplitID {
 			continue
 		}
-		if value, ok := enumCaseValue(flow); ok && value == "true" {
+		if flowCaseString(flow.CaseValue) == "true" {
 			if _, ok := objects[flow.DestinationID].(*microflows.ExclusiveMerge); ok {
 				return
 			}

mdl/executor/cmd_microflows_builder_flows.go

@@ -653,10 +653,7 @@ func newHorizontalFlow(originID, destinationID model.ID) *microflows.SequenceFlo
 // newHorizontalFlowWithCase creates a horizontal SequenceFlow with a boolean case value (for splits)
 func newHorizontalFlowWithCase(originID, destinationID model.ID, caseValue string) *microflows.SequenceFlow {
 	flow := newHorizontalFlow(originID, destinationID)
-	flow.CaseValue = microflows.EnumerationCase{
-		BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
-		Value:       caseValue, // "true" or "false" as string
-	}
+	flow.CaseValue = caseValueForFlow(caseValue)
 	return flow
 }
 
@@ -678,10 +675,27 @@ func newDownwardFlowWithCase(originID, destinationID model.ID, caseValue string)
 		DestinationID:              destinationID,
 		OriginConnectionIndex:      AnchorBottom, // Connect from bottom of origin (going down)
 		DestinationConnectionIndex: AnchorLeft,   // Connect to left side of destination
-		CaseValue: microflows.EnumerationCase{
+		CaseValue:                  caseValueForFlow(caseValue),
+	}
+}
+
+func caseValueForFlow(caseValue string) microflows.CaseValue {
+	switch caseValue {
+	case "true":
+		return microflows.BooleanCase{
 			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
-			Value:       caseValue, // "true" or "false" as string
-		},
+			Value:       true,
+		}
+	case "false":
+		return microflows.BooleanCase{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Value:       false,
+		}
+	default:
+		return microflows.EnumerationCase{
+			BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},
+			Value:       caseValue,
+		}
 	}
 }
 

mdl/executor/cmd_microflows_guard_pattern_test.go

@@ -47,17 +47,11 @@ func TestBuilder_GuardPatternPreservesFalseBranchAnchor(t *testing.T) {
 	oc := fb.buildFlowGraph(body, nil)
 
 	// Find the flow from the split to the tail log. It's the only one with
-	// an EnumerationCase Value=="false" that doesn't target an EndEvent.
+	// a BooleanCase Value==false that doesn't target an EndEvent.
 	var found *microflows.SequenceFlow
 	for _, f := range oc.Flows {
-		cv, ok := f.CaseValue.(microflows.EnumerationCase)
-		if !ok {
-			if p, okp := f.CaseValue.(*microflows.EnumerationCase); okp {
-				cv = *p
-				ok = true
-			}
-		}
-		if !ok || cv.Value != "false" {
+		cv, ok := f.CaseValue.(microflows.BooleanCase)
+		if !ok || cv.Value {
 			continue
 		}
 		// Exclude flows pointing at an EndEvent.
@@ -85,3 +79,31 @@ func TestBuilder_GuardPatternPreservesFalseBranchAnchor(t *testing.T) {
 		t.Errorf("destination: got %d, want %d (Top)", found.DestinationConnectionIndex, AnchorTop)
 	}
 }
+
+func TestCaseValueForFlowUsesBooleanCaseForBooleanBranches(t *testing.T) {
+	for _, tc := range []struct {
+		value string
+		want  bool
+	}{
+		{value: "true", want: true},
+		{value: "false", want: false},
+	} {
+		got, ok := caseValueForFlow(tc.value).(microflows.BooleanCase)
+		if !ok {
+			t.Fatalf("caseValueForFlow(%q) = %T, want BooleanCase", tc.value, caseValueForFlow(tc.value))
+		}
+		if got.Value != tc.want {
+			t.Fatalf("caseValueForFlow(%q).Value = %v, want %v", tc.value, got.Value, tc.want)
+		}
+	}
+}
+
+func TestCaseValueForFlowKeepsEnumValuesAsEnumerationCase(t *testing.T) {
+	got, ok := caseValueForFlow("Submitted").(microflows.EnumerationCase)
+	if !ok {
+		t.Fatalf("caseValueForFlow(enum) = %T, want EnumerationCase", caseValueForFlow("Submitted"))
+	}
+	if got.Value != "Submitted" {
+		t.Fatalf("enum case value = %q, want Submitted", got.Value)
+	}
+}