Implement raw module output contracts

internal/modules/merge/appendorder/merger.go

@@ -5,8 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"gitea.maximumdirect.net/eric/notarius/internal/core/artifacts"
-	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
 )
@@ -36,11 +34,34 @@ func (m *Merger) Merge(ctx context.Context, req contracts.MergeRequest) (contrac
 		return contracts.MergeResult{}, mergerErrorf("context error before merge: %w", err)
 	}
 
-	var candidates []artifacts.ArtifactCandidate
-	for _, chunkArtifacts := range req.ChunkArtifacts {
-		candidates = append(candidates, cloneCandidates(chunkArtifacts.Candidates)...)
+	if len(req.ExtractOutputs) == 1 {
+		payload := cloneRawPayload(req.ExtractOutputs[0].Payload)
+		return contracts.MergeResult{
+			Output: contracts.MergeOutput{
+				LaneID:    req.LaneID,
+				MergerKey: Key,
+				SourceID:  req.ExtractOutputs[0].SourceID,
+				Schema:    req.ExtractOutputs[0].Schema,
+				Payload:   payload,
+			},
+		}, nil
 	}
-	return contracts.MergeResult{Candidates: candidates}, nil
+
+	content, err := orderedContent(req.ExtractOutputs)
+	if err != nil {
+		return contracts.MergeResult{}, err
+	}
+	return contracts.MergeResult{
+		Output: contracts.MergeOutput{
+			LaneID:    req.LaneID,
+			MergerKey: Key,
+			SourceID:  sourceID(req.ExtractOutputs),
+			Payload: contracts.RawPayload{
+				Content:   content,
+				MediaType: "application/json",
+			},
+		},
+	}, nil
 }
 
 func ModuleSpec() pipeline.ModuleSpec {
@@ -57,27 +78,45 @@ func Register(registry *pipeline.MergerRegistry) error {
 	})
 }
 
-func cloneCandidates(candidates []artifacts.ArtifactCandidate) []artifacts.ArtifactCandidate {
-	if len(candidates) == 0 {
-		return nil
+func orderedContent(outputs []contracts.ExtractOutput) ([]byte, error) {
+	items := make([]map[string]any, 0, len(outputs))
+	for _, output := range outputs {
+		item := map[string]any{
+			"chunk_id":    output.ChunkID,
+			"chunk_index": output.ChunkIndex,
+			"media_type":  output.Payload.MediaType,
+		}
+		if json.Valid(output.Payload.Content) {
+			item["content"] = json.RawMessage(append([]byte(nil), output.Payload.Content...))
+		} else {
+			item["content"] = string(output.Payload.Content)
+		}
+		items = append(items, item)
 	}
-
-	out := make([]artifacts.ArtifactCandidate, 0, len(candidates))
-	for _, candidate := range candidates {
-		out = append(out, cloneCandidate(candidate))
+	content, err := json.Marshal(struct {
+		Outputs []map[string]any `json:"outputs"`
+	}{Outputs: items})
+	if err != nil {
+		return nil, mergerErrorf("encode merged output: %w", err)
 	}
-	return out
+	return content, nil
 }
 
-func cloneCandidate(candidate artifacts.ArtifactCandidate) artifacts.ArtifactCandidate {
-	return artifacts.ArtifactCandidate{
-		Index:         candidate.Index,
-		ExtractorKey:  candidate.ExtractorKey,
-		ArtifactType:  candidate.ArtifactType,
-		SchemaVersion: candidate.SchemaVersion,
-		Payload:       append(json.RawMessage(nil), candidate.Payload...),
-		SourceRefs:    append([]source.SourceRef(nil), candidate.SourceRefs...),
-		Metadata:      cloneMetadata(candidate.Metadata),
+func sourceID(outputs []contracts.ExtractOutput) string {
+	for _, output := range outputs {
+		if output.SourceID != "" {
+			return output.SourceID
+		}
+	}
+	return ""
+}
+
+func cloneRawPayload(payload contracts.RawPayload) contracts.RawPayload {
+	return contracts.RawPayload{
+		Content:   append([]byte(nil), payload.Content...),
+		MediaType: payload.MediaType,
+		Metadata:  cloneMetadata(payload.Metadata),
+		Warnings:  append([]contracts.Warning(nil), payload.Warnings...),
 	}
 }