Implement raw module output contracts

internal/framework/contracts/composition_test.go

@@ -27,7 +27,6 @@ func TestContractsComposeAcrossPackages(t *testing.T) {
 	extractor := compositionExtractor{}
 	merger := compositionMerger{}
 	normalizer := compositionNormalizer{}
-	validator := compositionValidator{}
 	encoder := compositionOutputEncoder{}
 
 	doc, err := adapter.Parse(ctx, contracts.ParseRequest{SourceID: "source-1"})
@@ -58,70 +57,37 @@ func TestContractsComposeAcrossPackages(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Extract() error = %v, want nil", err)
 	}
-	if len(extraction.Candidates) != 1 {
-		t.Fatalf("len(Candidates) = %d, want 1", len(extraction.Candidates))
-	}
-
-	candidate := extraction.Candidates[0]
-	for _, ref := range candidate.SourceRefs {
-		if err := source.ValidateRef(doc, ref); err != nil {
-			t.Fatalf("ValidateRef() error = %v, want nil", err)
-		}
+	if extraction.Output.Payload.MediaType != "application/json" {
+		t.Fatalf("extract media type = %q, want application/json", extraction.Output.Payload.MediaType)
 	}
 
 	merge, err := merger.Merge(ctx, contracts.MergeRequest{
-		Source: doc,
-		LaneID: candidate.ArtifactType,
-		ChunkArtifacts: []contracts.ChunkArtifacts{
-			{
-				Chunk:      chunking.Chunks[0],
-				Candidates: extraction.Candidates,
-			},
-		},
+		Source:         doc,
+		LaneID:         "generic-lane",
+		ExtractOutputs: []contracts.ExtractOutput{extraction.Output},
 	})
 	if err != nil {
 		t.Fatalf("Merge() error = %v, want nil", err)
 	}
-	if len(merge.Candidates) != 1 {
-		t.Fatalf("len(merge.Candidates) = %d, want 1", len(merge.Candidates))
+	if string(merge.Output.Payload.Content) != `{"value":"example"}` {
+		t.Fatalf("merge output = %s, want extract payload", merge.Output.Payload.Content)
 	}
 
 	normalize, err := normalizer.Normalize(ctx, contracts.NormalizeRequest{
-		Source:     doc,
-		LaneID:     candidate.ArtifactType,
-		Candidates: merge.Candidates,
+		Source:      doc,
+		LaneID:      "generic-lane",
+		MergeOutput: merge.Output,
 	})
 	if err != nil {
 		t.Fatalf("Normalize() error = %v, want nil", err)
 	}
-	if len(normalize.Candidates) != 1 {
-		t.Fatalf("len(normalize.Candidates) = %d, want 1", len(normalize.Candidates))
-	}
-
-	validation, err := validator.Validate(ctx, contracts.ValidationRequest{
-		Source:     doc,
-		Candidates: normalize.Candidates,
-	})
-	if err != nil {
-		t.Fatalf("Validate() error = %v, want nil", err)
-	}
-	if len(validation.Decisions) != 1 {
-		t.Fatalf("len(Decisions) = %d, want 1", len(validation.Decisions))
-	}
-
-	decision := validation.Decisions[0]
-	if !decision.Approved {
-		t.Fatal("Approved = false, want true")
-	}
-	if decision.CandidateIndex != candidate.Index {
-		t.Fatalf("CandidateIndex = %d, want %d", decision.CandidateIndex, candidate.Index)
+	if string(normalize.Output.Payload.Content) != `{"value":"example"}` {
+		t.Fatalf("normalize output = %s, want merge payload", normalize.Output.Payload.Content)
 	}
 
 	output, err := encoder.Encode(ctx, contracts.OutputRequest{
-		Manifest: artifacts.RunManifest{RunID: "run-1"},
-		Approved: []artifacts.Artifact{
-			artifacts.ArtifactFromCandidate(normalize.Candidates[0]),
-		},
+		Manifest:         artifacts.RunManifest{RunID: "run-1"},
+		NormalizeOutputs: []contracts.NormalizeOutput{normalize.Output},
 	})
 	if err != nil {
 		t.Fatalf("Encode() error = %v, want nil", err)
@@ -203,49 +169,24 @@ func (extractor compositionExtractor) Key() string {
 	return "generic-extractor"
 }
 
-func (extractor compositionExtractor) ArtifactType() string {
-	return "generic-artifact"
-}
-
-func (extractor compositionExtractor) SchemaVersion() string {
-	return "v1"
-}
-
 func (extractor compositionExtractor) ReferenceSlots() []contracts.ReferenceSlot {
 	return nil
 }
 
-func (extractor compositionExtractor) Validators() []contracts.Validator {
-	return []contracts.Validator{compositionValidator{}}
-}
-
 func (extractor compositionExtractor) Extract(ctx context.Context, req contracts.ExtractionRequest) (contracts.ExtractionResult, error) {
 	if req.Source == nil {
 		return contracts.ExtractionResult{}, errors.New("source document is required")
 	}
-	units := req.Source.Units
-	if req.Chunk != nil {
-		units = req.Chunk.Units
-	}
 	if req.AmbientContext["synopsis"] == "" {
 		return contracts.ExtractionResult{}, errors.New("ambient synopsis is required")
 	}
 
 	return contracts.ExtractionResult{
-		Candidates: []artifacts.ArtifactCandidate{
-			{
-				Index:         0,
-				ExtractorKey:  extractor.Key(),
-				ArtifactType:  extractor.ArtifactType(),
-				SchemaVersion: extractor.SchemaVersion(),
-				Payload:       json.RawMessage(`{"value":"example"}`),
-				SourceRefs: []source.SourceRef{
-					{
-						SourceID:    req.Source.ID,
-						StartUnitID: units[0].ID,
-						EndUnitID:   units[len(units)-1].ID,
-					},
-				},
+		Output: contracts.ExtractOutput{
+			Schema: contracts.ResponseSchema{ID: "schema-id", Name: "schema-name", Version: "v1"},
+			Payload: contracts.RawPayload{
+				Content:   []byte(`{"value":"example"}`),
+				MediaType: "application/json",
 			},
 		},
 	}, nil
@@ -258,12 +199,14 @@ func (merger compositionMerger) Key() string {
 }
 
 func (merger compositionMerger) Merge(ctx context.Context, req contracts.MergeRequest) (contracts.MergeResult, error) {
-	var candidates []artifacts.ArtifactCandidate
-	for _, chunkArtifacts := range req.ChunkArtifacts {
-		candidates = append(candidates, chunkArtifacts.Candidates...)
-	}
-
-	return contracts.MergeResult{Candidates: candidates}, nil
+	output := req.ExtractOutputs[0]
+	return contracts.MergeResult{Output: contracts.MergeOutput{
+		LaneID:    req.LaneID,
+		MergerKey: merger.Key(),
+		SourceID:  output.SourceID,
+		Schema:    output.Schema,
+		Payload:   cloneCompositionPayload(output.Payload),
+	}}, nil
 }
 
 type compositionNormalizer struct{}
@@ -277,7 +220,33 @@ func (normalizer compositionNormalizer) ReferenceSlots() []contracts.ReferenceSl
 }
 
 func (normalizer compositionNormalizer) Normalize(ctx context.Context, req contracts.NormalizeRequest) (contracts.NormalizeResult, error) {
-	return contracts.NormalizeResult{Candidates: req.Candidates}, nil
+	return contracts.NormalizeResult{Output: contracts.NormalizeOutput{
+		LaneID:        req.LaneID,
+		NormalizerKey: normalizer.Key(),
+		SourceID:      req.MergeOutput.SourceID,
+		Schema:        req.MergeOutput.Schema,
+		Payload:       cloneCompositionPayload(req.MergeOutput.Payload),
+	}}, nil
+}
+
+func cloneCompositionPayload(payload contracts.RawPayload) contracts.RawPayload {
+	return contracts.RawPayload{
+		Content:   append([]byte(nil), payload.Content...),
+		MediaType: payload.MediaType,
+		Metadata:  cloneCompositionMetadata(payload.Metadata),
+		Warnings:  append([]contracts.Warning(nil), payload.Warnings...),
+	}
+}
+
+func cloneCompositionMetadata(metadata map[string]any) map[string]any {
+	if len(metadata) == 0 {
+		return nil
+	}
+	out := make(map[string]any, len(metadata))
+	for key, value := range metadata {
+		out[key] = value
+	}
+	return out
 }
 
 type compositionValidator struct{}
@@ -311,11 +280,11 @@ func (encoder compositionOutputEncoder) Key() string {
 
 func (encoder compositionOutputEncoder) Encode(ctx context.Context, req contracts.OutputRequest) (contracts.OutputResult, error) {
 	payload := struct {
-		RunID         string `json:"run_id"`
-		ApprovedCount int    `json:"approved_count"`
+		RunID       string `json:"run_id"`
+		OutputCount int    `json:"output_count"`
 	}{
-		RunID:         req.Manifest.RunID,
-		ApprovedCount: len(req.Approved),
+		RunID:       req.Manifest.RunID,
+		OutputCount: len(req.NormalizeOutputs),
 	}
 	encoded, err := json.Marshal(payload)
 	if err != nil {