Bring F3 up to its release branch, with both sides' store tests (part 12 of 14)

Carries every field of a config declaration on the declared-config mirror (ADR 0356 section 4), read from config or its alias settings.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/inventory/mirrors.go

@@ -26,26 +26,42 @@ type AssignmentMirrored struct {
 }
 
 // DeclaredConfigMirrored is one registered module's config declarations as the declared-config mirror holds
-// them: the module, and each key its manifest's `settings` declares with that declaration's listed fields.
-// An empty object when the module declares none: registered, declaring nothing.
+// them: the module, and each key its manifest declares — under `config`, or under its old name `settings` for a
+// module not yet moved (ADR 0348 §1) — with that declaration's listed fields. An empty object when the module
+// declares none: registered, declaring nothing.
 type DeclaredConfigMirrored struct {
 	Module   string                      `json:"module"`
 	Settings map[string]DeclaredMirrored `json:"settings"`
 }
 
 // DeclaredMirrored is one key's declaration as the mirror holds it: **its listed fields and no other**
-// (ADR 0289 §12). Today a declaration is kind, default and why (catalogue.SettingDeclaration); a field the
-// manifest gains reaches the bus only once it is added here, deliberately, and a test fails until it is
-// listed or refused (ADR 0348 clause 4's fields arrive with package K1). A default is never a secret: the
-// catalogue refuses a default for a key whose name says secret.
+// (ADR 0289 §12), and every field a declaration has (catalogue.SettingDeclaration), under the same names. The
+// mirror holds what the module's manifest declares about its config values, and mesh-config validates and
+// resolves from it (ADR 0356 §4, ADR 0348 §4, §9), so it carries the whole declaration: kind, default and why
+// of the settings form, and type, description, validation, trusted, predefined, required and runtime of the
+// config form. None is a secret: a secret lives in the vault, never in config, and the catalogue refuses a
+// default for a key whose name says secret. A field the manifest gains reaches the bus only once it is added
+// here, deliberately: a test fails until it is listed. The config form's fields are left out when unset, so a
+// module not yet moved is mirrored as it was before they were carried.
 type DeclaredMirrored struct {
-	Kind    string          `json:"kind"`
-	Default json.RawMessage `json:"default"`
-	Why     string          `json:"why"`
+	Kind        string          `json:"kind"`
+	Default     json.RawMessage `json:"default"`
+	Why         string          `json:"why"`
+	Type        string          `json:"type,omitempty"`
+	Description string          `json:"description,omitempty"`
+	Enum        json.RawMessage `json:"enum,omitempty"`
+	Minimum     *float64        `json:"minimum,omitempty"`
+	Maximum     *float64        `json:"maximum,omitempty"`
+	Pattern     string          `json:"pattern,omitempty"`
+	Trusted     bool            `json:"trusted,omitempty"`
+	Predefined  string          `json:"predefined,omitempty"`
+	Required    bool            `json:"required,omitempty"`
+	Runtime     bool            `json:"runtime,omitempty"`
 }
 
 // DeclaredMirroredFields are the fields of a declaration the mirror carries, by their manifest names.
-var DeclaredMirroredFields = []string{"kind", "default", "why"}
+var DeclaredMirroredFields = []string{"kind", "default", "why", "type", "description", "enum", "minimum", "maximum",
+	"pattern", "trusted", "predefined", "required", "runtime"}
 
 // AssignmentsMirror is every assignment's mirrored value, keyed `<node>.<module>`.
 func (i *Inventory) AssignmentsMirror(ctx context.Context) (map[string][]byte, error) {
@@ -74,7 +90,7 @@ func (i *Inventory) AssignmentsMirror(ctx context.Context) (map[string][]byte, e
 // DeclaredConfigMirror is every registered module's mirrored config declarations, keyed by the module.
 func (i *Inventory) DeclaredConfigMirror(ctx context.Context) (map[string][]byte, error) {
 	rows, err := i.store.Pool().Query(ctx,
-		`select name, coalesce(manifest->'settings', '{}'::jsonb) from module`)
+		`select name, coalesce(manifest->'config', manifest->'settings', '{}'::jsonb) from module`)
 	if err != nil {
 		return nil, err
 	}
@@ -88,19 +104,9 @@ func (i *Inventory) DeclaredConfigMirror(ctx context.Context) (map[string][]byte
 		if err := rows.Scan(&d.Module, &raw); err != nil {
 			return nil, err
 		}
-		var declared map[string]DeclaredMirrored
-		if err := json.Unmarshal(raw, &declared); err != nil {
+		if d.Settings, err = declaredMirrored(raw); err != nil {
 			return nil, fmt.Errorf("the declarations of %s cannot be read: %w", d.Module, err)
 		}
-		d.Settings = map[string]DeclaredMirrored{}
-		for key, decl := range declared {
-			if len(decl.Default) > 0 {
-				if decl.Default, err = canonical(decl.Default); err != nil {
-					return nil, err
-				}
-			}
-			d.Settings[key] = decl
-		}
 		value, err := json.Marshal(d)
 		if err != nil {
 			return nil, err
@@ -110,6 +116,31 @@ func (i *Inventory) DeclaredConfigMirror(ctx context.Context) (map[string][]byte
 	return out, rows.Err()
 }
 
+// declaredMirrored is a manifest's config declarations, keyed by the value, as the mirror holds them: each
+// with its listed fields, a default and an enum encoded the one way.
+func declaredMirrored(raw []byte) (map[string]DeclaredMirrored, error) {
+	var declared map[string]DeclaredMirrored
+	if err := json.Unmarshal(raw, &declared); err != nil {
+		return nil, err
+	}
+	out := map[string]DeclaredMirrored{}
+	for key, decl := range declared {
+		var err error
+		if len(decl.Default) > 0 {
+			if decl.Default, err = canonical(decl.Default); err != nil {
+				return nil, err
+			}
+		}
+		if len(decl.Enum) > 0 {
+			if decl.Enum, err = canonical(decl.Enum); err != nil {
+				return nil, err
+			}
+		}
+		out[key] = decl
+	}
+	return out, nil
+}
+
 // canonical is a JSON document encoded the one way: objects' keys sorted, numbers as written.
 func canonical(raw []byte) ([]byte, error) {
 	dec := json.NewDecoder(bytes.NewReader(raw))