fix: always emit merge for continuing inheritance split branches

addStructuredInheritanceSplit took a no-merge shortcut when exactly
one non-split branch continued and the rest terminated — it wired
the parent's next statement directly to that branch's tail.

Two failure modes followed:

1. Re-describe emitted the parent continuation inside the case
   body (the post-split statement was visually buried inside the
   first case).
2. Studio Pro raised CE0079 ("condition value should be configured
   for an outgoing flow") on terminating branches because their
   cases had no merge to converge on.

With this change any surviving branch causes a merge to be emitted,
so the parent always resumes after the split.

Test: new TestInheritanceSplitAlwaysEmitsMergeWhenBranchContinues
asserts that a one-case + terminating-else split still creates
the ExclusiveMerge.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hjothamendix

mdl/executor/cmd_microflows_builder_actions.go

@@ -557,10 +557,15 @@ func (fb *flowBuilder) addStructuredInheritanceSplit(s *ast.InheritanceSplitStmt
 	fb.endsWithReturn = savedEndsWithReturn
 	if allBranchesReturn {
 		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 {
+		// Always emit an ExclusiveMerge when at least one branch continues.
+		// Previous code skipped the merge when exactly one non-split branch
+		// continued and wired the parent's next statement directly to that
+		// branch's tail — but re-describe then buried the parent continuation
+		// inside the case body, and Studio Pro rejected the terminating
+		// branches' outgoing flows with CE0079 ("condition value should be
+		// configured for an outgoing flow") because they had no merge to
+		// converge on.
 		merge := &microflows.ExclusiveMerge{
 			BaseMicroflowObject: microflows.BaseMicroflowObject{
 				BaseElement: model.BaseElement{ID: model.ID(types.GenerateID())},

mdl/executor/cmd_microflows_builder_inheritance_split_merge_test.go

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package executor
+
+import (
+	"testing"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+	"github.com/mendixlabs/mxcli/sdk/microflows"
+)
+
+// TestInheritanceSplitAlwaysEmitsMergeWhenBranchContinues guards against a
+// describe/exec roundtrip regression where `addStructuredInheritanceSplit`
+// used to take a "no-merge shortcut" when exactly one non-split branch
+// continued: it wired the parent's next statement directly to the
+// continuing case's tail. Two things broke:
+//
+//  1. Re-describe emitted the parent's continuation inside the case body
+//     (visually burying statements in the wrong scope).
+//  2. Studio Pro raised CE0079 ("condition value should be configured for
+//     an outgoing flow") on terminating branches because their cases had
+//     no merge to converge on.
+func TestInheritanceSplitAlwaysEmitsMergeWhenBranchContinues(t *testing.T) {
+	fb := &flowBuilder{
+		spacing:  HorizontalSpacing,
+		measurer: &layoutMeasurer{},
+	}
+
+	// An InheritanceSplit with one continuing case (`CastedA`) and a
+	// terminating else that returns. Before the fix this took the no-merge
+	// shortcut because branchTails == 1 && !fromSplit.
+	fb.addStructuredInheritanceSplit(&ast.InheritanceSplitStmt{
+		Variable: "obj",
+		Cases: []ast.InheritanceSplitCase{
+			{
+				Entity: ast.QualifiedName{Module: "M", Name: "CastedA"},
+				Body: []ast.MicroflowStatement{
+					&ast.LogStmt{Level: ast.LogInfo, Message: &ast.LiteralExpr{Kind: ast.LiteralString, Value: "continue"}},
+				},
+			},
+		},
+		ElseBody: []ast.MicroflowStatement{
+			&ast.ReturnStmt{},
+		},
+	})
+
+	var merge *microflows.ExclusiveMerge
+	for _, obj := range fb.objects {
+		if m, ok := obj.(*microflows.ExclusiveMerge); ok {
+			merge = m
+		}
+	}
+	if merge == nil {
+		t.Fatal("expected ExclusiveMerge to be created when one branch continues — no-merge shortcut regression")
+	}
+}