tods-competition-factory 0.72.2 → 0.75.0

package/dist/tods-competition-factory.development.cjs.js

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.72.2';
+  return '0.75.0';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -718,6 +718,7 @@ const MISSING_DRAW_DEFINITION = 'Missing drawDefinition';
 const EXISTING_DRAW_DEFINITIONS = 'Existing drawDefinition(s)';
 const DRAW_DEFINITION_NOT_FOUND = 'drawDefinition not found';
 const INVALID_STRUCTURE = 'Invalid structure';
+const INCOMPLETE_SOURCE_STRUCTURE = 'Incomplete source structure';
 const INVALID_DRAW_POSITION_FOR_SEEDING = 'Invalid drawPosition for seedAssignment';
 const DRAW_POSITION_ASSIGNED = 'drawPosition already assigned';
 const DRAW_POSITION_NOT_CLEARED = 'drawPosition not cleared';
@@ -892,6 +893,7 @@ const errorConditionConstants = {
   EXISTING_PROFILE,
   EXISTING_ROUND,
   INCOMPATIBLE_MATCHUP_STATUS,
+  INCOMPLETE_SOURCE_STRUCTURE,
   INVALID_BOOKINGS,
   INVALID_CONFIGURATION,
   INVALID_DATE_AVAILABILITY,
@@ -1021,26 +1023,35 @@ const errorConditionConstants = {
 };
 
 const syncGlobalState = {
+  disableNotifications: false,
   tournamentId: undefined,
   tournamentRecords: {},
   subscriptions: {},
   notices: []
 };
 var syncGlobalState$1 = {
-  setSubscriptions: setSubscriptions$1,
   addNotice: addNotice$1,
-  getNotices: getNotices$1,
+  callListener: callListener$1,
   deleteNotices: deleteNotices$1,
+  disableNotifications: disableNotifications$1,
+  enableNotifications: enableNotifications$1,
+  getNotices: getNotices$1,
   getTopics: getTopics$1,
-  callListener: callListener$1,
   getTournamentId: getTournamentId$1,
   getTournamentRecord: getTournamentRecord$1,
   getTournamentRecords: getTournamentRecords$1,
+  removeTournamentRecord: removeTournamentRecord$1,
+  setSubscriptions: setSubscriptions$1,
   setTournamentId: setTournamentId$1,
   setTournamentRecord: setTournamentRecord$2,
-  setTournamentRecords: setTournamentRecords$1,
-  removeTournamentRecord: removeTournamentRecord$1
+  setTournamentRecords: setTournamentRecords$1
 };
+function disableNotifications$1() {
+  syncGlobalState.disableNotifications = true;
+}
+function enableNotifications$1() {
+  syncGlobalState.disableNotifications = false;
+}
 function getTournamentId$1() {
   return syncGlobalState.tournamentId;
 }
@@ -1127,7 +1138,7 @@ function addNotice$1({
     return;
   }
 
-  if (!syncGlobalState.subscriptions[topic]) return;
+  if (syncGlobalState.disableNotifications || !syncGlobalState.subscriptions[topic]) return;
 
   if (key) {
     syncGlobalState.notices = syncGlobalState.notices.filter(notice => !(notice.topic === topic && notice.key === key));
@@ -1166,19 +1177,19 @@ function callListener$1({
 }
 
 const globalState = {
-  devContext: undefined,
   timers: {
     default: {
       elapsedTime: 0
     }
   },
-  deepCopy: true,
+  devContext: undefined,
   deepCopyAttributes: {
     threshold: undefined,
     stringify: [],
     ignore: [],
     toJSON: []
-  }
+  },
+  deepCopy: true
 };
 let _globalStateProvider = syncGlobalState$1;
 const requiredStateProviderMethods = ['addNotice', 'callListener', 'deleteNotices', 'getNotices', 'getTopics', 'getTournamentId', 'getTournamentRecord', 'getTournamentRecords', 'removeTournamentRecord', 'setSubscriptions', 'setTournamentId', 'setTournamentRecord', 'setTournamentRecords'];
@@ -1234,6 +1245,12 @@ function getDevContext(contextCriteria) {
 function setDevContext(value) {
   globalState.devContext = value;
 }
+function disableNotifications() {
+  _globalStateProvider.disableNotifications();
+}
+function enableNotifications() {
+  _globalStateProvider.enableNotifications();
+}
 function setDeepCopy(value, attributes) {
   if (typeof value === 'boolean') {
     globalState.deepCopy = value;
@@ -2051,7 +2068,7 @@ The algorithm relies on the values avaialble in the calculated `participantResul
 • participantResults scoped to the members of a group and recalculated when `{ idsFilter: true }`
 */
 
-const defaultTallyDirectives = [{
+const headToHeadTallyDirectives = [{
   attribute: 'matchUpsRatio',
   idsFilter: false
 }, {
@@ -2092,6 +2109,12 @@ const defaultTallyDirectives = [{
   attribute: 'pointsRatio',
   idsFilter: true
 }];
+const GEMScoreValueMap = {
+  matchUpsRatio: 16,
+  setsRatio: 12,
+  gamesRatio: 8,
+  pointsRatio: 4
+};
 /**
  *
  * @param {object[]} participantResults - calculated results for each participant
@@ -2104,15 +2127,17 @@ const defaultTallyDirectives = [{
 function getGroupOrder(params) {
   const {
     participantResults,
-    subOrderMap
+    subOrderMap,
+    tallyPolicy
   } = params; // if not all opponents have completed their matchUps, no orders are assigned
 
   if (!isComplete(params)) return;
-  const matchUpsWonGroups = getGroups({
-    attribute: 'matchUpsWon',
-    participantResults
+  const attribute = ['matchUpsWon', 'pointsWon', 'gamesWon', 'setsWon', 'gamesRatio', 'setsRatio', 'pointsRatio', 'matchUpsRatio'].includes(tallyPolicy === null || tallyPolicy === void 0 ? void 0 : tallyPolicy.groupOrderKey) ? tallyPolicy.groupOrderKey : 'matchUpsWon';
+  const orderedTallyGroups = getGroups({
+    participantResults,
+    attribute
   });
-  const groupOrder = Object.keys(matchUpsWonGroups).map(key => parseFloat(key)).sort((a, b) => b - a).map(key => matchUpsWonGroups[key]).map(participantIds => groupSubSort({
+  const groupOrder = Object.keys(orderedTallyGroups).map(key => parseFloat(key)).sort((a, b) => b - a).map(key => orderedTallyGroups[key]).map(participantIds => groupSubSort({
     participantIds,
     ...params
   })).flat(Infinity);
@@ -2162,11 +2187,11 @@ function getGroupOrder(params) {
     result.GEMscore = getRatioHash(result);
   });
   return groupOrder;
-}
 
-function getRatioHash(result) {
-  const rh = result.matchUpsRatio * Math.pow(10, 16) + result.setsRatio * Math.pow(10, 12) + result.gamesRatio * Math.pow(10, 8) + result.pointsRatio * Math.pow(10, 3);
-  return rh;
+  function getRatioHash(result) {
+    const attributes = Array.isArray(tallyPolicy === null || tallyPolicy === void 0 ? void 0 : tallyPolicy.GEMscore) ? Object.keys(GEMScoreValueMap).filter(attribute => tallyPolicy.GEMscore.includes(attribute)) : Object.keys(GEMScoreValueMap);
+    return attributes.map(attribute => (result[attribute] || 0) * Math.pow(10, GEMScoreValueMap[attribute])).reduce((a, b) => a + b, 0);
+  }
 }
 
 function isComplete({
@@ -2244,7 +2269,7 @@ function groupSubSort({
   }
 
   let result;
-  ((tallyPolicy === null || tallyPolicy === void 0 ? void 0 : tallyPolicy.tallyDirectives) || defaultTallyDirectives).every(({
+  ((tallyPolicy === null || tallyPolicy === void 0 ? void 0 : tallyPolicy.tallyDirectives) || headToHeadTallyDirectives).every(({
     attribute,
     reversed,
     idsFilter,
@@ -3288,6 +3313,211 @@ const eventConstants = {
   BOTH
 };
 
+function getVenuesAndCourts$1({
+  tournamentRecord
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  const venues = makeDeepCopy(tournamentRecord.venues || []);
+  const courts = venues.reduce((courts, venue) => {
+    var _venue$courts;
+
+    return venue !== null && venue !== void 0 && (_venue$courts = venue.courts) !== null && _venue$courts !== void 0 && _venue$courts.length ? courts.concat(venue.courts) : courts;
+  }, []);
+  return {
+    venues,
+    courts
+  };
+}
+function findVenue({
+  tournamentRecord,
+  venueId
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!venueId) return {
+    error: MISSING_VENUE_ID
+  };
+  const venues = tournamentRecord.venues || [];
+  const venue = venues.reduce((venue, venueRecord) => {
+    return venueRecord.venueId === venueId ? venueRecord : venue;
+  }, undefined);
+  return venue && {
+    venue
+  } || {
+    error: VENUE_NOT_FOUND
+  };
+}
+function publicFindVenue(params) {
+  return makeDeepCopy(findVenue(params), false, true);
+}
+
+function findCourt({
+  tournamentRecord,
+  courtId
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!courtId) return {
+    error: MISSING_COURT_ID
+  };
+  let court, venue;
+  (tournamentRecord.venues || []).forEach(venueRecord => {
+    (venueRecord.courts || []).forEach(courtRecord => {
+      if (courtRecord.courtId === courtId) {
+        court = courtRecord;
+        venue = venueRecord;
+      }
+    });
+  });
+  return court && {
+    court,
+    venue
+  } || {
+    error: COURT_NOT_FOUND
+  };
+}
+function publicFindCourt(params) {
+  return makeDeepCopy(findCourt(params), false, true);
+}
+/**
+ *
+ * @param {string} venueId - optional -
+ * @param {string[]} venueIds - optional -
+ */
+
+function getCourts({
+  tournamentRecord,
+  venueId,
+  venueIds
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  const courts = (tournamentRecord.venues || []).filter(venue => {
+    if (venueId) return venue.venueId === venueId;
+    if (venueIds) return venueIds.includes(venue.venueId);
+    if (!venueId && !venueIds) return true;
+    return false;
+  }).map(venue => {
+    const {
+      venueId
+    } = venue;
+    const venueCourts = makeDeepCopy(venue.courts || []);
+    venueCourts.forEach(court => Object.assign(court, {
+      venueId
+    }));
+    return venueCourts;
+  }).flat();
+  return {
+    courts
+  };
+}
+
+function getCourtInfo({
+  tournamentRecord,
+  courtId
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!courtId) return {
+    error: MISSING_COURT_ID
+  };
+  const {
+    court,
+    error
+  } = findCourt({
+    tournamentRecord,
+    courtId
+  });
+  if (error) return {
+    error
+  };
+
+  const courtInfo = (({
+    altitude,
+    courtId,
+    courtName,
+    courtDimensions,
+    latitude,
+    longitude,
+    surfaceCategory,
+    surfaceType,
+    surfaceDate,
+    pace,
+    notes
+  }) => ({
+    altitude,
+    courtId,
+    courtName,
+    courtDimensions,
+    latitude,
+    longitude,
+    surfaceCategory,
+    surfaceType,
+    surfaceDate,
+    pace,
+    notes
+  }))(court);
+
+  return { ...SUCCESS,
+    courtInfo: makeDeepCopy(courtInfo)
+  };
+}
+
+// e.g. dataAvailability objects are not returned.
+
+function getVenueData({
+  tournamentRecord,
+  venueId
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!venueId) return {
+    error: MISSING_VENUE_ID
+  };
+  const {
+    venue,
+    error
+  } = findVenue({
+    tournamentRecord,
+    venueId
+  });
+  if (error) return {
+    error
+  };
+  const courts = venue.courts || [];
+  const courtsInfo = courts.map(court => (({
+    courtInfo
+  }) => ({ ...courtInfo
+  }))(getCourtInfo({
+    tournamentRecord,
+    courtId: court.courtId
+  })));
+
+  const venueInfo = (({
+    venueId,
+    venueName,
+    venueAbbreviation
+  }) => ({
+    venueId,
+    venueName,
+    venueAbbreviation
+  }))(venue);
+
+  const venueData = { ...venueInfo,
+    courtsInfo
+  };
+  return { ...SUCCESS,
+    venueData: makeDeepCopy(venueData)
+  };
+}
+
 function getMatchUpScheduleDetails({
   scheduleVisibilityFilters,
   afterRecoveryTimes = true,
@@ -3347,6 +3577,8 @@ function getMatchUpScheduleDetails({
   } = scheduleVisibilityFilters || {};
 
   if ((!eventIds || eventIds.includes(matchUp.eventId)) && (!drawIds || drawIds.includes(matchUp.drawId))) {
+    var _ref;
+
     const scheduleSource = {
       matchUp,
       visibilityThreshold
@@ -3389,13 +3621,31 @@ function getMatchUpScheduleDetails({
     }
 
     if (!scheduledDate && scheduledTime) scheduledDate = extractDate(scheduledTime);
+    const extractedTime = extractTime(scheduledTime);
+    let isoDateString = extractDate(scheduledDate);
+    if (isoDateString && extractedTime) isoDateString += `T${extractedTime}`;
+    const venueData = ((_ref = tournamentRecord && venueId && getVenueData({
+      tournamentRecord,
+      venueId
+    })) === null || _ref === void 0 ? void 0 : _ref.venueData) || {};
+    const {
+      venueName,
+      venueAbbreviation,
+      courtsInfo
+    } = venueData;
+    const courtInfo = courtId && (courtsInfo === null || courtsInfo === void 0 ? void 0 : courtsInfo.find(courtInfo => courtInfo.courtId === courtId));
+    const courtName = courtInfo === null || courtInfo === void 0 ? void 0 : courtInfo.courtName;
     schedule = definedAttributes({
-      venueId,
-      courtId,
       typeChangeTimeAfterRecovery,
       timeAfterRecovery,
       scheduledDate,
       scheduledTime,
+      isoDateString,
+      venueAbbreviation,
+      venueName,
+      venueId,
+      courtName,
+      courtId,
       typeChangeRecoveryMinutes,
       recoveryMinutes,
       averageMinutes,
@@ -10564,9 +10814,9 @@ function getAllPositionedParticipantIds({
   }).flat();
 }
 function getPositionAssignments$1({
-  structure,
   drawDefinition,
-  structureId
+  structureId,
+  structure
 }) {
   let error,
       positionAssignments = [];
@@ -10617,9 +10867,9 @@ function structureAssignedDrawPositions({
   const {
     positionAssignments
   } = getPositionAssignments$1({
-    structure,
     drawDefinition,
-    structureId
+    structureId,
+    structure
   });
   const assignedPositions = positionAssignments.filter(drawPosition => {
     return drawPosition.participantId || drawPosition.bye || drawPosition.qualifier;
@@ -11235,6 +11485,7 @@ function getAllStructureMatchUps({
   tournamentAppliedPolicies,
   tournamentParticipants,
   policyDefinitions,
+  tournamentRecord,
   seedAssignments,
   drawDefinition,
   contextFilters,
@@ -11324,7 +11575,7 @@ function getAllStructureMatchUps({
     drawId,
     drawName
   } = drawDefinition || {};
-  const isRoundRobin = structure.structures;
+  const isRoundRobin = !!structure.structures;
   let matchUps = getMappedStructureMatchUps({
     matchUpsMap,
     structureId,
@@ -11456,6 +11707,7 @@ function getAllStructureMatchUps({
       endDate
     } = getMatchUpScheduleDetails({
       scheduleVisibilityFilters,
+      tournamentRecord,
       scheduleTiming,
       matchUpFormat,
       matchUpType,
@@ -11571,6 +11823,11 @@ function getAllStructureMatchUps({
           });
 
           if (participant) {
+            if (drawDefinition !== null && drawDefinition !== void 0 && drawDefinition.entries) {
+              const entry = drawDefinition.entries.find(entry => entry.participantId === side.participantId);
+              if (entry !== null && entry !== void 0 && entry.entryStatus) participant.entryStatus = entry.entryStatus || ALTERNATE;
+            }
+
             Object.assign(side, {
               participant
             });
@@ -11601,17 +11858,6 @@ function getAllStructureMatchUps({
           matchUpType
         });
       }
-
-      if (drawDefinition !== null && drawDefinition !== void 0 && drawDefinition.entries) {
-        matchUpWithContext.sides.filter(Boolean).forEach(side => {
-          if (side.participantId) {
-            const entry = drawDefinition.entries.find(entry => entry.participantId === side.participantId);
-            if (entry !== null && entry !== void 0 && entry.entryStatus) Object.assign(side, {
-              entryStatus: entry.entryStatus || ALTERNATE
-            });
-          }
-        });
-      }
     }
 
     if (matchUpWithContext.tieMatchUps) {
@@ -11825,47 +12071,6 @@ function resetMatchUpTimeItems({
   };
 }
 
-function getVenuesAndCourts$1({
-  tournamentRecord
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  const venues = makeDeepCopy(tournamentRecord.venues || []);
-  const courts = venues.reduce((courts, venue) => {
-    var _venue$courts;
-
-    return venue !== null && venue !== void 0 && (_venue$courts = venue.courts) !== null && _venue$courts !== void 0 && _venue$courts.length ? courts.concat(venue.courts) : courts;
-  }, []);
-  return {
-    venues,
-    courts
-  };
-}
-function findVenue({
-  tournamentRecord,
-  venueId
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  if (!venueId) return {
-    error: MISSING_VENUE_ID
-  };
-  const venues = tournamentRecord.venues || [];
-  const venue = venues.reduce((venue, venueRecord) => {
-    return venueRecord.venueId === venueId ? venueRecord : venue;
-  }, undefined);
-  return venue && {
-    venue
-  } || {
-    error: VENUE_NOT_FOUND
-  };
-}
-function publicFindVenue(params) {
-  return makeDeepCopy(findVenue(params), false, true);
-}
-
 function assignMatchUpVenue$1({
   tournamentRecord,
   drawDefinition,
@@ -11905,69 +12110,6 @@ function assignMatchUpVenue$1({
   });
 }
 
-function findCourt({
-  tournamentRecord,
-  courtId
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  if (!courtId) return {
-    error: MISSING_COURT_ID
-  };
-  let court, venue;
-  (tournamentRecord.venues || []).forEach(venueRecord => {
-    (venueRecord.courts || []).forEach(courtRecord => {
-      if (courtRecord.courtId === courtId) {
-        court = courtRecord;
-        venue = venueRecord;
-      }
-    });
-  });
-  return court && {
-    court,
-    venue
-  } || {
-    error: COURT_NOT_FOUND
-  };
-}
-function publicFindCourt(params) {
-  return makeDeepCopy(findCourt(params), false, true);
-}
-/**
- *
- * @param {string} venueId - optional -
- * @param {string[]} venueIds - optional -
- */
-
-function getCourts({
-  tournamentRecord,
-  venueId,
-  venueIds
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  const courts = (tournamentRecord.venues || []).filter(venue => {
-    if (venueId) return venue.venueId === venueId;
-    if (venueIds) return venueIds.includes(venue.venueId);
-    if (!venueId && !venueIds) return true;
-    return false;
-  }).map(venue => {
-    const {
-      venueId
-    } = venue;
-    const venueCourts = makeDeepCopy(venue.courts || []);
-    venueCourts.forEach(court => Object.assign(court, {
-      venueId
-    }));
-    return venueCourts;
-  }).flat();
-  return {
-    courts
-  };
-}
-
 function assignMatchUpCourt$1({
   tournamentRecord,
   drawDefinition,
@@ -13274,6 +13416,7 @@ function getStructureMatchUps({
   tournamentAppliedPolicies,
   tournamentParticipants,
   policyDefinitions,
+  tournamentRecord,
   drawDefinition,
   matchUpFilters,
   contextFilters,
@@ -13304,6 +13447,7 @@ function getStructureMatchUps({
     scheduleVisibilityFilters,
     tournamentParticipants,
     policyDefinitions,
+    tournamentRecord,
     drawDefinition,
     matchUpFilters,
     contextFilters,
@@ -13462,6 +13606,7 @@ function getDrawMatchUps({
       requireParticipants,
       includeByeMatchUps,
       policyDefinitions,
+      tournamentRecord,
       drawDefinition,
       matchUpFilters,
       //
@@ -16925,22 +17070,26 @@ function assignDrawPositionBye$1({
   drawDefinition,
   drawPosition,
   matchUpsMap,
-  structureId
+  structureId,
+  structure
 }) {
   var _matchUp$drawPosition;
 
   if (!drawDefinition) return {
     error: MISSING_DRAW_DEFINITION
   };
-  const {
+  if (!structure) ({
     structure
   } = findStructure({
     drawDefinition,
     structureId
-  });
+  }));
   if (!structure) return {
     error: STRUCTURE_NOT_FOUND
   };
+  if (!structureId) ({
+    structureId
+  } = structure);
 
   if (!matchUpsMap) {
     matchUpsMap = getMatchUpsMap({
@@ -17148,10 +17297,10 @@ function advanceDrawPosition({
       loserTargetDrawPosition
     }
   } = positionTargets({
-    matchUpId,
-    structure,
+    inContextDrawMatchUps,
     drawDefinition,
-    inContextDrawMatchUps
+    matchUpId,
+    structure
   }); // only handling situation where winningMatchUp is in same structure
 
   if (winnerMatchUp && winnerMatchUp.structureId === structure.structureId) {
@@ -17182,10 +17331,10 @@ function advanceDrawPosition({
       if (result.error) return result;
     } else {
       assignFedDrawPositionBye({
+        loserTargetDrawPosition,
+        loserTargetLink,
         drawDefinition,
         loserMatchUp,
-        loserTargetLink,
-        loserTargetDrawPosition,
         matchUpsMap
       });
     }
@@ -21094,6 +21243,7 @@ function addCourt({
   disableNotice,
   returnDetails,
   venueId,
+  courtId,
   court
 }) {
   const {
@@ -21107,7 +21257,8 @@ function addCourt({
   };
   if (!venue.courts) venue.courts = [];
   const courtRecord = { ...courtTemplate(),
-    venueId
+    venueId,
+    courtId
   };
 
   if (!courtRecord.courtId) {
@@ -21198,6 +21349,7 @@ function addCourts$1({
   tournamentRecord,
   courtNames = [],
   courtsCount,
+  courtIds,
   venueId
 }) {
   if (!venueId) return {
@@ -21214,13 +21366,17 @@ function addCourts$1({
     };
     return court;
   });
-  const result = courts.map(court => addCourt({
-    tournamentRecord,
-    venueId,
-    court,
-    disableNotice: true,
-    returnDetails: true
-  }));
+  const result = courts.map(court => {
+    const courtId = courtIds === null || courtIds === void 0 ? void 0 : courtIds.pop();
+    return addCourt({
+      disableNotice: true,
+      returnDetails: true,
+      tournamentRecord,
+      courtId,
+      venueId,
+      court
+    });
+  });
   const courtRecords = result.map(outcome => outcome.court).filter(Boolean);
 
   if (courtRecords.length === courtsCount) {
@@ -24624,9 +24780,10 @@ function findMatchUpFormatTiming({
  */
 
 function getScheduledRoundsDetails({
-  tournamentRecords,
+  scheduleCompletedMatchUps,
   containedStructureIds,
   // optional to support calling method outside of scheduleProfileRounds
+  tournamentRecords,
   periodLength = 30,
   matchUps,
   // optional to support calling method outside of scheduleProfileRounds
@@ -24733,8 +24890,8 @@ function getScheduledRoundsDetails({
     };
     const matchUpIds = roundMatchUps.filter(({
       matchUpStatus
-    }) => // don't attempt to scheduled completed matchUpstatuses
-    !completedMatchUpStatuses.includes(matchUpStatus) && matchUpStatus !== BYE).map(getMatchUpId);
+    }) => // don't attempt to scheduled completed matchUpstatuses unless explicit override
+    (scheduleCompletedMatchUps || !completedMatchUpStatuses.includes(matchUpStatus)) && matchUpStatus !== BYE).map(getMatchUpId);
     matchUpIds.forEach(matchUpId => {
       minutesMap[matchUpId] = {
         typeChangeRecoveryMinutes,
@@ -26077,6 +26234,8 @@ function generateScheduleTimes({
 function jinnScheduler({
   checkPotentialRequestConflicts = true,
   // passed to checkRequestConflicts
+  scheduleCompletedMatchUps,
+  // override which can be used by mocksEngine
   clearScheduleDates,
   scheduleDates = [],
   tournamentRecords,
@@ -26196,9 +26355,9 @@ function jinnScheduler({
 
       if ((_matchUp$schedule = matchUp.schedule) !== null && _matchUp$schedule !== void 0 && _matchUp$schedule.scheduledDate && sameDay(scheduleDate, extractDate(matchUp.schedule.scheduledDate))) {
         processNextMatchUps({
-          matchUp,
+          matchUpPotentialParticipantIds,
           matchUpNotBeforeTimes,
-          matchUpPotentialParticipantIds
+          matchUp
         });
       }
     }); // checking that matchUpDependencies is scoped to only those matchUps that are already or are to be scheduled on the same date
@@ -26218,6 +26377,7 @@ function jinnScheduler({
         orderedMatchUpIds,
         minutesMap
       } = getScheduledRoundsDetails({
+        scheduleCompletedMatchUps,
         containedStructureIds,
         tournamentRecords,
         periodLength,
@@ -26291,7 +26451,8 @@ function jinnScheduler({
       let matchUpsToSchedule = orderedMatchUpIds.map(matchUpId => matchUps.find(matchUp => matchUp.matchUpId === matchUpId)).filter(Boolean).filter(matchUp => {
         const alreadyScheduled = !clearDate && dateScheduledMatchUpIds.includes(matchUp.matchUpId);
         const doNotSchedule = [BYE, DEFAULTED, COMPLETED, ABANDONED, RETIRED, WALKOVER$1].includes(matchUp === null || matchUp === void 0 ? void 0 : matchUp.matchUpStatus);
-        return !alreadyScheduled && !matchUp.winningSide && !doNotSchedule;
+        return scheduleCompletedMatchUps || // override for mocksEngine
+        !alreadyScheduled && !matchUp.winningSide && !doNotSchedule;
       }); // for optimization, build up an object for each tournament and an array for each draw with target matchUps
       // keep track of matchUps counts per participant and don't add matchUps for participants beyond those limits
 
@@ -26603,6 +26764,7 @@ function jinnScheduler({
     schedulingProfileModifications,
     schedulingProfileIssues,
     scheduleTimesRemaining,
+    dateSchedulingProfiles,
     skippedScheduleTimes,
     recoveryTimeDeferredMatchUpIds,
     dependencyDeferredMatchUpIds,
@@ -26617,6 +26779,7 @@ function jinnScheduler({
 
 function scheduleProfileRounds({
   checkPotentialRequestConflicts = true,
+  scheduleCompletedMatchUps,
   clearScheduleDates,
   scheduleDates = [],
   tournamentRecords,
@@ -26625,6 +26788,7 @@ function scheduleProfileRounds({
 }) {
   return jinnScheduler({
     checkPotentialRequestConflicts,
+    scheduleCompletedMatchUps,
     clearScheduleDates,
     tournamentRecords,
     scheduleDates,
@@ -30917,9 +31081,10 @@ function positionByes({
   for (const drawPosition of byeDrawPositions) {
     const result = assignDrawPositionBye$1({
       drawDefinition,
-      structureId,
       drawPosition,
-      matchUpsMap
+      matchUpsMap,
+      structureId,
+      structure
     });
     if (result !== null && result !== void 0 && result.error) return result;
   }
@@ -30966,6 +31131,8 @@ function positionQualifiers(params) {
     positionAssignments.forEach(assignment => {
       if (assignment.drawPosition === drawPosition) {
         assignment.qualifier = true;
+        delete assignment.participantId;
+        delete assignment.bye;
       }
     });
   });
@@ -30997,27 +31164,27 @@ function getQualifiersData({
   } = structure;
   const qualifiersCount = getStageQualifiersCount({
     drawDefinition,
-    stage,
-    stageSequence
+    stageSequence,
+    stage
   });
   const unplacedQualifiersCount = qualifiersCount - assignedQualifierPositions.length;
   const placedQualifiersCount = assignedQualifierPositions.length;
   return {
-    positionAssignments,
-    qualifiersCount,
+    unplacedQualifiersCount,
     placedQualifiersCount,
-    unplacedQualifiersCount
+    positionAssignments,
+    qualifiersCount
   };
 }
 
 function positionSeedBlocks({
+  inContextDrawMatchUps,
   drawDefinition,
   participants,
   groupsCount,
   structureId,
-  structure,
   matchUpsMap,
-  inContextDrawMatchUps
+  structure
 }) {
   const errors = [];
   let placedSeedBlocks = 0;
@@ -31048,11 +31215,11 @@ function positionSeedBlocks({
   generateRange(0, groupsCount).forEach(() => {
     if (placedSeedBlocks < groupsCount) {
       const result = positionSeedBlock({
+        inContextDrawMatchUps,
         drawDefinition,
         participants,
         structureId,
-        matchUpsMap,
-        inContextDrawMatchUps
+        matchUpsMap
       });
       if (result && result.success) placedSeedBlocks++;
 
@@ -31100,13 +31267,13 @@ function positionSeedBlock({
       error: MISSING_DRAW_POSITION
     };
     const result = assignDrawPosition$1({
+      automaticPlacement: true,
+      inContextDrawMatchUps,
       drawDefinition,
-      structureId,
-      drawPosition,
       participantId,
-      automaticPlacement: true,
+      drawPosition,
       matchUpsMap,
-      inContextDrawMatchUps
+      structureId
     });
     if (!result.success) return result;
   }
@@ -31115,6 +31282,7 @@ function positionSeedBlock({
 }
 
 function automatedPositioning$1({
+  applyPositioning = true,
   inContextDrawMatchUps,
   drawDefinition,
   candidatesCount,
@@ -31125,6 +31293,24 @@ function automatedPositioning$1({
   drawType,
   event
 }) {
+  //-----------------------------------------------------------
+  // handle notification state for all exit conditions
+  if (!applyPositioning) {
+    disableNotifications();
+    drawDefinition = makeDeepCopy(drawDefinition, false, true);
+  }
+
+  const handleErrorCondition = result => {
+    if (!applyPositioning) enableNotifications();
+    return result;
+  };
+
+  const handleSuccessCondition = result => {
+    if (!applyPositioning) enableNotifications();
+    return result;
+  }; //-----------------------------------------------------------
+
+
   const {
     structure,
     error
@@ -31132,9 +31318,9 @@ function automatedPositioning$1({
     drawDefinition,
     structureId
   });
-  if (error) return {
+  if (error) return handleErrorCondition({
     error
-  };
+  });
   const entryStatuses = [DIRECT_ACCEPTANCE, WILDCARD];
   const entries = getStageEntries$1({
     stageSequence: structure.stageSequence,
@@ -31143,7 +31329,8 @@ function automatedPositioning$1({
     entryStatuses,
     structureId
   });
-  if (!(entries !== null && entries !== void 0 && entries.length)) return SUCCESS;
+  if (!(entries !== null && entries !== void 0 && entries.length)) return handleSuccessCondition({ ...SUCCESS
+  });
   const {
     seedingProfile
   } = structure;
@@ -31172,7 +31359,7 @@ function automatedPositioning$1({
       seedsOnly,
       event
     });
-    if (result.error) return result;
+    if (result.error) return handleErrorCondition(result);
     result = positionSeedBlocks({
       inContextDrawMatchUps,
       drawDefinition,
@@ -31180,7 +31367,7 @@ function automatedPositioning$1({
       matchUpsMap,
       structure
     });
-    if (result.error) return result;
+    if (result.error) return handleErrorCondition(result);
   } else {
     // otherwise... seeds need to be placed first so that BYEs
     // can follow the seedValues of placed seeds
@@ -31192,7 +31379,7 @@ function automatedPositioning$1({
         matchUpsMap,
         structure
       });
-      if (result.error) return result;
+      if (result.error) return handleErrorCondition(result);
     }
 
     const result = positionByes({
@@ -31203,7 +31390,7 @@ function automatedPositioning$1({
       seedsOnly,
       event
     });
-    if (result.error) return result;
+    if (result.error) return handleErrorCondition(result);
   }
 
   const conflicts = {};
@@ -31217,25 +31404,37 @@ function automatedPositioning$1({
       matchUpsMap,
       structure
     });
-    if (result.error) return result;
+    if (result.error) return handleErrorCondition(result);
     if (result.conflicts) conflicts.unseededConflicts = result.conflicts;
     result = positionQualifiers({
+      inContextDrawMatchUps,
       drawDefinition,
       participants,
-      structure,
       matchUpsMap,
-      inContextDrawMatchUps
+      structure
     });
-    if (result.error) return result;
+    if (result.error) return handleErrorCondition(result);
     if (result.conflicts) conflicts.qualifierConflicts = result.conflicts;
   }
 
+  const {
+    positionAssignments
+  } = getPositionAssignments$1({
+    drawDefinition,
+    structure
+  });
   modifyDrawNotice({
     drawDefinition,
     structureIds: [structureId]
-  });
+  }); //-----------------------------------------------------------
+  // re-enable notifications, if they have been disabled
+
+  if (!applyPositioning) enableNotifications(); //-----------------------------------------------------------
+
   return {
-    conflicts
+    positionAssignments,
+    conflicts,
+    ...SUCCESS
   };
 }
 
@@ -31985,8 +32184,8 @@ function addVoluntaryConsolationStage$1({
 
 function getStructureQualifiersCount({
   drawDefinition,
-  structure,
-  structureId
+  structureId,
+  structure
 }) {
   let error, qualifiersCount;
 
@@ -34816,15 +35015,15 @@ function getSeedsCount({
 }
 
 function initializeStructureSeedAssignments({
-  tournamentRecord,
-  drawDefinition,
-  event,
   requireParticipantCount = true,
   enforcePolicyLimits = true,
   drawSizeProgression,
+  tournamentRecord,
   participantCount,
+  drawDefinition,
   structureId,
-  seedsCount
+  seedsCount,
+  event
 }) {
   const {
     structure,
@@ -35173,6 +35372,110 @@ function alternateDrawPositionAssignment$1({
   });
 }
 
+function setPositionAssignments$1({
+  structurePositionAssignments,
+  drawDefinition
+}) {
+  if (!drawDefinition) return {
+    error: MISSING_DRAW_DEFINITION
+  };
+  if (!Array.isArray(structurePositionAssignments)) return {
+    error: INVALID_VALUES
+  };
+
+  for (const structureAssignments of structurePositionAssignments) {
+    var _structure$positionAs;
+
+    const {
+      structureId,
+      positionAssignments
+    } = structureAssignments;
+    const result = findStructure({
+      drawDefinition,
+      structureId
+    });
+    if (result.error) return result;
+    const structure = result.structure;
+    if (!structure) return {
+      error: STRUCTURE_NOT_FOUND
+    };
+    if (structure.structures) return {
+      error: INVALID_STRUCTURE,
+      message: 'cannot be Round Robin group container'
+    };
+    const structureDrawPositions = (_structure$positionAs = structure.positionAssignments) === null || _structure$positionAs === void 0 ? void 0 : _structure$positionAs.map(({
+      drawPosition
+    }) => drawPosition);
+    const submittedDrawPositions = positionAssignments.map(({
+      drawPosition
+    }) => drawPosition);
+    if (intersection(structureDrawPositions, submittedDrawPositions).length !== structureDrawPositions.length) return {
+      error: INVALID_VALUES,
+      message: 'drawPositions do not match'
+    };
+    const matchUpsMap = getMatchUpsMap({
+      drawDefinition
+    });
+    const {
+      matchUps: inContextDrawMatchUps
+    } = getAllDrawMatchUps({
+      includeByeMatchUps: true,
+      inContext: true,
+      drawDefinition,
+      matchUpsMap
+    });
+
+    for (const assignment of positionAssignments) {
+      const {
+        drawPosition,
+        participantId,
+        bye,
+        qualifier
+      } = assignment;
+
+      if (bye) {
+        const result = assignDrawPositionBye$1({
+          drawDefinition,
+          drawPosition,
+          matchUpsMap,
+          structureId,
+          structure
+        });
+        if (result !== null && result !== void 0 && result.error) return result;
+      } else if (qualifier) {
+        positionAssignments.forEach(assignment => {
+          if (assignment.drawPosition === drawPosition) {
+            assignment.qualifier = true;
+            delete assignment.participantId;
+            delete assignment.bye;
+          }
+        });
+      } else if (participantId) {
+        const result = assignDrawPosition$1({
+          automaticPlacement: true,
+          inContextDrawMatchUps,
+          drawDefinition,
+          participantId,
+          drawPosition,
+          matchUpsMap,
+          structureId
+        });
+        if (result !== null && result !== void 0 && result.error) return result;
+      }
+    }
+  }
+
+  const structureIds = structurePositionAssignments.map(({
+    structureId
+  }) => structureId);
+  modifyDrawNotice({
+    drawDefinition,
+    structureIds
+  });
+  return { ...SUCCESS
+  };
+}
+
 // optionally filter to included only specified stages
 
 function getAssignedParticipantIds({
@@ -36725,12 +37028,11 @@ function setSubOrder({
   };
 }
 
-// import { assignCollectionPosition, assignDrawPosition } from './positionAssignment';
 const positionGovernor = {
   setSubOrder,
   clearDrawPosition,
   assignDrawPosition: assignDrawPosition$1,
-  //  assignCollectionPosition,
+  setPositionAssignments: setPositionAssignments$1,
   automatedPositioning: automatedPositioning$1,
   assignDrawPositionBye: assignDrawPositionBye$1,
   swapDrawPositionAssignments: swapDrawPositionAssignments$1,
@@ -38852,7 +39154,7 @@ function modifySeedAssignment$1({
   if (!structure) return {
     error: STRUCTURE_NOT_FOUND
   };
-  const validValue = !validation || isNumeric(seedValue) || typeof seedValue === 'string' && seedValue.split('-').every(isNumeric);
+  const validValue = !validation || isNumeric(seedValue) || [undefined, ''].includes(seedValue) || typeof seedValue === 'string' && seedValue.split('-').every(v => isNumeric(v) && v > 0);
   if (!validValue) return {
     error: INVALID_VALUES
   };
@@ -38866,7 +39168,8 @@ function modifySeedAssignment$1({
   const existingAssginment = seedAssignments.find(assignment => assignment.participantId === participantId);
 
   if (existingAssginment) {
-    existingAssginment.seedValue = seedValue;
+    const newValue = typeof seedValue === 'string' ? seedValue.includes('-') ? seedValue.split('-').map(v => parseInt(v)).join('-') : seedValue > 0 ? parseInt(seedValue) : '' : seedValue > 0 ? parseInt(seedValue) : '';
+    existingAssginment.seedValue = newValue;
   } else {
     const seedNumber = Math.max(0, ...seedNumbers) + 1;
     structure.seedAssignments.push({
@@ -41392,61 +41695,10 @@ const participantGovernor = {
   getTournamentPersons
 };
 
-function getCourtInfo({
-  tournamentRecord,
-  courtId
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  if (!courtId) return {
-    error: MISSING_COURT_ID
-  };
-  const {
-    court,
-    error
-  } = findCourt({
-    tournamentRecord,
-    courtId
-  });
-  if (error) return {
-    error
-  };
-
-  const courtInfo = (({
-    altitude,
-    courtId,
-    courtName,
-    courtDimensions,
-    latitude,
-    longitude,
-    surfaceCategory,
-    surfaceType,
-    surfaceDate,
-    pace,
-    notes
-  }) => ({
-    altitude,
-    courtId,
-    courtName,
-    courtDimensions,
-    latitude,
-    longitude,
-    surfaceCategory,
-    surfaceType,
-    surfaceDate,
-    pace,
-    notes
-  }))(court);
-
-  return { ...SUCCESS,
-    courtInfo: makeDeepCopy(courtInfo)
-  };
-}
-
 function getDrawData({
   tournamentParticipants = [],
   policyDefinitions,
+  tournamentRecord,
   inContext = true,
   drawDefinition,
   context,
@@ -41525,6 +41777,7 @@ function getDrawData({
         },
         tournamentParticipants,
         policyDefinitions,
+        tournamentRecord,
         seedAssignments,
         drawDefinition,
         structure,
@@ -41670,55 +41923,6 @@ function getStructureGroups({
   };
 }
 
-// e.g. dataAvailability objects are not returned.
-
-function getVenueData({
-  tournamentRecord,
-  venueId
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  if (!venueId) return {
-    error: MISSING_VENUE_ID
-  };
-  const {
-    venue,
-    error
-  } = findVenue({
-    tournamentRecord,
-    venueId
-  });
-  if (error) return {
-    error
-  };
-  const courts = venue.courts || [];
-  const courtsInfo = courts.map(court => (({
-    courtInfo
-  }) => ({ ...courtInfo
-  }))(getCourtInfo({
-    tournamentRecord,
-    courtId: court.courtId
-  })));
-
-  const venueInfo = (({
-    venueId,
-    venueName,
-    venueAbbreviation
-  }) => ({
-    venueId,
-    venueName,
-    venueAbbreviation
-  }))(venue);
-
-  const venueData = { ...venueInfo,
-    courtsInfo
-  };
-  return { ...SUCCESS,
-    venueData: makeDeepCopy(venueData)
-  };
-}
-
 function getEventData({
   participantsProfile,
   policyDefinitions,
@@ -41756,14 +41960,15 @@ function getEventData({
   }) => ({ ...drawInfo,
     structures
   }))(getDrawData({
-    tournamentParticipants,
-    policyDefinitions,
-    drawDefinition,
     context: {
       eventId,
       tournamentId,
       endDate
     },
+    tournamentParticipants,
+    policyDefinitions,
+    tournamentRecord,
+    drawDefinition,
     event
   })));
   const {
@@ -43210,14 +43415,13 @@ function addEvent({
  */
 
 function automatedPositioning({
+  applyPositioning = true,
   tournamentRecord,
   drawDefinition,
   structureId,
   seedsOnly,
   event
 }) {
-  var _result$errors;
-
   if (!event) return {
     error: EVENT_NOT_FOUND
   };
@@ -43225,17 +43429,16 @@ function automatedPositioning({
     error: DRAW_DEFINITION_NOT_FOUND
   };
   const participants = tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.participants;
-  const result = automatedPositioning$1({
+  return automatedPositioning$1({
+    applyPositioning,
     drawDefinition,
     participants,
     structureId,
     seedsOnly
   });
-  return result.error ? result : result !== null && result !== void 0 && (_result$errors = result.errors) !== null && _result$errors !== void 0 && _result$errors.length ? {
-    error: result.errors
-  } : SUCCESS;
 }
 function automatedPlayoffPositioning({
+  applyPositioning = true,
   candidatesCount = 1,
   tournamentRecord,
   drawDefinition,
@@ -43249,13 +43452,21 @@ function automatedPlayoffPositioning({
   if (!drawDefinition) return {
     error: DRAW_DEFINITION_NOT_FOUND
   };
-  const participants = tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.participants;
+  const structureIsComplete = isCompletedStructure({
+    drawDefinition,
+    structureId
+  });
+  if (!structureIsComplete) return {
+    error: INCOMPLETE_SOURCE_STRUCTURE
+  };
   const {
     playoffStructures
   } = getPlayoffStructures({
     drawDefinition,
     structureId
   });
+  const structurePositionAssignments = [];
+  const participants = tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.participants;
 
   if (playoffStructures) {
     for (const structure of playoffStructures) {
@@ -43264,16 +43475,22 @@ function automatedPlayoffPositioning({
       } = structure;
       const result = automatedPositioning$1({
         structureId: playoffStructureId,
+        applyPositioning,
         candidatesCount,
         drawDefinition,
         participants,
         seedsOnly
       });
       if (result.error) return result;
+      structurePositionAssignments.push({
+        positionAssignments: result.positionAssignments,
+        structureId: playoffStructureId
+      });
     }
   }
 
-  return { ...SUCCESS
+  return { ...SUCCESS,
+    structurePositionAssignments
   };
 }
 
@@ -45123,6 +45340,10 @@ function setEntryPositions({
   };
 }
 
+function setPositionAssignments(params) {
+  return setPositionAssignments$1(params);
+}
+
 function addDrawDefinitionTimeItem({
   drawDefinition,
   timeItem
@@ -46368,6 +46589,7 @@ const eventGovernor = {
   setDrawParticipantRepresentativeIds,
   getDrawParticipantRepresentativeIds,
   luckyLoserDrawPositionAssignment,
+  setPositionAssignments,
   automatedPositioning,
   automatedPlayoffPositioning,
   checkInParticipant,
@@ -52256,7 +52478,8 @@ function generateEventWithDraw({
             tournamentRecord,
             drawDefinition,
             event
-          });
+          }); // ignore when positioning cannot occur because of incomplete source structure
+
           const playoffCompletionGoal = completionGoal ? completionGoal - completedCount : undefined;
           result = completeDrawMatchUps({
             completionGoal: completionGoal ? playoffCompletionGoal : undefined,
@@ -52302,16 +52525,20 @@ function generateVenues({
 
   for (const [index, venueProfile] of venueProfiles.entries()) {
     let {
+      venueAbbreviation,
       venueId = UUID(),
-      venueName,
-      courtsCount,
       dateAvailability,
       startTime = '07:00',
-      endTime = '19:00'
+      endTime = '19:00',
+      courtsCount,
+      courtNames,
+      venueName,
+      courtIds
     } = venueProfile;
     const newVenue = {
-      venueId,
-      venueName: venueName || `Venue ${index + 1}`
+      venueName: venueName || `Venue ${index + 1}`,
+      venueAbbreviation,
+      venueId
     };
     let result = addVenue$1({
       tournamentRecord,
@@ -52327,9 +52554,11 @@ function generateVenues({
     })) || dateAvailability;
     result = addCourts$1({
       tournamentRecord,
-      venueId,
+      dateAvailability,
       courtsCount,
-      dateAvailability
+      courtNames,
+      courtIds,
+      venueId
     });
     if (result.error) return result;
   }
@@ -52643,30 +52872,30 @@ function generateSchedulingProfile({
           let structureId = targetMatchUp.structureId;
 
           if (roundNumber && !winnerFinishingPositionRange) {
-            structureId = Object.keys(containedStructures).find(containingStructureId => containedStructures[containingStructureId].includes(structureId));
+            structureId = Object.keys(containedStructures).find(containingStructureId => containedStructures[containingStructureId].includes(structureId)) || structureId;
           }
 
           const roundToSchedule = {
             tournamentId,
-            eventId,
-            drawId,
             structureId,
             roundNumber,
-            roundSegment
+            roundSegment,
+            eventId,
+            drawId
           };
           let result = addSchedulingProfileRound({
             tournamentRecords: {
               [tournamentId]: tournamentRecord
             },
+            round: roundToSchedule,
             scheduleDate,
-            venueId,
-            round: roundToSchedule
+            venueId
           });
           if (result.error) return result;
           scheduledRounds.push({
-            drawName,
             structureName,
             roundName,
+            drawName,
             ...roundToSchedule
           });
         }
@@ -52704,6 +52933,8 @@ function generateSchedulingProfile({
  */
 
 function generateTournamentRecord({
+  scheduleCompletedMatchUps,
+  // explicit override for scheduler
   ratingsParameters: ratingsParameters$1 = ratingsParameters,
   tournamentName = 'Mock Tournament',
   tournamentExtensions,
@@ -52856,7 +53087,8 @@ function generateTournamentRecord({
 
   const venueIds = venueProfiles !== null && venueProfiles !== void 0 && venueProfiles.length ? generateVenues({
     tournamentRecord,
-    venueProfiles
+    venueProfiles,
+    uuids
   }) : [];
   let scheduledRounds;
   let schedulerResult = {};
@@ -52877,6 +53109,7 @@ function generateTournamentRecord({
         [tournamentId]: tournamentRecord
       };
       schedulerResult = scheduleProfileRounds({
+        scheduleCompletedMatchUps,
         tournamentRecords
       });
     }