Add reference contracts to extractor metadata

internal/framework/pipeline/extractor_registry_test.go

@@ -49,6 +49,20 @@ func TestExtractorRegistryRegisterWithSpecStoresMetadata(t *testing.T) {
 		Stage:    StageExtract,
 		Provides: []string{" generic-artifact ", "source-citations", "generic-artifact", ""},
 		Requires: []string{" source-document ", "source-document", ""},
+		ReferenceSlots: []contracts.ReferenceSlot{
+			{
+				Name:               " glossary ",
+				Description:        " Supporting terms ",
+				AcceptedMediaTypes: []string{" text/plain ", "text/markdown", "text/plain", ""},
+				MaxBytes:           1024,
+			},
+			{
+				Name:        " roster ",
+				Description: " Characters ",
+				Required:    true,
+				Multiple:    true,
+			},
+		},
 	}
 
 	if err := registry.RegisterWithSpec(spec, fakeExtractorConstructor("generic-extractor")); err != nil {
@@ -64,12 +78,28 @@ func TestExtractorRegistryRegisterWithSpecStoresMetadata(t *testing.T) {
 		Stage:    StageExtract,
 		Provides: []string{"generic-artifact", "source-citations"},
 		Requires: []string{"source-document"},
+		ReferenceSlots: []contracts.ReferenceSlot{
+			{
+				Name:               "glossary",
+				Description:        "Supporting terms",
+				AcceptedMediaTypes: []string{"text/markdown", "text/plain"},
+				MaxBytes:           1024,
+			},
+			{
+				Name:        "roster",
+				Description: "Characters",
+				Required:    true,
+				Multiple:    true,
+			},
+		},
 	}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("Spec() = %#v, want %#v", got, want)
 	}
 
 	got.Provides[0] = "changed"
+	got.ReferenceSlots[0].Name = "changed"
+	got.ReferenceSlots[0].AcceptedMediaTypes[0] = "changed"
 	again, ok := registry.Spec("generic-extractor")
 	if !ok {
 		t.Fatal("Spec() after caller mutation ok = false, want true")
@@ -109,6 +139,50 @@ func TestExtractorRegistryRegisterWithSpecRejectsWrongStage(t *testing.T) {
 	}
 }
 
+func TestExtractorRegistryRejectsInvalidReferenceSlots(t *testing.T) {
+	tests := []struct {
+		name  string
+		slots []contracts.ReferenceSlot
+		want  string
+	}{
+		{
+			name:  "empty name",
+			slots: []contracts.ReferenceSlot{{Name: " "}},
+			want:  "name",
+		},
+		{
+			name: "duplicate name after trim",
+			slots: []contracts.ReferenceSlot{
+				{Name: "roster"},
+				{Name: " roster "},
+			},
+			want: "duplicated",
+		},
+		{
+			name:  "negative max bytes",
+			slots: []contracts.ReferenceSlot{{Name: "roster", MaxBytes: -1}},
+			want:  "max_bytes",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			registry := NewExtractorRegistry()
+			err := registry.RegisterWithSpec(ModuleSpec{
+				Key:            "generic-extractor",
+				Stage:          StageExtract,
+				ReferenceSlots: test.slots,
+			}, fakeExtractorConstructor("generic-extractor"))
+			if err == nil {
+				t.Fatal("RegisterWithSpec() error = nil, want error")
+			}
+			if !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("RegisterWithSpec() error = %q, want %q", err.Error(), test.want)
+			}
+		})
+	}
+}
+
 func TestExtractorRegistrySpecRejectsUnknownKey(t *testing.T) {
 	registry := NewExtractorRegistry()
 
@@ -301,6 +375,10 @@ func (extractor registryFakeExtractor) SchemaVersion() string {
 	return "v1"
 }
 
+func (extractor registryFakeExtractor) ReferenceSlots() []contracts.ReferenceSlot {
+	return nil
+}
+
 func (extractor registryFakeExtractor) Validators() []contracts.Validator {
 	return nil
 }