fix: stabilize MDL test runner and docker flow

Several unrelated papercuts made the integration/test-runner flow
unreliable in CI. This folds the fixes into one scope (MDL test runner
+ docker pathing) since they were discovered together while chasing
the same green build.

Test-runner and generator:
- `varPattern` / `assignPattern` now match on any line in the test
  body (added `(?m)` flag and tightened anchoring). Without this,
  multi-line test cases saw `$var = CREATE ...` silently left
  un-rewritten, which then failed the compiled microflow with
  "variable is not declared".
- Drop the `isSideEffectStatement` / auto-`ON ERROR CONTINUE` wrapping
  for DELETE/COMMIT/CHANGE. The blanket wrap hid actual test failures
  behind silent passes; if a test wants tolerant error handling it can
  write it explicitly.
- `runner.Run` now ensures the `.docker/` stack exists before building
  or restarting (new `ensureDockerStack` helper that calls
  `docker.Init` on demand). Previously a fresh checkout with no
  `.docker/docker-compose.yml` failed with a raw `stat` error before
  any test ran.

Docker layer:
- `resolveMxBuild` / `ResolveMxForVersion` now accept a preferred
  project version and prefer exact-match cached binaries over the
  lexicographically-last glob entry (which sorted Mendix 9 after 11).
  `AnyCachedMxBuildPath` and the MxBuild downloader share the new
  `newestVersionedPath` helper that parses `[major,minor,patch,build]`
  numerically.
- `findPADDir` / `isPADDir` recognise the already-extracted layout
  (`app/`, `bin/`, `etc/`, `lib/`) produced by newer PAD outputs where
  the Dockerfile is not emitted.
- `Check` resolves the project's version from the MPR reader and
  passes it through, so check-on-build uses the same `mx` binary the
  project was last built against.

Microflow builder type inference:
- `flowBuilder.lookupMicroflowReturnType` walks the raw microflow unit
  to fetch the return type of a called microflow. When the builder
  knows the return type, `registerResultVariableType` records it in
  `varTypes` with qualified entity name, so subsequent CHANGE /
  attribute-access activities on the returned variable resolve
  correctly. This is what lets tests like
  `$Product = CALL MfTest.M012_CreateEntity();
  CHANGE $Product SET Price = 10.0;` validate without forcing the
  test author to re-declare the variable type.

Makefile / scripts:
- `make test-mdl` now goes through `scripts/run-mdl-tests.sh`, which
  copies the project into a temp directory before running the
  bootstrap MDL + test spec. The old direct invocation mutated the
  repo's seed `app.mpr`, so re-running the target picked up stale
  state.

Regression tests:
- `TestFindPADDir_ExtractedLayoutInRoot` for the new PAD layout
- generator tests cover the multiline assign pattern
- builder-type test uses `MockBackend.ListMicroflowsFunc` to assert
  that a subsequent CHANGE resolves against the returned entity

Author: hjotha

Makefile

@@ -151,7 +151,7 @@ test-integration:
 # Usage: make test-mdl MPR=path/to/app.mpr
 MPR ?= app.mpr
 test-mdl: build
-	$(BUILD_DIR)/$(BINARY_NAME) test mdl-examples/doctype-tests/microflow-spec.test.mdl -p $(MPR)
+	./scripts/run-mdl-tests.sh "$(abspath $(MPR))" "$(abspath $(BUILD_DIR)/$(BINARY_NAME))"
 
 # Lint all code (Go + TypeScript)
 lint: lint-go lint-ts

cmd/mxcli/docker/build.go

@@ -65,7 +65,7 @@ func Build(opts BuildOptions) error {
 
 	// Step 2: Resolve MxBuild
 	fmt.Fprintln(w, "Resolving MxBuild...")
-	mxbuildPath, err := resolveMxBuild(opts.MxBuildPath)
+	mxbuildPath, err := resolveMxBuild(opts.MxBuildPath, pv.ProductVersion)
 	if err != nil {
 		// Auto-download fallback
 		fmt.Fprintln(w, "  MxBuild not found locally, downloading from CDN...")
@@ -96,7 +96,7 @@ func Build(opts BuildOptions) error {
 	// Step 4: Pre-build check
 	if !opts.SkipCheck {
 		fmt.Fprintln(w, "Checking project for errors...")
-		mxPath, err := ResolveMx(opts.MxBuildPath)
+		mxPath, err := ResolveMxForVersion(opts.MxBuildPath, pv.ProductVersion)
 		if err != nil {
 			fmt.Fprintf(w, "  Skipping check: %v\n", err)
 		} else {
@@ -383,8 +383,10 @@ func Run(opts RunOptions) error {
 }
 
 // findPADDir searches for a PAD output in the output directory tree.
-// It looks for a Dockerfile first, then for docker_compose/Default.yaml as a fallback
-// (MxBuild 11.6.3+ generates docker_compose instead of a Dockerfile).
+// It recognizes:
+//   - classic PAD output with a Dockerfile
+//   - PAD output with docker_compose/Default.yaml
+//   - newer PAD output already extracted at the build root (app/bin/etc/lib)
 func findPADDir(outputDir string) (string, error) {
 	// Check output dir itself
 	if isPADDir(outputDir) {
@@ -405,19 +407,48 @@ func findPADDir(outputDir string) (string, error) {
 		}
 	}
 
-	return "", fmt.Errorf("no PAD output found in %s (looked for Dockerfile or docker_compose/Default.yaml)", outputDir)
+	return "", fmt.Errorf("no PAD output found in %s (looked for Dockerfile, docker_compose/Default.yaml, or extracted app/bin/etc/lib layout)", outputDir)
 }
 
 // isPADDir checks if a directory contains PAD output.
-// Recognizes both Dockerfile-based PAD and docker_compose-based PAD.
+// Recognizes Dockerfile-based PAD, docker_compose-based PAD, and newer
+// already-extracted PAD layout at the build root.
 func isPADDir(dir string) bool {
 	if _, err := os.Stat(filepath.Join(dir, "Dockerfile")); err == nil {
 		return true
 	}
 	if _, err := os.Stat(filepath.Join(dir, "docker_compose", "Default.yaml")); err == nil {
 		return true
 	}
-	return false
+	return hasExtractedPADLayout(dir)
+}
+
+func hasExtractedPADLayout(dir string) bool {
+	requiredDirs := []string{
+		filepath.Join(dir, "app"),
+		filepath.Join(dir, "bin"),
+		filepath.Join(dir, "etc"),
+		filepath.Join(dir, "lib"),
+	}
+	for _, path := range requiredDirs {
+		info, err := os.Stat(path)
+		if err != nil || !info.IsDir() {
+			return false
+		}
+	}
+
+	requiredFiles := []string{
+		filepath.Join(dir, "bin", "start"),
+		filepath.Join(dir, "lib", "runtime", "launcher", "runtimelauncher.jar"),
+	}
+	for _, path := range requiredFiles {
+		info, err := os.Stat(path)
+		if err != nil || info.IsDir() {
+			return false
+		}
+	}
+
+	return true
 }
 
 // flattenPADDir moves contents from a PAD subdirectory to the output root directory.

cmd/mxcli/docker/build_test.go

@@ -434,6 +434,34 @@ func TestFindPADDir_DockerCompose_InSubdir(t *testing.T) {
 	}
 }
 
+func TestFindPADDir_ExtractedLayoutInRoot(t *testing.T) {
+	dir := t.TempDir()
+	for _, subdir := range []string{
+		filepath.Join(dir, "app"),
+		filepath.Join(dir, "etc"),
+		filepath.Join(dir, "bin"),
+		filepath.Join(dir, "lib", "runtime", "launcher"),
+	} {
+		if err := os.MkdirAll(subdir, 0755); err != nil {
+			t.Fatalf("mkdir %s: %v", subdir, err)
+		}
+	}
+	if err := os.WriteFile(filepath.Join(dir, "bin", "start"), []byte("#!/bin/sh\n"), 0755); err != nil {
+		t.Fatalf("write start script: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "lib", "runtime", "launcher", "runtimelauncher.jar"), []byte("fake"), 0644); err != nil {
+		t.Fatalf("write launcher: %v", err)
+	}
+
+	padDir, err := findPADDir(dir)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if padDir != dir {
+		t.Errorf("expected %s, got %s", dir, padDir)
+	}
+}
+
 func TestFindPADDir_PrefersDockerfile(t *testing.T) {
 	dir := t.TempDir()
 	// Both Dockerfile and docker_compose exist — Dockerfile wins

cmd/mxcli/docker/check.go

@@ -10,6 +10,8 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+
+	"github.com/mendixlabs/mxcli/sdk/mpr"
 )
 
 // CheckOptions configures the mx check command.
@@ -44,7 +46,15 @@ func Check(opts CheckOptions) error {
 	}
 
 	// Resolve mx binary
-	mxPath, err := ResolveMx(opts.MxBuildPath)
+	projectVersion := ""
+	if opts.ProjectPath != "" {
+		if reader, err := mpr.Open(opts.ProjectPath); err == nil {
+			projectVersion = reader.ProjectVersion().ProductVersion
+			reader.Close()
+		}
+	}
+
+	mxPath, err := ResolveMxForVersion(opts.MxBuildPath, projectVersion)
 	if err != nil {
 		return err
 	}
@@ -88,12 +98,25 @@ func mxBinaryName() string {
 	return "mx"
 }
 
+func mxBinaryNames() []string {
+	if runtime.GOOS == "windows" {
+		return []string{"mx.exe", "mx"}
+	}
+	return []string{"mx"}
+}
+
 // ResolveMx finds the mx executable.
 // Priority: derive from mxbuild path > PATH lookup.
 func ResolveMx(mxbuildPath string) (string, error) {
+	return ResolveMxForVersion(mxbuildPath, "")
+}
+
+// ResolveMxForVersion finds the mx executable, preferring the project's exact
+// Mendix version when multiple local installations or cached downloads exist.
+func ResolveMxForVersion(mxbuildPath, preferredVersion string) (string, error) {
 	if mxbuildPath != "" {
 		// Resolve mxbuild first to handle directory paths
-		resolvedMxBuild, err := resolveMxBuild(mxbuildPath)
+		resolvedMxBuild, err := resolveMxBuild(mxbuildPath, preferredVersion)
 		if err == nil {
 			// Look for mx in the same directory as mxbuild
 			mxDir := filepath.Dir(resolvedMxBuild)
@@ -123,24 +146,47 @@ func ResolveMx(mxbuildPath string) (string, error) {
 		return p, nil
 	}
 
+	if preferredVersion != "" {
+		if studioProDir := ResolveStudioProDir(preferredVersion); studioProDir != "" {
+			for _, name := range mxBinaryNames() {
+				candidate := filepath.Join(studioProDir, "modeler", name)
+				if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
+					return candidate, nil
+				}
+			}
+		}
+	}
+
 	// Try OS-specific known locations (Studio Pro on Windows) before cached downloads.
-	for _, pattern := range mendixSearchPaths(mxBinaryName()) {
-		matches, _ := filepath.Glob(pattern)
-		if len(matches) > 0 {
-			return matches[len(matches)-1], nil
+	if matches := globVersionedMatches(mendixSearchPaths(mxBinaryName())); len(matches) > 0 {
+		if exact := exactVersionedPath(matches, preferredVersion); exact != "" {
+			return exact, nil
+		}
+		if newest := newestVersionedPath(matches); newest != "" {
+			return newest, nil
 		}
 	}
 
-	// Try cached mxbuild installations (~/.mxcli/mxbuild/*/modeler/mx).
-	// NOTE: lexicographic sort is imperfect for versions (e.g. "9.x" > "10.x"),
-	// but this is a fallback-of-last-resort — in practice users typically have
-	// only one mxbuild version installed.
-	if home, err := os.UserHomeDir(); err == nil {
-		matches, _ := filepath.Glob(filepath.Join(home, ".mxcli", "mxbuild", "*", "modeler", mxBinaryName()))
-		if len(matches) > 0 {
-			return matches[len(matches)-1], nil
+	if preferredVersion != "" {
+		if p := CachedMxPath(preferredVersion); p != "" {
+			return p, nil
 		}
 	}
+	if p := AnyCachedMxPath(); p != "" {
+		return p, nil
+	}
 
 	return "", fmt.Errorf("mx not found; specify --mxbuild-path pointing to Mendix installation directory")
 }
+
+func CachedMxPath(version string) string {
+	cacheDir, err := MxBuildCacheDir(version)
+	if err != nil {
+		return ""
+	}
+	return cachedBinaryPath(cacheDir, mxBinaryNames())
+}
+
+func AnyCachedMxPath() string {
+	return anyCachedBinaryPath(mxBinaryNames())
+}

cmd/mxcli/docker/check_test.go

@@ -118,3 +118,33 @@ func TestCheck_SkipUpdateWidgetsFlag(t *testing.T) {
 		t.Error("check should still be called")
 	}
 }
+
+func TestResolveMxForVersion_PrefersExactCachedVersion(t *testing.T) {
+	dir := t.TempDir()
+	setTestHomeDir(t, dir)
+	t.Setenv("PATH", "")
+
+	versions := []string{"9.24.40.80973", "11.6.3", "11.9.0"}
+	var expected string
+	for _, version := range versions {
+		modelerDir := filepath.Join(dir, ".mxcli", "mxbuild", version, "modeler")
+		if err := os.MkdirAll(modelerDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		bin := filepath.Join(modelerDir, mxBinaryName())
+		if err := os.WriteFile(bin, []byte("fake"), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if version == "11.9.0" {
+			expected = bin
+		}
+	}
+
+	result, err := ResolveMxForVersion("", "11.9.0")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if result != expected {
+		t.Errorf("expected exact cached mx %s, got %s", expected, result)
+	}
+}

cmd/mxcli/docker/detect.go

@@ -73,7 +73,12 @@ func findMxBuildInDir(dir string) string {
 // CDN downloads are Linux binaries that cannot run natively on Windows.
 // The explicit path can be the binary itself or a directory containing it
 // (e.g., a Mendix installation root with modeler/mxbuild inside).
-func resolveMxBuild(explicitPath string) (string, error) {
+func resolveMxBuild(explicitPath string, preferredVersion ...string) (string, error) {
+	targetVersion := ""
+	if len(preferredVersion) > 0 {
+		targetVersion = preferredVersion[0]
+	}
+
 	if explicitPath != "" {
 		info, err := os.Stat(explicitPath)
 		if err != nil {
@@ -94,13 +99,31 @@ func resolveMxBuild(explicitPath string) (string, error) {
 		return p, nil
 	}
 
+	// Try the exact Studio Pro installation for the project version first.
+	// This keeps Docker builds on the same Mendix line as the project when
+	// multiple installs are present locally.
+	if targetVersion != "" {
+		if studioProDir := ResolveStudioProDir(targetVersion); studioProDir != "" {
+			if found := findMxBuildInDir(studioProDir); found != "" {
+				return found, nil
+			}
+		}
+	}
+
 	// Try OS-specific known locations (Studio Pro on Windows) BEFORE cached downloads.
 	// On Windows, CDN downloads are Linux binaries — Studio Pro's mxbuild.exe is preferred.
-	for _, pattern := range mxbuildSearchPaths() {
-		matches, _ := filepath.Glob(pattern)
-		if len(matches) > 0 {
-			// Return the last match (likely newest version)
-			return matches[len(matches)-1], nil
+	if matches := globVersionedMatches(mxbuildSearchPaths()); len(matches) > 0 {
+		if exact := exactVersionedPath(matches, targetVersion); exact != "" {
+			return exact, nil
+		}
+		if newest := newestVersionedPath(matches); newest != "" {
+			return newest, nil
+		}
+	}
+
+	if targetVersion != "" {
+		if p := CachedMxBuildPath(targetVersion); p != "" {
+			return p, nil
 		}
 	}
 

cmd/mxcli/docker/detect_test.go

@@ -268,3 +268,33 @@ func TestResolveMxBuild_PrefersStudioProOverCache(t *testing.T) {
 		t.Errorf("expected Studio Pro binary %s, got %s (should prefer Studio Pro over cache)", studioBin, result)
 	}
 }
+
+func TestResolveMxBuild_PrefersExactCachedVersion(t *testing.T) {
+	dir := t.TempDir()
+	setTestHomeDir(t, dir)
+	t.Setenv("PATH", "")
+
+	versions := []string{"9.24.40.80973", "11.6.3", "11.9.0"}
+	var expected string
+	for _, version := range versions {
+		modelerDir := filepath.Join(dir, ".mxcli", "mxbuild", version, "modeler")
+		if err := os.MkdirAll(modelerDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		bin := filepath.Join(modelerDir, mxbuildBinaryName())
+		if err := os.WriteFile(bin, []byte("fake"), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if version == "11.9.0" {
+			expected = bin
+		}
+	}
+
+	result, err := resolveMxBuild("", "11.9.0")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if result != expected {
+		t.Errorf("expected exact cached version %s, got %s", expected, result)
+	}
+}