tods-competition-factory 1.7.19 → 1.8.1

package/dist/forge/generate.mjs

@@ -1279,68 +1279,16 @@ function UUID() {
 const APPLIED_POLICIES = "appliedPolicies";
 const AUDIT_POSITION_ACTIONS = "positionActions";
 const CONTEXT = "context";
-const DELEGATED_OUTCOME = "delegatedOutcome";
-const DISABLED = "disabled";
 const DISABLE_LINKS = "disableLinks";
 const DISABLE_AUTO_CALC = "disableAutoCalc";
-const DRAW_DELETIONS = "drawDeletions";
-const DRAW_PROFILE = "drawProfile";
 const ENTRY_PROFILE = "entryProfile";
-const EVENT_PROFILE = "eventProfile";
-const FACTORY = "factory";
 const FLIGHT_PROFILE = "flightProfile";
-const GROUPING_ATTRIBUTE = "groupingAttribute";
 const LINEUPS = "lineUps";
 const LINKED_TOURNAMENTS = "linkedTournamentsIds";
-const MATCHUP_HISTORY = "matchUpHistory";
-const PARTICIPANT_REPRESENTATIVES = "participantRepresentatives";
-const PERSON_REQUESTS = "personRequests";
-const RANKING_POINTS = "rankingPoints";
 const ROUND_TARGET = "roundTarget";
-const SCHEDULE_LIMITS = "scheduleLimits";
 const SCHEDULE_TIMING = "scheduleTiming";
-const SCHEDULING_PROFILE = "schedulingProfile";
-const STATUS_DETAIL = "statusDetail";
 const SUB_ORDER = "subOrder";
 const TALLY = "tally";
-const TIE_FORMAT_MODIFICATIONS = "tieFormatModification";
-const extensionConstants = {
-  APPLIED_POLICIES,
-  AUDIT_POSITION_ACTIONS,
-  CONTEXT,
-  // used to capture, e.g. context in which a venue was added
-  DELEGATED_OUTCOME,
-  DISABLED,
-  DISABLE_LINKS,
-  DISABLE_AUTO_CALC,
-  DRAW_DELETIONS,
-  DRAW_PROFILE,
-  ENTRY_PROFILE,
-  // used for drawGeneration; not relevant for anonymized tournaments
-  EVENT_PROFILE,
-  FLIGHT_PROFILE,
-  GROUPING_ATTRIBUTE,
-  // for generating teams; not relevant for anonymized tournaments
-  LINEUPS,
-  LINKED_TOURNAMENTS,
-  MATCHUP_HISTORY,
-  PARTICIPANT_REPRESENTATIVES,
-  PERSON_REQUESTS,
-  RANKING_POINTS,
-  // for attaching points awarded to tournamentRecord
-  ROUND_TARGET,
-  SCHEDULE_LIMITS,
-  SCHEDULE_TIMING,
-  SCHEDULING_PROFILE,
-  STATUS_DETAIL,
-  // attached to event.entries
-  SUB_ORDER,
-  TALLY,
-  TIE_FORMAT_MODIFICATIONS,
-  // for auditing, not important when anonymized
-  FACTORY
-  // used for capturing versioning of factory and other TODS document processors
-};
 
 function getAppliedPolicies({
   onlySpecifiedPolicyTypes = false,
@@ -1794,9 +1742,7 @@ function getScheduleTiming({
   return { scheduleTiming };
 }
 
-const SINGLES_MATCHUP = "SINGLES";
 const SINGLES$1 = "SINGLES";
-const DOUBLES_MATCHUP = "DOUBLES";
 const DOUBLES$1 = "DOUBLES";
 const TEAM_MATCHUP = "TEAM";
 const TEAM$2 = "TEAM";
@@ -7596,24 +7542,6 @@ function getTimeItem({
     return { info: NOT_FOUND };
   }
 }
-function getEventTimeItem({
-  returnPreviousValues,
-  itemSubTypes,
-  itemType,
-  event
-}) {
-  if (!event)
-    return { error: MISSING_EVENT };
-  if (!event.timeItems)
-    return { info: NOT_FOUND };
-  const { timeItem, previousItems, info } = getTimeItem({
-    returnPreviousValues,
-    element: event,
-    itemSubTypes,
-    itemType
-  });
-  return timeItem && { timeItem, previousItems } || { info };
-}
 
 const typeMap = {
   [GROUP]: "groupParticipantIds",
@@ -7627,7 +7555,6 @@ const membershipMap = {
 function getParticipantMap({
   withIndividualParticipants,
   convertExtensions,
-  policyDefinitions,
   tournamentRecord,
   withSignInStatus,
   withScaleValues,
@@ -7635,32 +7562,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
@@ -7711,7 +7629,7 @@ function addIndividualParticipants({ participantMap }) {
 }
 function processIndividualParticipantIds({
   individualParticipantIds,
-  filteredParticipant,
+  participantCopy,
   participantMap,
   participantType,
   participantId
@@ -7726,7 +7644,7 @@ function processIndividualParticipantIds({
         participantName,
         participantId: participantId2,
         teamId
-      } = filteredParticipant;
+      } = participantCopy;
       const membership = membershipMap[participantType];
       individualParticipant[membership].push({
         participantRoleResponsibilities,
@@ -7789,7 +7707,6 @@ function initializeParticipantId({ participantMap, participantId }) {
 function hydrateParticipants({
   participantsProfile,
   useParticipantMap,
-  policyDefinitions,
   tournamentRecord,
   contextProfile,
   inContext
@@ -7798,7 +7715,6 @@ function hydrateParticipants({
     const participantMap = getParticipantMap({
       ...participantsProfile,
       ...contextProfile,
-      policyDefinitions,
       tournamentRecord
     })?.participantMap;
     return { participantMap };
@@ -15262,7 +15178,7 @@ function getParticipantResults({
               }
             }
           }
-          processMatchUp$1({
+          processMatchUp({
             matchUpFormat: tieMatchUp.matchUpFormat,
             matchUpStatus: tieMatchUp.matchUpStatus,
             score: tieMatchUp.score,
@@ -15282,7 +15198,7 @@ function getParticipantResults({
           matchUpStatus
         });
       } else {
-        processMatchUp$1({
+        processMatchUp({
           matchUpFormat: matchUp.matchUpFormat || matchUpFormat,
           isTieMatchUp: void 0,
           winningParticipantId,
@@ -15407,7 +15323,7 @@ function processScore({
     }
   });
 }
-function processMatchUp$1({
+function processMatchUp({
   winningParticipantId,
   losingParticipantId,
   participantResults,
@@ -17695,125 +17611,30 @@ function generateAndPopulatePlayoffStructures(params) {
   };
 }
 
-function getDerivedPositionAssignments({
-  derivedDrawInfo,
-  participantId,
-  drawId
-}) {
-  const mainPositionAssignment = derivedDrawInfo[drawId]?.mainPositionAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const qualifyingPositionAssignment = derivedDrawInfo[drawId]?.qualifyingPositionAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const positionAssignments = {};
-  if (mainPositionAssignment) {
-    const { participantId: participantId2, ...props } = mainPositionAssignment;
-    if (participantId2)
-      positionAssignments[MAIN] = { ...props };
-  }
-  if (qualifyingPositionAssignment) {
-    const { participantId: participantId2, ...props } = qualifyingPositionAssignment;
-    if (participantId2)
-      positionAssignments[QUALIFYING] = { ...props };
-  }
-  return Object.keys(positionAssignments).length ? positionAssignments : void 0;
-}
-
-function getRelevantParticipantIdsMap({
-  processParticipantId,
-  // optional method which is passed each participantId
-  tournamentRecords,
-  tournamentRecord
-}) {
-  if (typeof tournamentRecord !== "object" && typeof tournamentRecords !== "object")
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const allParticipants = tournamentRecords ? Object.values(tournamentRecords).map((tournamentRecord2) => tournamentRecord2?.participants || []).flat() : tournamentRecord?.participants || [];
-  const relevantParticipantIdsMap = Object.assign(
-    {},
-    ...allParticipants.map(
-      ({ participantId, participantType, individualParticipantIds }) => {
-        typeof processParticipantId === "function" && processParticipantId(participantId);
-        const individualParticipantIdObjects = (individualParticipantIds || []).map((relevantParticipantId) => ({
-          participantType: INDIVIDUAL,
-          relevantParticipantId
-        }));
-        return {
-          [participantId]: individualParticipantIdObjects.concat({
-            relevantParticipantId: participantId,
-            participantType
-          })
-        };
-      }
-    )
-  );
-  return { relevantParticipantIdsMap };
-}
-
-function getDerivedSeedAssignments({
-  derivedDrawInfo,
-  participantId,
-  drawId
-}) {
-  const mainSeedAssignment = derivedDrawInfo[drawId]?.mainSeedAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const qualifyingSeedAssignment = derivedDrawInfo[drawId]?.qualifyingSeedAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const seedAssignments = {};
-  if (mainSeedAssignment) {
-    const { participantId: participantId2, ...props } = mainSeedAssignment;
-    if (participantId2)
-      seedAssignments[MAIN] = { ...props };
-  }
-  if (qualifyingSeedAssignment) {
-    const { participantId: participantId2, ...props } = qualifyingSeedAssignment;
-    if (participantId2)
-      seedAssignments[QUALIFYING] = { ...props };
-  }
-  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 = []
-}) {
-  if (!validMatchUps(matchUps))
-    return { error: MISSING_MATCHUPS };
-  if (!Array.isArray(scheduleAttributes))
-    return { error: INVALID_VALUES };
-  const scheduledMatchUps = matchUps.filter(Boolean).filter(({ schedule }) => hasSchedule({ schedule, scheduleAttributes })).reduce((dateMatchUps, matchUp) => {
-    const { schedule } = matchUp;
-    const date = extractDate(schedule?.scheduledDate);
-    const time = extractTime(schedule?.scheduledTime);
-    if (date && time) {
-      if (dateMatchUps[date]) {
-        dateMatchUps[date].push(matchUp);
-      } else {
-        dateMatchUps[date] = [matchUp];
-      }
-    }
-    return dateMatchUps;
-  }, {});
-  const dates = Object.keys(scheduledMatchUps);
-  dates.forEach((date) => {
-    scheduledMatchUps[date].sort(
-      (a, b) => timeSort(
-        extractTime(a.schedule?.scheduledTime),
-        extractTime(b.schedule?.scheduledTime)
-      )
-    );
+function getEventPublishStatuses({ event }) {
+  const itemType = `${PUBLISH}.${STATUS}`;
+  const { timeItem } = getTimeItem({
+    element: event,
+    itemType
   });
-  return { scheduledMatchUps };
+  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 void 0;
 }
 
 function participantScaleItem({
@@ -17855,871 +17676,968 @@ function participantScaleItem({
   return { error: MISSING_PARTICIPANT };
 }
 
-function annotateParticipant(params) {
-  const {
-    withScaleValues = true,
-    eventsPublishStatuses,
-    withEvents = true,
-    withDraws = true,
-    participantIdMap,
-    scheduleAnalysis,
-    derivedDrawInfo,
-    usePublishState,
-    withStatistics,
-    withOpponents,
-    withMatchUps,
-    withSeeding,
-    participant,
-    withISO2,
-    withIOC
-  } = params;
-  const scheduleConflicts = [];
-  const scheduleItems = [];
-  if (withIOC || withISO2)
-    addNationalityCode({ participant, withIOC, withISO2 });
-  if (withScaleValues) {
-    const { ratings, rankings } = getScaleValues({ participant });
-    participant.rankings = rankings;
-    participant.ratings = ratings;
-  }
-  const participantId = participant?.participantId;
-  if (!participantId || !participantIdMap[participantId])
-    return {};
-  const {
-    potentialMatchUps,
-    opponents,
-    matchUps,
-    events,
-    losses,
-    draws,
-    wins
-  } = participantIdMap[participantId];
-  const denominator = wins + losses;
-  const numerator = wins;
-  const statValue = denominator && numerator / denominator;
-  const winRatioStat = {
-    statCode: WIN_RATIO$1,
-    denominator,
-    numerator,
-    statValue
-  };
-  const participantDraws = Object.values(draws);
-  const participantEvents = Object.values(events);
-  if (withDraws && participantDraws) {
-    participant.draws = participantDraws;
-    for (const participantDraw of participantDraws) {
-      const publishedSeeding = eventsPublishStatuses[participantDraw.eventId]?.publishedSeeding;
-      const seedingPublished = !usePublishState || publishedSeeding?.published && (publishedSeeding?.drawIds?.length === 0 || publishedSeeding?.drawIds?.includes(participantDraw.drawId));
-      if (seedingPublished) {
-        const seedAssignments = getDerivedSeedAssignments({
-          drawId: participantDraw.drawId,
-          derivedDrawInfo,
-          participantId
-        });
-        if (seedAssignments) {
-          participantDraw.seedAssignments = seedAssignments;
-        }
+function getEventSeedAssignments({
+  publishedSeeding,
+  usePublishState,
+  withSeeding,
+  participant,
+  event
+}) {
+  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 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 (withEvents && participantEvents) {
-    participant.events = participantEvents;
-    if (withSeeding) {
-      const seedingScales = Object.assign(
-        {},
-        ...(participant.timeItems || []).filter(({ itemType }) => itemType.split(".")[1] === SEEDING).map(({ itemType: seedingScaleName, itemValue: seedValue }) => ({
-          [seedingScaleName]: seedValue
-        }))
-      );
-      for (const participantEvent of participantEvents) {
-        const getScaleAccessor = (scaleName) => [SCALE, SEEDING, participantEvent.eventType, scaleName].join(".");
-        const publishedSeeding = eventsPublishStatuses[participantEvent.eventId]?.publishedSeeding;
-        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);
-            participantEvent.seedAssignments = seedAssignments;
-          } else if (publishedEventSeedingScaleNames) {
-            const seedValues = publishedEventSeedingScaleNames.map(
-              (scaleName) => seedingScales[scaleName]
-            );
-            participantEvent.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);
-          participantEvent.seedAssignments = seedAssignments;
-        } else {
-          const { categoryName, ageCategoryCode } = participantEvent.category || {};
-          let scaleItem;
-          for (const scaleName of [
-            participantEvent.eventId,
-            ageCategoryCode,
-            categoryName
-          ]) {
-            const scaleAttributes = {
-              eventType: participantEvent.eventType,
-              scaleType: SEEDING,
-              scaleName
-            };
-            const result = participantScaleItem({
-              scaleAttributes,
-              participant
-            });
-            if (result.scaleItem) {
-              scaleItem = result.scaleItem;
-              break;
-            }
-          }
-          if (scaleItem) {
-            const seedValue = scaleItem.scaleValue;
-            const seedingPublished = !usePublishState || publishedSeeding?.published && (publishedSeeding?.drawIds?.length === 0 || publishedSeeding?.drawIds?.includes(
-              participantEvent.drawId
-            ));
-            if (seedingPublished) {
-              participantEvent.seedValue = seedValue;
-            }
-          }
-        }
-        if (participantEvent.drawIds?.length) {
-          for (const flightDrawId of participantEvent.drawIds || []) {
-            const drawSeedPublishingDisabled = publishedSeeding?.drawIds?.length && !publishedSeeding?.drawIds?.includes(flightDrawId);
-            if (eventSeedingPublished && !drawSeedPublishingDisabled) {
-              const seedAssignments = getDerivedSeedAssignments({
-                drawId: flightDrawId,
-                derivedDrawInfo,
-                participantId
-              });
-              if (seedAssignments && participantEvent.seedAssignments) {
-                for (const key of Object.keys(
-                  participantEvent.seedAssignments
-                )) {
-                  participantEvent.seedAssignments[key] = seedAssignments[key];
-                }
-              } else {
-                participantEvent.seedAssignments = seedAssignments;
-              }
-            }
-          }
-        }
+    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 participantOpponents = Object.values(opponents).flat();
-  if (withOpponents && participantOpponents?.length) {
-    participant.opponents = participantOpponents;
-    participantDraws?.forEach((draw) => {
-      draw.opponents = participantOpponents.filter(
-        (opponent) => opponent.drawId === draw.drawId
-      );
-    });
-  }
-  const participantPotentialMatchUps = Object.values(potentialMatchUps);
-  const participantMatchUps = Object.values(matchUps);
-  if (withMatchUps) {
-    participant.potentialMatchUps = participantPotentialMatchUps;
-    participant.matchUps = participantMatchUps;
-  }
-  const allParticipantMatchUps = participantMatchUps.concat(
-    participantPotentialMatchUps
-  );
-  const scheduledMatchUps = participantScheduledMatchUps({
-    matchUps: allParticipantMatchUps
-  })?.scheduledMatchUps || [];
-  const { scheduledMinutesDifference } = scheduleAnalysis || {};
-  const dates = Object.keys(scheduledMatchUps);
-  dates.forEach((date) => {
-    scheduledMatchUps[date].filter(Boolean).forEach((matchUp, i) => {
-      const {
-        schedule: {
-          scheduledTime,
-          timeAfterRecovery,
-          typeChangeTimeAfterRecovery
-        },
-        matchUpStatus,
-        roundPosition,
-        structureName,
-        matchUpType,
-        roundNumber,
-        matchUpId,
-        drawId,
-        score
-      } = matchUp;
-      scheduleItems.push({
-        ...matchUp.schedule,
-        scheduledTime: extractTime(matchUp.schedule?.scheduledTime),
-        roundPosition,
-        structureName,
-        matchUpType,
-        roundNumber,
-        matchUpId,
-        drawId
-      });
-      const ignoreMatchUp = matchUpStatus === BYE || [WALKOVER$1, DEFAULTED].includes(matchUpStatus) && !scoreHasValue({ score });
-      if (scheduledTime && !ignoreMatchUp) {
-        const scheduledMinutes = timeStringMinutes(scheduledTime);
-        const matchUpsToConsider = scheduledMatchUps[date].slice(i + 1);
-        for (const consideredMatchUp of matchUpsToConsider) {
-          const ignoreMatchUp2 = consideredMatchUp.matchUpStatus === BYE || [WALKOVER$1, DEFAULTED].includes(consideredMatchUp.matchUpStatus) && !scoreHasValue(consideredMatchUp);
-          if (!ignoreMatchUp2 && consideredMatchUp.schedule?.scheduledTime) {
-            const typeChange = matchUp.matchUpType !== consideredMatchUp.matchUpType;
-            const notBeforeTime = typeChange ? typeChangeTimeAfterRecovery || timeAfterRecovery : timeAfterRecovery;
-            const sameDraw = matchUp.drawId === consideredMatchUp.drawId;
-            const bothPotential = matchUp.potential && consideredMatchUp.potential;
-            const nextMinutes = timeStringMinutes(
-              consideredMatchUp.schedule?.scheduledTime
-            );
-            const minutesDifference = nextMinutes - scheduledMinutes;
-            const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : timeStringMinutes(notBeforeTime) > timeStringMinutes(consideredMatchUp.schedule?.scheduledTime);
-            if (timeOverlap && !(bothPotential && sameDraw)) {
-              scheduleConflicts.push({
-                priorScheduledMatchUpId: consideredMatchUp.matchUpId,
-                matchUpIdWithConflict: matchUpId
-              });
-            }
-          }
-        }
-      }
-    });
-  });
-  if (withStatistics)
-    participant.statistics = [winRatioStat];
-  return { scheduleConflicts, scheduleItems };
+  return eventSeedAssignments;
 }
 
-function getDrawDetails({
-  eventEntries,
-  sortConfig,
-  event
+function processEventEntry({
+  extensionConversions,
+  seedAssignments,
+  participant,
+  withSeeding,
+  seedValue,
+  eventId,
+  ranking,
+  entry
 }) {
-  const derivedInfo = {};
-  const drawDetails = Object.assign(
-    {},
-    ...(event.drawDefinitions ?? []).map((drawDefinition) => {
-      const entriesMap = Object.assign(
-        {},
-        ...(eventEntries ?? []).filter((entry) => entry.participantId).map((entry) => ({ [entry.participantId]: entry })),
-        ...drawDefinition.entries.filter((entry) => entry.participantId).map((entry) => ({ [entry.participantId]: entry }))
-      );
-      const drawEntries = Object.values(entriesMap);
-      const mainStructure = getDrawStructures({
-        stageSequence: 1,
-        drawDefinition,
-        stage: MAIN
-      })?.structures?.[0];
-      const mainPositionAssignments = mainStructure && getPositionAssignments({
-        structure: mainStructure
-      })?.positionAssignments;
-      const drawSize = mainPositionAssignments?.length;
-      const qualifyingStructure = getDrawStructures({
-        stageSequence: 1,
-        stage: QUALIFYING,
-        drawDefinition
-      })?.structures?.[0];
-      const qualifyingPositionAssignments = mainStructure && getPositionAssignments({
-        structure: qualifyingStructure
-      })?.positionAssignments;
-      const qualifyingDrawSize = qualifyingPositionAssignments?.length;
-      const mainSeedAssignments = mainStructure?.seedAssignments;
-      const qualifyingSeedAssignments = qualifyingStructure?.seedAssignments;
-      const orderedStructureIds = (drawDefinition.structures || []).sort((a, b) => structureSort(a, b, sortConfig)).map(({ structureId, structures }) => {
-        return [
-          structureId,
-          ...(structures || []).map(({ structureId: structureId2 }) => structureId2)
-        ];
-      }).flat(Infinity);
-      const flightNumber = event?._flightProfile?.flights?.find(
-        (flight) => flight.drawId === drawDefinition.drawId
-      )?.flightNumber;
-      derivedInfo[drawDefinition.drawId] = {
-        qualifyingPositionAssignments,
-        qualifyingSeedAssignments,
-        mainPositionAssignments,
-        mainSeedAssignments,
-        orderedStructureIds,
-        qualifyingDrawSize,
-        flightNumber,
-        drawSize
-      };
-      return {
-        [drawDefinition.drawId]: {
-          drawType: drawDefinition.drawType,
-          drawEntries
-        }
-      };
-    })
+  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 { derivedInfo, drawDetails };
+  if (withSeeding) {
+    if (seedAssignments)
+      participant.events[eventId].seedAssignments = seedAssignments;
+    if (seedValue)
+      participant.events[eventId].seedValue = seedValue;
+  }
 }
 
-function processMatchUp({
-  relevantParticipantIdsMap,
-  participantFilters,
-  participantIdMap,
-  derivedDrawInfo,
-  eventDrawsCount,
-  drawDetails,
-  eventType,
-  matchUp
-}) {
+function addScheduleItem(params) {
   const {
-    collectionId,
-    collectionPosition,
-    drawId,
-    drawName,
-    eventId,
-    eventName,
-    finishingRound,
-    finishingPositionRange,
-    processCodes,
-    loserTo,
-    matchUpId,
-    matchUpType,
-    matchUpFormat,
+    participantMap,
+    participantId,
     matchUpStatus,
-    matchUpStatusCodes,
-    matchUpTieId,
-    roundName,
-    roundNumber,
     roundPosition,
-    score,
-    sides,
-    stage,
-    stageSequence,
-    schedule,
-    structureName,
     structureId,
-    tieFormat,
-    tieMatchUps,
-    tournamentId,
-    winnerTo,
-    winningSide
-  } = matchUp;
-  const targetParticipantIds = participantFilters?.participantIds;
-  const getRelevantParticipantIds = (participantId) => {
-    const relevantParticipantIds = participantId && relevantParticipantIdsMap[participantId] || [];
-    relevantParticipantIds.push(participantId);
-    return relevantParticipantIds.some(
-      (obj) => !targetParticipantIds || targetParticipantIds.includes(obj.relevantParticipantId)
-    ) ? relevantParticipantIds : [];
-  };
-  const { winner, loser } = finishingPositionRange || {};
-  const doublesTieParticipants = tieMatchUps?.length && tieMatchUps.filter(({ matchUpType: matchUpType2 }) => matchUpType2 === DOUBLES_MATCHUP).map(
-    ({ sides: sides2 }) => sides2.map(
-      ({ sideNumber, participantId, participant }) => sideNumber && participantId && {
-        sideNumber,
-        participantId,
-        participant
-      }
-    )
-  ).flat().filter(Boolean) || [];
-  if (eventType === TEAM_EVENT && matchUpType === DOUBLES_MATCHUP) {
-    const participants = (matchUp.sides?.filter(Boolean) || []).map(
-      ({ sideNumber, participantId, participant }) => sideNumber && participantId && {
-        sideNumber,
-        participantId,
-        participant
-      }
-    ).filter(Boolean);
-    doublesTieParticipants.push(...participants);
-  }
-  sides?.forEach((params) => {
-    const { participantId, sideNumber } = params;
-    if (!participantId)
-      return;
-    const { drawType, drawEntries } = drawDetails[drawId];
-    const participantScore = sideNumber === 1 ? score?.scoreStringSide1 : score?.scoreStringSide2;
-    const participantWon = winningSide && sideNumber === winningSide;
-    const opponent = matchUp.sides.find(
-      (side) => side.sideNumber === 3 - sideNumber
-    );
-    const opponentParticipantId = opponent?.participantId;
-    const relevantOpponents = opponentParticipantId && relevantParticipantIdsMap[opponentParticipantId] || [];
-    const finishingPositionRange2 = participantWon ? winner : loser;
-    const drawEntry = drawEntries.find(
-      (entry) => entry.participantId === participantId
-    );
-    const relevantParticipantIds = getRelevantParticipantIds(participantId);
-    const addedPairParticipantIds = [];
-    doublesTieParticipants?.filter((participant) => participant.sideNumber === sideNumber).forEach((p) => {
-      const participantId2 = p.participantId;
-      if (participantId2 && !addedPairParticipantIds.includes(participantId2)) {
-        relevantParticipantIds.push({
-          relevantParticipantId: participantId2,
-          participantType: PAIR
-        });
-        addedPairParticipantIds.push(participantId2);
-      }
+    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
     });
-    const filteredRelevantParticipantIds = relevantParticipantIds.filter(
-      (opponent2) => {
-        return eventType !== TEAM_EVENT || eventType === TEAM_EVENT && [DOUBLES_MATCHUP, TEAM_MATCHUP].includes(matchUpType) && [PAIR, TEAM_PARTICIPANT].includes(opponent2.participantType) || eventType === TEAM_EVENT && [SINGLES_MATCHUP, DOUBLES_MATCHUP].includes(matchUpType) && [INDIVIDUAL].includes(opponent2.participantType);
-      }
-    );
-    filteredRelevantParticipantIds?.forEach(
-      ({ relevantParticipantId, participantType }) => {
-        const { entryStage, entryStatus, entryPosition } = drawEntry || {};
-        if (!participantIdMap[relevantParticipantId])
-          return;
-        if (!participantIdMap[relevantParticipantId].draws[drawId]) {
-          const positionAssignments = getDerivedPositionAssignments({
-            participantId: relevantParticipantId,
-            derivedDrawInfo,
-            drawId
-          });
-          const seedAssignments = getDerivedSeedAssignments({
-            participantId: relevantParticipantId,
-            derivedDrawInfo,
-            drawId
-          });
-          participantIdMap[relevantParticipantId].draws[drawId] = definedAttributes({
-            qualifyingDrawSize: derivedDrawInfo[drawId]?.qualifyingDrawSize,
-            drawSize: derivedDrawInfo[drawId]?.drawSize,
-            partnerParticipantIds: [],
-            positionAssignments,
-            seedAssignments,
-            entryPosition,
-            entryStatus,
-            entryStage,
-            drawName,
-            drawType,
-            eventId,
-            drawId
-          });
+  }
+}
+
+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;
+    }
+  }
+  if (finishingPositionRange && (!structureParticipation.finishingPositionRange || diff(finishingPositionRange) < diff(structureParticipation.finishingPositionRange))) {
+    structureParticipation.finishingPositionRange = finishingPositionRange;
+  }
+  if (finishingRound) {
+    if (!structureParticipation.finishingRound || finishingRound < structureParticipation.finishingRound) {
+      structureParticipation.finishingMatchUpId = matchUpId;
+      structureParticipation.finishingRound = finishingRound;
+      structureParticipation.roundNumber = roundNumber;
+    }
+    if (finishingRound === 1) {
+      structureParticipation.participantWon = participantWon;
+    }
+  }
+}
+
+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 (!participantIdMap[relevantParticipantId].events[eventId]) {
-          participantIdMap[relevantParticipantId].events[eventId] = {
-            partnerParticipantIds: [],
-            drawIds: [],
-            eventName,
-            eventId
-          };
+      ];
+      if (participantType !== TEAM_PARTICIPANT) {
+        for (const participantId2 of opponent?.individualParticipantIds || []) {
+          const participant = participantMap[participantId2]?.participant;
+          info.push({
+            participantType: participant?.participantType,
+            participantId: participantId2
+          });
         }
-        const eventDrawIds = participantIdMap[relevantParticipantId].events[eventId].drawIds;
-        if (eventDrawIds && !eventDrawIds?.includes(drawId)) {
-          participantIdMap[relevantParticipantId].events[eventId].drawIds.push(
-            drawId
+      }
+      return info;
+    };
+    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;
         }
-        let partnerParticipantId;
-        if (participantType === INDIVIDUAL && matchUpType === DOUBLES_MATCHUP) {
-          const relevantParticipantInfo = filteredRelevantParticipantIds.find(
-            (participantInfo) => {
-              return participantInfo.relevantParticipantId !== relevantParticipantId && participantInfo.participantType === INDIVIDUAL;
-            }
-          );
-          partnerParticipantId = relevantParticipantInfo?.relevantParticipantId;
+        if (collectionId) {
+          participantMap[participantId2].matchUps[matchUpId].collectionId = collectionId;
         }
-        const filteredRelevantOpponents = relevantOpponents?.filter(
-          (opponent2) => matchUpType === TEAM_MATCHUP && participantType === TEAM_PARTICIPANT && opponent2.participantType === TEAM_PARTICIPANT || matchUpType === SINGLES_MATCHUP && opponent2.participantType === INDIVIDUAL || matchUpType === DOUBLES_MATCHUP && (participantType === INDIVIDUAL ? [INDIVIDUAL, PAIR].includes(opponent2.participantType) : (
-            // for PAIR participants only show PAIR opponenents
-            opponent2.participantType === PAIR
-          ))
-        ) || [];
-        filteredRelevantOpponents.forEach(
-          ({
-            relevantParticipantId: opponentParticipantId2,
-            participantType: opponentParticipantType
-          }) => {
-            if (!participantIdMap[relevantParticipantId].opponents) {
-              participantIdMap[relevantParticipantId].opponents = {};
-            }
-            participantIdMap[relevantParticipantId].opponents[opponentParticipantId2] = {
-              eventId,
-              drawId,
-              matchUpId,
-              participantType: opponentParticipantType,
-              participantId: opponentParticipantId2
-            };
-          }
+      }
+      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);
+        }
+      };
+      if (withDraws)
+        addPartnerParticiapntId(
+          participant?.draws?.[drawId],
+          partnerParticipantId
         );
-        const opponentParticipantInfo = filteredRelevantOpponents.map(
-          ({ relevantParticipantId: relevantParticipantId2, participantType: participantType2 }) => ({
-            participantId: relevantParticipantId2,
-            participantType: participantType2
-          })
+      if (withEvents) {
+        addPartnerParticiapntId(
+          participant?.events?.[eventId],
+          partnerParticipantId
         );
-        const includeMatchUp = matchUpType !== TEAM_MATCHUP && [INDIVIDUAL, PAIR].includes(participantType) || matchUpType === TEAM_MATCHUP && participantType === TEAM_PARTICIPANT;
-        if (includeMatchUp)
-          participantIdMap[relevantParticipantId].matchUps[matchUpId] = definedAttributes({
-            collectionId,
-            collectionPosition,
-            drawId,
+      }
+      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,
-            eventType,
-            eventDrawsCount,
-            finishingRound,
-            finishingPositionRange: finishingPositionRange2,
-            loserTo,
-            matchUpId,
-            matchUpType,
-            matchUpFormat,
-            matchUpStatus,
-            matchUpStatusCodes,
-            matchUpTieId,
-            opponentParticipantInfo,
-            participantWon,
-            partnerParticipantId,
-            perspectiveScoreString: participantScore,
-            processCodes,
-            roundName,
-            roundNumber,
-            roundPosition,
-            schedule,
-            score,
-            sides,
-            stage,
-            stageSequence,
-            structureName,
-            structureId,
-            tieFormat,
-            tournamentId,
-            winnerTo,
-            winningSide
-          });
-        if (partnerParticipantId) {
-          participantIdMap[relevantParticipantId].events[eventId].partnerParticipantIds.push(partnerParticipantId);
-          participantIdMap[relevantParticipantId].draws[drawId].partnerParticipantIds.push(partnerParticipantId);
-          participantIdMap[relevantParticipantId].events[eventId].partnerParticipantId = partnerParticipantId;
-          participantIdMap[relevantParticipantId].draws[drawId].partnerParticipantId = partnerParticipantId;
+            drawId
+          };
+          addDrawData(participantId);
+          individualParticipantIds.forEach(addDrawData);
         }
-        if (winningSide) {
+      }
+      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) {
-            participantIdMap[relevantParticipantId].wins++;
+            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 {
-            participantIdMap[relevantParticipantId].losses++;
+            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);
       }
-    );
-  });
-  if (Array.isArray(matchUp.potentialParticipants)) {
-    const potentialParticipantIds = getParticipantIds(
-      matchUp.potentialParticipants.flat()
-    );
-    potentialParticipantIds?.forEach((participantId) => {
-      const relevantParticipantIds = getRelevantParticipantIds(participantId);
-      relevantParticipantIds?.forEach(({ relevantParticipantId }) => {
-        participantIdMap[relevantParticipantId].potentialMatchUps[matchUpId] = definedAttributes({
-          drawId,
-          eventId,
-          eventType,
-          matchUpId,
-          matchUpType,
-          matchUpFormat,
-          roundName,
-          roundNumber,
-          roundPosition,
-          schedule,
-          tieFormat,
-          structureName,
-          tournamentId,
-          potential: true
-        });
-      });
-    });
+    }
   }
 }
 
-function addParticipantContext(params) {
-  const participantIdsWithConflicts = [];
-  const eventsPublishStatuses = {};
-  const derivedDrawInfo = {};
-  const participantIdMap = {};
-  const initializeParticipantId = (participantId) => {
-    if (!participantIdMap[participantId])
-      participantIdMap[participantId] = {
-        groupParticipantIds: [],
-        teamParticipantIds: [],
-        pairParticipantIds: [],
-        potentialMatchUps: {},
-        scheduleItems: [],
-        opponents: {},
-        matchUps: {},
-        events: {},
-        groups: [],
-        teams: [],
-        draws: {},
-        losses: 0,
-        wins: 0
-      };
-  };
-  const { tournamentRecord, participantFilters, allTournamentParticipants } = params;
-  const { relevantParticipantIdsMap } = getRelevantParticipantIdsMap({
-    processParticipantId: initializeParticipantId,
-    tournamentRecord
-  });
+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 && relevantParticipantIdsMap[participantId] || [];
+    const relevantParticipantIds = [participantId];
     relevantParticipantIds.push(participantId);
+    participantMap[participantId]?.participant.individualParticipantIds?.forEach(
+      (individualParticiapntId) => relevantParticipantIds.push(individualParticiapntId)
+    );
     return relevantParticipantIds.some(
-      (obj) => !targetParticipantIds || targetParticipantIds.includes(obj.relevantParticipantId)
+      (obj) => !targetParticipantIds?.length || targetParticipantIds.includes(obj.relevantParticipantId)
     ) ? relevantParticipantIds : [];
   };
-  params.withGroupings && allTournamentParticipants.forEach((participant) => {
-    if (participant.participantType === GROUP) {
-      const groupParticipantId = participant.participantId;
-      participant?.individualParticipantIds?.forEach((participantId) => {
-        if (!participantIdMap[participantId].groupParticipantIds.includes(
-          groupParticipantId
-        )) {
-          participantIdMap[participantId].groupParticipantIds.push(
-            groupParticipantId
-          );
-          participantIdMap[participantId].groups.push({
-            participantRoleResponsibilities: participant.participantRoleResponsibilities,
-            participantOtherName: participant.participantOtherName,
-            participantName: participant.participantName,
-            participantId: participant.participantId
-          });
+  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
+          }));
         }
-      });
+        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);
+      }
     }
-    if (participant.participantType === TEAM$2) {
-      const teamParticipantId = participant.participantId;
-      participant?.individualParticipantIds?.forEach((participantId) => {
-        if (!participantIdMap[participantId]?.teamParticipantIds?.includes(
-          teamParticipantId
-        )) {
-          participantIdMap[participantId]?.teamParticipantIds.push(
-            teamParticipantId
-          );
-          participantIdMap[participantId]?.teams.push({
-            participantRoleResponsibilities: participant.participantRoleResponsibilities,
-            participantOtherName: participant.participantOtherName,
-            participantName: participant.participantName,
-            participantId: participant.participantId,
-            teamId: participant.teamId
+    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 (participant.participantType === PAIR) {
-      const pairParticipantId = participant.participantId;
-      participant?.individualParticipantIds?.forEach((participantId) => {
-        if (participantIdMap[participantId] && !participantIdMap[participantId].pairParticipantIds.includes(
-          pairParticipantId
-        )) {
-          participantIdMap[participantId].pairParticipantIds.push(
-            pairParticipantId
-          );
+    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 (params.withMatchUps) {
-    getMatchUpDependencies({ tournamentRecord });
-  }
-  if (params.withScheduleItems || params.scheduleAnalysis || params.withStatistics || params.withOpponents || params.withMatchUps || params.withSeeding || params.withEvents || params.withDraws) {
-    params.tournamentEvents?.forEach((rawEvent) => {
-      const event = makeDeepCopy(rawEvent, true, true);
-      const flightProfile = getFlightProfile({ event }).flightProfile;
-      const eventDrawsCount = flightProfile?.flights?.length || event.drawDefinitions?.length || 0;
-      (event.drawDefinitions || []).forEach((drawDefinition, i) => {
-        if (event?.eventType === TEAM$2) {
-          const { extension } = findExtension$1({
-            element: rawEvent.drawDefinitions[i],
-            // rawEvent because deepCopy has converted extensions
-            name: LINEUPS
+        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
+              });
+            }
           });
-          if (extension)
-            drawDefinition.extensions = [extension];
         }
-      });
-      const { eventId, eventName, eventType, category } = event;
-      const eventInfo = { eventId, eventName, eventType, category };
-      const extensionKeys = event && Object.keys(event).filter((key) => key.startsWith("_"));
-      extensionKeys?.forEach(
-        (extensionKey) => eventInfo[extensionKey] = event[extensionKey]
-      );
-      const eventEntries = event.entries || [];
-      const itemType = `${PUBLISH}.${STATUS}`;
-      const { timeItem } = getEventTimeItem({
-        itemType,
-        event
-      });
-      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);
-        eventsPublishStatuses[eventId] = {
-          publishedDrawIds,
-          publishedSeeding
+      }
+      matchUps.push(...eventMatchUps);
+    }
+  }
+  if (withStatistics || withRankingProfile || !!scheduleAnalysis) {
+    const aggregators = Object.values(participantMap);
+    for (const participantAggregator of aggregators) {
+      const {
+        wins,
+        losses,
+        [SINGLES$1]: { wins: singlesWins, losses: singlesLosses },
+        [DOUBLES$1]: { 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$1, wins, losses);
+        addStatValue(`${WIN_RATIO$1}.${SINGLES$1}`, singlesWins, singlesLosses);
+        addStatValue(`${WIN_RATIO$1}.${DOUBLES$1}`, doublesWins, doublesLosses);
       }
-      const disallowedConstants = [
-        ...Object.values(extensionConstants)
-      ];
-      const disallowedKeys = disallowedConstants.map(
-        (constant) => `_${constant}`
-      );
-      const filteredEventInfo = eventInfo && Object.keys(eventInfo).filter((key) => !disallowedKeys.includes(key)).reduce((obj, key) => {
-        obj[key] = eventInfo[key];
-        return obj;
-      }, {});
-      eventEntries?.filter((entry) => entry?.participantId).forEach((entry) => {
-        const { participantId, entryStage, entryStatus, entryPosition } = entry;
-        const relevantParticipantIds = getRelevantParticipantIds(participantId);
-        relevantParticipantIds?.forEach(({ relevantParticipantId }) => {
-          if (!participantIdMap[relevantParticipantId])
-            initializeParticipantId(relevantParticipantId);
-          participantIdMap[relevantParticipantId].events[eventId] = {
-            ...filteredEventInfo,
-            partnerParticipantIds: [],
-            entryPosition,
-            entryStatus,
-            entryStage,
-            drawIds: [],
-            eventId
-          };
-        });
-      });
-      const addDrawData = ({ drawEntry, drawId }) => {
-        const { participantId, entryStage, entryStatus, entryPosition } = drawEntry;
-        const relevantParticipantIds = getRelevantParticipantIds(participantId);
-        relevantParticipantIds?.forEach(({ relevantParticipantId }) => {
-          if (!participantIdMap[relevantParticipantId].events[eventId]) {
-            participantIdMap[relevantParticipantId].events[eventId] = {
-              ...filteredEventInfo,
-              partnerParticipantIds: [],
-              entryPosition,
-              entryStatus,
-              entryStage,
-              drawIds: [],
-              eventId
-            };
-          }
-          if (!participantIdMap[relevantParticipantId].draws[drawId]) {
-            const positionAssignments = getDerivedPositionAssignments({
-              participantId: relevantParticipantId,
-              derivedDrawInfo,
-              drawId
-            });
-            const seedAssignments = getDerivedSeedAssignments({
-              participantId: relevantParticipantId,
-              derivedDrawInfo,
-              drawId
-            });
-            participantIdMap[relevantParticipantId].draws[drawId] = definedAttributes({
-              qualifyingDrawSize: derivedDrawInfo[drawId]?.qualifyingDrawSize,
-              drawSize: derivedDrawInfo[drawId]?.drawSize,
-              partnerParticipantIds: [],
-              positionAssignments,
-              eventDrawsCount,
-              seedAssignments,
-              entryPosition,
-              entryStatus,
-              entryStage,
-              eventId,
-              drawId
-            });
-          }
-          const eventDrawIds = participantIdMap[relevantParticipantId].events[eventId].drawIds;
-          if (eventDrawIds && !eventDrawIds?.includes(drawId)) {
-            participantIdMap[relevantParticipantId].events[eventId].drawIds.push(drawId);
+      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;
+            }
           }
-        });
-      };
-      const drawIdsWithDefinitions = event.drawDefinitions?.map(({ drawId }) => drawId) || [];
-      eventInfo._flightProfile?.flights?.forEach((flight) => {
-        const { drawId, drawEntries } = flight;
-        if (!drawIdsWithDefinitions.includes(drawId)) {
-          drawEntries?.forEach(
-            (drawEntry) => addDrawData({ drawEntry, drawId })
-          );
         }
-      });
-      const { drawDetails, derivedInfo } = getDrawDetails({
-        eventEntries,
-        event
-      });
-      Object.assign(derivedDrawInfo, derivedInfo);
-      if (event.eventType === TEAM$2 || // for TEAM events some individual attributes can only be derived by processing
-      params.withScheduleItems || params.scheduleAnalysis || params.withStatistics || params.withOpponents || params.withMatchUps || params.withDraws) {
-        const matchUps = allEventMatchUps({
-          afterRecoveryTimes: params.scheduleAnalysis,
-          participants: allTournamentParticipants,
-          nextMatchUps: true,
-          tournamentRecord,
-          inContext: true,
-          event
-        })?.matchUps;
-        matchUps?.forEach(
-          (matchUp) => processMatchUp({
-            relevantParticipantIdsMap,
-            participantFilters,
-            participantIdMap,
-            derivedDrawInfo,
-            eventDrawsCount,
-            drawDetails,
-            eventType,
-            matchUp
-          })
-        );
       }
-    });
-  }
-  params.tournamentParticipants?.forEach((participant) => {
-    const { scheduleConflicts, scheduleItems } = annotateParticipant({
-      ...params,
-      eventsPublishStatuses,
-      participantIdMap,
-      derivedDrawInfo,
-      participant
-    });
-    if (params.withSignInStatus) {
-      const { timeItem } = getTimeItem({
-        itemType: SIGN_IN_STATUS,
-        element: participant
-      });
-      participant.signedIn = timeItem?.itemValue === SIGNED_IN;
-    }
-    if (params.withScheduleItems) {
-      participant.scheduleItems = scheduleItems;
-    }
-    if (params.scheduleAnalysis) {
-      participant.scheduleConflicts = scheduleConflicts;
-      if (scheduleConflicts?.length && !participantIdsWithConflicts.includes(participant.participantId)) {
-        participantIdsWithConflicts.push(participant.participantId);
+      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;
       }
     }
-    if (params.withGroupings !== false) {
-      const participantAttributes = participantIdMap[participant.participantId];
-      participant.groupParticipantIds = participantAttributes?.groupParticipantIds;
-      participant.pairParticipantIds = participantAttributes?.pairParticipantIds;
-      participant.teamParticipantIds = participantAttributes?.teamParticipantIds;
-      participant.groups = participantAttributes?.groups;
-      participant.teams = participantAttributes?.teams;
-    }
-    if (params.withTeamMatchUps) ;
-  });
-  return { participantIdsWithConflicts, eventsPublishStatuses };
+  }
+  return {
+    participantIdsWithConflicts,
+    eventsPublishStatuses,
+    derivedEventInfo,
+    derivedDrawInfo,
+    mappedMatchUps,
+    participantMap,
+    matchUps
+  };
 }
 
 function filterParticipants({
@@ -18839,117 +18757,134 @@ function getEventEntries({ eventEntryStatuses, tournamentEvents }) {
   );
 }
 
-function getTournamentParticipants(params) {
+function getParticipants(params) {
   const {
+    withIndividualParticipants,
     participantFilters = {},
+    withPotentialMatchUps,
+    withRankingProfile,
     convertExtensions,
     policyDefinitions,
     withScheduleItems,
+    tournamentRecord,
     scheduleAnalysis,
     withSignInStatus,
     withTeamMatchUps,
-    // not implemented
-    tournamentRecord,
-    usePublishState,
     withScaleValues,
+    usePublishState,
+    contextProfile,
     withStatistics,
-    withGroupings,
     withOpponents,
     withMatchUps,
+    internalUse,
     withSeeding,
     withEvents,
     withDraws,
-    inContext,
     withISO2,
     withIOC
   } = params;
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  if (!tournamentRecord.participants)
-    return { error: MISSING_PARTICIPANTS };
-  const allTournamentParticipants = tournamentRecord.participants.map(
-    // (participant) => makeDeepCopy(participant, convertExtensions, true)
-    (participant) => makeDeepCopy(participant, convertExtensions)
-    // removed until Mongo/Mongoose issues resolved
-  );
-  if (typeof participantFilters !== "object")
-    return { error: INVALID_OBJECT, participantFilters };
-  if (inContext) {
-    allTournamentParticipants?.forEach((participant) => {
-      if ([PAIR, TEAM, GROUP].includes(participant.participantType)) {
-        participant.individualParticipants = participant.individualParticipantIds?.map((participantId) => {
-          const targetParticipant = tournamentRecord.participants.find(
-            (p) => p.participantId === participantId
-          );
-          const individualParticipant = makeDeepCopy(
-            targetParticipant,
-            convertExtensions,
-            true
+  if (withMatchUps || withRankingProfile) {
+    getMatchUpDependencies({ tournamentRecord });
+  }
+  let { participantMap } = getParticipantMap({
+    withIndividualParticipants,
+    convertExtensions,
+    tournamentRecord,
+    withSignInStatus,
+    withScaleValues,
+    internalUse,
+    withISO2,
+    withIOC
+  });
+  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
+  });
+  const {
+    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
           );
-          if (withScaleValues) {
-            const { ratings, rankings } = getScaleValues({
-              participant: individualParticipant
-            });
-            individualParticipant.ratings = ratings;
-            individualParticipant.rankings = rankings;
-          }
-          if (withIOC || withISO2)
-            addNationalityCode({
-              participant: individualParticipant,
-              withISO2,
-              withIOC
-            });
-          return individualParticipant;
         });
       }
-    });
-  }
-  let tournamentParticipants = participantFilters ? filterParticipants({
-    participants: allTournamentParticipants,
+      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 participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
+  const template = participantAttributes?.participant;
+  const filteredParticipants = filterParticipants({
+    participants: processedParticipants,
     participantFilters,
     tournamentRecord
-  }) : allTournamentParticipants;
-  let participantIdsWithConflicts, eventsPublishStatuses;
-  const addContext = withScheduleItems || withSignInStatus || scheduleAnalysis || withScaleValues || withStatistics || withGroupings || withOpponents || withMatchUps || withSeeding || withEvents || withDraws || withISO2 || withIOC;
-  if (addContext) {
-    const result = addParticipantContext({
-      tournamentEvents: tournamentRecord.events,
-      allTournamentParticipants,
-      tournamentParticipants,
-      participantFilters,
-      withScheduleItems,
-      withSignInStatus,
-      tournamentRecord,
-      scheduleAnalysis,
-      withTeamMatchUps,
-      usePublishState,
-      withScaleValues,
-      withStatistics,
-      withGroupings,
-      withOpponents,
-      withMatchUps,
-      withSeeding,
-      withEvents,
-      withDraws,
-      withISO2,
-      withIOC
-    });
-    participantIdsWithConflicts = result?.participantIdsWithConflicts;
-    eventsPublishStatuses = result?.eventsPublishStatuses;
-  }
-  const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
-  if (participantAttributes?.participant) {
-    tournamentParticipants = tournamentParticipants.map(
-      (participant) => attributeFilter({
-        template: participantAttributes.participant,
-        source: participant
-      })
-    );
-  }
+  });
+  const participants = template ? filteredParticipants.map(
+    (source) => attributeFilter({ source, template })
+  ) : filteredParticipants;
   return {
     participantIdsWithConflicts,
-    tournamentParticipants,
-    eventsPublishStatuses
+    eventsPublishStatuses,
+    derivedEventInfo,
+    derivedDrawInfo,
+    mappedMatchUps,
+    participantMap,
+    participants,
+    ...SUCCESS,
+    matchUps
   };
 }
 
@@ -19120,11 +19055,11 @@ function createGroupParticipant({
       info: "Invalid individualParticipantIds",
       error: INVALID_VALUES
     };
-  const { tournamentParticipants } = getTournamentParticipants({
+  const participants = getParticipants({
     participantFilters: { participantTypes: [INDIVIDUAL] },
     tournamentRecord
-  });
-  const tournamentIndividualParticipantIds = tournamentParticipants.map(
+  }).participants ?? [];
+  const tournamentIndividualParticipantIds = participants.map(
     (participant) => participant.participantId
   );
   for (const participantId2 of individualParticipantIds) {
@@ -19542,10 +19477,10 @@ function generateVoluntaryConsolation$1(params) {
   let drawDefinition = params?.drawDefinition;
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
-  const tournamentParticipants = getTournamentParticipants({
-    tournamentRecord,
-    inContext: true
-  })?.tournamentParticipants;
+  const participants = tournamentRecord ? getParticipants({
+    withIndividualParticipants: true,
+    tournamentRecord
+  })?.participants : [];
   const stage = VOLUNTARY_CONSOLATION;
   const entries = getStageEntries({
     stageSequence: 1,
@@ -19636,10 +19571,10 @@ function generateVoluntaryConsolation$1(params) {
   if (automated) {
     automatedPositioning$1({
       seedingProfile: params.seedingProfile,
-      participants: tournamentParticipants,
       applyPositioning,
       tournamentRecord,
       drawDefinition,
+      participants,
       structureId,
       placeByes,
       drawSize,
@@ -20916,9 +20851,7 @@ function addDrawDefinition(params) {
   });
   if (relevantFlight && !drawEntriesPresentInFlight) {
     return decorateResult({
-      result: {
-        error: INVALID_DRAW_DEFINITION
-      },
+      result: { error: INVALID_DRAW_DEFINITION },
       context: {
         drawEntriesPresentInFlight,
         matchingEventEntries,
@@ -21285,11 +21218,17 @@ const definitionTemplate = () => ({
 
 function newDrawDefinition({
   drawId = UUID(),
+  processCodes,
   matchUpType,
   drawType
 }) {
   const drawDefinition = definitionTemplate();
-  return Object.assign(drawDefinition, { drawId, drawType, matchUpType });
+  return Object.assign(drawDefinition, {
+    processCodes,
+    matchUpType,
+    drawType,
+    drawId
+  });
 }
 
 var collectionDefinitions$g = [
@@ -23003,9 +22942,9 @@ function generateDrawDefinition(params) {
   }).appliedPolicies ?? {};
   const drawTypeCoercion = params.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
   const drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
-  const { tournamentParticipants: participants } = getTournamentParticipants({
-    tournamentRecord,
-    inContext: true
+  const { participants } = getParticipants({
+    withIndividualParticipants: true,
+    tournamentRecord
   });
   const enforceGender = params.enforceGender ?? policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender;
   const allowedDrawTypes = !ignoreAllowedDrawTypes && tournamentRecord && getAllowedDrawTypes({
@@ -23082,7 +23021,11 @@ function generateDrawDefinition(params) {
     return decorateResult({ result: { error: INVALID_VALUES }, stack });
   if (existingDrawDefinition && drawType !== existingDrawDefinition.drawType)
     existingDrawDefinition.drawType = drawType;
-  let drawDefinition = existingDrawDefinition ?? newDrawDefinition({ drawType, drawId: params.drawId });
+  let drawDefinition = existingDrawDefinition ?? newDrawDefinition({
+    drawType,
+    drawId: params.drawId,
+    processCodes: params.processCodes
+  });
   if (matchUpFormat || tieFormat) {
     const equivalentInScope = matchUpFormat && event?.matchUpFormat === matchUpFormat || event?.tieFormat && tieFormat && JSON.stringify(event.tieFormat) === JSON.stringify(tieFormat);
     if (!equivalentInScope) {