tods-competition-factory 1.7.19 → 1.8.1

package/dist/forge/query.mjs

@@ -3682,7 +3682,6 @@ const membershipMap = {
 function getParticipantMap({
   withIndividualParticipants,
   convertExtensions,
-  policyDefinitions,
   tournamentRecord,
   withSignInStatus,
   withScaleValues,
@@ -3690,32 +3689,23 @@ function getParticipantMap({
   withISO2,
   withIOC
 }) {
-  const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
-  const filterAttributes = participantAttributes?.participant;
   const participantMap = {};
-  for (const participant of tournamentRecord.participants || []) {
+  for (const participant of tournamentRecord.participants ?? []) {
     const participantId = participant?.participantId;
     participantId && initializeParticipantId({ participantMap, participantId });
   }
-  for (const participant of tournamentRecord.participants || []) {
+  for (const participant of tournamentRecord.participants ?? []) {
     const participantCopy = makeDeepCopy(
       participant,
       convertExtensions,
       internalUse
     );
-    const filteredParticipant = filterAttributes ? attributeFilter({
-      template: participantAttributes.participant,
-      source: participantCopy
-    }) : participantCopy;
-    const { participantId, individualParticipantIds, participantType } = filteredParticipant;
-    Object.assign(
-      participantMap[participantId].participant,
-      filteredParticipant
-    );
+    const { participantId, individualParticipantIds, participantType } = participantCopy;
+    Object.assign(participantMap[participantId].participant, participantCopy);
     if (individualParticipantIds) {
       processIndividualParticipantIds({
         individualParticipantIds,
-        filteredParticipant,
+        participantCopy,
         participantMap,
         participantType,
         participantId
@@ -3766,7 +3756,7 @@ function addIndividualParticipants({ participantMap }) {
 }
 function processIndividualParticipantIds({
   individualParticipantIds,
-  filteredParticipant,
+  participantCopy,
   participantMap,
   participantType,
   participantId
@@ -3781,7 +3771,7 @@ function processIndividualParticipantIds({
         participantName,
         participantId: participantId2,
         teamId
-      } = filteredParticipant;
+      } = participantCopy;
       const membership = membershipMap[participantType];
       individualParticipant[membership].push({
         participantRoleResponsibilities,
@@ -3844,7 +3834,6 @@ function initializeParticipantId({ participantMap, participantId }) {
 function hydrateParticipants({
   participantsProfile,
   useParticipantMap,
-  policyDefinitions,
   tournamentRecord,
   contextProfile,
   inContext
@@ -3853,7 +3842,6 @@ function hydrateParticipants({
     const participantMap = getParticipantMap({
       ...participantsProfile,
       ...contextProfile,
-      policyDefinitions,
       tournamentRecord
     })?.participantMap;
     return { participantMap };
@@ -9222,7 +9210,9 @@ const POLICY_MATCHUP_ACTIONS_DEFAULT = {
     },
     processCodes: {
       substitution: ["RANKING.IGNORE", "RATING.IGNORE"]
-    }
+    },
+    substituteAfterCompleted: false,
+    substituteWithoutScore: false
   }
 };
 
@@ -11213,649 +11203,1127 @@ function getMatchUpDependencies(params) {
   };
 }
 
-function getInitialRoundNumber({
-  drawPosition,
-  matchUps = []
-}) {
-  const initialRoundNumber = matchUps.filter(
-    ({ drawPositions }) => drawPosition && drawPositions?.includes(drawPosition)
-  ).map(({ roundNumber }) => roundNumber).sort(numericSort)[0];
-  return { initialRoundNumber };
-}
-
-function getContainedStructures({
-  tournamentRecord,
-  drawDefinition,
-  event
-}) {
-  const events = tournamentRecord?.events || event && [event];
-  const drawDefinitions = events?.map((event2) => event2?.drawDefinitions).flat().filter(Boolean) || drawDefinition && [drawDefinition] || [];
-  const containedStructures = {};
-  const containerStructures = {};
-  const structureContainers = drawDefinitions.map((dd) => dd?.structures?.filter((structure) => structure?.structures)).flat().filter(Boolean);
-  for (const structureContainer of structureContainers) {
-    const { structures, structureId } = structureContainer || {};
-    structures && structureId && (containedStructures[structureId] = structures?.map(
-      (structure) => structure.structureId
-    )) && structures.forEach(
-      (structure) => containerStructures[structure.structureId] = structureContainer?.structureId
-    );
+function getEventPublishStatuses({ event }) {
+  const itemType = `${PUBLISH}.${STATUS$1}`;
+  const { timeItem } = getTimeItem({
+    element: event,
+    itemType
+  });
+  if (timeItem?.itemValue?.PUBLIC) {
+    const { drawIds: publishedDrawIds = [], seeding } = timeItem.itemValue.PUBLIC || {};
+    const publishedSeeding = {
+      published: void 0,
+      // seeding can be present for all entries in an event when no flights have been defined
+      seedingScaleNames: [],
+      drawIds: []
+      // seeding can be specific to drawIds
+    };
+    if (seeding) {
+      Object.assign(publishedSeeding, timeItem.itemValue.PUBLIC.seeding);
+    }
+    return {
+      publishedDrawIds,
+      publishedSeeding
+    };
   }
-  return { containedStructures, containerStructures };
+  return void 0;
 }
 
-function isActiveMatchUp({
-  matchUpStatus,
-  winningSide,
-  tieMatchUps,
-  sides,
-  score
+function getEventSeedAssignments({
+  publishedSeeding,
+  usePublishState,
+  withSeeding,
+  participant,
+  event
 }) {
-  const participantAssigned = sides?.find(({ participantId }) => participantId);
-  const activeTieMatchUps = tieMatchUps?.filter(isActiveMatchUp)?.length;
-  const scoreExists = scoreHasValue({ score });
-  return scoreExists || activeTieMatchUps || winningSide && participantAssigned || // if winningSide and no participant assigned => "produced" WALKOVER
-  // must exclude IN_PROGRESS as this is automatically set by updateTieMatchUpScore
-  // must exclude WALKOVER and DEFAULTED as "produced" scenarios do not imply a winningSide
-  matchUpStatus && isActiveMatchUpStatus({ matchUpStatus }) && ![DEFAULTED, WALKOVER$1, IN_PROGRESS].includes(matchUpStatus);
-}
-
-function getStructureDrawPositionProfiles(params) {
-  const { drawDefinition, findContainer, structureId, event } = params;
-  let structure = params.structure;
-  const matchUpFilters = { isCollectionMatchUp: false };
-  const { containedStructures } = getContainedStructures({ drawDefinition });
-  const containedStructureIds = structureId ? containedStructures[structureId] || [] : [];
-  if (!structure) {
-    const result = findStructure({ drawDefinition, structureId });
-    if (result.error)
-      return result;
-    structure = findContainer ? result.containingStructure || result.structure : result.structure;
-  }
-  if (isAdHoc({ drawDefinition, structure })) {
-    return { structure, isAdHoc: true, error: INVALID_DRAW_POSITION };
-  }
-  const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
-    inContext: true,
-    matchUpFilters,
-    drawDefinition,
-    event
-  });
-  const inContextStructureMatchUps = inContextDrawMatchUps?.filter(
-    (matchUp) => matchUp.structureId === structureId || containedStructureIds.includes(matchUp.structureId)
+  const eventSeedAssignments = {};
+  const getScaleAccessor = (scaleName) => [SCALE, SEEDING, event.eventType, scaleName].join(".");
+  const seedingScales = Object.assign(
+    {},
+    ...(participant.timeItems || []).filter(({ itemType }) => itemType.split(".")[1] === SEEDING).map(({ itemType: seedingScaleName, itemValue: seedValue }) => ({
+      [seedingScaleName]: seedValue
+    }))
   );
-  const { matchUpDependencies } = getMatchUpDependencies({
-    drawIds: [drawDefinition.drawId],
-    matchUps: inContextDrawMatchUps,
-    drawDefinition
-  });
-  const activeDependentMatchUpIdsCollection = [];
-  const drawPositionsCollection = [];
-  const drawPositionInitialRounds = {};
-  const activeMatchUps = [];
-  for (const matchUp of inContextDrawMatchUps || []) {
-    if (matchUp.structureId === structureId || containedStructureIds.includes(matchUp.structureId)) {
-      drawPositionsCollection.push(...matchUp.drawPositions || []);
-      const roundNumber = matchUp.roundNumber;
-      for (const drawPosition of (matchUp.drawPositions || []).filter(
-        Boolean
-      )) {
-        if (!drawPositionInitialRounds[drawPosition] || roundNumber && drawPositionInitialRounds[drawPosition] > roundNumber) {
-          drawPositionInitialRounds[drawPosition] = roundNumber;
-        }
+  const eventSeedingScaleNames = (publishedSeeding?.stageSeedingScaleNames && Object.values(publishedSeeding?.stageSeedingScaleNames) || Array.isArray(publishedSeeding?.seedingScaleNames) && publishedSeeding.seedingScaleNames || []).map(getScaleAccessor);
+  const publishedEventSeedingScaleNames = intersection(
+    Object.keys(seedingScales),
+    eventSeedingScaleNames
+  );
+  const eventSeedingPublished = !!(!usePublishState || !Object.keys(seedingScales).length && !publishedSeeding?.drawIds?.length || publishedEventSeedingScaleNames.length);
+  if (eventSeedingPublished && publishedEventSeedingScaleNames.length) {
+    if (publishedSeeding?.stageSeedingScaleNames) {
+      const scaleValues = Object.keys(publishedSeeding.stageSeedingScaleNames).map((key) => {
+        const accessor = getScaleAccessor(
+          publishedSeeding.stageSeedingScaleNames[key]
+        );
+        const scaleValue = seedingScales[accessor];
+        return [key, scaleValue];
+      }).filter((pair) => pair[1]).map((pair) => ({ [pair[0]]: { seedValue: pair[1] } }));
+      const seedAssignments = Object.assign({}, ...scaleValues);
+      eventSeedAssignments.seedAssignments = seedAssignments;
+    } else if (publishedEventSeedingScaleNames) {
+      const seedValues = publishedEventSeedingScaleNames.map(
+        (scaleName) => seedingScales[scaleName]
+      );
+      eventSeedAssignments.seedValue = seedValues.pop();
+    }
+  } else if (!usePublishState && typeof withSeeding === "object") {
+    const scaleValues = Object.keys(withSeeding).map((key) => {
+      const accessor = getScaleAccessor(withSeeding[key]);
+      const scaleValue = seedingScales[accessor];
+      return [key, scaleValue];
+    }).filter((pair) => pair[1]).map((pair) => ({ [pair[0]]: { seedValue: pair[1] } }));
+    const seedAssignments = Object.assign({}, ...scaleValues);
+    eventSeedAssignments.seedAssignments = seedAssignments;
+  } else {
+    const { categoryName, ageCategoryCode } = event.category || {};
+    let scaleItem;
+    for (const scaleName of [ageCategoryCode, event.eventId, categoryName]) {
+      const scaleAttributes = {
+        eventType: event.eventType,
+        scaleType: SEEDING,
+        scaleName
+      };
+      const result = participantScaleItem({
+        scaleAttributes,
+        participant
+      });
+      if (result.scaleItem) {
+        scaleItem = result.scaleItem;
+        break;
       }
     }
-    if (isActiveMatchUp(matchUp)) {
-      activeMatchUps.push(matchUp);
-      activeDependentMatchUpIdsCollection.push(
-        matchUp.matchUpId,
-        ...matchUpDependencies?.[matchUp?.matchUpId]?.matchUpIds || []
-      );
+    if (scaleItem) {
+      const seedingPublished = !usePublishState || publishedSeeding?.published && // if drawIds have been specified then don't attach event seeding here
+      // defer to seedValue that is in seedAssignments for draw in which participant appears
+      !publishedSeeding?.published?.drawIds?.length;
+      if (seedingPublished) {
+        const seedValue = scaleItem.scaleValue;
+        eventSeedAssignments.seedValue = seedValue;
+      }
     }
   }
-  const drawPositions = unique(drawPositionsCollection.filter(Boolean)).sort(
-    numericSort
-  );
-  const activeDependentMatchUpIds = unique(activeDependentMatchUpIdsCollection);
-  const activeDrawPositions = unique(
-    inContextStructureMatchUps?.map(
-      ({ matchUpId, drawPositions: drawPositions2 }) => activeDependentMatchUpIds.includes(matchUpId) ? drawPositions2 : []
-    ).flat().filter(Boolean)
-  ).sort(numericSort);
-  const { positionAssignments } = getPositionAssignments({
-    drawDefinition,
-    structure
-  });
-  const byeDrawPositions = positionAssignments?.filter((assignment) => assignment.bye).map((assignment) => assignment.drawPosition);
-  const qualifyingDrawPositions = positionAssignments?.filter((assignment) => assignment.qualifier).map((assignment) => assignment.drawPosition);
-  const inactiveDrawPositions = drawPositions?.filter(
-    (drawPosition) => !activeDrawPositions.includes(drawPosition)
-  ) || [];
-  return {
-    allDrawPositions: drawPositions,
-    inContextStructureMatchUps,
-    drawPositionInitialRounds,
-    activeDependentMatchUpIds,
-    qualifyingDrawPositions,
-    inactiveDrawPositions,
-    positionAssignments,
-    activeDrawPositions,
-    byeDrawPositions,
-    activeMatchUps,
-    structure
-  };
-}
-
-const hasParticipantId = (o) => o?.participantId;
-
-function getNumericSeedValue(seedValue) {
-  if (!seedValue)
-    return Infinity;
-  if (isConvertableInteger(seedValue))
-    return ensureInt(seedValue);
-  const firstValue = seedValue.split("-")[0];
-  if (isConvertableInteger(firstValue))
-    return ensureInt(firstValue);
-  return Infinity;
+  return eventSeedAssignments;
 }
 
-function getValidGroupSizes({
-  drawSize,
-  groupSizeLimit = 10
+function processEventEntry({
+  extensionConversions,
+  seedAssignments,
+  participant,
+  withSeeding,
+  seedValue,
+  eventId,
+  ranking,
+  entry
 }) {
-  const validGroupSizes = generateRange(3, groupSizeLimit + 1).filter(
-    (groupSize) => {
-      const groupsCount = Math.ceil(drawSize / groupSize);
-      const byesCount = groupsCount * groupSize - drawSize;
-      const maxParticipantsPerGroup = Math.ceil(drawSize / groupsCount);
-      const maxByesPerGroup = Math.ceil(byesCount / groupsCount);
-      return (!byesCount || byesCount < groupSize) && maxParticipantsPerGroup === groupSize && maxParticipantsPerGroup >= 3 && maxByesPerGroup < 2;
-    }
+  const { entryStatus, entryStage, entryPosition, extensions } = entry;
+  const entryExtensions = extensions?.length ? Object.assign({}, ...extensionsToAttributes(extensions)) : {};
+  const attributes = Object.assign(entryExtensions, {
+    ...extensionConversions,
+    // this should be deprecated and clients should use derivedEventInfo
+    entryPosition,
+    entryStatus,
+    entryStage,
+    ranking,
+    eventId
+  });
+  participant.events[eventId] = definedAttributes(
+    attributes,
+    false,
+    false,
+    true
   );
-  return { ...SUCCESS, validGroupSizes };
+  if (withSeeding) {
+    if (seedAssignments)
+      participant.events[eventId].seedAssignments = seedAssignments;
+    if (seedValue)
+      participant.events[eventId].seedValue = seedValue;
+  }
 }
 
-function getSeedBlocks(params) {
-  const { roundRobinGroupsCount, participantsCount, cluster } = params;
-  if (!isConvertableInteger(participantsCount))
-    return {
-      seedBlocks: void 0,
-      ...decorateResult({
-        result: { error: INVALID_VALUES },
-        context: { participantsCount },
-        stack: "getSeedBlocks"
-      })
-    };
-  const drawSize = nextPowerOf2(participantsCount);
-  if (roundRobinGroupsCount) {
-    const increment = Math.min(roundRobinGroupsCount, drawSize);
-    const seedBlocks2 = [];
-    let position = 1;
-    generateRange(0, increment).forEach(() => {
-      seedBlocks2.push([position]);
-      position++;
+function addScheduleItem(params) {
+  const {
+    participantMap,
+    participantId,
+    matchUpStatus,
+    roundPosition,
+    structureId,
+    matchUpType,
+    roundNumber,
+    matchUpId,
+    potential,
+    schedule,
+    drawId,
+    score
+  } = params;
+  if (!schedule || !Object.keys(schedule).length)
+    return;
+  const ignoreMatchUp = matchUpStatus === BYE;
+  if (!ignoreMatchUp) {
+    participantMap[participantId].scheduleItems.push({
+      ...schedule,
+      scheduledDate: extractDate(schedule?.scheduledDate),
+      scheduledTime: extractTime(schedule?.scheduledTime),
+      scoreHasValue: scoreHasValue({ score }),
+      matchUpStatus,
+      roundPosition,
+      structureId,
+      matchUpType,
+      roundNumber,
+      matchUpId,
+      potential,
+      drawId
     });
-    while (position < drawSize) {
-      const range2 = generateRange(position, position + increment);
-      position += increment;
-      seedBlocks2.push(range2);
+  }
+}
+
+function addStructureParticipation({
+  finishingPositionRange: matchUpFinishingPositionRanges = {},
+  participantMap,
+  finishingRound,
+  participantWon,
+  matchUpStatus,
+  participantId,
+  stageSequence,
+  roundNumber,
+  structureId,
+  matchUpId,
+  drawId,
+  stage
+}) {
+  const participantAggregator = participantMap[participantId];
+  const diff = (range) => Math.abs(range[0] - range[1]);
+  if (!participantAggregator.structureParticipation[structureId]) {
+    participantAggregator.structureParticipation[structureId] = {
+      rankingStage: stage,
+      walkoverWinCount: 0,
+      defaultWinCount: 0,
+      stageSequence,
+      winCount: 0,
+      structureId,
+      drawId
+    };
+  }
+  const structureParticipation = participantAggregator.structureParticipation[structureId];
+  const { winner, loser } = matchUpFinishingPositionRanges;
+  const finishingPositionRange = participantWon ? winner : loser;
+  if (participantWon) {
+    structureParticipation.winCount += 1;
+    if (matchUpStatus === WALKOVER$1) {
+      structureParticipation.walkoverWinCount += 1;
+    }
+    if (matchUpStatus === DEFAULTED) {
+      structureParticipation.defaultWinCount += 1;
     }
-    return { ...SUCCESS, seedBlocks: seedBlocks2 };
   }
-  const range = generateRange(1, drawSize + 1);
-  const positions = [];
-  let chunkSize = drawSize / 2;
-  while (chunkSize > 1) {
-    const chunks = chunkArray(range, chunkSize);
-    const chunksCount = chunks.length;
-    chunks.forEach((chunk, i) => {
-      let candidate;
-      const top = i < chunksCount / 2;
-      const isEven = i % 2 === 0;
-      const first = chunk[0];
-      const last = chunk[chunk.length - 1];
-      if (cluster && chunksCount > 4) {
-        if (chunksCount === 8) {
-          candidate = top ? last : first;
-        } else {
-          candidate = isEven ? first : last;
-        }
-      } else {
-        candidate = top ? first : last;
-      }
-      if (!overlap(chunk, positions)) {
-        positions.push(candidate);
-      }
-    });
-    chunkSize = chunkSize / 2;
+  if (finishingPositionRange && (!structureParticipation.finishingPositionRange || diff(finishingPositionRange) < diff(structureParticipation.finishingPositionRange))) {
+    structureParticipation.finishingPositionRange = finishingPositionRange;
   }
-  const remainingPositions = range.filter(
-    (position) => !positions.includes(position)
-  );
-  while (remainingPositions.length) {
-    if (remainingPositions.length % 2 === 0) {
-      positions.push(remainingPositions.pop());
-    } else {
-      positions.push(remainingPositions.shift());
+  if (finishingRound) {
+    if (!structureParticipation.finishingRound || finishingRound < structureParticipation.finishingRound) {
+      structureParticipation.finishingMatchUpId = matchUpId;
+      structureParticipation.finishingRound = finishingRound;
+      structureParticipation.roundNumber = roundNumber;
+    }
+    if (finishingRound === 1) {
+      structureParticipation.participantWon = participantWon;
     }
   }
-  const seedBlockSizes = generateRange(0, 20).map((x) => Math.pow(2, x));
-  seedBlockSizes.unshift(1);
-  const iterations = seedBlockSizes.indexOf(drawSize);
-  let sum = 0;
-  const seedBlocks = [];
-  generateRange(0, iterations).forEach((i) => {
-    seedBlocks.push(positions.slice(sum, sum + seedBlockSizes[i]));
-    sum += seedBlockSizes[i];
-  });
-  return { ...SUCCESS, seedBlocks };
 }
-function getSeedGroups({
-  roundRobinGroupsCount,
-  drawSize
-}) {
-  const stack = "getSeedGroups";
-  if (!isConvertableInteger(drawSize))
-    return {
-      seedGroups: void 0,
-      ...decorateResult({
-        result: { error: INVALID_VALUES },
-        context: { drawSize },
-        stack
-      })
+
+function processSides(params) {
+  const {
+    withScheduleTimes,
+    scheduleAnalysis,
+    withTeamMatchUps,
+    participantMap,
+    withOpponents,
+    withMatchUps,
+    withEvents,
+    withDraws,
+    finishingPositionRange,
+    finishingRound,
+    matchUpStatus,
+    stageSequence,
+    roundNumber,
+    structureId,
+    score,
+    stage,
+    withRankingProfile,
+    tieWinningSide,
+    roundPosition,
+    matchUpTieId,
+    matchUpSides,
+    collectionId,
+    matchUpType,
+    winningSide,
+    matchUpId,
+    schedule,
+    eventId,
+    drawId,
+    sides
+  } = params;
+  const opponents = withOpponents && sides?.length === 2 && Object.assign(
+    {},
+    ...sides.map(({ sideNumber }, i) => {
+      const opponentParticipantId = sides[1 - i].participantId;
+      return sideNumber && {
+        [sideNumber]: opponentParticipantId
+      };
+    }).filter(Boolean)
+  );
+  for (const side of sides) {
+    const { participantId, sideNumber, bye } = side;
+    if (bye)
+      continue;
+    const participantWon = winningSide === sideNumber;
+    const getOpponentInfo = (opponentParticipantId) => {
+      const opponent = participantMap[opponentParticipantId]?.participant;
+      const participantType = opponent?.participantType;
+      const info = [
+        {
+          participantId: opponentParticipantId,
+          participantType
+        }
+      ];
+      if (participantType !== TEAM_PARTICIPANT) {
+        for (const participantId2 of opponent?.individualParticipantIds || []) {
+          const participant = participantMap[participantId2]?.participant;
+          info.push({
+            participantType: participant?.participantType,
+            participantId: participantId2
+          });
+        }
+      }
+      return info;
     };
-  if (roundRobinGroupsCount) {
-    if (!isConvertableInteger(roundRobinGroupsCount))
-      return {
-        seedGroups: void 0,
-        ...decorateResult({
-          context: { roundRobinGroupsCount },
-          result: { error: INVALID_VALUES },
-          stack
-        })
+    const addMatchUp = (participantId2, opponentParticipantId) => {
+      if (withMatchUps) {
+        participantMap[participantId2].matchUps[matchUpId] = {
+          participantWon,
+          matchUpType,
+          structureId,
+          sideNumber,
+          matchUpId,
+          eventId,
+          drawId,
+          stage
+        };
+        if (withOpponents) {
+          const opponentParticipantInfo = getOpponentInfo(
+            opponentParticipantId
+          );
+          participantMap[participantId2].matchUps[matchUpId].opponentParticipantInfo = opponentParticipantInfo;
+        }
+        if (collectionId) {
+          participantMap[participantId2].matchUps[matchUpId].collectionId = collectionId;
+        }
+      }
+      if (withOpponents && opponentParticipantId) {
+        participantMap[participantId2].opponents[opponentParticipantId] = {
+          participantId: opponentParticipantId,
+          matchUpId,
+          eventId,
+          drawId
+        };
+      }
+      if (withRankingProfile) {
+        addStructureParticipation({
+          finishingPositionRange,
+          participantMap,
+          participantWon,
+          finishingRound,
+          matchUpStatus,
+          participantId: participantId2,
+          stageSequence,
+          roundNumber,
+          structureId,
+          matchUpId,
+          drawId,
+          stage
+        });
+      }
+      if (scheduleAnalysis || withScheduleTimes) {
+        addScheduleItem({
+          participantMap,
+          participantId: participantId2,
+          matchUpStatus,
+          roundPosition,
+          matchUpType,
+          roundNumber,
+          structureId,
+          matchUpId,
+          schedule,
+          drawId,
+          score
+        });
+      }
+    };
+    const addPartner = ({ participant, partnerParticipantId }) => {
+      const addPartnerParticiapntId = (element, partnerParticipantId2) => {
+        if (element) {
+          if (!element.partnerParticipantIds)
+            element.partnerParticipantIds = [];
+          if (!element.partnerParticipantIds.includes(partnerParticipantId2))
+            element.partnerParticipantIds.push(partnerParticipantId2);
+        }
       };
-    let seedNumber = 1;
-    const roundsCount = Math.floor(drawSize / roundRobinGroupsCount);
-    const seedGroups = generateRange(0, roundsCount).map(() => {
-      const seedNumbers = generateRange(
-        seedNumber,
-        seedNumber + roundRobinGroupsCount
-      );
-      seedNumber += roundRobinGroupsCount;
-      return seedNumbers;
-    });
-    return { seedGroups };
-  } else {
-    const { seedBlocks } = getSeedBlocks({
-      participantsCount: drawSize,
-      roundRobinGroupsCount
-    });
-    let seedNumber = 0;
-    const seedGroups = (seedBlocks || []).map(
-      (seedBlock) => (seedBlock || []).map(() => {
-        seedNumber += 1;
-        return seedNumber;
-      })
-    );
-    return { seedGroups };
+      if (withDraws)
+        addPartnerParticiapntId(
+          participant?.draws?.[drawId],
+          partnerParticipantId
+        );
+      if (withEvents) {
+        addPartnerParticiapntId(
+          participant?.events?.[eventId],
+          partnerParticipantId
+        );
+      }
+      if (withMatchUps) {
+        addPartnerParticiapntId(
+          participant?.matchUps?.[matchUpId],
+          partnerParticipantId
+        );
+      }
+    };
+    if (participantId && participantMap[participantId]) {
+      const opponentParticipantId = opponents?.[sideNumber];
+      addMatchUp(participantId, opponentParticipantId);
+      const isPair = participantMap[participantId]?.participant.participantType === PAIR;
+      const individualParticipantIds = participantMap[participantId]?.participant.individualParticipantIds || [];
+      if (matchUpTieId) {
+        if (withTeamMatchUps) {
+          const addTeamMatchUp = (participantId2) => participantMap[participantId2].matchUps[matchUpTieId] = {
+            participantWon: tieWinningSide === sideNumber,
+            matchUpType: TypeEnum.Team,
+            matchUpId: matchUpTieId,
+            sideNumber
+          };
+          addTeamMatchUp(participantId);
+          individualParticipantIds.forEach(addTeamMatchUp);
+        }
+        if (withDraws && !participantMap[participantId].draws[drawId]) {
+          const teamParticipantId = matchUpSides.find(
+            (s) => s.sideNumber === sideNumber
+          )?.participant?.participantId;
+          const teamEntryStatus = participantMap[teamParticipantId]?.draws?.[drawId]?.entryStatus;
+          const addDrawData = (participantId2) => participantMap[participantId2].draws[drawId] = {
+            entryStatus: teamEntryStatus,
+            // add positions played in lineUp collections
+            eventId,
+            drawId
+          };
+          addDrawData(participantId);
+          individualParticipantIds.forEach(addDrawData);
+        }
+      }
+      if (isPair) {
+        individualParticipantIds.forEach(
+          (participantId2) => participantMap[participantId2] && addMatchUp(participantId2, opponentParticipantId)
+        );
+        individualParticipantIds.forEach((participantId2, i) => {
+          const partnerParticipantId = individualParticipantIds[1 - i];
+          const participant = participantMap[participantId2];
+          participant && addPartner({ participant, partnerParticipantId });
+        });
+        if (withEvents && matchUpSides) {
+          const teamParticipantId = matchUpSides.find(
+            (s) => s.sideNumber === sideNumber
+          )?.participant?.participantId;
+          if (teamParticipantId) {
+            const teamEntry = participantMap[teamParticipantId]?.events[eventId];
+            if (teamEntry) {
+              participantMap[participantId].events[eventId] = { ...teamEntry };
+              individualParticipantIds.forEach(
+                (individualParticiapntId) => participantMap[individualParticiapntId].events[eventId] = {
+                  ...teamEntry
+                }
+              );
+            } else {
+              console.log("Missing teamEntry", { eventId, teamParticipantId });
+            }
+          }
+        }
+      }
+      if (winningSide) {
+        const processParticipantId = (id) => {
+          if (participantWon) {
+            participantMap[id].counters[matchUpType].wins += 1;
+            participantMap[id].counters.wins += 1;
+            if (matchUpStatus === WALKOVER$1) {
+              participantMap[id].counters[matchUpType].walkoverWins += 1;
+              participantMap[id].counters.walkoverWins += 1;
+            }
+            if (matchUpStatus === DEFAULTED) {
+              participantMap[id].counters[matchUpType].defaultWins += 1;
+              participantMap[id].counters.defaultWins += 1;
+            }
+          } else {
+            participantMap[id].counters[matchUpType].losses += 1;
+            participantMap[id].counters.losses += 1;
+            if (matchUpStatus === WALKOVER$1) {
+              participantMap[id].counters[matchUpType].walkovers += 1;
+              participantMap[id].counters.walkovers += 1;
+            }
+            if (matchUpStatus === DEFAULTED) {
+              participantMap[id].counters[matchUpType].defaults += 1;
+              participantMap[id].counters.defaults += 1;
+            }
+          }
+        };
+        processParticipantId(participantId);
+        individualParticipantIds.forEach(processParticipantId);
+      }
+    }
   }
 }
 
-function getValidSeedBlocks({
-  provisionalPositioning,
-  appliedPolicies,
-  drawDefinition,
-  allPositions,
-  structure
-}) {
-  let validSeedBlocks = [];
-  if (!structure)
-    return { error: MISSING_STRUCTURE };
-  const { matchUps, roundMatchUps } = getAllStructureMatchUps({
-    matchUpFilters: { roundNumbers: [1] },
-    provisionalPositioning,
-    structure
-  });
-  const { seedAssignments } = getStructureSeedAssignments({
-    provisionalPositioning,
-    drawDefinition,
-    structure
-  });
-  const { positionAssignments } = structureAssignedDrawPositions({ structure });
-  const positionsCount = positionAssignments?.length;
-  const seedsCount = seedAssignments?.length ?? 0;
-  let allDrawPositions = [];
-  const roundNumbers = Object.keys(roundMatchUps).map((n) => parseInt(n)).sort((a, b) => a - b);
-  const uniqueDrawPositionsByRound = roundNumbers.map((roundNumber) => {
-    const roundDrawPositions = roundMatchUps[roundNumber].map((matchUp) => matchUp.drawPositions).flat(Infinity).filter(Boolean);
-    const uniqueRoundDrawPositions = roundDrawPositions.filter(
-      (drawPosition) => !allDrawPositions.includes(drawPosition)
+function getParticipantEntries(params) {
+  const {
+    participantFilters,
+    convertExtensions,
+    policyDefinitions,
+    tournamentRecord,
+    usePublishState,
+    contextProfile,
+    participantMap,
+    withPotentialMatchUps,
+    withRankingProfile,
+    withScheduleTimes,
+    withScheduleItems,
+    scheduleAnalysis,
+    withTeamMatchUps,
+    withStatistics,
+    withOpponents,
+    withMatchUps,
+    withSeeding,
+    withEvents,
+    withDraws
+  } = params;
+  if (withScheduleItems)
+    console.log({ withScheduleItems });
+  const targetParticipantIds = participantFilters?.participantIds;
+  const getRelevantParticipantIds = (participantId) => {
+    const relevantParticipantIds = [participantId];
+    relevantParticipantIds.push(participantId);
+    participantMap[participantId]?.participant.individualParticipantIds?.forEach(
+      (individualParticiapntId) => relevantParticipantIds.push(individualParticiapntId)
     );
-    allDrawPositions = allDrawPositions.concat(...roundDrawPositions);
-    return uniqueRoundDrawPositions;
-  }).filter((f) => f.length).reverse();
-  const firstRoundDrawPositions = uniqueDrawPositionsByRound.pop();
-  const firstRoundDrawPositionOffset = firstRoundDrawPositions && Math.min(...firstRoundDrawPositions) - 1 || 0;
-  const seedingProfile = appliedPolicies?.seeding?.seedingProfile;
-  const baseDrawSize = firstRoundDrawPositions?.length || 0;
-  const seedRangeDrawPositionBlocks = uniqueDrawPositionsByRound.filter(
-    (block) => block.filter((drawPosition) => drawPosition <= seedsCount).length
-  );
-  const { stage, structureType, roundLimit } = structure;
-  const isContainer = structureType === CONTAINER;
-  const isFeedIn = !isContainer && uniqueDrawPositionsByRound?.length;
-  const qualifyingBlocks = !isContainer && stage === QUALIFYING && roundLimit;
-  const fedSeedBlockPositions = seedRangeDrawPositionBlocks.flat(Infinity);
-  const fedSeedNumberOffset = isFeedIn ? fedSeedBlockPositions?.length : 0;
-  const countLimit = allPositions ? positionsCount : seedsCount;
-  const isLuckyStructure = isLucky({
-    drawDefinition,
-    structure,
-    matchUps
-  });
-  const firstRoundSeedsCount = isLuckyStructure ? 0 : !isFeedIn && countLimit || countLimit && fedSeedBlockPositions.length < countLimit && countLimit - fedSeedBlockPositions.length || 0;
-  if (qualifyingBlocks) {
-    const seedingBlocksCount = structure?.matchUps ? structure.matchUps.filter(
-      ({ roundNumber }) => roundNumber === structure.roundLimit
-    ).length : 0;
-    const chunkSize = firstRoundDrawPositions.length / seedingBlocksCount;
-    if (isFeedIn) ; else {
-      const positioning = getSeedPattern(seedingProfile);
-      const drawPositionChunks = chunkArray(firstRoundDrawPositions, chunkSize);
-      let groupNumber = 1;
-      const seedGroups = generateRange(0, drawPositionChunks[0].length).map(
-        () => {
-          const seedNumbers = generateRange(
-            groupNumber,
-            groupNumber + drawPositionChunks.length
-          );
-          groupNumber += drawPositionChunks.length;
-          return seedNumbers;
+    return relevantParticipantIds.some(
+      (obj) => !targetParticipantIds?.length || targetParticipantIds.includes(obj.relevantParticipantId)
+    ) ? relevantParticipantIds : [];
+  };
+  const withOpts = {
+    withMatchUps: withMatchUps || withRankingProfile,
+    withEvents: withEvents || withRankingProfile,
+    withDraws: withDraws || withRankingProfile,
+    withPotentialMatchUps,
+    withRankingProfile,
+    withScheduleTimes,
+    scheduleAnalysis,
+    withTeamMatchUps,
+    withStatistics,
+    participantMap,
+    withOpponents,
+    withSeeding
+  };
+  const participantIdsWithConflicts = [];
+  const mappedMatchUps = {};
+  const matchUps = [];
+  const eventsPublishStatuses = {};
+  const derivedEventInfo = {};
+  const derivedDrawInfo = {};
+  const getRanking = ({ eventType, scaleNames, participantId }) => participantMap[participantId].participant?.rankings?.[eventType]?.find(
+    (ranking) => scaleNames.includes(ranking.scaleName)
+  )?.scaleValue;
+  for (const event of tournamentRecord?.events || []) {
+    if (participantFilters?.eventIds && !participantFilters.eventIds.includes(event.eventId))
+      continue;
+    const {
+      drawDefinitions = [],
+      extensions = [],
+      eventType,
+      eventName,
+      category,
+      entries,
+      eventId,
+      gender
+    } = event;
+    const { flightProfile } = getFlightProfile({ event });
+    const flights = flightProfile?.flights ?? [];
+    const publishStatuses = getEventPublishStatuses({ event });
+    const publishedSeeding = publishStatuses?.publishedSeeding;
+    if (publishStatuses)
+      eventsPublishStatuses[eventId] = publishStatuses;
+    if (withEvents || withSeeding || withRankingProfile) {
+      const extensionConversions = convertExtensions ? Object.assign({}, ...extensionsToAttributes(extensions)) : {};
+      derivedEventInfo[eventId] = {
+        ...extensionConversions,
+        eventName,
+        eventType,
+        category,
+        eventId,
+        gender
+      };
+      const scaleNames = [
+        category?.categoryName,
+        category?.ageCategoryCode
+      ].filter(Boolean);
+      for (const entry of entries) {
+        const { participantId } = entry;
+        if (!participantId || !participantMap[participantId])
+          continue;
+        const ranking = getRanking({ eventType, scaleNames, participantId });
+        let seedAssignments, seedValue;
+        if (withSeeding) {
+          const participant = participantMap[participantId].participant;
+          ({ seedAssignments, seedValue } = getEventSeedAssignments({
+            publishedSeeding,
+            usePublishState,
+            withSeeding,
+            participant,
+            event
+          }));
         }
-      );
-      ({ validSeedBlocks } = getSeedBlockPattern({
-        drawPositionBlocks: drawPositionChunks,
-        positioning,
-        seedGroups
-      }));
+        const addEventEntry = (id) => {
+          if (participantMap[id]?.events?.[eventId])
+            return;
+          const participant = participantMap[id];
+          processEventEntry({
+            extensionConversions,
+            seedAssignments,
+            participant,
+            withSeeding,
+            seedValue,
+            eventId,
+            ranking,
+            entry
+          });
+        };
+        addEventEntry(participantId);
+        const individualParticipantIds = participantMap[participantId].participant.individualParticipantIds || [];
+        individualParticipantIds.forEach(addEventEntry);
+      }
+    }
+    const eventPublishedSeeding = eventsPublishStatuses?.[eventId]?.publishedSeeding;
+    if (withDraws || withRankingProfile || withSeeding) {
+      const getSeedingMap = (assignments) => assignments ? Object.assign(
+        {},
+        ...assignments.map(
+          ({ participantId, seedValue, seedNumber }) => ({
+            [participantId]: { seedValue, seedNumber }
+          })
+        )
+      ) : void 0;
+      const drawIds = unique([
+        ...drawDefinitions.map(extractAttributes("drawId")),
+        ...flights.map(extractAttributes("drawId"))
+      ]);
+      for (const drawId of drawIds) {
+        const drawDefinition = drawDefinitions.find(
+          (drawDefinition2) => drawDefinition2.drawId === drawId
+        );
+        const flight = flights?.find((flight2) => flight2.drawId === drawId);
+        const entries2 = drawDefinition?.entries || flight?.drawEntries;
+        const {
+          structures = [],
+          drawOrder,
+          drawName,
+          drawType
+        } = drawDefinition ?? {};
+        const flightNumber = flight?.flightNumber;
+        const scaleNames = [
+          category?.categoryName,
+          category?.ageCategoryCode
+        ].filter(Boolean);
+        const orderedStructureIds = (drawDefinition?.structures || []).sort((a, b) => structureSort(a, b)).map(({ structureId, structures: structures2 }) => {
+          return [
+            structureId,
+            ...(structures2 || []).map(({ structureId: structureId2 }) => structureId2)
+          ];
+        }).flat(Infinity);
+        let qualifyingPositionAssignments, qualifyingSeedAssignments, mainPositionAssignments, mainSeedAssignments, drawSize = 0;
+        const assignedParticipantIds = structures.filter(
+          ({ stage, stageSequence }) => stage === MAIN && stageSequence === 1 || stage === QUALIFYING
+        ).flatMap((structure) => {
+          const { seedAssignments, stageSequence, stage } = structure;
+          const { positionAssignments } = getPositionAssignments({
+            structure
+          });
+          if (stage === MAIN) {
+            drawSize = positionAssignments?.length ?? 0;
+            mainPositionAssignments = positionAssignments;
+            mainSeedAssignments = seedAssignments;
+          } else if (stageSequence === 1) {
+            qualifyingPositionAssignments = positionAssignments;
+            qualifyingSeedAssignments = seedAssignments;
+          }
+          return positionAssignments;
+        }).map(({ participantId }) => participantId).filter(Boolean);
+        const mainSeedingMap = getSeedingMap(mainSeedAssignments);
+        const qualifyingSeedingMap = getSeedingMap(qualifyingSeedAssignments);
+        const relevantEntries = !drawDefinition ? entries2 : entries2.filter(
+          ({ participantId }) => assignedParticipantIds.includes(participantId)
+        );
+        const seedingPublished = !usePublishState || eventPublishedSeeding?.published && (eventPublishedSeeding?.drawIds?.length === 0 || eventPublishedSeeding?.drawIds?.includes(drawId));
+        for (const entry of relevantEntries) {
+          const { entryStatus, entryStage, entryPosition, participantId } = entry;
+          const ranking = getRanking({
+            participantId,
+            scaleNames,
+            eventType
+          });
+          const addDrawEntry = (id) => {
+            if (participantMap[id].draws?.[drawId])
+              return;
+            const includeSeeding = withSeeding && seedingPublished;
+            const seedAssignments = includeSeeding ? {} : void 0;
+            const mainSeeding = includeSeeding ? mainSeedingMap?.[participantId]?.seedValue || mainSeedingMap?.[participantId]?.seedNumber : void 0;
+            const mainSeedingAssignments = mainSeeding ? mainSeedingMap?.[participantId] : void 0;
+            const qualifyingSeeding = includeSeeding ? qualifyingSeedingMap?.[participantId]?.seedValue || qualifyingSeedingMap?.[participantId]?.seedNumber : void 0;
+            const qualifyingSeedingAssignments = qualifyingSeeding ? qualifyingSeedingMap?.[participantId] : void 0;
+            if (seedAssignments && mainSeeding)
+              seedAssignments[MAIN] = mainSeedingAssignments;
+            if (seedAssignments && qualifyingSeeding)
+              seedAssignments[QUALIFYING] = qualifyingSeedingAssignments;
+            const seedValue = mainSeeding || qualifyingSeeding;
+            if (seedValue) {
+              if (!participantMap[id].participant.seedings[eventType])
+                participantMap[id].participant.seedings[eventType] = [];
+              if (mainSeedingAssignments) {
+                participantMap[id].participant.seedings[eventType].push({
+                  ...mainSeedingAssignments,
+                  scaleName: drawId
+                });
+              }
+              if (qualifyingSeedingAssignments) {
+                participantMap[id].participant.seedings[eventType].push({
+                  ...qualifyingSeedingAssignments,
+                  scaleName: drawId
+                });
+              }
+              if (seedAssignments) {
+                if (!participantMap[id].events[eventId].seedAssignments)
+                  participantMap[id].events[eventId].seedAssignments = {};
+                Object.keys(seedAssignments).forEach(
+                  (stage) => participantMap[id].events[eventId].seedAssignments[stage] = seedAssignments[stage]
+                );
+              }
+            }
+            if ((withEvents || withRankingProfile) && participantMap[id] && eventId) {
+              if (!participantMap[id].events[eventId])
+                participantMap[id].events[eventId] = {};
+              if (includeSeeding) {
+                participantMap[id].events[eventId].seedValue = seedValue;
+              } else if (participantMap[id].events[eventId].seedValue) {
+                participantMap[id].events[eventId].seedValue = void 0;
+              }
+            }
+            if (withDraws || withRankingProfile) {
+              participantMap[id].draws[drawId] = definedAttributes(
+                {
+                  seedAssignments,
+                  entryPosition,
+                  entryStatus,
+                  entryStage,
+                  eventId,
+                  ranking,
+                  drawId
+                },
+                false,
+                false,
+                true
+              );
+            }
+          };
+          if (![UNGROUPED, UNPAIRED].includes(entryStatus)) {
+            addDrawEntry(participantId);
+            const individualParticipantIds = participantMap[participantId].participant.individualParticipantIds || [];
+            individualParticipantIds?.forEach(addDrawEntry);
+          }
+        }
+        derivedDrawInfo[drawId] = {
+          qualifyingPositionAssignments,
+          qualifyingSeedAssignments,
+          mainPositionAssignments,
+          qualifyingSeedingMap,
+          mainSeedAssignments,
+          orderedStructureIds,
+          mainSeedingMap,
+          flightNumber,
+          drawOrder,
+          drawName,
+          drawType,
+          drawSize,
+          drawId
+          // qualifyingDrawSize,
+        };
+      }
+    }
+    if (withRankingProfile || scheduleAnalysis || withTeamMatchUps || withStatistics || withOpponents || withMatchUps || withDraws) {
+      const nextMatchUps = !!scheduleAnalysis || withPotentialMatchUps;
+      const eventMatchUps = allEventMatchUps({
+        afterRecoveryTimes: !!scheduleAnalysis,
+        policyDefinitions,
+        tournamentRecord,
+        inContext: true,
+        contextProfile,
+        participantMap,
+        nextMatchUps,
+        event
+      })?.matchUps ?? [];
+      for (const matchUp of eventMatchUps) {
+        const {
+          finishingPositionRange,
+          potentialParticipants,
+          tieMatchUps = [],
+          sides = [],
+          winningSide,
+          matchUpType,
+          matchUpId,
+          eventId: eventId2,
+          drawId,
+          collectionId,
+          stageSequence,
+          finishingRound,
+          matchUpStatus,
+          roundPosition,
+          roundNumber,
+          structureId,
+          schedule,
+          score,
+          stage
+        } = matchUp;
+        mappedMatchUps[matchUpId] = matchUp;
+        const baseAttrs = {
+          finishingPositionRange,
+          finishingRound,
+          stageSequence,
+          roundPosition,
+          collectionId,
+          roundNumber,
+          structureId,
+          schedule,
+          eventId: eventId2,
+          drawId,
+          score,
+          stage
+        };
+        processSides({
+          ...baseAttrs,
+          ...withOpts,
+          matchUpStatus,
+          winningSide,
+          matchUpType,
+          matchUpId,
+          sides
+        });
+        for (const tieMatchUp of tieMatchUps) {
+          const {
+            winningSide: tieMatchUpWinningSide,
+            sides: tieMatchUpSides = [],
+            matchUpId: tieMatchUpId,
+            matchUpStatus: matchUpStatus2,
+            matchUpType: matchUpType2
+          } = tieMatchUp;
+          processSides({
+            ...baseAttrs,
+            ...withOpts,
+            winningSide: tieMatchUpWinningSide,
+            tieWinningSide: winningSide,
+            matchUpTieId: matchUpId,
+            matchUpId: tieMatchUpId,
+            sides: tieMatchUpSides,
+            matchUpSides: sides,
+            matchUpStatus: matchUpStatus2,
+            matchUpType: matchUpType2
+          });
+        }
+        if (Array.isArray(potentialParticipants) && (nextMatchUps || !!scheduleAnalysis || withScheduleTimes)) {
+          const potentialParticipantIds = potentialParticipants.flat().map(extractAttributes("participantId")).filter(Boolean);
+          potentialParticipantIds?.forEach((participantId) => {
+            const relevantParticipantIds = getRelevantParticipantIds(participantId);
+            relevantParticipantIds?.forEach((relevantParticipantId) => {
+              if (!participantMap[relevantParticipantId]) {
+                return;
+              }
+              participantMap[relevantParticipantId].potentialMatchUps[matchUpId] = definedAttributes({
+                tournamentId: tournamentRecord?.tournamentId,
+                matchUpId,
+                eventId: eventId2,
+                drawId
+              });
+            });
+            if (!!scheduleAnalysis || withScheduleTimes) {
+              addScheduleItem({
+                potential: true,
+                participantMap,
+                participantId,
+                matchUpStatus,
+                roundPosition,
+                structureId,
+                matchUpType,
+                roundNumber,
+                matchUpId,
+                schedule,
+                drawId,
+                score
+              });
+            }
+          });
+        }
+      }
+      matchUps.push(...eventMatchUps);
     }
-  } else if (isContainer) {
-    const result = getContainerBlocks({
-      seedingProfile,
-      structure
-    });
-    ({ validSeedBlocks } = result);
-  } else if (isFeedIn) {
-    validSeedBlocks = seedRangeDrawPositionBlocks.map((block) => {
-      return { seedNumbers: block, drawPositions: block };
-    });
-  } else if (isLuckyStructure) {
-    const blocks = chunkArray(firstRoundDrawPositions, 2).map((block, i) => ({
-      drawPositions: [block[0]],
-      seedNumbers: [i + 1]
-    }));
-    blocks.forEach((block) => validSeedBlocks.push(block));
-  }
-  if (!isContainer && !isLuckyStructure && !qualifyingBlocks) {
-    const { blocks } = constructPower2Blocks({
-      drawPositionOffset: firstRoundDrawPositionOffset,
-      seedNumberOffset: fedSeedNumberOffset,
-      seedCountGoal: firstRoundSeedsCount,
-      seedingProfile,
-      baseDrawSize
-    });
-    blocks.forEach((block) => validSeedBlocks.push(block));
   }
-  const seedDrawPositions = validSeedBlocks.flatMap(
-    (seedBlock) => seedBlock.drawPositions
-  );
-  const validSeedPositions = seedDrawPositions.reduce(
-    (result, drawPosition) => {
-      return firstRoundDrawPositions?.includes(drawPosition) && result;
-    },
-    true
-  );
-  if (!isLuckyStructure && !isFeedIn && !isContainer && !validSeedPositions) {
-    return {
-      error: INVALID_SEED_POSITION,
-      validSeedBlocks: [],
-      isContainer,
-      isFeedIn
-    };
+  if (withStatistics || withRankingProfile || !!scheduleAnalysis) {
+    const aggregators = Object.values(participantMap);
+    for (const participantAggregator of aggregators) {
+      const {
+        wins,
+        losses,
+        [SINGLES$1]: { wins: singlesWins, losses: singlesLosses },
+        [DOUBLES]: { wins: doublesWins, losses: doublesLosses }
+      } = participantAggregator.counters;
+      const addStatValue = (statCode, wins2, losses2) => {
+        const denominator = wins2 + losses2;
+        const numerator = wins2;
+        const statValue = denominator && numerator / denominator;
+        participantAggregator.statistics[statCode] = {
+          denominator,
+          numerator,
+          statValue,
+          statCode
+        };
+      };
+      if (withStatistics) {
+        addStatValue(WIN_RATIO, wins, losses);
+        addStatValue(`${WIN_RATIO}.${SINGLES$1}`, singlesWins, singlesLosses);
+        addStatValue(`${WIN_RATIO}.${DOUBLES}`, doublesWins, doublesLosses);
+      }
+      if (withRankingProfile) {
+        const diff = (range = []) => Math.abs(range[0] - range[1]);
+        for (const drawId of Object.keys(participantAggregator.draws)) {
+          const { orderedStructureIds = [], flightNumber } = derivedDrawInfo[drawId] || {};
+          if (participantAggregator.structureParticipation && orderedStructureIds.length) {
+            let finishingPositionRange;
+            let nonQualifyingOrder = 0;
+            const orderedParticipation = orderedStructureIds.map((structureId) => {
+              const participation = participantAggregator.structureParticipation[structureId];
+              if (!participation)
+                return;
+              if (!finishingPositionRange)
+                finishingPositionRange = participation?.finishingPositionRange;
+              if (diff(finishingPositionRange) > diff(participation?.finishingPositionRange))
+                finishingPositionRange = participation?.finishingPositionRange;
+              const notQualifying = participation.stage !== QUALIFYING;
+              if (notQualifying)
+                nonQualifyingOrder += 1;
+              const participationOrder = notQualifying ? nonQualifyingOrder : void 0;
+              return definedAttributes({
+                ...participation,
+                participationOrder,
+                flightNumber
+              });
+            }).filter(Boolean);
+            if (participantAggregator.draws[drawId]) {
+              participantAggregator.draws[drawId].finishingPositionRange = finishingPositionRange;
+              participantAggregator.draws[drawId].structureParticipation = orderedParticipation;
+            }
+          }
+        }
+      }
+      if (scheduleAnalysis) {
+        const scheduledMinutesDifference = isObject(scheduleAnalysis) ? scheduleAnalysis.scheduledMinutesDifference : 0;
+        const scheduleItems = participantAggregator.scheduleItems || [];
+        const potentialMatchUps = participantAggregator.potentialMatchUps || {};
+        const dateItems = scheduleItems.reduce((dateItems2, scheduleItem) => {
+          const { scheduledDate, scheduledTime } = scheduleItem;
+          if (!dateItems2[scheduledDate])
+            dateItems2[scheduledDate] = [];
+          if (scheduledTime)
+            dateItems2[scheduledDate].push(scheduleItem);
+          return dateItems2;
+        }, {});
+        Object.values(dateItems).forEach((items) => items.sort(timeSort));
+        for (const scheduleItem of scheduleItems) {
+          const {
+            typeChangeTimeAfterRecovery,
+            timeAfterRecovery,
+            scheduledDate,
+            scheduledTime
+          } = scheduleItem;
+          const scheduleItemsToConsider = dateItems[scheduledDate];
+          const scheduledMinutes = timeStringMinutes(scheduledTime);
+          for (const consideredItem of scheduleItemsToConsider) {
+            const ignoreItem = consideredItem.matchUpId === scheduleItem.matchUpId || [WALKOVER$1, DEFAULTED].includes(consideredItem.matchUpStatus) && !consideredItem.scoreHasValue;
+            if (ignoreItem)
+              continue;
+            const typeChange = scheduleItem.matchUpType !== consideredItem.matchUpType;
+            const notBeforeTime = typeChange ? typeChangeTimeAfterRecovery || timeAfterRecovery : timeAfterRecovery;
+            const sameDraw = scheduleItem.drawId === consideredItem.drawId;
+            const bothPotential = potentialMatchUps[scheduleItem.matchUpId] && potentialMatchUps[consideredItem.matchUpId];
+            const nextMinutes = timeStringMinutes(consideredItem.scheduledTime);
+            const minutesDifference = Math.abs(nextMinutes - scheduledMinutes);
+            const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : timeStringMinutes(notBeforeTime) > timeStringMinutes(consideredItem.scheduledTime);
+            if (timeOverlap && !(bothPotential && sameDraw)) {
+              participantAggregator.scheduleConflicts.push({
+                priorScheduledMatchUpId: consideredItem.matchUpId,
+                matchUpIdWithConflict: scheduleItem.matchUpId
+              });
+            }
+          }
+        }
+        const pid = participantAggregator.participant.participantId;
+        if (participantAggregator.scheduleConflicts.length) {
+          participantIdsWithConflicts.push(pid);
+        }
+        participantMap[pid].scheduleConflicts = participantAggregator.scheduleConflicts;
+      }
+    }
   }
   return {
-    isLuckyStructure,
-    validSeedBlocks,
-    isContainer,
-    isFeedIn
+    participantIdsWithConflicts,
+    eventsPublishStatuses,
+    derivedEventInfo,
+    derivedDrawInfo,
+    mappedMatchUps,
+    participantMap,
+    matchUps
   };
 }
-function getContainerBlocks({ seedingProfile, structure }) {
-  const containedStructures = structure.structures || [];
-  const roundRobinGroupsCount = containedStructures.length;
-  const positionAssignments = getPositionAssignments({
-    structure
-  })?.positionAssignments;
-  const positioning = getSeedPattern(seedingProfile);
-  const drawSize = positionAssignments?.length ?? 0;
-  const { seedGroups } = getSeedGroups({
-    roundRobinGroupsCount,
-    drawSize
+
+function getParticipants(params) {
+  const {
+    withIndividualParticipants,
+    participantFilters = {},
+    withPotentialMatchUps,
+    withRankingProfile,
+    convertExtensions,
+    policyDefinitions,
+    withScheduleItems,
+    tournamentRecord,
+    scheduleAnalysis,
+    withSignInStatus,
+    withTeamMatchUps,
+    withScaleValues,
+    usePublishState,
+    contextProfile,
+    withStatistics,
+    withOpponents,
+    withMatchUps,
+    internalUse,
+    withSeeding,
+    withEvents,
+    withDraws,
+    withISO2,
+    withIOC
+  } = params;
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (withMatchUps || withRankingProfile) {
+    getMatchUpDependencies({ tournamentRecord });
+  }
+  let { participantMap } = getParticipantMap({
+    withIndividualParticipants,
+    convertExtensions,
+    tournamentRecord,
+    withSignInStatus,
+    withScaleValues,
+    internalUse,
+    withISO2,
+    withIOC
   });
-  const drawPositionBlocks = containedStructures.map(
-    (containedStructure) => getPositionAssignments({
-      structure: containedStructure
-    }).positionAssignments?.map((assignment) => assignment.drawPosition)
-  );
-  return getSeedBlockPattern({
-    drawPositionBlocks,
-    positioning,
-    seedGroups
+  const entriesResult = getParticipantEntries({
+    withMatchUps: withMatchUps ?? withRankingProfile,
+    withEvents: withEvents ?? withRankingProfile,
+    withDraws: withDraws ?? withRankingProfile,
+    withPotentialMatchUps,
+    participantFilters,
+    withRankingProfile,
+    convertExtensions,
+    withScheduleItems,
+    policyDefinitions,
+    tournamentRecord,
+    scheduleAnalysis,
+    withTeamMatchUps,
+    usePublishState,
+    withStatistics,
+    participantMap,
+    withOpponents,
+    contextProfile,
+    withSeeding
   });
-}
-function getSeedBlockPattern({ positioning, seedGroups, drawPositionBlocks }) {
-  const validSeedBlocks = [];
-  const topDown = (a, b) => a - b;
-  const bottomUp = (a, b) => b - a;
-  const assignedPositions = [];
-  seedGroups.forEach((seedGroup, i) => {
-    if (i && positioning !== WATERFALL) {
-      shuffleArray(seedGroup);
-    }
-    seedGroup.forEach((seedNumber, j) => {
-      const blockIndex = i % 2 ? drawPositionBlocks.length - j - 1 : j;
-      const drawPosition = drawPositionBlocks[blockIndex].sort(i % 2 ? bottomUp : topDown).find((drawPosition2) => !assignedPositions.includes(drawPosition2));
-      assignedPositions.push(drawPosition);
-      validSeedBlocks.push({
-        seedNumbers: [seedNumber],
-        drawPositions: [drawPosition]
-      });
-    });
-  });
-  return { validSeedBlocks };
-}
-function constructPower2Blocks(params) {
-  const {
-    drawPositionOffset = 0,
-    roundRobinGroupsCount,
-    seedNumberOffset = 0,
-    seedingProfile,
-    seedCountGoal,
-    baseDrawSize
-  } = params;
-  let count = 1;
-  const blocks = [];
-  const { seedBlocks } = getSeedBlocks({
-    cluster: getSeedPattern(seedingProfile) === CLUSTER,
-    participantsCount: baseDrawSize,
-    roundRobinGroupsCount
-  });
-  count = 0;
-  for (const seedBlock of seedBlocks) {
-    if (count + 1 > seedCountGoal)
-      break;
-    const drawPositions = seedBlock.map(
-      (drawPosition) => drawPosition + drawPositionOffset
-    );
-    const seedNumbers = getSeeds(count + 1, seedBlock.length).map(
-      (seedNumber) => +seedNumber + seedNumberOffset
-    );
-    count += seedBlock.length;
-    blocks.push({ drawPositions, seedNumbers });
-  }
-  return { blocks };
-  function getSeeds(s, n) {
-    return Array.from(new Array(n), (_, i) => i + s);
-  }
-}
-function isValidSeedPosition({
-  appliedPolicies,
-  drawDefinition,
-  seedBlockInfo,
-  drawPosition,
-  structureId,
-  seedNumber
-}) {
-  const { structure } = findStructure({ drawDefinition, structureId });
-  if (!appliedPolicies) {
-    appliedPolicies = getAppliedPolicies({ drawDefinition }).appliedPolicies;
-  }
-  let validSeedBlocks = seedBlockInfo?.validSeedBlocks;
-  if (!validSeedBlocks && structure) {
-    validSeedBlocks = getValidSeedBlocks({
-      appliedPolicies,
-      drawDefinition,
-      structure
-    })?.validSeedBlocks;
-  }
-  if (appliedPolicies?.seeding?.validSeedPositions?.ignore)
-    return true;
-  if (appliedPolicies?.seeding?.validSeedPositions?.strict) {
-    const targetSeedBlock = validSeedBlocks.find(
-      (seedBlock) => seedBlock.seedNumbers.includes(seedNumber)
-    );
-    const validSeedPositions2 = targetSeedBlock?.drawPositions || [];
-    return validSeedPositions2.includes(drawPosition);
-  }
-  const validSeedPositions = [].concat(
-    ...validSeedBlocks.map((seedBlock) => seedBlock.drawPositions)
-  );
-  return validSeedPositions.includes(drawPosition);
-}
-function getNextSeedBlock(params) {
   const {
-    provisionalPositioning,
-    drawDefinition,
-    seedBlockInfo,
-    structureId,
-    randomize
-  } = params;
-  const { structure } = findStructure({ drawDefinition, structureId });
-  const { seedAssignments } = getStructureSeedAssignments({
-    provisionalPositioning,
-    drawDefinition,
-    structure
-  });
-  const { positionAssignments } = structureAssignedDrawPositions({ structure });
-  const positionsWithParticipants = positionAssignments?.filter(
-    (assignment) => assignment.participantId ?? assignment.bye ?? assignment.qualifier
+    participantIdsWithConflicts,
+    eventsPublishStatuses,
+    derivedEventInfo,
+    derivedDrawInfo,
+    mappedMatchUps
+  } = entriesResult;
+  const matchUps = entriesResult.matchUps;
+  participantMap = entriesResult.participantMap;
+  const nextMatchUps = scheduleAnalysis ?? withPotentialMatchUps;
+  const processedParticipants = Object.values(participantMap).map(
+    ({
+      potentialMatchUps,
+      scheduleConflicts,
+      participant,
+      statistics,
+      opponents,
+      matchUps: matchUps2,
+      events,
+      draws
+    }) => {
+      const participantDraws = Object.values(draws);
+      const participantOpponents = Object.values(opponents);
+      if (withOpponents) {
+        participantDraws?.forEach((draw) => {
+          draw.opponents = participantOpponents.filter(
+            (opponent) => opponent.drawId === draw.drawId
+          );
+        });
+      }
+      return definedAttributes(
+        {
+          ...participant,
+          scheduleConflicts: scheduleAnalysis ? scheduleConflicts : void 0,
+          draws: withDraws || withRankingProfile ? participantDraws : void 0,
+          events: withEvents || withRankingProfile ? Object.values(events) : void 0,
+          matchUps: withMatchUps || withRankingProfile ? Object.values(matchUps2) : void 0,
+          opponents: withOpponents ? participantOpponents : void 0,
+          potentialMatchUps: nextMatchUps ? Object.values(potentialMatchUps) : void 0,
+          statistics: withStatistics ? Object.values(statistics) : void 0
+        },
+        false,
+        false,
+        true
+      );
+    }
   );
-  const assignedDrawPositions = positionsWithParticipants?.map((assignment) => assignment.drawPosition).filter(Boolean);
-  const { appliedPolicies } = getAppliedPolicies({ drawDefinition });
-  const validSeedBlocks = seedBlockInfo?.validSeedBlocks || structure && getValidSeedBlocks({
-    provisionalPositioning,
-    appliedPolicies,
-    drawDefinition,
-    structure
-  })?.validSeedBlocks;
-  const unfilledSeedBlocks = (validSeedBlocks || []).filter((seedBlock) => {
-    const unfilledPositions2 = seedBlock.drawPositions.filter(
-      (drawPosition) => !assignedDrawPositions?.includes(drawPosition)
-    );
-    return unfilledPositions2.length;
+  const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
+  const template = participantAttributes?.participant;
+  const filteredParticipants = filterParticipants({
+    participants: processedParticipants,
+    participantFilters,
+    tournamentRecord
   });
-  const nextSeedBlock = unfilledSeedBlocks[0];
-  const assignedSeedParticipantIds = seedAssignments?.map((assignment) => assignment.participantId).filter(Boolean);
-  const assignedPositionParticipantIds = positionAssignments?.map((assignment) => assignment.participantId).filter(Boolean);
-  const placedSeedParticipantIds = assignedSeedParticipantIds?.filter(
-    (participantId) => assignedPositionParticipantIds?.includes(participantId)
-  );
-  const unplacedSeedIds = assignedSeedParticipantIds?.filter(
-    (participantId) => !assignedPositionParticipantIds?.includes(participantId)
-  );
-  const unplacedSeedAssignments = seedAssignments?.filter(
-    (assignment) => unplacedSeedIds?.includes(assignment.participantId)
-  );
-  const seedsWithoutDrawPositions = seedAssignments?.filter(
-    (assignment) => !assignment.participantId
-  );
-  const seedsLeftToAssign = unplacedSeedAssignments?.length && unplacedSeedAssignments.length > 0 ? unplacedSeedAssignments.length : seedsWithoutDrawPositions?.length ?? 0;
-  const unfilled = seedsLeftToAssign && nextSeedBlock?.drawPositions.filter(
-    (drawPosition) => !assignedDrawPositions?.includes(drawPosition)
-  ) || [];
-  const unfilledPositions = randomize ? shuffleArray(unfilled) : unfilled;
-  const selectedParticipantIds = [];
-  const randomlySelectedUnplacedSeedValueIds = unfilledPositions.map(() => {
-    const assignment = randomlySelectLowestSeedValue(
-      unplacedSeedAssignments,
-      selectedParticipantIds
-    );
-    const participantId = assignment?.participantId;
-    if (participantId)
-      selectedParticipantIds.push(participantId);
-    return participantId;
-  }).filter(Boolean);
-  const placedSeedNumbers = seedAssignments?.filter(
-    (assignment) => placedSeedParticipantIds?.includes(assignment.participantId)
-  ).map((assignment) => assignment.seedNumber);
-  const blockSeedNumbers = nextSeedBlock?.seedNumbers || [];
-  const unplacedSeedNumbers = blockSeedNumbers.filter(
-    (seedNumber) => !placedSeedNumbers?.includes(seedNumber)
-  );
-  const unplacedSeedNumberIds = seedAssignments?.filter(
-    (assignment) => unplacedSeedNumbers.includes(assignment.seedNumber)
-  ).map((assignment) => assignment.participantId);
-  const duplicateSeedNumbers = appliedPolicies?.seeding?.duplicateSeedNumbers;
-  const allowsDuplicateSeedNumbers = duplicateSeedNumbers !== void 0 ? duplicateSeedNumbers : true;
-  const unplacedSeedParticipantIds = allowsDuplicateSeedNumbers ? randomlySelectedUnplacedSeedValueIds : unplacedSeedNumberIds;
+  const participants = template ? filteredParticipants.map(
+    (source) => attributeFilter({ source, template })
+  ) : filteredParticipants;
   return {
-    nextSeedBlock,
-    unplacedSeedParticipantIds,
-    unplacedSeedNumbers,
-    unfilledPositions,
-    unplacedSeedAssignments
+    participantIdsWithConflicts,
+    eventsPublishStatuses,
+    derivedEventInfo,
+    derivedDrawInfo,
+    mappedMatchUps,
+    participantMap,
+    participants,
+    ...SUCCESS,
+    matchUps
   };
-  function randomlySelectLowestSeedValue(assignments, selectedParticipantIds2) {
-    const filteredAssignments = assignments.filter(
-      (assignment) => !selectedParticipantIds2.includes(assignment.participantId)
-    );
-    const lowestSeedValue = Math.min(
-      ...filteredAssignments.map(
-        (assignment) => getNumericSeedValue(assignment.seedValue)
-      )
-    );
-    const assignmentsWithLowestSeedValue = filteredAssignments.filter(
-      (assignment) => getNumericSeedValue(assignment.seedValue) === lowestSeedValue
-    );
-    const randomizedAssignments = shuffleArray(assignmentsWithLowestSeedValue);
-    return randomizedAssignments.pop();
-  }
-}
-function getSeedPattern(seedingProfile) {
-  if (typeof seedingProfile === "string")
-    return seedingProfile;
-  if (typeof seedingProfile === "object")
-    return seedingProfile.positioning;
 }
 
-const hasSchedule = ({
-  scheduleAttributes = ["scheduledDate", "scheduledTime"],
-  schedule = {}
-}) => {
-  const matchUpScheduleKeys = Object.keys(schedule).filter((key) => scheduleAttributes.includes(key)).filter((key) => schedule[key]);
-  return !!matchUpScheduleKeys.length;
-};
-
 function getDerivedPositionAssignments({
   derivedDrawInfo,
   participantId,
@@ -11936,6 +12404,14 @@ function getDerivedSeedAssignments({
   return Object.keys(seedAssignments).length ? seedAssignments : void 0;
 }
 
+const hasSchedule = ({
+  scheduleAttributes = ["scheduledDate", "scheduledTime"],
+  schedule = {}
+}) => {
+  const matchUpScheduleKeys = Object.keys(schedule).filter((key) => scheduleAttributes.includes(key)).filter((key) => schedule[key]);
+  return !!matchUpScheduleKeys.length;
+};
+
 function participantScheduledMatchUps({
   scheduleAttributes = ["scheduledDate", "scheduledTime"],
   matchUps = []
@@ -12943,322 +13419,955 @@ function getTournamentParticipants(params) {
       })
     );
   }
-  return {
-    participantIdsWithConflicts,
-    tournamentParticipants,
-    eventsPublishStatuses
-  };
+  return {
+    participantIdsWithConflicts,
+    tournamentParticipants,
+    eventsPublishStatuses
+  };
+}
+
+function deepMerge(existing, incoming, arrayMerge) {
+  if (!existing && incoming)
+    return incoming;
+  if (existing && !incoming)
+    return existing;
+  if (typeof existing !== "object" || typeof incoming !== "object")
+    return existing;
+  const keys = unique(Object.keys(existing).concat(Object.keys(incoming)));
+  return keys.reduce((merged, key) => {
+    if (!incoming[key]) {
+      merged[key] = existing[key];
+    } else if (!existing[key]) {
+      merged[key] = incoming[key];
+    } else if (typeof existing[key] !== typeof incoming[key]) {
+      merged[key] = incoming[key];
+    } else if (Array.isArray(existing[key])) {
+      if (arrayMerge === true || Array.isArray(arrayMerge) && arrayMerge.includes(key)) {
+        const mergedArrays = unique(
+          existing[key].map((e) => JSON.stringify(e)).concat(incoming[key].map((i) => JSON.stringify(i)))
+        ).map((u) => JSON.parse(u));
+        merged[key] = mergedArrays;
+      } else {
+        merged[key] = incoming[key];
+      }
+    } else if (typeof existing[key] === "object") {
+      merged[key] = deepMerge(existing[key], incoming[key], arrayMerge);
+    } else {
+      merged[key] = incoming[key];
+    }
+    return merged;
+  }, {});
+}
+
+function getCompetitionParticipants(params) {
+  const { tournamentRecords } = params || {};
+  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  let competitionParticipants = [];
+  const participantIdsWithConflicts = [];
+  const competitionParticipantIds = [];
+  for (const tournamentRecord of Object.values(tournamentRecords)) {
+    const {
+      tournamentParticipants,
+      participantIdsWithConflicts: idsWithConflicts
+    } = getTournamentParticipants({
+      tournamentRecord,
+      ...params
+    });
+    for (const tournamentParticipant of tournamentParticipants) {
+      const { participantId } = tournamentParticipant;
+      if (!competitionParticipantIds.includes(participantId)) {
+        competitionParticipantIds.push(participantId);
+        competitionParticipants.push(tournamentParticipant);
+      } else {
+        competitionParticipants = competitionParticipants.map(
+          (participant) => participant.participantId !== participantId ? participant : deepMerge(participant, tournamentParticipant, true)
+        );
+      }
+    }
+    idsWithConflicts?.forEach((participantId) => {
+      if (!participantIdsWithConflicts.includes(participantId))
+        participantIdsWithConflicts.push(participantId);
+    });
+  }
+  return { competitionParticipants, participantIdsWithConflicts, ...SUCCESS };
+}
+function publicFindParticipant({
+  policyDefinitions,
+  tournamentRecords,
+  participantId,
+  inContext,
+  personId
+}) {
+  if (!tournamentRecords)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  if (typeof participantId !== "string" && typeof personId !== "string")
+    return { error: MISSING_VALUE, stack: "publicFindParticipant" };
+  let participant, tournamentId;
+  for (const tournamentRecord of Object.values(tournamentRecords)) {
+    tournamentId = tournamentRecord.tournamentId;
+    const { tournamentParticipants } = getTournamentParticipants({
+      policyDefinitions,
+      tournamentRecord,
+      inContext
+    });
+    participant = findParticipant({
+      tournamentParticipants,
+      internalUse: true,
+      policyDefinitions,
+      participantId,
+      personId
+    });
+    if (participant)
+      break;
+  }
+  return { participant, tournamentId, ...SUCCESS };
+}
+
+function getParticipantScaleItem({
+  tournamentRecords,
+  policyDefinitions,
+  scaleAttributes,
+  participantId,
+  inContext,
+  personId
+}) {
+  let result = publicFindParticipant({
+    tournamentRecords,
+    policyDefinitions,
+    participantId,
+    inContext,
+    personId
+  });
+  if (result.error)
+    return result;
+  const { participant, tournamentId } = result;
+  result = participantScaleItem({ participant, scaleAttributes });
+  if (result.error)
+    return { ...result, tournamentId };
+  return { ...SUCCESS, tournamentId, ...result };
+}
+
+function getSourceStructureIdsAndRelevantLinks({
+  targetRoundNumber,
+  finishingPosition,
+  drawDefinition,
+  structureId,
+  // structure for which source and target links are to be found
+  linkType
+  // only return links which match linkType
+}) {
+  const { links } = getStructureLinks({
+    drawDefinition,
+    structureId
+  }) || {};
+  const sourceLinks = (links?.target || []).filter(({ linkType: structureLinkType }) => structureLinkType === linkType).filter(
+    ({ target }) => !targetRoundNumber || targetRoundNumber === target.roundNumber
+  );
+  const relevantLinks = sourceLinks.map((link) => {
+    const sourceStructureId = link.source.structureId;
+    const { structure: sourceStructure } = findStructure({
+      structureId: sourceStructureId,
+      drawDefinition
+    });
+    if (finishingPosition && sourceStructure?.finishingPosition !== finishingPosition)
+      return;
+    return link;
+  }).filter(Boolean);
+  const sourceStructureIds = relevantLinks.map(
+    ({ source }) => source.structureId
+  );
+  return { sourceStructureIds, relevantLinks };
+}
+
+function getContainedStructures({
+  tournamentRecord,
+  drawDefinition,
+  event
+}) {
+  const events = tournamentRecord?.events || event && [event];
+  const drawDefinitions = events?.map((event2) => event2?.drawDefinitions).flat().filter(Boolean) || drawDefinition && [drawDefinition] || [];
+  const containedStructures = {};
+  const containerStructures = {};
+  const structureContainers = drawDefinitions.map((dd) => dd?.structures?.filter((structure) => structure?.structures)).flat().filter(Boolean);
+  for (const structureContainer of structureContainers) {
+    const { structures, structureId } = structureContainer || {};
+    structures && structureId && (containedStructures[structureId] = structures?.map(
+      (structure) => structure.structureId
+    )) && structures.forEach(
+      (structure) => containerStructures[structure.structureId] = structureContainer?.structureId
+    );
+  }
+  return { containedStructures, containerStructures };
+}
+
+function isActiveMatchUp({
+  matchUpStatus,
+  winningSide,
+  tieMatchUps,
+  sides,
+  score
+}) {
+  const participantAssigned = sides?.find(({ participantId }) => participantId);
+  const activeTieMatchUps = tieMatchUps?.filter(isActiveMatchUp)?.length;
+  const scoreExists = scoreHasValue({ score });
+  return scoreExists || activeTieMatchUps || winningSide && participantAssigned || // if winningSide and no participant assigned => "produced" WALKOVER
+  // must exclude IN_PROGRESS as this is automatically set by updateTieMatchUpScore
+  // must exclude WALKOVER and DEFAULTED as "produced" scenarios do not imply a winningSide
+  matchUpStatus && isActiveMatchUpStatus({ matchUpStatus }) && ![DEFAULTED, WALKOVER$1, IN_PROGRESS].includes(matchUpStatus);
+}
+
+function getStructureDrawPositionProfiles(params) {
+  const { drawDefinition, findContainer, structureId, event } = params;
+  let structure = params.structure;
+  const matchUpFilters = { isCollectionMatchUp: false };
+  const { containedStructures } = getContainedStructures({ drawDefinition });
+  const containedStructureIds = structureId ? containedStructures[structureId] || [] : [];
+  if (!structure) {
+    const result = findStructure({ drawDefinition, structureId });
+    if (result.error)
+      return result;
+    structure = findContainer ? result.containingStructure || result.structure : result.structure;
+  }
+  if (isAdHoc({ drawDefinition, structure })) {
+    return { structure, isAdHoc: true, error: INVALID_DRAW_POSITION };
+  }
+  const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
+    inContext: true,
+    matchUpFilters,
+    drawDefinition,
+    event
+  });
+  const inContextStructureMatchUps = inContextDrawMatchUps?.filter(
+    (matchUp) => matchUp.structureId === structureId || containedStructureIds.includes(matchUp.structureId)
+  );
+  const { matchUpDependencies } = getMatchUpDependencies({
+    drawIds: [drawDefinition.drawId],
+    matchUps: inContextDrawMatchUps,
+    drawDefinition
+  });
+  const activeDependentMatchUpIdsCollection = [];
+  const drawPositionsCollection = [];
+  const drawPositionInitialRounds = {};
+  const activeMatchUps = [];
+  for (const matchUp of inContextDrawMatchUps || []) {
+    if (matchUp.structureId === structureId || containedStructureIds.includes(matchUp.structureId)) {
+      drawPositionsCollection.push(...matchUp.drawPositions || []);
+      const roundNumber = matchUp.roundNumber;
+      for (const drawPosition of (matchUp.drawPositions || []).filter(
+        Boolean
+      )) {
+        if (!drawPositionInitialRounds[drawPosition] || roundNumber && drawPositionInitialRounds[drawPosition] > roundNumber) {
+          drawPositionInitialRounds[drawPosition] = roundNumber;
+        }
+      }
+    }
+    if (isActiveMatchUp(matchUp)) {
+      activeMatchUps.push(matchUp);
+      activeDependentMatchUpIdsCollection.push(
+        matchUp.matchUpId,
+        ...matchUpDependencies?.[matchUp?.matchUpId]?.matchUpIds || []
+      );
+    }
+  }
+  const drawPositions = unique(drawPositionsCollection.filter(Boolean)).sort(
+    numericSort
+  );
+  const activeDependentMatchUpIds = unique(activeDependentMatchUpIdsCollection);
+  const activeDrawPositions = unique(
+    inContextStructureMatchUps?.map(
+      ({ matchUpId, drawPositions: drawPositions2 }) => activeDependentMatchUpIds.includes(matchUpId) ? drawPositions2 : []
+    ).flat().filter(Boolean)
+  ).sort(numericSort);
+  const { positionAssignments } = getPositionAssignments({
+    drawDefinition,
+    structure
+  });
+  const byeDrawPositions = positionAssignments?.filter((assignment) => assignment.bye).map((assignment) => assignment.drawPosition);
+  const qualifyingDrawPositions = positionAssignments?.filter((assignment) => assignment.qualifier).map((assignment) => assignment.drawPosition);
+  const inactiveDrawPositions = drawPositions?.filter(
+    (drawPosition) => !activeDrawPositions.includes(drawPosition)
+  ) || [];
+  return {
+    allDrawPositions: drawPositions,
+    inContextStructureMatchUps,
+    drawPositionInitialRounds,
+    activeDependentMatchUpIds,
+    qualifyingDrawPositions,
+    inactiveDrawPositions,
+    positionAssignments,
+    activeDrawPositions,
+    byeDrawPositions,
+    activeMatchUps,
+    structure
+  };
+}
+
+function getAssignedParticipantIds({
+  drawDefinition,
+  stages
+}) {
+  const stageStructures = (drawDefinition?.structures || []).filter(
+    (structure) => !stages?.length || structure.stage && stages.includes(structure.stage)
+  );
+  return stageStructures.map((structure) => {
+    const { positionAssignments } = getPositionAssignments({
+      structure
+    });
+    return positionAssignments ? positionAssignments.map(extractAttributes("participantId")) : [];
+  }).flat();
+}
+
+function getValidModifyAssignedPairAction({
+  tournamentParticipants,
+  returnParticipants,
+  drawPosition,
+  participant,
+  drawId,
+  event
+}) {
+  const availableIndividualParticipantIds = event?.entries?.filter(({ entryStatus }) => [UNGROUPED, UNPAIRED].includes(entryStatus)).map(({ participantId }) => participantId) || [];
+  if (availableIndividualParticipantIds.length) {
+    const existingIndividualParticipantIds = participant.individualParticipantIds;
+    const availableIndividualParticipants = returnParticipants ? tournamentParticipants.filter(
+      ({ participantId }) => availableIndividualParticipantIds.includes(participantId)
+    ) : void 0;
+    const existingIndividualParticipants = returnParticipants ? tournamentParticipants.filter(
+      ({ participantId }) => existingIndividualParticipantIds.includes(participantId)
+    ) : void 0;
+    const validModifyAssignedPairAction = definedAttributes(
+      {
+        payload: {
+          participantId: participant.participantId,
+          replacementIndividualParticipantId: void 0,
+          existingIndividualParticipantId: void 0,
+          drawPosition,
+          drawId
+        },
+        method: MODIFY_PAIR_ASSIGNMENT_METHOD,
+        availableIndividualParticipantIds,
+        availableIndividualParticipants,
+        existingIndividualParticipantIds,
+        existingIndividualParticipants,
+        type: MODIFY_PAIR_ASSIGNMENT
+      },
+      false,
+      false,
+      true
+    );
+    return { validModifyAssignedPairAction };
+  }
+  return {};
+}
+
+function getInitialRoundNumber({
+  drawPosition,
+  matchUps = []
+}) {
+  const initialRoundNumber = matchUps.filter(
+    ({ drawPositions }) => drawPosition && drawPositions?.includes(drawPosition)
+  ).map(({ roundNumber }) => roundNumber).sort(numericSort)[0];
+  return { initialRoundNumber };
+}
+
+function getValidLuckyLosersAction({
+  tournamentParticipants = [],
+  sourceStructuresComplete,
+  possiblyDisablingAction,
+  isWinRatioFedStructure,
+  activeDrawPositions,
+  positionAssignments,
+  drawDefinition,
+  drawPosition,
+  structureId,
+  structure,
+  drawId,
+  event
+}) {
+  if (activeDrawPositions.includes(drawPosition) || // can't be a lucky loser if still have matches to play in a round robin structure!!
+  isWinRatioFedStructure && !sourceStructuresComplete) {
+    return {};
+  }
+  const { sourceStructureIds, targetStructureIds } = drawDefinition.links?.reduce(
+    (ids, link) => {
+      const sourceStructureId = link.source?.structureId;
+      const targetStructureId = link.target?.structureId;
+      if (!ids.sourceStructureIds.includes(sourceStructureId))
+        ids.sourceStructureIds.push(sourceStructureId);
+      if (!ids.targetStructureIds.includes(targetStructureId))
+        ids.targetStructureIds.push(targetStructureId);
+      return ids;
+    },
+    { sourceStructureIds: [], targetStructureIds: [] }
+  ) || {};
+  const availableLuckyLoserParticipantIds = [];
+  const relevantLinks = drawDefinition.links?.filter(
+    (link) => link.target?.structureId === structure.structureId
+  ) || [];
+  for (const relevantLink of relevantLinks) {
+    const sourceStructureId = relevantLink?.source?.structureId;
+    const { structure: sourceStructure } = findStructure({
+      structureId: sourceStructureId,
+      drawDefinition
+    });
+    const restrictBySourceRound = sourceStructure?.finishingPosition === ROUND_OUTCOME && (sourceStructureIds?.length !== 1 || targetStructureIds?.length !== 1);
+    const matchUpFilters = {};
+    if (restrictBySourceRound) {
+      const { matchUps } = getAllStructureMatchUps({
+        drawDefinition,
+        structure,
+        event
+      });
+      const { initialRoundNumber } = getInitialRoundNumber({
+        drawPosition,
+        matchUps
+      });
+      const relevantLink2 = drawDefinition.links?.find(
+        (link) => link.target?.structureId === structure?.structureId && link.target.roundNumber === initialRoundNumber
+      );
+      const sourceRoundNumber = relevantLink2?.source?.roundNumber;
+      matchUpFilters.roundNumbers = [sourceRoundNumber];
+    }
+    const { completedMatchUps } = getStructureMatchUps({
+      structureId: sourceStructureId,
+      inContext: true,
+      matchUpFilters,
+      drawDefinition
+    });
+    const assignedParticipantIds = positionAssignments.map((assignment) => assignment.participantId).filter(Boolean);
+    const availableParticipantIds = completedMatchUps?.filter(
+      ({ matchUpType, winningSide }) => winningSide && (event?.eventType !== TEAM || matchUpType === TEAM)
+    ).map(
+      ({ winningSide, sides }) => winningSide && sides?.[1 - (winningSide - 1)]
+    ).map(extractAttributes("participantId")).filter(
+      (participantId) => participantId && !assignedParticipantIds.includes(participantId)
+    );
+    availableParticipantIds?.forEach((participantId) => {
+      if (!availableLuckyLoserParticipantIds.includes(participantId))
+        availableLuckyLoserParticipantIds.push(participantId);
+    });
+  }
+  const availableLuckyLosers = tournamentParticipants?.filter(
+    (participant) => availableLuckyLoserParticipantIds?.includes(participant.participantId)
+  );
+  availableLuckyLosers?.forEach((luckyLoser) => {
+    const entry = (drawDefinition.entries || []).find(
+      (entry2) => entry2.participantId === luckyLoser.participantId
+    );
+    luckyLoser.entryPosition = entry?.entryPosition;
+  });
+  if (availableLuckyLoserParticipantIds?.length) {
+    const validLuckyLosersAction = {
+      type: LUCKY_PARTICIPANT,
+      method: LUCKY_PARTICIPANT_METHOD,
+      availableLuckyLosers,
+      availableLuckyLoserParticipantIds,
+      willDisableLinks: possiblyDisablingAction,
+      payload: { drawId, structureId, drawPosition }
+    };
+    return { validLuckyLosersAction };
+  }
+  return {};
 }
 
-function deepMerge(existing, incoming, arrayMerge) {
-  if (!existing && incoming)
-    return incoming;
-  if (existing && !incoming)
-    return existing;
-  if (typeof existing !== "object" || typeof incoming !== "object")
-    return existing;
-  const keys = unique(Object.keys(existing).concat(Object.keys(incoming)));
-  return keys.reduce((merged, key) => {
-    if (!incoming[key]) {
-      merged[key] = existing[key];
-    } else if (!existing[key]) {
-      merged[key] = incoming[key];
-    } else if (typeof existing[key] !== typeof incoming[key]) {
-      merged[key] = incoming[key];
-    } else if (Array.isArray(existing[key])) {
-      if (arrayMerge === true || Array.isArray(arrayMerge) && arrayMerge.includes(key)) {
-        const mergedArrays = unique(
-          existing[key].map((e) => JSON.stringify(e)).concat(incoming[key].map((i) => JSON.stringify(i)))
-        ).map((u) => JSON.parse(u));
-        merged[key] = mergedArrays;
-      } else {
-        merged[key] = incoming[key];
-      }
-    } else if (typeof existing[key] === "object") {
-      merged[key] = deepMerge(existing[key], incoming[key], arrayMerge);
-    } else {
-      merged[key] = incoming[key];
+function getNumericSeedValue(seedValue) {
+  if (!seedValue)
+    return Infinity;
+  if (isConvertableInteger(seedValue))
+    return ensureInt(seedValue);
+  const firstValue = seedValue.split("-")[0];
+  if (isConvertableInteger(firstValue))
+    return ensureInt(firstValue);
+  return Infinity;
+}
+
+function getValidGroupSizes({
+  drawSize,
+  groupSizeLimit = 10
+}) {
+  const validGroupSizes = generateRange(3, groupSizeLimit + 1).filter(
+    (groupSize) => {
+      const groupsCount = Math.ceil(drawSize / groupSize);
+      const byesCount = groupsCount * groupSize - drawSize;
+      const maxParticipantsPerGroup = Math.ceil(drawSize / groupsCount);
+      const maxByesPerGroup = Math.ceil(byesCount / groupsCount);
+      return (!byesCount || byesCount < groupSize) && maxParticipantsPerGroup === groupSize && maxParticipantsPerGroup >= 3 && maxByesPerGroup < 2;
     }
-    return merged;
-  }, {});
+  );
+  return { ...SUCCESS, validGroupSizes };
 }
 
-function getCompetitionParticipants(params) {
-  const { tournamentRecords } = params || {};
-  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  let competitionParticipants = [];
-  const participantIdsWithConflicts = [];
-  const competitionParticipantIds = [];
-  for (const tournamentRecord of Object.values(tournamentRecords)) {
-    const {
-      tournamentParticipants,
-      participantIdsWithConflicts: idsWithConflicts
-    } = getTournamentParticipants({
-      tournamentRecord,
-      ...params
+function getSeedBlocks(params) {
+  const { roundRobinGroupsCount, participantsCount, cluster } = params;
+  if (!isConvertableInteger(participantsCount))
+    return {
+      seedBlocks: void 0,
+      ...decorateResult({
+        result: { error: INVALID_VALUES },
+        context: { participantsCount },
+        stack: "getSeedBlocks"
+      })
+    };
+  const drawSize = nextPowerOf2(participantsCount);
+  if (roundRobinGroupsCount) {
+    const increment = Math.min(roundRobinGroupsCount, drawSize);
+    const seedBlocks2 = [];
+    let position = 1;
+    generateRange(0, increment).forEach(() => {
+      seedBlocks2.push([position]);
+      position++;
     });
-    for (const tournamentParticipant of tournamentParticipants) {
-      const { participantId } = tournamentParticipant;
-      if (!competitionParticipantIds.includes(participantId)) {
-        competitionParticipantIds.push(participantId);
-        competitionParticipants.push(tournamentParticipant);
+    while (position < drawSize) {
+      const range2 = generateRange(position, position + increment);
+      position += increment;
+      seedBlocks2.push(range2);
+    }
+    return { ...SUCCESS, seedBlocks: seedBlocks2 };
+  }
+  const range = generateRange(1, drawSize + 1);
+  const positions = [];
+  let chunkSize = drawSize / 2;
+  while (chunkSize > 1) {
+    const chunks = chunkArray(range, chunkSize);
+    const chunksCount = chunks.length;
+    chunks.forEach((chunk, i) => {
+      let candidate;
+      const top = i < chunksCount / 2;
+      const isEven = i % 2 === 0;
+      const first = chunk[0];
+      const last = chunk[chunk.length - 1];
+      if (cluster && chunksCount > 4) {
+        if (chunksCount === 8) {
+          candidate = top ? last : first;
+        } else {
+          candidate = isEven ? first : last;
+        }
       } else {
-        competitionParticipants = competitionParticipants.map(
-          (participant) => participant.participantId !== participantId ? participant : deepMerge(participant, tournamentParticipant, true)
-        );
+        candidate = top ? first : last;
+      }
+      if (!overlap(chunk, positions)) {
+        positions.push(candidate);
       }
-    }
-    idsWithConflicts?.forEach((participantId) => {
-      if (!participantIdsWithConflicts.includes(participantId))
-        participantIdsWithConflicts.push(participantId);
     });
+    chunkSize = chunkSize / 2;
   }
-  return { competitionParticipants, participantIdsWithConflicts, ...SUCCESS };
-}
-function publicFindParticipant({
-  policyDefinitions,
-  tournamentRecords,
-  participantId,
-  inContext,
-  personId
-}) {
-  if (!tournamentRecords)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  if (typeof participantId !== "string" && typeof personId !== "string")
-    return { error: MISSING_VALUE, stack: "publicFindParticipant" };
-  let participant, tournamentId;
-  for (const tournamentRecord of Object.values(tournamentRecords)) {
-    tournamentId = tournamentRecord.tournamentId;
-    const { tournamentParticipants } = getTournamentParticipants({
-      policyDefinitions,
-      tournamentRecord,
-      inContext
-    });
-    participant = findParticipant({
-      tournamentParticipants,
-      internalUse: true,
-      policyDefinitions,
-      participantId,
-      personId
-    });
-    if (participant)
-      break;
+  const remainingPositions = range.filter(
+    (position) => !positions.includes(position)
+  );
+  while (remainingPositions.length) {
+    if (remainingPositions.length % 2 === 0) {
+      positions.push(remainingPositions.pop());
+    } else {
+      positions.push(remainingPositions.shift());
+    }
   }
-  return { participant, tournamentId, ...SUCCESS };
+  const seedBlockSizes = generateRange(0, 20).map((x) => Math.pow(2, x));
+  seedBlockSizes.unshift(1);
+  const iterations = seedBlockSizes.indexOf(drawSize);
+  let sum = 0;
+  const seedBlocks = [];
+  generateRange(0, iterations).forEach((i) => {
+    seedBlocks.push(positions.slice(sum, sum + seedBlockSizes[i]));
+    sum += seedBlockSizes[i];
+  });
+  return { ...SUCCESS, seedBlocks };
 }
-
-function getParticipantScaleItem({
-  tournamentRecords,
-  policyDefinitions,
-  scaleAttributes,
-  participantId,
-  inContext,
-  personId
+function getSeedGroups({
+  roundRobinGroupsCount,
+  drawSize
 }) {
-  let result = publicFindParticipant({
-    tournamentRecords,
-    policyDefinitions,
-    participantId,
-    inContext,
-    personId
-  });
-  if (result.error)
-    return result;
-  const { participant, tournamentId } = result;
-  result = participantScaleItem({ participant, scaleAttributes });
-  if (result.error)
-    return { ...result, tournamentId };
-  return { ...SUCCESS, tournamentId, ...result };
+  const stack = "getSeedGroups";
+  if (!isConvertableInteger(drawSize))
+    return {
+      seedGroups: void 0,
+      ...decorateResult({
+        result: { error: INVALID_VALUES },
+        context: { drawSize },
+        stack
+      })
+    };
+  if (roundRobinGroupsCount) {
+    if (!isConvertableInteger(roundRobinGroupsCount))
+      return {
+        seedGroups: void 0,
+        ...decorateResult({
+          context: { roundRobinGroupsCount },
+          result: { error: INVALID_VALUES },
+          stack
+        })
+      };
+    let seedNumber = 1;
+    const roundsCount = Math.floor(drawSize / roundRobinGroupsCount);
+    const seedGroups = generateRange(0, roundsCount).map(() => {
+      const seedNumbers = generateRange(
+        seedNumber,
+        seedNumber + roundRobinGroupsCount
+      );
+      seedNumber += roundRobinGroupsCount;
+      return seedNumbers;
+    });
+    return { seedGroups };
+  } else {
+    const { seedBlocks } = getSeedBlocks({
+      participantsCount: drawSize,
+      roundRobinGroupsCount
+    });
+    let seedNumber = 0;
+    const seedGroups = (seedBlocks || []).map(
+      (seedBlock) => (seedBlock || []).map(() => {
+        seedNumber += 1;
+        return seedNumber;
+      })
+    );
+    return { seedGroups };
+  }
 }
 
-function getSourceStructureIdsAndRelevantLinks({
-  targetRoundNumber,
-  finishingPosition,
+function getValidSeedBlocks({
+  provisionalPositioning,
+  appliedPolicies,
   drawDefinition,
-  structureId,
-  // structure for which source and target links are to be found
-  linkType
-  // only return links which match linkType
+  allPositions,
+  structure
 }) {
-  const { links } = getStructureLinks({
+  let validSeedBlocks = [];
+  if (!structure)
+    return { error: MISSING_STRUCTURE };
+  const { matchUps, roundMatchUps } = getAllStructureMatchUps({
+    matchUpFilters: { roundNumbers: [1] },
+    provisionalPositioning,
+    structure
+  });
+  const { seedAssignments } = getStructureSeedAssignments({
+    provisionalPositioning,
     drawDefinition,
-    structureId
-  }) || {};
-  const sourceLinks = (links?.target || []).filter(({ linkType: structureLinkType }) => structureLinkType === linkType).filter(
-    ({ target }) => !targetRoundNumber || targetRoundNumber === target.roundNumber
+    structure
+  });
+  const { positionAssignments } = structureAssignedDrawPositions({ structure });
+  const positionsCount = positionAssignments?.length;
+  const seedsCount = seedAssignments?.length ?? 0;
+  let allDrawPositions = [];
+  const roundNumbers = Object.keys(roundMatchUps).map((n) => parseInt(n)).sort((a, b) => a - b);
+  const uniqueDrawPositionsByRound = roundNumbers.map((roundNumber) => {
+    const roundDrawPositions = roundMatchUps[roundNumber].map((matchUp) => matchUp.drawPositions).flat(Infinity).filter(Boolean);
+    const uniqueRoundDrawPositions = roundDrawPositions.filter(
+      (drawPosition) => !allDrawPositions.includes(drawPosition)
+    );
+    allDrawPositions = allDrawPositions.concat(...roundDrawPositions);
+    return uniqueRoundDrawPositions;
+  }).filter((f) => f.length).reverse();
+  const firstRoundDrawPositions = uniqueDrawPositionsByRound.pop();
+  const firstRoundDrawPositionOffset = firstRoundDrawPositions && Math.min(...firstRoundDrawPositions) - 1 || 0;
+  const seedingProfile = appliedPolicies?.seeding?.seedingProfile;
+  const baseDrawSize = firstRoundDrawPositions?.length || 0;
+  const seedRangeDrawPositionBlocks = uniqueDrawPositionsByRound.filter(
+    (block) => block.filter((drawPosition) => drawPosition <= seedsCount).length
   );
-  const relevantLinks = sourceLinks.map((link) => {
-    const sourceStructureId = link.source.structureId;
-    const { structure: sourceStructure } = findStructure({
-      structureId: sourceStructureId,
-      drawDefinition
+  const { stage, structureType, roundLimit } = structure;
+  const isContainer = structureType === CONTAINER;
+  const isFeedIn = !isContainer && uniqueDrawPositionsByRound?.length;
+  const qualifyingBlocks = !isContainer && stage === QUALIFYING && roundLimit;
+  const fedSeedBlockPositions = seedRangeDrawPositionBlocks.flat(Infinity);
+  const fedSeedNumberOffset = isFeedIn ? fedSeedBlockPositions?.length : 0;
+  const countLimit = allPositions ? positionsCount : seedsCount;
+  const isLuckyStructure = isLucky({
+    drawDefinition,
+    structure,
+    matchUps
+  });
+  const firstRoundSeedsCount = isLuckyStructure ? 0 : !isFeedIn && countLimit || countLimit && fedSeedBlockPositions.length < countLimit && countLimit - fedSeedBlockPositions.length || 0;
+  if (qualifyingBlocks) {
+    const seedingBlocksCount = structure?.matchUps ? structure.matchUps.filter(
+      ({ roundNumber }) => roundNumber === structure.roundLimit
+    ).length : 0;
+    const chunkSize = firstRoundDrawPositions.length / seedingBlocksCount;
+    if (isFeedIn) ; else {
+      const positioning = getSeedPattern(seedingProfile);
+      const drawPositionChunks = chunkArray(firstRoundDrawPositions, chunkSize);
+      let groupNumber = 1;
+      const seedGroups = generateRange(0, drawPositionChunks[0].length).map(
+        () => {
+          const seedNumbers = generateRange(
+            groupNumber,
+            groupNumber + drawPositionChunks.length
+          );
+          groupNumber += drawPositionChunks.length;
+          return seedNumbers;
+        }
+      );
+      ({ validSeedBlocks } = getSeedBlockPattern({
+        drawPositionBlocks: drawPositionChunks,
+        positioning,
+        seedGroups
+      }));
+    }
+  } else if (isContainer) {
+    const result = getContainerBlocks({
+      seedingProfile,
+      structure
     });
-    if (finishingPosition && sourceStructure?.finishingPosition !== finishingPosition)
-      return;
-    return link;
-  }).filter(Boolean);
-  const sourceStructureIds = relevantLinks.map(
-    ({ source }) => source.structureId
+    ({ validSeedBlocks } = result);
+  } else if (isFeedIn) {
+    validSeedBlocks = seedRangeDrawPositionBlocks.map((block) => {
+      return { seedNumbers: block, drawPositions: block };
+    });
+  } else if (isLuckyStructure) {
+    const blocks = chunkArray(firstRoundDrawPositions, 2).map((block, i) => ({
+      drawPositions: [block[0]],
+      seedNumbers: [i + 1]
+    }));
+    blocks.forEach((block) => validSeedBlocks.push(block));
+  }
+  if (!isContainer && !isLuckyStructure && !qualifyingBlocks) {
+    const { blocks } = constructPower2Blocks({
+      drawPositionOffset: firstRoundDrawPositionOffset,
+      seedNumberOffset: fedSeedNumberOffset,
+      seedCountGoal: firstRoundSeedsCount,
+      seedingProfile,
+      baseDrawSize
+    });
+    blocks.forEach((block) => validSeedBlocks.push(block));
+  }
+  const seedDrawPositions = validSeedBlocks.flatMap(
+    (seedBlock) => seedBlock.drawPositions
   );
-  return { sourceStructureIds, relevantLinks };
+  const validSeedPositions = seedDrawPositions.reduce(
+    (result, drawPosition) => {
+      return firstRoundDrawPositions?.includes(drawPosition) && result;
+    },
+    true
+  );
+  if (!isLuckyStructure && !isFeedIn && !isContainer && !validSeedPositions) {
+    return {
+      error: INVALID_SEED_POSITION,
+      validSeedBlocks: [],
+      isContainer,
+      isFeedIn
+    };
+  }
+  return {
+    isLuckyStructure,
+    validSeedBlocks,
+    isContainer,
+    isFeedIn
+  };
 }
-
-function getAssignedParticipantIds({
-  drawDefinition,
-  stages
-}) {
-  const stageStructures = (drawDefinition?.structures || []).filter(
-    (structure) => !stages?.length || structure.stage && stages.includes(structure.stage)
+function getContainerBlocks({ seedingProfile, structure }) {
+  const containedStructures = structure.structures || [];
+  const roundRobinGroupsCount = containedStructures.length;
+  const positionAssignments = getPositionAssignments({
+    structure
+  })?.positionAssignments;
+  const positioning = getSeedPattern(seedingProfile);
+  const drawSize = positionAssignments?.length ?? 0;
+  const { seedGroups } = getSeedGroups({
+    roundRobinGroupsCount,
+    drawSize
+  });
+  const drawPositionBlocks = containedStructures.map(
+    (containedStructure) => getPositionAssignments({
+      structure: containedStructure
+    }).positionAssignments?.map((assignment) => assignment.drawPosition)
   );
-  return stageStructures.map((structure) => {
-    const { positionAssignments } = getPositionAssignments({
-      structure
+  return getSeedBlockPattern({
+    drawPositionBlocks,
+    positioning,
+    seedGroups
+  });
+}
+function getSeedBlockPattern({ positioning, seedGroups, drawPositionBlocks }) {
+  const validSeedBlocks = [];
+  const topDown = (a, b) => a - b;
+  const bottomUp = (a, b) => b - a;
+  const assignedPositions = [];
+  seedGroups.forEach((seedGroup, i) => {
+    if (i && positioning !== WATERFALL) {
+      shuffleArray(seedGroup);
+    }
+    seedGroup.forEach((seedNumber, j) => {
+      const blockIndex = i % 2 ? drawPositionBlocks.length - j - 1 : j;
+      const drawPosition = drawPositionBlocks[blockIndex].sort(i % 2 ? bottomUp : topDown).find((drawPosition2) => !assignedPositions.includes(drawPosition2));
+      assignedPositions.push(drawPosition);
+      validSeedBlocks.push({
+        seedNumbers: [seedNumber],
+        drawPositions: [drawPosition]
+      });
     });
-    return positionAssignments ? positionAssignments.map(extractAttributes("participantId")) : [];
-  }).flat();
+  });
+  return { validSeedBlocks };
 }
-
-function getValidModifyAssignedPairAction({
-  tournamentParticipants,
-  returnParticipants,
-  drawPosition,
-  participant,
-  drawId,
-  event
-}) {
-  const availableIndividualParticipantIds = event?.entries?.filter(({ entryStatus }) => [UNGROUPED, UNPAIRED].includes(entryStatus)).map(({ participantId }) => participantId) || [];
-  if (availableIndividualParticipantIds.length) {
-    const existingIndividualParticipantIds = participant.individualParticipantIds;
-    const availableIndividualParticipants = returnParticipants ? tournamentParticipants.filter(
-      ({ participantId }) => availableIndividualParticipantIds.includes(participantId)
-    ) : void 0;
-    const existingIndividualParticipants = returnParticipants ? tournamentParticipants.filter(
-      ({ participantId }) => existingIndividualParticipantIds.includes(participantId)
-    ) : void 0;
-    const validModifyAssignedPairAction = definedAttributes(
-      {
-        payload: {
-          participantId: participant.participantId,
-          replacementIndividualParticipantId: void 0,
-          existingIndividualParticipantId: void 0,
-          drawPosition,
-          drawId
-        },
-        method: MODIFY_PAIR_ASSIGNMENT_METHOD,
-        availableIndividualParticipantIds,
-        availableIndividualParticipants,
-        existingIndividualParticipantIds,
-        existingIndividualParticipants,
-        type: MODIFY_PAIR_ASSIGNMENT
-      },
-      false,
-      false,
-      true
+function constructPower2Blocks(params) {
+  const {
+    drawPositionOffset = 0,
+    roundRobinGroupsCount,
+    seedNumberOffset = 0,
+    seedingProfile,
+    seedCountGoal,
+    baseDrawSize
+  } = params;
+  let count = 1;
+  const blocks = [];
+  const { seedBlocks } = getSeedBlocks({
+    cluster: getSeedPattern(seedingProfile) === CLUSTER,
+    participantsCount: baseDrawSize,
+    roundRobinGroupsCount
+  });
+  count = 0;
+  for (const seedBlock of seedBlocks) {
+    if (count + 1 > seedCountGoal)
+      break;
+    const drawPositions = seedBlock.map(
+      (drawPosition) => drawPosition + drawPositionOffset
     );
-    return { validModifyAssignedPairAction };
+    const seedNumbers = getSeeds(count + 1, seedBlock.length).map(
+      (seedNumber) => +seedNumber + seedNumberOffset
+    );
+    count += seedBlock.length;
+    blocks.push({ drawPositions, seedNumbers });
+  }
+  return { blocks };
+  function getSeeds(s, n) {
+    return Array.from(new Array(n), (_, i) => i + s);
   }
-  return {};
 }
-
-function getValidLuckyLosersAction({
-  tournamentParticipants = [],
-  sourceStructuresComplete,
-  possiblyDisablingAction,
-  isWinRatioFedStructure,
-  activeDrawPositions,
-  positionAssignments,
+function isValidSeedPosition({
+  appliedPolicies,
   drawDefinition,
+  seedBlockInfo,
   drawPosition,
   structureId,
-  structure,
-  drawId,
-  event
+  seedNumber
 }) {
-  if (activeDrawPositions.includes(drawPosition) || // can't be a lucky loser if still have matches to play in a round robin structure!!
-  isWinRatioFedStructure && !sourceStructuresComplete) {
-    return {};
+  const { structure } = findStructure({ drawDefinition, structureId });
+  if (!appliedPolicies) {
+    appliedPolicies = getAppliedPolicies({ drawDefinition }).appliedPolicies;
   }
-  const { sourceStructureIds, targetStructureIds } = drawDefinition.links?.reduce(
-    (ids, link) => {
-      const sourceStructureId = link.source?.structureId;
-      const targetStructureId = link.target?.structureId;
-      if (!ids.sourceStructureIds.includes(sourceStructureId))
-        ids.sourceStructureIds.push(sourceStructureId);
-      if (!ids.targetStructureIds.includes(targetStructureId))
-        ids.targetStructureIds.push(targetStructureId);
-      return ids;
-    },
-    { sourceStructureIds: [], targetStructureIds: [] }
-  ) || {};
-  const availableLuckyLoserParticipantIds = [];
-  const relevantLinks = drawDefinition.links?.filter(
-    (link) => link.target?.structureId === structure.structureId
-  ) || [];
-  for (const relevantLink of relevantLinks) {
-    const sourceStructureId = relevantLink?.source?.structureId;
-    const { structure: sourceStructure } = findStructure({
-      structureId: sourceStructureId,
-      drawDefinition
-    });
-    const restrictBySourceRound = sourceStructure?.finishingPosition === ROUND_OUTCOME && (sourceStructureIds?.length !== 1 || targetStructureIds?.length !== 1);
-    const matchUpFilters = {};
-    if (restrictBySourceRound) {
-      const { matchUps } = getAllStructureMatchUps({
-        drawDefinition,
-        structure,
-        event
-      });
-      const { initialRoundNumber } = getInitialRoundNumber({
-        drawPosition,
-        matchUps
-      });
-      const relevantLink2 = drawDefinition.links?.find(
-        (link) => link.target?.structureId === structure?.structureId && link.target.roundNumber === initialRoundNumber
-      );
-      const sourceRoundNumber = relevantLink2?.source?.roundNumber;
-      matchUpFilters.roundNumbers = [sourceRoundNumber];
-    }
-    const { completedMatchUps } = getStructureMatchUps({
-      structureId: sourceStructureId,
-      inContext: true,
-      matchUpFilters,
-      drawDefinition
-    });
-    const assignedParticipantIds = positionAssignments.map((assignment) => assignment.participantId).filter(Boolean);
-    const availableParticipantIds = completedMatchUps?.filter(
-      ({ matchUpType, winningSide }) => winningSide && (event?.eventType !== TEAM || matchUpType === TEAM)
-    ).map(
-      ({ winningSide, sides }) => winningSide && sides?.[1 - (winningSide - 1)]
-    ).map(extractAttributes("participantId")).filter(
-      (participantId) => participantId && !assignedParticipantIds.includes(participantId)
+  let validSeedBlocks = seedBlockInfo?.validSeedBlocks;
+  if (!validSeedBlocks && structure) {
+    validSeedBlocks = getValidSeedBlocks({
+      appliedPolicies,
+      drawDefinition,
+      structure
+    })?.validSeedBlocks;
+  }
+  if (appliedPolicies?.seeding?.validSeedPositions?.ignore)
+    return true;
+  if (appliedPolicies?.seeding?.validSeedPositions?.strict) {
+    const targetSeedBlock = validSeedBlocks.find(
+      (seedBlock) => seedBlock.seedNumbers.includes(seedNumber)
     );
-    availableParticipantIds?.forEach((participantId) => {
-      if (!availableLuckyLoserParticipantIds.includes(participantId))
-        availableLuckyLoserParticipantIds.push(participantId);
-    });
+    const validSeedPositions2 = targetSeedBlock?.drawPositions || [];
+    return validSeedPositions2.includes(drawPosition);
   }
-  const availableLuckyLosers = tournamentParticipants?.filter(
-    (participant) => availableLuckyLoserParticipantIds?.includes(participant.participantId)
+  const validSeedPositions = [].concat(
+    ...validSeedBlocks.map((seedBlock) => seedBlock.drawPositions)
   );
-  availableLuckyLosers?.forEach((luckyLoser) => {
-    const entry = (drawDefinition.entries || []).find(
-      (entry2) => entry2.participantId === luckyLoser.participantId
+  return validSeedPositions.includes(drawPosition);
+}
+function getNextSeedBlock(params) {
+  const {
+    provisionalPositioning,
+    drawDefinition,
+    seedBlockInfo,
+    structureId,
+    randomize
+  } = params;
+  const { structure } = findStructure({ drawDefinition, structureId });
+  const { seedAssignments } = getStructureSeedAssignments({
+    provisionalPositioning,
+    drawDefinition,
+    structure
+  });
+  const { positionAssignments } = structureAssignedDrawPositions({ structure });
+  const positionsWithParticipants = positionAssignments?.filter(
+    (assignment) => assignment.participantId ?? assignment.bye ?? assignment.qualifier
+  );
+  const assignedDrawPositions = positionsWithParticipants?.map((assignment) => assignment.drawPosition).filter(Boolean);
+  const { appliedPolicies } = getAppliedPolicies({ drawDefinition });
+  const validSeedBlocks = seedBlockInfo?.validSeedBlocks || structure && getValidSeedBlocks({
+    provisionalPositioning,
+    appliedPolicies,
+    drawDefinition,
+    structure
+  })?.validSeedBlocks;
+  const unfilledSeedBlocks = (validSeedBlocks || []).filter((seedBlock) => {
+    const unfilledPositions2 = seedBlock.drawPositions.filter(
+      (drawPosition) => !assignedDrawPositions?.includes(drawPosition)
     );
-    luckyLoser.entryPosition = entry?.entryPosition;
+    return unfilledPositions2.length;
   });
-  if (availableLuckyLoserParticipantIds?.length) {
-    const validLuckyLosersAction = {
-      type: LUCKY_PARTICIPANT,
-      method: LUCKY_PARTICIPANT_METHOD,
-      availableLuckyLosers,
-      availableLuckyLoserParticipantIds,
-      willDisableLinks: possiblyDisablingAction,
-      payload: { drawId, structureId, drawPosition }
-    };
-    return { validLuckyLosersAction };
+  const nextSeedBlock = unfilledSeedBlocks[0];
+  const assignedSeedParticipantIds = seedAssignments?.map((assignment) => assignment.participantId).filter(Boolean);
+  const assignedPositionParticipantIds = positionAssignments?.map((assignment) => assignment.participantId).filter(Boolean);
+  const placedSeedParticipantIds = assignedSeedParticipantIds?.filter(
+    (participantId) => assignedPositionParticipantIds?.includes(participantId)
+  );
+  const unplacedSeedIds = assignedSeedParticipantIds?.filter(
+    (participantId) => !assignedPositionParticipantIds?.includes(participantId)
+  );
+  const unplacedSeedAssignments = seedAssignments?.filter(
+    (assignment) => unplacedSeedIds?.includes(assignment.participantId)
+  );
+  const seedsWithoutDrawPositions = seedAssignments?.filter(
+    (assignment) => !assignment.participantId
+  );
+  const seedsLeftToAssign = unplacedSeedAssignments?.length && unplacedSeedAssignments.length > 0 ? unplacedSeedAssignments.length : seedsWithoutDrawPositions?.length ?? 0;
+  const unfilled = seedsLeftToAssign && nextSeedBlock?.drawPositions.filter(
+    (drawPosition) => !assignedDrawPositions?.includes(drawPosition)
+  ) || [];
+  const unfilledPositions = randomize ? shuffleArray(unfilled) : unfilled;
+  const selectedParticipantIds = [];
+  const randomlySelectedUnplacedSeedValueIds = unfilledPositions.map(() => {
+    const assignment = randomlySelectLowestSeedValue(
+      unplacedSeedAssignments,
+      selectedParticipantIds
+    );
+    const participantId = assignment?.participantId;
+    if (participantId)
+      selectedParticipantIds.push(participantId);
+    return participantId;
+  }).filter(Boolean);
+  const placedSeedNumbers = seedAssignments?.filter(
+    (assignment) => placedSeedParticipantIds?.includes(assignment.participantId)
+  ).map((assignment) => assignment.seedNumber);
+  const blockSeedNumbers = nextSeedBlock?.seedNumbers || [];
+  const unplacedSeedNumbers = blockSeedNumbers.filter(
+    (seedNumber) => !placedSeedNumbers?.includes(seedNumber)
+  );
+  const unplacedSeedNumberIds = seedAssignments?.filter(
+    (assignment) => unplacedSeedNumbers.includes(assignment.seedNumber)
+  ).map((assignment) => assignment.participantId);
+  const duplicateSeedNumbers = appliedPolicies?.seeding?.duplicateSeedNumbers;
+  const allowsDuplicateSeedNumbers = duplicateSeedNumbers !== void 0 ? duplicateSeedNumbers : true;
+  const unplacedSeedParticipantIds = allowsDuplicateSeedNumbers ? randomlySelectedUnplacedSeedValueIds : unplacedSeedNumberIds;
+  return {
+    nextSeedBlock,
+    unplacedSeedParticipantIds,
+    unplacedSeedNumbers,
+    unfilledPositions,
+    unplacedSeedAssignments
+  };
+  function randomlySelectLowestSeedValue(assignments, selectedParticipantIds2) {
+    const filteredAssignments = assignments.filter(
+      (assignment) => !selectedParticipantIds2.includes(assignment.participantId)
+    );
+    const lowestSeedValue = Math.min(
+      ...filteredAssignments.map(
+        (assignment) => getNumericSeedValue(assignment.seedValue)
+      )
+    );
+    const assignmentsWithLowestSeedValue = filteredAssignments.filter(
+      (assignment) => getNumericSeedValue(assignment.seedValue) === lowestSeedValue
+    );
+    const randomizedAssignments = shuffleArray(assignmentsWithLowestSeedValue);
+    return randomizedAssignments.pop();
   }
-  return {};
+}
+function getSeedPattern(seedingProfile) {
+  if (typeof seedingProfile === "string")
+    return seedingProfile;
+  if (typeof seedingProfile === "object")
+    return seedingProfile.positioning;
 }
 
 function getValidAssignmentActions({
@@ -13842,14 +14951,14 @@ function positionActions$1(params) {
         (assignment) => assignment.participantId === participantId
       ) || {};
       validActions.push({
-        type: REMOVE_SEED,
         method: REMOVE_SEED_METHOD,
+        type: REMOVE_SEED,
         participant,
         seedNumber,
         payload: {
-          drawId,
+          participantId,
           structureId,
-          participantId
+          drawId
         }
       });
     }
@@ -13860,11 +14969,11 @@ function positionActions$1(params) {
           method: ADD_PENALTY_METHOD,
           participant,
           payload: {
-            drawId,
             penaltyCode: void 0,
             penaltyType: void 0,
             participantIds: [],
-            notes: void 0
+            notes: void 0,
+            drawId
           }
         };
         validActions.push(addPenaltyAction);
@@ -13963,9 +15072,9 @@ function positionActions(params) {
   const { tournamentRecord } = params;
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  const { tournamentParticipants } = getTournamentParticipants({
-    tournamentRecord,
-    inContext: true
+  const { participants: tournamentParticipants } = getParticipants({
+    withIndividualParticipants: true,
+    tournamentRecord
   });
   return positionActions$1({
     tournamentParticipants,
@@ -13973,6 +15082,8 @@ function positionActions(params) {
   });
 }
 
+const hasParticipantId = (o) => o?.participantId;
+
 function getStructureGroups({ drawDefinition }) {
   const links = drawDefinition.links || [];
   const sourceStructureIds = {};
@@ -14217,7 +15328,7 @@ function getEventData(params) {
     event
   });
   const publishStatus = timeItem?.itemValue?.[status];
-  const { tournamentParticipants } = getTournamentParticipants({
+  const { participants: tournamentParticipants } = getParticipants({
     withGroupings: true,
     withEvents: false,
     withDraws: false,