cricinfo-cli-go 0.1.0 → 0.1.2

package/internal/cricinfo/matches.go

@@ -5,13 +5,20 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"sort"
 	"strconv"
 	"strings"
 	"sync"
+	"time"
 )
 
 const defaultMatchListLimit = 20
-const deliveryFetchConcurrency = 12
+const deliveryFetchConcurrency = 96
+const detailSubresourceFetchConcurrency = 24
+const detailItemFetchTimeout = 3 * time.Second
+const matchTeamQueryScanRange = 6
+const maxTeamQueryEventCandidates = 36
+const teamQueryEventFetchTimeout = 1500 * time.Millisecond
 
 // MatchServiceConfig configures match discovery and lookup behavior.
 type MatchServiceConfig struct {
@@ -21,7 +28,8 @@ type MatchServiceConfig struct {
 
 // MatchListOptions controls list/live traversal behavior.
 type MatchListOptions struct {
-	Limit int
+	Limit    int
+	LeagueID string
 }
 
 // MatchLookupOptions controls resolver-backed single match lookup.
@@ -225,6 +233,151 @@ func (s *MatchService) Situation(ctx context.Context, query string, opts MatchLo
 	return result, nil
 }
 
+// Phases resolves and returns fan-oriented innings phase splits (powerplay/middle/death).
+func (s *MatchService) Phases(ctx context.Context, query string, opts MatchLookupOptions) (NormalizedResult, error) {
+	lookup, passthrough := s.resolveMatchLookup(ctx, query, opts)
+	if passthrough != nil {
+		passthrough.Kind = EntityMatchPhases
+		return *passthrough, nil
+	}
+
+	statusCache := map[string]matchStatusSnapshot{}
+	teamCache := map[string]teamIdentity{}
+	scoreCache := map[string]string{}
+	warnings := append([]string{}, lookup.warnings...)
+	warnings = append(warnings, s.hydrateMatch(ctx, lookup.match, statusCache, teamCache, scoreCache)...)
+
+	teams, teamWarnings, teamResult := s.selectTeamsFromMatch(ctx, *lookup.match, "", opts.LeagueID)
+	if teamResult != nil {
+		teamResult.Kind = EntityMatchPhases
+		return *teamResult, nil
+	}
+	warnings = append(warnings, teamWarnings...)
+
+	report := MatchPhases{
+		MatchID:       lookup.match.ID,
+		LeagueID:      lookup.match.LeagueID,
+		EventID:       lookup.match.EventID,
+		CompetitionID: nonEmpty(lookup.match.CompetitionID, lookup.match.ID),
+		Fixture:       nonEmpty(lookup.match.ShortDescription, lookup.match.Description),
+		Result:        nonEmpty(lookup.match.MatchState, lookup.match.Note),
+		Innings:       make([]MatchPhaseInning, 0),
+	}
+
+	for _, team := range teams {
+		inningsList, _, inningsWarnings := s.fetchTeamInnings(ctx, *lookup.match, team)
+		warnings = append(warnings, inningsWarnings...)
+		for i := range inningsList {
+			innings := inningsList[i]
+			statsWarnings := s.hydrateInningsTimelines(ctx, &innings)
+			warnings = append(warnings, statsWarnings...)
+			if !isMeaningfulPhaseInnings(innings) {
+				continue
+			}
+
+			phaseInnings := buildPhaseInnings(team, innings)
+			if !phaseInningsHasData(phaseInnings) {
+				continue
+			}
+			report.Innings = append(report.Innings, phaseInnings)
+		}
+	}
+
+	result := NewDataResult(EntityMatchPhases, report)
+	if len(warnings) > 0 {
+		result = NewPartialResult(EntityMatchPhases, report, compactWarnings(warnings)...)
+	}
+	result.RequestedRef = lookup.resolved.RequestedRef
+	result.CanonicalRef = lookup.resolved.CanonicalRef
+	return result, nil
+}
+
+func isMeaningfulPhaseInnings(innings Innings) bool {
+	if strings.TrimSpace(innings.Score) != "" {
+		return true
+	}
+	if innings.Runs > 0 || innings.Wickets > 0 || innings.Target > 0 {
+		return true
+	}
+	return len(innings.OverTimeline) > 0 || len(innings.WicketTimeline) > 0
+}
+
+func buildPhaseInnings(team Team, innings Innings) MatchPhaseInning {
+	out := MatchPhaseInning{
+		TeamID:        nonEmpty(strings.TrimSpace(team.ID), strings.TrimSpace(innings.TeamID)),
+		TeamName:      nonEmpty(strings.TrimSpace(team.ShortName), strings.TrimSpace(team.Name), strings.TrimSpace(innings.TeamName), strings.TrimSpace(innings.TeamID)),
+		InningsNumber: innings.InningsNumber,
+		Period:        innings.Period,
+		Score:         innings.Score,
+		Target:        innings.Target,
+		Powerplay:     PhaseSummary{Name: "Powerplay"},
+		Middle:        PhaseSummary{Name: "Middle"},
+		Death:         PhaseSummary{Name: "Death"},
+	}
+
+	bestRuns := -1
+	for _, over := range innings.OverTimeline {
+		phase := phaseBucket(over.Number)
+		switch phase {
+		case "Powerplay":
+			accumulatePhase(&out.Powerplay, over)
+		case "Middle":
+			accumulatePhase(&out.Middle, over)
+		case "Death":
+			accumulatePhase(&out.Death, over)
+		}
+
+		if over.Runs > bestRuns {
+			bestRuns = over.Runs
+			out.BestScoringOver = over.Number
+			out.BestScoringOverRuns = over.Runs
+		}
+		if over.WicketCount > out.CollapseWickets {
+			out.CollapseWickets = over.WicketCount
+			out.CollapseOver = over.Number
+		}
+	}
+
+	finalizePhase(&out.Powerplay)
+	finalizePhase(&out.Middle)
+	finalizePhase(&out.Death)
+
+	return out
+}
+
+func phaseBucket(overNumber int) string {
+	switch {
+	case overNumber >= 1 && overNumber <= 6:
+		return "Powerplay"
+	case overNumber >= 7 && overNumber <= 15:
+		return "Middle"
+	case overNumber >= 16:
+		return "Death"
+	default:
+		return "Middle"
+	}
+}
+
+func accumulatePhase(phase *PhaseSummary, over InningsOver) {
+	if phase == nil {
+		return
+	}
+	phase.Runs += over.Runs
+	phase.Wickets += over.WicketCount
+	phase.Overs += 1
+}
+
+func finalizePhase(phase *PhaseSummary) {
+	if phase == nil || phase.Overs <= 0 {
+		return
+	}
+	phase.RunRate = float64(phase.Runs) / phase.Overs
+}
+
+func phaseInningsHasData(innings MatchPhaseInning) bool {
+	return innings.Powerplay.Overs > 0 || innings.Middle.Overs > 0 || innings.Death.Overs > 0
+}
+
 // Innings resolves and returns innings summaries with over and wicket timelines when period statistics are available.
 func (s *MatchService) Innings(ctx context.Context, query string, opts MatchInningsOptions) (NormalizedResult, error) {
 	lookup, passthrough := s.resolveMatchLookup(ctx, query, MatchLookupOptions{LeagueID: opts.LeagueID})
@@ -417,9 +570,14 @@ func (s *MatchService) Deliveries(ctx context.Context, query string, opts MatchI
 }
 
 func (s *MatchService) listFromEvents(ctx context.Context, opts MatchListOptions, liveOnly bool) (NormalizedResult, error) {
-	resolved, err := s.client.ResolveRefChain(ctx, "/events")
+	rootRef := "/events"
+	if leagueID := strings.TrimSpace(opts.LeagueID); leagueID != "" {
+		rootRef = "/leagues/" + leagueID + "/events"
+	}
+
+	resolved, err := s.client.ResolveRefChain(ctx, rootRef)
 	if err != nil {
-		return NewTransportErrorResult(EntityMatch, "/events", err), nil
+		return NewTransportErrorResult(EntityMatch, rootRef, err), nil
 	}
 
 	page, err := DecodePage[Ref](resolved.Body)
@@ -532,16 +690,24 @@ func (s *MatchService) resolveMatchLookup(ctx context.Context, query string, opt
 		result := NewTransportErrorResult(EntityMatch, query, err)
 		return nil, &result
 	}
-	if len(searchResult.Entities) == 0 {
-		result := NormalizedResult{
-			Kind:    EntityMatch,
-			Status:  ResultStatusEmpty,
-			Message: fmt.Sprintf("no matches found for %q", query),
+	warnings := append([]string{}, searchResult.Warnings...)
+	entity := IndexedEntity{}
+	if len(searchResult.Entities) > 0 {
+		entity = searchResult.Entities[0]
+	} else {
+		discovered, discoveryWarnings := s.discoverMatchByTeamQuery(ctx, query, strings.TrimSpace(opts.LeagueID))
+		warnings = append(warnings, discoveryWarnings...)
+		if discovered == nil {
+			result := NormalizedResult{
+				Kind:    EntityMatch,
+				Status:  ResultStatusEmpty,
+				Message: fmt.Sprintf("no matches found for %q", query),
+			}
+			return nil, &result
 		}
-		return nil, &result
+		entity = *discovered
 	}
 
-	entity := searchResult.Entities[0]
 	ref := buildMatchRef(entity)
 	if ref == "" {
 		result := NormalizedResult{
@@ -571,10 +737,322 @@ func (s *MatchService) resolveMatchLookup(ctx context.Context, query string, opt
 	return &matchLookup{
 		match:    match,
 		resolved: resolved,
-		warnings: searchResult.Warnings,
+		warnings: compactWarnings(warnings),
 	}, nil
 }
 
+func (s *MatchService) discoverMatchByTeamQuery(ctx context.Context, query, leagueID string) (*IndexedEntity, []string) {
+	left, right, ok := parseTeamVsQuery(query)
+	if !ok {
+		return nil, nil
+	}
+
+	preferredLeagueID := inferTeamQueryLeagueHint(left, right)
+	candidates, err := s.buildTeamQueryEventCandidates(ctx, leagueID, preferredLeagueID)
+	if err != nil {
+		return nil, []string{fmt.Sprintf("team-query fallback unavailable: %v", err)}
+	}
+	if len(candidates) == 0 {
+		return nil, []string{"team-query fallback found no event candidates"}
+	}
+
+	for _, eventID := range candidates {
+		reqCtx, cancel := context.WithTimeout(ctx, teamQueryEventFetchTimeout)
+		resolved, resolveErr := s.client.ResolveRefChain(reqCtx, "/events/"+eventID)
+		cancel()
+		if resolveErr != nil {
+			continue
+		}
+
+		payload, decodeErr := decodePayloadMap(resolved.Body)
+		if decodeErr != nil {
+			continue
+		}
+		if !eventMatchesTeamQuery(payload, left, right) {
+			continue
+		}
+
+		competitions := mapSliceField(payload, "competitions")
+		competitionID := ""
+		competitionRef := ""
+		if len(competitions) > 0 {
+			competitionID = stringField(competitions[0], "id")
+			competitionRef = stringField(competitions[0], "$ref")
+		}
+
+		competitionID = nonEmpty(competitionID, stringField(payload, "id"))
+		if competitionID == "" {
+			continue
+		}
+
+		refIDsMap := refIDs(nonEmpty(competitionRef, resolved.CanonicalRef, resolved.RequestedRef))
+		eventIDResolved := nonEmpty(stringField(payload, "id"), refIDsMap["eventId"])
+		leagueIDResolved := nonEmpty(refIDsMap["leagueId"], strings.TrimSpace(leagueID))
+		if competitionRef == "" && leagueIDResolved != "" && eventIDResolved != "" {
+			competitionRef = fmt.Sprintf("/leagues/%s/events/%s/competitions/%s", leagueIDResolved, eventIDResolved, competitionID)
+		}
+		if competitionRef == "" {
+			continue
+		}
+
+		entity := IndexedEntity{
+			Kind:      EntityMatch,
+			ID:        competitionID,
+			Ref:       competitionRef,
+			Name:      nonEmpty(stringField(payload, "name"), stringField(payload, "shortDescription"), stringField(payload, "description")),
+			ShortName: nonEmpty(stringField(payload, "shortName"), stringField(payload, "shortDescription")),
+			LeagueID:  leagueIDResolved,
+			EventID:   eventIDResolved,
+			MatchID:   competitionID,
+			Aliases: []string{
+				stringField(payload, "name"),
+				stringField(payload, "shortName"),
+				stringField(payload, "shortDescription"),
+				stringField(payload, "description"),
+				left,
+				right,
+				competitionID,
+				eventIDResolved,
+			},
+			UpdatedAt: time.Now().UTC(),
+		}
+		if s.resolver != nil && s.resolver.index != nil {
+			_ = s.resolver.index.Upsert(entity)
+		}
+		return &entity, []string{fmt.Sprintf("team-query fallback matched event %s", eventIDResolved)}
+	}
+
+	return nil, []string{"team-query fallback scanned recent events with no match"}
+}
+
+func (s *MatchService) buildTeamQueryEventCandidates(ctx context.Context, leagueID, preferredLeagueID string) ([]string, error) {
+	rootRef := "/events"
+	if strings.TrimSpace(leagueID) != "" {
+		rootRef = "/leagues/" + strings.TrimSpace(leagueID) + "/events"
+	}
+
+	seedRefs := make([]Ref, 0)
+	if refs, err := s.fetchEventRefs(ctx, rootRef); err == nil {
+		seedRefs = append(seedRefs, refs...)
+	}
+	if len(seedRefs) == 0 && rootRef != "/events" {
+		refs, err := s.fetchEventRefs(ctx, "/events")
+		if err != nil {
+			return nil, err
+		}
+		seedRefs = append(seedRefs, refs...)
+	}
+
+	seen := map[string]struct{}{}
+	candidates := make([]string, 0, maxTeamQueryEventCandidates)
+	type eventSeed struct {
+		id       int
+		leagueID string
+	}
+	seeds := make([]eventSeed, 0, len(seedRefs))
+	for _, item := range seedRefs {
+		ids := refIDs(item.URL)
+		eventID := strings.TrimSpace(ids["eventId"])
+		if eventID == "" {
+			continue
+		}
+
+		seed, err := strconv.Atoi(eventID)
+		if err != nil {
+			continue
+		}
+		seeds = append(seeds, eventSeed{id: seed, leagueID: strings.TrimSpace(ids["leagueId"])})
+	}
+
+	sort.Slice(seeds, func(i, j int) bool {
+		iPref := strings.TrimSpace(preferredLeagueID) != "" && seeds[i].leagueID == strings.TrimSpace(preferredLeagueID)
+		jPref := strings.TrimSpace(preferredLeagueID) != "" && seeds[j].leagueID == strings.TrimSpace(preferredLeagueID)
+		if iPref != jPref {
+			return iPref
+		}
+		return seeds[i].id > seeds[j].id
+	})
+
+	for delta := 0; delta <= matchTeamQueryScanRange; delta++ {
+		for _, seed := range seeds {
+			down := strconv.Itoa(seed.id - delta)
+			if _, ok := seen[down]; !ok {
+				seen[down] = struct{}{}
+				candidates = append(candidates, down)
+				if len(candidates) >= maxTeamQueryEventCandidates {
+					return candidates, nil
+				}
+			}
+
+			if delta == 0 {
+				continue
+			}
+			up := strconv.Itoa(seed.id + delta)
+			if _, ok := seen[up]; !ok {
+				seen[up] = struct{}{}
+				candidates = append(candidates, up)
+				if len(candidates) >= maxTeamQueryEventCandidates {
+					return candidates, nil
+				}
+			}
+		}
+	}
+
+	return candidates, nil
+}
+
+func (s *MatchService) fetchEventRefs(ctx context.Context, ref string) ([]Ref, error) {
+	resolved, err := s.client.ResolveRefChain(ctx, ref)
+	if err != nil {
+		return nil, err
+	}
+	page, err := DecodePage[Ref](resolved.Body)
+	if err != nil {
+		return nil, err
+	}
+	return page.Items, nil
+}
+
+func parseTeamVsQuery(query string) (string, string, bool) {
+	normalized := normalizeAlias(query)
+	if normalized == "" {
+		return "", "", false
+	}
+
+	separators := []string{" versus ", " vs ", " v "}
+	for _, sep := range separators {
+		parts := strings.SplitN(normalized, sep, 2)
+		if len(parts) != 2 {
+			continue
+		}
+		left := strings.TrimSpace(parts[0])
+		right := strings.TrimSpace(parts[1])
+		if left == "" || right == "" {
+			return "", "", false
+		}
+		return left, right, true
+	}
+	return "", "", false
+}
+
+func eventMatchesTeamQuery(payload map[string]any, left, right string) bool {
+	parts := []string{
+		stringField(payload, "name"),
+		stringField(payload, "shortName"),
+		stringField(payload, "shortDescription"),
+		stringField(payload, "description"),
+	}
+	for _, competition := range mapSliceField(payload, "competitions") {
+		parts = append(parts,
+			stringField(competition, "name"),
+			stringField(competition, "shortName"),
+			stringField(competition, "shortDescription"),
+			stringField(competition, "description"),
+			stringField(competition, "note"),
+		)
+	}
+
+	haystack := normalizeAlias(strings.Join(parts, " "))
+	return teamQuerySideMatches(haystack, left) && teamQuerySideMatches(haystack, right)
+}
+
+func teamQuerySideMatches(haystack, side string) bool {
+	if haystack == "" {
+		return false
+	}
+	for _, variant := range teamQueryVariants(side) {
+		if variant != "" && strings.Contains(haystack, variant) {
+			return true
+		}
+	}
+	return false
+}
+
+func teamQueryVariants(side string) []string {
+	base := normalizeAlias(side)
+	if base == "" {
+		return nil
+	}
+
+	seen := map[string]struct{}{base: {}}
+	variants := []string{base}
+
+	add := func(value string) {
+		value = normalizeAlias(value)
+		if value == "" {
+			return
+		}
+		if _, ok := seen[value]; ok {
+			return
+		}
+		seen[value] = struct{}{}
+		variants = append(variants, value)
+	}
+
+	if strings.Contains(base, "bangalore") {
+		add(strings.ReplaceAll(base, "bangalore", "bengaluru"))
+	}
+	if strings.Contains(base, "bengaluru") {
+		add(strings.ReplaceAll(base, "bengaluru", "bangalore"))
+	}
+
+	for _, alias := range knownIPLTeamAliases[base] {
+		add(alias)
+	}
+
+	return variants
+}
+
+func inferTeamQueryLeagueHint(left, right string) string {
+	left = normalizeAlias(left)
+	right = normalizeAlias(right)
+	if left == "" || right == "" {
+		return ""
+	}
+	_, leftKnown := knownIPLTeamAliases[left]
+	_, rightKnown := knownIPLTeamAliases[right]
+	if leftKnown && rightKnown {
+		return "8048"
+	}
+	return ""
+}
+
+var knownIPLTeamAliases = map[string][]string{
+	"csk":                         {"chennai super kings", "chennai"},
+	"chennai super kings":         {"csk", "chennai"},
+	"chennai":                     {"csk", "chennai super kings"},
+	"dc":                          {"delhi capitals", "delhi"},
+	"delhi capitals":              {"dc", "delhi"},
+	"delhi":                       {"dc", "delhi capitals"},
+	"gt":                          {"gujarat titans", "gujarat"},
+	"gujarat titans":              {"gt", "gujarat"},
+	"gujarat":                     {"gt", "gujarat titans"},
+	"kkr":                         {"kolkata knight riders", "kolkata"},
+	"kolkata knight riders":       {"kkr", "kolkata"},
+	"kolkata":                     {"kkr", "kolkata knight riders"},
+	"lsg":                         {"lucknow super giants", "lucknow"},
+	"lucknow super giants":        {"lsg", "lucknow"},
+	"lucknow":                     {"lsg", "lucknow super giants"},
+	"mi":                          {"mumbai indians", "mumbai"},
+	"mumbai indians":              {"mi", "mumbai"},
+	"mumbai":                      {"mi", "mumbai indians"},
+	"pbks":                        {"punjab kings", "punjab"},
+	"punjab kings":                {"pbks", "punjab", "kxip"},
+	"punjab":                      {"pbks", "punjab kings", "kxip"},
+	"kxip":                        {"pbks", "punjab kings", "punjab"},
+	"rcb":                         {"royal challengers bengaluru", "royal challengers bangalore", "bangalore", "bengaluru"},
+	"royal challengers bengaluru": {"rcb", "royal challengers bangalore", "bangalore", "bengaluru"},
+	"royal challengers bangalore": {"rcb", "royal challengers bengaluru", "bangalore", "bengaluru"},
+	"bangalore":                   {"rcb", "royal challengers bengaluru", "royal challengers bangalore", "bengaluru"},
+	"bengaluru":                   {"rcb", "royal challengers bengaluru", "royal challengers bangalore", "bangalore"},
+	"rr":                          {"rajasthan royals", "rajasthan"},
+	"rajasthan royals":            {"rr", "rajasthan"},
+	"rajasthan":                   {"rr", "rajasthan royals"},
+	"srh":                         {"sunrisers hyderabad", "hyderabad"},
+	"sunrisers hyderabad":         {"srh", "hyderabad"},
+	"hyderabad":                   {"srh", "sunrisers hyderabad"},
+}
+
 func (s *MatchService) deliveryEventsFromRoute(ctx context.Context, ref string, baseWarnings []string) (NormalizedResult, error) {
 	resolved, err := s.resolveRefChainResilient(ctx, ref)
 	if err != nil {
@@ -628,7 +1106,9 @@ func (s *MatchService) loadDeliveryEvents(ctx context.Context, refs []Ref) ([]De
 				return
 			}
 
-			itemResolved, itemErr := s.resolveRefChainResilient(ctx, itemRef)
+			itemCtx, cancel := context.WithTimeout(ctx, detailItemFetchTimeout)
+			itemResolved, itemErr := s.resolveRefChainResilient(itemCtx, itemRef)
+			cancel()
 			if itemErr != nil {
 				results[index] = deliveryLoadResult{index: index, warning: fmt.Sprintf("detail %s: %v", itemRef, itemErr)}
 				return
@@ -962,26 +1442,55 @@ func (s *MatchService) fetchDetailedRefCollection(
 		return nil, nil, nil, err
 	}
 
-	items := make([]any, 0, len(pageItems))
-	for _, item := range pageItems {
-		itemRef := strings.TrimSpace(item.URL)
-		if itemRef == "" {
-			warnings = append(warnings, "skip item with empty ref")
-			continue
-		}
+	type normalizedItemResult struct {
+		index   int
+		item    any
+		warning string
+	}
 
-		itemResolved, itemErr := s.resolveRefChainResilient(ctx, itemRef)
-		if itemErr != nil {
-			warnings = append(warnings, fmt.Sprintf("item %s: %v", itemRef, itemErr))
-			continue
-		}
+	results := make([]normalizedItemResult, len(pageItems))
+	sem := make(chan struct{}, detailSubresourceFetchConcurrency)
+	var wg sync.WaitGroup
+	for i, item := range pageItems {
+		wg.Add(1)
+		go func(index int, item Ref) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			itemRef := strings.TrimSpace(item.URL)
+			if itemRef == "" {
+				results[index] = normalizedItemResult{index: index, warning: "skip item with empty ref"}
+				return
+			}
+
+			itemCtx, cancel := context.WithTimeout(ctx, detailItemFetchTimeout)
+			itemResolved, itemErr := s.resolveRefChainResilient(itemCtx, itemRef)
+			cancel()
+			if itemErr != nil {
+				results[index] = normalizedItemResult{index: index, warning: fmt.Sprintf("item %s: %v", itemRef, itemErr)}
+				return
+			}
+
+			normalized, normalizeErr := normalize(itemResolved.Body)
+			if normalizeErr != nil {
+				results[index] = normalizedItemResult{index: index, warning: fmt.Sprintf("item %s: %v", itemRef, normalizeErr)}
+				return
+			}
+			results[index] = normalizedItemResult{index: index, item: normalized}
+		}(i, item)
+	}
+	wg.Wait()
 
-		normalized, normalizeErr := normalize(itemResolved.Body)
-		if normalizeErr != nil {
-			warnings = append(warnings, fmt.Sprintf("item %s: %v", itemRef, normalizeErr))
+	items := make([]any, 0, len(results))
+	for _, result := range results {
+		if strings.TrimSpace(result.warning) != "" {
+			warnings = append(warnings, result.warning)
 			continue
 		}
-		items = append(items, normalized)
+		if result.item != nil {
+			items = append(items, result.item)
+		}
 	}
 
 	return resolved, items, compactWarnings(warnings), nil
@@ -1001,25 +1510,55 @@ func (s *MatchService) resolvePageRefs(ctx context.Context, first *ResolvedDocum
 		return items, nil, nil
 	}
 
-	warnings := make([]string, 0)
+	type pageLoadResult struct {
+		page    int
+		items   []Ref
+		warning string
+	}
+
+	results := make([]pageLoadResult, page.PageCount+1)
+	sem := make(chan struct{}, detailSubresourceFetchConcurrency)
+	var wg sync.WaitGroup
 	baseRef := firstNonEmptyString(first.CanonicalRef, first.RequestedRef)
 	for pageIndex := 2; pageIndex <= page.PageCount; pageIndex++ {
-		pageRef := pagedRef(baseRef, pageIndex)
-		if pageRef == "" {
-			warnings = append(warnings, fmt.Sprintf("page %d unavailable for %s", pageIndex, baseRef))
-			continue
-		}
-		pageDoc, pageErr := s.resolveRefChainResilient(ctx, pageRef)
-		if pageErr != nil {
-			warnings = append(warnings, fmt.Sprintf("page %d %s: %v", pageIndex, pageRef, pageErr))
+		wg.Add(1)
+		go func(index int) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			pageRef := pagedRef(baseRef, index)
+			if pageRef == "" {
+				results[index] = pageLoadResult{page: index, warning: fmt.Sprintf("page %d unavailable for %s", index, baseRef)}
+				return
+			}
+
+			pageDoc, pageErr := s.resolveRefChainResilient(ctx, pageRef)
+			if pageErr != nil {
+				results[index] = pageLoadResult{page: index, warning: fmt.Sprintf("page %d %s: %v", index, pageRef, pageErr)}
+				return
+			}
+
+			nextPage, decodeErr := DecodePage[Ref](pageDoc.Body)
+			if decodeErr != nil {
+				results[index] = pageLoadResult{page: index, warning: fmt.Sprintf("page %d %s: %v", index, pageDoc.CanonicalRef, decodeErr)}
+				return
+			}
+			results[index] = pageLoadResult{page: index, items: nextPage.Items}
+		}(pageIndex)
+	}
+	wg.Wait()
+
+	warnings := make([]string, 0)
+	for pageIndex := 2; pageIndex <= page.PageCount; pageIndex++ {
+		result := results[pageIndex]
+		if strings.TrimSpace(result.warning) != "" {
+			warnings = append(warnings, result.warning)
 			continue
 		}
-		nextPage, decodeErr := DecodePage[Ref](pageDoc.Body)
-		if decodeErr != nil {
-			warnings = append(warnings, fmt.Sprintf("page %d %s: %v", pageIndex, pageDoc.CanonicalRef, decodeErr))
-			continue
+		if len(result.items) > 0 {
+			items = append(items, result.items...)
 		}
-		items = append(items, nextPage.Items...)
 	}
 
 	return items, compactWarnings(warnings), nil