fix: preserve inheritance split nested continuation cases

Symptom: an inheritance split branch containing a nested empty-then decision
could lose the boolean case value on the continuation flow when the branch
joined a shared split merge.

Root cause: addStructuredInheritanceSplit consumed flowBuilder.nextConnectionPoint
from the nested decision but did not carry flowBuilder.nextFlowCase through branch
tail wiring.

Fix: preserve the pending case value on inheritance branch tails and reapply it
when connecting to the next statement, parent continuation, or shared merge.

Tests: add a builder regression for nested empty-then inheritance branches that
must keep CaseValue=true on continuation flows.

Author: hjothamendix

mdl/executor/cmd_microflows_builder_actions.go

@@ -480,6 +480,7 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		fb.endsWithReturn = false
 
 		var lastID model.ID
+		pendingCase := ""
 		for _, stmt := range body {
 			actID := fb.addStatement(stmt)
 			if actID == "" {
@@ -504,11 +505,18 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 				}
 				fb.flows = append(fb.flows, flow)
 			} else {
-				fb.flows = append(fb.flows, newHorizontalFlow(lastID, actID))
+				if pendingCase != "" {
+					fb.flows = append(fb.flows, newHorizontalFlowWithCase(lastID, actID, pendingCase))
+					pendingCase = ""
+				} else {
+					fb.flows = append(fb.flows, newHorizontalFlow(lastID, actID))
+				}
 			}
 			if fb.nextConnectionPoint != "" {
 				lastID = fb.nextConnectionPoint
 				fb.nextConnectionPoint = ""
+				pendingCase = fb.nextFlowCase
+				fb.nextFlowCase = ""
 			} else {
 				lastID = actID
 			}
@@ -517,7 +525,7 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		if !lastStmtIsReturn(body) {
 			allBranchesReturn = false
 			if lastID != "" {
-				branchTails = append(branchTails, branchTail{id: lastID})
+				branchTails = append(branchTails, branchTail{id: lastID, caseValue: pendingCase})
 			}
 		}
 	}
@@ -534,6 +542,7 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 		fb.endsWithReturn = true
 	} else if len(branchTails) == 1 && !branchTails[0].fromSplit {
 		fb.nextConnectionPoint = branchTails[0].id
+		fb.nextFlowCase = branchTails[0].caseValue
 	} else if len(branchTails) > 0 {
 		merge := &microflows.ExclusiveMerge{
 			BaseMicroflowObject: microflows.BaseMicroflowObject{
@@ -551,7 +560,11 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 					fb.flows = append(fb.flows, newDownwardFlowWithInheritanceCase(splitID, merge.ID, tail.caseValue))
 				}
 			} else {
-				fb.flows = append(fb.flows, newHorizontalFlow(tail.id, merge.ID))
+				if tail.caseValue != "" {
+					fb.flows = append(fb.flows, newHorizontalFlowWithCase(tail.id, merge.ID, tail.caseValue))
+				} else {
+					fb.flows = append(fb.flows, newHorizontalFlow(tail.id, merge.ID))
+				}
 			}
 		}
 		fb.nextConnectionPoint = merge.ID

mdl/executor/cmd_microflows_inheritance_test.go

@@ -130,6 +130,72 @@ func TestLastStmtIsReturn_InheritanceSplitAllBranchesReturn(t *testing.T) {
 	}
 }
 
+func TestBuilder_InheritanceSplitNestedEmptyThenBranchKeepsContinuationCase(t *testing.T) {
+	fb := &flowBuilder{
+		spacing:      HorizontalSpacing,
+		declaredVars: map[string]string{"HasMember": "Boolean", "HasApp": "Boolean"},
+		varTypes:     map[string]string{"Selection": "Sample.Selection"},
+		measurer:     &layoutMeasurer{},
+	}
+
+	oc := fb.buildFlowGraph([]ast.MicroflowStatement{
+		&ast.InheritanceSplitStmt{
+			Variable: "Selection",
+			Cases: []ast.InheritanceSplitCase{
+				{
+					Entity: ast.QualifiedName{Module: "Sample", Name: "MemberSelection"},
+					Body: []ast.MicroflowStatement{
+						&ast.IfStmt{
+							Condition: &ast.VariableExpr{Name: "HasMember"},
+							ElseBody:  []ast.MicroflowStatement{&ast.ReturnStmt{}},
+						},
+					},
+				},
+				{
+					Entity: ast.QualifiedName{Module: "Sample", Name: "AppSelection"},
+					Body: []ast.MicroflowStatement{
+						&ast.IfStmt{
+							Condition: &ast.VariableExpr{Name: "HasApp"},
+							ElseBody:  []ast.MicroflowStatement{&ast.ReturnStmt{}},
+						},
+					},
+				},
+			},
+			ElseBody: []ast.MicroflowStatement{&ast.ReturnStmt{}},
+		},
+		&ast.LogStmt{Level: ast.LogInfo, Message: &ast.LiteralExpr{Kind: ast.LiteralString, Value: "shared tail"}},
+	}, nil)
+
+	objects := map[model.ID]microflows.MicroflowObject{}
+	var nestedSplitID model.ID
+	for _, obj := range oc.Objects {
+		objects[obj.GetID()] = obj
+		split, ok := obj.(*microflows.ExclusiveSplit)
+		if !ok {
+			continue
+		}
+		if condition, ok := split.SplitCondition.(*microflows.ExpressionSplitCondition); ok && condition.Expression == "$HasMember" {
+			nestedSplitID = split.ID
+		}
+	}
+	if nestedSplitID == "" {
+		t.Fatal("expected nested decision split")
+	}
+	for _, flow := range oc.Flows {
+		if flow.OriginID != nestedSplitID {
+			continue
+		}
+		caseValue, ok := flow.CaseValue.(microflows.EnumerationCase)
+		if !ok || caseValue.Value != "true" {
+			continue
+		}
+		if _, ok := objects[flow.DestinationID].(*microflows.ExclusiveMerge); ok {
+			return
+		}
+	}
+	t.Fatal("nested empty-then inheritance branch must carry CaseValue=true to the inheritance merge")
+}
+
 func assertLineContains(t *testing.T, lines []string, want string) {
 	t.Helper()
 	for _, line := range lines {