Added support for a minimal JSON output schema

schema/output_test.go

@@ -13,6 +13,96 @@ func TestValidateTranscriptAcceptsValidTranscript(t *testing.T) {
 	}
 }
 
+func TestValidateMinimalTranscriptAcceptsValidTranscript(t *testing.T) {
+	transcript := validMinimalTranscript()
+
+	if err := ValidateMinimalTranscript(transcript); err != nil {
+		t.Fatalf("validate minimal transcript: %v", err)
+	}
+}
+
+func TestValidateMinimalJSONRejectsMissingRequiredField(t *testing.T) {
+	err := ValidateMinimalJSON([]byte(`{
+		"metadata": {
+			"application": "seriatim",
+			"version": "dev",
+			"output_schema": "minimal"
+		}
+	}`))
+	assertErrorContains(t, err, "segments")
+}
+
+func TestValidateMinimalJSONRejectsWrongFieldType(t *testing.T) {
+	err := ValidateMinimalJSON([]byte(`{
+		"metadata": {
+			"application": "seriatim",
+			"version": "dev",
+			"output_schema": "minimal"
+		},
+		"segments": [
+			{
+				"id": "1",
+				"start": 1,
+				"end": 2,
+				"speaker": "Alice",
+				"text": "hello"
+			}
+		]
+	}`))
+	assertErrorContains(t, err, "id")
+}
+
+func TestValidateMinimalJSONRejectsUnexpectedFields(t *testing.T) {
+	tests := []struct {
+		name string
+		json string
+	}{
+		{
+			name: "top-level overlap groups",
+			json: `{
+				"metadata": {"application": "seriatim", "version": "dev", "output_schema": "minimal"},
+				"segments": [],
+				"overlap_groups": []
+			}`,
+		},
+		{
+			name: "segment source",
+			json: `{
+				"metadata": {"application": "seriatim", "version": "dev", "output_schema": "minimal"},
+				"segments": [{"id": 1, "source": "input.json", "start": 1, "end": 2, "speaker": "Alice", "text": "hello"}]
+			}`,
+		},
+		{
+			name: "segment categories",
+			json: `{
+				"metadata": {"application": "seriatim", "version": "dev", "output_schema": "minimal"},
+				"segments": [{"id": 1, "start": 1, "end": 2, "speaker": "Alice", "text": "hello", "categories": ["backchannel"]}]
+			}`,
+		},
+		{
+			name: "segment derived from",
+			json: `{
+				"metadata": {"application": "seriatim", "version": "dev", "output_schema": "minimal"},
+				"segments": [{"id": 1, "start": 1, "end": 2, "speaker": "Alice", "text": "hello", "derived_from": ["input.json#0"]}]
+			}`,
+		},
+		{
+			name: "segment words",
+			json: `{
+				"metadata": {"application": "seriatim", "version": "dev", "output_schema": "minimal"},
+				"segments": [{"id": 1, "start": 1, "end": 2, "speaker": "Alice", "text": "hello", "words": []}]
+			}`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := ValidateMinimalJSON([]byte(test.json))
+			assertErrorContains(t, err, "additional properties")
+		})
+	}
+}
+
 func TestValidateJSONRejectsMissingRequiredField(t *testing.T) {
 	err := ValidateJSON([]byte(`{
 		"metadata": {
@@ -135,6 +225,46 @@ func TestValidateTranscriptRejectsInvalidTiming(t *testing.T) {
 	assertErrorContains(t, err, "segment 0 has end")
 }
 
+func TestValidateMinimalTranscriptRejectsMissingOrNonSequentialIDs(t *testing.T) {
+	tests := []struct {
+		name string
+		ids  []int
+		want string
+	}{
+		{name: "missing zero id", ids: []int{0}, want: "segment 0 has id 0; want 1"},
+		{name: "does not start at one", ids: []int{2}, want: "segment 0 has id 2; want 1"},
+		{name: "gap", ids: []int{1, 3}, want: "segment 1 has id 3; want 2"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			transcript := validMinimalTranscript()
+			transcript.Segments = transcript.Segments[:0]
+			for index, id := range test.ids {
+				transcript.Segments = append(transcript.Segments, MinimalSegment{
+					ID:      id,
+					Start:   float64(index),
+					End:     float64(index) + 1,
+					Speaker: "Alice",
+					Text:    "hello",
+				})
+			}
+
+			err := ValidateMinimalTranscript(transcript)
+			assertErrorContains(t, err, test.want)
+		})
+	}
+}
+
+func TestValidateMinimalTranscriptRejectsInvalidTiming(t *testing.T) {
+	transcript := validMinimalTranscript()
+	transcript.Segments[0].Start = 2
+	transcript.Segments[0].End = 1
+
+	err := ValidateMinimalTranscript(transcript)
+	assertErrorContains(t, err, "segment 0 has end")
+}
+
 func TestValidateTranscriptRejectsInvalidOverlapGroupTiming(t *testing.T) {
 	transcript := validTranscript()
 	transcript.OverlapGroups = []OverlapGroup{
@@ -153,6 +283,25 @@ func TestValidateTranscriptRejectsInvalidOverlapGroupTiming(t *testing.T) {
 	assertErrorContains(t, err, "overlap_group 0 has end")
 }
 
+func validMinimalTranscript() MinimalTranscript {
+	return MinimalTranscript{
+		Metadata: MinimalMetadata{
+			Application:  "seriatim",
+			Version:      "dev",
+			OutputSchema: "minimal",
+		},
+		Segments: []MinimalSegment{
+			{
+				ID:      1,
+				Start:   1,
+				End:     2,
+				Speaker: "Alice",
+				Text:    "hello",
+			},
+		},
+	}
+}
+
 func validTranscript() Transcript {
 	sourceIndex := 0
 	return Transcript{