Adopt ConfigKit for pipeline loading

internal/config/effective_projection.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"sort"
+	"strings"
 )
 
 // effectivePipelineProjection is the single safe, schema-specific view used
@@ -37,6 +38,11 @@ type effectiveScriptoriumConfig struct {
 	Artifacts   map[string]ScriptoriumArtifactConfig `yaml:"artifacts" json:"artifacts"`
 }
 
+type projectedPipelineValue struct {
+	record   EffectivePipelineValueRecord
+	segments []string
+}
+
 func projectEffectivePipeline(cfg *PipelineConfig, logicalNotarius bool) effectivePipelineProjection {
 	projection := effectivePipelineProjection{
 		Workspace: cfg.Workspace, Campaigns: cfg.Campaigns, Storage: cfg.Storage,
@@ -70,23 +76,35 @@ func projectionJSON(projection effectivePipelineProjection) ([]byte, error) {
 }
 
 func projectionValueRecords(projection effectivePipelineProjection) ([]EffectivePipelineValueRecord, error) {
-	data, err := projectionJSON(projection)
+	detailed, err := projectionDetailedRecords(projection)
 	if err != nil {
 		return nil, err
 	}
+	records := make([]EffectivePipelineValueRecord, 0, len(detailed))
+	for _, value := range detailed {
+		records = append(records, value.record)
+	}
+	return records, nil
+}
+
+func projectionDetailedRecords(value any) ([]projectedPipelineValue, error) {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return nil, fmt.Errorf("encode typed pipeline projection: %w", err)
+	}
 	decoder := json.NewDecoder(bytes.NewReader(data))
 	decoder.UseNumber()
 	var root map[string]any
 	if err := decoder.Decode(&root); err != nil {
 		return nil, fmt.Errorf("decode effective pipeline projection: %w", err)
 	}
-	var records []EffectivePipelineValueRecord
-	appendProjectionRecords(&records, "", root)
-	sort.Slice(records, func(i, j int) bool { return records[i].Path < records[j].Path })
+	var records []projectedPipelineValue
+	appendProjectionRecords(&records, nil, root)
+	sort.Slice(records, func(i, j int) bool { return records[i].record.Path < records[j].record.Path })
 	return records, nil
 }
 
-func appendProjectionRecords(records *[]EffectivePipelineValueRecord, path string, value any) {
+func appendProjectionRecords(records *[]projectedPipelineValue, segments []string, value any) {
 	if mapping, ok := value.(map[string]any); ok && len(mapping) > 0 {
 		keys := make([]string, 0, len(mapping))
 		for key := range mapping {
@@ -94,14 +112,15 @@ func appendProjectionRecords(records *[]EffectivePipelineValueRecord, path strin
 		}
 		sort.Strings(keys)
 		for _, key := range keys {
-			childPath := key
-			if path != "" {
-				childPath = path + "." + key
-			}
-			appendProjectionRecords(records, childPath, mapping[key])
+			child := append(append([]string(nil), segments...), key)
+			appendProjectionRecords(records, child, mapping[key])
 		}
 		return
 	}
 	encoded, _ := json.Marshal(value)
-	*records = append(*records, EffectivePipelineValueRecord{Path: path, Value: string(encoded)})
+	path := strings.Join(segments, ".")
+	*records = append(*records, projectedPipelineValue{
+		record:   EffectivePipelineValueRecord{Path: path, Value: string(encoded)},
+		segments: append([]string(nil), segments...),
+	})
 }