Match hosted hitter commands to live app parity

src/matchups.js

@@ -6,8 +6,18 @@ const DEFAULT_RECENT_WINDOW = 'season';
 const DEFAULT_SPLIT_KEY = 'overall';
 const DEFAULT_WEIGHTED_MODE = 'weighted';
 const DEFAULT_FALLBACK_DAYS = 7;
+const DEFAULT_ROTOWIRE_URL = 'https://www.rotowire.com/baseball/daily-lineups.php';
 const COCKROACH_RETRY_CODES = new Set(['40001']);
 const PROFILE_CANDIDATE_LIMIT = 5;
+const ROTOWIRE_LINEUP_STATUS = new Map([
+  ['Confirmed Lineup', 'confirmed'],
+  ['Expected Lineup', 'expected'],
+  ['Unknown Lineup', 'unknown'],
+]);
+const ROTOWIRE_POSITION_TOKENS = new Set(['C', '1B', '2B', '3B', 'SS', 'LF', 'CF', 'RF', 'DH', 'P']);
+const ROTOWIRE_STOP_TOKENS = new Set(['Home Run Odds', 'Starting Pitcher Intel']);
+const ROTOWIRE_TIME_RE = /^\d{1,2}:\d{2}\s(?:AM|PM)\sET$/;
+const ROTOWIRE_PRICE_RE = /^\$\d[\d,]*$/;
 const MLB_TEAM_ALIASES = new Map([
   ['ARI', ['ari', 'arizona', 'diamondbacks', 'arizona diamondbacks']],
   ['ATL', ['atl', 'atlanta', 'braves', 'atlanta braves']],
@@ -50,6 +60,7 @@ const HITTER_COLUMNS = [
   'batter',
   'player_id',
   'hitter_name',
+  'stand',
   'split_key',
   'recent_window',
   'weighted_mode',
@@ -58,6 +69,8 @@ const HITTER_COLUMNS = [
   'zone_fit_score',
   'likely_starter_score',
   'xwoba',
+  'swstr_pct',
+  'barrel_bbe_pct',
   'fb_pct',
   'pulled_barrel_pct',
   'sweet_spot_pct',
@@ -276,6 +289,16 @@ function normalizeText(value) {
   return String(value ?? '').trim().toLowerCase();
 }
 
+function normalizeName(value) {
+  return String(value ?? '')
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim()
+    .replace(/\s+/g, ' ');
+}
+
 function normalizeTeam(value) {
   return String(value ?? '').trim().toUpperCase();
 }
@@ -343,6 +366,14 @@ function compareNullableDescending(left, right) {
   return rightValue - leftValue;
 }
 
+function sortHittersLiveApp(rows) {
+  return [...rows].sort((left, right) =>
+    compareNullableDescending(left.matchup_score, right.matchup_score)
+    || compareNullableDescending(left.xwoba, right.xwoba)
+    || String(left.hitter_name ?? '').localeCompare(String(right.hitter_name ?? ''))
+  );
+}
+
 function sortHitters(rows) {
   return [...rows].sort((left, right) =>
     compareNullableDescending(left.matchup_score, right.matchup_score)
@@ -649,6 +680,32 @@ function buildBestMatchupBoardRows(rows) {
   return sortHitters(boardRows);
 }
 
+function buildBestMatchupBoardRowsLiveApp(rows) {
+  if (!rows?.length) {
+    return [];
+  }
+
+  const rowsWithGame = rows.filter((row) => row.game_pk !== null && row.game_pk !== undefined && row.game_pk !== '');
+  if (!rowsWithGame.length) {
+    return sortHittersLiveApp(rows);
+  }
+
+  const grouped = new Map();
+  for (const row of rowsWithGame) {
+    const key = String(row.game_pk);
+    const bucket = grouped.get(key) ?? [];
+    bucket.push(row);
+    grouped.set(key, bucket);
+  }
+
+  const boardRows = [];
+  for (const gameRows of grouped.values()) {
+    boardRows.push(...sortHittersLiveApp(gameRows).slice(0, 3));
+  }
+
+  return sortHittersLiveApp(boardRows);
+}
+
 function keepRowForDefaults(row) {
   const splitKey = String(row.split_key ?? DEFAULT_SPLIT_KEY);
   const recentWindow = String(row.recent_window ?? DEFAULT_RECENT_WINDOW);
@@ -714,6 +771,44 @@ function buildRosterLookup(rows) {
   return lookup;
 }
 
+function buildRosterIdsByTeam(rows) {
+  const lookup = new Map();
+  for (const row of rows) {
+    const team = normalizeTeam(row.team);
+    const playerId = String(row.player_id ?? '').trim();
+    if (!team || !playerId) {
+      continue;
+    }
+    const bucket = lookup.get(team) ?? new Set();
+    bucket.add(playerId);
+    lookup.set(team, bucket);
+  }
+  return lookup;
+}
+
+function buildRosterNameLookupByTeam(rows) {
+  const lookup = new Map();
+  for (const row of rows) {
+    const team = normalizeTeam(row.team);
+    const playerName = String(row.player_name ?? '').trim();
+    const playerId = String(row.player_id ?? '').trim();
+    if (!team || !playerName || !playerId) {
+      continue;
+    }
+    let teamLookup = lookup.get(team);
+    if (!teamLookup) {
+      teamLookup = {
+        exact: new Map(),
+        normalized: new Map(),
+      };
+      lookup.set(team, teamLookup);
+    }
+    teamLookup.exact.set(playerName.toLowerCase(), playerId);
+    teamLookup.normalized.set(normalizeName(playerName), playerId);
+  }
+  return lookup;
+}
+
 function resolveHostedPlayerName(row, rosterLookup, type = 'hitter') {
   const rawName = type === 'pitcher'
     ? String(row.pitcher_name ?? row.player_name ?? '').trim()
@@ -756,6 +851,232 @@ function withDefaults(row, slateLookup, options = {}) {
   };
 }
 
+function decodeHtmlEntities(value) {
+  return String(value ?? '')
+    .replace(/ /gi, ' ')
+    .replace(/&/gi, '&')
+    .replace(/"/gi, '"')
+    .replace(/'/gi, '\'')
+    .replace(/'/gi, '\'')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>');
+}
+
+function extractRotowireTokens(html) {
+  return decodeHtmlEntities(
+    String(html ?? '')
+      .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+      .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+      .replace(/<[^>]+>/g, '\n')
+  )
+    .split(/\r?\n/)
+    .map((token) => token.trim())
+    .filter(Boolean);
+}
+
+function nextNonPriceToken(tokens, startIndex) {
+  let index = startIndex;
+  while (index < tokens.length) {
+    if (!ROTOWIRE_PRICE_RE.test(tokens[index])) {
+      return { token: tokens[index], index };
+    }
+    index += 1;
+  }
+  return { token: null, index };
+}
+
+function parseRotowireLineupSide(tokens, startIndex) {
+  const rawStatus = tokens[startIndex];
+  const status = ROTOWIRE_LINEUP_STATUS.get(rawStatus) ?? 'unknown';
+  let index = startIndex + 1;
+  const players = [];
+
+  if (status === 'unknown') {
+    while (index < tokens.length) {
+      const token = tokens[index];
+      if (
+        ROTOWIRE_LINEUP_STATUS.has(token)
+        || ROTOWIRE_STOP_TOKENS.has(token)
+        || token.startsWith('Umpire:')
+        || ROTOWIRE_TIME_RE.test(token)
+      ) {
+        break;
+      }
+      index += 1;
+    }
+    return { lineup: { status, players }, nextIndex: index };
+  }
+
+  let slot = 1;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (
+      ROTOWIRE_LINEUP_STATUS.has(token)
+      || ROTOWIRE_STOP_TOKENS.has(token)
+      || token.startsWith('Umpire:')
+      || ROTOWIRE_TIME_RE.test(token)
+    ) {
+      break;
+    }
+    if (ROTOWIRE_POSITION_TOKENS.has(token)) {
+      const next = nextNonPriceToken(tokens, index + 1);
+      if (
+        next.token
+        && !ROTOWIRE_POSITION_TOKENS.has(next.token)
+        && !ROTOWIRE_STOP_TOKENS.has(next.token)
+        && !ROTOWIRE_LINEUP_STATUS.has(next.token)
+      ) {
+        players.push({
+          slot,
+          player_name: next.token,
+          position: token,
+        });
+        slot += 1;
+        index = next.index + 1;
+        continue;
+      }
+    }
+    index += 1;
+  }
+
+  return { lineup: { status, players }, nextIndex: index };
+}
+
+function parseRotowireLineups(html, validTeams) {
+  const tokens = extractRotowireTokens(html);
+  const validTeamSet = new Set(validTeams.map((team) => normalizeTeam(team)));
+  const lineups = {};
+  let index = 0;
+
+  while (index < tokens.length) {
+    if (!ROTOWIRE_TIME_RE.test(tokens[index])) {
+      index += 1;
+      continue;
+    }
+
+    const teamTokens = [];
+    let scanIndex = index + 1;
+    while (scanIndex < tokens.length && scanIndex < index + 25 && teamTokens.length < 2) {
+      const token = normalizeTeam(tokens[scanIndex]);
+      if (validTeamSet.has(token) && !teamTokens.includes(token)) {
+        teamTokens.push(token);
+      }
+      scanIndex += 1;
+    }
+
+    if (teamTokens.length !== 2) {
+      index += 1;
+      continue;
+    }
+
+    const [awayTeam, homeTeam] = teamTokens;
+    let firstStatusIndex = null;
+    for (let candidate = scanIndex; candidate < Math.min(tokens.length, scanIndex + 80); candidate += 1) {
+      if (ROTOWIRE_LINEUP_STATUS.has(tokens[candidate])) {
+        firstStatusIndex = candidate;
+        break;
+      }
+    }
+    if (firstStatusIndex === null) {
+      index += 1;
+      continue;
+    }
+
+    const awayResult = parseRotowireLineupSide(tokens, firstStatusIndex);
+    let secondStatusIndex = null;
+    for (let candidate = awayResult.nextIndex; candidate < Math.min(tokens.length, awayResult.nextIndex + 80); candidate += 1) {
+      if (ROTOWIRE_LINEUP_STATUS.has(tokens[candidate])) {
+        secondStatusIndex = candidate;
+        break;
+      }
+    }
+    if (secondStatusIndex === null) {
+      index = awayResult.nextIndex;
+      continue;
+    }
+
+    const homeResult = parseRotowireLineupSide(tokens, secondStatusIndex);
+    lineups[awayTeam] = awayResult.lineup;
+    lineups[homeTeam] = homeResult.lineup;
+    index = homeResult.nextIndex;
+  }
+
+  return lineups;
+}
+
+function resolveRotowireLineups(lineups, rosterRows) {
+  if (!lineups || !Object.keys(lineups).length || !rosterRows?.length) {
+    return lineups ?? {};
+  }
+
+  const rosterLookupByTeam = buildRosterNameLookupByTeam(rosterRows);
+  const resolved = {};
+
+  for (const [team, payload] of Object.entries(lineups)) {
+    const teamLookup = rosterLookupByTeam.get(normalizeTeam(team)) ?? { exact: new Map(), normalized: new Map() };
+    const players = (payload?.players ?? []).map((player) => {
+      const playerName = String(player.player_name ?? '');
+      const exactPlayerId = teamLookup.exact.get(playerName.toLowerCase());
+      const normalizedPlayerId = teamLookup.normalized.get(normalizeName(playerName));
+      return {
+        ...player,
+        player_id: exactPlayerId ?? normalizedPlayerId ?? null,
+      };
+    });
+    resolved[normalizeTeam(team)] = {
+      status: payload?.status ?? 'unknown',
+      players,
+    };
+  }
+
+  return resolved;
+}
+
+function applyProjectedLineup(rows, team, rotowireLineups) {
+  if (!rows.length || !rotowireLineups) {
+    return rows;
+  }
+
+  const payload = rotowireLineups[normalizeTeam(team)];
+  if (!payload || !['confirmed', 'expected'].includes(String(payload.status ?? ''))) {
+    return rows;
+  }
+
+  const slotByPlayerId = new Map();
+  for (const player of payload.players ?? []) {
+    const playerId = String(player.player_id ?? '').trim();
+    if (!playerId) {
+      continue;
+    }
+    slotByPlayerId.set(playerId, Number(player.slot ?? null));
+  }
+
+  if (slotByPlayerId.size < 7) {
+    return rows;
+  }
+
+  return rows
+    .filter((row) => slotByPlayerId.has(String(row.batter ?? row.player_id ?? '').trim()))
+    .map((row) => ({
+      ...row,
+      projected_lineup_slot: slotByPlayerId.get(String(row.batter ?? row.player_id ?? '').trim()) ?? null,
+    }))
+    .sort((left, right) => {
+      const leftSlot = numberOrNull(left.projected_lineup_slot);
+      const rightSlot = numberOrNull(right.projected_lineup_slot);
+      if (leftSlot === null && rightSlot === null) {
+        return 0;
+      }
+      if (leftSlot === null) {
+        return 1;
+      }
+      if (rightSlot === null) {
+        return -1;
+      }
+      return leftSlot - rightSlot;
+    });
+}
+
 function pickMetrics(row, metricKeys) {
   return metricKeys
     .map(([label, key]) => ({ label, key, value: numberOrNull(row[key]) }))
@@ -839,6 +1160,8 @@ export class HostedArtifactSource {
     this.fallbackDays = Number(config.fallbackDays ?? DEFAULT_FALLBACK_DAYS);
     this.logger = options.logger ?? console;
     this.readParquetImpl = options.readParquetImpl ?? readParquetFromUrl;
+    this.fetchTextImpl = options.fetchTextImpl ?? defaultFetchText;
+    this.rotowireUrl = String(config.rotowireUrl ?? DEFAULT_ROTOWIRE_URL);
     this.cache = new Map();
   }
 
@@ -892,37 +1215,177 @@ export class HostedArtifactSource {
     return rows;
   }
 
-  async getTopHitters(options = {}) {
+  async fetchRotowireLineups(targetDate, validTeams, rosterRows = []) {
+    if (!this.fetchTextImpl || !validTeams?.length) {
+      return {};
+    }
+
+    const cacheKey = `rotowire|${parseDateOrToday(targetDate)}|${[...validTeams].sort().join(',')}`;
+    const now = Date.now();
+    const cached = this.cache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      return cached.rows;
+    }
+
+    try {
+      const html = await this.fetchTextImpl(this.rotowireUrl, parseDateOrToday(targetDate));
+      const parsed = parseRotowireLineups(html, validTeams);
+      const resolved = resolveRotowireLineups(parsed, rosterRows);
+      this.cache.set(cacheKey, {
+        expiresAt: now + this.cacheTtlMs,
+        rows: resolved,
+      });
+      return resolved;
+    } catch (error) {
+      this.logger?.debug?.('Rotowire lineup fetch failed', {
+        targetDate: parseDateOrToday(targetDate),
+        error: error.message,
+      });
+      return {};
+    }
+  }
+
+  async buildHostedHitterParityResult(options = {}) {
     const targetDate = parseDateOrToday(options.date);
     const resolvedDate = await this.getLatestAvailableDate(targetDate);
     if (!resolvedDate) {
       throw new Error('No hosted matchup slate was available in the fallback window.');
     }
 
-    const [slateRows, hitterRows, exclusionRows, rosterRows] = await Promise.all([
+    const [slateRows, hitterRows, pitcherRows, exclusionRows, rosterRows, batterZoneRows, pitcherZoneRows] = await Promise.all([
       this.readDailyFile(resolvedDate, 'slate.parquet', SLATE_COLUMNS),
       this.readDailyFile(resolvedDate, 'daily_hitter_metrics.parquet', HITTER_COLUMNS),
+      this.readDailyFile(resolvedDate, 'daily_pitcher_metrics.parquet', PITCHER_COLUMNS),
       this.readDailyFile(resolvedDate, 'hitter_pitcher_exclusions.parquet', EXCLUSION_COLUMNS).catch(() => []),
       this.readDailyFile(resolvedDate, 'rosters.parquet', ROSTER_COLUMNS).catch(() => []),
+      this.readDailyFile(resolvedDate, 'daily_batter_zone_profiles.parquet', BATTER_ZONE_COLUMNS).catch(() => []),
+      this.readDailyFile(resolvedDate, 'daily_pitcher_zone_profiles.parquet', PITCHER_ZONE_COLUMNS).catch(() => []),
     ]);
 
-    const exclusionSet = buildExclusionSet(exclusionRows);
+    const split = String(options.split ?? DEFAULT_SPLIT_KEY);
+    const recentWindow = String(options.recentWindow ?? DEFAULT_RECENT_WINDOW);
+    const weightedMode = String(options.weightedMode ?? DEFAULT_WEIGHTED_MODE);
+    const likelyOnly = options.likelyOnly === true;
     const slateLookup = mapSlateTeams(slateRows);
+    const exclusionSet = buildExclusionSet(exclusionRows);
     const rosterLookup = buildRosterLookup(rosterRows);
-    const filteredRows = hitterRows
-      .filter(keepRowForDefaults)
-      .map((row) => withDefaults(row, slateLookup, { rosterLookup, playerType: 'hitter' }))
-      .filter((row) => rowMatchesTeamFilter(row.team, options.team))
-      .filter((row) => {
-        const playerId = row.batter ?? row.player_id;
-        return !exclusionSet.has(String(playerId ?? ''));
+    const rosterIdsByTeam = buildRosterIdsByTeam(rosterRows);
+    const validTeams = [...new Set(slateRows.flatMap((row) => [normalizeTeam(row.away_team), normalizeTeam(row.home_team)]).filter(Boolean))];
+    const rotowireLineups = await this.fetchRotowireLineups(resolvedDate, validTeams, rosterRows);
+    const filteredPitchers = pitcherRows.filter((row) =>
+      String(row.split_key ?? DEFAULT_SPLIT_KEY) === split
+      && String(row.recent_window ?? DEFAULT_RECENT_WINDOW) === recentWindow
+      && String(row.weighted_mode ?? DEFAULT_WEIGHTED_MODE) === weightedMode
+    );
+    const pitchersById = new Map();
+    for (const row of filteredPitchers) {
+      pitchersById.set(String(row.pitcher_id ?? row.player_id ?? ''), row);
+    }
+
+    const allRows = [];
+    const boardRows = [];
+    for (const slateRow of slateRows) {
+      const gamePk = slateRow.game_pk ?? null;
+      const awayTeam = normalizeTeam(slateRow.away_team);
+      const homeTeam = normalizeTeam(slateRow.home_team);
+      const awayPitcher = pitchersById.get(String(slateRow.away_probable_pitcher_id ?? '')) ?? null;
+      const homePitcher = pitchersById.get(String(slateRow.home_probable_pitcher_id ?? '')) ?? null;
+      const awayHand = String(homePitcher?.p_throws ?? slateRow.home_probable_hand ?? '').trim().toUpperCase() || null;
+      const homeHand = String(awayPitcher?.p_throws ?? slateRow.away_probable_hand ?? '').trim().toUpperCase() || null;
+
+      const awayRows = this.prepareHostedTeamHitters({
+        team: awayTeam,
+        slateLookup,
+        rosterLookup,
+        rosterIdsByTeam,
+        exclusionSet,
+        rotowireLineups,
+        hitterRows,
+        opposingPitcherHand: awayHand,
+        split,
+        recentWindow,
+        weightedMode,
+        likelyOnly,
+      });
+      const homeRows = this.prepareHostedTeamHitters({
+        team: homeTeam,
+        slateLookup,
+        rosterLookup,
+        rosterIdsByTeam,
+        exclusionSet,
+        rotowireLineups,
+        hitterRows,
+        opposingPitcherHand: homeHand,
+        split,
+        recentWindow,
+        weightedMode,
+        likelyOnly,
       });
 
+      const awayScored = addHitterMatchupScore(awayRows, batterZoneRows, pitcherZoneRows);
+      const homeScored = addHitterMatchupScore(homeRows, batterZoneRows, pitcherZoneRows);
+      const combinedGameRows = sortHittersLiveApp([...awayScored, ...homeScored]);
+      allRows.push(...combinedGameRows);
+      boardRows.push(...combinedGameRows.slice(0, 3));
+    }
+
+    const sortedRows = sortHittersLiveApp(allRows);
+    const sortedBoardRows = sortHittersLiveApp(boardRows);
+    const filteredRows = sortedRows.filter((row) => rowMatchesTeamFilter(row.team, options.team));
+    const filteredBoardRows = sortedBoardRows.filter((row) => rowMatchesTeamFilter(row.team, options.team));
+
     return {
       source: 'hosted',
       resolvedDate,
-        rows: sortHitters(filteredRows).slice(0, limitOrDefault(options.limit)),
-      };
+      parityRanked: true,
+      rows: filteredRows,
+      boardRows: filteredBoardRows,
+    };
+  }
+
+  prepareHostedTeamHitters({
+    team,
+    slateLookup,
+    rosterLookup,
+    rosterIdsByTeam,
+    exclusionSet,
+    rotowireLineups,
+    hitterRows,
+    opposingPitcherHand,
+    split,
+    recentWindow,
+    weightedMode,
+    likelyOnly,
+  }) {
+    const normalizedTeam = normalizeTeam(team);
+    const effectiveSplit = split === DEFAULT_SPLIT_KEY && opposingPitcherHand === 'R'
+      ? 'vs_rhp'
+      : split === DEFAULT_SPLIT_KEY && opposingPitcherHand === 'L'
+        ? 'vs_lhp'
+        : split;
+    const rosterPlayerIds = rosterIdsByTeam.get(normalizedTeam) ?? null;
+
+    const preparedRows = hitterRows
+      .filter((row) => normalizeTeam(row.team) === normalizedTeam)
+      .filter((row) => String(row.split_key ?? DEFAULT_SPLIT_KEY) === effectiveSplit)
+      .filter((row) => String(row.recent_window ?? DEFAULT_RECENT_WINDOW) === recentWindow)
+      .filter((row) => String(row.weighted_mode ?? DEFAULT_WEIGHTED_MODE) === weightedMode)
+      .filter((row) => !rosterPlayerIds || rosterPlayerIds.has(String(row.batter ?? row.player_id ?? '').trim()))
+      .filter((row) => !exclusionSet.has(String(row.batter ?? row.player_id ?? '').trim()))
+      .map((row) => withDefaults(row, slateLookup, { rosterLookup, playerType: 'hitter' }))
+      .filter((row) => !likelyOnly || (numberOrNull(row.likely_starter_score) ?? 0) > 0);
+
+    return applyProjectedLineup(preparedRows, normalizedTeam, rotowireLineups);
+  }
+
+  async getTopHitters(options = {}) {
+    const result = await this.buildHostedHitterParityResult(options);
+    return {
+      source: result.source,
+      resolvedDate: result.resolvedDate,
+      parityRanked: true,
+      rows: result.rows.slice(0, limitOrDefault(options.limit)),
+    };
   }
 
   async getTopPitchers(options = {}) {
@@ -953,64 +1416,12 @@ export class HostedArtifactSource {
   }
 
   async getBestMatchups(options = {}) {
-    const targetDate = parseDateOrToday(options.date);
-    const resolvedDate = await this.getLatestAvailableDate(targetDate);
-    if (!resolvedDate) {
-      throw new Error('No hosted matchup slate was available in the fallback window.');
-    }
-
-    const [slateRows, hitterRows, exclusionRows, rosterRows, batterZoneRows, pitcherZoneRows] = await Promise.all([
-      this.readDailyFile(resolvedDate, 'slate.parquet', SLATE_COLUMNS),
-      this.readDailyFile(resolvedDate, 'daily_hitter_metrics.parquet', HITTER_COLUMNS),
-      this.readDailyFile(resolvedDate, 'hitter_pitcher_exclusions.parquet', EXCLUSION_COLUMNS).catch(() => []),
-      this.readDailyFile(resolvedDate, 'rosters.parquet', ROSTER_COLUMNS).catch(() => []),
-      this.readDailyFile(resolvedDate, 'daily_batter_zone_profiles.parquet', BATTER_ZONE_COLUMNS).catch(() => []),
-      this.readDailyFile(resolvedDate, 'daily_pitcher_zone_profiles.parquet', PITCHER_ZONE_COLUMNS).catch(() => []),
-    ]);
-
-    const slateLookup = mapSlateTeams(slateRows);
-    const exclusionSet = buildExclusionSet(exclusionRows);
-    const rosterLookup = buildRosterLookup(rosterRows);
-    const rosterIdsByTeam = new Map();
-    for (const row of rosterRows) {
-      const team = normalizeTeam(row.team);
-      const playerId = String(row.player_id ?? '').trim();
-      if (!team || !playerId) {
-        continue;
-      }
-      const bucket = rosterIdsByTeam.get(team) ?? new Set();
-      bucket.add(playerId);
-      rosterIdsByTeam.set(team, bucket);
-    }
-
-    const scoredRows = [];
-    for (const [team, slate] of slateLookup.entries()) {
-      if (!rowMatchesTeamFilter(team, options.team)) {
-        continue;
-      }
-
-      const splitKey = slate.opposingPitcherHand === 'R'
-        ? 'vs_rhp'
-        : slate.opposingPitcherHand === 'L'
-          ? 'vs_lhp'
-          : DEFAULT_SPLIT_KEY;
-      const rosterPlayerIds = rosterIdsByTeam.get(normalizeTeam(team)) ?? null;
-      const teamRows = hitterRows
-        .filter((row) => normalizeTeam(row.team) === normalizeTeam(team))
-        .filter((row) => String(row.split_key ?? '') === splitKey)
-        .filter((row) => String(row.recent_window ?? '') === DEFAULT_RECENT_WINDOW)
-        .filter((row) => String(row.weighted_mode ?? '') === DEFAULT_WEIGHTED_MODE)
-        .filter((row) => !rosterPlayerIds || rosterPlayerIds.has(String(row.batter ?? row.player_id ?? '')))
-        .filter((row) => !exclusionSet.has(String(row.batter ?? row.player_id ?? '')))
-        .map((row) => withDefaults(row, slateLookup, { rosterLookup, playerType: 'hitter' }));
-
-      scoredRows.push(...addHitterMatchupScore(teamRows, batterZoneRows, pitcherZoneRows));
-    }
-
+    const result = await this.buildHostedHitterParityResult(options);
     return {
-      source: 'hosted',
-      resolvedDate,
-      rows: buildBestMatchupBoardRows(scoredRows).slice(0, limitOrDefault(options.limit ?? (options.team ? 3 : 12), 12)),
+      source: result.source,
+      resolvedDate: result.resolvedDate,
+      parityRanked: true,
+      rows: result.boardRows.slice(0, limitOrDefault(options.limit ?? (options.team ? 3 : 12), 12)),
     };
   }
 
@@ -1456,7 +1867,7 @@ export class MatchupService {
     if (this.hosted?.isConfigured?.()) {
       try {
         const hostedResult = await this.hosted[methodName](options);
-        if (methodName === 'getTopHitters') {
+        if (methodName === 'getTopHitters' && !hostedResult?.parityRanked) {
           return await this.enrichHostedHitters(hostedResult, options, methodName);
         }
         return hostedResult;
@@ -1555,6 +1966,20 @@ export class MatchupService {
   }
 }
 
+async function defaultFetchText(url, targetDate) {
+  const requestUrl = new URL(url);
+  requestUrl.searchParams.set('date', parseDateOrToday(targetDate));
+  const response = await fetch(requestUrl, {
+    headers: {
+      'User-Agent': 'KasperMLB/1.0',
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`Rotowire request failed with status ${response.status}`);
+  }
+  return response.text();
+}
+
 export async function readParquetFromUrl(url, columns) {
   const file = await asyncBufferFromUrl({ url });
   return parquetReadObjects({

test/matchups.test.js

@@ -11,6 +11,8 @@ test('hosted artifact source resolves latest available daily slate and caches pa
         game_pk: 10,
         away_team: 'CHC',
         home_team: 'MIL',
+        away_probable_pitcher_id: 1001,
+        home_probable_pitcher_id: 1002,
         away_probable_pitcher: 'Shota Imanaga',
         home_probable_pitcher: 'Freddy Peralta',
         away_probable_hand: 'L',
@@ -20,20 +22,48 @@ test('hosted artifact source resolves latest available daily slate and caches pa
     ['https://example.test/daily/2026-04-06/daily_hitter_metrics.parquet', [
       {
         team: 'CHC',
-        hitter_name: 'Seiya Suzuki',
+        hitter_name: '100',
         batter: 100,
-        split_key: 'overall',
+        stand: 'R',
+        split_key: 'vs_rhp',
         recent_window: 'season',
         weighted_mode: 'weighted',
-        matchup_score: 82.4,
-        ceiling_score: 79.5,
-        zone_fit_score: 70.1,
+        swstr_pct: 0.08,
+        barrel_bbe_pct: 0.16,
+        barrel_bip_pct: 0.14,
+        pulled_barrel_pct: 0.11,
+        sweet_spot_pct: 0.37,
         likely_starter_score: 98.2,
         xwoba: 0.398,
+        fb_pct: 0.29,
         hard_hit_pct: 48.2,
+        avg_launch_angle: 17.2,
+      },
+    ]],
+    ['https://example.test/daily/2026-04-06/daily_pitcher_metrics.parquet', [
+      {
+        pitcher_id: 1001,
+        pitcher_name: 'Shota Imanaga',
+        p_throws: 'L',
+        split_key: 'overall',
+        recent_window: 'season',
+        weighted_mode: 'weighted',
+      },
+      {
+        pitcher_id: 1002,
+        pitcher_name: 'Freddy Peralta',
+        p_throws: 'R',
+        split_key: 'overall',
+        recent_window: 'season',
+        weighted_mode: 'weighted',
       },
     ]],
     ['https://example.test/daily/2026-04-06/hitter_pitcher_exclusions.parquet', []],
+    ['https://example.test/daily/2026-04-06/rosters.parquet', [
+      { team: 'CHC', player_id: 100, player_name: 'Seiya Suzuki' },
+    ]],
+    ['https://example.test/daily/2026-04-06/daily_batter_zone_profiles.parquet', []],
+    ['https://example.test/daily/2026-04-06/daily_pitcher_zone_profiles.parquet', []],
   ]);
   const calls = [];
   const source = new HostedArtifactSource(
@@ -50,6 +80,7 @@ test('hosted artifact source resolves latest available daily slate and caches pa
         }
         return responses.get(url);
       },
+      fetchTextImpl: async () => '',
       logger: { debug() {}, warn() {} },
     }
   );
@@ -72,6 +103,8 @@ test('hosted artifact source matches common team aliases against team abbreviati
         game_pk: 20,
         away_team: 'ATH',
         home_team: 'NYY',
+        away_probable_pitcher_id: 2001,
+        home_probable_pitcher_id: 2002,
         away_probable_pitcher: 'JP Sears',
         home_probable_pitcher: 'Carlos Rodon',
         away_probable_hand: 'L',
@@ -96,6 +129,10 @@ test('hosted artifact source matches common team aliases against team abbreviati
         avg_launch_angle: 14.2,
       },
     ]],
+    ['https://example.test/daily/2026-04-07/daily_pitcher_metrics.parquet', [
+      { pitcher_id: 2001, pitcher_name: 'JP Sears', p_throws: 'L', split_key: 'overall', recent_window: 'season', weighted_mode: 'weighted' },
+      { pitcher_id: 2002, pitcher_name: 'Carlos Rodon', p_throws: 'L', split_key: 'overall', recent_window: 'season', weighted_mode: 'weighted' },
+    ]],
     ['https://example.test/daily/2026-04-07/hitter_pitcher_exclusions.parquet', []],
     ['https://example.test/daily/2026-04-07/rosters.parquet', [
       {
@@ -121,6 +158,7 @@ test('hosted artifact source matches common team aliases against team abbreviati
         }
         return responses.get(url);
       },
+      fetchTextImpl: async () => '',
       logger: { debug() {}, warn() {} },
     }
   );
@@ -186,6 +224,24 @@ test('hosted best matchups uses pitcher-hand split rows from hosted slate inputs
         avg_launch_angle: 20,
       },
     ]],
+    ['https://example.test/daily/2026-04-07/daily_pitcher_metrics.parquet', [
+      {
+        pitcher_id: 501,
+        pitcher_name: 'Garrett Crochet',
+        p_throws: 'L',
+        split_key: 'overall',
+        recent_window: 'season',
+        weighted_mode: 'weighted',
+      },
+      {
+        pitcher_id: 601,
+        pitcher_name: 'Freddy Peralta',
+        p_throws: 'R',
+        split_key: 'overall',
+        recent_window: 'season',
+        weighted_mode: 'weighted',
+      },
+    ]],
     ['https://example.test/daily/2026-04-07/hitter_pitcher_exclusions.parquet', []],
     ['https://example.test/daily/2026-04-07/rosters.parquet', [
       { team: 'MIL', player_id: 123, player_name: 'Gary Sanchez' },
@@ -207,6 +263,7 @@ test('hosted best matchups uses pitcher-hand split rows from hosted slate inputs
         }
         return responses.get(url);
       },
+      fetchTextImpl: async () => '',
       logger: { debug() {}, warn() {} },
     }
   );
@@ -286,6 +343,12 @@ test('hosted best matchups keeps only the top three hitters per game before rank
       { team: 'BOS', hitter_name: '23', batter: 23, stand: 'L', split_key: 'vs_rhp', recent_window: 'season', weighted_mode: 'weighted', xwoba: 0.350, swstr_pct: 0.10, barrel_bbe_pct: 0.13, barrel_bip_pct: 0.11, pulled_barrel_pct: 0.07, sweet_spot_pct: 0.33, fb_pct: 0.24, hard_hit_pct: 0.41, avg_launch_angle: 16 },
       { team: 'BAL', hitter_name: '24', batter: 24, stand: 'L', split_key: 'vs_rhp', recent_window: 'season', weighted_mode: 'weighted', xwoba: 0.330, swstr_pct: 0.11, barrel_bbe_pct: 0.11, barrel_bip_pct: 0.09, pulled_barrel_pct: 0.06, sweet_spot_pct: 0.31, fb_pct: 0.22, hard_hit_pct: 0.39, avg_launch_angle: 14 },
     ]],
+    ['https://example.test/daily/2026-04-07/daily_pitcher_metrics.parquet', [
+      { pitcher_id: 101, pitcher_name: 'Away One', p_throws: 'R', split_key: 'overall', recent_window: 'season', weighted_mode: 'weighted' },
+      { pitcher_id: 201, pitcher_name: 'Home One', p_throws: 'L', split_key: 'overall', recent_window: 'season', weighted_mode: 'weighted' },
+      { pitcher_id: 301, pitcher_name: 'Away Two', p_throws: 'R', split_key: 'overall', recent_window: 'season', weighted_mode: 'weighted' },
+      { pitcher_id: 401, pitcher_name: 'Home Two', p_throws: 'R', split_key: 'overall', recent_window: 'season', weighted_mode: 'weighted' },
+    ]],
     ['https://example.test/daily/2026-04-07/hitter_pitcher_exclusions.parquet', []],
     ['https://example.test/daily/2026-04-07/rosters.parquet', [
       { team: 'NYY', player_id: 11, player_name: 'Game One A' },
@@ -314,6 +377,7 @@ test('hosted best matchups keeps only the top three hitters per game before rank
         }
         return responses.get(url);
       },
+      fetchTextImpl: async () => '',
       logger: { debug() {}, warn() {} },
     }
   );