tods-competition-factory 1.6.22 → 1.6.23

package/dist/forge/generate.mjs

@@ -8053,25 +8053,25 @@ function targetByRoundOutcome({
     matchUp,
     targetLinks: { loserTargetLink, winnerTargetLink, byeTargetLink },
     targetMatchUps: {
-      byeMatchUp,
-      loserMatchUp,
-      winnerMatchUp,
-      byeTargetDrawPosition,
-      loserTargetDrawPosition,
-      winnerTargetDrawPosition,
-      byeMatchUpDrawPositionIndex,
+      winnerMatchUpDrawPositionIndex,
       loserMatchUpDrawPositionIndex,
-      winnerMatchUpDrawPositionIndex
+      byeMatchUpDrawPositionIndex,
+      winnerTargetDrawPosition,
+      loserTargetDrawPosition,
+      byeTargetDrawPosition,
+      winnerMatchUp,
+      loserMatchUp,
+      byeMatchUp
     },
     targetMatchUpIds: !!(winnerMatchUpId || loserMatchUpId)
   });
 }
 function targetByWinRatio({ matchUp }) {
   return {
-    matchUp,
     targetLinks: { loserTargetLink: void 0, winnerTargetLink: void 0 },
     // returned for testing
-    targetMatchUps: { loserMatchUp: void 0, winnerMatchUp: void 0 }
+    targetMatchUps: { loserMatchUp: void 0, winnerMatchUp: void 0 },
+    matchUp
   };
 }
 
@@ -17488,6 +17488,36 @@ function generateAndPopulatePlayoffStructures(params) {
     if (result.error)
       console.log(result.error);
   });
+  const byeMatchUps = inContextDrawMatchUps?.filter(
+    (matchUp) => matchUp.matchUpStatus === BYE && matchUp.structureId === sourceStructureId
+  );
+  byeMatchUps?.forEach((matchUp) => {
+    const { matchUpId } = matchUp;
+    const targetData = positionTargets({
+      inContextDrawMatchUps,
+      drawDefinition,
+      matchUpId
+    });
+    const {
+      targetLinks: { loserTargetLink },
+      targetMatchUps: {
+        loserMatchUpDrawPositionIndex,
+        // only present when positionTargets found without loserMatchUpId
+        loserMatchUp
+      }
+    } = targetData;
+    const targetStructureId = loserTargetLink.target.structureId;
+    const targetDrawPosition = loserMatchUp.drawPositions[loserMatchUpDrawPositionIndex];
+    const result = assignDrawPositionBye({
+      drawPosition: targetDrawPosition,
+      structureId: targetStructureId,
+      tournamentRecord,
+      drawDefinition,
+      event
+    });
+    if (result.error)
+      console.log(result.error);
+  });
   const matchUpModifications = [];
   const goesToMap = addGoesTo({
     inContextDrawMatchUps,
@@ -19545,188 +19575,600 @@ function generateVoluntaryConsolation(params) {
   return generateVoluntaryConsolation$1({ participants: tournamentParticipants, ...params });
 }
 
-function generateQualifyingLink({
-  targetEntryRound = 1,
-  finishingPositions,
-  sourceRoundNumber,
-  sourceStructureId,
-  targetStructureId,
-  linkType = LinkTypeEnum.Winner
+function generateCandidate({
+  maxIterations = 5e3,
+  // cap the processing intensity of the candidate generator
+  valueSortedPairings,
+  // pairings sorted by value from low to high
+  pairingValues,
+  deltaObjects
 }) {
-  if (!sourceStructureId || !targetStructureId)
-    return { error: MISSING_STRUCTURE_ID };
-  const link = definedAttributes({
-    linkType,
-    source: {
-      roundNumber: sourceRoundNumber,
-      structureId: sourceStructureId,
-      finishingPositions
-    },
-    target: {
-      feedProfile: DRAW,
-      // positions are not automatically placed
-      roundNumber: targetEntryRound,
-      structureId: targetStructureId
-    }
+  const rankedMatchUpValues = Object.assign(
+    {},
+    ...valueSortedPairings.map((rm) => ({ [rm.pairing]: rm.value }))
+  );
+  let candidate = roundCandidate({
+    rankedMatchUpValues,
+    valueSortedPairings,
+    deltaObjects
   });
-  return { link };
-}
-
-function generateQualifyingStructures({
-  qualifyingProfiles,
-  appliedPolicies,
-  idPrefix,
-  isMock,
-  uuids
-}) {
-  const stack = "generateQualifyingSTructures";
-  const qualifyingDetails = [];
-  const structures = [];
-  const links = [];
-  const sequenceSort = (a, b) => a.stageSequence - b.stageSequence;
-  const roundTargetSort = (a, b) => a.roundTarget - b.roundTarget;
-  let qualifyingDrawPositionsCount = 0, totalQualifiersCount = 0, finishingPositions, roundTarget = 1;
-  for (const roundTargetProfile of qualifyingProfiles.sort(roundTargetSort)) {
-    const structureProfiles = roundTargetProfile.structureProfiles || [];
-    roundTarget = roundTargetProfile.roundTarget || roundTarget;
-    let stageSequence = 1, targetRoundQualifiersCount = 0, finalQualifyingRoundNumber, finalQualifyingStructureId, linkType;
-    for (const structureProfile of (structureProfiles || []).sort(
-      sequenceSort
-    )) {
-      let drawSize = structureProfile.drawSize || coerceEven(structureProfile.participantsCount);
-      const {
-        qualifyingRoundNumber,
-        qualifyingPositions,
-        structureOptions,
-        matchUpFormat,
-        structureName,
-        structureId,
-        drawType
-      } = structureProfile;
-      const matchUpType = structureProfile.matchUpType;
-      let roundLimit, structure, matchUps;
-      if (!isConvertableInteger(drawSize)) {
-        return decorateResult({
-          result: { error: MISSING_DRAW_SIZE },
-          stack
-        });
-      }
-      const roundTargetName = qualifyingProfiles.length > 1 ? `${roundTarget}-` : "";
-      const stageSequenceName = structureProfiles.length > 1 || roundTargetName ? stageSequence : "";
-      const qualifyingStructureName = structureName || (roundTargetName || stageSequenceName ? `${QUALIFYING} ${roundTargetName}${stageSequenceName}` : QUALIFYING);
-      if (drawType === ROUND_ROBIN) {
-        const {
-          structures: structures2,
-          groupCount,
-          maxRoundNumber
-          /*, groupSize*/
-        } = generateRoundRobin({
-          structureName: structureProfile.structureName || qualifyingStructureName,
-          structureId: structureId || uuids?.pop(),
-          // qualifyingPositions,
-          stage: QUALIFYING,
-          structureOptions,
-          appliedPolicies,
-          stageSequence,
-          matchUpType,
-          roundTarget,
-          drawSize,
-          idPrefix,
-          isMock,
-          uuids
-        });
-        targetRoundQualifiersCount = groupCount;
-        roundLimit = maxRoundNumber;
-        structure = structures2[0];
-        finishingPositions = [1];
-      } else {
-        ({ drawSize, matchUps, roundLimit } = treeMatchUps({
-          qualifyingRoundNumber,
-          qualifyingPositions,
-          matchUpType,
-          drawSize,
-          idPrefix,
-          isMock,
-          uuids
-        }));
-        structure = structureTemplate({
-          structureName: structureProfile.structureName || qualifyingStructureName,
-          structureId: structureId || uuids?.pop(),
-          qualifyingRoundNumber: roundLimit,
-          stage: QUALIFYING,
-          matchUpFormat,
-          stageSequence,
-          matchUpType,
-          roundLimit,
-          // redundant
-          matchUps
-        });
-        if (roundTarget) {
-          addExtension({
-            element: structure,
-            extension: { name: ROUND_TARGET, value: roundTarget }
-          });
-        }
-        targetRoundQualifiersCount = matchUps?.filter((matchUp) => matchUp.roundNumber === roundLimit)?.length || 0;
-      }
-      if (stageSequence > 1) {
-        const { link } = generateQualifyingLink({
-          sourceStructureId: finalQualifyingStructureId,
-          sourceRoundNumber: finalQualifyingRoundNumber,
-          targetStructureId: structure.structureId,
-          finishingPositions: linkType === POSITION ? [1] : void 0,
-          linkType
+  let deltaCandidate = candidate;
+  const actors = Object.keys(pairingValues);
+  let candidatesCount = 0;
+  let iterations;
+  let opponentCount = actors.length;
+  do {
+    opponentCount -= 1;
+    iterations = actors.length * opponentCount * valueSortedPairings.length / 2;
+  } while (iterations > maxIterations && opponentCount > 2);
+  const stipulatedPairs = [];
+  actors.forEach((actor) => {
+    const participantIdPairings = pairingValues[actor];
+    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
         });
-        links.push(link);
-        qualifyingDrawPositionsCount += (drawSize || 0) - targetRoundQualifiersCount;
-      } else {
-        qualifyingDrawPositionsCount += drawSize || 0;
+        if (proposed.maxDelta < deltaCandidate.maxDelta)
+          deltaCandidate = proposed;
+        if (proposed.value < candidate.value)
+          candidate = proposed;
+        stipulatedPairs.push(stipulatedPair);
+        candidatesCount += 1;
       }
-      linkType = drawType === ROUND_ROBIN ? POSITION : WINNER;
-      finalQualifyingStructureId = structure.structureId;
-      finalQualifyingRoundNumber = roundLimit;
-      structures.push(structure);
-      stageSequence += 1;
-    }
-    totalQualifiersCount += targetRoundQualifiersCount;
-    qualifyingDetails.push({
-      qualifiersCount: targetRoundQualifiersCount,
-      finalQualifyingRoundNumber,
-      finalQualifyingStructureId,
-      finishingPositions,
-      roundTarget,
-      linkType
     });
-    targetRoundQualifiersCount = 0;
-    roundTarget += 1;
-  }
-  return {
-    qualifiersCount: totalQualifiersCount,
-    qualifyingDrawPositionsCount,
-    qualifyingDetails,
-    structures,
-    ...SUCCESS,
-    links
-  };
+  });
+  return { candidate, deltaCandidate, candidatesCount, iterations };
 }
-
-function generateDrawStructuresAndLinks(params) {
-  const {
-    enforceMinimumDrawSize = true,
-    overwriteExisting,
-    drawTypeCoercion,
-    // coerce to SINGLE_ELIMINATION for drawSize: 2
-    appliedPolicies,
-    staggeredEntry,
-    // optional - specifies main structure FEED_IN for drawTypes CURTIS_CONSOLATION, FEED_IN_CHAMPIONSHIPS, FMLC
-    drawDefinition,
-    tieFormat,
-    drawSize,
-    isMock,
-    uuids
-  } = params || {};
-  const stack = "generateDrawStructuresAndLinks";
-  let drawType = params.drawType ?? SINGLE_ELIMINATION;
+function roundCandidate({
+  rankedMatchUpValues,
+  valueSortedPairings,
+  stipulated = [],
+  deltaObjects
+}) {
+  const roundPlayers = [].concat(...stipulated);
+  const participantIdPairings = [];
+  let candidateValue = 0;
+  stipulated.filter(Boolean).forEach((participantIds) => {
+    const [p1, p2] = participantIds;
+    const pairing = pairingHash(p1, p2);
+    const value = rankedMatchUpValues[pairing];
+    participantIdPairings.push({ participantIds, value });
+    candidateValue += rankedMatchUpValues[pairing];
+  });
+  valueSortedPairings.forEach((rankedPairing) => {
+    const participantIds = rankedPairing.pairing.split("|");
+    const opponentExists = participantIds.reduce(
+      (p, c) => roundPlayers.includes(c) || p,
+      false
+    );
+    if (!opponentExists) {
+      roundPlayers.push(...participantIds);
+      const value = rankedPairing.value;
+      candidateValue += value;
+      participantIdPairings.push({ participantIds, value });
+    }
+  });
+  participantIdPairings.sort((a, b) => a.value - b.value);
+  const maxDelta = participantIdPairings.reduce((p, c) => {
+    const [p1, p2] = c.participantIds;
+    const hash = pairingHash(p1, p2);
+    const delta = deltaObjects[hash];
+    return delta > p ? delta : p;
+  }, 0);
+  return { value: candidateValue, participantIdPairings, maxDelta };
+}
+function pairingHash(id1, id2) {
+  return [id1, id2].sort().join("|");
+}
+
+function generateAdHocMatchUps({
+  participantIdPairings,
+  addToStructure = true,
+  tournamentRecord,
+  matchUpIds = [],
+  drawDefinition,
+  matchUpsCount,
+  roundNumber,
+  structureId,
+  newRound
+}) {
+  if (typeof drawDefinition !== "object")
+    return { error: MISSING_DRAW_DEFINITION };
+  if (!structureId && drawDefinition.structures?.length === 1)
+    structureId = drawDefinition.structures?.[0]?.structureId;
+  if (typeof structureId !== "string")
+    return { error: MISSING_STRUCTURE_ID };
+  if (participantIdPairings && !Array.isArray(participantIdPairings) || matchUpsCount && !isConvertableInteger(matchUpsCount) || matchUpIds && !Array.isArray(matchUpIds) || !participantIdPairings && !matchUpsCount) {
+    return { error: INVALID_VALUES, info: "matchUpsCount or pairings error" };
+  }
+  const structure = drawDefinition?.structures?.find(
+    (structure2) => structure2.structureId === structureId
+  );
+  let structureHasRoundPositions;
+  const existingMatchUps = structure?.matchUps;
+  const lastRoundNumber = existingMatchUps?.reduce(
+    (roundNumber2, matchUp) => {
+      if (matchUp.roundPosition)
+        structureHasRoundPositions = true;
+      return (matchUp?.roundNumber || 0) > roundNumber2 ? matchUp.roundNumber : roundNumber2;
+    },
+    0
+  );
+  if (structure?.structures || structureHasRoundPositions || structure?.finishingPosition === ROUND_OUTCOME) {
+    return { error: INVALID_STRUCTURE };
+  }
+  if (roundNumber && roundNumber - 1 > (lastRoundNumber || 0))
+    return { error: INVALID_VALUES, info: "roundNumber error" };
+  const nextRoundNumber = roundNumber ?? (newRound ? (lastRoundNumber ?? 0) + 1 : lastRoundNumber ?? 1);
+  participantIdPairings = participantIdPairings ?? generateRange(0, matchUpsCount).map(() => ({
+    participantIds: [void 0, void 0]
+  }));
+  const matchUps = participantIdPairings?.map((pairing) => {
+    const idStack = pairing?.participantIds ?? [void 0, void 0];
+    idStack.push(...[void 0, void 0]);
+    const participantIds = idStack.slice(0, 2);
+    const sides = participantIds.map(
+      (participantId, i) => definedAttributes({
+        sideNumber: i + 1,
+        participantId
+      })
+    );
+    return {
+      matchUpStatus: MatchUpStatusEnum.ToBePlayed,
+      matchUpId: matchUpIds.pop() ?? UUID(),
+      roundNumber: nextRoundNumber,
+      sides
+    };
+  });
+  if (addToStructure) {
+    const result = addAdHocMatchUps({
+      tournamentRecord,
+      drawDefinition,
+      structureId,
+      matchUps
+    });
+    if (result.error)
+      return result;
+  }
+  return { matchUpsCount: matchUps.length, matchUps, ...SUCCESS };
+}
+function addAdHocMatchUps({
+  tournamentRecord,
+  drawDefinition,
+  structureId,
+  matchUps
+}) {
+  if (typeof drawDefinition !== "object")
+    return { error: MISSING_DRAW_DEFINITION };
+  if (!structureId && drawDefinition.structures?.length === 1)
+    structureId = drawDefinition.structures?.[0]?.structureId;
+  if (typeof structureId !== "string")
+    return { error: MISSING_STRUCTURE_ID };
+  if (!validMatchUps(matchUps))
+    return { error: INVALID_VALUES, info: mustBeAnArray("matchUps") };
+  const structure = drawDefinition.structures?.find(
+    (structure2) => structure2.structureId === structureId
+  );
+  if (!structure)
+    return { error: STRUCTURE_NOT_FOUND };
+  const existingMatchUps = structure?.matchUps;
+  const structureHasRoundPositions = existingMatchUps.find(
+    (matchUp) => !!matchUp.roundPosition
+  );
+  if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
+    return { error: INVALID_STRUCTURE };
+  }
+  const existingMatchUpIds = allTournamentMatchUps({
+    tournamentRecord,
+    inContext: false
+  })?.matchUps?.map(getMatchUpId) ?? [];
+  const newMatchUpIds = matchUps.map(getMatchUpId);
+  if (overlap(existingMatchUpIds, newMatchUpIds)) {
+    return {
+      error: EXISTING_MATCHUP_ID,
+      info: "One or more matchUpIds already present in tournamentRecord"
+    };
+  }
+  structure.matchUps.push(...matchUps);
+  addMatchUpsNotice({
+    tournamentId: tournamentRecord?.tournamentId,
+    drawDefinition,
+    matchUps
+  });
+  modifyDrawNotice({ drawDefinition, structureIds: [structureId] });
+  return { ...SUCCESS };
+}
+
+const ENCOUNTER_VALUE = 50;
+const SAME_TEAM_VALUE = 60;
+const DEFAULT_RATING = 0;
+const MAX_ITERATIONS = 5e3;
+function generateDrawMaticRound({
+  maxIterations = MAX_ITERATIONS,
+  generateMatchUps = true,
+  tournamentParticipants,
+  tournamentRecord,
+  participantIds,
+  addToStructure,
+  drawDefinition,
+  adHocRatings,
+  structureId,
+  matchUpIds,
+  eventType,
+  structure
+}) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  if (!structure && !structureId)
+    return { error: STRUCTURE_NOT_FOUND };
+  if (!structure) {
+    structure = findStructure({ drawDefinition, structureId }).structure;
+  }
+  if (!isObject(structure))
+    return { error: MISSING_STRUCTURE };
+  if (!participantIds?.length) {
+    return { error: MISSING_PARTICIPANT_IDS };
+  }
+  const { encounters } = getEncounters({ matchUps: structure?.matchUps ?? [] });
+  const valueObjects = {};
+  for (const pairing of encounters) {
+    if (!valueObjects[pairing])
+      valueObjects[pairing] = 0;
+    valueObjects[pairing] += ENCOUNTER_VALUE;
+  }
+  const teamParticipants = tournamentParticipants?.filter(
+    ({ participantType }) => participantType === TEAM
+  );
+  if (teamParticipants) {
+    for (const teamParticipant of teamParticipants) {
+      const participantIds2 = teamParticipant.individualParticipantIds || [];
+      const { uniquePairings: uniquePairings2 } = getPairingsData({ participantIds: participantIds2 });
+      for (const pairing of uniquePairings2) {
+        if (!valueObjects[pairing])
+          valueObjects[pairing] = 0;
+        valueObjects[pairing] += SAME_TEAM_VALUE;
+      }
+    }
+  }
+  const { uniquePairings, possiblePairings, deltaObjects } = getPairingsData({
+    participantIds
+  });
+  const params = {
+    tournamentParticipants,
+    possiblePairings,
+    drawDefinition,
+    participantIds,
+    uniquePairings,
+    maxIterations,
+    adHocRatings,
+    deltaObjects,
+    valueObjects,
+    eventType,
+    structure
+  };
+  const { candidatesCount, participantIdPairings, iterations } = getPairings(params);
+  if (!candidatesCount)
+    return { error: NO_CANDIDATES };
+  let matchUps;
+  if (generateMatchUps) {
+    const result = generateAdHocMatchUps({
+      structureId: structure?.structureId,
+      participantIdPairings,
+      tournamentRecord,
+      addToStructure,
+      newRound: true,
+      drawDefinition,
+      matchUpIds
+    });
+    if (result.error)
+      return result;
+    matchUps = result.matchUps;
+  }
+  return {
+    ...SUCCESS,
+    participantIdPairings,
+    candidatesCount,
+    iterations,
+    matchUps
+  };
+}
+function getSideRatings({
+  tournamentParticipants,
+  adHocRatings,
+  eventType,
+  pairing
+}) {
+  return pairing.split("|").map((participantId) => {
+    if (eventType === DOUBLES) {
+      const individualParticipantIds = tournamentParticipants?.find(
+        (participant) => participant.participantId === participantId
+      )?.individualParticipantIds;
+      return !individualParticipantIds ? DEFAULT_RATING * 2 : individualParticipantIds?.map(
+        (participantId2) => adHocRatings[participantId2 || DEFAULT_RATING]
+      );
+    } else {
+      return adHocRatings[participantId] || DEFAULT_RATING;
+    }
+  });
+}
+function getPairings({
+  tournamentParticipants,
+  adHocRatings = {},
+  possiblePairings,
+  // participant keyed; provides array of possible opponents
+  uniquePairings,
+  // 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
+}) {
+  uniquePairings.forEach((pairing) => {
+    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(ratingsDifference, 2);
+  });
+  const valueSortedPairings = uniquePairings.map((pairing) => ({ pairing, value: valueObjects[pairing] })).sort((a, b) => a.value - b.value);
+  const { pairingValues } = getParticipantPairingValues({
+    possiblePairings,
+    valueObjects
+  });
+  const { candidate, candidatesCount, iterations } = generateCandidate({
+    valueSortedPairings,
+    maxIterations,
+    pairingValues,
+    deltaObjects
+  });
+  const { participantIdPairings } = candidate;
+  return { candidatesCount, participantIdPairings, iterations };
+}
+function getPairingsData({ participantIds }) {
+  const possiblePairings = {};
+  const uniquePairings = [];
+  participantIds.forEach((participantId) => {
+    possiblePairings[participantId] = participantIds.filter(
+      (id) => id !== participantId
+    );
+    possiblePairings[participantId].forEach((id) => {
+      const pairing = pairingHash(id, participantId);
+      if (!uniquePairings.includes(pairing))
+        uniquePairings.push(pairing);
+    });
+  });
+  const deltaObjects = Object.assign(
+    {},
+    ...uniquePairings.map((pairing) => ({ [pairing]: 0 }))
+  );
+  return { uniquePairings, possiblePairings, deltaObjects };
+}
+function getEncounters({ matchUps }) {
+  const encounters = [];
+  for (const matchUp of matchUps) {
+    const participantIds = matchUp.sides.map(getParticipantId);
+    if (participantIds.length === 2) {
+      const [p1, p2] = participantIds;
+      const pairing = pairingHash(p1, p2);
+      if (!encounters.includes(pairing))
+        encounters.push(pairing);
+    }
+  }
+  return { encounters };
+}
+function getParticipantPairingValues({ possiblePairings, valueObjects }) {
+  const pairingValues = {};
+  for (const participantId of Object.keys(possiblePairings)) {
+    const participantValues = possiblePairings[participantId].map(
+      (opponent) => pairingValue(participantId, opponent)
+    );
+    pairingValues[participantId] = participantValues.sort(
+      (a, b) => a.value - b.value
+    );
+  }
+  function pairingValue(participantId, opponent) {
+    const key = pairingHash(participantId, opponent);
+    return { opponent, value: valueObjects[key] };
+  }
+  return { pairingValues };
+}
+
+function generateQualifyingLink({
+  targetEntryRound = 1,
+  finishingPositions,
+  sourceRoundNumber,
+  sourceStructureId,
+  targetStructureId,
+  linkType = LinkTypeEnum.Winner
+}) {
+  if (!sourceStructureId || !targetStructureId)
+    return { error: MISSING_STRUCTURE_ID };
+  const link = definedAttributes({
+    linkType,
+    source: {
+      roundNumber: sourceRoundNumber,
+      structureId: sourceStructureId,
+      finishingPositions
+    },
+    target: {
+      feedProfile: DRAW,
+      // positions are not automatically placed
+      roundNumber: targetEntryRound,
+      structureId: targetStructureId
+    }
+  });
+  return { link };
+}
+
+function generateQualifyingStructures({
+  qualifyingProfiles,
+  appliedPolicies,
+  idPrefix,
+  isMock,
+  uuids
+}) {
+  const stack = "generateQualifyingSTructures";
+  const qualifyingDetails = [];
+  const structures = [];
+  const links = [];
+  const sequenceSort = (a, b) => a.stageSequence - b.stageSequence;
+  const roundTargetSort = (a, b) => a.roundTarget - b.roundTarget;
+  let qualifyingDrawPositionsCount = 0, totalQualifiersCount = 0, finishingPositions, roundTarget = 1;
+  for (const roundTargetProfile of qualifyingProfiles.sort(roundTargetSort)) {
+    const structureProfiles = roundTargetProfile.structureProfiles || [];
+    roundTarget = roundTargetProfile.roundTarget || roundTarget;
+    let stageSequence = 1, targetRoundQualifiersCount = 0, finalQualifyingRoundNumber, finalQualifyingStructureId, linkType;
+    for (const structureProfile of (structureProfiles || []).sort(
+      sequenceSort
+    )) {
+      let drawSize = structureProfile.drawSize || coerceEven(structureProfile.participantsCount);
+      const {
+        qualifyingRoundNumber,
+        qualifyingPositions,
+        structureOptions,
+        matchUpFormat,
+        structureName,
+        structureId,
+        drawType
+      } = structureProfile;
+      const matchUpType = structureProfile.matchUpType;
+      let roundLimit, structure, matchUps;
+      if (!isConvertableInteger(drawSize)) {
+        return decorateResult({
+          result: { error: MISSING_DRAW_SIZE },
+          stack
+        });
+      }
+      const roundTargetName = qualifyingProfiles.length > 1 ? `${roundTarget}-` : "";
+      const stageSequenceName = structureProfiles.length > 1 || roundTargetName ? stageSequence : "";
+      const qualifyingStructureName = structureName || (roundTargetName || stageSequenceName ? `${QUALIFYING} ${roundTargetName}${stageSequenceName}` : QUALIFYING);
+      if (drawType === ROUND_ROBIN) {
+        const {
+          structures: structures2,
+          groupCount,
+          maxRoundNumber
+          /*, groupSize*/
+        } = generateRoundRobin({
+          structureName: structureProfile.structureName || qualifyingStructureName,
+          structureId: structureId || uuids?.pop(),
+          // qualifyingPositions,
+          stage: QUALIFYING,
+          structureOptions,
+          appliedPolicies,
+          stageSequence,
+          matchUpType,
+          roundTarget,
+          drawSize,
+          idPrefix,
+          isMock,
+          uuids
+        });
+        targetRoundQualifiersCount = groupCount;
+        roundLimit = maxRoundNumber;
+        structure = structures2[0];
+        finishingPositions = [1];
+      } else {
+        ({ drawSize, matchUps, roundLimit } = treeMatchUps({
+          qualifyingRoundNumber,
+          qualifyingPositions,
+          matchUpType,
+          drawSize,
+          idPrefix,
+          isMock,
+          uuids
+        }));
+        structure = structureTemplate({
+          structureName: structureProfile.structureName || qualifyingStructureName,
+          structureId: structureId || uuids?.pop(),
+          qualifyingRoundNumber: roundLimit,
+          stage: QUALIFYING,
+          matchUpFormat,
+          stageSequence,
+          matchUpType,
+          roundLimit,
+          // redundant
+          matchUps
+        });
+        if (roundTarget) {
+          addExtension({
+            element: structure,
+            extension: { name: ROUND_TARGET, value: roundTarget }
+          });
+        }
+        targetRoundQualifiersCount = matchUps?.filter((matchUp) => matchUp.roundNumber === roundLimit)?.length || 0;
+      }
+      if (stageSequence > 1) {
+        const { link } = generateQualifyingLink({
+          sourceStructureId: finalQualifyingStructureId,
+          sourceRoundNumber: finalQualifyingRoundNumber,
+          targetStructureId: structure.structureId,
+          finishingPositions: linkType === POSITION ? [1] : void 0,
+          linkType
+        });
+        links.push(link);
+        qualifyingDrawPositionsCount += (drawSize || 0) - targetRoundQualifiersCount;
+      } else {
+        qualifyingDrawPositionsCount += drawSize || 0;
+      }
+      linkType = drawType === ROUND_ROBIN ? POSITION : WINNER;
+      finalQualifyingStructureId = structure.structureId;
+      finalQualifyingRoundNumber = roundLimit;
+      structures.push(structure);
+      stageSequence += 1;
+    }
+    totalQualifiersCount += targetRoundQualifiersCount;
+    qualifyingDetails.push({
+      qualifiersCount: targetRoundQualifiersCount,
+      finalQualifyingRoundNumber,
+      finalQualifyingStructureId,
+      finishingPositions,
+      roundTarget,
+      linkType
+    });
+    targetRoundQualifiersCount = 0;
+    roundTarget += 1;
+  }
+  return {
+    qualifiersCount: totalQualifiersCount,
+    qualifyingDrawPositionsCount,
+    qualifyingDetails,
+    structures,
+    ...SUCCESS,
+    links
+  };
+}
+
+function generateDrawStructuresAndLinks(params) {
+  const {
+    enforceMinimumDrawSize = true,
+    overwriteExisting,
+    drawTypeCoercion,
+    // coerce to SINGLE_ELIMINATION for drawSize: 2
+    appliedPolicies,
+    staggeredEntry,
+    // optional - specifies main structure FEED_IN for drawTypes CURTIS_CONSOLATION, FEED_IN_CHAMPIONSHIPS, FMLC
+    drawDefinition,
+    tieFormat,
+    drawSize,
+    isMock,
+    uuids
+  } = params || {};
+  const stack = "generateDrawStructuresAndLinks";
+  let drawType = params.drawType ?? SINGLE_ELIMINATION;
   const structures = [], links = [];
   const matchUpType = params?.matchUpType ?? SINGLES$1;
   const existingQualifyingStructures = drawDefinition?.structures?.filter(
@@ -20351,149 +20793,31 @@ function addDrawDefinition(params) {
       }
       if (incomingMatchUps?.length) {
         addMatchUpsNotice({
-          matchUps: incomingMatchUps,
-          tournamentId,
-          eventId
-        });
-      }
-      event.drawDefinitions = event.drawDefinitions.map(
-        (d) => d.drawId === drawId ? drawDefinition : d
-      );
-      const structureIds = drawDefinition.structures?.map(
-        ({ structureId }) => structureId
-      );
-      modifyDrawNotice({ drawDefinition, tournamentId, structureIds, eventId });
-    }
-  } else {
-    event.drawDefinitions.push(drawDefinition);
-    if (!suppressNotifications) {
-      const { matchUps } = allDrawMatchUps({ drawDefinition, event });
-      matchUps && addMatchUpsNotice({
-        tournamentId: tournamentRecord?.tournamentId,
-        matchUps
-      });
-      addDrawNotice({ drawDefinition, tournamentId, eventId });
-    }
-  }
-  return { ...SUCCESS, modifiedEventEntryStatusCount };
-}
-
-function generateAdHocMatchUps({
-  participantIdPairings,
-  addToStructure = true,
-  tournamentRecord,
-  matchUpIds = [],
-  drawDefinition,
-  matchUpsCount,
-  roundNumber,
-  structureId,
-  newRound
-}) {
-  if (typeof drawDefinition !== "object")
-    return { error: MISSING_DRAW_DEFINITION };
-  if (!structureId && drawDefinition.structures?.length === 1)
-    structureId = drawDefinition.structures?.[0]?.structureId;
-  if (typeof structureId !== "string")
-    return { error: MISSING_STRUCTURE_ID };
-  if (participantIdPairings && !Array.isArray(participantIdPairings) || matchUpsCount && !isConvertableInteger(matchUpsCount) || matchUpIds && !Array.isArray(matchUpIds) || !participantIdPairings && !matchUpsCount) {
-    return { error: INVALID_VALUES, info: "matchUpsCount or pairings error" };
-  }
-  const structure = drawDefinition?.structures?.find(
-    (structure2) => structure2.structureId === structureId
-  );
-  let structureHasRoundPositions;
-  const existingMatchUps = structure?.matchUps;
-  const lastRoundNumber = existingMatchUps?.reduce(
-    (roundNumber2, matchUp) => {
-      if (matchUp.roundPosition)
-        structureHasRoundPositions = true;
-      return (matchUp?.roundNumber || 0) > roundNumber2 ? matchUp.roundNumber : roundNumber2;
-    },
-    0
-  );
-  if (structure?.structures || structureHasRoundPositions || structure?.finishingPosition === ROUND_OUTCOME) {
-    return { error: INVALID_STRUCTURE };
-  }
-  if (roundNumber && roundNumber - 1 > (lastRoundNumber || 0))
-    return { error: INVALID_VALUES, info: "roundNumber error" };
-  const nextRoundNumber = roundNumber ?? (newRound ? (lastRoundNumber ?? 0) + 1 : lastRoundNumber ?? 1);
-  participantIdPairings = participantIdPairings ?? generateRange(0, matchUpsCount).map(() => ({
-    participantIds: [void 0, void 0]
-  }));
-  const matchUps = participantIdPairings?.map((pairing) => {
-    const idStack = pairing?.participantIds ?? [void 0, void 0];
-    idStack.push(...[void 0, void 0]);
-    const participantIds = idStack.slice(0, 2);
-    const sides = participantIds.map(
-      (participantId, i) => definedAttributes({
-        sideNumber: i + 1,
-        participantId
-      })
-    );
-    return {
-      matchUpStatus: MatchUpStatusEnum.ToBePlayed,
-      matchUpId: matchUpIds.pop() ?? UUID(),
-      roundNumber: nextRoundNumber,
-      sides
-    };
-  });
-  if (addToStructure) {
-    const result = addAdHocMatchUps({
-      tournamentRecord,
-      drawDefinition,
-      structureId,
-      matchUps
-    });
-    if (result.error)
-      return result;
-  }
-  return { matchUpsCount: matchUps.length, matchUps, ...SUCCESS };
-}
-function addAdHocMatchUps({
-  tournamentRecord,
-  drawDefinition,
-  structureId,
-  matchUps
-}) {
-  if (typeof drawDefinition !== "object")
-    return { error: MISSING_DRAW_DEFINITION };
-  if (!structureId && drawDefinition.structures?.length === 1)
-    structureId = drawDefinition.structures?.[0]?.structureId;
-  if (typeof structureId !== "string")
-    return { error: MISSING_STRUCTURE_ID };
-  if (!validMatchUps(matchUps))
-    return { error: INVALID_VALUES, info: mustBeAnArray("matchUps") };
-  const structure = drawDefinition.structures?.find(
-    (structure2) => structure2.structureId === structureId
-  );
-  if (!structure)
-    return { error: STRUCTURE_NOT_FOUND };
-  const existingMatchUps = structure?.matchUps;
-  const structureHasRoundPositions = existingMatchUps.find(
-    (matchUp) => !!matchUp.roundPosition
-  );
-  if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
-    return { error: INVALID_STRUCTURE };
-  }
-  const existingMatchUpIds = allTournamentMatchUps({
-    tournamentRecord,
-    inContext: false
-  })?.matchUps?.map(getMatchUpId) ?? [];
-  const newMatchUpIds = matchUps.map(getMatchUpId);
-  if (overlap(existingMatchUpIds, newMatchUpIds)) {
-    return {
-      error: EXISTING_MATCHUP_ID,
-      info: "One or more matchUpIds already present in tournamentRecord"
-    };
+          matchUps: incomingMatchUps,
+          tournamentId,
+          eventId
+        });
+      }
+      event.drawDefinitions = event.drawDefinitions.map(
+        (d) => d.drawId === drawId ? drawDefinition : d
+      );
+      const structureIds = drawDefinition.structures?.map(
+        ({ structureId }) => structureId
+      );
+      modifyDrawNotice({ drawDefinition, tournamentId, structureIds, eventId });
+    }
+  } else {
+    event.drawDefinitions.push(drawDefinition);
+    if (!suppressNotifications) {
+      const { matchUps } = allDrawMatchUps({ drawDefinition, event });
+      matchUps && addMatchUpsNotice({
+        tournamentId: tournamentRecord?.tournamentId,
+        matchUps
+      });
+      addDrawNotice({ drawDefinition, tournamentId, eventId });
+    }
   }
-  structure.matchUps.push(...matchUps);
-  addMatchUpsNotice({
-    tournamentId: tournamentRecord?.tournamentId,
-    drawDefinition,
-    matchUps
-  });
-  modifyDrawNotice({ drawDefinition, structureIds: [structureId] });
-  return { ...SUCCESS };
+  return { ...SUCCESS, modifiedEventEntryStatusCount };
 }
 
 function attachPolicies({ drawDefinition, policyDefinitions }) {
@@ -20558,543 +20882,163 @@ function checkValidEntries({
     const entryStatus = entryStatusMap[participant.participantId];
     const ungroupedParticipant = eventType && [TypeEnum.Doubles, TypeEnum.Team].includes(eventType) && participant.participantType === INDIVIDUAL && (isUngrouped(entryStatus) || entryStatus === WITHDRAWN);
     const mismatch = participant.participantType !== participantType && !ungroupedParticipant;
-    const personGender = participant?.person?.sex;
-    const wrongGender = !ignoreGender && eventGender && eventType === TypeEnum.Singles && [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender !== eventGender;
-    return mismatch || wrongGender;
-  });
-  if (invalidEntries.length) {
-    const invalidParticipantIds = invalidEntries.map(
-      (participant) => participant.participantId
-    );
-    return { error: INVALID_ENTRIES, invalidParticipantIds };
-  }
-  return { ...SUCCESS };
-}
-
-function getValidStage({ stage, drawDefinition }) {
-  return Boolean(
-    stage === VOLUNTARY_CONSOLATION || stageExists({ stage, drawDefinition }) && getStageDrawPositionsCount({ stage, drawDefinition })
-  );
-}
-
-function getStageSpace({
-  entryStatus = DIRECT_ACCEPTANCE,
-  drawDefinition,
-  stageSequence,
-  stage
-}) {
-  if (entryStatus === ALTERNATE) {
-    if (stageAlternatesCount({ stage, drawDefinition })) {
-      return { positionsAvailable: Infinity, ...SUCCESS };
-    } else {
-      return { error: ENTRY_STATUS_NOT_ALLOWED_IN_STAGE };
-    }
-  }
-  const stageDrawPositionsAvailable = getStageDrawPositionsAvailable({
-    drawDefinition,
-    stageSequence,
-    stage
-  });
-  const wildcardPositions = getStageWildcardsCount({
-    drawDefinition,
-    stage
-  });
-  const wildcardEntriesCount = getStageEntryTypeCount({
-    entryStatus: WILDCARD,
-    drawDefinition,
-    stage
-  });
-  const directEntriesCount = getStageEntryTypeCount({
-    entryStatus: DIRECT_ACCEPTANCE,
-    drawDefinition,
-    stage
-  });
-  const totalEntriesCount = wildcardEntriesCount + directEntriesCount;
-  const stageFull = totalEntriesCount >= stageDrawPositionsAvailable;
-  const positionsAvailable = stageDrawPositionsAvailable - totalEntriesCount;
-  if (stage !== VOLUNTARY_CONSOLATION && stageFull) {
-    return { error: NO_STAGE_SPACE_AVAILABLE_FOR_ENTRY_STATUS };
-  }
-  if (entryStatus === WILDCARD) {
-    if (wildcardEntriesCount < wildcardPositions)
-      return { ...SUCCESS };
-    return { error: NO_STAGE_SPACE_AVAILABLE_FOR_ENTRY_STATUS };
-  }
-  return { positionsAvailable, ...SUCCESS };
-}
-
-function addDrawEntry(params) {
-  const {
-    entryStatus = EntryStatusEnum.DirectAcceptance,
-    entryStageSequence,
-    entryStage = MAIN,
-    ignoreStageSpace,
-    drawDefinition,
-    entryPosition,
-    participant,
-    roundTarget,
-    extensions,
-    extension,
-    drawType
-  } = params;
-  const stack = "addDrawEntry";
-  if (!drawDefinition)
-    return { error: MISSING_DRAW_DEFINITION };
-  if (!entryStage)
-    return { error: MISSING_STAGE };
-  if (drawType !== AD_HOC && !getValidStage({ stage: entryStage, drawDefinition })) {
-    return decorateResult({ result: { error: INVALID_STAGE }, stack });
-  }
-  const spaceAvailable = getStageSpace({
-    stageSequence: entryStageSequence,
-    stage: entryStage,
-    drawDefinition,
-    entryStatus
-  });
-  if (!ignoreStageSpace && !spaceAvailable.success) {
-    return { error: spaceAvailable.error };
-  }
-  if (extension && !isValidExtension({ extension }))
-    return decorateResult({
-      result: { error: INVALID_VALUES },
-      info: "Invalid extension",
-      context: { extension },
-      stack
-    });
-  const participantId = params.participantId || participant?.participantId;
-  if (!participantId)
-    return decorateResult({ result: { error: MISSING_PARTICIPANT_ID }, stack });
-  const invalidLuckyLoser = entryStatus === EntryStatusEnum.LuckyLoser && participantInEntries({ participantId, drawDefinition, entryStatus });
-  const invalidVoluntaryConsolation = entryStage === VOLUNTARY_CONSOLATION && participantInEntries({
-    participantId,
-    drawDefinition,
-    entryStage
-  });
-  const invalidEntry = entryStatus !== EntryStatusEnum.LuckyLoser && entryStage !== VOLUNTARY_CONSOLATION && participantInEntries({ drawDefinition, participantId });
-  if (invalidEntry || invalidLuckyLoser || invalidVoluntaryConsolation) {
-    return decorateResult({
-      context: { invalidEntry, invalidLuckyLoser, invalidVoluntaryConsolation },
-      result: { error: EXISTING_PARTICIPANT },
-      stack
-    });
-  }
-  const entry = definedAttributes({
-    entryStageSequence,
-    participantId,
-    entryPosition,
-    entryStatus,
-    entryStage,
-    extensions
-  });
-  if (extension) {
-    addExtension({ element: entry, extension });
-  }
-  if (roundTarget) {
-    addExtension({
-      extension: { name: "roundEntry", value: roundTarget },
-      element: entry
-    });
-  }
-  if (!drawDefinition.entries)
-    drawDefinition.entries = [];
-  drawDefinition.entries.push(entry);
-  modifyDrawNotice({ drawDefinition });
-  return { ...SUCCESS };
-}
-
-function getAllowedDrawTypes({
-  tournamentRecord,
-  categoryName,
-  categoryType
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const { appliedPolicies } = getAppliedPolicies({ tournamentRecord });
-  const drawTypesPolicy = appliedPolicies?.[POLICY_TYPE_DRAWS];
-  const drawTypes = drawTypesPolicy?.allowedDrawTypes || [];
-  return drawTypes.filter(
-    ({ categoryNames, categoryTypes }) => !categoryName && !categoryTypes || categoryName && categoryNames?.includes(categoryName) || categoryType && categoryTypes?.includes(categoryType)
-  );
-}
-
-function generateCandidate({
-  maxIterations = 5e3,
-  // cap the processing intensity of the candidate generator
-  valueSortedPairings,
-  // pairings sorted by value from low to high
-  pairingValues,
-  deltaObjects
-}) {
-  const rankedMatchUpValues = Object.assign(
-    {},
-    ...valueSortedPairings.map((rm) => ({ [rm.pairing]: rm.value }))
-  );
-  let candidate = roundCandidate({
-    rankedMatchUpValues,
-    valueSortedPairings,
-    deltaObjects
-  });
-  let deltaCandidate = candidate;
-  const actors = Object.keys(pairingValues);
-  let candidatesCount = 0;
-  let iterations;
-  let opponentCount = actors.length;
-  do {
-    opponentCount -= 1;
-    iterations = actors.length * opponentCount * valueSortedPairings.length / 2;
-  } while (iterations > maxIterations && opponentCount > 2);
-  const stipulatedPairs = [];
-  actors.forEach((actor) => {
-    const participantIdPairings = pairingValues[actor];
-    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, deltaCandidate, candidatesCount, iterations };
-}
-function roundCandidate({
-  rankedMatchUpValues,
-  valueSortedPairings,
-  stipulated = [],
-  deltaObjects
-}) {
-  const roundPlayers = [].concat(...stipulated);
-  const participantIdPairings = [];
-  let candidateValue = 0;
-  stipulated.filter(Boolean).forEach((participantIds) => {
-    const [p1, p2] = participantIds;
-    const pairing = pairingHash(p1, p2);
-    const value = rankedMatchUpValues[pairing];
-    participantIdPairings.push({ participantIds, value });
-    candidateValue += rankedMatchUpValues[pairing];
+    const personGender = participant?.person?.sex;
+    const wrongGender = !ignoreGender && eventGender && eventType === TypeEnum.Singles && [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender !== eventGender;
+    return mismatch || wrongGender;
   });
-  valueSortedPairings.forEach((rankedPairing) => {
-    const participantIds = rankedPairing.pairing.split("|");
-    const opponentExists = participantIds.reduce(
-      (p, c) => roundPlayers.includes(c) || p,
-      false
+  if (invalidEntries.length) {
+    const invalidParticipantIds = invalidEntries.map(
+      (participant) => participant.participantId
     );
-    if (!opponentExists) {
-      roundPlayers.push(...participantIds);
-      const value = rankedPairing.value;
-      candidateValue += value;
-      participantIdPairings.push({ participantIds, value });
-    }
-  });
-  participantIdPairings.sort((a, b) => a.value - b.value);
-  const maxDelta = participantIdPairings.reduce((p, c) => {
-    const [p1, p2] = c.participantIds;
-    const hash = pairingHash(p1, p2);
-    const delta = deltaObjects[hash];
-    return delta > p ? delta : p;
-  }, 0);
-  return { value: candidateValue, participantIdPairings, maxDelta };
+    return { error: INVALID_ENTRIES, invalidParticipantIds };
+  }
+  return { ...SUCCESS };
 }
-function pairingHash(id1, id2) {
-  return [id1, id2].sort().join("|");
+
+function getValidStage({ stage, drawDefinition }) {
+  return Boolean(
+    stage === VOLUNTARY_CONSOLATION || stageExists({ stage, drawDefinition }) && getStageDrawPositionsCount({ stage, drawDefinition })
+  );
 }
 
-const ENCOUNTER_VALUE = 50;
-const SAME_TEAM_VALUE = 60;
-const DEFAULT_RATING = 0;
-const MAX_ITERATIONS = 5e3;
-function generateDrawMaticRound({
-  maxIterations = MAX_ITERATIONS,
-  generateMatchUps = true,
-  tournamentParticipants,
-  tournamentRecord,
-  participantIds,
-  addToStructure,
+function getStageSpace({
+  entryStatus = DIRECT_ACCEPTANCE,
   drawDefinition,
-  adHocRatings,
-  structureId,
-  matchUpIds,
-  eventType,
-  structure
+  stageSequence,
+  stage
 }) {
-  if (!participantIds?.length) {
-    return { error: MISSING_PARTICIPANT_IDS };
-  }
-  const { encounters } = getEncounters({ matchUps: structure.matchUps });
-  const valueObjects = {};
-  for (const pairing of encounters) {
-    if (!valueObjects[pairing])
-      valueObjects[pairing] = 0;
-    valueObjects[pairing] += ENCOUNTER_VALUE;
-  }
-  const teamParticipants = tournamentParticipants?.filter(
-    ({ participantType }) => participantType === TEAM
-  );
-  if (teamParticipants) {
-    for (const teamParticipant of teamParticipants) {
-      const participantIds2 = teamParticipant.individualParticipantIds || [];
-      const { uniquePairings: uniquePairings2 } = getPairingsData({ participantIds: participantIds2 });
-      for (const pairing of uniquePairings2) {
-        if (!valueObjects[pairing])
-          valueObjects[pairing] = 0;
-        valueObjects[pairing] += SAME_TEAM_VALUE;
-      }
+  if (entryStatus === ALTERNATE) {
+    if (stageAlternatesCount({ stage, drawDefinition })) {
+      return { positionsAvailable: Infinity, ...SUCCESS };
+    } else {
+      return { error: ENTRY_STATUS_NOT_ALLOWED_IN_STAGE };
     }
   }
-  const { uniquePairings, possiblePairings, deltaObjects } = getPairingsData({
-    participantIds
-  });
-  const params = {
-    tournamentParticipants,
-    possiblePairings,
+  const stageDrawPositionsAvailable = getStageDrawPositionsAvailable({
     drawDefinition,
-    participantIds,
-    uniquePairings,
-    maxIterations,
-    adHocRatings,
-    deltaObjects,
-    valueObjects,
-    eventType,
-    structure
-  };
-  const { candidatesCount, participantIdPairings, iterations } = getPairings(params);
-  if (!candidatesCount)
-    return { error: NO_CANDIDATES };
-  let matchUps;
-  if (generateMatchUps) {
-    const result = generateAdHocMatchUps({
-      participantIdPairings,
-      tournamentRecord,
-      addToStructure,
-      newRound: true,
-      drawDefinition,
-      structureId,
-      matchUpIds
-    });
-    if (result.error)
-      return result;
-    matchUps = result.matchUps;
-  }
-  return {
-    ...SUCCESS,
-    participantIdPairings,
-    candidatesCount,
-    iterations,
-    matchUps
-  };
-}
-function getSideRatings({
-  tournamentParticipants,
-  adHocRatings,
-  eventType,
-  pairing
-}) {
-  return pairing.split("|").map((participantId) => {
-    if (eventType === DOUBLES) {
-      const individualParticipantIds = tournamentParticipants?.find(
-        (participant) => participant.participantId === participantId
-      )?.individualParticipantIds;
-      return !individualParticipantIds ? DEFAULT_RATING * 2 : individualParticipantIds?.map(
-        (participantId2) => adHocRatings[participantId2 || DEFAULT_RATING]
-      );
-    } else {
-      return adHocRatings[participantId] || DEFAULT_RATING;
-    }
+    stageSequence,
+    stage
   });
-}
-function getPairings({
-  tournamentParticipants,
-  adHocRatings = {},
-  possiblePairings,
-  // participant keyed; provides array of possible opponents
-  uniquePairings,
-  // 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
-}) {
-  uniquePairings.forEach((pairing) => {
-    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(ratingsDifference, 2);
+  const wildcardPositions = getStageWildcardsCount({
+    drawDefinition,
+    stage
   });
-  const valueSortedPairings = uniquePairings.map((pairing) => ({ pairing, value: valueObjects[pairing] })).sort((a, b) => a.value - b.value);
-  const { pairingValues } = getParticipantPairingValues({
-    possiblePairings,
-    valueObjects
+  const wildcardEntriesCount = getStageEntryTypeCount({
+    entryStatus: WILDCARD,
+    drawDefinition,
+    stage
   });
-  const { candidate, candidatesCount, iterations } = generateCandidate({
-    valueSortedPairings,
-    maxIterations,
-    pairingValues,
-    deltaObjects
+  const directEntriesCount = getStageEntryTypeCount({
+    entryStatus: DIRECT_ACCEPTANCE,
+    drawDefinition,
+    stage
   });
-  const { participantIdPairings } = candidate;
-  return { candidatesCount, participantIdPairings, iterations };
+  const totalEntriesCount = wildcardEntriesCount + directEntriesCount;
+  const stageFull = totalEntriesCount >= stageDrawPositionsAvailable;
+  const positionsAvailable = stageDrawPositionsAvailable - totalEntriesCount;
+  if (stage !== VOLUNTARY_CONSOLATION && stageFull) {
+    return { error: NO_STAGE_SPACE_AVAILABLE_FOR_ENTRY_STATUS };
+  }
+  if (entryStatus === WILDCARD) {
+    if (wildcardEntriesCount < wildcardPositions)
+      return { ...SUCCESS };
+    return { error: NO_STAGE_SPACE_AVAILABLE_FOR_ENTRY_STATUS };
+  }
+  return { positionsAvailable, ...SUCCESS };
 }
-function getPairingsData({ participantIds }) {
-  const possiblePairings = {};
-  const uniquePairings = [];
-  participantIds.forEach((participantId) => {
-    possiblePairings[participantId] = participantIds.filter(
-      (id) => id !== participantId
-    );
-    possiblePairings[participantId].forEach((id) => {
-      const pairing = pairingHash(id, participantId);
-      if (!uniquePairings.includes(pairing))
-        uniquePairings.push(pairing);
+
+function addDrawEntry(params) {
+  const {
+    entryStatus = EntryStatusEnum.DirectAcceptance,
+    entryStageSequence,
+    entryStage = MAIN,
+    ignoreStageSpace,
+    drawDefinition,
+    entryPosition,
+    participant,
+    roundTarget,
+    extensions,
+    extension,
+    drawType
+  } = params;
+  const stack = "addDrawEntry";
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  if (!entryStage)
+    return { error: MISSING_STAGE };
+  if (drawType !== AD_HOC && !getValidStage({ stage: entryStage, drawDefinition })) {
+    return decorateResult({ result: { error: INVALID_STAGE }, stack });
+  }
+  const spaceAvailable = getStageSpace({
+    stageSequence: entryStageSequence,
+    stage: entryStage,
+    drawDefinition,
+    entryStatus
+  });
+  if (!ignoreStageSpace && !spaceAvailable.success) {
+    return { error: spaceAvailable.error };
+  }
+  if (extension && !isValidExtension({ extension }))
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      info: "Invalid extension",
+      context: { extension },
+      stack
     });
+  const participantId = params.participantId || participant?.participantId;
+  if (!participantId)
+    return decorateResult({ result: { error: MISSING_PARTICIPANT_ID }, stack });
+  const invalidLuckyLoser = entryStatus === EntryStatusEnum.LuckyLoser && participantInEntries({ participantId, drawDefinition, entryStatus });
+  const invalidVoluntaryConsolation = entryStage === VOLUNTARY_CONSOLATION && participantInEntries({
+    participantId,
+    drawDefinition,
+    entryStage
   });
-  const deltaObjects = Object.assign(
-    {},
-    ...uniquePairings.map((pairing) => ({ [pairing]: 0 }))
-  );
-  return { uniquePairings, possiblePairings, deltaObjects };
-}
-function getEncounters({ matchUps }) {
-  const encounters = [];
-  for (const matchUp of matchUps) {
-    const participantIds = matchUp.sides.map(getParticipantId);
-    if (participantIds.length === 2) {
-      const [p1, p2] = participantIds;
-      const pairing = pairingHash(p1, p2);
-      if (!encounters.includes(pairing))
-        encounters.push(pairing);
-    }
+  const invalidEntry = entryStatus !== EntryStatusEnum.LuckyLoser && entryStage !== VOLUNTARY_CONSOLATION && participantInEntries({ drawDefinition, participantId });
+  if (invalidEntry || invalidLuckyLoser || invalidVoluntaryConsolation) {
+    return decorateResult({
+      context: { invalidEntry, invalidLuckyLoser, invalidVoluntaryConsolation },
+      result: { error: EXISTING_PARTICIPANT },
+      stack
+    });
   }
-  return { encounters };
-}
-function getParticipantPairingValues({ possiblePairings, valueObjects }) {
-  const pairingValues = {};
-  for (const participantId of Object.keys(possiblePairings)) {
-    const participantValues = possiblePairings[participantId].map(
-      (opponent) => pairingValue(participantId, opponent)
-    );
-    pairingValues[participantId] = participantValues.sort(
-      (a, b) => a.value - b.value
-    );
+  const entry = definedAttributes({
+    entryStageSequence,
+    participantId,
+    entryPosition,
+    entryStatus,
+    entryStage,
+    extensions
+  });
+  if (extension) {
+    addExtension({ element: entry, extension });
   }
-  function pairingValue(participantId, opponent) {
-    const key = pairingHash(participantId, opponent);
-    return { opponent, value: valueObjects[key] };
+  if (roundTarget) {
+    addExtension({
+      extension: { name: "roundEntry", value: roundTarget },
+      element: entry
+    });
   }
-  return { pairingValues };
+  if (!drawDefinition.entries)
+    drawDefinition.entries = [];
+  drawDefinition.entries.push(entry);
+  modifyDrawNotice({ drawDefinition });
+  return { ...SUCCESS };
 }
 
-function drawMatic({
-  tournamentParticipants,
-  restrictEntryStatus,
+function getAllowedDrawTypes({
   tournamentRecord,
-  generateMatchUps,
-  addToStructure,
-  participantIds,
-  drawDefinition,
-  maxIterations,
-  structureId,
-  matchUpIds,
-  scaleName,
-  // custom rating name to seed dynamic ratings
-  eventType,
-  event
+  categoryName,
+  categoryType
 }) {
-  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, info: "Missing Entries" };
-  }
-  eventType = eventType ?? event?.eventType;
-  const enteredParticipantIds = drawDefinition?.entries?.filter((entry) => {
-    const entryStatus = entry.entryStatus;
-    return !restrictEntryStatus || STRUCTURE_SELECTED_STATUSES.includes(entryStatus);
-  }).map(getParticipantId);
-  if (participantIds) {
-    const invalidParticipantIds = participantIds.filter(
-      (participantId) => !enteredParticipantIds?.includes(participantId)
-    );
-    if (invalidParticipantIds?.length)
-      return {
-        error: INVALID_PARTICIPANT_ID,
-        invalidParticipantIds
-      };
-  } else {
-    participantIds = enteredParticipantIds;
-  }
-  if (!structureId) {
-    const targetStructure = drawDefinition?.structures?.filter((structure2) => structure2.stageSequence === 1)?.reduce((targetStructure2, structure2) => {
-      const orderNumber = structure2.stage && stageOrder[structure2.stage];
-      const structureIsAdHoc2 = isAdHoc({ drawDefinition, structure: structure2 });
-      return structureIsAdHoc2 && orderNumber > (stageOrder[targetStructure2?.stage] || 1) ? structure2 : targetStructure2;
-    }, void 0);
-    structureId = targetStructure?.structureId;
-  }
-  const structure = drawDefinition?.structures?.find(
-    (structure2) => structure2.structureId === structureId
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  const { appliedPolicies } = getAppliedPolicies({ tournamentRecord });
+  const drawTypesPolicy = appliedPolicies?.[POLICY_TYPE_DRAWS];
+  const drawTypes = drawTypesPolicy?.allowedDrawTypes || [];
+  return drawTypes.filter(
+    ({ categoryNames, categoryTypes }) => !categoryName && !categoryTypes || categoryName && categoryNames?.includes(categoryName) || categoryType && categoryTypes?.includes(categoryType)
   );
-  if (!structure)
-    return { error: STRUCTURE_NOT_FOUND };
-  const structureIsAdHoc = isAdHoc({ drawDefinition, structure });
-  if (!structureIsAdHoc)
-    return { error: INVALID_DRAW_DEFINITION };
-  const adHocRatings = {};
-  for (const participantId of participantIds ?? []) {
-    const participant = tournamentParticipants?.find(
-      (participant2) => participant2.participantId === participantId
-    );
-    let scaleValue = getScaleValue({ eventType, participant });
-    if (!scaleValue && scaleName) {
-      scaleValue = getScaleValue({ scaleName, eventType, participant });
-    }
-    if (scaleValue)
-      adHocRatings[participantId] = scaleValue;
-  }
-  return generateDrawMaticRound({
-    tournamentParticipants,
-    tournamentRecord,
-    generateMatchUps,
-    participantIds,
-    addToStructure,
-    drawDefinition,
-    maxIterations,
-    adHocRatings,
-    structureId,
-    matchUpIds,
-    structure,
-    eventType
-  });
-}
-function getScaleValue({ scaleName = "dynamic", eventType, participant }) {
-  const scaleAttributes = {
-    eventType: eventType || TypeEnum.Singles,
-    scaleType: RATING,
-    scaleName
-  };
-  const result = participant && participantScaleItem({
-    scaleAttributes,
-    participant
-  });
-  return result?.scaleItem?.scaleValue;
 }
 
 const definitionTemplate = () => ({
@@ -22572,6 +22516,113 @@ function prepareStage(params) {
   };
 }
 
+function drawMatic({
+  tournamentParticipants,
+  restrictEntryStatus,
+  tournamentRecord,
+  generateMatchUps,
+  addToStructure,
+  participantIds,
+  drawDefinition,
+  scaleAccessor,
+  maxIterations,
+  structureId,
+  matchUpIds,
+  scaleName,
+  // custom rating name to seed dynamic ratings
+  eventType,
+  event
+}) {
+  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, info: "Missing Entries" };
+  }
+  eventType = eventType ?? event?.eventType;
+  const enteredParticipantIds = drawDefinition?.entries?.filter((entry) => {
+    const entryStatus = entry.entryStatus;
+    return !restrictEntryStatus || STRUCTURE_SELECTED_STATUSES.includes(entryStatus);
+  }).map(getParticipantId);
+  if (participantIds) {
+    const invalidParticipantIds = participantIds.filter(
+      (participantId) => !enteredParticipantIds?.includes(participantId)
+    );
+    if (invalidParticipantIds?.length)
+      return {
+        error: INVALID_PARTICIPANT_ID,
+        invalidParticipantIds
+      };
+  } else {
+    participantIds = enteredParticipantIds;
+  }
+  if (!structureId) {
+    const targetStructure = drawDefinition?.structures?.filter((structure2) => structure2.stageSequence === 1)?.reduce((targetStructure2, structure2) => {
+      const orderNumber = structure2.stage && stageOrder[structure2.stage];
+      const structureIsAdHoc2 = isAdHoc({ drawDefinition, structure: structure2 });
+      return structureIsAdHoc2 && orderNumber > (stageOrder[targetStructure2?.stage] || 1) ? structure2 : targetStructure2;
+    }, void 0);
+    structureId = targetStructure?.structureId;
+  }
+  const structure = drawDefinition?.structures?.find(
+    (structure2) => structure2.structureId === structureId
+  );
+  if (!structure)
+    return { error: STRUCTURE_NOT_FOUND };
+  const structureIsAdHoc = isAdHoc({ drawDefinition, structure });
+  if (!structureIsAdHoc)
+    return { error: INVALID_DRAW_DEFINITION };
+  tournamentParticipants = tournamentParticipants ?? tournamentRecord.participants ?? [];
+  const adHocRatings = {};
+  for (const participantId of participantIds ?? []) {
+    const participant = tournamentParticipants?.find(
+      (participant2) => participant2.participantId === participantId
+    );
+    let scaleValue = getScaleValue({ eventType, participant });
+    if (!scaleValue && scaleName) {
+      scaleValue = getScaleValue({
+        scaleAccessor,
+        participant,
+        scaleName,
+        eventType
+      });
+    }
+    if (scaleValue)
+      adHocRatings[participantId] = scaleValue;
+  }
+  return generateDrawMaticRound({
+    tournamentParticipants,
+    tournamentRecord,
+    generateMatchUps,
+    participantIds,
+    addToStructure,
+    drawDefinition,
+    maxIterations,
+    adHocRatings,
+    matchUpIds,
+    structure,
+    eventType
+  });
+}
+function getScaleValue({
+  eventType = TypeEnum.Singles,
+  scaleName = "dynamic",
+  scaleAccessor,
+  participant
+}) {
+  const scaleAttributes = {
+    eventType: eventType || TypeEnum.Singles,
+    scaleType: RATING,
+    scaleName
+  };
+  const result = participant && participantScaleItem({
+    scaleAttributes,
+    participant
+  });
+  const scaleValue = result?.scaleItem?.scaleValue;
+  return scaleAccessor && isObject(scaleValue) ? scaleValue[scaleAccessor] : scaleValue;
+}
+
 const POLICY_SEEDING_USTA = {
   [POLICY_TYPE_SEEDING]: {
     validSeedPositions: { ignore: true },
@@ -22899,12 +22950,28 @@ function generateDrawDefinition(params) {
       const matchUpsCount = entries2 ? Math.floor(entries2.length / 2) : 0;
       generateRange(1, params.roundsCount + 1).forEach(() => {
         if (params.automated) {
+          const {
+            restrictEntryStatus,
+            generateMatchUps,
+            addToStructure,
+            maxIterations,
+            structureId: structureId2,
+            matchUpIds,
+            scaleName
+          } = params.drawMatic ?? {};
           drawMatic({
-            generateMatchUps: true,
-            eventType: matchUpType,
             tournamentRecord,
             participantIds,
-            drawDefinition
+            drawDefinition,
+            eventType: params.drawMatic?.eventType ?? matchUpType,
+            generateMatchUps: generateMatchUps ?? true,
+            restrictEntryStatus,
+            addToStructure,
+            maxIterations,
+            structureId: structureId2,
+            matchUpIds,
+            scaleName
+            // custom rating name to seed dynamic ratings
           });
         } else {
           generateAdHocMatchUps({
@@ -23146,5 +23213,5 @@ function generateFlightProfile(params) {
   }
 }
 
-export { automatedPlayoffPositioning, automatedPositioning, createGroupParticipant, generateAndPopulatePlayoffStructures, generateDrawDefinition, generateFlightProfile, generateVoluntaryConsolation };
+export { automatedPlayoffPositioning, automatedPositioning, createGroupParticipant, generateAndPopulatePlayoffStructures, generateDrawDefinition, generateDrawMaticRound, generateFlightProfile, generateVoluntaryConsolation };
 //# sourceMappingURL=generate.mjs.map