fix: preserve XPath path source spacing in retrieve clauses

Symptom: retrieve WHERE clauses using compact XPath paths could roundtrip as canonicalized paths with spaces around '/', producing cosmetic drift.

Root cause: source-expression preservation did not treat retrieve XPath paths as source-sensitive, and XPath constraints were built directly from normalized XPath AST nodes.

Fix: preserve original source text for XPath constraints and retrieve WHERE expressions that contain path separators without changing normal expression parsing.

Tests: added a retrieve XPath path-spacing regression and ran make test.

Author: hjothamendix

mdl/visitor/visitor_microflow_statements.go

@@ -934,15 +934,15 @@ func buildRetrieveStatement(ctx parser.IRetrieveStatementContext) *ast.RetrieveS
 		if len(xpathConstraints) == 1 {
 			xcCtx := xpathConstraints[0].(*parser.XpathConstraintContext)
 			if xpathExpr := xcCtx.XpathExpr(); xpathExpr != nil {
-				stmt.Where = buildXPathExpr(xpathExpr)
+				stmt.Where = buildXPathSourceExpression(xpathExpr)
 			}
 		} else if len(xpathConstraints) > 1 {
 			// Multiple predicates [cond1][cond2] — combine with AND
 			var andExprs []ast.Expression
 			for _, xc := range xpathConstraints {
 				xcCtx := xc.(*parser.XpathConstraintContext)
 				if xpathExpr := xcCtx.XpathExpr(); xpathExpr != nil {
-					andExprs = append(andExprs, buildXPathExpr(xpathExpr))
+					andExprs = append(andExprs, buildXPathSourceExpression(xpathExpr))
 				}
 			}
 			if len(andExprs) == 1 {
@@ -956,7 +956,7 @@ func buildRetrieveStatement(ctx parser.IRetrieveStatementContext) *ast.RetrieveS
 				stmt.Where = result
 			}
 		} else if expr := retrCtx.Expression(0); expr != nil {
-			stmt.Where = buildSourceExpression(expr)
+			stmt.Where = buildRetrieveWhereExpression(expr)
 		}
 	}
 
@@ -1172,6 +1172,34 @@ func buildSourceExpression(ctx parser.IExpressionContext) ast.Expression {
 	return expr
 }
 
+func buildXPathSourceExpression(ctx parser.IXpathExprContext) ast.Expression {
+	if ctx == nil {
+		return nil
+	}
+	expr := buildXPathExpr(ctx)
+	if prc, ok := ctx.(antlr.ParserRuleContext); ok {
+		if source := strings.TrimSpace(extractOriginalText(prc)); source != "" {
+			return &ast.SourceExpr{Expression: expr, Source: source}
+		}
+	}
+	return expr
+}
+
+func buildRetrieveWhereExpression(ctx parser.IExpressionContext) ast.Expression {
+	if ctx == nil {
+		return nil
+	}
+	expr := buildExpression(ctx)
+	if prc, ok := ctx.(antlr.ParserRuleContext); ok {
+		if source := strings.TrimSpace(extractOriginalText(prc)); source != "" {
+			if shouldPreserveExpressionSource(source) || strings.Contains(source, "/") {
+				return &ast.SourceExpr{Expression: expr, Source: source}
+			}
+		}
+	}
+	return expr
+}
+
 func shouldPreserveExpressionSource(source string) bool {
 	if strings.ContainsAny(source, "\r\n") {
 		return true

mdl/visitor/visitor_test.go

@@ -1714,6 +1714,30 @@ END;`
 	}
 }
 
+func TestRetrieveXPathPreservesOriginalPathSpacing(t *testing.T) {
+	input := `CREATE MICROFLOW Synthetic.PreserveXPathPathSpacing ()
+BEGIN
+  RETRIEVE $Items FROM Synthetic.Item
+    WHERE Synthetic.Item_Group/Synthetic.Group/Synthetic.Group_Company = $Company;
+END;`
+
+	prog, errs := Build(input)
+	if len(errs) > 0 {
+		t.Fatalf("unexpected parse errors: %v", errs)
+	}
+
+	mf := prog.Statements[0].(*ast.CreateMicroflowStmt)
+	retrieveStmt := mf.Body[0].(*ast.RetrieveStmt)
+	source, ok := retrieveStmt.Where.(*ast.SourceExpr)
+	if !ok {
+		t.Fatalf("expected retrieve XPath SourceExpr, got %T", retrieveStmt.Where)
+	}
+	want := "Synthetic.Item_Group/Synthetic.Group/Synthetic.Group_Company = $Company"
+	if source.Source != want {
+		t.Fatalf("XPath source = %q, want %q", source.Source, want)
+	}
+}
+
 func TestTrailingExpressionWhitespacePreservedForRoundtripSlots(t *testing.T) {
 	input := `CREATE MICROFLOW Synthetic.PreserveTrailingExpressionWhitespace (
   $Object: Synthetic.Entity