cricinfo-cli-go 0.1.0 → 0.1.2

package/internal/cli/matches.go

@@ -19,6 +19,7 @@ type matchCommandService interface {
 	Details(ctx context.Context, query string, opts cricinfo.MatchLookupOptions) (cricinfo.NormalizedResult, error)
 	Plays(ctx context.Context, query string, opts cricinfo.MatchLookupOptions) (cricinfo.NormalizedResult, error)
 	Situation(ctx context.Context, query string, opts cricinfo.MatchLookupOptions) (cricinfo.NormalizedResult, error)
+	Phases(ctx context.Context, query string, opts cricinfo.MatchLookupOptions) (cricinfo.NormalizedResult, error)
 	Innings(ctx context.Context, query string, opts cricinfo.MatchInningsOptions) (cricinfo.NormalizedResult, error)
 	Partnerships(ctx context.Context, query string, opts cricinfo.MatchInningsOptions) (cricinfo.NormalizedResult, error)
 	FallOfWicket(ctx context.Context, query string, opts cricinfo.MatchInningsOptions) (cricinfo.NormalizedResult, error)
@@ -77,7 +78,10 @@ func newMatchesCommand(global *globalOptions) *cobra.Command {
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return runMatchCommand(cmd, global, func(ctx context.Context, service matchCommandService) (cricinfo.NormalizedResult, error) {
-				return service.List(ctx, cricinfo.MatchListOptions{Limit: opts.limit})
+				return service.List(ctx, cricinfo.MatchListOptions{
+					Limit:    opts.limit,
+					LeagueID: opts.leagueID,
+				})
 			})
 		},
 	}
@@ -98,7 +102,10 @@ func newMatchesCommand(global *globalOptions) *cobra.Command {
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return runMatchCommand(cmd, global, func(ctx context.Context, service matchCommandService) (cricinfo.NormalizedResult, error) {
-				return service.Live(ctx, cricinfo.MatchListOptions{Limit: opts.limit})
+				return service.Live(ctx, cricinfo.MatchListOptions{
+					Limit:    opts.limit,
+					LeagueID: opts.leagueID,
+				})
 			})
 		},
 	}
@@ -224,6 +231,26 @@ func newMatchesCommand(global *globalOptions) *cobra.Command {
 		},
 	}
 
+	phasesCmd := &cobra.Command{
+		Use:   "phases <match>",
+		Short: "Show powerplay, middle, and death-over phase splits for each innings",
+		Long: strings.Join([]string{
+			"Resolve a match and show fan-friendly phase splits (powerplay/middle/death) with momentum markers.",
+			"",
+			"Next steps:",
+			"  cricinfo matches scorecard <match>",
+			"  cricinfo matches deliveries <match> --team <team> --innings <n> --period <n>",
+			"  cricinfo matches fow <match> --team <team> --innings <n> --period <n>",
+		}, "\n"),
+		Args: cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			query := strings.TrimSpace(strings.Join(args, " "))
+			return runMatchCommand(cmd, global, func(ctx context.Context, service matchCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Phases(ctx, query, cricinfo.MatchLookupOptions{LeagueID: opts.leagueID})
+			})
+		},
+	}
+
 	inningsCmd := &cobra.Command{
 		Use:   "innings <match>",
 		Short: "Show innings summaries with over and wicket timelines",
@@ -369,6 +396,7 @@ func newMatchesCommand(global *globalOptions) *cobra.Command {
 		detailsCmd,
 		playsCmd,
 		situationCmd,
+		phasesCmd,
 		inningsCmd,
 		partnershipsCmd,
 		fowCmd,

package/internal/cli/matches_test.go

@@ -19,6 +19,7 @@ type fakeMatchService struct {
 	detailsResult   cricinfo.NormalizedResult
 	playsResult     cricinfo.NormalizedResult
 	situationResult cricinfo.NormalizedResult
+	phasesResult    cricinfo.NormalizedResult
 	inningsResult   cricinfo.NormalizedResult
 	partnerships    cricinfo.NormalizedResult
 	fowResult       cricinfo.NormalizedResult
@@ -68,6 +69,10 @@ func (f *fakeMatchService) Situation(context.Context, string, cricinfo.MatchLook
 	return f.situationResult, nil
 }
 
+func (f *fakeMatchService) Phases(context.Context, string, cricinfo.MatchLookupOptions) (cricinfo.NormalizedResult, error) {
+	return f.phasesResult, nil
+}
+
 func (f *fakeMatchService) Innings(_ context.Context, query string, opts cricinfo.MatchInningsOptions) (cricinfo.NormalizedResult, error) {
 	f.inningsQueries = append(f.inningsQueries, query)
 	f.inningsOpts = append(f.inningsOpts, opts)
@@ -150,6 +155,12 @@ func TestMatchesCommandsRenderTextAndJSON(t *testing.T) {
 		detailsResult:   cricinfo.NewListResult(cricinfo.EntityDeliveryEvent, []any{delivery}),
 		playsResult:     cricinfo.NewListResult(cricinfo.EntityDeliveryEvent, []any{delivery}),
 		situationResult: cricinfo.NewDataResult(cricinfo.EntityMatchSituation, situation),
+		phasesResult: cricinfo.NewDataResult(cricinfo.EntityMatchPhases, cricinfo.MatchPhases{
+			MatchID: "1529474",
+			Innings: []cricinfo.MatchPhaseInning{
+				{TeamName: "BOOST", InningsNumber: 1, Period: 3, Score: "69/2 (19 ov)"},
+			},
+		}),
 		inningsResult: cricinfo.NewListResult(cricinfo.EntityInnings, []any{
 			cricinfo.Innings{
 				TeamName:      "BOOST",

package/internal/cricinfo/analysis.go

@@ -467,54 +467,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++
+				}
 			}
 		}
 	}
@@ -559,6 +567,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)
@@ -1191,7 +1326,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 +1345,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 +1408,35 @@ 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 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/historical_hydration.go

@@ -6,6 +6,7 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -133,6 +134,8 @@ type HistoricalScopeSession struct {
 	partnershipWarnByMatch map[string][]string
 
 	metrics HydrationMetrics
+
+	resolveMu sync.Mutex
 }
 
 func newHistoricalScopeSession(client *Client, resolver *Resolver, opts HistoricalScopeOptions) *HistoricalScopeSession {
@@ -292,52 +295,78 @@ func (s *HistoricalScopeSession) HydratePlayerMatchSummaries(ctx context.Context
 			continue
 		}
 
-		for _, entry := range entries {
-			playerID := strings.TrimSpace(entry.PlayerID)
-			if playerID == "" {
-				continue
-			}
-			if strings.TrimSpace(entry.DisplayName) == "" && s.resolver != nil {
-				_ = s.resolver.seedPlayerByID(ctx, playerID, match.LeagueID, match.ID)
-			}
-			entry = s.enrichRosterEntryFromIndex(entry)
+		type playerHydrationResult struct {
+			item    *PlayerMatch
+			warning string
+		}
+		results := make([]playerHydrationResult, len(entries))
+		sem := make(chan struct{}, detailSubresourceFetchConcurrency)
+		var wg sync.WaitGroup
+		for i, entry := range entries {
+			wg.Add(1)
+			go func(index int, entry TeamRosterEntry, team Team) {
+				defer wg.Done()
+				sem <- struct{}{}
+				defer func() { <-sem }()
 
-			statsRef := rosterPlayerStatisticsRef(match, team, entry)
-			if statsRef == "" {
-				warnings = append(warnings, fmt.Sprintf("player %s has no match statistics route", playerID))
-				continue
-			}
+				playerID := strings.TrimSpace(entry.PlayerID)
+				if playerID == "" {
+					return
+				}
+				if strings.TrimSpace(entry.DisplayName) == "" && s.resolver != nil {
+					_ = s.resolver.seedPlayerByID(ctx, playerID, match.LeagueID, match.ID)
+				}
+				entry = s.enrichRosterEntryFromIndex(entry)
 
-			statsDoc, err := s.resolve(ctx, statsRef)
-			if err != nil {
-				warnings = append(warnings, fmt.Sprintf("player statistics %s: %v", statsRef, err))
-				continue
-			}
+				statsRef := rosterPlayerStatisticsRef(match, team, entry)
+				if statsRef == "" {
+					results[index] = playerHydrationResult{warning: fmt.Sprintf("player %s has no match statistics route", playerID)}
+					return
+				}
 
-			categories, err := NormalizeStatCategories(statsDoc.Body)
-			if err != nil {
-				warnings = append(warnings, fmt.Sprintf("player statistics %s: %v", statsDoc.CanonicalRef, err))
+				statsDoc, err := s.resolve(ctx, statsRef)
+				if err != nil {
+					results[index] = playerHydrationResult{warning: fmt.Sprintf("player statistics %s: %v", statsRef, err)}
+					return
+				}
+
+				categories, err := NormalizeStatCategories(statsDoc.Body)
+				if err != nil {
+					results[index] = playerHydrationResult{warning: fmt.Sprintf("player statistics %s: %v", statsDoc.CanonicalRef, err)}
+					return
+				}
+
+				batting, bowling, fielding := splitPlayerStatCategories(categories)
+				playerMatch := PlayerMatch{
+					PlayerID:      playerID,
+					PlayerRef:     entry.PlayerRef,
+					PlayerName:    nonEmpty(entry.DisplayName, "Unknown Player"),
+					MatchID:       match.ID,
+					CompetitionID: nonEmpty(match.CompetitionID, match.ID),
+					EventID:       match.EventID,
+					LeagueID:      match.LeagueID,
+					TeamID:        team.ID,
+					TeamName:      nonEmpty(team.ShortName, team.Name, "Unknown Team"),
+					StatisticsRef: statsDoc.CanonicalRef,
+					LinescoresRef: rosterPlayerLinescoresRef(match, team, entry),
+					Batting:       batting,
+					Bowling:       bowling,
+					Fielding:      fielding,
+					Summary:       summarizePlayerMatchCategories(categories),
+				}
+				results[index] = playerHydrationResult{item: &playerMatch}
+			}(i, entry, team)
+		}
+		wg.Wait()
+
+		for _, result := range results {
+			if strings.TrimSpace(result.warning) != "" {
+				warnings = append(warnings, result.warning)
 				continue
 			}
-
-			batting, bowling, fielding := splitPlayerStatCategories(categories)
-			items = append(items, PlayerMatch{
-				PlayerID:      playerID,
-				PlayerRef:     entry.PlayerRef,
-				PlayerName:    nonEmpty(entry.DisplayName, "Unknown Player"),
-				MatchID:       match.ID,
-				CompetitionID: nonEmpty(match.CompetitionID, match.ID),
-				EventID:       match.EventID,
-				LeagueID:      match.LeagueID,
-				TeamID:        team.ID,
-				TeamName:      nonEmpty(team.ShortName, team.Name, "Unknown Team"),
-				StatisticsRef: statsDoc.CanonicalRef,
-				LinescoresRef: rosterPlayerLinescoresRef(match, team, entry),
-				Batting:       batting,
-				Bowling:       bowling,
-				Fielding:      fielding,
-				Summary:       summarizePlayerMatchCategories(categories),
-			})
+			if result.item != nil {
+				items = append(items, *result.item)
+			}
 		}
 	}
 
@@ -1397,23 +1426,34 @@ func (s *HistoricalScopeSession) resolve(ctx context.Context, ref string) (*Reso
 		return nil, fmt.Errorf("ref is empty")
 	}
 
+	s.resolveMu.Lock()
 	if cached, ok := s.resolvedDocs[ref]; ok {
 		s.metrics.ResolveCacheHits++
+		s.resolveMu.Unlock()
 		return cached, nil
 	}
+	s.resolveMu.Unlock()
 
 	resolved, err := s.client.ResolveRefChain(ctx, ref)
 	if err != nil {
 		return nil, err
 	}
-	s.metrics.ResolveCacheMisses++
 
 	copied := *resolved
 	pointer := &copied
 	keys := compactWarnings([]string{ref, copied.RequestedRef, copied.CanonicalRef})
+
+	s.resolveMu.Lock()
+	if cached, ok := s.resolvedDocs[ref]; ok {
+		s.metrics.ResolveCacheHits++
+		s.resolveMu.Unlock()
+		return cached, nil
+	}
+	s.metrics.ResolveCacheMisses++
 	for _, key := range keys {
 		s.resolvedDocs[key] = pointer
 	}
+	s.resolveMu.Unlock()
 	return pointer, nil
 }