From a9c72c1b6765db16dd27d1182a187a29d7844488 Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Wed, 18 Nov 2026 00:37:16 +0000 Subject: [PATCH] Parse main-scoped secrets bootstrap controls --- docs/roadmap/implementation.md | 2 + facade_config_directives_test.go | 68 +++++++++++++++ internal/engine/contextless_imports.go | 2 +- internal/engine/destination_import_test.go | 2 +- internal/engine/directive_scope_test.go | 87 +++++++++++++++++++- internal/engine/directives.go | 80 ++++++++++++++++-- internal/engine/import_acquisition.go | 2 +- internal/engine/import_spec_test.go | 2 +- internal/engine/imports_test.go | 2 +- internal/engine/sequence_declaration_test.go | 8 +- internal/engine/source_version.go | 2 +- 11 files changed, 239 insertions(+), 18 deletions(-) diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index f2d4d64..2592166 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -179,6 +179,8 @@ new `LoadSecretsDir` tests once callers compile. ## Stage 2 — Add main-scoped bootstrap control parsing +**Completed.** + Work primarily in `internal/engine/directives.go`, `acquisition.go`, and the directive/version parsing handoffs in `source_version.go`. diff --git a/facade_config_directives_test.go b/facade_config_directives_test.go index 641810e..490ba8a 100644 --- a/facade_config_directives_test.go +++ b/facade_config_directives_test.go @@ -1,6 +1,8 @@ package configkit_test import ( + "errors" + "os" "strings" "testing" "testing/fstest" @@ -8,6 +10,72 @@ import ( configkit "go.maximumdirect.net/configkit" ) +func TestMainBootstrapControlsAreConsumedWithoutEnvironmentWrites(t *testing.T) { + t.Setenv("CONFIGKIT_CONTROL_SENTINEL", "unchanged") + type nested struct { + Config struct { + Directory string `yaml:"secrets_dir"` + } `yaml:"config"` + } + type app struct { + Service nested `yaml:"service"` + } + for _, imports := range []bool{false, true} { + body := "config: {secrets_dir: missing, secrets_overwrite: true}\nservice: {config: {secrets_dir: ordinary}}\n" + fs := configkit.NewFilesystem("bundle", fstest.MapFS{"main.yml": {Data: []byte(body)}}) + result, err := configkit.Load[app](fs.File("main.yml"), configkit.Options[app]{Imports: imports}) + if err != nil || result.Config.Service.Config.Directory != "ordinary" || os.Getenv("CONFIGKIT_CONTROL_SENTINEL") != "unchanged" { + t.Fatalf("imports %v: result = %#v, error = %v", imports, result, err) + } + } +} + +func TestBootstrapControlsRejectMisplacedAndMalformedValues(t *testing.T) { + for _, test := range []struct { + name, body string + code configkit.Code + path string + }{ + {"directory", "config: {secrets_dir: null}\n", configkit.CodeSecretsInvalidPath, "/config/secrets_dir"}, + {"overwrite", "config: {secrets_overwrite: 'false'}\n", configkit.CodeSecretsInvalidValue, "/config/secrets_overwrite"}, + } { + t.Run(test.name, func(t *testing.T) { + _, err := configkit.Load[struct{}](configkit.Bytes("main", []byte(test.body))) + var loadErr *configkit.LoadError + if !errors.As(err, &loadErr) || len(loadErr.Diagnostics()) != 1 || loadErr.Diagnostics()[0].Code != test.code || loadErr.Diagnostics()[0].Path.String() != test.path || loadErr.Diagnostics()[0].Primary == nil { + t.Fatalf("error = %#v", err) + } + }) + } + fs := configkit.NewFilesystem("bundle", fstest.MapFS{ + "main.yml": {Data: []byte("config: {imports: [{path: other.yml}]}\n")}, + "other.yml": {Data: []byte("config: {secrets_overwrite: false}\n")}, + }) + _, err := configkit.Load[struct{}](fs.File("main.yml"), configkit.Options[struct{}]{Imports: true}) + var loadErr *configkit.LoadError + if !errors.As(err, &loadErr) || len(loadErr.Diagnostics()) != 1 || loadErr.Diagnostics()[0].Code != configkit.CodeImportInvalid || loadErr.Diagnostics()[0].Path.String() != "/config/secrets_overwrite" { + t.Fatalf("import error = %#v", err) + } + _, err = configkit.LoadLayered(configkit.Input{Source: configkit.Bytes("main", []byte("{}\n"))}, configkit.LayeredOptions[struct{}]{ + Underlays: []configkit.Underlay{{Inputs: []configkit.Input{{Source: configkit.Bytes("underlay", []byte("config: {secrets_dir: secrets}\n"))}}}}, + }) + if !errors.As(err, &loadErr) || len(loadErr.Diagnostics()) != 1 || loadErr.Diagnostics()[0].Code != configkit.CodeImportInvalid { + t.Fatalf("underlay error = %#v", err) + } + overlays := configkit.NewFilesystem("overlays", fstest.MapFS{ + "main.yml": {Data: []byte("{}\n")}, + "overlays/dev.yml": {Data: []byte("config: {secrets_overwrite: false}\n")}, + }) + _, err = configkit.Load[struct{}](overlays.File("main.yml"), configkit.Options[struct{}]{Overlay: "dev"}) + if !errors.As(err, &loadErr) || len(loadErr.Diagnostics()) != 1 || loadErr.Diagnostics()[0].Code != configkit.CodeOverlayDirective || loadErr.Diagnostics()[0].Primary == nil { + t.Fatalf("overlay error = %#v", err) + } + _, err = configkit.Load[struct{}](configkit.Bytes("main", []byte("config: {imports: [], secrets_overwrite: false}\n"))) + if !errors.As(err, &loadErr) || len(loadErr.Diagnostics()) != 1 || loadErr.Diagnostics()[0].Code != configkit.CodeImportDisabled { + t.Fatalf("disabled imports error = %#v", err) + } +} + func TestDocumentRootControlsAndNestedApplicationConfig(t *testing.T) { type settings struct { Imports string `yaml:"imports"` diff --git a/internal/engine/contextless_imports.go b/internal/engine/contextless_imports.go index ce28609..3c3e2cc 100644 --- a/internal/engine/contextless_imports.go +++ b/internal/engine/contextless_imports.go @@ -12,7 +12,7 @@ func acquireContextlessInput(input assembledInput, request inputAcquisitionReque body, declarations = processing.payload, processing.imports sequences = cloneSequenceDeclarations(processing.sequences) } else { - body, declarations, diagnostics = splitImportDirectives(parsed.document) + body, declarations, diagnostics = splitImportDirectives(parsed.document, request.role) } destination := request.input.destination localDestination := destination diff --git a/internal/engine/destination_import_test.go b/internal/engine/destination_import_test.go index 5182dca..207539c 100644 --- a/internal/engine/destination_import_test.go +++ b/internal/engine/destination_import_test.go @@ -129,7 +129,7 @@ parent: true betaPath := writeImportFile(t, directory, "fragments/b.yml", "beta: true\n") main := parseImportMain(t, mainPath) - _, declarations, diagnostics := splitImportDirectives(main.document) + _, declarations, diagnostics := splitImportDirectives(main.document, sourceVersionMain) if len(diagnostics) != 0 { t.Fatalf("main directive diagnostics = %#v", diagnostics) } diff --git a/internal/engine/directive_scope_test.go b/internal/engine/directive_scope_test.go index b474f13..4d53996 100644 --- a/internal/engine/directive_scope_test.go +++ b/internal/engine/directive_scope_test.go @@ -18,7 +18,7 @@ records: configkit: {imports: [{path: absent.yaml}]} _configkit: ordinary `) - extracted, diagnostics := extractRootDirectives(root, rootDirectiveContextSource) + extracted, diagnostics := extractRootDirectives(root, rootDirectiveContextSource, sourceVersionContribution) if len(diagnostics) != 0 || len(extracted.imports) != 1 { t.Fatalf("extraction = %#v, diagnostics = %#v", extracted, diagnostics) } @@ -59,7 +59,7 @@ func TestDocumentRootControlValidation(t *testing.T) { {"bad imports", "config: {imports: wrong}\n", CodeImportInvalid, "/config/imports"}, } { t.Run(test.name, func(t *testing.T) { - _, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, test.input), rootDirectiveContextSource) + _, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, test.input), rootDirectiveContextSource, sourceVersionContribution) if len(diagnostics) == 0 || diagnostics[0].Code != test.code || diagnostics[0].Path.String() != test.path { t.Fatalf("diagnostics = %#v", diagnostics) } @@ -87,7 +87,88 @@ func TestDocumentRootControlGuards(t *testing.T) { if got := overlayDirectiveDiagnostics(sequences, Path{}, true); len(got) != 0 { t.Fatalf("overlay sequences diagnostics = %#v", got) } - if _, got := extractRootDirectives(sequences, rootDirectiveContextImportsOnly); len(got) == 0 || got[0].Code != CodeSequenceInvalid { + if _, got := extractRootDirectives(sequences, rootDirectiveContextImportsOnly, sourceVersionContribution); len(got) == 0 || got[0].Code != CodeSequenceInvalid { t.Fatalf("imports-only extraction diagnostics = %#v", got) } } + +func TestBootstrapControlExtraction(t *testing.T) { + root := parseRootDirectiveDocument(t, "config:\n imports: invalid\n secrets_dir: ../secrets\n secrets_overwrite: false\n") + settings, diagnostics := extractBootstrapSettings(root) + if len(diagnostics) != 0 || !settings.directoryDeclared || settings.directory != "../secrets" || !settings.overwriteDeclared || settings.overwrite || settings.directoryLocation.Line != 3 || settings.overwriteLocation.Line != 4 { + t.Fatalf("settings = %#v, diagnostics = %#v", settings, diagnostics) + } + if _, diagnostics := extractRootDirectives(root, rootDirectiveContextSource, sourceVersionMain); len(diagnostics) == 0 { + t.Fatal("normal extraction did not validate unrelated import grammar") + } + for _, test := range []struct { + input string + code Code + path string + }{ + {"config: {secrets_dir: ''}", CodeSecretsInvalidPath, "/config/secrets_dir"}, + {"config: {secrets_dir: /absolute}", CodeSecretsInvalidPath, "/config/secrets_dir"}, + {"config: {secrets_dir: null}", CodeSecretsInvalidPath, "/config/secrets_dir"}, + {"config: {secrets_dir: 123}", CodeSecretsInvalidPath, "/config/secrets_dir"}, + {"config: {secrets_overwrite: null}", CodeSecretsInvalidValue, "/config/secrets_overwrite"}, + {"config: {secrets_overwrite: 'true'}", CodeSecretsInvalidValue, "/config/secrets_overwrite"}, + {"config: invalid", CodeImportInvalid, "/config"}, + } { + t.Run(test.input, func(t *testing.T) { + root := parseRootDirectiveDocument(t, test.input+"\n") + _, preparation := extractBootstrapSettings(root) + _, normal := extractRootDirectives(root, rootDirectiveContextSource, sourceVersionMain) + for _, got := range [][]Diagnostic{preparation, normal} { + if len(got) != 1 || got[0].Code != test.code || got[0].Path.String() != test.path || got[0].Primary == nil || got[0].Primary.Line != 1 { + t.Fatalf("diagnostics = %#v", got) + } + } + }) + } +} + +func TestBootstrapControlsRequireMainSource(t *testing.T) { + root := parseRootDirectiveDocument(t, "config: {secrets_dir: secrets, secrets_overwrite: true}\nvalue: ordinary\n") + for _, context := range []rootDirectiveContext{rootDirectiveContextSource, rootDirectiveContextLayered} { + main, diagnostics := extractRootDirectives(root, context, sourceVersionMain) + if len(diagnostics) != 0 || len(main.body.Mapping) != 1 || main.body.Mapping[0].Key != "value" { + t.Fatalf("main extraction = %#v, diagnostics = %#v", main, diagnostics) + } + _, diagnostics = extractRootDirectives(root, context, sourceVersionContribution) + if len(diagnostics) != 2 || diagnostics[0].Code != CodeImportInvalid || diagnostics[1].Code != CodeImportInvalid { + t.Fatalf("contribution diagnostics = %#v", diagnostics) + } + } + _, diagnostics := extractRootDirectives(root, rootDirectiveContextOverlay, sourceVersionContribution) + if len(diagnostics) != 2 || diagnostics[0].Code != CodeOverlayDirective || diagnostics[1].Code != CodeOverlayDirective { + t.Fatalf("overlay diagnostics = %#v", diagnostics) + } + for _, name := range []string{"secrets_dir", "secrets_overwrite"} { + if !sourceVersionControlOverlap(root, Keys("config", name)) { + t.Errorf("version overlap not detected for %s", name) + } + } +} + +func TestBootstrapControlsKeepSourceVersionChecksInLoad(t *testing.T) { + root := parseRootDirectiveDocument(t, "config: {secrets_dir: secrets, secrets_overwrite: false}\nversion: 1\n") + called := false + rule := &VersionRule{Path: Keys("version"), Check: func(Version, *Validation) error { + called = true + return nil + }} + if _, diagnostics := extractBootstrapSettings(root); len(diagnostics) != 0 || called { + t.Fatalf("preparation diagnostics = %#v, checker called = %v", diagnostics, called) + } + result := processSourceVersionWithDirectiveContext(root, rule, sourceVersionMain, Path{}, sourceVersionModeRequired, rootDirectiveContextSource) + if len(result.diagnostics) != 0 || !called { + t.Fatalf("load diagnostics = %#v, checker called = %v", result.diagnostics, called) + } + for _, name := range []string{"secrets_dir", "secrets_overwrite"} { + rule.Path = Keys("config", name) + result = processSourceVersionWithDirectiveContext(root, rule, sourceVersionMain, Path{}, sourceVersionModeRequired, rootDirectiveContextSource) + if len(result.diagnostics) != 1 || result.diagnostics[0].Code != CodeVersionError { + t.Errorf("overlap %s diagnostics = %#v", name, result.diagnostics) + } + } +} diff --git a/internal/engine/directives.go b/internal/engine/directives.go index cdb0a30..e718abc 100644 --- a/internal/engine/directives.go +++ b/internal/engine/directives.go @@ -2,6 +2,7 @@ package engine import ( "path" + "path/filepath" "strings" "go.maximumdirect.net/configkit/internal/document" @@ -24,15 +25,71 @@ type rootDirectiveExtraction struct { sequences []sequenceDeclarationSpec } -func splitImportDirectives(root *document.Node) (*document.Node, []importDeclarationSpec, []Diagnostic) { - extracted, diagnostics := extractRootDirectives(root, rootDirectiveContextImportsOnly) +// bootstrapSettings retains only source-local control facts, never credentials. +type bootstrapSettings struct { + directoryDeclared bool + directory string + directoryLocation document.Location + overwriteDeclared bool + overwrite bool + overwriteLocation document.Location +} + +// extractBootstrapSettings validates only the controls needed for preparation; +// normal loading remains responsible for the rest of the directive grammar. +func extractBootstrapSettings(root *document.Node) (bootstrapSettings, []Diagnostic) { + var settings bootstrapSettings + if root == nil || root.Kind != document.Mapping { + return settings, nil + } + for _, entry := range root.Mapping { + if entry.Key != directiveKey { + continue + } + if entry.Value == nil || entry.Value.Kind != document.Mapping { + return settings, []Diagnostic{nodeImportDiagnostic(CodeImportInvalid, Keys(directiveKey), "configuration directive must be a mapping", entry.Value)} + } + var diagnostics []Diagnostic + for _, field := range entry.Value.Mapping { + if field.Key == "secrets_dir" || field.Key == "secrets_overwrite" { + if diagnostic := parseBootstrapField(&settings, field); diagnostic != nil { + diagnostics = append(diagnostics, *diagnostic) + } + } + } + return settings, canonicalDiagnostics(diagnostics) + } + return settings, nil +} + +func parseBootstrapField(settings *bootstrapSettings, entry document.Entry) *Diagnostic { + value := entry.Value + fieldPath := Keys(directiveKey, entry.Key) + if entry.Key == "secrets_dir" { + if value == nil || value.Kind != document.String || value.Text == "" || filepath.IsAbs(value.Text) || filepath.VolumeName(value.Text) != "" { + diagnostic := nodeImportDiagnostic(CodeSecretsInvalidPath, fieldPath, "secrets directory must be a nonempty relative host path", value) + return &diagnostic + } + settings.directoryDeclared, settings.directory, settings.directoryLocation = true, value.Text, value.Location + return nil + } + if value == nil || value.Kind != document.Boolean { + diagnostic := nodeImportDiagnostic(CodeSecretsInvalidValue, fieldPath, "secrets overwrite setting must be a Boolean", value) + return &diagnostic + } + settings.overwriteDeclared, settings.overwrite, settings.overwriteLocation = true, value.Text == "true", value.Location + return nil +} + +func splitImportDirectives(root *document.Node, role sourceVersionRole) (*document.Node, []importDeclarationSpec, []Diagnostic) { + extracted, diagnostics := extractRootDirectives(root, rootDirectiveContextImportsOnly, role) if len(diagnostics) != 0 { return nil, nil, diagnostics } return extracted.body, extracted.imports, nil } -func extractRootDirectives(root *document.Node, context rootDirectiveContext) (rootDirectiveExtraction, []Diagnostic) { +func extractRootDirectives(root *document.Node, context rootDirectiveContext, role sourceVersionRole) (rootDirectiveExtraction, []Diagnostic) { if root == nil { return rootDirectiveExtraction{}, nil } @@ -43,7 +100,7 @@ func extractRootDirectives(root *document.Node, context rootDirectiveContext) (r continue } directiveIndex = index - extracted, diagnostics := parseRootDirectiveBlock(entry.Value, Keys(directiveKey), context) + extracted, diagnostics := parseRootDirectiveBlock(entry.Value, Keys(directiveKey), context, role) if len(diagnostics) != 0 { return rootDirectiveExtraction{}, diagnostics } @@ -56,7 +113,7 @@ func extractRootDirectives(root *document.Node, context rootDirectiveContext) (r return rootDirectiveExtraction{body: body}, nil } -func parseRootDirectiveBlock(node *document.Node, directivePath Path, context rootDirectiveContext) (rootDirectiveExtraction, []Diagnostic) { +func parseRootDirectiveBlock(node *document.Node, directivePath Path, context rootDirectiveContext, role sourceVersionRole) (rootDirectiveExtraction, []Diagnostic) { if node == nil || node.Kind != document.Mapping { return rootDirectiveExtraction{}, []Diagnostic{nodeImportDiagnostic(CodeImportInvalid, directivePath, "configuration directive must be a mapping", node)} } @@ -89,6 +146,19 @@ func parseRootDirectiveBlock(node *document.Node, directivePath Path, context ro parsed, issues := parseSequenceDeclarationDirective(entry.Value, fieldPath) extracted.sequences = append(extracted.sequences, parsed...) diagnostics = append(diagnostics, issues...) + case "secrets_dir", "secrets_overwrite": + if role != sourceVersionMain || context == rootDirectiveContextOverlay { + code := CodeImportInvalid + if context == rootDirectiveContextOverlay { + code = CodeOverlayDirective + } + diagnostics = append(diagnostics, nodeImportDiagnostic(code, fieldPath, "secrets bootstrap controls are only permitted in the main document", entry.Value)) + continue + } + var settings bootstrapSettings + if diagnostic := parseBootstrapField(&settings, entry); diagnostic != nil { + diagnostics = append(diagnostics, *diagnostic) + } default: diagnostics = append(diagnostics, nodeImportDiagnostic(CodeImportInvalid, fieldPath, "configuration directive field is not recognized", entry.Value)) } diff --git a/internal/engine/import_acquisition.go b/internal/engine/import_acquisition.go index 8bc0872..4dc63b8 100644 --- a/internal/engine/import_acquisition.go +++ b/internal/engine/import_acquisition.go @@ -156,7 +156,7 @@ func acquireImportedWithAccess(request importAcquisitionRequest, policy *acquisi declarations = processing.imports sequenceDeclarations = cloneSequenceDeclarations(processing.sequences) } else { - body, declarations, diagnostics = splitImportDirectives(main.document) + body, declarations, diagnostics = splitImportDirectives(main.document, request.input.role) } root := acquiredContribution{ source: cloneSourceInfo(mainInfo), payload: body, identity: mainNodeKey, diff --git a/internal/engine/import_spec_test.go b/internal/engine/import_spec_test.go index 519da27..ea883fa 100644 --- a/internal/engine/import_spec_test.go +++ b/internal/engine/import_spec_test.go @@ -232,7 +232,7 @@ func parseImportSpecsYAML(t *testing.T, declarations string) ([]importDeclaratio if len(diagnostics) != 0 { return nil, diagnostics } - extracted, diagnostics := extractRootDirectives(parsed.document, rootDirectiveContextSource) + extracted, diagnostics := extractRootDirectives(parsed.document, rootDirectiveContextSource, sourceVersionContribution) if len(diagnostics) != 0 { return nil, diagnostics } diff --git a/internal/engine/imports_test.go b/internal/engine/imports_test.go index 3cf2872..ae72d17 100644 --- a/internal/engine/imports_test.go +++ b/internal/engine/imports_test.go @@ -1558,6 +1558,6 @@ func parseImportSpecificationYAML(input string) ([]importDeclarationSpec, []Diag if len(diagnostics) != 0 { return nil, diagnostics } - _, declarations, diagnostics := splitImportDirectives(parsed.document) + _, declarations, diagnostics := splitImportDirectives(parsed.document, sourceVersionMain) return declarations, diagnostics } diff --git a/internal/engine/sequence_declaration_test.go b/internal/engine/sequence_declaration_test.go index 5144f33..41b579b 100644 --- a/internal/engine/sequence_declaration_test.go +++ b/internal/engine/sequence_declaration_test.go @@ -81,14 +81,14 @@ func TestExtractRootDirectivesAllowsSequencesButRejectsOverlayImports(t *testing _, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, `config: imports: [{path: fragments/base.yaml}] sequences: [{destination: [prompts], key: id}] -`), rootDirectiveContextOverlay) +`), rootDirectiveContextOverlay, sourceVersionContribution) if len(diagnostics) != 1 || diagnostics[0].Code != CodeOverlayDirective || diagnostics[0].Path.String() != "/config/imports" { t.Fatalf("overlay diagnostics = %#v, want imports-only rejection", diagnostics) } extracted, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, `config: sequences: [{destination: [prompts], key: id}] -`), rootDirectiveContextOverlay) +`), rootDirectiveContextOverlay, sourceVersionContribution) if len(diagnostics) != 0 || len(extracted.sequences) != 1 { t.Fatalf("overlay sequence extraction = %#v, %#v", extracted, diagnostics) } @@ -114,7 +114,7 @@ func TestParseSequenceDeclarationRejectsMalformedForms(t *testing.T) { } for _, test := range tests { t.Run(test.name, func(t *testing.T) { - _, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, test.body), rootDirectiveContextSource) + _, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, test.body), rootDirectiveContextSource, sourceVersionContribution) if len(diagnostics) == 0 || diagnostics[0].Code != CodeSequenceInvalid || diagnostics[0].Path.String() != test.path { t.Fatalf("diagnostics = %#v, want %s at %s", diagnostics, CodeSequenceInvalid, test.path) } @@ -155,7 +155,7 @@ version: v1 func extractSequenceDeclarationsYAML(t *testing.T, input string, context rootDirectiveContext) rootDirectiveExtraction { t.Helper() - extracted, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, input), context) + extracted, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, input), context, sourceVersionContribution) if len(diagnostics) != 0 { t.Fatalf("root directive diagnostics = %#v", diagnostics) } diff --git a/internal/engine/source_version.go b/internal/engine/source_version.go index e4692a1..7d0feb6 100644 --- a/internal/engine/source_version.go +++ b/internal/engine/source_version.go @@ -220,7 +220,7 @@ func processSourceVersionWithDirectiveContext(root *document.Node, rule *Version return sourceVersionProcessingResult{} } - extracted, diagnostics := extractRootDirectives(root, directiveContext) + extracted, diagnostics := extractRootDirectives(root, directiveContext, role) if len(diagnostics) != 0 { return sourceVersionProcessingResult{diagnostics: diagnostics} }