fix: preserve enum split case order

Symptom: enum split cases could be reordered after describe/exec/describe,
especially empty or body-less cases sharing the same split destination shape.

Root cause: the builder emitted enum case sequence flows with identical default
connection metadata, and the describer only had that metadata available after
MPR serialization. Cases with equivalent flow shape could therefore come back in
a different order.

Fix: encode the authoring case order into valid split flow connection pairs and
make the enum split describer sort by that encoded order before grouping case
values by destination.

Tests: added describe coverage that shuffles the stored flows but expects the
encoded enum case order to be preserved; existing enum split builder tests still
cover case value emission.

Author: hjothamendix

mdl/executor/cmd_microflows_builder_actions.go

@@ -353,7 +353,7 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 				fb.pendingAnnotations = nil
 			}
 			if lastID == "" {
-				fb.addEnumSplitFlows(splitID, actID, br.values)
+				fb.addEnumSplitFlows(splitID, actID, br.values, i)
 			} else {
 				if pendingCase != "" {
 					fb.flows = append(fb.flows, newHorizontalFlowWithCase(lastID, actID, pendingCase))
@@ -377,7 +377,7 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 		}
 		allBranchesReturn = false
 		if lastID == "" {
-			fb.addEnumSplitFlows(splitID, merge.ID, br.values)
+			fb.addEnumSplitFlows(splitID, merge.ID, br.values, i)
 		} else {
 			if pendingCase != "" {
 				fb.flows = append(fb.flows, newHorizontalFlowWithCase(lastID, merge.ID, pendingCase))
@@ -398,16 +398,53 @@ func (fb *flowBuilder) addEnumSplit(s *ast.EnumSplitStmt) model.ID {
 	return splitID
 }
 
-func (fb *flowBuilder) addEnumSplitFlows(originID, destinationID model.ID, values []string) {
+func (fb *flowBuilder) addEnumSplitFlows(originID, destinationID model.ID, values []string, order int) {
 	if len(values) == 0 {
-		fb.flows = append(fb.flows, newHorizontalFlow(originID, destinationID))
+		flow := newHorizontalFlow(originID, destinationID)
+		applySplitCaseOrder(flow, order)
+		fb.flows = append(fb.flows, flow)
 		return
 	}
 	for _, value := range values {
-		fb.flows = append(fb.flows, newHorizontalFlowWithEnumCase(originID, destinationID, value))
+		flow := newHorizontalFlowWithEnumCase(originID, destinationID, value)
+		applySplitCaseOrder(flow, order)
+		fb.flows = append(fb.flows, flow)
 	}
 }
 
+type splitCaseOrderAnchor struct {
+	origin      int
+	destination int
+}
+
+var splitCaseOrderAnchors = []splitCaseOrderAnchor{
+	{AnchorTop, AnchorLeft},
+	{AnchorRight, AnchorLeft},
+	{AnchorBottom, AnchorLeft},
+	{AnchorLeft, AnchorLeft},
+	{AnchorTop, AnchorTop},
+	{AnchorRight, AnchorTop},
+	{AnchorBottom, AnchorTop},
+	{AnchorLeft, AnchorTop},
+	{AnchorTop, AnchorRight},
+	{AnchorRight, AnchorRight},
+	{AnchorBottom, AnchorRight},
+	{AnchorLeft, AnchorRight},
+	{AnchorTop, AnchorBottom},
+	{AnchorRight, AnchorBottom},
+	{AnchorBottom, AnchorBottom},
+	{AnchorLeft, AnchorBottom},
+}
+
+func applySplitCaseOrder(flow *microflows.SequenceFlow, order int) {
+	if flow == nil || order < 0 || order >= len(splitCaseOrderAnchors) {
+		return
+	}
+	pair := splitCaseOrderAnchors[order]
+	flow.OriginConnectionIndex = pair.origin
+	flow.DestinationConnectionIndex = pair.destination
+}
+
 func enumSplitCaseValues(c ast.EnumSplitCase) []string {
 	if len(c.Values) > 0 {
 		return append([]string(nil), c.Values...)

mdl/executor/cmd_microflows_describe_enum_split_test.go

@@ -3,6 +3,7 @@
 package executor
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/mendixlabs/mxcli/model"
@@ -55,6 +56,58 @@ func TestTraverseFlow_EnumSplit(t *testing.T) {
 	assertContainsAny(t, lines, "end split;")
 }
 
+func TestTraverseFlow_EnumSplitPreservesExplicitCaseOrder(t *testing.T) {
+	e := newTestExecutor()
+
+	activityMap := map[model.ID]microflows.MicroflowObject{
+		mkID("split"): &microflows.ExclusiveSplit{
+			BaseMicroflowObject: mkObj("split"),
+			SplitCondition:      &microflows.ExpressionSplitCondition{Expression: "$Status"},
+		},
+		mkID("empty"): &microflows.ActionActivity{
+			BaseActivity: microflows.BaseActivity{BaseMicroflowObject: mkObj("empty")},
+			Action:       &microflows.LogMessageAction{LogLevel: "Info", MessageTemplate: &model.Text{Translations: map[string]string{"en_US": "empty"}}},
+		},
+		mkID("ready"): &microflows.ActionActivity{
+			BaseActivity: microflows.BaseActivity{BaseMicroflowObject: mkObj("ready")},
+			Action:       &microflows.LogMessageAction{LogLevel: "Info", MessageTemplate: &model.Text{Translations: map[string]string{"en_US": "ready"}}},
+		},
+		mkID("blocked"): &microflows.ActionActivity{
+			BaseActivity: microflows.BaseActivity{BaseMicroflowObject: mkObj("blocked")},
+			Action:       &microflows.LogMessageAction{LogLevel: "Info", MessageTemplate: &model.Text{Translations: map[string]string{"en_US": "blocked"}}},
+		},
+		mkID("merge"): &microflows.ExclusiveMerge{BaseMicroflowObject: mkObj("merge")},
+	}
+	emptyFlow := mkBranchFlow("split", "empty", microflows.EnumerationCase{Value: ""})
+	readyFlow := mkBranchFlow("split", "ready", microflows.EnumerationCase{Value: "Ready"})
+	blockedFlow := mkBranchFlow("split", "blocked", microflows.EnumerationCase{Value: "Blocked"})
+	applySplitCaseOrder(emptyFlow, 0)
+	applySplitCaseOrder(readyFlow, 1)
+	applySplitCaseOrder(blockedFlow, 2)
+	flowsByOrigin := map[model.ID][]*microflows.SequenceFlow{
+		mkID("split"):   {blockedFlow, readyFlow, emptyFlow},
+		mkID("empty"):   {mkFlow("empty", "merge")},
+		mkID("ready"):   {mkFlow("ready", "merge")},
+		mkID("blocked"): {mkFlow("blocked", "merge")},
+	}
+	splitMergeMap := map[model.ID]model.ID{mkID("split"): mkID("merge")}
+
+	var lines []string
+	visited := make(map[model.ID]bool)
+	e.traverseFlow(mkID("split"), activityMap, flowsByOrigin, splitMergeMap, visited, nil, nil, &lines, 1, nil, 0, nil)
+
+	out := strings.Join(lines, "\n")
+	emptyIdx := strings.Index(out, "case (empty)")
+	readyIdx := strings.Index(out, "case Ready")
+	blockedIdx := strings.Index(out, "case Blocked")
+	if emptyIdx == -1 || readyIdx == -1 || blockedIdx == -1 {
+		t.Fatalf("missing expected cases:\n%s", out)
+	}
+	if !(emptyIdx < readyIdx && readyIdx < blockedIdx) {
+		t.Fatalf("case order was not preserved:\n%s", out)
+	}
+}
+
 func assertContainsAny(t *testing.T, lines []string, want string) {
 	t.Helper()
 	for _, line := range lines {

mdl/executor/cmd_microflows_show_helpers.go

@@ -6,6 +6,7 @@ package executor
 import (
 	"context"
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/mendixlabs/mxcli/model"
@@ -960,7 +961,7 @@ func emitEnumSplitStatement(
 	branches := []enumBranch{}
 	branchByDestination := map[model.ID]int{}
 	var elseFlow *microflows.SequenceFlow
-	for _, flow := range findNormalFlows(flowsByOrigin[currentID]) {
+	for _, flow := range orderedEnumSplitFlows(findNormalFlows(flowsByOrigin[currentID])) {
 		caseValue, ok := enumCaseValue(flow)
 		if !ok {
 			elseFlow = flow
@@ -1024,6 +1025,26 @@ func enumCaseValue(flow *microflows.SequenceFlow) (string, bool) {
 	}
 }
 
+func orderedEnumSplitFlows(flows []*microflows.SequenceFlow) []*microflows.SequenceFlow {
+	ordered := append([]*microflows.SequenceFlow(nil), flows...)
+	sort.SliceStable(ordered, func(i, j int) bool {
+		return splitCaseOrder(ordered[i]) < splitCaseOrder(ordered[j])
+	})
+	return ordered
+}
+
+func splitCaseOrder(flow *microflows.SequenceFlow) int {
+	if flow == nil {
+		return 1 << 20
+	}
+	for i, pair := range splitCaseOrderAnchors {
+		if flow.OriginConnectionIndex == pair.origin && flow.DestinationConnectionIndex == pair.destination {
+			return i
+		}
+	}
+	return (1 << 10) + flow.OriginConnectionIndex*4 + flow.DestinationConnectionIndex
+}
+
 func formatEnumSplitCaseValue(value string) string {
 	if value == "" || value == "(empty)" {
 		return "(empty)"