tods-competition-factory 0.65.2 → 0.67.2

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.65.2';
+  return '0.67.2';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -7525,6 +7525,7 @@ const LUCKY_PARTICIPANT_METHOD = 'luckyLoserDrawPositionAssignment';
 const REMOVE_ASSIGNMENT_METHOD = 'removeDrawPositionAssignment';
 const SWAP_PARTICIPANT_METHOD = 'swapDrawPositionAssignments';
 const ADD_NICKNAME_METHOD = 'modifyParticipantOtherName';
+const ASSIGN_SIDE_METHOD = 'assignMatchUpSideParticipant';
 const ASSIGN_PARTICIPANT_METHOD = 'assignDrawPosition';
 const ASSIGN_BYE_METHOD = 'assignDrawPositionBye';
 const SEED_VALUE_METHOD = 'modifySeedAssignment';
@@ -9455,7 +9456,9 @@ function getRoundMatchUps$1({
     const currentRoundMatchUps = roundMatchUps[roundNumber].sort((a, b) => a.roundPosition - b.roundPosition);
     const currentRoundDrawPositions = currentRoundMatchUps.map(matchUp => (matchUp === null || matchUp === void 0 ? void 0 : matchUp.drawPositions) || []).flat();
     roundProfile[roundNumber].roundNumber = roundNumber; // convenience
+    // convenience for display calculations
 
+    roundProfile[roundNumber].roundFactor = roundProfile[roundNumber].matchUpsCount ? maxMatchUpsCount / roundProfile[roundNumber].matchUpsCount : 1;
     roundProfile[roundNumber].finishingRound = finishingRoundMap[roundNumber].finishingRound;
     roundProfile[roundNumber].roundName = finishingRoundMap[roundNumber].roundName;
     roundProfile[roundNumber].abbreviatedRoundName = finishingRoundMap[roundNumber].abbreviatedRoundName;
@@ -10671,6 +10674,16 @@ function getOrderedDrawPositions({
   };
 }
 
+function isAdHoc({
+  drawDefinition,
+  structure
+}) {
+  if (!drawDefinition || !structure) return false;
+  return !(structure !== null && structure !== void 0 && structure.structures) && !(drawDefinition !== null && drawDefinition !== void 0 && drawDefinition.drawType && drawDefinition.drawType !== AD_HOC) && !(structure !== null && structure !== void 0 && structure.matchUps.find(({
+    roundPosition
+  }) => !!roundPosition));
+}
+
 function getRoundContextProfile({
   roundNamingPolicy,
   structure,
@@ -10678,6 +10691,9 @@ function getRoundContextProfile({
 }) {
   const roundNamingProfile = {};
   const isRoundRobin = structure.structures;
+  const isAdHocStructure = isAdHoc({
+    structure
+  });
   const {
     roundProfile
   } = getRoundMatchUps$1({
@@ -10695,7 +10711,7 @@ function getRoundContextProfile({
   const stageConstants = roundNamingPolicy === null || roundNamingPolicy === void 0 ? void 0 : roundNamingPolicy.stageConstants;
   const stageConstant = stageConstants && stageConstants[stage] || stageInitial;
 
-  if (isRoundRobin) {
+  if (isRoundRobin || isAdHocStructure) {
     Object.assign(roundNamingProfile, ...Object.keys(roundProfile).map(key => {
       const profileSize = `R${key}`;
       return {
@@ -11379,7 +11395,7 @@ function getAllStructureMatchUps({
     matchUp,
     event
   }) {
-    var _roundNamingProfile$r, _roundNamingProfile$r2, _roundProfile$roundNu, _roundProfile$roundNu2;
+    var _roundNamingProfile$r, _roundNamingProfile$r2, _roundProfile$roundNu, _roundProfile$roundNu2, _roundProfile$roundNu3;
 
     const tieFormat = matchUp.tieFormat || structure.tieFormat || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat);
     const collectionDefinitions = tieFormat === null || tieFormat === void 0 ? void 0 : tieFormat.collectionDefinitions;
@@ -11421,6 +11437,7 @@ function getAllStructureMatchUps({
     const abbreviatedRoundName = roundNamingProfile && ((_roundNamingProfile$r2 = roundNamingProfile[roundNumber]) === null || _roundNamingProfile$r2 === void 0 ? void 0 : _roundNamingProfile$r2.abbreviatedRoundName) || additionalContext.abbreviatedRoundName;
     const feedRound = roundProfile === null || roundProfile === void 0 ? void 0 : (_roundProfile$roundNu = roundProfile[roundNumber]) === null || _roundProfile$roundNu === void 0 ? void 0 : _roundProfile$roundNu.feedRound;
     const preFeedRound = roundProfile === null || roundProfile === void 0 ? void 0 : (_roundProfile$roundNu2 = roundProfile[roundNumber]) === null || _roundProfile$roundNu2 === void 0 ? void 0 : _roundProfile$roundNu2.preFeedRound;
+    const roundFactor = roundProfile === null || roundProfile === void 0 ? void 0 : (_roundProfile$roundNu3 = roundProfile[roundNumber]) === null || _roundProfile$roundNu3 === void 0 ? void 0 : _roundProfile$roundNu3.roundFactor;
     const drawPositionsRoundRanges = drawPositionsRanges && drawPositionsRanges[roundNumber];
     const drawPositionsRange = drawPositionsRoundRanges && drawPositionsRoundRanges[roundPosition];
     const sourceDrawPositionRoundRanges = sourceDrawPositionRanges && sourceDrawPositionRanges[roundNumber]; // order is important here as Round Robin matchUps already have inContext structureId
@@ -11437,8 +11454,10 @@ function getAllStructureMatchUps({
       stageSequence,
       drawPositions,
       matchUpStatus,
+      isRoundRobin,
       matchUpTieId,
       preFeedRound,
+      roundFactor,
       matchUpType,
       exitProfile,
       structureId,
@@ -13038,7 +13057,7 @@ function addUpcomingMatchUps({
         }
 
         if ((_loserTo = loserTo) !== null && _loserTo !== void 0 && (_loserTo$schedule = _loserTo.schedule) !== null && _loserTo$schedule !== void 0 && _loserTo$schedule.scheduledTime) {
-          const scheduleConflict = timeStringMinutes(winnerTo.schedule.scheduledTime) < timeStringMinutes(timeAfterRecovery);
+          const scheduleConflict = timeStringMinutes(loserTo.schedule.scheduledTime) < timeStringMinutes(timeAfterRecovery);
 
           if (scheduleConflict) {
             scheduleConflictMatchUpIds[loserTo.matchUpId] = inContextMatchUp.matchUpId;
@@ -16373,15 +16392,23 @@ function removeDirectedParticipants(params) {
     structure,
     event
   } = params;
-  const isCollectionMatchUp = Boolean(params.matchUp.collectionId); // targetData will have team matchUp when params.matchUp is a collectionMatchUp
+  const isCollectionMatchUp = Boolean(params.matchUp.collectionId);
+  const isAdHocMatchUp = isAdHoc({
+    drawDefinition,
+    structure
+  }); // targetData will have team matchUp when params.matchUp is a collectionMatchUp
 
   const {
     drawPositions,
     winningSide
   } = targetData.matchUp || {};
-  if (!drawPositions) return {
-    error: MISSING_DRAW_POSITIONS
-  };
+
+  if (!isAdHocMatchUp && !drawPositions) {
+    return {
+      error: MISSING_DRAW_POSITIONS
+    };
+  }
+
   const {
     targetLinks: {
       loserTargetLink,
@@ -16392,27 +16419,6 @@ function removeDirectedParticipants(params) {
       winnerMatchUp
     }
   } = targetData;
-  const {
-    positionAssignments
-  } = structureAssignedDrawPositions({
-    structure
-  });
-  const winningIndex = winningSide - 1;
-  const losingIndex = 1 - winningIndex;
-  const winningDrawPosition = drawPositions[winningIndex];
-  const loserDrawPosition = drawPositions[losingIndex]; // use reduce for single pass resolution of both
-
-  const {
-    winnerParticipantId,
-    loserParticipantId
-  } = positionAssignments.reduce((assignments, assignment) => {
-    if (assignment.drawPosition === loserDrawPosition) assignments.loserParticipantId = assignment.participantId;
-    if (assignment.drawPosition === winningDrawPosition) assignments.winnerParticipantId = assignment.participantId;
-    return assignments;
-  }, {
-    winnerParticipantId: undefined,
-    loserParticipantId: undefined
-  });
   const result = modifyMatchUpScore({ ...params,
     matchUpStatus: matchUpStatus || TO_BE_PLAYED,
     removeWinningSide: true
@@ -16435,6 +16441,8 @@ function removeDirectedParticipants(params) {
     };
   }
 
+  if (isAdHocMatchUp) return { ...SUCCESS
+  };
   const {
     matchUps: sourceMatchUps
   } = getAllStructureMatchUps({
@@ -16443,6 +16451,27 @@ function removeDirectedParticipants(params) {
     matchUpsMap,
     structure
   });
+  const {
+    positionAssignments
+  } = structureAssignedDrawPositions({
+    structure
+  });
+  const winningIndex = winningSide - 1;
+  const losingIndex = 1 - winningIndex;
+  const winningDrawPosition = drawPositions[winningIndex];
+  const loserDrawPosition = drawPositions[losingIndex]; // use reduce for single pass resolution of both
+
+  const {
+    winnerParticipantId,
+    loserParticipantId
+  } = positionAssignments.reduce((assignments, assignment) => {
+    if (assignment.drawPosition === loserDrawPosition) assignments.loserParticipantId = assignment.participantId;
+    if (assignment.drawPosition === winningDrawPosition) assignments.winnerParticipantId = assignment.participantId;
+    return assignments;
+  }, {
+    winnerParticipantId: undefined,
+    loserParticipantId: undefined
+  });
   const drawPositionMatchUps = sourceMatchUps.filter(matchUp => matchUp.drawPositions.includes(loserDrawPosition));
 
   if (winnerMatchUp) {
@@ -18037,40 +18066,6 @@ function checkConnectedStructures({
   };
 }
 
-function getAvailableAdHocParticipantIds({
-  drawDefinition,
-  drawPosition,
-  structure
-}) {
-  var _structure$matchUps, _structure$matchUps2, _structure$positionAs;
-
-  // In AdHoc draws a participant can be assigned to multiple drawPositions ...
-  // ... because each round is unique ...
-  // therfore, the targetMatchUp must be found...
-  const targetMatchUp = structure === null || structure === void 0 ? void 0 : (_structure$matchUps = structure.matchUps) === null || _structure$matchUps === void 0 ? void 0 : _structure$matchUps.find(matchUp => {
-    var _matchUp$drawPosition;
-
-    return (_matchUp$drawPosition = matchUp.drawPositions) === null || _matchUp$drawPosition === void 0 ? void 0 : _matchUp$drawPosition.includes(drawPosition);
-  }); // ... so that the target roundNumber can be found ...
-
-  const roundNumber = targetMatchUp === null || targetMatchUp === void 0 ? void 0 : targetMatchUp.roundNumber; // ... so that the round's drawPositions can be found ...
-
-  const roundDrawPositions = structure === null || structure === void 0 ? void 0 : (_structure$matchUps2 = structure.matchUps) === null || _structure$matchUps2 === void 0 ? void 0 : _structure$matchUps2.filter(matchUp => matchUp.roundNumber === roundNumber).map(({
-    drawPositions
-  }) => drawPositions).flat(); // ... so that the round's assigned participantIds can be found ...
-
-  const roundAssignedParticipantIds = structure === null || structure === void 0 ? void 0 : (_structure$positionAs = structure.positionAssignments) === null || _structure$positionAs === void 0 ? void 0 : _structure$positionAs.filter(({
-    drawPosition,
-    participantId
-  }) => roundDrawPositions.includes(drawPosition) && participantId).map(getParticipantId);
-  const enteredParticipantIds = (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.entries.filter(({
-    entryStatus
-  }) => [DIRECT_ACCEPTANCE, ORGANISER_ACCEPTANCE, WILDCARD].includes(entryStatus)).map(getParticipantId)) || []; // AdHoc available participants are those entered in the draw who are not assigned to the target round
-
-  const availableParticipantIds = enteredParticipantIds.filter(participantId => !roundAssignedParticipantIds.includes(participantId));
-  return availableParticipantIds;
-}
-
 function conditionallyDisableLinkPositioning({
   drawPositions,
   structure
@@ -18686,6 +18681,12 @@ function assignDrawPosition$1({
   if (error) return {
     error
   };
+  if (isAdHoc({
+    drawDefinition,
+    structure
+  })) return {
+    error: INVALID_MATCHUP
+  };
   const {
     positionAssignments
   } = structureAssignedDrawPositions({
@@ -18719,16 +18720,7 @@ function assignDrawPosition$1({
   if (!participantId) return {
     error: MISSING_PARTICIPANT_ID
   };
-  const isAdHoc = !(structure !== null && structure !== void 0 && structure.structures) && !(structure !== null && structure !== void 0 && structure.matchUps.find(({
-    roundPosition
-  }) => !!roundPosition)); // in adHoc structures participants may have a drawPosition assigned in each round
-  // whereas in other types of structures they may appear only once in positionAssignments
-
-  const participantAlreadyAssigned = isAdHoc ? !getAvailableAdHocParticipantIds({
-    drawDefinition,
-    drawPosition,
-    structure
-  }).includes(participantId) : positionAssignments.map(getParticipantId).includes(participantId);
+  const participantAlreadyAssigned = positionAssignments.map(getParticipantId).includes(participantId);
 
   if (participantAlreadyAssigned) {
     return {
@@ -19215,7 +19207,11 @@ function directParticipants(params) {
     score
   } = params;
   const isCollectionMatchUp = Boolean(matchUp.collectionId);
-  const validToScore = isCollectionMatchUp || drawPositionsAssignedParticipantIds({
+  const isAdHocMatchUp = isAdHoc({
+    drawDefinition,
+    structure
+  });
+  const validToScore = isCollectionMatchUp || isAdHocMatchUp || drawPositionsAssignedParticipantIds({
     structure,
     matchUp
   });
@@ -19264,6 +19260,11 @@ function directParticipants(params) {
     };
   }
 
+  if (isAdHocMatchUp) {
+    return { ...SUCCESS
+    };
+  }
+
   if (drawPositions) {
     const winningIndex = winningSide - 1;
     const losingIndex = 1 - winningIndex;
@@ -19778,7 +19779,7 @@ function swapWinnerLoser(params) {
 // WOULDBENICE: return object containing all modified { matchUpIds, structureIds, drawIds }
 
 function setMatchUpStatus$2(params) {
-  var _inContextMatchUp$dra;
+  var _inContextMatchUp$dra, _matchUp$sides;
 
   // matchUpStatus in params is the new status
   // winningSide in params is new winningSide
@@ -19857,12 +19858,6 @@ function setMatchUpStatus$2(params) {
 
   const assignedDrawPositions = (_inContextMatchUp$dra = inContextMatchUp.drawPositions) === null || _inContextMatchUp$dra === void 0 ? void 0 : _inContextMatchUp$dra.filter(Boolean);
 
-  if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && (!assignedDrawPositions || (assignedDrawPositions === null || assignedDrawPositions === void 0 ? void 0 : assignedDrawPositions.length) < 2)) {
-    return {
-      error: INVALID_MATCHUP_STATUS
-    };
-  }
-
   if (matchUp.matchUpType === TEAM$3) {
     // do not direclty set team score... unless walkover/default/double walkover/Retirement
     return {
@@ -19885,6 +19880,14 @@ function setMatchUpStatus$2(params) {
     drawDefinition,
     structureId
   });
+  const bothSideParticipants = ((_matchUp$sides = matchUp.sides) === null || _matchUp$sides === void 0 ? void 0 : _matchUp$sides.map(side => side.participantId).filter(Boolean).length) === 2 || (assignedDrawPositions === null || assignedDrawPositions === void 0 ? void 0 : assignedDrawPositions.length) === 2;
+
+  if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && !bothSideParticipants) {
+    return {
+      error: INVALID_MATCHUP_STATUS
+    };
+  }
+
   Object.assign(params, {
     inContextDrawMatchUps,
     inContextMatchUp,
@@ -28408,6 +28411,7 @@ const matchUpActionConstants = {
  */
 
 function matchUpActions$2({
+  tournamentParticipants = [],
   inContextDrawMatchUps,
   drawDefinition,
   matchUpsMap,
@@ -28422,6 +28426,9 @@ function matchUpActions$2({
   if (!matchUpId) return {
     error: MISSING_MATCHUP_ID
   };
+  const {
+    drawId
+  } = drawDefinition;
   const {
     matchUp,
     structure
@@ -28446,6 +28453,46 @@ function matchUpActions$2({
   if (!structureId) return {
     validActions
   };
+
+  if (isAdHoc({
+    drawDefinition,
+    structure
+  })) {
+    const roundMatchUps = (structure.matchUps || []).filter(({
+      roundNumber
+    }) => roundNumber === matchUp.roundNumber);
+    const enteredParticipantIds = (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.entries.filter(({
+      entryStatus
+    }) => [DIRECT_ACCEPTANCE, ORGANISER_ACCEPTANCE, WILDCARD].includes(entryStatus)).map(getParticipantId)) || [];
+    const roundAssignedParticipantIds = roundMatchUps.map(matchUp => (matchUp.sides || []).map(side => side.participantId)).flat().filter(Boolean);
+    const availableParticipantIds = enteredParticipantIds.filter(participantId => !roundAssignedParticipantIds.includes(participantId));
+    const participantsAvailable = tournamentParticipants === null || tournamentParticipants === void 0 ? void 0 : tournamentParticipants.filter(participant => availableParticipantIds === null || availableParticipantIds === void 0 ? void 0 : availableParticipantIds.includes(participant.participantId));
+    participantsAvailable === null || participantsAvailable === void 0 ? void 0 : participantsAvailable.forEach(participant => {
+      const entry = (drawDefinition.entries || []).find(entry => entry.participantId === participant.participantId);
+      participant.entryPosition = entry === null || entry === void 0 ? void 0 : entry.entryPosition;
+    });
+
+    if (availableParticipantIds.length) {
+      validActions.push({
+        type: ASSIGN_PARTICIPANT,
+        availableParticipantIds,
+        participantsAvailable,
+        method: ASSIGN_SIDE_METHOD,
+        payload: {
+          drawId,
+          matchUpId,
+          structureId
+          /*, sideNumber*/
+
+        }
+      });
+    }
+
+    validActions.push({
+      type: ALTERNATE_PARTICIPANT
+    });
+  }
+
   const structureIsComplete = isCompletedStructure({
     drawDefinition,
     structure
@@ -28510,9 +28557,6 @@ function matchUpActions$2({
   }
 
   const readyToScore = (matchUpDrawPositionsAreAssigned || hasParticipants) && !(isDoubleWalkover && activeDownstream);
-  const {
-    drawId
-  } = drawDefinition;
   const addPenaltyAction = {
     type: ADD_PENALTY,
     method: ADD_PENALTY_METHOD,
@@ -31477,70 +31521,6 @@ function generateVoluntaryConsolationStructure$1({
   };
 }
 
-/**
- *
- * @param {string} drawId - when called via tournamentEngine enabled drawDefinition discovery
- * @param {object} drawDefinition - required when called via drawEngine
- * @param {string} structureId
- * @param {object[]} matchUps
- *
- */
-
-function addAdHocMatchUps$1({
-  drawDefinition,
-  structureId,
-  matchUps
-}) {
-  var _drawDefinition$struc;
-
-  if (typeof drawDefinition !== 'object') return {
-    error: MISSING_DRAW_DEFINITION
-  };
-  if (typeof structureId !== 'string') return {
-    error: MISSING_STRUCTURE_ID
-  };
-  if (!Array.isArray(matchUps)) return {
-    error: INVALID_VALUES
-  };
-  const structure = (_drawDefinition$struc = drawDefinition.structures) === null || _drawDefinition$struc === void 0 ? void 0 : _drawDefinition$struc.find(structure => structure.structureId === structureId);
-  if (!structure) return {
-    error: STRUCTURE_NOT_FOUND
-  };
-  const existingMatchUps = structure === null || structure === void 0 ? void 0 : structure.matchUps;
-  const structureHasRoundPositions = existingMatchUps.find(matchUp => !!matchUp.roundPosition);
-
-  if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
-    return {
-      error: INVALID_STRUCTURE
-    };
-  }
-
-  const existingDrawPositions = (structure.matchUps || []).map(({
-    drawPositions
-  }) => drawPositions).flat().sort((a, b) => a - b);
-  const nextDrawPosition = Math.max(...existingDrawPositions, 0) + 1;
-  const matchUpsCount = matchUps.length;
-  const newDrawPositions = generateRange(nextDrawPosition, nextDrawPosition + matchUpsCount * 2);
-  const newDrawPositionPairs = chunkArray(newDrawPositions, 2);
-  matchUps.forEach((matchUp, i) => matchUp.drawPositions = newDrawPositionPairs[i]);
-  structure.matchUps.push(...matchUps);
-  const newPositionAssignments = newDrawPositions.map(drawPosition => ({
-    drawPosition
-  }));
-  if (!structure.positionAssignments) structure.positionAssignments = [];
-  structure.positionAssignments.push(...newPositionAssignments);
-  addMatchUpsNotice({
-    drawDefinition,
-    matchUps
-  });
-  modifyDrawNotice({
-    drawDefinition,
-    structureIds: [structureId]
-  });
-  return { ...SUCCESS
-  };
-}
-
 /**
  *
  * @param {string} drawId - required - tournamentEngine discovers and passes { drawDefinition }
@@ -31555,12 +31535,12 @@ function addAdHocMatchUps$1({
  */
 
 function generateAdHocMatchUps$1({
-  drawDefinition,
-  structureId,
-  addMatchUps = false,
-  matchUpsCount = 1,
+  participantIdPairings,
   matchUpIds = [],
+  drawDefinition,
+  matchUpsCount,
   roundNumber,
+  structureId,
   newRound
 }) {
   var _drawDefinition$struc;
@@ -31571,7 +31551,7 @@ function generateAdHocMatchUps$1({
   if (typeof structureId !== 'string') return {
     error: MISSING_STRUCTURE_ID
   };
-  if (!isConvertableInteger(matchUpsCount) || !Array.isArray(matchUpIds)) return {
+  if (participantIdPairings && !Array.isArray(participantIdPairings) || matchUpsCount && !isConvertableInteger(matchUpsCount) || matchUpIds && !Array.isArray(matchUpIds) || !participantIdPairings && !matchUpsCount) return {
     error: INVALID_VALUES
   }; // if drawDefinition and structureId are provided it is possible to infer roundNumber
 
@@ -31595,25 +31575,74 @@ function generateAdHocMatchUps$1({
     error: INVALID_VALUES
   };
   const nextRoundNumber = roundNumber || (newRound ? lastRoundNumber + 1 : lastRoundNumber || 1);
-  const matchUps = generateRange(0, matchUpsCount).map(() => ({
-    matchUpId: matchUpIds.pop() || UUID(),
-    roundNumber: nextRoundNumber,
-    matchUpStatus: TO_BE_PLAYED,
-    drawPositions: []
+  participantIdPairings = participantIdPairings || generateRange(0, matchUpsCount).map(() => ({
+    participantIds: []
   }));
+  const matchUps = participantIdPairings.map(pairing => {
+    // ensure there are always 2 sides in generated matchUps
+    const participantIds = ((pairing === null || pairing === void 0 ? void 0 : pairing.participantIds) || []).concat([undefined, undefined]).slice(0, 2);
+    const sides = participantIds.map((participantId, i) => definedAttributes({
+      sideNumber: i + 1,
+      participantId
+    }));
+    return {
+      matchUpId: matchUpIds.pop() || UUID(),
+      roundNumber: nextRoundNumber,
+      matchUpStatus: TO_BE_PLAYED,
+      sides
+    };
+  });
+  const result = addAdHocMatchUps({
+    drawDefinition,
+    structureId,
+    matchUps
+  });
+  if (result.error) return result;
+  return {
+    matchUpsCount: matchUps.length,
+    ...SUCCESS
+  };
+}
 
-  if (addMatchUps) {
-    const result = addAdHocMatchUps$1({
-      drawDefinition,
-      structureId,
-      matchUps
-    });
-    if (result.error) return result;
+function addAdHocMatchUps({
+  drawDefinition,
+  structureId,
+  matchUps
+}) {
+  var _drawDefinition$struc2;
+
+  if (typeof drawDefinition !== 'object') return {
+    error: MISSING_DRAW_DEFINITION
+  };
+  if (typeof structureId !== 'string') return {
+    error: MISSING_STRUCTURE_ID
+  };
+  if (!Array.isArray(matchUps)) return {
+    error: INVALID_VALUES
+  };
+  const structure = (_drawDefinition$struc2 = drawDefinition.structures) === null || _drawDefinition$struc2 === void 0 ? void 0 : _drawDefinition$struc2.find(structure => structure.structureId === structureId);
+  if (!structure) return {
+    error: STRUCTURE_NOT_FOUND
+  };
+  const existingMatchUps = structure === null || structure === void 0 ? void 0 : structure.matchUps;
+  const structureHasRoundPositions = existingMatchUps.find(matchUp => !!matchUp.roundPosition);
+
+  if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
+    return {
+      error: INVALID_STRUCTURE
+    };
   }
 
-  return {
-    matchUps,
-    ...SUCCESS
+  structure.matchUps.push(...matchUps);
+  addMatchUpsNotice({
+    drawDefinition,
+    matchUps
+  });
+  modifyDrawNotice({
+    drawDefinition,
+    structureIds: [structureId]
+  });
+  return { ...SUCCESS
   };
 }
 
@@ -34152,7 +34181,6 @@ const structureGovernor = {
   getAvailablePlayoffRounds: getAvailablePlayoffRounds$1,
   addPlayoffStructures: addPlayoffStructures$1,
   removeStructure,
-  addAdHocMatchUps: addAdHocMatchUps$1,
   generateAdHocMatchUps: generateAdHocMatchUps$1,
   deleteAdHocMatchUps: deleteAdHocMatchUps$1,
   structureSort,
@@ -36261,51 +36289,80 @@ function participantScaleItem({
 }
 
 function generateCandidate({
-  rankedPairings,
+  maxIterations = 5000,
+  // cap the processing intensity of the candidate generator
+  valueSortedPairings,
+  // pairings sorted by value from low to high
   pairingValues,
-  deltaObjects,
-  candidateGoal = 2000,
-  actorDivisor = 100
+  deltaObjects
 }) {
-  const rankedMatchUpValues = Object.assign({}, ...rankedPairings.map(rm => ({
-    [rm.matchUp]: rm.value
-  })));
+  const rankedMatchUpValues = Object.assign({}, ...valueSortedPairings.map(rm => ({
+    [rm.pairing]: rm.value
+  }))); // generate an initial candidate value with no stipulated pairings
+
   let candidate = roundCandidate({
-    rankedPairings,
     rankedMatchUpValues,
+    valueSortedPairings,
     deltaObjects
   });
-  let deltaCandidate = candidate; // for each actor generate a roundCandidate using all of their matchUp values
+  let deltaCandidate = candidate;
+  const actors = Object.keys(pairingValues); // iterations is the number of loops over valueSortedPairings
+
+  let candidatesCount = 0;
+  let iterations; // calculate the number of opponents to consider for each participantId
+
+  let opponentCount = actors.length;
+
+  do {
+    opponentCount -= 1;
+    iterations = actors.length * opponentCount * valueSortedPairings.length / 2;
+  } while (iterations > maxIterations && opponentCount > 2);
+
+  let stipulatedPairs = []; // for each actor generate a roundCandidate using opponentCount of pairing values
 
-  const actors = Object.keys(pairingValues);
-  const divisor = candidateGoal / (actors.length / actorDivisor);
-  let iterations = Math.floor(divisor / actors.length);
-  if (iterations > candidateGoal) iterations = candidateGoal;
   actors.forEach(actor => {
-    const participantIdPairings = pairingValues[actor];
-    participantIdPairings.slice(0, iterations).forEach(pairing => {
-      const proposed = roundCandidate({
-        rankedPairings,
-        rankedMatchUpValues,
-        stipulated: [pairing.participantIds],
-        deltaObjects
-      });
-      if (proposed.maxDelta < deltaCandidate.maxDelta) deltaCandidate = proposed;
-      if (proposed.value < candidate.value) candidate = proposed;
+    const participantIdPairings = pairingValues[actor]; // opponentCount limits the number of opponents to consider
+
+    participantIdPairings.slice(0, opponentCount).forEach(pairing => {
+      const stipulatedPair = pairingHash(actor, pairing.opponent);
+
+      if (!stipulatedPairs.includes(stipulatedPair)) {
+        const proposed = roundCandidate({
+          // each roundCandidate starts with stipulated pairings
+          stipulated: [[actor, pairing.opponent]],
+          rankedMatchUpValues,
+          valueSortedPairings,
+          deltaObjects
+        });
+        if (proposed.maxDelta < deltaCandidate.maxDelta) deltaCandidate = proposed;
+        if (proposed.value < candidate.value) candidate = proposed;
+        stipulatedPairs.push(stipulatedPair);
+        candidatesCount += 1;
+      }
     });
   });
-  return candidate;
+  return {
+    candidate,
+    deltaCandidate,
+    candidatesCount,
+    iterations
+  };
 }
 
 function roundCandidate({
-  rankedPairings,
   rankedMatchUpValues,
+  valueSortedPairings,
   stipulated = [],
   deltaObjects
 }) {
-  let candidateValue = 0;
-  let participantIdPairings = [];
-  let roundPlayers = [].concat(...stipulated);
+  // roundPlayers starts with the stipulated pairing
+  const roundPlayers = [].concat(...stipulated); // aggregates the pairings generated for a roundCandidate
+
+  const participantIdPairings = []; // candidateValue is the sum of all participantIdPairings in a roundCandidate
+  // the winning candidate has the LOWEST total value
+
+  let candidateValue = 0; // candidateValue is initialized with any stipulated pairings
+
   stipulated.filter(Boolean).forEach(participantIds => {
     const pairing = pairingHash(...participantIds);
     const value = rankedMatchUpValues[pairing];
@@ -36314,13 +36371,15 @@ function roundCandidate({
       value
     });
     candidateValue += rankedMatchUpValues[pairing];
-  });
-  rankedPairings.forEach(rankedPairing => {
+  }); // go through the valueSortedPairings (of all possible unique pairings)
+  // this is an array sorted from lowest value to highest value
+
+  valueSortedPairings.forEach(rankedPairing => {
     const participantIds = rankedPairing.pairing.split('|');
-    const opponent_exists = participantIds.reduce((p, c) => roundPlayers.indexOf(c) >= 0 || p, false);
+    const opponentExists = participantIds.reduce((p, c) => roundPlayers.includes(c) || p, false);
 
-    if (!opponent_exists) {
-      roundPlayers = roundPlayers.concat(...participantIds);
+    if (!opponentExists) {
+      roundPlayers.push(...participantIds);
       let value = rankedPairing.value;
       candidateValue += value;
       participantIdPairings.push({
@@ -36328,8 +36387,10 @@ function roundCandidate({
         value
       });
     }
-  });
-  participantIdPairings.sort((a, b) => a.value - b.value);
+  }); // sort the candidate's proposed pairings by value
+
+  participantIdPairings.sort((a, b) => a.value - b.value); // determine the greatest delta in the candidate's pairings
+
   const maxDelta = participantIdPairings.reduce((p, c) => {
     const hash = pairingHash(...c.participantIds);
     const delta = deltaObjects[hash];
@@ -36346,15 +36407,16 @@ function pairingHash(id1, id2) {
   return [id1, id2].sort().join('|');
 }
 
+// import { assignDrawPosition } from '../../governors/positionGovernor/positionAssignment';
+
 const ENCOUNTER_VALUE = 50;
 const SAME_TEAM_VALUE = 60;
 const DEFAULT_RATING = 0;
-const CANDIDATE_GOAL = 2000;
-const ACTOR_DIVISOR = 100; // valueObjects provide "weighting" to each possible pairing of participants
-// deltaObjects contain the difference in ratings between two participants
-
+const MAX_ITERATIONS = 5000;
 function generateDrawMaticRound({
+  maxIterations = MAX_ITERATIONS,
   tournamentParticipants,
+  generateMatchUps,
   drawDefinition,
   participantIds,
   adHocRatings,
@@ -36364,17 +36426,16 @@ function generateDrawMaticRound({
   structure
 }) {
   // create valueObject for each previous encounter within the structure
-  const {
-    positionAssignments
-  } = getPositionAssignments$1({
-    structure
-  });
   const {
     encounters
   } = getEncounters({
-    matchUps: structure.matchUps,
-    positionAssignments
+    matchUps: structure.matchUps
   }); // valueObjects provide "weighting" to each possible pairing of participants
+  // {
+  //  'P-I-0|P-I-1': 1,
+  //  'P-I-0|P-I-2': 1,
+  //  'P-I-0|P-I-3': 1
+  // }
 
   const valueObjects = {};
 
@@ -36402,7 +36463,13 @@ function generateDrawMaticRound({
         valueObjects[pairing] += SAME_TEAM_VALUE;
       }
     }
-  }
+  } // deltaObjects contain the difference in ratings between two participants
+  // {
+  //  'P-I-0|P-I-1': 0,
+  //  'P-I-0|P-I-2': 0,
+  //  'P-I-0|P-I-3': 0
+  // }
+
 
   const {
     uniquePairings,
@@ -36411,82 +36478,108 @@ function generateDrawMaticRound({
   } = getPairingsData({
     participantIds
   });
-  const matchUpsCount = Math.floor(participantIds.length / 2); // TODO: for client/server sync...
-  // ... this needs to be called BEFORE drawMatic and the matchUpIds of pre-generated matchUps passed in...
-  // ... and draw position assignments need to be passed in bulk AFTER
-
-  const result = generateAdHocMatchUps$1({
-    newRound: true,
-    drawDefinition,
-    matchUpsCount,
-    structureId,
-    matchUpIds,
-    addMatchUps: true
-  }); // OR: the matchUps don't get added here...
-  // ... and the drawPositions to be added are retrieved by query then added ...
-  // ... and then the addAdHocMatchUps method can be called with drawPositions in place ...
-  // ... and it needs to do an integrity check to insure the drawPositions are all valid.
-  // This approach would require drawPositions to be assigned without calling assignDrawPosition
-
-  if (result.error) return result;
-  const roundMatchUps = result.matchUps;
   const params = {
+    tournamentParticipants,
+    possiblePairings,
     drawDefinition,
     participantIds,
-    possiblePairings,
     uniquePairings,
+    maxIterations,
     adHocRatings,
     deltaObjects,
     valueObjects,
+    eventType,
     structure
   };
   const {
-    participantIdPairings
-  } = eventType === DOUBLES ? getDoublesPairings(params) : getSinglesPairings(params);
-  console.log(participantIdPairings);
-
-  for (const [index, matchUp] of roundMatchUps.entries()) {
-    const drawPositions = matchUp.drawPositions;
-    const {
-      participantIds
-    } = participantIdPairings[index];
+    candidatesCount,
+    participantIdPairings,
+    iterations
+  } = getPairings(params);
+  if (!candidatesCount) return {
+    error: 'No Candidates'
+  };
 
-    for (const i of drawPositions.keys()) {
-      const participantId = participantIds[i];
-      const drawPosition = drawPositions[i];
-      const result = assignDrawPosition$1({
-        drawDefinition,
-        structureId,
-        participantId,
-        drawPosition
-      });
-      if (result.error) return result;
-    }
+  if (generateMatchUps) {
+    const result = generateAdHocMatchUps$1({
+      participantIdPairings,
+      drawDefinition,
+      newRound: true,
+      structureId,
+      matchUpIds
+    });
+    if (result.error) return result;
   }
 
-  return { ...SUCCESS
+  return { ...SUCCESS,
+    participantIdPairings,
+    candidatesCount,
+    iterations
   };
 }
 
-function getSinglesPairings({
-  deltaObjects,
-  valueObjects,
+function getSideRatings({
+  tournamentParticipants,
+  adHocRatings,
+  eventType,
+  pairing
+}) {
+  const ratings = pairing.split('|').map(participantId => {
+    if (eventType === DOUBLES) {
+      var _tournamentParticipan;
+
+      const individualParticipantIds = tournamentParticipants === null || tournamentParticipants === void 0 ? void 0 : (_tournamentParticipan = tournamentParticipants.find(participant => participant.participantId === participantId)) === null || _tournamentParticipan === void 0 ? void 0 : _tournamentParticipan.individualParticipantIds;
+      return !individualParticipantIds ? DEFAULT_RATING * 2 : individualParticipantIds.map(participantId => adHocRatings[participantId || DEFAULT_RATING]);
+    } else {
+      return adHocRatings[participantId] || DEFAULT_RATING;
+    }
+  });
+  return ratings;
+}
+
+function getPairings({
+  tournamentParticipants,
   adHocRatings = {},
+  possiblePairings,
+  // participant keyed; provides array of possible opponents
   uniquePairings,
-  possiblePairings
+  // hashes of all possible participantId pairings
+  maxIterations,
+  deltaObjects,
+  // difference in rating between paired participants
+  valueObjects,
+  // calculated value of a pairing of participants, used for sorting pairings
+  eventType
 }) {
-  // modify valueObjects by ratings differential squared
+  // modify valueObjects by ratings ratingsDifference squared
+  // update deltaObjects to reflect the current difference between participant's ratings
   uniquePairings.forEach(pairing => {
-    const ratings = pairing.split('|').map(participantId => adHocRatings[participantId] || DEFAULT_RATING);
-    const differential = Math.abs(ratings[0] - ratings[1]) + 1;
+    const ratings = getSideRatings({
+      tournamentParticipants,
+      adHocRatings,
+      eventType,
+      pairing
+    });
+    const ratingsDifference = Math.abs(ratings[0] - ratings[1]) + 1;
     deltaObjects[pairing] = Math.abs(ratings[0] - ratings[1]);
     if (!valueObjects[pairing]) valueObjects[pairing] = 0;
-    valueObjects[pairing] += Math.pow(differential, 2);
+    valueObjects[pairing] += Math.pow(ratingsDifference, 2);
   });
-  const rankedPairings = uniquePairings.map(pairing => ({
+  /**
+   * valueSortedPairings are uniquePairings sorted by the value of the pairings, lowest to highest
+   */
+
+  const valueSortedPairings = uniquePairings.map(pairing => ({
     pairing,
     value: valueObjects[pairing]
   })).sort((a, b) => a.value - b.value);
+  /**
+   * pairingValues is keyed by participantId and provides a value-sorted array of pairings for each participantId
+   * 'actorId': [
+        { opponent: 'potentialId1', value: 1 },
+        { opponent: 'potentialId2', value: 1 },
+   */
+
   const {
     pairingValues
   } = getParticipantPairingValues({
@@ -36494,24 +36587,22 @@ function getSinglesPairings({
     valueObjects
   });
   const {
-    participantIdPairings
+    candidate,
+    candidatesCount,
+    iterations
   } = generateCandidate({
-    rankedPairings,
+    valueSortedPairings,
+    maxIterations,
     pairingValues,
-    deltaObjects,
-    candidateGoal: CANDIDATE_GOAL,
-    actorDivisor: ACTOR_DIVISOR
+    deltaObjects
   });
-  return {
+  const {
     participantIdPairings
-  };
-}
-
-function getDoublesPairings({
-  roundMatchUps
-}) {
+  } = candidate;
   return {
-    matchUps: roundMatchUps
+    candidatesCount,
+    participantIdPairings,
+    iterations
   };
 }
 
@@ -36523,7 +36614,7 @@ function getPairingsData({
   participantIds.forEach(participantId => {
     possiblePairings[participantId] = participantIds.filter(id => id !== participantId);
     possiblePairings[participantId].forEach(id => {
-      const pairing = matchupHash(id, participantId);
+      const pairing = pairingHash(id, participantId);
       if (!uniquePairings.includes(pairing)) uniquePairings.push(pairing);
     });
   });
@@ -36538,18 +36629,15 @@ function getPairingsData({
 }
 
 function getEncounters({
-  matchUps,
-  positionAssignments
+  matchUps
 }) {
   let encounters = [];
 
   for (const matchUp of matchUps) {
-    const participantIds = positionAssignments.filter(({
-      drawPosition
-    }) => matchUp.drawPositions.includes(drawPosition)).map(getParticipantId).filter(Boolean);
+    const participantIds = matchUp.sides.map(getParticipantId);
 
     if (participantIds.length === 2) {
-      const pairing = matchupHash(...participantIds);
+      const pairing = pairingHash(...participantIds);
       if (!encounters.includes(pairing)) encounters.push(pairing);
     }
   }
@@ -36571,7 +36659,7 @@ function getParticipantPairingValues({
   }
 
   function pairingValue(participantId, opponent) {
-    let key = matchupHash(participantId, opponent);
+    let key = pairingHash(participantId, opponent);
     return {
       opponent,
       value: valueObjects[key]
@@ -36583,14 +36671,10 @@ function getParticipantPairingValues({
   };
 }
 
-function matchupHash(id1, id2) {
-  return [id1, id2].sort().join('|');
-}
-
 /**
  *
- * @param {object} drawDefinition
- * @param {string} structureId
+ * @param {object} drawDefinition - provided automatically by drawEngine
+ * @param {string} structureId - optional - defaults to the first structure of latest stage
  * @param {string[]} participantIds - optional - allows a subset of drawDefinition.entries to be specified
  *
  */
@@ -36598,19 +36682,24 @@ function matchupHash(id1, id2) {
 function drawMatic$1({
   tournamentParticipants,
   restrictEntryStatus,
+  generateMatchUps,
   drawDefinition,
   participantIds,
+  maxIterations,
   structureId,
   matchUpIds,
   scaleName,
   // custom rating name to seed dynamic ratings
   event
 }) {
-  var _drawDefinition$struc2;
+  var _drawDefinition$struc3;
 
-  if (typeof drawDefinition !== 'object') return {
+  if (typeof drawDefinition !== 'object' || drawDefinition.drawType && drawDefinition.drawType !== AD_HOC) return {
     error: INVALID_DRAW_DEFINITION
   };
+  if (!Array.isArray(drawDefinition.entries) || participantIds && !Array.isArray(participantIds)) return {
+    error: INVALID_VALUES
+  };
   const {
     eventType
   } = event || {};
@@ -36620,35 +36709,40 @@ function drawMatic$1({
 
   if (participantIds) {
     // ensure all participantIds are in drawDefinition.entries
-    const invalidParticipantId = !!participantIds.find(participantId => enteredParticipantIds.includes(participantId));
-    if (invalidParticipantId) return {
+    const invalidParticipantIds = participantIds.filter(participantId => !enteredParticipantIds.includes(participantId));
+    if (invalidParticipantIds !== null && invalidParticipantIds !== void 0 && invalidParticipantIds.length) return {
       error: INVALID_PARTICIPANT_ID,
-      participantId: invalidParticipantId
+      invalidParticipantIds
     };
   } else {
     participantIds = enteredParticipantIds;
-  }
-
-  const isAdHoc = structure => !(structure !== null && structure !== void 0 && structure.structures) && !(structure !== null && structure !== void 0 && structure.matchUps.find(({
-    roundPosition
-  }) => !!roundPosition)); // if no structureId is specified find the latest stage which has matchUps
+  } // if no structureId is specified find the latest AD_HOC stage which has matchUps
 
 
   if (!structureId) {
-    var _drawDefinition$struc;
+    var _drawDefinition$struc, _drawDefinition$struc2;
 
-    const targetStructure = (_drawDefinition$struc = drawDefinition.structures) === null || _drawDefinition$struc === void 0 ? void 0 : _drawDefinition$struc.find(structure => structure.stageSequence === 1).recuce((targetStructure, structure) => {
+    const targetStructure = (_drawDefinition$struc = drawDefinition.structures) === null || _drawDefinition$struc === void 0 ? void 0 : (_drawDefinition$struc2 = _drawDefinition$struc.filter(structure => structure.stageSequence === 1)) === null || _drawDefinition$struc2 === void 0 ? void 0 : _drawDefinition$struc2.reduce((targetStructure, structure) => {
       const orderNumber = stageOrder[structure.stage];
-      return isAdHoc(structure) && orderNumber > stageOrder[targetStructure.stage] ? structure : targetStructure;
+      const structureIsAdHoc = isAdHoc({
+        drawDefinition,
+        structure
+      });
+      return structureIsAdHoc && orderNumber > (stageOrder[targetStructure === null || targetStructure === void 0 ? void 0 : targetStructure.stage] || 1) ? structure : targetStructure;
     }, undefined);
     structureId = targetStructure === null || targetStructure === void 0 ? void 0 : targetStructure.structureId;
   }
 
-  const structure = (_drawDefinition$struc2 = drawDefinition.structures) === null || _drawDefinition$struc2 === void 0 ? void 0 : _drawDefinition$struc2.find(structure => structure.structureId === structureId);
+  const structure = (_drawDefinition$struc3 = drawDefinition.structures) === null || _drawDefinition$struc3 === void 0 ? void 0 : _drawDefinition$struc3.find(structure => structure.structureId === structureId);
   if (!structure) return {
     error: STRUCTURE_NOT_FOUND
-  };
-  if (!isAdHoc(structure)) return {
+  }; // an AD_HOC structure is one that has no child structures and in which no matchUps have roundPosition
+
+  const structureIsAdHoc = isAdHoc({
+    drawDefinition,
+    structure
+  });
+  if (!structureIsAdHoc) return {
     error: INVALID_DRAW_DEFINITION
   };
   const adHocRatings = {};
@@ -36673,11 +36767,15 @@ function drawMatic$1({
   }
 
   const {
-    matchUps
+    candidatesCount,
+    iterations,
+    participantIdPairings
   } = generateDrawMaticRound({
     tournamentParticipants,
+    generateMatchUps,
     drawDefinition,
     participantIds,
+    maxIterations,
     adHocRatings,
     matchUpIds,
     structureId,
@@ -36685,7 +36783,9 @@ function drawMatic$1({
     eventType
   });
   return { ...SUCCESS,
-    matchUps
+    candidatesCount,
+    iterations,
+    participantIdPairings
   };
 }
 
@@ -37479,10 +37579,6 @@ function getValidAssignmentActions({
     };
   }
 
-  const isAdHoc = !(structure !== null && structure !== void 0 && structure.structures) && !(structure !== null && structure !== void 0 && structure.matchUps.find(({
-    roundPosition
-  }) => !!roundPosition));
-
   if (unfilledPositions.includes(drawPosition) || isByePosition) {
     var _unplacedSeedAssignme;
 
@@ -37497,12 +37593,6 @@ function getValidAssignmentActions({
       });
       validToAssign.sort(validAssignmentsSort);
       availableParticipantIds = validToAssign.map(assignment => assignment.participantId);
-    } else if (isAdHoc) {
-      availableParticipantIds = getAvailableAdHocParticipantIds({
-        drawDefinition,
-        drawPosition,
-        structure
-      });
     } else {
       // otherwise look for any unplaced entries
       // 1) unassigned DIRECT_ACCEPTANCE or WILDCARD structure entries
@@ -41751,309 +41841,109 @@ const policyGovernor = {
   getEventAppliedPolicies
 };
 
-const COLLEGE_DEFAULT = 'COLLEGE_DEFAULT';
-const COLLEGE_JUCO = 'COLLEGE_JUCO';
-const COLLEGE_D3 = 'COLLEGE_D3';
-const DOMINANT_DUO = 'DOMINANT_DUO';
-const LAVER_CUP = 'LAVER_CUP';
-const TEAM_DOUBLES_3_AGGREGATION = 'TEAM_DOUBLES_3_AGGREGATION';
-const tieFormatConstants = {
-  COLLEGE_D3,
-  COLLEGE_DEFAULT,
-  COLLEGE_JUCO,
-  DOMINANT_DUO,
-  LAVER_CUP,
-  TEAM_DOUBLES_3_AGGREGATION
-};
-
-const namedFormats = {
-  STANDARD: {
-    hydrate: true,
-    doubles: {
-      matchUpCount: 3,
-      matchUpValue: 1
-    },
-    singles: {
-      matchUpCount: 6,
-      matchUpValue: 1
-    },
-    valueGoal: 5
-  },
-  [COLLEGE_D3]: {
-    hydrate: true,
-    doubles: {
-      matchUpCount: 3,
-      matchUpValue: 1,
-      matchUpFormat: 'SET1-S:8/TB7@7'
-    },
-    singles: {
-      matchUpCount: 6,
-      matchUpValue: 1,
-      matchUpFormat: 'SET3-S:6/TB7'
-    },
-    tieFormatName: 'COLLEGE_D3',
-    valueGoal: 5
-  },
-  [COLLEGE_DEFAULT]: {
-    hydrate: true,
-    doubles: {
-      matchUpCount: 3,
-      collectionValue: 1,
-      matchUpFormat: 'SET1-S:6/TB7'
-    },
-    singles: {
-      matchUpCount: 6,
-      matchUpValue: 1,
-      matchUpFormat: 'SET3-S:6/TB7'
-    },
-    tieFormatName: 'COLLEGE_DEFAULT',
-    valueGoal: 4
-  },
-  [COLLEGE_JUCO]: {
-    hydrate: true,
-    doubles: {
-      matchUpCount: 3,
-      matchUpValue: 1,
-      matchUpFormat: 'SET1-S:8/TB7'
-    },
-    singles: {
-      matchUpCount: 6,
-      matchUpValue: 1,
-      matchUpFormat: 'SET3-S:6/TB7'
-    },
-    tieFormatName: 'COLLEGE_JUCO',
-    valueGoal: 5
-  },
-  [LAVER_CUP]: LAVER_CUP_TIE_FORMAT,
-  [DOMINANT_DUO]: DOMINANT_DUO_TIE_FORMAT,
-  [TEAM_DOUBLES_3_AGGREGATION]: TEAM_AGGREGATION_TIE_FORMAT
-};
-const tieFormatDefaults = ({
-  namedFormat,
-  uuids = []
-} = {}) => {
-  var _uuids, _uuids2;
-
-  if (!Object.keys(namedFormats).includes(namedFormat)) namedFormat = 'STANDARD';
-  if (!Array.isArray(uuids)) uuids = [];
-  const template = namedFormats[namedFormat];
-
-  if (!template.hydrate) {
-    template.collectionDefinitions.forEach(collectionDefinition => collectionDefinition.collectionId = UUID());
-    return template;
-  }
-
-  const tieFormat = {
-    winCriteria: {
-      valueGoal: template.valueGoal
-    },
-    collectionDefinitions: [{
-      collectionId: ((_uuids = uuids) === null || _uuids === void 0 ? void 0 : _uuids.pop()) || UUID(),
-      collectionName: 'Doubles',
-      matchUpType: DOUBLES$1,
-      matchUpFormat: 'SET3-S:6/TB7-F:TB10',
-      ...template.doubles
-    }, {
-      collectionId: ((_uuids2 = uuids) === null || _uuids2 === void 0 ? void 0 : _uuids2.pop()) || UUID(),
-      collectionName: 'Singles',
-      matchUpType: SINGLES$1,
-      matchUpFormat: 'SET3-S:6/TB7',
-      ...template.singles
-    }]
-  };
-  if (template.tieFormatName) tieFormat.tieFormatName = template.tieFormatName;
-  return tieFormat;
-};
-
-function addEvent({
-  tournamentRecord,
+function assignMatchUpSideParticipant({
+  drawDefinition,
+  participantId,
+  sideNumber,
+  matchUpId,
   event
 }) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  if (!tournamentRecord.events) tournamentRecord.events = []; // set default startDate, endDate based on tournamentRecord
-
-  const {
-    startDate,
-    endDate
-  } = tournamentRecord;
-  const eventRecord = Object.assign({}, {
-    startDate,
-    endDate,
-    eventType: SINGLES
-  }, event);
-
-  if (event.eventType === TEAM$2 && event.tieFormatName && tieFormats[event.tieFormatName]) {
-    eventRecord.tieFormat = tieFormatDefaults({
-      namedFormat: event.tieFormatName
-    });
-  }
-
-  if (!eventRecord.eventId) eventRecord.eventId = UUID();
-  const eventExists = tournamentRecord.events.reduce((exists, event) => {
-    return exists || event.eventId === eventRecord.eventId;
-  }, undefined);
-
-  if (!eventExists) {
-    tournamentRecord.events.push(eventRecord);
-    return { ...SUCCESS,
-      event: eventRecord
-    };
-  } else {
-    return {
-      error: EVENT_EXISTS
-    };
-  }
-}
-
-const DELETE_EVENTS = 'deleteEvents';
-const DELETE_DRAW_DEFINITIONS = 'deleteDrawDefinitions';
-const auditConstants = {
-  DELETE_EVENTS,
-  DELETE_DRAW_DEFINITIONS
-};
+  var _matchUp$score;
 
-function deleteEvents({
-  tournamentRecord,
-  eventIds
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
+  if (participantId && typeof participantId !== 'string') return {
+    error: INVALID_PARTICIPANT_ID
   };
-  if (!tournamentRecord.events) return {
-    error: EVENT_NOT_FOUND
+  if (!drawDefinition) return {
+    error: MISSING_DRAW_DEFINITION
   };
-  if (!Array.isArray(eventIds)) return {
-    error: MISSING_VALUE
+  if (!sideNumber) return {
+    error: MISSING_SIDE_NUMBER
   };
-  const auditTrail = [];
-  const deletedEventDetails = [];
-  tournamentRecord.events = (tournamentRecord.events || []).filter(event => {
-    if (eventIds.includes(event.eventId)) {
-      const auditData = {
-        action: DELETE_EVENTS,
-        payload: {
-          events: [event]
-        }
-      };
-      auditTrail.push(auditData);
-      deletedEventDetails.push({
-        eventName: event.eventName,
-        eventType: event.eventType,
-        category: event.category,
-        eventId: event.eventId,
-        gender: event.gender
-      });
-    }
-
-    return !eventIds.includes(event.eventId);
-  }); // cleanup references to eventId in schedulingProfile extension
-
-  checkSchedulingProfile({
-    tournamentRecord
+  if (!matchUpId) return {
+    error: MISSING_MATCHUP_ID
+  };
+  if (![1, 2].includes(sideNumber)) return {
+    error: INVALID_VALUES,
+    sideNumber
+  };
+  const {
+    matchUp,
+    structure
+  } = findMatchUp$1({
+    drawDefinition,
+    matchUpId,
+    event
   });
+  const isAdHoc = !(structure !== null && structure !== void 0 && structure.structures) && !(drawDefinition.drawType && drawDefinition.drawType !== AD_HOC) && !(structure !== null && structure !== void 0 && structure.matchUps.find(({
+    roundPosition
+  }) => !!roundPosition));
+  if (!isAdHoc) return {
+    error: INVALID_DRAW_TYPE
+  }; // if no participantId / participant is being un-assigned, there cannot be a score or completed outcome
 
-  if (auditTrail.length) {
-    addNotice({
-      topic: AUDIT,
-      payload: auditTrail
-    });
-    const timeItem = {
-      itemType: DELETE_EVENTS,
-      itemValue: deletedEventDetails
-    };
-    addTournamentTimeItem({
-      tournamentRecord,
-      timeItem
-    });
-  }
+  if (!participantId && ((_matchUp$score = matchUp.score) !== null && _matchUp$score !== void 0 && _matchUp$score.scoreStringSide1 || completedMatchUpStatuses.includes(matchUp.matchUpstatus) || matchUp.matchUpStatus === DOUBLE_WALKOVER)) return {
+    error: CANNOT_REMOVE_PARTICIPANTS,
+    message: 'matchUp has completed status or score'
+  };
+  matchUp.sides = [1, 2].map(currentSideNumber => {
+    var _matchUp$sides;
 
-  return SUCCESS;
+    const existingSide = ((_matchUp$sides = matchUp.sides) === null || _matchUp$sides === void 0 ? void 0 : _matchUp$sides.find(side => side.sideNumber === currentSideNumber)) || {
+      sideNumber: currentSideNumber
+    };
+    return sideNumber === currentSideNumber ? { ...existingSide,
+      participantId
+    } : existingSide;
+  });
+  addMatchUpsNotice({
+    drawDefinition,
+    matchUps: [matchUp]
+  });
+  return { ...SUCCESS
+  };
 }
 
-function promoteAlternate({
-  tournamentRecord,
+function assignDrawPosition({
   drawDefinition,
-  event,
+  drawPosition,
+  structureId,
   participantId,
-  stage = MAIN,
-  stageSequence
+  qualifier,
+  bye
 }) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
+  if (!drawDefinition) return {
+    error: MISSING_DRAW_DEFINITION
   };
-  if (!event) return {
-    error: MISSING_EVENT
+  if (!drawPosition) return {
+    error: MISSING_DRAW_POSITION
+  };
+  if (!structureId) return {
+    error: MISSING_STRUCTURE_ID
   };
 
-  if (event) {
-    const result = promoteWithinElement({
-      element: event,
-      participantId,
-      stageSequence,
-      stage
+  if (bye) {
+    const result = assignDrawPositionBye$1({
+      drawDefinition,
+      drawPosition,
+      structureId
     });
     if (result.error) return result;
-  }
-
-  if (drawDefinition) {
-    const result = promoteWithinElement({
-      element: drawDefinition,
-      participantId,
-      stageSequence,
-      stage
+  } else if (qualifier) {
+    return {
+      error: NOT_IMPLEMENTED
+    };
+  } else {
+    const result = assignDrawPosition$1({
+      drawDefinition,
+      structureId,
+      drawPosition,
+      participantId
     });
     if (result.error) return result;
   }
 
-  return SUCCESS;
-}
-
-function promoteWithinElement({
-  element,
-  participantId,
-  stage,
-  stageSequence
-}) {
-  const alternates = (element.entries || []).filter(entry => entry.entryStatus === ALTERNATE); // if no participantId is provided, take the alternate with the lowest entryPosition
-
-  const participantEntry = (element.entries || []).find(entry => entry.participantId === participantId) || alternates.reduce((participantEntry, entry) => {
-    const {
-      entryPosition
-    } = entry;
-    return isNaN(entryPosition) ? participantEntry : !participantEntry || entryPosition < participantEntry.entryPosition ? entry : participantEntry;
-  }, undefined);
-  if (!participantEntry) return {
-    error: PARTICIPANT_ENTRY_NOT_FOUND
-  };
-  if (participantEntry.entryStatus !== ALTERNATE) return {
-    error: INVALID_ENTRY_STATUS
-  };
-  if (participantEntry.stage && participantEntry.entryStage !== stage) return {
-    error: PARTICIPANT_NOT_ENTERED_IN_STAGE
-  };
-  if (stageSequence && participantEntry.stageSequence !== stageSequence) return {
-    error: PARTICIPANT_NOT_FOUND_IN_STAGE
+  return { ...SUCCESS
   };
-  participantEntry.entryStatus = DIRECT_ACCEPTANCE; // cleanUp
-
-  const entryPosition = participantEntry === null || participantEntry === void 0 ? void 0 : participantEntry.entryPosition;
-
-  if (!isNaN(entryPosition)) {
-    // if promoted participant has an entryPosition, adjust all other alternates with an entryPosition higher than promoted participant
-    element.entries.forEach(entry => {
-      if (entry.entryStatus === ALTERNATE && entry.entryPosition > entryPosition) {
-        entry.entryPosition = entry.entryPosition - 1;
-      }
-    });
-  }
-
-  let maxEntryPosition = Math.max(...element.entries.filter(entry => entry.entryStatus === DIRECT_ACCEPTANCE && !isNaN(entry.entryPosition)).map(({
-    entryPosition
-  }) => parseInt(entryPosition || 0)), 0);
-  participantEntry.entryPosition = maxEntryPosition || 0;
-  return SUCCESS;
 }
 
 /**
@@ -42208,47 +42098,88 @@ function checkValidEntries({
   return SUCCESS;
 }
 
-function assignDrawPosition({
+function promoteAlternate({
+  tournamentRecord,
   drawDefinition,
-  drawPosition,
-  structureId,
+  event,
   participantId,
-  qualifier,
-  bye
+  stage = MAIN,
+  stageSequence
 }) {
-  if (!drawDefinition) return {
-    error: MISSING_DRAW_DEFINITION
-  };
-  if (!drawPosition) return {
-    error: MISSING_DRAW_POSITION
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
   };
-  if (!structureId) return {
-    error: MISSING_STRUCTURE_ID
+  if (!event) return {
+    error: MISSING_EVENT
   };
 
-  if (bye) {
-    const result = assignDrawPositionBye$1({
-      drawDefinition,
-      drawPosition,
-      structureId
+  if (event) {
+    const result = promoteWithinElement({
+      element: event,
+      participantId,
+      stageSequence,
+      stage
     });
     if (result.error) return result;
-  } else if (qualifier) {
-    return {
-      error: NOT_IMPLEMENTED
-    };
-  } else {
-    const result = assignDrawPosition$1({
-      drawDefinition,
-      structureId,
-      drawPosition,
-      participantId
+  }
+
+  if (drawDefinition) {
+    const result = promoteWithinElement({
+      element: drawDefinition,
+      participantId,
+      stageSequence,
+      stage
     });
     if (result.error) return result;
   }
 
-  return { ...SUCCESS
+  return SUCCESS;
+}
+
+function promoteWithinElement({
+  element,
+  participantId,
+  stage,
+  stageSequence
+}) {
+  const alternates = (element.entries || []).filter(entry => entry.entryStatus === ALTERNATE); // if no participantId is provided, take the alternate with the lowest entryPosition
+
+  const participantEntry = (element.entries || []).find(entry => entry.participantId === participantId) || alternates.reduce((participantEntry, entry) => {
+    const {
+      entryPosition
+    } = entry;
+    return isNaN(entryPosition) ? participantEntry : !participantEntry || entryPosition < participantEntry.entryPosition ? entry : participantEntry;
+  }, undefined);
+  if (!participantEntry) return {
+    error: PARTICIPANT_ENTRY_NOT_FOUND
   };
+  if (participantEntry.entryStatus !== ALTERNATE) return {
+    error: INVALID_ENTRY_STATUS
+  };
+  if (participantEntry.stage && participantEntry.entryStage !== stage) return {
+    error: PARTICIPANT_NOT_ENTERED_IN_STAGE
+  };
+  if (stageSequence && participantEntry.stageSequence !== stageSequence) return {
+    error: PARTICIPANT_NOT_FOUND_IN_STAGE
+  };
+  participantEntry.entryStatus = DIRECT_ACCEPTANCE; // cleanUp
+
+  const entryPosition = participantEntry === null || participantEntry === void 0 ? void 0 : participantEntry.entryPosition;
+
+  if (!isNaN(entryPosition)) {
+    // if promoted participant has an entryPosition, adjust all other alternates with an entryPosition higher than promoted participant
+    element.entries.forEach(entry => {
+      if (entry.entryStatus === ALTERNATE && entry.entryPosition > entryPosition) {
+        entry.entryPosition = entry.entryPosition - 1;
+      }
+    });
+  }
+
+  let maxEntryPosition = Math.max(...element.entries.filter(entry => entry.entryStatus === DIRECT_ACCEPTANCE && !isNaN(entry.entryPosition)).map(({
+    entryPosition
+  }) => parseInt(entryPosition || 0)), 0);
+  participantEntry.entryPosition = maxEntryPosition || 0;
+  return SUCCESS;
 }
 
 /*
@@ -42335,6 +42266,227 @@ function assignSeedPositions(params) {
   };
 }
 
+const DELETE_EVENTS = 'deleteEvents';
+const DELETE_DRAW_DEFINITIONS = 'deleteDrawDefinitions';
+const auditConstants = {
+  DELETE_EVENTS,
+  DELETE_DRAW_DEFINITIONS
+};
+
+function deleteEvents({
+  tournamentRecord,
+  eventIds
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!tournamentRecord.events) return {
+    error: EVENT_NOT_FOUND
+  };
+  if (!Array.isArray(eventIds)) return {
+    error: MISSING_VALUE
+  };
+  const auditTrail = [];
+  const deletedEventDetails = [];
+  tournamentRecord.events = (tournamentRecord.events || []).filter(event => {
+    if (eventIds.includes(event.eventId)) {
+      const auditData = {
+        action: DELETE_EVENTS,
+        payload: {
+          events: [event]
+        }
+      };
+      auditTrail.push(auditData);
+      deletedEventDetails.push({
+        eventName: event.eventName,
+        eventType: event.eventType,
+        category: event.category,
+        eventId: event.eventId,
+        gender: event.gender
+      });
+    }
+
+    return !eventIds.includes(event.eventId);
+  }); // cleanup references to eventId in schedulingProfile extension
+
+  checkSchedulingProfile({
+    tournamentRecord
+  });
+
+  if (auditTrail.length) {
+    addNotice({
+      topic: AUDIT,
+      payload: auditTrail
+    });
+    const timeItem = {
+      itemType: DELETE_EVENTS,
+      itemValue: deletedEventDetails
+    };
+    addTournamentTimeItem({
+      tournamentRecord,
+      timeItem
+    });
+  }
+
+  return SUCCESS;
+}
+
+const COLLEGE_DEFAULT = 'COLLEGE_DEFAULT';
+const COLLEGE_JUCO = 'COLLEGE_JUCO';
+const COLLEGE_D3 = 'COLLEGE_D3';
+const DOMINANT_DUO = 'DOMINANT_DUO';
+const LAVER_CUP = 'LAVER_CUP';
+const TEAM_DOUBLES_3_AGGREGATION = 'TEAM_DOUBLES_3_AGGREGATION';
+const tieFormatConstants = {
+  COLLEGE_D3,
+  COLLEGE_DEFAULT,
+  COLLEGE_JUCO,
+  DOMINANT_DUO,
+  LAVER_CUP,
+  TEAM_DOUBLES_3_AGGREGATION
+};
+
+const namedFormats = {
+  STANDARD: {
+    hydrate: true,
+    doubles: {
+      matchUpCount: 3,
+      matchUpValue: 1
+    },
+    singles: {
+      matchUpCount: 6,
+      matchUpValue: 1
+    },
+    valueGoal: 5
+  },
+  [COLLEGE_D3]: {
+    hydrate: true,
+    doubles: {
+      matchUpCount: 3,
+      matchUpValue: 1,
+      matchUpFormat: 'SET1-S:8/TB7@7'
+    },
+    singles: {
+      matchUpCount: 6,
+      matchUpValue: 1,
+      matchUpFormat: 'SET3-S:6/TB7'
+    },
+    tieFormatName: 'COLLEGE_D3',
+    valueGoal: 5
+  },
+  [COLLEGE_DEFAULT]: {
+    hydrate: true,
+    doubles: {
+      matchUpCount: 3,
+      collectionValue: 1,
+      matchUpFormat: 'SET1-S:6/TB7'
+    },
+    singles: {
+      matchUpCount: 6,
+      matchUpValue: 1,
+      matchUpFormat: 'SET3-S:6/TB7'
+    },
+    tieFormatName: 'COLLEGE_DEFAULT',
+    valueGoal: 4
+  },
+  [COLLEGE_JUCO]: {
+    hydrate: true,
+    doubles: {
+      matchUpCount: 3,
+      matchUpValue: 1,
+      matchUpFormat: 'SET1-S:8/TB7'
+    },
+    singles: {
+      matchUpCount: 6,
+      matchUpValue: 1,
+      matchUpFormat: 'SET3-S:6/TB7'
+    },
+    tieFormatName: 'COLLEGE_JUCO',
+    valueGoal: 5
+  },
+  [LAVER_CUP]: LAVER_CUP_TIE_FORMAT,
+  [DOMINANT_DUO]: DOMINANT_DUO_TIE_FORMAT,
+  [TEAM_DOUBLES_3_AGGREGATION]: TEAM_AGGREGATION_TIE_FORMAT
+};
+const tieFormatDefaults = ({
+  namedFormat,
+  uuids = []
+} = {}) => {
+  var _uuids, _uuids2;
+
+  if (!Object.keys(namedFormats).includes(namedFormat)) namedFormat = 'STANDARD';
+  if (!Array.isArray(uuids)) uuids = [];
+  const template = namedFormats[namedFormat];
+
+  if (!template.hydrate) {
+    template.collectionDefinitions.forEach(collectionDefinition => collectionDefinition.collectionId = UUID());
+    return template;
+  }
+
+  const tieFormat = {
+    winCriteria: {
+      valueGoal: template.valueGoal
+    },
+    collectionDefinitions: [{
+      collectionId: ((_uuids = uuids) === null || _uuids === void 0 ? void 0 : _uuids.pop()) || UUID(),
+      collectionName: 'Doubles',
+      matchUpType: DOUBLES$1,
+      matchUpFormat: 'SET3-S:6/TB7-F:TB10',
+      ...template.doubles
+    }, {
+      collectionId: ((_uuids2 = uuids) === null || _uuids2 === void 0 ? void 0 : _uuids2.pop()) || UUID(),
+      collectionName: 'Singles',
+      matchUpType: SINGLES$1,
+      matchUpFormat: 'SET3-S:6/TB7',
+      ...template.singles
+    }]
+  };
+  if (template.tieFormatName) tieFormat.tieFormatName = template.tieFormatName;
+  return tieFormat;
+};
+
+function addEvent({
+  tournamentRecord,
+  event
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!tournamentRecord.events) tournamentRecord.events = []; // set default startDate, endDate based on tournamentRecord
+
+  const {
+    startDate,
+    endDate
+  } = tournamentRecord;
+  const eventRecord = Object.assign({}, {
+    startDate,
+    endDate,
+    eventType: SINGLES
+  }, event);
+
+  if (event.eventType === TEAM$2 && event.tieFormatName && tieFormats[event.tieFormatName]) {
+    eventRecord.tieFormat = tieFormatDefaults({
+      namedFormat: event.tieFormatName
+    });
+  }
+
+  if (!eventRecord.eventId) eventRecord.eventId = UUID();
+  const eventExists = tournamentRecord.events.reduce((exists, event) => {
+    return exists || event.eventId === eventRecord.eventId;
+  }, undefined);
+
+  if (!eventExists) {
+    tournamentRecord.events.push(eventRecord);
+    return { ...SUCCESS,
+      event: eventRecord
+    };
+  } else {
+    return {
+      error: EVENT_EXISTS
+    };
+  }
+}
+
 /**
  *
  * @param {string} drawId - tournamentEngine will resovle event and drawDefinition
@@ -45132,10 +45284,6 @@ function setOrderOfFinish(params) {
   return setOrderOfFinish$1(params);
 }
 
-function addAdHocMatchUps(params) {
-  return addAdHocMatchUps$1(params);
-}
-
 // if those entries are assigned positions in any structures...
 
 function modifyEventEntries({
@@ -45489,7 +45637,6 @@ const eventGovernor = {
   getFlightProfile,
   getScaledEntries,
   addFlight,
-  addAdHocMatchUps,
   generateAdHocMatchUps,
   deleteAdHocMatchUps,
   drawMatic,
@@ -45507,6 +45654,7 @@ const eventGovernor = {
   assignDrawPosition,
   assignSeedPositions,
   assignDrawPositionBye,
+  assignMatchUpSideParticipant,
   swapDrawPositionAssignments,
   removeDrawPositionAssignment,
   alternateDrawPositionAssignment,
@@ -50056,6 +50204,21 @@ function generateFlightDrawDefinitions({
         if (result.error === DRAW_ID_EXISTS) break;
         if (result.error) return result;
 
+        if (drawProfile.drawType === AD_HOC && drawProfile.drawMatic) {
+          const roundsCount = drawProfile.roundsCount || 1;
+
+          for (const roundNumber of generateRange(1, roundsCount + 1)) {
+            const result = drawMatic({
+              generateMatchUps: true,
+              tournamentRecord,
+              drawDefinition,
+              roundNumber // this is not a real parameter
+
+            });
+            if (result.error) return result;
+          }
+        }
+
         if (drawProfile !== null && drawProfile !== void 0 && drawProfile.withPlayoffs) {
           const structureId = drawDefinition.structures[0].structureId;
           const result = addPlayoffStructures({
@@ -51255,6 +51418,21 @@ function generateEventWithDraw({
       event
     });
 
+    if (drawType === AD_HOC && drawProfile.drawMatic) {
+      const roundsCount = drawProfile.roundsCount || 1;
+
+      for (const roundNumber of generateRange(1, roundsCount + 1)) {
+        const result = drawMatic({
+          generateMatchUps: true,
+          tournamentRecord,
+          drawDefinition,
+          roundNumber // this is not a real parameter
+
+        });
+        if (result.error) return result;
+      }
+    }
+
     if (drawProfile.withPlayoffs) {
       const structureId = drawDefinition.structures[0].structureId;
       const result = addPlayoffStructures({ ...drawProfile.withPlayoffs,