cricinfo-cli-go 0.1.1 → 0.1.4

package/internal/cricinfo/analysis.go

@@ -19,6 +19,7 @@ const (
 	analysisMetricSixesConceded = "sixes-conceded"
 	analysisMetricFours         = "fours"
 	analysisMetricSixes         = "sixes"
+	analysisMetricRuns          = "runs"
 	analysisMetricStrikeRate    = "strike-rate"
 )
 
@@ -349,54 +350,62 @@ func (s *AnalysisService) Bowling(ctx context.Context, opts AnalysisMetricOption
 
 	agg := map[string]*analysisAggregate{}
 	warnings := append([]string{}, run.warnings...)
-	for _, match := range run.session.ScopedMatches() {
-		seasonID := seasonForMatch(match, run.seasonHint)
-		players, playerWarnings, hydrateErr := run.session.HydratePlayerMatchSummaries(ctx, match.ID)
-		if hydrateErr != nil {
-			if statusErr := analysisTransportResult(EntityAnalysisBowl, match.ID, hydrateErr); statusErr != nil {
-				return *statusErr, nil
-			}
-			warnings = append(warnings, fmt.Sprintf("match %s player summary: %v", match.ID, hydrateErr))
-			continue
+	if run.mode == analysisScopeMatch {
+		if fastAgg, fastWarnings, used := s.hydrateMatchScopeBowlingFromScorecard(ctx, run, filters, groupBy); used {
+			agg = fastAgg
+			warnings = append(warnings, fastWarnings...)
 		}
-		warnings = append(warnings, playerWarnings...)
-
-		for _, player := range players {
-			totals := extractBowlingTotals(player)
-			playerName := analysisDisplayPlayerName(s.resolver, player.PlayerID, player.PlayerName)
-			teamName := analysisDisplayTeamName(s.resolver, player.TeamID, player.TeamName)
-			row := analysisSourceRow{
-				MatchID:       strings.TrimSpace(player.MatchID),
-				LeagueID:      strings.TrimSpace(player.LeagueID),
-				SeasonID:      seasonID,
-				TeamID:        strings.TrimSpace(player.TeamID),
-				TeamName:      strings.TrimSpace(teamName),
-				PlayerID:      strings.TrimSpace(player.PlayerID),
-				PlayerName:    strings.TrimSpace(playerName),
-				CountValue:    1,
-				Dots:          totals.dots,
-				SixesConceded: totals.sixesConceded,
-				Balls:         totals.balls,
-				RunsConceded:  totals.conceded,
-				EconomySample: totals.economy,
-			}
-			if !filters.matches(row) {
+	}
+	if len(agg) == 0 {
+		for _, match := range run.session.ScopedMatches() {
+			seasonID := seasonForMatch(match, run.seasonHint)
+			players, playerWarnings, hydrateErr := run.session.HydratePlayerMatchSummaries(ctx, match.ID)
+			if hydrateErr != nil {
+				if statusErr := analysisTransportResult(EntityAnalysisBowl, match.ID, hydrateErr); statusErr != nil {
+					return *statusErr, nil
+				}
+				warnings = append(warnings, fmt.Sprintf("match %s player summary: %v", match.ID, hydrateErr))
 				continue
 			}
-			key, dims := buildAnalysisGroup(row, groupBy)
-			entry := agg[key]
-			if entry == nil {
-				entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
-				agg[key] = entry
-			}
-			entry.matchIDs[row.MatchID] = struct{}{}
-			entry.dots += row.Dots
-			entry.sixesConceded += row.SixesConceded
-			entry.balls += row.Balls
-			entry.runsConceded += row.RunsConceded
-			if row.EconomySample > 0 {
-				entry.economyTotal += row.EconomySample
-				entry.economyCount++
+			warnings = append(warnings, playerWarnings...)
+
+			for _, player := range players {
+				totals := extractBowlingTotals(player)
+				playerName := analysisDisplayPlayerName(s.resolver, player.PlayerID, player.PlayerName)
+				teamName := analysisDisplayTeamName(s.resolver, player.TeamID, player.TeamName)
+				row := analysisSourceRow{
+					MatchID:       strings.TrimSpace(player.MatchID),
+					LeagueID:      strings.TrimSpace(player.LeagueID),
+					SeasonID:      seasonID,
+					TeamID:        strings.TrimSpace(player.TeamID),
+					TeamName:      strings.TrimSpace(teamName),
+					PlayerID:      strings.TrimSpace(player.PlayerID),
+					PlayerName:    strings.TrimSpace(playerName),
+					CountValue:    1,
+					Dots:          totals.dots,
+					SixesConceded: totals.sixesConceded,
+					Balls:         totals.balls,
+					RunsConceded:  totals.conceded,
+					EconomySample: totals.economy,
+				}
+				if !filters.matches(row) {
+					continue
+				}
+				key, dims := buildAnalysisGroup(row, groupBy)
+				entry := agg[key]
+				if entry == nil {
+					entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
+					agg[key] = entry
+				}
+				entry.matchIDs[row.MatchID] = struct{}{}
+				entry.dots += row.Dots
+				entry.sixesConceded += row.SixesConceded
+				entry.balls += row.Balls
+				entry.runsConceded += row.RunsConceded
+				if row.EconomySample > 0 {
+					entry.economyTotal += row.EconomySample
+					entry.economyCount++
+				}
 			}
 		}
 	}
@@ -447,6 +456,103 @@ func (s *AnalysisService) Bowling(ctx context.Context, opts AnalysisMetricOption
 	return analysisResult(EntityAnalysisBowl, view, warnings), nil
 }
 
+func (s *AnalysisService) hydrateMatchScopeBowlingFromScorecard(
+	ctx context.Context,
+	run *analysisScopeRun,
+	filters analysisFilterSpec,
+	groupBy []string,
+) (map[string]*analysisAggregate, []string, bool) {
+	if run == nil || run.session == nil {
+		return nil, nil, false
+	}
+	matches := run.session.ScopedMatches()
+	if len(matches) != 1 {
+		return nil, nil, false
+	}
+	match := matches[0]
+	scorecardRef := matchSubresourceRef(match, "matchcards", "matchcards")
+	if strings.TrimSpace(scorecardRef) == "" {
+		return nil, nil, false
+	}
+	resolved, err := s.client.ResolveRefChain(ctx, scorecardRef)
+	if err != nil {
+		return nil, nil, false
+	}
+	scorecard, err := NormalizeMatchScorecard(resolved.Body, match)
+	if err != nil {
+		return nil, nil, false
+	}
+	if len(scorecard.BowlingCards) == 0 {
+		return nil, nil, false
+	}
+
+	teamIDByAlias := map[string]string{}
+	for _, team := range match.Teams {
+		teamID := strings.TrimSpace(team.ID)
+		for _, raw := range []string{team.Name, team.ShortName, team.Abbreviation} {
+			alias := normalizeAlias(raw)
+			if alias == "" {
+				continue
+			}
+			if _, exists := teamIDByAlias[alias]; !exists {
+				teamIDByAlias[alias] = teamID
+			}
+		}
+	}
+
+	seasonID := seasonForMatch(match, run.seasonHint)
+	agg := map[string]*analysisAggregate{}
+	for _, card := range scorecard.BowlingCards {
+		teamName := strings.TrimSpace(card.TeamName)
+		teamID := teamIDByAlias[normalizeAlias(teamName)]
+		teamName = analysisDisplayTeamName(s.resolver, teamID, teamName)
+
+		for _, player := range card.Players {
+			conceded := analysisNumericString(player.Conceded)
+			wickets := analysisNumericString(player.Wickets)
+			balls := oversToBalls(player.Overs)
+			econ := 0.0
+			if balls > 0 {
+				econ = float64(conceded) / (float64(balls) / 6.0)
+			}
+			row := analysisSourceRow{
+				MatchID:       strings.TrimSpace(match.ID),
+				LeagueID:      strings.TrimSpace(nonEmpty(match.LeagueID, run.scope.League.ID)),
+				SeasonID:      seasonID,
+				TeamID:        teamID,
+				TeamName:      teamName,
+				PlayerID:      strings.TrimSpace(player.PlayerID),
+				PlayerName:    analysisDisplayPlayerName(s.resolver, player.PlayerID, player.PlayerName),
+				CountValue:    1,
+				Balls:         balls,
+				RunsConceded:  conceded,
+				EconomySample: econ,
+			}
+			if wickets > 0 {
+				row.Dots = 0
+			}
+			if !filters.matches(row) {
+				continue
+			}
+
+			key, dims := buildAnalysisGroup(row, groupBy)
+			entry := agg[key]
+			if entry == nil {
+				entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
+				agg[key] = entry
+			}
+			entry.matchIDs[row.MatchID] = struct{}{}
+			entry.balls += row.Balls
+			entry.runsConceded += row.RunsConceded
+			if row.EconomySample > 0 {
+				entry.economyTotal += row.EconomySample
+				entry.economyCount++
+			}
+		}
+	}
+	return agg, nil, true
+}
+
 // Batting ranks batting metrics over match or season scope.
 func (s *AnalysisService) Batting(ctx context.Context, opts AnalysisMetricOptions) (NormalizedResult, error) {
 	metric, err := normalizeBattingMetric(opts.Metric)
@@ -467,54 +573,62 @@ func (s *AnalysisService) Batting(ctx context.Context, opts AnalysisMetricOption
 
 	agg := map[string]*analysisAggregate{}
 	warnings := append([]string{}, run.warnings...)
-	for _, match := range run.session.ScopedMatches() {
-		seasonID := seasonForMatch(match, run.seasonHint)
-		players, playerWarnings, hydrateErr := run.session.HydratePlayerMatchSummaries(ctx, match.ID)
-		if hydrateErr != nil {
-			if statusErr := analysisTransportResult(EntityAnalysisBat, match.ID, hydrateErr); statusErr != nil {
-				return *statusErr, nil
-			}
-			warnings = append(warnings, fmt.Sprintf("match %s player summary: %v", match.ID, hydrateErr))
-			continue
+	if run.mode == analysisScopeMatch {
+		if fastAgg, fastWarnings, used := s.hydrateMatchScopeBattingFromScorecard(ctx, run, filters, groupBy); used {
+			agg = fastAgg
+			warnings = append(warnings, fastWarnings...)
 		}
-		warnings = append(warnings, playerWarnings...)
-
-		for _, player := range players {
-			totals := extractBattingTotals(player)
-			playerName := analysisDisplayPlayerName(s.resolver, player.PlayerID, player.PlayerName)
-			teamName := analysisDisplayTeamName(s.resolver, player.TeamID, player.TeamName)
-			row := analysisSourceRow{
-				MatchID:      strings.TrimSpace(player.MatchID),
-				LeagueID:     strings.TrimSpace(player.LeagueID),
-				SeasonID:     seasonID,
-				TeamID:       strings.TrimSpace(player.TeamID),
-				TeamName:     strings.TrimSpace(teamName),
-				PlayerID:     strings.TrimSpace(player.PlayerID),
-				PlayerName:   strings.TrimSpace(playerName),
-				CountValue:   1,
-				Fours:        totals.fours,
-				BattingSixes: totals.sixes,
-				RunsScored:   totals.runs,
-				BallsFaced:   totals.balls,
-				StrikeSample: totals.strikeRate,
-			}
-			if !filters.matches(row) {
+	}
+	if len(agg) == 0 {
+		for _, match := range run.session.ScopedMatches() {
+			seasonID := seasonForMatch(match, run.seasonHint)
+			players, playerWarnings, hydrateErr := run.session.HydratePlayerMatchSummaries(ctx, match.ID)
+			if hydrateErr != nil {
+				if statusErr := analysisTransportResult(EntityAnalysisBat, match.ID, hydrateErr); statusErr != nil {
+					return *statusErr, nil
+				}
+				warnings = append(warnings, fmt.Sprintf("match %s player summary: %v", match.ID, hydrateErr))
 				continue
 			}
-			key, dims := buildAnalysisGroup(row, groupBy)
-			entry := agg[key]
-			if entry == nil {
-				entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
-				agg[key] = entry
-			}
-			entry.matchIDs[row.MatchID] = struct{}{}
-			entry.fours += row.Fours
-			entry.battingSixes += row.BattingSixes
-			entry.runsScored += row.RunsScored
-			entry.ballsFaced += row.BallsFaced
-			if row.StrikeSample > 0 {
-				entry.strikeRateTotal += row.StrikeSample
-				entry.strikeRateCount++
+			warnings = append(warnings, playerWarnings...)
+
+			for _, player := range players {
+				totals := extractBattingTotals(player)
+				playerName := analysisDisplayPlayerName(s.resolver, player.PlayerID, player.PlayerName)
+				teamName := analysisDisplayTeamName(s.resolver, player.TeamID, player.TeamName)
+				row := analysisSourceRow{
+					MatchID:      strings.TrimSpace(player.MatchID),
+					LeagueID:     strings.TrimSpace(player.LeagueID),
+					SeasonID:     seasonID,
+					TeamID:       strings.TrimSpace(player.TeamID),
+					TeamName:     strings.TrimSpace(teamName),
+					PlayerID:     strings.TrimSpace(player.PlayerID),
+					PlayerName:   strings.TrimSpace(playerName),
+					CountValue:   1,
+					Fours:        totals.fours,
+					BattingSixes: totals.sixes,
+					RunsScored:   totals.runs,
+					BallsFaced:   totals.balls,
+					StrikeSample: totals.strikeRate,
+				}
+				if !filters.matches(row) {
+					continue
+				}
+				key, dims := buildAnalysisGroup(row, groupBy)
+				entry := agg[key]
+				if entry == nil {
+					entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
+					agg[key] = entry
+				}
+				entry.matchIDs[row.MatchID] = struct{}{}
+				entry.fours += row.Fours
+				entry.battingSixes += row.BattingSixes
+				entry.runsScored += row.RunsScored
+				entry.ballsFaced += row.BallsFaced
+				if row.StrikeSample > 0 {
+					entry.strikeRateTotal += row.StrikeSample
+					entry.strikeRateCount++
+				}
 			}
 		}
 	}
@@ -533,6 +647,9 @@ func (s *AnalysisService) Batting(ctx context.Context, opts AnalysisMetricOption
 		case analysisMetricSixes:
 			row.Value = float64(entry.battingSixes)
 			row.Count = entry.battingSixes
+		case analysisMetricRuns:
+			row.Value = float64(entry.runsScored)
+			row.Count = entry.runsScored
 		case analysisMetricStrikeRate:
 			row.Value = strikeRateFromAggregate(entry)
 		}
@@ -559,6 +676,133 @@ func (s *AnalysisService) Batting(ctx context.Context, opts AnalysisMetricOption
 	return analysisResult(EntityAnalysisBat, view, warnings), nil
 }
 
+func (s *AnalysisService) hydrateMatchScopeBattingFromScorecard(
+	ctx context.Context,
+	run *analysisScopeRun,
+	filters analysisFilterSpec,
+	groupBy []string,
+) (map[string]*analysisAggregate, []string, bool) {
+	if run == nil || run.session == nil {
+		return nil, nil, false
+	}
+	matches := run.session.ScopedMatches()
+	if len(matches) != 1 {
+		return nil, nil, false
+	}
+
+	match := matches[0]
+	scorecardRef := matchSubresourceRef(match, "matchcards", "matchcards")
+	if strings.TrimSpace(scorecardRef) == "" {
+		return nil, nil, false
+	}
+
+	resolved, err := s.client.ResolveRefChain(ctx, scorecardRef)
+	if err != nil {
+		return nil, nil, false
+	}
+	scorecard, err := NormalizeMatchScorecard(resolved.Body, match)
+	if err != nil {
+		return nil, nil, false
+	}
+
+	teamIDByAlias := map[string]string{}
+	playerNameByID := map[string]string{}
+	for _, team := range match.Teams {
+		teamID := strings.TrimSpace(team.ID)
+		for _, raw := range []string{team.Name, team.ShortName, team.Abbreviation} {
+			alias := normalizeAlias(raw)
+			if alias == "" {
+				continue
+			}
+			if _, exists := teamIDByAlias[alias]; !exists {
+				teamIDByAlias[alias] = teamID
+			}
+		}
+
+		rosterRef := nonEmpty(strings.TrimSpace(team.RosterRef), competitorSubresourceRef(match, team.ID, "roster"))
+		if strings.TrimSpace(rosterRef) == "" {
+			continue
+		}
+		rosterDoc, rosterErr := s.client.ResolveRefChain(ctx, rosterRef)
+		if rosterErr != nil {
+			continue
+		}
+		entries, normalizeErr := NormalizeTeamRosterEntries(rosterDoc.Body, team, TeamScopeMatch, match.ID)
+		if normalizeErr != nil {
+			continue
+		}
+		for _, entry := range entries {
+			playerID := strings.TrimSpace(entry.PlayerID)
+			playerName := strings.TrimSpace(entry.DisplayName)
+			if playerID == "" || playerName == "" {
+				continue
+			}
+			if _, exists := playerNameByID[playerID]; !exists {
+				playerNameByID[playerID] = playerName
+			}
+		}
+	}
+
+	seasonID := seasonForMatch(match, run.seasonHint)
+	agg := map[string]*analysisAggregate{}
+	for _, card := range scorecard.BattingCards {
+		teamName := strings.TrimSpace(card.TeamName)
+		teamID := teamIDByAlias[normalizeAlias(teamName)]
+		teamName = analysisDisplayTeamName(s.resolver, teamID, teamName)
+
+		for _, player := range card.Players {
+			runs := analysisNumericString(player.Runs)
+			balls := analysisNumericString(player.BallsFaced)
+			fours := analysisNumericString(player.Fours)
+			sixes := analysisNumericString(player.Sixes)
+			strikeRate := 0.0
+			if balls > 0 {
+				strikeRate = (float64(runs) * 100.0) / float64(balls)
+			}
+
+			row := analysisSourceRow{
+				MatchID:  strings.TrimSpace(match.ID),
+				LeagueID: strings.TrimSpace(nonEmpty(match.LeagueID, run.scope.League.ID)),
+				SeasonID: seasonID,
+				TeamID:   teamID,
+				TeamName: teamName,
+				PlayerID: strings.TrimSpace(player.PlayerID),
+				PlayerName: analysisDisplayPlayerName(
+					s.resolver,
+					player.PlayerID,
+					nonEmpty(playerNameByID[strings.TrimSpace(player.PlayerID)], player.PlayerName),
+				),
+				CountValue:   1,
+				Fours:        fours,
+				BattingSixes: sixes,
+				RunsScored:   runs,
+				BallsFaced:   balls,
+				StrikeSample: strikeRate,
+			}
+			if !filters.matches(row) {
+				continue
+			}
+
+			key, dims := buildAnalysisGroup(row, groupBy)
+			entry := agg[key]
+			if entry == nil {
+				entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
+				agg[key] = entry
+			}
+			entry.matchIDs[row.MatchID] = struct{}{}
+			entry.fours += row.Fours
+			entry.battingSixes += row.BattingSixes
+			entry.runsScored += row.RunsScored
+			entry.ballsFaced += row.BallsFaced
+			if row.StrikeSample > 0 {
+				entry.strikeRateTotal += row.StrikeSample
+				entry.strikeRateCount++
+			}
+		}
+	}
+	return agg, nil, true
+}
+
 // Partnerships ranks partnerships over match or season scope.
 func (s *AnalysisService) Partnerships(ctx context.Context, opts AnalysisMetricOptions) (NormalizedResult, error) {
 	groupBy, err := parseGroupBy(opts.GroupBy, []string{"innings"}, analysisGroupPartnershipAllowed)
@@ -858,10 +1102,10 @@ func normalizeBattingMetric(raw string) (string, error) {
 	metric = strings.ReplaceAll(metric, "_", "-")
 	metric = strings.ReplaceAll(metric, " ", "-")
 	switch metric {
-	case analysisMetricFours, analysisMetricSixes, analysisMetricStrikeRate:
+	case analysisMetricFours, analysisMetricSixes, analysisMetricRuns, analysisMetricStrikeRate:
 		return metric, nil
 	default:
-		return "", fmt.Errorf("--metric must be one of: fours, sixes, strike-rate")
+		return "", fmt.Errorf("--metric must be one of: fours, sixes, runs, strike-rate")
 	}
 }
 
@@ -1191,7 +1435,7 @@ type battingTotals struct {
 }
 
 func extractBattingTotals(player PlayerMatch) battingTotals {
-	totals := battingTotals{strikeRate: player.Summary.StrikeRate, balls: player.Summary.BallsFaced}
+	totals := battingTotals{strikeRate: player.Summary.StrikeRate}
 	for _, category := range player.Batting {
 		for _, stat := range category.Stats {
 			switch normalizeStatName(stat.Name) {
@@ -1210,6 +1454,12 @@ func extractBattingTotals(player PlayerMatch) battingTotals {
 			}
 		}
 	}
+
+	// Batting summary fields are frequently derived from the same stats payload.
+	// Prefer the larger value rather than summing to avoid duplicate counting.
+	if player.Summary.BallsFaced > 0 {
+		totals.balls = analysisMaxInt(totals.balls, player.Summary.BallsFaced)
+	}
 	return totals
 }
 
@@ -1267,6 +1517,56 @@ func analysisMaxInt(a, b int) int {
 	return b
 }
 
+func analysisNumericString(raw string) int {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return 0
+	}
+	start := -1
+	end := -1
+	for i, r := range raw {
+		if r >= '0' && r <= '9' {
+			if start == -1 {
+				start = i
+			}
+			end = i + 1
+			continue
+		}
+		if start != -1 {
+			break
+		}
+	}
+	if start == -1 || end == -1 {
+		return 0
+	}
+	value, err := strconv.Atoi(raw[start:end])
+	if err != nil {
+		return 0
+	}
+	return value
+}
+
+func oversToBalls(raw string) int {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return 0
+	}
+	if strings.Contains(raw, ".") {
+		parts := strings.SplitN(raw, ".", 2)
+		whole, errWhole := strconv.Atoi(strings.TrimSpace(parts[0]))
+		frac, errFrac := strconv.Atoi(strings.TrimSpace(parts[1]))
+		if errWhole != nil || errFrac != nil || whole < 0 || frac < 0 || frac > 6 {
+			return 0
+		}
+		return whole*6 + frac
+	}
+	value, err := strconv.Atoi(raw)
+	if err != nil || value < 0 {
+		return 0
+	}
+	return value * 6
+}
+
 func analysisDisplayPlayerName(resolver *Resolver, playerID, fallback string) string {
 	name := strings.TrimSpace(fallback)
 	if name != "" {

package/internal/cricinfo/analysis_phase15_test.go

@@ -203,6 +203,44 @@ func TestPhase15BowlingActivityFilterSkipsNonBowlers(t *testing.T) {
 	}
 }
 
+func TestPhase15ExtractBattingTotalsDoesNotDoubleCountSummaryBalls(t *testing.T) {
+	t.Parallel()
+
+	player := PlayerMatch{
+		PlayerID:   "1408688",
+		PlayerName: "Vaibhav Sooryavanshi",
+		Batting: []StatCategory{
+			{
+				Name: "general",
+				Stats: []StatValue{
+					{Name: "runs", Value: "78"},
+					{Name: "ballsFaced", Value: "26"},
+					{Name: "fours", Value: "8"},
+					{Name: "sixes", Value: "7"},
+					{Name: "strikeRate", Value: "300"},
+				},
+			},
+		},
+		Summary: PlayerMatchSummary{
+			BallsFaced: 26,
+			StrikeRate: 300,
+		},
+	}
+
+	totals := extractBattingTotals(player)
+	if totals.runs != 78 || totals.balls != 26 {
+		t.Fatalf("expected 78/26 batting totals, got runs=%d balls=%d", totals.runs, totals.balls)
+	}
+
+	agg := &analysisAggregate{
+		runsScored: totals.runs,
+		ballsFaced: totals.balls,
+	}
+	if got := strikeRateFromAggregate(agg); got != 300 {
+		t.Fatalf("expected strike rate 300, got %.2f", got)
+	}
+}
+
 func TestLivePhase15SmallHistoricalScope(t *testing.T) {
 	t.Parallel()
 	requireLiveMatrix(t)

package/internal/cricinfo/client.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"math"
 	"math/rand"
+	"net"
 	"net/http"
 	"net/url"
 	"strings"
@@ -138,7 +139,18 @@ func NewClient(cfg Config) (*Client, error) {
 
 	httpClient := cfg.HTTPClient
 	if httpClient == nil {
-		httpClient = &http.Client{}
+		httpClient = &http.Client{
+			Transport: &http.Transport{
+				Proxy:                 http.ProxyFromEnvironment,
+				DialContext:           (&net.Dialer{Timeout: 5 * time.Second, KeepAlive: 30 * time.Second}).DialContext,
+				ForceAttemptHTTP2:     true,
+				MaxIdleConns:          128,
+				MaxIdleConnsPerHost:   32,
+				IdleConnTimeout:       90 * time.Second,
+				TLSHandshakeTimeout:   5 * time.Second,
+				ExpectContinueTimeout: 1 * time.Second,
+			},
+		}
 	}
 
 	sleep := cfg.Sleep
@@ -207,7 +219,7 @@ func (c *Client) Fetch(ctx context.Context, ref string) (*Document, error) {
 			return nil, fmt.Errorf("read response %q: %w", requestURL, readErr)
 		}
 
-		if resp.StatusCode >= defaultRetryStatusCode && attempt < c.maxRetries {
+		if c.shouldRetryStatus(resp.StatusCode) && attempt < c.maxRetries {
 			if sleepErr := c.sleep(ctx, c.retryDelay(attempt)); sleepErr != nil {
 				return nil, sleepErr
 			}
@@ -348,6 +360,15 @@ func (c *Client) shouldRetryError(err error, parentCtx context.Context) bool {
 	return parentCtx.Err() == nil
 }
 
+func (c *Client) shouldRetryStatus(statusCode int) bool {
+	switch statusCode {
+	case http.StatusRequestTimeout, http.StatusTooManyRequests:
+		return true
+	default:
+		return statusCode >= defaultRetryStatusCode
+	}
+}
+
 func (c *Client) retryDelay(attempt int) time.Duration {
 	delay := float64(c.retryBaseDelay)
 	delay *= math.Pow(2, float64(attempt))