tods-competition-factory 1.7.5 → 1.7.7

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.5";
+  return "1.7.7";
 }
 
 function getObjectTieFormat(obj) {
@@ -1727,6 +1727,9 @@ function handleCaughtError({
   });
 }
 
+function isString(obj) {
+  return typeof obj === "string";
+}
 function isObject(obj) {
   return typeof obj === "object";
 }
@@ -4163,7 +4166,7 @@ const WIN_RATIO$1 = "winRatio";
 const POLICY_COMPETITIVE_BANDS_DEFAULT = {
   [POLICY_TYPE_COMPETITIVE_BANDS]: {
     policyName: "Competitive Bands Default",
-    competitiveProfile: {
+    profileBands: {
       [DECISIVE]: 20,
       [ROUTINE]: 50
     }
@@ -4217,7 +4220,8 @@ function getCollectionPositionMatchUps({ matchUps }) {
 
 const add = (a, b) => (a || 0) + (b || 0);
 function getBand(spread, bandProfiles) {
-  return isNaN(spread) && WALKOVER$1 || spread <= bandProfiles[DECISIVE] && DECISIVE || spread <= bandProfiles[ROUTINE] && ROUTINE || COMPETITIVE;
+  const spreadValue = Array.isArray(spread) ? spread[0] : spread;
+  return isNaN(spreadValue) && WALKOVER$1 || spreadValue <= bandProfiles[DECISIVE] && DECISIVE || spreadValue <= bandProfiles[ROUTINE] && ROUTINE || COMPETITIVE;
 }
 function getScoreComponents({ score }) {
   const sets = score?.sets || [];
@@ -4248,7 +4252,7 @@ function gamesPercent(scoreComponents) {
   return Math.round(minGames / maxGames * 100);
 }
 function pctSpread(pcts) {
-  return pcts.map(gamesPercent).sort().map((p) => p.toFixed(2));
+  return pcts.map(gamesPercent).sort().map((p) => parseFloat(p.toFixed(2)));
 }
 
 function findPolicy({
@@ -4269,8 +4273,8 @@ function findPolicy({
   return appliedPolicies?.[policyType] ? { policy: appliedPolicies[policyType] } : { error: POLICY_NOT_FOUND };
 }
 
-function getMatchUpCompetitiveness({
-  competitiveProfile,
+function getMatchUpCompetitiveProfile({
+  profileBands,
   tournamentRecord,
   matchUp
 }) {
@@ -4279,15 +4283,16 @@ function getMatchUpCompetitiveness({
   const { score, winningSide } = matchUp;
   if (!winningSide)
     return { error: INVALID_VALUES };
-  const policy = !competitiveProfile && tournamentRecord && findPolicy({
+  const policy = !profileBands && tournamentRecord && findPolicy({
     policyType: POLICY_TYPE_COMPETITIVE_BANDS,
     tournamentRecord
   }).policy;
-  const bandProfiles = competitiveProfile || policy?.competitiveProfile || POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].competitiveProfile;
+  const bandProfiles = profileBands || policy?.profileBands || POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].profileBands;
   const scoreComponents = getScoreComponents({ score });
   const spread = pctSpread([scoreComponents]);
   const competitiveness = getBand(spread, bandProfiles);
-  return { ...SUCCESS, competitiveness };
+  const pctSpreadValue = Array.isArray(spread) ? spread[0] : spread;
+  return { ...SUCCESS, competitiveness, pctSpread: pctSpreadValue };
 }
 
 function findMatchupFormatAverageTimes(params) {
@@ -7606,6 +7611,9 @@ function isAdHoc({ drawDefinition, structure }) {
 const POLICY_ROUND_NAMING_DEFAULT = {
   [POLICY_TYPE_ROUND_NAMING]: {
     policyName: "Round Naming Default",
+    namingConventions: {
+      round: "Round"
+    },
     abbreviatedRoundNamingMap: {
       // key is matchUpsCount for the round
       1: "F",
@@ -7645,6 +7653,9 @@ function getRoundContextProfile({
   const roundNamingMap = roundNamingPolicy?.roundNamingMap || defaultRoundNamingPolicy.roundNamingMap || {};
   const abbreviatedRoundNamingMap = roundNamingPolicy?.abbreviatedRoundNamingMap || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
   const roundNamePrefix = roundNamingPolicy?.affixes || defaultRoundNamingPolicy.affixes;
+  const roundNumberAffix = roundNamePrefix.roundNumber || defaultRoundNamingPolicy.affixes.roundNumber;
+  const namingConventions = roundNamingPolicy?.namingConventions || defaultRoundNamingPolicy.namingConventions;
+  const roundNameFallback = namingConventions.round;
   const stageInitial = stage && stage !== MAIN && stage[0];
   const stageConstants = roundNamingPolicy?.stageConstants;
   const stageConstant = stage && stageConstants?.[stage] || stageInitial;
@@ -7653,8 +7664,8 @@ function getRoundContextProfile({
     Object.assign(
       roundNamingProfile,
       ...roundProfileKeys.map((key) => {
-        const roundName = `Round ${key}`;
-        const abbreviatedRoundName = `R${key}`;
+        const roundName = `${roundNameFallback} ${key}`;
+        const abbreviatedRoundName = `${roundNumberAffix}${key}`;
         return { [key]: { roundName, abbreviatedRoundName } };
       })
     );
@@ -8012,7 +8023,7 @@ function getAllStructureMatchUps({
       ...collectionDefinition.category
     } : context?.category;
     const processCodes = matchUp.processCodes?.length && matchUp.processCodes || collectionDefinition?.processCodes?.length && collectionDefinition?.processCodes || structure?.processCodes?.length && structure?.processCodes || drawDefinition?.processCodes?.length && drawDefinition?.processCodes || event2?.processCodes?.length && event2?.processCodes || tournamentRecord?.processCodes;
-    const competitiveness = contextProfile?.withCompetitiveness && getMatchUpCompetitiveness({ ...contextContent, matchUp }).competitiveness;
+    const competitiveProfile = contextProfile?.withCompetitiveness && getMatchUpCompetitiveProfile({ ...contextContent, matchUp });
     const finishingPositionRange = matchUp.finishingPositionRange || additionalContext.finishingPositionRange;
     const onlyDefined = (obj) => definedAttributes(obj, void 0, true);
     const matchUpWithContext = {
@@ -8028,7 +8039,7 @@ function getAllStructureMatchUps({
         finishingPositionRange,
         abbreviatedRoundName,
         drawPositionsRange,
-        competitiveness,
+        competitiveProfile,
         structureName,
         stageSequence,
         drawPositions,
@@ -13381,13 +13392,19 @@ const ratingConstants = {
 };
 
 const ratingsParameters = {
-  [ELO]: { range: [0, 3e3], decimalsCount: 0, defaultInitialization: 1500 },
+  [ELO]: {
+    defaultInitialization: 1500,
+    decimalsCount: 0,
+    range: [0, 3e3],
+    ascending: true
+  },
   [NTRP]: {
     accessors: ["ntrpRating", "dntrpRatingHundredths"],
     attributes: { ustaRatingType: "" },
     accessor: "dntrpRatingHundredths",
     defaultInitialization: 3,
     decimalsCount: 1,
+    ascending: true,
     range: [1, 7]
   },
   [UTR]: {
@@ -13395,6 +13412,7 @@ const ratingsParameters = {
     accessors: ["utrRating"],
     accessor: "utrRating",
     decimalsCount: 2,
+    ascending: true,
     range: [1, 16]
   },
   [WTN]: {
@@ -13402,6 +13420,7 @@ const ratingsParameters = {
     accessors: ["wtnRating", "confidence"],
     defaultInitialization: 23,
     accessor: "wtnRating",
+    ascending: false,
     decimalsCount: 2,
     range: [40, 1]
   }
@@ -26373,8 +26392,8 @@ function modifyMatchUpFormatTiming$1({
       recoveryTimes
     });
     addTournamentExtension({
-      tournamentRecord,
-      extension: { name, value }
+      extension: { name, value },
+      tournamentRecord
     });
   }
   return { ...SUCCESS };
@@ -32229,8 +32248,8 @@ function checkSchedulingProfile$1({ tournamentRecords }) {
 }
 
 function scheduledSortedMatchUps({
-  matchUps = [],
-  schedulingProfile
+  schedulingProfile,
+  matchUps = []
 }) {
   const profileHash = {};
   const getHash = ({ eventId, drawId, structureId, roundNumber }) => {
@@ -46724,6 +46743,10 @@ function removeDelegatedOutcome$1({ drawDefinition, event, matchUpId }) {
   });
 }
 
+function stringSort(a, b) {
+  return (a || "").localeCompare(b || "");
+}
+
 function generateCandidate({
   maxIterations = 4e3,
   // cap the processing intensity of the candidate generator
@@ -46858,7 +46881,7 @@ function roundCandidate({
   return { value: candidateValue, participantIdPairings, maxDelta, maxDiff };
 }
 function pairingHash(id1, id2) {
-  return [id1, id2].sort().join("|");
+  return [id1, id2].sort(stringSort).join("|");
 }
 
 function getPairingsData({ participantIds }) {
@@ -47458,7 +47481,10 @@ const matchUpGovernor = {
   validateScore
 };
 
-function attachPolicies({ drawDefinition, policyDefinitions }) {
+function attachPolicies({
+  drawDefinition,
+  policyDefinitions
+}) {
   if (!drawDefinition) {
     return { error: MISSING_DRAW_DEFINITION };
   }
@@ -47468,8 +47494,9 @@ function attachPolicies({ drawDefinition, policyDefinitions }) {
   if (!drawDefinition.extensions)
     drawDefinition.extensions = [];
   const appliedPolicies = getAppliedPolicies({ drawDefinition })?.appliedPolicies ?? {};
+  const validReplacements = [POLICY_TYPE_ROUND_NAMING, POLICY_TYPE_DISPLAY];
   const applied = Object.keys(policyDefinitions).every((policyType) => {
-    if (!appliedPolicies[policyType]) {
+    if (!appliedPolicies[policyType] || validReplacements.includes(policyType)) {
       appliedPolicies[policyType] = policyDefinitions[policyType];
       return true;
     } else {
@@ -52897,6 +52924,20 @@ function setTournamentStatus({ tournamentRecord, status }) {
   return { ...SUCCESS };
 }
 
+function addOnlineResource({
+  tournamentRecord,
+  onlineResource
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!onlineResource)
+    return { error: MISSING_VALUE };
+  if (!tournamentRecord.onlineResources)
+    tournamentRecord.onlineResources = [];
+  tournamentRecord.onlineResources.push(onlineResource);
+  return { ...SUCCESS };
+}
+
 function analyzeDraws({ tournamentRecord }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
@@ -53175,10 +53216,11 @@ function removeInvalidScheduling({ tournamentRecord }) {
 }
 
 const tournamentGovernor = {
-  addNotes,
-  removeNotes,
-  analyzeDraws,
   analyzeTournament,
+  analyzeDraws,
+  addOnlineResource,
+  removeNotes,
+  addNotes,
   completeDrawMatchUps,
   getRounds,
   getProfileRounds,
@@ -56396,13 +56438,6 @@ function deleteFlightAndFlightDraw({
   return refreshEventDrawOrder({ tournamentRecord, event });
 }
 
-function generateAdHocMatchUps(params) {
-  return generateAdHocMatchUps$1(params);
-}
-function addAdHocMatchUps(params) {
-  return addAdHocMatchUps$1(params);
-}
-
 function attachFlightProfile({ deleteExisting, event, flightProfile }) {
   const stack = "attachFlightProfile";
   if (!flightProfile)
@@ -56608,6 +56643,98 @@ function deleteAdHocMatchUps(params) {
   return deleteAdHocMatchUps$1(params);
 }
 
+function modifyDrawName({
+  tournamentRecord,
+  drawDefinition,
+  flightProfile,
+  drawName,
+  drawId,
+  event
+}) {
+  if (!drawName || typeof drawName !== "string")
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { drawName }
+    });
+  if (!flightProfile) {
+    flightProfile = getFlightProfile({ event }).flightProfile;
+  }
+  const flight = flightProfile?.flights?.find(
+    (flight2) => flight2.drawId === drawId
+  );
+  if (flight) {
+    flight.drawName = drawName;
+    const extension = {
+      name: FLIGHT_PROFILE,
+      value: {
+        ...flightProfile,
+        flights: flightProfile.flights
+      }
+    };
+    addEventExtension$1({ event, extension });
+  }
+  if (drawDefinition) {
+    drawDefinition.drawName = drawName;
+    modifyDrawNotice({
+      tournamentId: tournamentRecord?.tournamentId,
+      drawDefinition
+    });
+  }
+  if (!flight && !drawDefinition) {
+    return { error: MISSING_DRAW_DEFINITION };
+  }
+  return { ...SUCCESS, flight };
+}
+
+function modifyDrawDefinition({
+  tournamentRecord,
+  drawDefinition,
+  drawUpdates,
+  drawId,
+  event
+}) {
+  if (!isObject(drawUpdates))
+    return { error: INVALID_END_TIME };
+  const flightProfile = getFlightProfile({ event }).flightProfile;
+  const nameResult = drawUpdates.drawName && modifyDrawName({
+    drawName: drawUpdates.drawName,
+    tournamentRecord,
+    drawDefinition,
+    flightProfile,
+    drawId,
+    event
+  });
+  if (nameResult?.error)
+    return nameResult?.error;
+  const flight = nameResult?.flight || flightProfile?.flights?.find((flight2) => flight2.drawId === drawId);
+  if (!flight && !drawDefinition) {
+    return { error: MISSING_DRAW_DEFINITION };
+  }
+  if (flight) {
+    const extension = {
+      name: FLIGHT_PROFILE,
+      value: {
+        ...flightProfile,
+        flights: flightProfile.flights
+      }
+    };
+    addEventExtension$1({ event, extension });
+  }
+  if (drawDefinition) {
+    if (drawUpdates.policyDefinitions) {
+      attachPolicies({
+        policyDefinitions: drawUpdates.policyDefinitions,
+        drawDefinition
+      });
+    }
+    modifyDrawNotice({
+      tournamentId: tournamentRecord?.tournamentId,
+      drawDefinition
+    });
+  }
+  return { ...SUCCESS };
+}
+
 function resetDrawDefinition({
   tournamentRecord,
   removeScheduling,
@@ -56768,34 +56895,6 @@ function setOrderOfFinish(params) {
   return setOrderOfFinish$1(params);
 }
 
-function modifyDrawName({ event, drawId, drawDefinition, drawName }) {
-  if (!drawName || typeof drawName !== "string")
-    return { error: INVALID_VALUES, drawName };
-  const { flightProfile } = getFlightProfile({ event });
-  const flight = flightProfile?.flights?.find(
-    (flight2) => flight2.drawId === drawId
-  );
-  if (flight) {
-    flight.drawName = drawName;
-    const extension = {
-      name: FLIGHT_PROFILE,
-      value: {
-        ...flightProfile,
-        flights: flightProfile.flights
-      }
-    };
-    addEventExtension$1({ event, extension });
-  }
-  if (drawDefinition) {
-    drawDefinition.drawName = drawName;
-    modifyDrawNotice({ drawDefinition });
-  }
-  if (!flight && !drawDefinition) {
-    return { error: MISSING_DRAW_DEFINITION };
-  }
-  return { ...SUCCESS };
-}
-
 function modifyEventEntries({
   entryStatus = DIRECT_ACCEPTANCE,
   unpairedParticipantIds = [],
@@ -56931,6 +57030,13 @@ function addFlight({
   return addEventExtension$1({ event, extension });
 }
 
+function generateAdHocMatchUps(params) {
+  return generateAdHocMatchUps$1(params);
+}
+function addAdHocMatchUps(params) {
+  return addAdHocMatchUps$1(params);
+}
+
 function attachConsolationStructures(params) {
   return attachStructures({
     ...params,
@@ -58092,6 +58198,61 @@ function enableTieAutoCalc(params) {
   return enableTieAutoCalc$1(params);
 }
 
+function modifyEvent({
+  tournamentRecord,
+  eventUpdates,
+  eventId,
+  event
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!isString(eventId) || !isObject(eventUpdates))
+    return { error: INVALID_VALUES };
+  const enteredParticipantIds = event?.entries?.filter(({ entryStatus }) => {
+    const status = entryStatus;
+    return [...STRUCTURE_SELECTED_STATUSES, ALTERNATE].includes(status);
+  }).map(({ participantId }) => participantId) || [];
+  const enteredParticipants = enteredParticipantIds ? getParticipants$1({
+    participantFilters: { participantIds: enteredParticipantIds },
+    withIndividualParticipants: true,
+    tournamentRecord
+  }).participants || [] : [];
+  const genderAccumulator = [];
+  const enteredParticipantTypes = enteredParticipants.reduce(
+    (types, participant) => {
+      const genders = participant.person?.sex ? [participant.person.sex] : participant.individualParticpants?.map((p) => p.person?.sex) || [];
+      genderAccumulator.push(...genders);
+      return !types.includes(participant.participantType) ? types.concat(participant.participantType) : types;
+    },
+    []
+  );
+  const enteredParticipantGenders = unique(genderAccumulator);
+  const validGender = !enteredParticipantGenders.length || [MIXED, ANY].includes(eventUpdates.gender || "") || enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender;
+  if (eventUpdates.gender && !validGender)
+    return decorateResult({
+      context: { gender: eventUpdates.gender },
+      result: { error: INVALID_VALUES }
+    });
+  const validEventTypes = enteredParticipantTypes.includes(TEAM$1) && [TEAM$1] || enteredParticipantTypes.includes(INDIVIDUAL) && [SINGLES] || enteredParticipantTypes.includes(PAIR) && [DOUBLES] || [
+    DOUBLES,
+    SINGLES,
+    TEAM$1
+  ];
+  const validEventType = validEventTypes.includes(eventUpdates.eventType || "");
+  if (eventUpdates.eventType && !validEventType)
+    return decorateResult({
+      context: { participantType: eventUpdates.eventType },
+      result: { error: INVALID_VALUES }
+    });
+  if (eventUpdates.eventType)
+    event.eventType === eventUpdates.eventType;
+  if (eventUpdates.eventName)
+    event.eventName = eventUpdates.eventName;
+  if (eventUpdates.gender)
+    event.gender = eventUpdates.gender;
+  return { ...SUCCESS };
+}
+
 const eventGovernor = {
   generateQualifyingStructure,
   attachQualifyingStructure,
@@ -58112,11 +58273,12 @@ const eventGovernor = {
   modifyTieFormat: modifyTieFormat$1,
   resetScorecard,
   resetTieFormat: resetTieFormat$1,
-  addEvent,
-  deleteEvents,
-  setEventDates,
   setEventStartDate,
   setEventEndDate,
+  setEventDates,
+  deleteEvents,
+  modifyEvent,
+  addEvent,
   removeSeededParticipant,
   removeScaleValues,
   checkValidEntries,
@@ -58128,6 +58290,7 @@ const eventGovernor = {
   getAvailablePlayoffProfiles,
   deleteDrawDefinitions,
   addPlayoffStructures,
+  modifyDrawDefinition,
   addDrawDefinition: addDrawDefinition$1,
   removeStructure,
   modifyDrawName,
@@ -58227,16 +58390,14 @@ function getPredictiveAccuracy(params) {
   let { matchUps } = params;
   const {
     tournamentRecord,
-    ascending = true,
     drawDefinition,
     excludeMargin,
     exclusionRule,
-    valueAccessor,
     zoneDoubling,
     matchUpType,
-    zoneMargin,
     scaleName,
     eventId,
+    zonePct,
     drawId,
     event
   } = params;
@@ -58246,6 +58407,11 @@ function getPredictiveAccuracy(params) {
     return { error: INVALID_VALUES, info: { matchUpType } };
   if (matchUps && !validMatchUps(matchUps))
     return { error: INVALID_VALUES, context: { matchUps } };
+  const scaleProfile = ratingsParameters[scaleName];
+  const ascending = scaleProfile?.ascending ?? params.ascending ?? false;
+  const valueAccessor = scaleProfile?.accessor ?? params.valueAccessor;
+  const ratingsRangeDifference = Array.isArray(scaleProfile?.range) ? Math.abs(scaleProfile.range[0] - scaleProfile.range[1]) : 0;
+  const zoneMargin = isConvertableInteger(zonePct) && ratingsRangeDifference ? (zonePct || 0 / 100) * ratingsRangeDifference : params.zoneMargin || ratingsRangeDifference;
   const contextProfile = { withScaleValues: true, withCompetitiveness: true };
   const contextFilters = {
     matchUpTypes: matchUpType ? [matchUpType] : [SINGLES$1, DOUBLES$1]
@@ -58283,7 +58449,7 @@ function getPredictiveAccuracy(params) {
   }
   const relevantMatchUps = matchUps.filter(
     ({ winningSide, score, sides, matchUpStatus }) => ![RETIRED$1, DEFAULTED, WALKOVER$2, DEAD_RUBBER, ABANDONED$1].includes(
-      matchUpStatus
+      matchUpStatus || ""
     ) && scoreHasValue({ score }) && sides?.length === 2 && winningSide
   );
   const accuracy = getGroupingAccuracy({
@@ -58294,8 +58460,8 @@ function getPredictiveAccuracy(params) {
     ascending,
     scaleName
   });
-  const marginCalc = !zoneDoubling || matchUpType === SINGLES$1 ? zoneMargin : zoneMargin * 2;
-  const zoneData = zoneMargin && relevantMatchUps.map(({ competitiveness, matchUpType: matchUpType2, score, sides }) => {
+  const marginCalc = !zoneDoubling || matchUpType === SINGLES$1 ? zoneMargin : (zoneMargin || 0) * 2;
+  const zoneData = zoneMargin ? relevantMatchUps.map(({ competitiveProfile, matchUpType: matchUpType2, score, sides }) => {
     const sideValues = getSideValues({
       valueAccessor,
       matchUpType: matchUpType2,
@@ -58303,11 +58469,15 @@ function getPredictiveAccuracy(params) {
       sides
     });
     const valuesGap = Math.abs(sideValues[0].value - sideValues[1].value);
-    return { competitiveness, score, valuesGap };
+    return {
+      competitiveness: competitiveProfile?.competitiveness,
+      valuesGap,
+      score
+    };
   }).filter(({ valuesGap }) => {
     return valuesGap <= marginCalc;
-  });
-  const zoneBands = zoneData?.length && getGroupingBands({ zoneData });
+  }) : [];
+  const zoneBands = getGroupingBands({ zoneData });
   const totalZoneMatchUps = zoneBands && [].concat(Object.values(zoneBands)).flat().length;
   const zoneDistribution = totalZoneMatchUps && Object.assign(
     {},
@@ -58458,7 +58628,7 @@ function getGroupingAccuracy({
       continue;
     }
     const valuesGap = sideValues[winningIndex].value - sideValues[1 - winningIndex].value;
-    const floatMargin = parseFloat(excludeMargin);
+    const floatMargin = parseFloat(excludeMargin || 0);
     const excludeGap = floatMargin && Math.abs(valuesGap) < floatMargin;
     if (excludeGap) {
       accuracy.excluded.push({
@@ -58471,7 +58641,7 @@ function getGroupingAccuracy({
       });
       continue;
     }
-    const signedGap = ascending ? valuesGap * -1 : valuesGap;
+    const signedGap = ascending ? valuesGap : valuesGap * -1;
     const winningScoreString = winningSide === 1 ? score?.scoreStringSide1 : score?.scoreStringSide2;
     if (signedGap > 0) {
       accuracy.affirmative.push({
@@ -58545,18 +58715,14 @@ function getMatchUpFormat({
   };
 }
 
-function getMatchUpsStats({
-  competitiveProfile,
-  tournamentRecord,
-  matchUps
-}) {
+function getMatchUpsStats({ profileBands, tournamentRecord, matchUps }) {
   if (!validMatchUps(matchUps))
     return { error: MISSING_MATCHUPS };
-  const policy = !competitiveProfile && findPolicy({
+  const policy = !profileBands && findPolicy({
     policyType: POLICY_TYPE_COMPETITIVE_BANDS,
     tournamentRecord
   }).policy;
-  const bandProfiles = competitiveProfile || policy?.competitiveProfile || POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].competitiveProfile;
+  const bandProfiles = profileBands || policy?.profileBands || POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].profileBands;
   const relevantMatchUps = matchUps.filter(({ winningSide }) => winningSide);
   const gamesMap = relevantMatchUps.map(getScoreComponents);
   const categorize = (p, spread) => {
@@ -58745,7 +58911,7 @@ const queryGovernor = {
   getPositionAssignments,
   isValidMatchUpFormat: isValid,
   getMaxEntryPosition,
-  getMatchUpCompetitiveness,
+  getMatchUpCompetitiveProfile,
   findVenue,
   getCourts,
   getVenuesAndCourts: getVenuesAndCourts$1,