cricinfo-cli-go 0.1.2 → 0.1.4

package/internal/cricinfo/matches.go

@@ -13,9 +13,16 @@ import (
 )
 
 const defaultMatchListLimit = 20
+const matchListEventFetchConcurrency = 3
+const matchListStatusFetchConcurrency = 3
+const matchListEventFetchTimeout = 4500 * time.Millisecond
+const matchListStatusFetchTimeout = 4 * time.Second
+const matchLineupRosterFetchConcurrency = 2
+const matchLineupRosterFetchTimeout = 5 * time.Second
 const deliveryFetchConcurrency = 96
 const detailSubresourceFetchConcurrency = 24
 const detailItemFetchTimeout = 3 * time.Second
+const liveViewRecentDeliveryFetchCount = 60
 const matchTeamQueryScanRange = 6
 const maxTeamQueryEventCandidates = 36
 const teamQueryEventFetchTimeout = 1500 * time.Millisecond
@@ -45,6 +52,13 @@ type MatchInningsOptions struct {
 	Period    int
 }
 
+// MatchDuelOptions controls batter-vs-bowler matchup lookup behavior.
+type MatchDuelOptions struct {
+	LeagueID    string
+	BatterQuery string
+	BowlerQuery string
+}
+
 // MatchService implements domain-level match discovery and lookup commands.
 type MatchService struct {
 	client       *Client
@@ -99,6 +113,124 @@ func (s *MatchService) Live(ctx context.Context, opts MatchListOptions) (Normali
 	return s.listFromEvents(ctx, opts, true)
 }
 
+// Lineups resolves one match and returns match-scoped roster entries for both teams.
+func (s *MatchService) Lineups(ctx context.Context, query string, opts MatchLookupOptions) (NormalizedResult, error) {
+	lookup, passthrough := s.resolveMatchLookup(ctx, query, opts)
+	if passthrough != nil {
+		passthrough.Kind = EntityTeamRoster
+		return *passthrough, nil
+	}
+
+	if len(lookup.match.Teams) == 0 {
+		return NormalizedResult{
+			Kind:    EntityTeamRoster,
+			Status:  ResultStatusEmpty,
+			Message: fmt.Sprintf("no teams found for match %q", lookup.match.ID),
+		}, nil
+	}
+
+	type lineupLoadResult struct {
+		entries []TeamRosterEntry
+		warns   []string
+	}
+
+	results := make([]lineupLoadResult, len(lookup.match.Teams))
+	sem := make(chan struct{}, matchLineupRosterFetchConcurrency)
+	var wg sync.WaitGroup
+	teamCache := map[string]teamIdentity{}
+
+	teamService := &TeamService{
+		client:   s.client,
+		resolver: s.resolver,
+	}
+
+	for i := range lookup.match.Teams {
+		team := lookup.match.Teams[i]
+		teamID := strings.TrimSpace(team.ID)
+		if teamID == "" {
+			teamID = strings.TrimSpace(refIDs(team.Ref)["teamId"])
+		}
+		if teamID == "" {
+			teamID = strings.TrimSpace(refIDs(team.Ref)["competitorId"])
+		}
+		if teamID == "" {
+			results[i].warns = []string{fmt.Sprintf("skip team with missing id/ref in match %q", lookup.match.ID)}
+			continue
+		}
+		team.ID = teamID
+		if strings.TrimSpace(team.Name) == "" || strings.TrimSpace(team.ShortName) == "" {
+			identity, err := s.fetchTeamIdentity(ctx, &team, teamCache)
+			if err != nil {
+				results[i].warns = append(results[i].warns, fmt.Sprintf("team %s: %v", nonEmpty(team.Ref, team.ID), err))
+			} else {
+				team.Name = nonEmpty(team.Name, identity.name)
+				team.ShortName = nonEmpty(team.ShortName, identity.shortName)
+			}
+		}
+
+		wg.Add(1)
+		go func(index int, team Team) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			rosterRef := nonEmpty(strings.TrimSpace(team.RosterRef), competitorSubresourceRef(*lookup.match, team.ID, "roster"))
+			if rosterRef == "" {
+				results[index].warns = []string{fmt.Sprintf("roster route unavailable for team %q", team.ID)}
+				return
+			}
+
+			reqCtx, cancel := context.WithTimeout(ctx, matchLineupRosterFetchTimeout)
+			resolved, err := s.client.ResolveRefChain(reqCtx, rosterRef)
+			cancel()
+			if err != nil {
+				results[index].warns = []string{fmt.Sprintf("roster %s: %v", rosterRef, err)}
+				return
+			}
+
+			entries, err := NormalizeTeamRosterEntries(resolved.Body, team, TeamScopeMatch, lookup.match.ID)
+			if err != nil {
+				results[index].warns = []string{fmt.Sprintf("roster %s: %v", resolved.CanonicalRef, err)}
+				return
+			}
+
+			for i := range entries {
+				entries[i].TeamName = nonEmpty(entries[i].TeamName, team.ShortName, team.Name, team.ID)
+			}
+
+			reqCtx, cancel = context.WithTimeout(ctx, matchLineupRosterFetchTimeout)
+			hydrateWarnings := teamService.enrichRosterEntries(reqCtx, entries)
+			cancel()
+			results[index] = lineupLoadResult{
+				entries: entries,
+				warns:   hydrateWarnings,
+			}
+		}(i, team)
+	}
+
+	wg.Wait()
+
+	warnings := append([]string{}, lookup.warnings...)
+	items := make([]any, 0)
+	for i := range results {
+		warnings = append(warnings, results[i].warns...)
+		for _, entry := range results[i].entries {
+			items = append(items, entry)
+		}
+	}
+
+	result := NewListResult(EntityTeamRoster, items)
+	if len(warnings) > 0 {
+		result = NewPartialListResult(EntityTeamRoster, items, compactWarnings(warnings)...)
+	}
+	result.RequestedRef = lookup.resolved.RequestedRef
+	result.CanonicalRef = lookup.resolved.CanonicalRef
+	if len(items) == 0 && strings.TrimSpace(result.Message) == "" {
+		result.Message = "no lineup entries found for this match"
+	}
+	return result, nil
+}
+
 // Show resolves and returns one match with normalized summary fields.
 func (s *MatchService) Show(ctx context.Context, query string, opts MatchLookupOptions) (NormalizedResult, error) {
 	return s.lookupMatch(ctx, query, opts, false)
@@ -116,6 +248,10 @@ func (s *MatchService) Scorecard(ctx context.Context, query string, opts MatchLo
 		passthrough.Kind = EntityMatchScorecard
 		return *passthrough, nil
 	}
+	statusCache := map[string]matchStatusSnapshot{}
+	teamCache := map[string]teamIdentity{}
+	scoreCache := map[string]string{}
+	hydrationWarnings := s.hydrateMatch(ctx, lookup.match, statusCache, teamCache, scoreCache)
 
 	scorecardRef := matchSubresourceRef(*lookup.match, "matchcards", "matchcards")
 	if scorecardRef == "" {
@@ -126,8 +262,26 @@ func (s *MatchService) Scorecard(ctx context.Context, query string, opts MatchLo
 		}, nil
 	}
 
-	resolved, err := s.client.ResolveRefChain(ctx, scorecardRef)
+	resolved, err := s.resolveRefChainResilient(ctx, scorecardRef)
 	if err != nil {
+		if live, liveWarnings := s.buildLiveView(ctx, *lookup.match); live != nil {
+			scorecard := &MatchScorecard{
+				Ref:           scorecardRef,
+				LeagueID:      lookup.match.LeagueID,
+				EventID:       lookup.match.EventID,
+				CompetitionID: lookup.match.CompetitionID,
+				MatchID:       lookup.match.ID,
+			}
+			augmentScorecardFromLive(scorecard, live)
+			warnings := append([]string{}, lookup.warnings...)
+			warnings = append(warnings, hydrationWarnings...)
+			warnings = append(warnings, liveWarnings...)
+			warnings = append(warnings, fmt.Sprintf("scorecard fallback used after %v", err))
+			result := NewPartialResult(EntityMatchScorecard, scorecard, warnings...)
+			result.RequestedRef = scorecardRef
+			result.CanonicalRef = scorecardRef
+			return result, nil
+		}
 		return NewTransportErrorResult(EntityMatchScorecard, scorecardRef, err), nil
 	}
 
@@ -135,8 +289,17 @@ func (s *MatchService) Scorecard(ctx context.Context, query string, opts MatchLo
 	if err != nil {
 		return NormalizedResult{}, fmt.Errorf("normalize matchcards %q: %w", resolved.CanonicalRef, err)
 	}
+	enrichmentWarnings := []string{}
+	if len(scorecard.BattingCards) == 0 || len(scorecard.BowlingCards) == 0 {
+		if live, warns := s.buildLiveView(ctx, *lookup.match); live != nil {
+			enrichmentWarnings = append(enrichmentWarnings, warns...)
+			augmentScorecardFromLive(scorecard, live)
+		}
+	}
 
 	warnings := append([]string{}, lookup.warnings...)
+	warnings = append(warnings, hydrationWarnings...)
+	warnings = append(warnings, enrichmentWarnings...)
 	result := NewDataResult(EntityMatchScorecard, scorecard)
 	if len(warnings) > 0 {
 		result = NewPartialResult(EntityMatchScorecard, scorecard, warnings...)
@@ -163,7 +326,23 @@ func (s *MatchService) Details(ctx context.Context, query string, opts MatchLook
 		}, nil
 	}
 
-	return s.deliveryEventsFromRoute(ctx, detailsRef, lookup.warnings)
+	events, warnings, err := s.deliveryEventsForMatchRefs(ctx, detailsRef, matchSubresourceRef(*lookup.match, "plays", "plays"))
+	if err != nil {
+		return NewTransportErrorResult(EntityDeliveryEvent, detailsRef, err), nil
+	}
+	warnings = append(lookup.warnings, warnings...)
+
+	items := make([]any, 0, len(events))
+	for _, delivery := range events {
+		items = append(items, delivery)
+	}
+	result := NewListResult(EntityDeliveryEvent, items)
+	if len(warnings) > 0 {
+		result = NewPartialListResult(EntityDeliveryEvent, items, warnings...)
+	}
+	result.RequestedRef = detailsRef
+	result.CanonicalRef = detailsRef
+	return result, nil
 }
 
 // Plays resolves and returns normalized delivery events from the plays route.
@@ -183,7 +362,23 @@ func (s *MatchService) Plays(ctx context.Context, query string, opts MatchLookup
 		}, nil
 	}
 
-	return s.deliveryEventsFromRoute(ctx, playsRef, lookup.warnings)
+	events, warnings, err := s.deliveryEventsForMatchRefs(ctx, playsRef, nonEmpty(strings.TrimSpace(lookup.match.DetailsRef), matchSubresourceRef(*lookup.match, "details", "details")))
+	if err != nil {
+		return NewTransportErrorResult(EntityDeliveryEvent, playsRef, err), nil
+	}
+	warnings = append(lookup.warnings, warnings...)
+
+	items := make([]any, 0, len(events))
+	for _, delivery := range events {
+		items = append(items, delivery)
+	}
+	result := NewListResult(EntityDeliveryEvent, items)
+	if len(warnings) > 0 {
+		result = NewPartialListResult(EntityDeliveryEvent, items, warnings...)
+	}
+	result.RequestedRef = playsRef
+	result.CanonicalRef = playsRef
+	return result, nil
 }
 
 // Situation resolves and returns normalized match situation data.
@@ -194,6 +389,11 @@ func (s *MatchService) Situation(ctx context.Context, query string, opts MatchLo
 		return *passthrough, nil
 	}
 
+	statusCache := map[string]matchStatusSnapshot{}
+	teamCache := map[string]teamIdentity{}
+	scoreCache := map[string]string{}
+	hydrationWarnings := s.hydrateMatch(ctx, lookup.match, statusCache, teamCache, scoreCache)
+
 	situationRef := matchSubresourceRef(*lookup.match, "situation", "situation")
 	if situationRef == "" {
 		return NormalizedResult{
@@ -214,6 +414,19 @@ func (s *MatchService) Situation(ctx context.Context, query string, opts MatchLo
 	}
 
 	if isSparseSituation(situation) {
+		if live, warnings := s.buildLiveView(ctx, *lookup.match); live != nil {
+			situation.Live = live
+			result := NewDataResult(EntityMatchSituation, situation)
+			combinedWarnings := append([]string{}, lookup.warnings...)
+			combinedWarnings = append(combinedWarnings, hydrationWarnings...)
+			combinedWarnings = append(combinedWarnings, warnings...)
+			if len(combinedWarnings) > 0 {
+				result = NewPartialResult(EntityMatchSituation, situation, combinedWarnings...)
+			}
+			result.RequestedRef = resolved.RequestedRef
+			result.CanonicalRef = resolved.CanonicalRef
+			return result, nil
+		}
 		result := NormalizedResult{
 			Kind:         EntityMatchSituation,
 			Status:       ResultStatusEmpty,
@@ -225,14 +438,211 @@ func (s *MatchService) Situation(ctx context.Context, query string, opts MatchLo
 	}
 
 	result := NewDataResult(EntityMatchSituation, situation)
-	if len(lookup.warnings) > 0 {
-		result = NewPartialResult(EntityMatchSituation, situation, lookup.warnings...)
+	combinedWarnings := append([]string{}, lookup.warnings...)
+	combinedWarnings = append(combinedWarnings, hydrationWarnings...)
+	if len(combinedWarnings) > 0 {
+		result = NewPartialResult(EntityMatchSituation, situation, combinedWarnings...)
 	}
 	result.RequestedRef = resolved.RequestedRef
 	result.CanonicalRef = resolved.CanonicalRef
 	return result, nil
 }
 
+// LiveView resolves and returns a fan-first live view synthesized from delivery details.
+func (s *MatchService) LiveView(ctx context.Context, query string, opts MatchLookupOptions) (NormalizedResult, error) {
+	lookup, passthrough := s.resolveMatchLookup(ctx, query, opts)
+	if passthrough != nil {
+		passthrough.Kind = EntityMatchSituation
+		return *passthrough, nil
+	}
+
+	statusCache := map[string]matchStatusSnapshot{}
+	teamCache := map[string]teamIdentity{}
+	scoreCache := map[string]string{}
+	hydrationWarnings := s.hydrateMatch(ctx, lookup.match, statusCache, teamCache, scoreCache)
+
+	live, liveWarnings := s.buildLiveView(ctx, *lookup.match)
+	if live == nil {
+		fallback, fallbackErr := s.Situation(ctx, query, opts)
+		if fallbackErr == nil && fallback.Status != ResultStatusError {
+			combinedWarnings := append([]string{}, fallback.Warnings...)
+			combinedWarnings = append(combinedWarnings, lookup.warnings...)
+			combinedWarnings = append(combinedWarnings, hydrationWarnings...)
+			combinedWarnings = append(combinedWarnings, liveWarnings...)
+			combinedWarnings = append(combinedWarnings, "live-view fallback: showing situation data")
+			combinedWarnings = compactWarnings(combinedWarnings)
+
+			if fallback.Data != nil && len(combinedWarnings) > 0 {
+				partial := NewPartialResult(EntityMatchSituation, fallback.Data, combinedWarnings...)
+				partial.RequestedRef = nonEmpty(fallback.RequestedRef, lookup.resolved.RequestedRef)
+				partial.CanonicalRef = nonEmpty(fallback.CanonicalRef, lookup.resolved.CanonicalRef)
+				return partial, nil
+			}
+			return fallback, nil
+		}
+
+		result := NormalizedResult{
+			Kind:    EntityMatchSituation,
+			Status:  ResultStatusEmpty,
+			Message: fmt.Sprintf("no live view data available for match %q", lookup.match.ID),
+		}
+		warnings := compactWarnings(append(append(append([]string{}, lookup.warnings...), hydrationWarnings...), liveWarnings...))
+		if len(warnings) > 0 {
+			result.Status = ResultStatusPartial
+			result.Message = "live view unavailable"
+			result.Warnings = warnings
+		}
+		return result, nil
+	}
+
+	situation := &MatchSituation{
+		Ref:           matchSubresourceRef(*lookup.match, "situation", "situation"),
+		LeagueID:      lookup.match.LeagueID,
+		EventID:       lookup.match.EventID,
+		CompetitionID: lookup.match.CompetitionID,
+		MatchID:       lookup.match.ID,
+		Live:          live,
+	}
+	warnings := append([]string{}, lookup.warnings...)
+	warnings = append(warnings, hydrationWarnings...)
+	warnings = append(warnings, liveWarnings...)
+
+	result := NewDataResult(EntityMatchSituation, situation)
+	if len(warnings) > 0 {
+		result = NewPartialResult(EntityMatchSituation, situation, warnings...)
+	}
+	result.RequestedRef = lookup.resolved.RequestedRef
+	result.CanonicalRef = lookup.resolved.CanonicalRef
+	return result, nil
+}
+
+// Duel resolves and returns a batter-vs-bowler matchup summary for one match.
+func (s *MatchService) Duel(ctx context.Context, query string, opts MatchDuelOptions) (NormalizedResult, error) {
+	lookup, passthrough := s.resolveMatchLookup(ctx, query, MatchLookupOptions{LeagueID: opts.LeagueID})
+	if passthrough != nil {
+		passthrough.Kind = EntityMatchDuel
+		return *passthrough, nil
+	}
+	if strings.TrimSpace(opts.BatterQuery) == "" || strings.TrimSpace(opts.BowlerQuery) == "" {
+		return NormalizedResult{
+			Kind:    EntityMatchDuel,
+			Status:  ResultStatusEmpty,
+			Message: "--batter and --bowler are required",
+		}, nil
+	}
+	statusCache := map[string]matchStatusSnapshot{}
+	teamCache := map[string]teamIdentity{}
+	scoreCache := map[string]string{}
+	hydrationWarnings := s.hydrateMatch(ctx, lookup.match, statusCache, teamCache, scoreCache)
+
+	detailsRef := nonEmpty(strings.TrimSpace(lookup.match.DetailsRef), matchSubresourceRef(*lookup.match, "details", "details"))
+	playsRef := matchSubresourceRef(*lookup.match, "plays", "plays")
+	primaryRef := nonEmpty(detailsRef, playsRef)
+	deliveries, warnings, err := s.deliveryEventsForMatchRefs(ctx, primaryRef, playsRef)
+	if err != nil {
+		return NewTransportErrorResult(EntityMatchDuel, primaryRef, err), nil
+	}
+	if len(deliveries) == 0 {
+		return NormalizedResult{
+			Kind:    EntityMatchDuel,
+			Status:  ResultStatusEmpty,
+			Message: "no delivery data available for duel analysis",
+		}, nil
+	}
+	matchLatest := deliveries[len(deliveries)-1]
+
+	batterID, batterName := resolveDuelIdentity(deliveries, strings.TrimSpace(opts.BatterQuery), true)
+	bowlerID, bowlerName := resolveDuelIdentity(deliveries, strings.TrimSpace(opts.BowlerQuery), false)
+	if batterID == "" && normalizeAlias(batterName) == "" {
+		return NormalizedResult{Kind: EntityMatchDuel, Status: ResultStatusEmpty, Message: fmt.Sprintf("batter %q not found in this match stream", opts.BatterQuery)}, nil
+	}
+	if bowlerID == "" && normalizeAlias(bowlerName) == "" {
+		return NormalizedResult{Kind: EntityMatchDuel, Status: ResultStatusEmpty, Message: fmt.Sprintf("bowler %q not found in this match stream", opts.BowlerQuery)}, nil
+	}
+
+	runs := 0
+	dots := 0
+	fours := 0
+	sixes := 0
+	wickets := 0
+	balls := 0
+	recent := make([]DeliveryEvent, 0, 8)
+	lastUpdate := int64(0)
+	for _, delivery := range deliveries {
+		if !deliveryMatchesDuel(delivery, batterID, batterName, bowlerID, bowlerName) {
+			continue
+		}
+		balls++
+		if delivery.ScoreValue > 0 {
+			runs += delivery.ScoreValue
+		} else {
+			dots++
+		}
+		short := strings.ToUpper(strings.TrimSpace(delivery.ShortText))
+		if strings.Contains(short, "FOUR") {
+			fours++
+		}
+		if strings.Contains(short, "SIX") {
+			sixes++
+		}
+		if truthyField(delivery.Dismissal, "dismissal") {
+			wickets++
+		}
+		recent = append(recent, delivery)
+		if delivery.BBBTimestamp > lastUpdate {
+			lastUpdate = delivery.BBBTimestamp
+		}
+	}
+	if balls == 0 {
+		return NormalizedResult{
+			Kind:    EntityMatchDuel,
+			Status:  ResultStatusEmpty,
+			Message: fmt.Sprintf("no deliveries found for %s vs %s", nonEmpty(batterName, opts.BatterQuery), nonEmpty(bowlerName, opts.BowlerQuery)),
+		}, nil
+	}
+	if len(recent) > 8 {
+		recent = recent[len(recent)-8:]
+	}
+	liveScore := firstNonEmpty(matchScoreLabel(matchLatest.HomeScore), matchScoreLabel(matchLatest.AwayScore), lookup.match.ScoreSummary)
+	liveOver := overBallString(matchLatest.OverNumber, matchLatest.BallNumber)
+	duelScore := liveScore
+	if liveScore != "" && liveOver != "" {
+		duelScore = fmt.Sprintf("%s (%s ov)", liveScore, liveOver)
+	}
+
+	duel := MatchDuel{
+		MatchID:      lookup.match.ID,
+		Fixture:      nonEmpty(lookup.match.ShortDescription, lookup.match.Description),
+		Score:        duelScore,
+		BatterID:     batterID,
+		BatterName:   nonEmpty(batterName, opts.BatterQuery),
+		BowlerID:     bowlerID,
+		BowlerName:   nonEmpty(bowlerName, opts.BowlerQuery),
+		Balls:        balls,
+		Runs:         runs,
+		Dots:         dots,
+		Fours:        fours,
+		Sixes:        sixes,
+		Wickets:      wickets,
+		StrikeRate:   strikeRate(runs, balls),
+		RecentBalls:  recent,
+		LastUpdateMS: lastUpdate,
+		SnapshotAt:   time.Now().UTC().Format(time.RFC3339),
+		SourceRoute:  primaryRef,
+	}
+
+	allWarnings := append([]string{}, lookup.warnings...)
+	allWarnings = append(allWarnings, hydrationWarnings...)
+	allWarnings = append(allWarnings, warnings...)
+	result := NewDataResult(EntityMatchDuel, duel)
+	if len(allWarnings) > 0 {
+		result = NewPartialResult(EntityMatchDuel, duel, allWarnings...)
+	}
+	result.RequestedRef = lookup.resolved.RequestedRef
+	result.CanonicalRef = lookup.resolved.CanonicalRef
+	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)
@@ -590,31 +1000,30 @@ func (s *MatchService) listFromEvents(ctx context.Context, opts MatchListOptions
 		limit = defaultMatchListLimit
 	}
 
-	statusCache := map[string]matchStatusSnapshot{}
-
 	matches := make([]Match, 0, limit)
 	warnings := make([]string, 0)
-	for _, eventRef := range page.Items {
-		if len(matches) >= limit {
+	eventResults := s.fetchEventMatchesConcurrent(ctx, page.Items)
+	candidates := make([]*Match, 0, len(page.Items))
+
+	for _, eventResult := range eventResults {
+		if len(matches) >= limit && !liveOnly {
 			break
 		}
 
-		eventMatches, eventWarnings, eventErr := s.matchesFromEventRef(ctx, eventRef.URL)
-		if eventErr != nil {
-			warnings = append(warnings, fmt.Sprintf("event %s: %v", strings.TrimSpace(eventRef.URL), eventErr))
+		if eventResult.err != nil {
+			warnings = append(warnings, fmt.Sprintf("event %s: %v", strings.TrimSpace(eventResult.ref), eventResult.err))
 			continue
 		}
-		warnings = append(warnings, eventWarnings...)
+		warnings = append(warnings, eventResult.warnings...)
 
-		for _, eventMatch := range eventMatches {
-			match := eventMatch
+		for i := range eventResult.matches {
+			match := eventResult.matches[i]
 			s.enrichMatchTeamsFromIndex(&match)
-			if liveOnly && !isLiveMatch(match) {
-				warnings = append(warnings, s.hydrateMatchStatusOnly(ctx, &match, statusCache)...)
-			}
-			if liveOnly && !isLiveMatch(match) {
+			if liveOnly {
+				candidates = append(candidates, &match)
 				continue
 			}
+
 			match.ScoreSummary = matchScoreSummary(match.Teams)
 			matches = append(matches, match)
 			if len(matches) >= limit {
@@ -623,6 +1032,20 @@ func (s *MatchService) listFromEvents(ctx context.Context, opts MatchListOptions
 		}
 	}
 
+	if liveOnly {
+		warnings = append(warnings, s.hydrateMatchStatusesConcurrent(ctx, candidates)...)
+		for _, candidate := range candidates {
+			if candidate == nil || !isLiveMatch(*candidate) {
+				continue
+			}
+			candidate.ScoreSummary = matchScoreSummary(candidate.Teams)
+			matches = append(matches, *candidate)
+			if len(matches) >= limit {
+				break
+			}
+		}
+	}
+
 	items := make([]any, 0, len(matches))
 	for i := range matches {
 		items = append(items, matches[i])
@@ -637,6 +1060,86 @@ func (s *MatchService) listFromEvents(ctx context.Context, opts MatchListOptions
 	return result, nil
 }
 
+type eventMatchesResult struct {
+	ref      string
+	matches  []Match
+	warnings []string
+	err      error
+}
+
+func (s *MatchService) fetchEventMatchesConcurrent(ctx context.Context, refs []Ref) []eventMatchesResult {
+	results := make([]eventMatchesResult, len(refs))
+	sem := make(chan struct{}, matchListEventFetchConcurrency)
+	var wg sync.WaitGroup
+
+	for i, item := range refs {
+		wg.Add(1)
+		go func(index int, item Ref) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			ref := strings.TrimSpace(item.URL)
+			if ref == "" {
+				results[index] = eventMatchesResult{
+					ref: ref,
+					err: fmt.Errorf("empty event ref"),
+				}
+				return
+			}
+
+			reqCtx, cancel := context.WithTimeout(ctx, matchListEventFetchTimeout)
+			matches, warnings, err := s.matchesFromEventRef(reqCtx, ref)
+			cancel()
+			results[index] = eventMatchesResult{
+				ref:      ref,
+				matches:  matches,
+				warnings: warnings,
+				err:      err,
+			}
+		}(i, item)
+	}
+
+	wg.Wait()
+	return results
+}
+
+func (s *MatchService) hydrateMatchStatusesConcurrent(ctx context.Context, matches []*Match) []string {
+	type statusHydrationResult struct {
+		warnings []string
+	}
+
+	results := make([]statusHydrationResult, len(matches))
+	sem := make(chan struct{}, matchListStatusFetchConcurrency)
+	var wg sync.WaitGroup
+
+	for i, match := range matches {
+		if match == nil || isLiveMatch(*match) || strings.TrimSpace(match.StatusRef) == "" {
+			continue
+		}
+
+		wg.Add(1)
+		go func(index int, match *Match) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			reqCtx, cancel := context.WithTimeout(ctx, matchListStatusFetchTimeout)
+			warnings := s.hydrateMatchStatusOnly(reqCtx, match, map[string]matchStatusSnapshot{})
+			cancel()
+			results[index] = statusHydrationResult{warnings: warnings}
+		}(i, match)
+	}
+
+	wg.Wait()
+
+	warnings := make([]string, 0)
+	for _, result := range results {
+		warnings = append(warnings, result.warnings...)
+	}
+	return compactWarnings(warnings)
+}
+
 func (s *MatchService) lookupMatch(ctx context.Context, query string, opts MatchLookupOptions, statusOnly bool) (NormalizedResult, error) {
 	lookup, passthrough := s.resolveMatchLookup(ctx, query, opts)
 	if passthrough != nil {
@@ -718,7 +1221,7 @@ func (s *MatchService) resolveMatchLookup(ctx context.Context, query string, opt
 		return nil, &result
 	}
 
-	resolved, err := s.client.ResolveRefChain(ctx, ref)
+	resolved, err := s.resolveRefChainResilient(ctx, ref)
 	if err != nil {
 		result := NewTransportErrorResult(EntityMatch, ref, err)
 		return nil, &result
@@ -1132,12 +1635,153 @@ func (s *MatchService) loadDeliveryEvents(ctx context.Context, refs []Ref) ([]De
 			continue
 		}
 		if result.delivery != nil {
-			deliveries = append(deliveries, *result.delivery)
+			if isRenderableDelivery(*result.delivery) {
+				deliveries = append(deliveries, *result.delivery)
+			}
 		}
 	}
 	return deliveries, compactWarnings(warnings)
 }
 
+func (s *MatchService) deliveryEventsForMatchRefs(ctx context.Context, primaryRef string, alternateRefs ...string) ([]DeliveryEvent, []string, error) {
+	primaryRef = strings.TrimSpace(primaryRef)
+	primaryEvents, primaryWarnings, primaryErr := s.loadDeliveryEventsFromRoute(ctx, primaryRef)
+	if primaryErr == nil && len(primaryEvents) > 0 && len(primaryWarnings) == 0 {
+		return primaryEvents, nil, nil
+	}
+
+	merged := append([]DeliveryEvent{}, primaryEvents...)
+	warnings := append([]string{}, primaryWarnings...)
+	if primaryErr != nil {
+		warnings = append(warnings, fmt.Sprintf("delivery route %s: %v", primaryRef, primaryErr))
+	}
+
+	for _, ref := range alternateRefs {
+		ref = strings.TrimSpace(ref)
+		if ref == "" || ref == primaryRef {
+			continue
+		}
+		events, routeWarnings, err := s.loadDeliveryEventsFromRoute(ctx, ref)
+		if err != nil {
+			warnings = append(warnings, fmt.Sprintf("delivery route %s: %v", ref, err))
+			continue
+		}
+		warnings = append(warnings, routeWarnings...)
+		merged = append(merged, events...)
+	}
+
+	merged = dedupeDeliveryEvents(merged)
+	sortDeliveryEvents(merged)
+	if len(merged) == 0 && primaryErr != nil {
+		return nil, compactWarnings(warnings), primaryErr
+	}
+	return merged, compactWarnings(warnings), nil
+}
+
+func (s *MatchService) loadDeliveryEventsFromRoute(ctx context.Context, ref string) ([]DeliveryEvent, []string, error) {
+	ref = strings.TrimSpace(ref)
+	if ref == "" {
+		return nil, nil, fmt.Errorf("empty delivery route")
+	}
+	resolved, err := s.resolveRefChainResilient(ctx, ref)
+	if err != nil {
+		return nil, nil, err
+	}
+	pageItems, pageWarnings, err := s.resolvePageRefs(ctx, resolved)
+	if err != nil {
+		return nil, nil, err
+	}
+	loaded, loadWarnings := s.loadDeliveryEvents(ctx, pageItems)
+	warnings := make([]string, 0, len(pageWarnings)+len(loadWarnings))
+	warnings = append(warnings, pageWarnings...)
+	warnings = append(warnings, loadWarnings...)
+	return loaded, compactWarnings(warnings), nil
+}
+
+func (s *MatchService) loadRecentDeliveryEventsFromRoute(ctx context.Context, ref string, maxItems int) ([]DeliveryEvent, []string, error) {
+	ref = strings.TrimSpace(ref)
+	if ref == "" {
+		return nil, nil, fmt.Errorf("empty delivery route")
+	}
+	resolved, err := s.resolveRefChainResilient(ctx, ref)
+	if err != nil {
+		return nil, nil, err
+	}
+	pageItems, pageWarnings, err := s.resolvePageRefs(ctx, resolved)
+	if err != nil {
+		return nil, nil, err
+	}
+	if maxItems > 0 && len(pageItems) > maxItems {
+		pageItems = append([]Ref(nil), pageItems[len(pageItems)-maxItems:]...)
+	}
+	loaded, loadWarnings := s.loadDeliveryEvents(ctx, pageItems)
+	warnings := make([]string, 0, len(pageWarnings)+len(loadWarnings))
+	warnings = append(warnings, pageWarnings...)
+	warnings = append(warnings, loadWarnings...)
+	return loaded, compactWarnings(warnings), nil
+}
+
+func isRenderableDelivery(delivery DeliveryEvent) bool {
+	if delivery.OverNumber > 0 && delivery.BallNumber > 0 {
+		return true
+	}
+	text := strings.TrimSpace(firstNonEmpty(delivery.ShortText, delivery.Text))
+	if text == "" || text == "/" || text == "-" {
+		return false
+	}
+	lowered := strings.ToLower(text)
+	return !strings.Contains(lowered, "over - ball")
+}
+
+func sortDeliveryEvents(deliveries []DeliveryEvent) {
+	sort.SliceStable(deliveries, func(i, j int) bool {
+		if deliveries[i].Period != deliveries[j].Period {
+			return deliveries[i].Period < deliveries[j].Period
+		}
+		if deliveries[i].OverNumber != deliveries[j].OverNumber {
+			return deliveries[i].OverNumber < deliveries[j].OverNumber
+		}
+		if deliveries[i].BallNumber != deliveries[j].BallNumber {
+			return deliveries[i].BallNumber < deliveries[j].BallNumber
+		}
+		if deliveries[i].Sequence != deliveries[j].Sequence {
+			return deliveries[i].Sequence < deliveries[j].Sequence
+		}
+		return deliveries[i].BBBTimestamp < deliveries[j].BBBTimestamp
+	})
+}
+
+func dedupeDeliveryEvents(deliveries []DeliveryEvent) []DeliveryEvent {
+	if len(deliveries) <= 1 {
+		return deliveries
+	}
+	seen := map[string]int{}
+	out := make([]DeliveryEvent, 0, len(deliveries))
+	for _, delivery := range deliveries {
+		key := strings.TrimSpace(delivery.ID)
+		if key == "" {
+			key = fmt.Sprintf("%d|%d|%d|%d|%s|%s|%s",
+				delivery.Period,
+				delivery.OverNumber,
+				delivery.BallNumber,
+				delivery.Sequence,
+				strings.TrimSpace(delivery.ShortText),
+				strings.TrimSpace(delivery.HomeScore),
+				strings.TrimSpace(delivery.AwayScore),
+			)
+		}
+		if idx, ok := seen[key]; ok {
+			if delivery.Sequence > out[idx].Sequence || delivery.BBBTimestamp > out[idx].BBBTimestamp {
+				out[idx] = delivery
+			}
+			continue
+		}
+		seen[key] = len(out)
+		out = append(out, delivery)
+	}
+	return out
+}
+
 type selectedInningsContext struct {
 	match    Match
 	team     Team
@@ -1988,11 +2632,381 @@ func extensionRef(extensions map[string]any, key string) string {
 	return strings.TrimSpace(stringField(refMap, "$ref"))
 }
 
+func (s *MatchService) buildLiveView(ctx context.Context, match Match) (*MatchLiveView, []string) {
+	detailsRef := nonEmpty(strings.TrimSpace(match.DetailsRef), matchSubresourceRef(match, "details", "details"))
+	playsRef := matchSubresourceRef(match, "plays", "plays")
+	if detailsRef == "" && playsRef == "" {
+		return nil, nil
+	}
+	primaryRef := nonEmpty(detailsRef, playsRef)
+	deliveries, warnings, err := s.loadRecentDeliveryEventsFromRoute(ctx, primaryRef, liveViewRecentDeliveryFetchCount)
+	if err != nil {
+		warnings = append(warnings, fmt.Sprintf("live deliveries %s: %v", primaryRef, err))
+		deliveries = nil
+	}
+	if len(deliveries) < 6 || len(warnings) > 0 {
+		alternate := strings.TrimSpace(playsRef)
+		if alternate != "" && alternate != primaryRef {
+			altDeliveries, altWarnings, altErr := s.loadRecentDeliveryEventsFromRoute(ctx, alternate, liveViewRecentDeliveryFetchCount)
+			if altErr != nil {
+				warnings = append(warnings, fmt.Sprintf("live deliveries %s: %v", alternate, altErr))
+			} else if len(altDeliveries) > 0 {
+				deliveries = append(deliveries, altDeliveries...)
+				warnings = append(warnings, altWarnings...)
+			}
+		}
+	}
+	deliveries = dedupeDeliveryEvents(deliveries)
+	sortDeliveryEvents(deliveries)
+	if len(deliveries) == 0 {
+		return nil, warnings
+	}
+	latest := deliveries[len(deliveries)-1]
+
+	nameMap := map[string]string{}
+	for _, event := range deliveries {
+		bowlerName, batsmanName := parseNamesFromDeliveryShortText(event.ShortText)
+		if strings.TrimSpace(event.BowlerPlayerID) != "" && strings.TrimSpace(bowlerName) != "" {
+			if _, ok := nameMap[event.BowlerPlayerID]; !ok {
+				nameMap[event.BowlerPlayerID] = bowlerName
+			}
+		}
+		if strings.TrimSpace(event.BatsmanPlayerID) != "" && strings.TrimSpace(batsmanName) != "" {
+			if _, ok := nameMap[event.BatsmanPlayerID]; !ok {
+				nameMap[event.BatsmanPlayerID] = batsmanName
+			}
+		}
+	}
+	score := firstNonEmpty(matchScoreLabel(latest.HomeScore), matchScoreLabel(latest.AwayScore))
+	if score == "" {
+		score = match.ScoreSummary
+	}
+
+	battingTeam := teamLabelByID(match, latest.TeamID)
+	bowlingTeam := otherTeamLabelByID(match, latest.TeamID)
+	if battingTeam == "" {
+		battingTeam = firstNonEmpty(matchTeamsLabelFromMatch(match), latest.TeamID)
+	}
+
+	batters := make([]LiveBatterView, 0, 2)
+	if latest.BatsmanPlayerID != "" {
+		batters = append(batters, LiveBatterView{
+			PlayerID:   latest.BatsmanPlayerID,
+			PlayerName: firstNonEmpty(nameMap[latest.BatsmanPlayerID], latest.BatsmanPlayerID),
+			Runs:       latest.BatsmanTotalRuns,
+			Balls:      latest.BatsmanBalls,
+			Fours:      latest.BatsmanFours,
+			Sixes:      latest.BatsmanSixes,
+			StrikeRate: strikeRate(latest.BatsmanTotalRuns, latest.BatsmanBalls),
+			OnStrike:   true,
+		})
+	}
+	if latest.OtherBatsmanID != "" {
+		batters = append(batters, LiveBatterView{
+			PlayerID:   latest.OtherBatsmanID,
+			PlayerName: firstNonEmpty(nameMap[latest.OtherBatsmanID], latest.OtherBatsmanID),
+			Runs:       latest.OtherBatterRuns,
+			Balls:      latest.OtherBatterBalls,
+			Fours:      latest.OtherBatterFours,
+			Sixes:      latest.OtherBatterSixes,
+			StrikeRate: strikeRate(latest.OtherBatterRuns, latest.OtherBatterBalls),
+		})
+	}
+
+	bowlers := make([]LiveBowlerView, 0, 2)
+	if latest.BowlerPlayerID != "" {
+		bowlers = append(bowlers, LiveBowlerView{
+			PlayerID:   latest.BowlerPlayerID,
+			PlayerName: firstNonEmpty(nameMap[latest.BowlerPlayerID], latest.BowlerPlayerID),
+			Overs:      latest.BowlerOvers,
+			Balls:      latest.BowlerBalls,
+			Maidens:    latest.BowlerMaidens,
+			Conceded:   latest.BowlerConceded,
+			Wickets:    latest.BowlerWickets,
+			Economy:    economy(latest.BowlerConceded, latest.BowlerBalls, latest.BowlerOvers),
+		})
+	}
+	if latest.OtherBowlerID != "" && latest.OtherBowlerID != latest.BowlerPlayerID {
+		bowlers = append(bowlers, LiveBowlerView{
+			PlayerID:   latest.OtherBowlerID,
+			PlayerName: firstNonEmpty(nameMap[latest.OtherBowlerID], latest.OtherBowlerID),
+			Overs:      latest.OtherBowlerOvers,
+			Balls:      latest.OtherBowlerBalls,
+			Maidens:    latest.OtherBowlerMaidens,
+			Conceded:   latest.OtherBowlerConceded,
+			Wickets:    latest.OtherBowlerWickets,
+			Economy:    economy(latest.OtherBowlerConceded, latest.OtherBowlerBalls, latest.OtherBowlerOvers),
+		})
+	}
+
+	startRecent := len(deliveries) - 6
+	if startRecent < 0 {
+		startRecent = 0
+	}
+	recent := append([]DeliveryEvent(nil), deliveries[startRecent:]...)
+	currentOver := make([]DeliveryEvent, 0, 6)
+	for _, event := range deliveries {
+		if event.OverNumber == latest.OverNumber && event.Period == latest.Period {
+			currentOver = append(currentOver, event)
+		}
+	}
+
+	view := &MatchLiveView{
+		Fixture:      nonEmpty(match.ShortDescription, match.Description),
+		Status:       nonEmpty(match.MatchState, match.Note),
+		Score:        score,
+		Overs:        overBallString(latest.OverNumber, latest.BallNumber),
+		CurrentOver:  latest.OverNumber,
+		BallInOver:   latest.BallNumber,
+		BattingTeam:  battingTeam,
+		BowlingTeam:  bowlingTeam,
+		Batters:      batters,
+		Bowlers:      bowlers,
+		RecentBalls:  recent,
+		CurrentBalls: currentOver,
+		LastDetailID: strings.TrimSpace(latest.ID),
+		LastUpdateMS: latest.BBBTimestamp,
+		SnapshotAt:   time.Now().UTC().Format(time.RFC3339),
+		SourceRoute:  primaryRef,
+	}
+	stale, reason := detectLiveStaleness(match.ScoreSummary, score)
+	view.Stale = stale
+	view.StaleReason = reason
+	return view, compactWarnings(warnings)
+}
+
+func augmentScorecardFromLive(scorecard *MatchScorecard, live *MatchLiveView) {
+	if scorecard == nil || live == nil {
+		return
+	}
+
+	if len(scorecard.BattingCards) == 0 && len(live.Batters) > 0 {
+		card := BattingCard{
+			InningsNumber: 1,
+			TeamName:      live.BattingTeam,
+			Runs:          live.Score,
+			Players:       make([]BattingCardEntry, 0, len(live.Batters)),
+		}
+		for _, batter := range live.Batters {
+			card.Players = append(card.Players, BattingCardEntry{
+				PlayerID:   batter.PlayerID,
+				PlayerName: batter.PlayerName,
+				Runs:       strconv.Itoa(batter.Runs),
+				BallsFaced: strconv.Itoa(batter.Balls),
+				Fours:      strconv.Itoa(batter.Fours),
+				Sixes:      strconv.Itoa(batter.Sixes),
+			})
+		}
+		scorecard.BattingCards = append(scorecard.BattingCards, card)
+	}
+
+	if len(scorecard.BowlingCards) == 0 && len(live.Bowlers) > 0 {
+		card := BowlingCard{
+			InningsNumber: 1,
+			TeamName:      live.BowlingTeam,
+			Players:       make([]BowlingCardEntry, 0, len(live.Bowlers)),
+		}
+		for _, bowler := range live.Bowlers {
+			card.Players = append(card.Players, BowlingCardEntry{
+				PlayerID:    bowler.PlayerID,
+				PlayerName:  bowler.PlayerName,
+				Overs:       overFromBallsOrFloat(bowler.Balls, bowler.Overs),
+				Maidens:     strconv.Itoa(bowler.Maidens),
+				Conceded:    strconv.Itoa(bowler.Conceded),
+				Wickets:     strconv.Itoa(bowler.Wickets),
+				EconomyRate: fmt.Sprintf("%.2f", bowler.Economy),
+			})
+		}
+		scorecard.BowlingCards = append(scorecard.BowlingCards, card)
+	}
+}
+
+func strikeRate(runs, balls int) float64 {
+	if balls <= 0 {
+		return 0
+	}
+	return float64(runs) * 100.0 / float64(balls)
+}
+
+func economy(conceded, balls int, overs float64) float64 {
+	if balls > 0 {
+		return float64(conceded) / (float64(balls) / 6.0)
+	}
+	if overs > 0 {
+		return float64(conceded) / overs
+	}
+	return 0
+}
+
+func overFromBallsOrFloat(balls int, overs float64) string {
+	if balls > 0 {
+		return fmt.Sprintf("%d.%d", balls/6, balls%6)
+	}
+	if overs > 0 {
+		return fmt.Sprintf("%.1f", overs)
+	}
+	return "0.0"
+}
+
+func teamLabelByID(match Match, teamID string) string {
+	teamID = strings.TrimSpace(teamID)
+	for _, team := range match.Teams {
+		if strings.TrimSpace(team.ID) == teamID {
+			return nonEmpty(strings.TrimSpace(team.ShortName), strings.TrimSpace(team.Name), teamID)
+		}
+	}
+	return ""
+}
+
+func otherTeamLabelByID(match Match, teamID string) string {
+	teamID = strings.TrimSpace(teamID)
+	for _, team := range match.Teams {
+		if strings.TrimSpace(team.ID) != teamID {
+			return nonEmpty(strings.TrimSpace(team.ShortName), strings.TrimSpace(team.Name), strings.TrimSpace(team.ID))
+		}
+	}
+	return ""
+}
+
+func matchTeamsLabelFromMatch(match Match) string {
+	parts := make([]string, 0, len(match.Teams))
+	for _, team := range match.Teams {
+		label := nonEmpty(strings.TrimSpace(team.ShortName), strings.TrimSpace(team.Name), strings.TrimSpace(team.ID))
+		if label != "" {
+			parts = append(parts, label)
+		}
+	}
+	return strings.Join(parts, ", ")
+}
+
+func parseNamesFromDeliveryShortText(shortText string) (string, string) {
+	shortText = strings.TrimSpace(shortText)
+	if shortText == "" {
+		return "", ""
+	}
+	toParts := strings.SplitN(shortText, " to ", 2)
+	if len(toParts) != 2 {
+		return "", ""
+	}
+	bowler := strings.TrimSpace(toParts[0])
+	right := toParts[1]
+	commaParts := strings.SplitN(right, ",", 2)
+	if len(commaParts) == 0 {
+		return "", ""
+	}
+	batsman := strings.TrimSpace(commaParts[0])
+	return bowler, batsman
+}
+
+func detectLiveStaleness(matchScore, liveScore string) (bool, string) {
+	matchRuns, matchWkts, okMatch := parseRunsWkts(matchScore)
+	liveRuns, liveWkts, okLive := parseRunsWkts(liveScore)
+	if !okMatch || !okLive {
+		return false, ""
+	}
+	if liveRuns < matchRuns || liveWkts < matchWkts {
+		return true, fmt.Sprintf("live snapshot %d/%d trails match summary %d/%d", liveRuns, liveWkts, matchRuns, matchWkts)
+	}
+	return false, ""
+}
+
+func parseRunsWkts(raw string) (int, int, bool) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return 0, 0, false
+	}
+	idx := strings.Index(raw, "/")
+	if idx <= 0 || idx >= len(raw)-1 {
+		return 0, 0, false
+	}
+	left := idx - 1
+	for left >= 0 && raw[left] >= '0' && raw[left] <= '9' {
+		left--
+	}
+	right := idx + 1
+	for right < len(raw) && raw[right] >= '0' && raw[right] <= '9' {
+		right++
+	}
+	runStr := strings.TrimSpace(raw[left+1 : idx])
+	wktStr := strings.TrimSpace(raw[idx+1 : right])
+	runs, err1 := strconv.Atoi(runStr)
+	wkts, err2 := strconv.Atoi(wktStr)
+	if err1 != nil || err2 != nil {
+		return 0, 0, false
+	}
+	return runs, wkts, true
+}
+
+func resolveDuelIdentity(deliveries []DeliveryEvent, query string, isBatter bool) (string, string) {
+	q := normalizeAlias(query)
+	if q == "" {
+		return "", ""
+	}
+
+	type candidate struct {
+		id    string
+		name  string
+		score int
+	}
+	best := candidate{}
+	for _, delivery := range deliveries {
+		bowlerName, batsmanName := parseNamesFromDeliveryShortText(delivery.ShortText)
+		id := delivery.BowlerPlayerID
+		name := bowlerName
+		if isBatter {
+			id = delivery.BatsmanPlayerID
+			name = batsmanName
+		}
+		if strings.TrimSpace(id) == "" && strings.TrimSpace(name) == "" {
+			continue
+		}
+		score := aliasMatchScore(normalizeAlias(nonEmpty(name, id)), q, strings.Fields(q))
+		if normalizeAlias(id) == q {
+			score = 1000
+		}
+		if score > best.score {
+			best = candidate{id: strings.TrimSpace(id), name: strings.TrimSpace(name), score: score}
+		}
+	}
+	if best.score >= 300 || best.score == 1000 {
+		return best.id, best.name
+	}
+	return "", ""
+}
+
+func deliveryMatchesDuel(delivery DeliveryEvent, batterID, batterName, bowlerID, bowlerName string) bool {
+	shortBowler, shortBatter := parseNamesFromDeliveryShortText(delivery.ShortText)
+	batterMatch := strings.TrimSpace(batterID) != "" && strings.TrimSpace(delivery.BatsmanPlayerID) == strings.TrimSpace(batterID)
+	if !batterMatch && normalizeAlias(batterName) != "" {
+		batterMatch = normalizeAlias(shortBatter) == normalizeAlias(batterName)
+	}
+	if !batterMatch {
+		return false
+	}
+
+	bowlerMatch := strings.TrimSpace(bowlerID) != "" && strings.TrimSpace(delivery.BowlerPlayerID) == strings.TrimSpace(bowlerID)
+	if !bowlerMatch && normalizeAlias(bowlerName) != "" {
+		bowlerMatch = normalizeAlias(shortBowler) == normalizeAlias(bowlerName)
+	}
+	return bowlerMatch
+}
+
+func matchScoreLabel(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+	if strings.Contains(raw, "/") {
+		return raw
+	}
+	return ""
+}
+
 func isSparseSituation(situation *MatchSituation) bool {
 	if situation == nil {
 		return true
 	}
-	return len(situation.Data) == 0
+	return len(situation.Data) == 0 && situation.Live == nil
 }
 
 func isLiveMatch(match Match) bool {