Retain main version warnings in layered loads

internal/engine/source_version_test.go

@@ -9,6 +9,77 @@ import (
 	"gitea.maximumdirect.net/eric/ConfigKit/internal/document"
 )
 
+func TestDefaultMainVersionWarningSurvivesLayeredLoading(t *testing.T) {
+	t.Parallel()
+	type config struct {
+		Version string           `yaml:"version"`
+		Count   int              `yaml:"count"`
+		Items   []map[string]any `yaml:"items"`
+	}
+	for _, test := range []struct {
+		name        string
+		ordinary    bool
+		body, lower string
+		failure     bool
+	}{
+		{name: "ordinary", ordinary: true},
+		{name: "layered", lower: "{}"},
+		{name: "later structural failure", body: "configkit:\n  sequences: [{destination: [items], key: id}]\nitems: []\n", lower: "items: null", failure: true},
+		{name: "later decoding failure", body: "count: invalid\n", lower: "{}", failure: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			calls := 0
+			definition := Definition[config]{Version: &VersionRule{
+				Path: Keys("version"),
+				Check: func(version Version, validation *Validation) error {
+					calls++
+					if version.Text != "current" {
+						t.Errorf("main checker received %q", version.Text)
+					}
+					validation.Warning(Keys("version"), "accepted main version")
+					return nil
+				},
+			}}
+			source := Bytes("main", []byte("version: current\n"+test.body))
+			var loaded *testResult[config]
+			var err error
+			if test.ordinary {
+				loaded, err = testLoad(source, Options[config]{Definition: definition})
+			} else {
+				loaded, err = testGroupedLoad(loadRequest[config]{
+					main: loadInput{source: source}, definition: definition,
+					underlays: []loadGroup{{inputs: []loadInput{{source: Bytes("lower", []byte(test.lower))}}}},
+				})
+			}
+			var diagnostics []Diagnostic
+			if test.failure {
+				var loadErr *LoadError
+				if !errors.As(err, &loadErr) || loaded != nil {
+					t.Fatalf("expected failed load: %#v, %v", loaded, err)
+				}
+				diagnostics = loadErr.Diagnostics()
+				if !hasErrors(diagnostics) {
+					t.Fatal("later failure was not reported")
+				}
+			} else {
+				if err != nil {
+					t.Fatal(err)
+				}
+				diagnostics = loaded.Diagnostics()
+			}
+			warnings := 0
+			for _, diagnostic := range diagnostics {
+				if diagnostic.Code == CodeVersionWarning && diagnostic.Severity == SeverityWarning {
+					warnings++
+				}
+			}
+			if calls != 1 || warnings != 1 {
+				t.Fatalf("main checker calls = %d, retained warnings = %d; diagnostics = %#v", calls, warnings, diagnostics)
+			}
+		})
+	}
+}
+
 func TestSourceVersionAbsentPathKeepsUnresolvedSegmentIntent(t *testing.T) {
 	t.Parallel()
 	for _, test := range []struct {