tods-competition-factory 1.8.9 → 1.8.11

package/dist/index.mjs

@@ -913,10 +913,6 @@ const INVALID_SCALE_ITEM = {
   message: "Invalid scaleItem",
   code: "ERR_INVALID_SCALE_ITEM"
 };
-const SCALE_ITEM_NOT_FOUND = {
-  message: "No scaleItem found",
-  code: "ERR_NOT_FOUND_SCALE_ITEM"
-};
 const MODIFICATIONS_FAILED = {
   message: "Modifications failed",
   code: "ERR_FAILURE_MODIFICATIONS"
@@ -1174,7 +1170,6 @@ const errorConditionConstants = {
   PENALTY_NOT_FOUND,
   POLICY_NOT_ATTACHED,
   POLICY_NOT_FOUND,
-  SCALE_ITEM_NOT_FOUND,
   SCHEDULE_NOT_CLEARED,
   SCHEDULED_MATCHUPS,
   SEEDSCOUNT_GREATER_THAN_DRAW_SIZE,
@@ -2380,7 +2375,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.9";
+  return "1.8.11";
 }
 
 function getObjectTieFormat(obj) {
@@ -4470,7 +4465,7 @@ function getPolicyDefinitions({
     if (policy)
       policyDefinitions[policyType] = policy;
   }
-  return Object.keys(policyDefinitions).length ? { policyDefinitions } : { error: POLICY_NOT_FOUND };
+  return Object.keys(policyDefinitions).length ? { policyDefinitions } : { info: POLICY_NOT_FOUND.message };
 }
 
 const WALKOVER$1 = "WALKOVER";
@@ -4587,7 +4582,7 @@ function findPolicy({
     structure,
     event
   });
-  return appliedPolicies?.[policyType] ? { policy: appliedPolicies[policyType] } : { error: POLICY_NOT_FOUND };
+  return appliedPolicies?.[policyType] ? { policy: appliedPolicies[policyType] } : { info: POLICY_NOT_FOUND?.message };
 }
 
 function getMatchUpCompetitiveProfile({
@@ -15080,7 +15075,7 @@ const POLICY_PRIVACY_DEFAULT = {
 const ADULT = "ADULT";
 const JUNIOR = "JUNIOR";
 const WHEELCHAIR = "WHEELCHAIR";
-const POLICY_SCHEDULING_USTA = {
+const POLICY_SCHEDULING_DEFAULT = {
   [POLICY_TYPE_SCHEDULING]: {
     defaultTimes: {
       averageTimes: [{ categoryNames: [], minutes: { default: 90 } }],
@@ -15427,7 +15422,7 @@ const policies = {
   POLICY_POSITION_ACTIONS_UNRESTRICTED,
   POLICY_PRIVACY_DEFAULT,
   POLICY_ROUND_NAMING_DEFAULT,
-  POLICY_SCHEDULING_USTA,
+  POLICY_SCHEDULING_DEFAULT,
   POLICY_SCORING_DEFAULT,
   POLICY_SCORING_USTA,
   POLICY_SEEDING_ITF,
@@ -26700,7 +26695,7 @@ function participantScaleItem({
     return { error: INVALID_VALUES };
   if (!participant.timeItems)
     participant.timeItems = [];
-  if (participant && Array.isArray(participant.timeItems)) {
+  if (Array.isArray(participant.timeItems)) {
     const { accessor, scaleType, eventType, scaleName } = scaleAttributes;
     const filterType = [SCALE$1, scaleType, eventType, scaleName].join(".");
     const filteredTimeItems = participant.timeItems.filter((timeItem2) => timeItem2?.itemType === filterType).filter((timeItem2) => !requireTimeStamp || timeItem2?.itemDate).sort(
@@ -26720,12 +26715,10 @@ function participantScaleItem({
         scaleName: scaleName2,
         scaleType: scaleType2
       };
-      return { scaleItem };
-    } else {
-      return { error: SCALE_ITEM_NOT_FOUND };
+      return { ...SUCCESS, scaleItem };
     }
   }
-  return { error: MISSING_PARTICIPANT };
+  return { ...SUCCESS, scaleItem: void 0 };
 }
 
 function getEventSeedAssignments({
@@ -26932,7 +26925,7 @@ function addStructureParticipation({
 
 function processSides(params) {
   const {
-    withScheduleTimes,
+    withScheduleItems,
     scheduleAnalysis,
     withTeamMatchUps,
     participantMap,
@@ -27042,7 +27035,7 @@ function processSides(params) {
           stage
         });
       }
-      if (scheduleAnalysis || withScheduleTimes) {
+      if (scheduleAnalysis || withScheduleItems) {
         addScheduleItem({
           participantMap,
           participantId: participantId2,
@@ -27188,7 +27181,6 @@ function getParticipantEntries(params) {
     participantMap,
     withPotentialMatchUps,
     withRankingProfile,
-    withScheduleTimes,
     withScheduleItems,
     scheduleAnalysis,
     withTeamMatchUps,
@@ -27199,8 +27191,6 @@ function getParticipantEntries(params) {
     withEvents,
     withDraws
   } = params;
-  if (withScheduleItems)
-    console.log({ withScheduleItems });
   const targetParticipantIds = participantFilters?.participantIds;
   const getRelevantParticipantIds = (participantId) => {
     const relevantParticipantIds = [participantId];
@@ -27218,7 +27208,7 @@ function getParticipantEntries(params) {
     withDraws: withDraws || withRankingProfile,
     withPotentialMatchUps,
     withRankingProfile,
-    withScheduleTimes,
+    withScheduleItems,
     scheduleAnalysis,
     withTeamMatchUps,
     withStatistics,
@@ -27538,7 +27528,7 @@ function getParticipantEntries(params) {
             matchUpType: matchUpType2
           });
         }
-        if (Array.isArray(potentialParticipants) && (nextMatchUps || !!scheduleAnalysis || withScheduleTimes)) {
+        if (Array.isArray(potentialParticipants) && (nextMatchUps || !!scheduleAnalysis || withScheduleItems)) {
           const potentialParticipantIds = potentialParticipants.flat().map(extractAttributes("participantId")).filter(Boolean);
           potentialParticipantIds?.forEach((participantId) => {
             const relevantParticipantIds = getRelevantParticipantIds(participantId);
@@ -27553,7 +27543,7 @@ function getParticipantEntries(params) {
                 drawId
               });
             });
-            if (!!scheduleAnalysis || withScheduleTimes) {
+            if (!!scheduleAnalysis || withScheduleItems) {
               addScheduleItem({
                 potential: true,
                 participantMap,
@@ -27662,13 +27652,18 @@ function getParticipantEntries(params) {
             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)) {
+            const consideredMinutes = timeStringMinutes(
+              consideredItem.scheduledTime
+            );
+            const minutesDifference = Math.abs(
+              consideredMinutes - scheduledMinutes
+            );
+            const itemIsPrior = consideredMinutes > scheduledMinutes;
+            const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : itemIsPrior && timeStringMinutes(consideredItem.scheduledTime) < timeStringMinutes(notBeforeTime);
+            if (timeOverlap && !(bothPotential && sameDraw) && itemIsPrior) {
               participantAggregator.scheduleConflicts.push({
-                priorScheduledMatchUpId: consideredItem.matchUpId,
-                matchUpIdWithConflict: scheduleItem.matchUpId
+                priorScheduledMatchUpId: scheduleItem.matchUpId,
+                matchUpIdWithConflict: consideredItem.matchUpId
               });
             }
           }
@@ -27884,6 +27879,7 @@ function getParticipants$1(params) {
     ({
       potentialMatchUps,
       scheduleConflicts,
+      scheduleItems,
       participant,
       statistics,
       opponents,
@@ -27909,7 +27905,8 @@ function getParticipants$1(params) {
           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
+          statistics: withStatistics ? Object.values(statistics) : void 0,
+          scheduleItems: withScheduleItems ? scheduleItems : void 0
         },
         false,
         false,
@@ -27940,1465 +27937,372 @@ function getParticipants$1(params) {
   };
 }
 
-function getDerivedPositionAssignments({
-  derivedDrawInfo,
+function deepMerge(existing, incoming, arrayMerge) {
+  if (!existing && incoming)
+    return incoming;
+  if (existing && !incoming)
+    return existing;
+  if (typeof existing !== "object" || typeof incoming !== "object")
+    return existing;
+  const keys = unique(Object.keys(existing).concat(Object.keys(incoming)));
+  return keys.reduce((merged, key) => {
+    if (!incoming[key]) {
+      merged[key] = existing[key];
+    } else if (!existing[key]) {
+      merged[key] = incoming[key];
+    } else if (typeof existing[key] !== typeof incoming[key]) {
+      merged[key] = incoming[key];
+    } else if (Array.isArray(existing[key])) {
+      if (arrayMerge === true || Array.isArray(arrayMerge) && arrayMerge.includes(key)) {
+        const mergedArrays = unique(
+          existing[key].map((e) => JSON.stringify(e)).concat(incoming[key].map((i) => JSON.stringify(i)))
+        ).map((u) => JSON.parse(u));
+        merged[key] = mergedArrays;
+      } else {
+        merged[key] = incoming[key];
+      }
+    } else if (typeof existing[key] === "object") {
+      merged[key] = deepMerge(existing[key], incoming[key], arrayMerge);
+    } else {
+      merged[key] = incoming[key];
+    }
+    return merged;
+  }, {});
+}
+
+function getParticipants(params) {
+  const { tournamentRecords } = params || {};
+  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length) {
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  }
+  const participantMap = {};
+  const participants = [];
+  const derivedEventInfo = {};
+  const derivedDrawInfo = {};
+  const matchUps = [];
+  const mappedMatchUps = {};
+  const participantIdsWithConflicts = [];
+  for (const tournamentRecord of Object.values(tournamentRecords)) {
+    const {
+      participantIdsWithConflicts: idsWithConflicts,
+      mappedMatchUps: tournamentMappedMatchUps,
+      participantMap: tournamentParticipantMap,
+      participants: tournamentParticipants,
+      matchUps: tournamentMatchUps,
+      derivedEventInfo: eventInfo,
+      derivedDrawInfo: drawInfo
+    } = getParticipants$1({ tournamentRecord, ...params });
+    Object.assign(mappedMatchUps, tournamentMappedMatchUps);
+    Object.assign(participantMap, tournamentParticipantMap);
+    Object.assign(derivedEventInfo, eventInfo);
+    Object.assign(derivedDrawInfo, drawInfo);
+    participants.push(...tournamentParticipants ?? []);
+    matchUps.push(...tournamentMatchUps ?? []);
+    idsWithConflicts?.forEach((participantId) => {
+      if (!participantIdsWithConflicts.includes(participantId))
+        participantIdsWithConflicts.push(participantId);
+    });
+  }
+  return {
+    participantIdsWithConflicts,
+    derivedEventInfo,
+    derivedDrawInfo,
+    participantMap,
+    mappedMatchUps,
+    participants,
+    ...SUCCESS,
+    matchUps
+  };
+}
+function getCompetitionParticipants(params) {
+  const { tournamentRecords } = params || {};
+  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  let competitionParticipants = [];
+  const participantIdsWithConflicts = [];
+  const competitionParticipantIds = [];
+  const mappedMatchUps = {};
+  for (const tournamentRecord of Object.values(tournamentRecords)) {
+    const {
+      participants,
+      participantIdsWithConflicts: idsWithConflicts,
+      mappedMatchUps: matchUpsMap
+    } = getParticipants$1({
+      tournamentRecord,
+      ...params
+    });
+    if (matchUpsMap)
+      Object.assign(mappedMatchUps, matchUpsMap);
+    for (const tournamentParticipant of participants ?? []) {
+      const { participantId } = tournamentParticipant;
+      if (!competitionParticipantIds.includes(participantId)) {
+        competitionParticipantIds.push(participantId);
+        competitionParticipants.push(tournamentParticipant);
+      } else {
+        competitionParticipants = competitionParticipants.map(
+          (participant) => participant.participantId !== participantId ? participant : deepMerge(participant, tournamentParticipant, true)
+        );
+      }
+    }
+    idsWithConflicts?.forEach((participantId) => {
+      if (!participantIdsWithConflicts.includes(participantId))
+        participantIdsWithConflicts.push(participantId);
+    });
+  }
+  return {
+    competitionParticipants,
+    participantIdsWithConflicts,
+    mappedMatchUps,
+    ...SUCCESS
+  };
+}
+function publicFindParticipant({
+  tournamentRecords,
+  policyDefinitions,
+  contextProfile,
   participantId,
-  drawId
+  personId
 }) {
-  const mainPositionAssignment = derivedDrawInfo[drawId]?.mainPositionAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const qualifyingPositionAssignment = derivedDrawInfo[drawId]?.qualifyingPositionAssignments?.find(
-    (assignment) => assignment.participantId === participantId
+  if (!tournamentRecords)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  if (typeof participantId !== "string" && typeof personId !== "string")
+    return { error: MISSING_VALUE, stack: "publicFindParticipant" };
+  let participant, tournamentId;
+  for (const tournamentRecord of Object.values(tournamentRecords)) {
+    tournamentId = tournamentRecord.tournamentId;
+    const participants = getParticipants$1({
+      policyDefinitions,
+      tournamentRecord
+    }).participants ?? [];
+    participant = findParticipant({
+      tournamentParticipants: participants,
+      internalUse: true,
+      policyDefinitions,
+      contextProfile,
+      participantId,
+      personId
+    });
+    if (participant)
+      break;
+  }
+  return { participant, tournamentId, ...SUCCESS };
+}
+
+const penaltyTemplate = ({ penaltyId = UUID() } = {}) => ({
+  refereeParticipantId: void 0,
+  penaltyCode: void 0,
+  penaltyType: void 0,
+  extensions: void 0,
+  matchUpId: void 0,
+  createdAt: void 0,
+  issuedAt: void 0,
+  notes: void 0,
+  penaltyId
+});
+
+function addPenalty$1({
+  refereeParticipantId,
+  tournamentRecord,
+  participantIds,
+  penaltyCode,
+  penaltyType,
+  extensions,
+  penaltyId,
+  matchUpId,
+  issuedAt,
+  notes
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!participantIds)
+    return { error: MISSING_PARTICIPANT_ID };
+  if (!penaltyType)
+    return { error: MISSING_PENALTY_TYPE };
+  const participants = tournamentRecord?.participants || [];
+  const relevantParticipants = participants.filter(
+    (participant) => participantIds.includes(participant.participantId)
   );
-  const positionAssignments = {};
-  if (mainPositionAssignment) {
-    const { participantId: participantId2, ...props } = mainPositionAssignment;
-    if (participantId2)
-      positionAssignments[MAIN] = { ...props };
+  if (!relevantParticipants.length)
+    return { error: PARTICIPANT_NOT_FOUND };
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const penaltyItem = Object.assign(penaltyTemplate({ penaltyId }), {
+    refereeParticipantId,
+    penaltyCode,
+    penaltyType,
+    matchUpId,
+    notes,
+    issuedAt,
+    createdAt
+  });
+  if (Array.isArray(extensions)) {
+    extensions.forEach(
+      (extension) => addExtension$1({ element: penaltyItem, extension })
+    );
   }
-  if (qualifyingPositionAssignment) {
-    const { participantId: participantId2, ...props } = qualifyingPositionAssignment;
-    if (participantId2)
-      positionAssignments[QUALIFYING] = { ...props };
+  relevantParticipants.forEach((participant) => {
+    if (!participant.penalties)
+      participant.penalties = [];
+    participant.penalties.push(penaltyItem);
+  });
+  addNotice({
+    topic: MODIFY_PARTICIPANTS,
+    payload: {
+      tournamentId: tournamentRecord.tournamentId,
+      participants: relevantParticipants
+    }
+  });
+  return { ...SUCCESS, penaltyId: penaltyItem.penaltyId };
+}
+function removePenalty$1({
+  tournamentRecord,
+  penaltyId
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!penaltyId)
+    return { error: MISSING_PENALTY_ID };
+  const participants = tournamentRecord?.participants || [];
+  const modifiedParticipants = [];
+  let penaltyRemoved = false;
+  let removedPenalty;
+  participants.forEach((participant) => {
+    let participantModified = false;
+    participant.penalties = (participant.penalties || []).filter((penalty) => {
+      if (penalty.penaltyId === penaltyId) {
+        participantModified = true;
+        if (!penaltyRemoved) {
+          removedPenalty = penalty;
+          penaltyRemoved = true;
+        }
+      }
+      if (participantModified)
+        modifiedParticipants.push(participant);
+      return penalty.penaltyId !== penaltyId;
+    });
+  });
+  if (removedPenalty) {
+    addNotice({
+      topic: MODIFY_PARTICIPANTS,
+      payload: {
+        tournamentId: tournamentRecord.tournamentId,
+        participants: modifiedParticipants
+      }
+    });
   }
-  return Object.keys(positionAssignments).length ? positionAssignments : void 0;
+  return removedPenalty ? { ...SUCCESS, penalty: removedPenalty } : { error: PENALTY_NOT_FOUND };
 }
-
-function getRelevantParticipantIdsMap({
-  processParticipantId,
-  // optional method which is passed each participantId
-  tournamentRecords,
+function getTournamentPenalties({
   tournamentRecord
 }) {
-  if (typeof tournamentRecord !== "object" && typeof tournamentRecords !== "object")
+  if (!tournamentRecord)
     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
-          })
+  const participants = tournamentRecord?.participants || [];
+  const allPenalties = participants.reduce((penalties, participant) => {
+    const { participantId } = participant;
+    (participant.penalties || []).forEach((penalty) => {
+      const { penaltyId } = penalty || {};
+      if (penalties[penaltyId]) {
+        penalties[penaltyId].participants.push(participantId);
+      } else {
+        penalties[penaltyId] = {
+          ...penalty,
+          participantIds: [participantId]
         };
       }
-    )
-  );
-  return { relevantParticipantIdsMap };
+    });
+    return penalties;
+  }, {});
+  return { penalties: Object.values(allPenalties) };
 }
-
-function getDerivedSeedAssignments({
-  derivedDrawInfo,
-  participantId,
-  drawId
+function modifyPenalty$1({
+  tournamentRecord,
+  modifications,
+  penaltyId
 }) {
-  const mainSeedAssignment = derivedDrawInfo[drawId]?.mainSeedAssignments?.find(
-    (assignment) => assignment.participantId === participantId
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!modifications)
+    return { error: INVALID_VALUES, modifications };
+  if (!penaltyId)
+    return { error: MISSING_PENALTY_ID };
+  const participants = tournamentRecord?.participants || [];
+  const validAttributes = Object.keys(penaltyTemplate()).filter(
+    (attribute) => attribute !== "penaltyId"
   );
-  const qualifyingSeedAssignment = derivedDrawInfo[drawId]?.qualifyingSeedAssignments?.find(
-    (assignment) => assignment.participantId === participantId
+  const validModificationAttributes = Object.keys(modifications).filter(
+    (attribute) => validAttributes.includes(attribute)
   );
-  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 };
+  if (!validModificationAttributes.length)
+    return { error: NO_VALID_ATTRIBUTES };
+  let updatedPenalty;
+  const modifiedParticipants = [];
+  participants.forEach((participant) => {
+    let participantModified = false;
+    participant.penalties = (participant.penalties || []).map((penalty) => {
+      if (penalty.penaltyId === penaltyId) {
+        participantModified = true;
+        validModificationAttributes.forEach(
+          (attribute) => Object.assign(penalty, { [attribute]: modifications[attribute] })
+        );
+        if (!updatedPenalty)
+          updatedPenalty = penalty;
+      }
+      return penalty;
+    });
+    if (participantModified)
+      modifiedParticipants.push(participant);
+  });
+  if (updatedPenalty) {
+    addNotice({
+      topic: MODIFY_PARTICIPANTS,
+      payload: {
+        tournamentId: tournamentRecord.tournamentId,
+        participants: modifiedParticipants
+      }
+    });
   }
-  return Object.keys(seedAssignments).length ? seedAssignments : void 0;
+  return updatedPenalty ? { ...SUCCESS, penalty: updatedPenalty } : { error: PENALTY_NOT_FOUND };
 }
 
-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];
-      }
+function addPenalty(params) {
+  const { tournamentRecords, participantIds } = params;
+  let penaltyId;
+  for (const tournamentRecord of Object.values(tournamentRecords)) {
+    const participants = getParticipants$1({
+      tournamentRecord
+    }).participants ?? [];
+    const tournamentParticipantIds = participants?.map(extractAttributes("participantId")).filter((participantId) => participantIds.includes(participantId));
+    if (tournamentParticipantIds.length) {
+      const result = addPenalty$1({
+        ...params,
+        penaltyId: params.penaltyId || penaltyId,
+        tournamentRecord,
+        participantIds: tournamentParticipantIds
+      });
+      penaltyId = result.penaltyId;
     }
-    return dateMatchUps;
-  }, {});
-  const dates = Object.keys(scheduledMatchUps);
-  dates.forEach((date) => {
-    scheduledMatchUps[date].sort(
-      (a, b) => timeSort(
-        extractTime(a.schedule?.scheduledTime),
-        extractTime(b.schedule?.scheduledTime)
-      )
-    );
-  });
-  return { scheduledMatchUps };
+  }
+  return penaltyId ? { ...SUCCESS, penaltyId } : { error: PARTICIPANT_NOT_FOUND };
 }
-
-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;
+function modifyPenalty(params) {
+  const { tournamentRecords } = params;
+  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  for (const tournamentRecord of Object.values(tournamentRecords)) {
+    const result = modifyPenalty$1({ tournamentRecord, ...params });
+    if (result.error && result.error !== PENALTY_NOT_FOUND)
+      return result;
   }
-  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;
-        }
-      }
-    }
-  }
-  if (withEvents && participantEvents) {
-    participant.events = participantEvents;
-    if (withSeeding) {
-      const seedingScales = Object.assign(
-        {},
-        ...(participant.timeItems || []).filter(({ itemType }) => itemType.split(".")[1] === SEEDING$1).map(({ itemType: seedingScaleName, itemValue: seedValue }) => ({
-          [seedingScaleName]: seedValue
-        }))
-      );
-      for (const participantEvent of participantEvents) {
-        const getScaleAccessor = (scaleName) => [SCALE$1, SEEDING$1, 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$1,
-              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;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  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$2, 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$2, 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 };
-}
-
-function getDrawDetails({
-  eventEntries,
-  sortConfig,
-  event
-}) {
-  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$1({
-        structure: mainStructure
-      })?.positionAssignments;
-      const drawSize = mainPositionAssignments?.length;
-      const qualifyingStructure = getDrawStructures({
-        stageSequence: 1,
-        stage: QUALIFYING,
-        drawDefinition
-      })?.structures?.[0];
-      const qualifyingPositionAssignments = mainStructure && getPositionAssignments$1({
-        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
-        }
-      };
-    })
-  );
-  return { derivedInfo, drawDetails };
-}
-
-function processMatchUp({
-  relevantParticipantIdsMap,
-  participantFilters,
-  participantIdMap,
-  derivedDrawInfo,
-  eventDrawsCount,
-  drawDetails,
-  eventType,
-  matchUp
-}) {
-  const {
-    collectionId,
-    collectionPosition,
-    drawId,
-    drawName,
-    eventId,
-    eventName,
-    finishingRound,
-    finishingPositionRange,
-    processCodes,
-    loserTo,
-    matchUpId,
-    matchUpType,
-    matchUpFormat,
-    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);
-      }
-    });
-    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
-          });
-        }
-        if (!participantIdMap[relevantParticipantId].events[eventId]) {
-          participantIdMap[relevantParticipantId].events[eventId] = {
-            partnerParticipantIds: [],
-            drawIds: [],
-            eventName,
-            eventId
-          };
-        }
-        const eventDrawIds = participantIdMap[relevantParticipantId].events[eventId].drawIds;
-        if (eventDrawIds && !eventDrawIds?.includes(drawId)) {
-          participantIdMap[relevantParticipantId].events[eventId].drawIds.push(
-            drawId
-          );
-        }
-        let partnerParticipantId;
-        if (participantType === INDIVIDUAL && matchUpType === DOUBLES_MATCHUP) {
-          const relevantParticipantInfo = filteredRelevantParticipantIds.find(
-            (participantInfo) => {
-              return participantInfo.relevantParticipantId !== relevantParticipantId && participantInfo.participantType === INDIVIDUAL;
-            }
-          );
-          partnerParticipantId = relevantParticipantInfo?.relevantParticipantId;
-        }
-        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
-            };
-          }
-        );
-        const opponentParticipantInfo = filteredRelevantOpponents.map(
-          ({ relevantParticipantId: relevantParticipantId2, participantType: participantType2 }) => ({
-            participantId: relevantParticipantId2,
-            participantType: participantType2
-          })
-        );
-        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,
-            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;
-        }
-        if (winningSide) {
-          if (participantWon) {
-            participantIdMap[relevantParticipantId].wins++;
-          } else {
-            participantIdMap[relevantParticipantId].losses++;
-          }
-        }
-      }
-    );
-  });
-  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
-  });
-  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 : [];
-  };
-  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
-          });
-        }
-      });
-    }
-    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
-          });
-        }
-      });
-    }
-    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 (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$2({
-            element: rawEvent.drawDefinitions[i],
-            // rawEvent because deepCopy has converted extensions
-            name: LINEUPS
-          });
-          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$1}`;
-      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
-        };
-      }
-      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);
-          }
-        });
-      };
-      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 (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 };
-}
-
-function getTournamentParticipants(params) {
-  const {
-    participantFilters = {},
-    convertExtensions,
-    policyDefinitions,
-    withScheduleItems,
-    scheduleAnalysis,
-    withSignInStatus,
-    withTeamMatchUps,
-    // not implemented
-    tournamentRecord,
-    usePublishState,
-    withScaleValues,
-    withStatistics,
-    withGroupings,
-    withOpponents,
-    withMatchUps,
-    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 (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,
-    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
-      })
-    );
-  }
-  return {
-    participantIdsWithConflicts,
-    tournamentParticipants,
-    eventsPublishStatuses
-  };
-}
-
-function deepMerge(existing, incoming, arrayMerge) {
-  if (!existing && incoming)
-    return incoming;
-  if (existing && !incoming)
-    return existing;
-  if (typeof existing !== "object" || typeof incoming !== "object")
-    return existing;
-  const keys = unique(Object.keys(existing).concat(Object.keys(incoming)));
-  return keys.reduce((merged, key) => {
-    if (!incoming[key]) {
-      merged[key] = existing[key];
-    } else if (!existing[key]) {
-      merged[key] = incoming[key];
-    } else if (typeof existing[key] !== typeof incoming[key]) {
-      merged[key] = incoming[key];
-    } else if (Array.isArray(existing[key])) {
-      if (arrayMerge === true || Array.isArray(arrayMerge) && arrayMerge.includes(key)) {
-        const mergedArrays = unique(
-          existing[key].map((e) => JSON.stringify(e)).concat(incoming[key].map((i) => JSON.stringify(i)))
-        ).map((u) => JSON.parse(u));
-        merged[key] = mergedArrays;
-      } else {
-        merged[key] = incoming[key];
-      }
-    } else if (typeof existing[key] === "object") {
-      merged[key] = deepMerge(existing[key], incoming[key], arrayMerge);
-    } else {
-      merged[key] = incoming[key];
-    }
-    return merged;
-  }, {});
-}
-
-function getParticipants(params) {
-  const { tournamentRecords } = params || {};
-  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length) {
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  }
-  const participantMap = {};
-  const participants = [];
-  const derivedEventInfo = {};
-  const derivedDrawInfo = {};
-  const matchUps = [];
-  const mappedMatchUps = {};
-  const participantIdsWithConflicts = [];
-  for (const tournamentRecord of Object.values(tournamentRecords)) {
-    const {
-      participantIdsWithConflicts: idsWithConflicts,
-      mappedMatchUps: tournamentMappedMatchUps,
-      participantMap: tournamentParticipantMap,
-      participants: tournamentParticipants,
-      matchUps: tournamentMatchUps,
-      derivedEventInfo: eventInfo,
-      derivedDrawInfo: drawInfo
-    } = getParticipants$1({ tournamentRecord, ...params });
-    Object.assign(mappedMatchUps, tournamentMappedMatchUps);
-    Object.assign(participantMap, tournamentParticipantMap);
-    Object.assign(derivedEventInfo, eventInfo);
-    Object.assign(derivedDrawInfo, drawInfo);
-    participants.push(...tournamentParticipants ?? []);
-    matchUps.push(...tournamentMatchUps ?? []);
-    idsWithConflicts?.forEach((participantId) => {
-      if (!participantIdsWithConflicts.includes(participantId))
-        participantIdsWithConflicts.push(participantId);
-    });
-  }
-  return {
-    participantIdsWithConflicts,
-    derivedEventInfo,
-    derivedDrawInfo,
-    participantMap,
-    mappedMatchUps,
-    participants,
-    ...SUCCESS,
-    matchUps
-  };
-}
-function getCompetitionParticipants(params) {
-  const { tournamentRecords } = params || {};
-  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  let competitionParticipants = [];
-  const participantIdsWithConflicts = [];
-  const competitionParticipantIds = [];
-  for (const tournamentRecord of Object.values(tournamentRecords)) {
-    const {
-      tournamentParticipants,
-      participantIdsWithConflicts: idsWithConflicts
-    } = getTournamentParticipants({
-      tournamentRecord,
-      ...params
-    });
-    for (const tournamentParticipant of tournamentParticipants) {
-      const { participantId } = tournamentParticipant;
-      if (!competitionParticipantIds.includes(participantId)) {
-        competitionParticipantIds.push(participantId);
-        competitionParticipants.push(tournamentParticipant);
-      } else {
-        competitionParticipants = competitionParticipants.map(
-          (participant) => participant.participantId !== participantId ? participant : deepMerge(participant, tournamentParticipant, true)
-        );
-      }
-    }
-    idsWithConflicts?.forEach((participantId) => {
-      if (!participantIdsWithConflicts.includes(participantId))
-        participantIdsWithConflicts.push(participantId);
-    });
-  }
-  return { competitionParticipants, participantIdsWithConflicts, ...SUCCESS };
-}
-function publicFindParticipant({
-  policyDefinitions,
-  tournamentRecords,
-  participantId,
-  inContext,
-  personId
-}) {
-  if (!tournamentRecords)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  if (typeof participantId !== "string" && typeof personId !== "string")
-    return { error: MISSING_VALUE, stack: "publicFindParticipant" };
-  let participant, tournamentId;
-  for (const tournamentRecord of Object.values(tournamentRecords)) {
-    tournamentId = tournamentRecord.tournamentId;
-    const { tournamentParticipants } = getTournamentParticipants({
-      policyDefinitions,
-      tournamentRecord,
-      inContext
-    });
-    participant = findParticipant({
-      tournamentParticipants,
-      internalUse: true,
-      policyDefinitions,
-      participantId,
-      personId
-    });
-    if (participant)
-      break;
-  }
-  return { participant, tournamentId, ...SUCCESS };
-}
-
-const penaltyTemplate = ({ penaltyId = UUID() } = {}) => ({
-  refereeParticipantId: void 0,
-  penaltyCode: void 0,
-  penaltyType: void 0,
-  extensions: void 0,
-  matchUpId: void 0,
-  createdAt: void 0,
-  issuedAt: void 0,
-  notes: void 0,
-  penaltyId
-});
-
-function addPenalty$1({
-  refereeParticipantId,
-  tournamentRecord,
-  participantIds,
-  penaltyCode,
-  penaltyType,
-  extensions,
-  penaltyId,
-  matchUpId,
-  issuedAt,
-  notes
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!participantIds)
-    return { error: MISSING_PARTICIPANT_ID };
-  if (!penaltyType)
-    return { error: MISSING_PENALTY_TYPE };
-  const participants = tournamentRecord?.participants || [];
-  const relevantParticipants = participants.filter(
-    (participant) => participantIds.includes(participant.participantId)
-  );
-  if (!relevantParticipants.length)
-    return { error: PARTICIPANT_NOT_FOUND };
-  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  const penaltyItem = Object.assign(penaltyTemplate({ penaltyId }), {
-    refereeParticipantId,
-    penaltyCode,
-    penaltyType,
-    matchUpId,
-    notes,
-    issuedAt,
-    createdAt
-  });
-  if (Array.isArray(extensions)) {
-    extensions.forEach(
-      (extension) => addExtension$1({ element: penaltyItem, extension })
-    );
-  }
-  relevantParticipants.forEach((participant) => {
-    if (!participant.penalties)
-      participant.penalties = [];
-    participant.penalties.push(penaltyItem);
-  });
-  addNotice({
-    topic: MODIFY_PARTICIPANTS,
-    payload: {
-      tournamentId: tournamentRecord.tournamentId,
-      participants: relevantParticipants
-    }
-  });
-  return { ...SUCCESS, penaltyId: penaltyItem.penaltyId };
-}
-function removePenalty$1({
-  tournamentRecord,
-  penaltyId
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!penaltyId)
-    return { error: MISSING_PENALTY_ID };
-  const participants = tournamentRecord?.participants || [];
-  const modifiedParticipants = [];
-  let penaltyRemoved = false;
-  let removedPenalty;
-  participants.forEach((participant) => {
-    let participantModified = false;
-    participant.penalties = (participant.penalties || []).filter((penalty) => {
-      if (penalty.penaltyId === penaltyId) {
-        participantModified = true;
-        if (!penaltyRemoved) {
-          removedPenalty = penalty;
-          penaltyRemoved = true;
-        }
-      }
-      if (participantModified)
-        modifiedParticipants.push(participant);
-      return penalty.penaltyId !== penaltyId;
-    });
-  });
-  if (removedPenalty) {
-    addNotice({
-      topic: MODIFY_PARTICIPANTS,
-      payload: {
-        tournamentId: tournamentRecord.tournamentId,
-        participants: modifiedParticipants
-      }
-    });
-  }
-  return removedPenalty ? { ...SUCCESS, penalty: removedPenalty } : { error: PENALTY_NOT_FOUND };
-}
-function getTournamentPenalties({
-  tournamentRecord
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const participants = tournamentRecord?.participants || [];
-  const allPenalties = participants.reduce((penalties, participant) => {
-    const { participantId } = participant;
-    (participant.penalties || []).forEach((penalty) => {
-      const { penaltyId } = penalty || {};
-      if (penalties[penaltyId]) {
-        penalties[penaltyId].participants.push(participantId);
-      } else {
-        penalties[penaltyId] = {
-          ...penalty,
-          participantIds: [participantId]
-        };
-      }
-    });
-    return penalties;
-  }, {});
-  return { penalties: Object.values(allPenalties) };
-}
-function modifyPenalty$1({
-  tournamentRecord,
-  modifications,
-  penaltyId
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!modifications)
-    return { error: INVALID_VALUES, modifications };
-  if (!penaltyId)
-    return { error: MISSING_PENALTY_ID };
-  const participants = tournamentRecord?.participants || [];
-  const validAttributes = Object.keys(penaltyTemplate()).filter(
-    (attribute) => attribute !== "penaltyId"
-  );
-  const validModificationAttributes = Object.keys(modifications).filter(
-    (attribute) => validAttributes.includes(attribute)
-  );
-  if (!validModificationAttributes.length)
-    return { error: NO_VALID_ATTRIBUTES };
-  let updatedPenalty;
-  const modifiedParticipants = [];
-  participants.forEach((participant) => {
-    let participantModified = false;
-    participant.penalties = (participant.penalties || []).map((penalty) => {
-      if (penalty.penaltyId === penaltyId) {
-        participantModified = true;
-        validModificationAttributes.forEach(
-          (attribute) => Object.assign(penalty, { [attribute]: modifications[attribute] })
-        );
-        if (!updatedPenalty)
-          updatedPenalty = penalty;
-      }
-      return penalty;
-    });
-    if (participantModified)
-      modifiedParticipants.push(participant);
-  });
-  if (updatedPenalty) {
-    addNotice({
-      topic: MODIFY_PARTICIPANTS,
-      payload: {
-        tournamentId: tournamentRecord.tournamentId,
-        participants: modifiedParticipants
-      }
-    });
-  }
-  return updatedPenalty ? { ...SUCCESS, penalty: updatedPenalty } : { error: PENALTY_NOT_FOUND };
-}
-
-function addPenalty(params) {
-  const { tournamentRecords, participantIds } = params;
-  let penaltyId;
-  for (const tournamentRecord of Object.values(tournamentRecords)) {
-    const participants = getParticipants$1({
-      tournamentRecord
-    }).participants ?? [];
-    const tournamentParticipantIds = participants?.map(extractAttributes("participantId")).filter((participantId) => participantIds.includes(participantId));
-    if (tournamentParticipantIds.length) {
-      const result = addPenalty$1({
-        ...params,
-        penaltyId: params.penaltyId || penaltyId,
-        tournamentRecord,
-        participantIds: tournamentParticipantIds
-      });
-      penaltyId = result.penaltyId;
-    }
-  }
-  return penaltyId ? { ...SUCCESS, penaltyId } : { error: PARTICIPANT_NOT_FOUND };
-}
-function modifyPenalty(params) {
-  const { tournamentRecords } = params;
-  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  for (const tournamentRecord of Object.values(tournamentRecords)) {
-    const result = modifyPenalty$1({ tournamentRecord, ...params });
-    if (result.error && result.error !== PENALTY_NOT_FOUND)
-      return result;
-  }
-  return { ...SUCCESS };
-}
-function removePenalty(params) {
-  const { tournamentRecords } = params;
-  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  for (const tournamentRecord of Object.values(tournamentRecords)) {
-    const result = removePenalty$1({ tournamentRecord, ...params });
-    if (result.error && result.error !== PENALTY_NOT_FOUND)
-      return result;
+  return { ...SUCCESS };
+}
+function removePenalty(params) {
+  const { tournamentRecords } = params;
+  if (typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  for (const tournamentRecord of Object.values(tournamentRecords)) {
+    const result = removePenalty$1({ tournamentRecord, ...params });
+    if (result.error && result.error !== PENALTY_NOT_FOUND)
+      return result;
   }
   return { ...SUCCESS };
 }
@@ -31905,6 +30809,7 @@ function getEventMatchUpFormatTiming$1({
   if (!event)
     return { error: MISSING_EVENT };
   let matchUpFormatDefinitions = [];
+  let info;
   if (!matchUpFormats?.length) {
     const { policy } = findPolicy({
       policyType: POLICY_TYPE_SCORING,
@@ -31918,20 +30823,19 @@ function getEventMatchUpFormatTiming$1({
         name: SCHEDULE_TIMING,
         event
       });
+      let matchUpAverageTimes, matchUpRecoveryTimes;
       if (extension?.value) {
-        matchUpFormatDefinitions = unique(
-          [
-            ...(extension.value.matchUpAverageTimes || []).map(
-              (at) => at.matchUpFormatCodes
-            ),
-            ...(extension.value.matchUpRecoveryTimes || []).map(
-              (at) => at.matchUpFormatCodes
-            )
-          ].flat()
-        ).map((matchUpFormat) => ({ matchUpFormat }));
+        ({ matchUpAverageTimes, matchUpRecoveryTimes } = extension.value);
       } else {
-        return { error: MISSING_SCORING_POLICY };
+        ({ matchUpAverageTimes, matchUpRecoveryTimes } = POLICY_SCHEDULING_DEFAULT[POLICY_TYPE_SCHEDULING]);
       }
+      matchUpFormatDefinitions = unique(
+        [
+          ...(matchUpAverageTimes || []).map((at) => at.matchUpFormatCodes),
+          ...(matchUpRecoveryTimes || []).map((at) => at.matchUpFormatCodes)
+        ].flat()
+      ).map((matchUpFormat) => ({ matchUpFormat }));
+      info = "default scheduling policy in use";
     }
   } else {
     const uniqueMatchUpFormats = [];
@@ -31946,7 +30850,7 @@ function getEventMatchUpFormatTiming$1({
     }).filter(Boolean);
   }
   const { eventType, eventId, category } = event;
-  const categoryName = category?.categoryName || category?.ageCategoryCode || eventId;
+  const categoryName = category?.categoryName ?? category?.ageCategoryCode ?? eventId;
   if (!eventId)
     return { error: MISSING_EVENT };
   const eventMatchUpFormatTiming = matchUpFormatDefinitions.map(
@@ -31959,17 +30863,14 @@ function getEventMatchUpFormatTiming$1({
         eventType,
         event
       });
-      return Object.assign(
-        {},
-        {
-          ...timing,
-          description,
-          matchUpFormat
-        }
-      );
+      return {
+        matchUpFormat,
+        description,
+        ...timing
+      };
     }
   );
-  return { eventMatchUpFormatTiming };
+  return definedAttributes({ eventMatchUpFormatTiming, info });
 }
 
 function getEventMatchUpFormatTiming({
@@ -33233,6 +32134,14 @@ function modifyParticipantMatchUpsCount({
   });
 }
 
+const hasSchedule = ({
+  scheduleAttributes = ["scheduledDate", "scheduledTime"],
+  schedule = {}
+}) => {
+  const matchUpScheduleKeys = Object.keys(schedule).filter((key) => scheduleAttributes.includes(key)).filter((key) => schedule[key]);
+  return !!matchUpScheduleKeys.length;
+};
+
 function processAlreadyScheduledMatchUps({
   matchUpPotentialParticipantIds,
   individualParticipantProfiles,
@@ -36924,14 +35833,12 @@ function getParticipantScaleItem$1({
   policyDefinitions,
   scaleAttributes,
   participantId,
-  inContext,
   personId
 }) {
   let result = publicFindParticipant({
     tournamentRecords,
     policyDefinitions,
     participantId,
-    inContext,
     personId
   });
   if (result.error)
@@ -50096,496 +49003,1590 @@ function clearHistory({ matchUp }) {
   return saveHistory({ matchUp });
 }
 
-function addPoint({ matchUp, point }) {
-  if (!point)
-    return { error: MISSING_VALUE };
-  if (typeof point !== "object")
-    return { error: INVALID_VALUES, context: { point } };
-  const { history = [] } = getHistory({ matchUp });
-  history.push(point);
-  return saveHistory({ matchUp, history });
+function addPoint({ matchUp, point }) {
+  if (!point)
+    return { error: MISSING_VALUE };
+  if (typeof point !== "object")
+    return { error: INVALID_VALUES, context: { point } };
+  const { history = [] } = getHistory({ matchUp });
+  history.push(point);
+  return saveHistory({ matchUp, history });
+}
+
+function addGame({ matchUp, game }) {
+  if (typeof game !== "object")
+    return { error: INVALID_VALUES, context: { game } };
+  const { history = [] } = getHistory({ matchUp });
+  history.push(game);
+  return saveHistory({ matchUp, history });
+}
+
+function addShot({ matchUp, shot }) {
+  if (typeof shot !== "object")
+    return { error: MISSING_VALUE };
+  const { history = [] } = getHistory({ matchUp });
+  history.push(shot);
+  return saveHistory({ matchUp, history });
+}
+
+function addSet({ matchUp, set }) {
+  if (typeof set !== "object")
+    return { error: MISSING_VALUE };
+  const { history = [] } = getHistory({ matchUp });
+  history.push(set);
+  return saveHistory({ matchUp, history });
+}
+
+function redo({ matchUp }) {
+  const { history = [], undoHistory = [] } = getHistory({ matchUp });
+  if (undoHistory.length)
+    history.push(undoHistory.pop());
+  return saveHistory({ matchUp, history, undoHistory });
+}
+
+function undo({ matchUp }) {
+  const { history = [], undoHistory = [] } = getHistory({ matchUp });
+  undoHistory.push(history.pop());
+  return saveHistory({ matchUp, history, undoHistory });
+}
+
+const umo = {
+  scoreboard: () => {
+  },
+  addPoints: () => {
+  },
+  addPoint: () => {
+  }
+};
+
+const historyGovernor = {
+  calculateHistoryScore,
+  setServingSide,
+  clearHistory,
+  addPoint,
+  addGame,
+  addShot,
+  addSet,
+  redo,
+  undo,
+  umo
+};
+
+function analyzeMatchUp(params) {
+  const { matchUp, sideNumber, setNumber, isTiebreakValue, isPointValue } = params || {};
+  let { matchUpFormat } = params || {};
+  if (!matchUp)
+    return { error: MISSING_MATCHUP };
+  matchUpFormat = matchUpFormat || matchUp?.matchUpFormat;
+  const matchUpScoringFormat = parse(matchUpFormat);
+  const isCompletedMatchUp = !!matchUp?.winningSide;
+  const sets = matchUp.score?.sets;
+  const setsCount = sets?.length;
+  const setIndex = setNumber && setNumber - 1;
+  const isExistingSet = !!sets?.find(
+    (set, index) => set.setNumber === setNumber && index === setIndex
+  );
+  const completedSets = sets?.filter((set) => set?.winningSide) || [];
+  const completedSetsCount = completedSets?.length || 0;
+  const setsFollowingCurrent = setNumber && sets?.slice(setNumber) || [];
+  const isLastSetWithValues = !!(setsCount && setNumber && // EVERY: is this a candidate for .every?
+  setsFollowingCurrent?.reduce((noValues, set) => {
+    return (!set || !set.side1Score && !set.side2Score && !set.side1TiebreakScore && !set.side2TiebreakScore && !set.side1PointScore && !set.side2PointScore) && noValues;
+  }, true));
+  const setObject = setNumber <= setsCount && sets.find((set) => set.setNumber === setNumber);
+  const specifiedSetAnalysis = setObject && analyzeSet({ setObject, matchUpScoringFormat });
+  const {
+    isCompletedSet,
+    sideGameScores,
+    // sidePointScores,
+    sideTiebreakScores
+  } = specifiedSetAnalysis || {};
+  const isActiveSet = !!(setObject && !isCompletedSet && isLastSetWithValues || setNumber && setNumber === setsCount + 1 && !isCompletedMatchUp);
+  const isValidSideNumber = [1, 2].includes(sideNumber);
+  const sideIndex = isValidSideNumber ? sideNumber - 1 : 0;
+  const existingValue = setObject && isValidSideNumber && (!isTiebreakValue && !isPointValue && sideGameScores[sideIndex] !== void 0 && sideGameScores[sideIndex] || isTiebreakValue && sideTiebreakScores[sideIndex] !== void 0 && sideTiebreakScores[sideIndex]);
+  const hasExistingValue = !!existingValue;
+  const completedSetsHaveValidOutcomes = completedSets?.map(
+    (setObject2) => analyzeSet({ setObject: setObject2, matchUpScoringFormat }).isValidSetOutcome
+  ).reduce((valid, validOutcome) => valid && validOutcome, true);
+  const setsWinCounts = completedSets.reduce(
+    (counts, set) => {
+      const { winningSide } = set;
+      const winningSideIndex = winningSide - 1;
+      counts[winningSideIndex]++;
+      return counts;
+    },
+    [0, 0]
+  );
+  const matchUpWinningSide = matchUp?.winningSide;
+  const matchUpWinningSideIndex = matchUpWinningSide && matchUpWinningSide - 1;
+  const matchUpLosingSideIndex = 1 - matchUpWinningSideIndex;
+  const winningSideSetsCount = setsWinCounts[matchUpWinningSideIndex];
+  const losingSideSetsCount = setsWinCounts[matchUpLosingSideIndex];
+  const maxSetsCount = Math.max(...setsWinCounts);
+  const maxSetsInstances = instanceCount(setsWinCounts)[maxSetsCount];
+  const { bestOf } = matchUpScoringFormat || {};
+  const setsToWin = bestOf && Math.ceil(bestOf / 2) || 1;
+  const calculatedWinningSide = maxSetsCount === setsToWin && maxSetsInstances === 1 && setsWinCounts.indexOf(maxSetsCount) + 1 || void 0;
+  const validMatchUpWinningSide = winningSideSetsCount > losingSideSetsCount && matchUpWinningSide === calculatedWinningSide;
+  const validMatchUpOutcome = calculatedWinningSide && completedSetsHaveValidOutcomes && validMatchUpWinningSide;
+  return {
+    completedSetsHaveValidOutcomes,
+    validMatchUpWinningSide,
+    calculatedWinningSide,
+    matchUpScoringFormat,
+    validMatchUpOutcome,
+    isLastSetWithValues,
+    completedSetsCount,
+    isCompletedMatchUp,
+    isValidSideNumber,
+    hasExistingValue,
+    existingValue,
+    isExistingSet,
+    isActiveSet,
+    ...specifiedSetAnalysis
+  };
+}
+
+const queryGovernor$1 = {
+  tallyParticipantResults,
+  matchUpIsComplete,
+  analyzeMatchUp,
+  getMatchUpType,
+  scoreHasValue,
+  validMatchUps,
+  validMatchUp
+};
+
+let keyedMatchUps = {};
+let matchUpId;
+function setState$2(value, deepCopyOption = true) {
+  if (!value)
+    return { error: MISSING_VALUE };
+  if (typeof value !== "object")
+    return { error: INVALID_OBJECT };
+  if (value.matchUpId) {
+    matchUpId = value.matchUpId;
+    keyedMatchUps[matchUpId] = deepCopyOption ? makeDeepCopy(value) : value;
+  } else if (Array.isArray(value)) {
+    for (const m of value.reverse()) {
+      if (m.matchUpId) {
+        keyedMatchUps[m.matchUpId] = deepCopyOption ? makeDeepCopy(m) : m;
+        if (!matchUpId)
+          matchUpId = m.matchUpId;
+      }
+    }
+  } else {
+    for (const m of Object.values(value)) {
+      if (m.matchUpId) {
+        keyedMatchUps[m.matchUpId] = deepCopyOption ? makeDeepCopy(m) : m;
+        if (!matchUpId)
+          matchUpId = m.matchUpId;
+      }
+    }
+  }
+  return deepCopyOption ? makeDeepCopy(value) : value;
+}
+function getMatchUp() {
+  return keyedMatchUps[matchUpId];
+}
+function getMatchUps() {
+  return Object.values(keyedMatchUps);
+}
+function reset() {
+  matchUpId = void 0;
+  keyedMatchUps = {};
+}
+function getState$2(params) {
+  return makeDeepCopy(
+    keyedMatchUps[matchUpId],
+    params?.convertExtensions,
+    false,
+    params?.removeExtensions
+  );
+}
+
+const matchUpEngine = (() => {
+  const engine = {
+    getState: (params) => getState$2(params),
+    version: () => factoryVersion(),
+    reset: () => {
+      reset();
+      return { ...SUCCESS };
+    },
+    drawId: void 0,
+    error: void 0,
+    success: false,
+    devContext: (contextCriteria) => {
+      setDevContext(contextCriteria);
+      return engine;
+    },
+    setState: (definition, deepCopyOption, deepCopyAttributes) => {
+      setDeepCopy(deepCopyOption, deepCopyAttributes);
+      const result = setState$2(definition);
+      return processResult(result);
+    }
+  };
+  function processResult(result) {
+    if (result?.error) {
+      engine.error = result.error;
+      engine.success = false;
+    } else {
+      engine.error = void 0;
+      engine.success = true;
+      engine.drawId = result.drawId;
+    }
+    return engine;
+  }
+  importGovernors([
+    tieFormatGovernor,
+    historyGovernor,
+    queryGovernor$1,
+    scoreGovernor
+  ]);
+  return engine;
+  function importGovernors(governors) {
+    governors.forEach((governor) => {
+      Object.keys(governor).forEach((methodName) => {
+        engine[methodName] = (params) => {
+          if (getDevContext()) {
+            return invoke({ params, governor, methodName });
+          } else {
+            try {
+              return invoke({ params, governor, methodName });
+            } catch (err) {
+              handleCaughtError({
+                engineName: "matchUpEngine",
+                methodName,
+                params,
+                err
+              });
+            }
+          }
+        };
+      });
+    });
+  }
+  function invoke({ params, governor, methodName }) {
+    engine.error = void 0;
+    engine.success = false;
+    const matchUp = params?.matchUp || getMatchUp();
+    const matchUps = params?.matchUps || getMatchUps();
+    const snapshot = params?.rollbackOnError && makeDeepCopy(matchUp, false, true);
+    params = {
+      ...params,
+      matchUpId: matchUp?.matchUpId,
+      matchUps,
+      matchUp
+    };
+    const result = governor[methodName](params);
+    if (result?.error) {
+      if (snapshot)
+        setState$2(snapshot);
+      return { ...result, rolledBack: !!snapshot };
+    }
+    const notify = result?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
+    if (notify)
+      notifySubscribers();
+    if (notify || !result?.success || params?.doNotNotify)
+      deleteNotices();
+    return result;
+  }
+})();
+
+function matchUpEngineAsync(test) {
+  const result = createInstanceState();
+  if (result.error && !test)
+    return result;
+  const engine = {
+    getState: (params) => getState$2(params),
+    version: () => factoryVersion(),
+    reset: () => {
+      reset();
+      return { ...SUCCESS };
+    },
+    drawId: void 0,
+    error: void 0,
+    success: false,
+    devContext: (contextCriteria) => {
+      setDevContext(contextCriteria);
+      return engine;
+    },
+    setState: (definition, deepCopyOption, deepCopyAttributes) => {
+      setDeepCopy(deepCopyOption, deepCopyAttributes);
+      const result2 = setState$2(definition);
+      return processResult(result2);
+    }
+  };
+  function processResult(result2) {
+    if (result2?.error) {
+      engine.error = result2.error;
+      engine.success = false;
+    } else {
+      engine.error = void 0;
+      engine.success = true;
+      engine.drawId = result2.drawId;
+    }
+    return engine;
+  }
+  importGovernors([
+    tieFormatGovernor,
+    historyGovernor,
+    queryGovernor$1,
+    scoreGovernor
+  ]);
+  return engine;
+  async function importGovernors(governors) {
+    for (const governor of governors) {
+      const governorMethods = Object.keys(governor);
+      for (const methodName of governorMethods) {
+        engine[methodName] = async (params) => {
+          if (getDevContext()) {
+            return await invoke({ params, governor, methodName });
+          } else {
+            try {
+              return await invoke({ params, governor, methodName });
+            } catch (err) {
+              handleCaughtError({
+                engineName: "matchUpEngine",
+                methodName,
+                params,
+                err
+              });
+            }
+          }
+        };
+      }
+    }
+  }
+  async function invoke({ params, governor, methodName }) {
+    engine.success = false;
+    engine.error = void 0;
+    const matchUp = params?.matchUp || getMatchUp();
+    const matchUps = params?.matchUps || getMatchUps();
+    const snapshot = params?.rollbackOnError && makeDeepCopy(matchUp, false, true);
+    params = {
+      ...params,
+      matchUpId: matchUp?.matchUpId,
+      matchUps,
+      matchUp
+    };
+    const result2 = governor[methodName](params);
+    if (result2?.error) {
+      if (snapshot)
+        setState$2(snapshot);
+      return { ...result2, rolledBack: !!snapshot };
+    }
+    const notify = result2?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
+    if (notify)
+      await notifySubscribersAsync();
+    if (notify || !result2?.success || params?.doNotNotify)
+      deleteNotices();
+    return result2;
+  }
+}
+
+function newTournamentRecord(params) {
+  const attributes = params || {};
+  if (!attributes.tournamentId)
+    attributes.tournamentId = UUID();
+  if (attributes.startDate && !isISODateString(attributes.startDate) && !validDateString.test(attributes.startDate)) {
+    return { error: INVALID_DATE };
+  }
+  if (attributes.endDate && !isISODateString(attributes.endDate) && !validDateString.test(attributes.endDate)) {
+    return { error: INVALID_DATE };
+  }
+  if (attributes.extensions) {
+    attributes.extensions = attributes.extensions.filter(isValidExtension);
+  }
+  return { ...attributes };
+}
+
+function setState$1(tournament, deepCopyOption) {
+  if (typeof tournament !== "object")
+    return { error: INVALID_OBJECT };
+  const tournamentId = tournament.unifiedTournamentId?.tournamentId || tournament.tournamentId;
+  if (!tournamentId)
+    return { error: MISSING_TOURNAMENT_ID };
+  const tournamentRecord = deepCopyOption !== false ? makeDeepCopy(tournament) : tournament;
+  setTournamentRecords({ [tournamentId]: tournamentRecord });
+  setTournamentId(tournamentId);
+  return tournamentRecord;
+}
+function getState$1({
+  convertExtensions = false,
+  removeExtensions = false,
+  tournamentId
+}) {
+  if (typeof tournamentId !== "string")
+    return {};
+  const tournamentRecord = getTournamentRecord(tournamentId);
+  return {
+    tournamentRecord: makeDeepCopy(
+      tournamentRecord,
+      convertExtensions,
+      false,
+      removeExtensions
+    )
+  };
+}
+function paramsMiddleware$1(tournamentRecord, params, prefetch) {
+  if (params) {
+    const drawId = params.drawId || params.matchUp?.drawId;
+    if (drawId) {
+      const { event, drawDefinition } = findEvent({
+        tournamentRecord,
+        drawId
+      });
+      params = {
+        ...params,
+        event,
+        drawDefinition
+      };
+      if (prefetch) {
+        const matchUpsMap = getMatchUpsMap({ drawDefinition });
+        const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
+          inContext: true,
+          drawDefinition,
+          matchUpsMap
+        });
+        params.matchUpsMap = matchUpsMap;
+        params.inContextDrawMatchUps = inContextDrawMatchUps;
+      }
+    }
+    if (params.eventId && !params.event) {
+      const { event } = findEvent({
+        eventId: params.eventId,
+        tournamentRecord
+      });
+      if (event) {
+        params = { ...params, event };
+      }
+    }
+  }
+  return params;
+}
+
+function getEligibleVoluntaryConsolationParticipants(params) {
+  if (!params.tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  return getEligibleVoluntaryConsolationParticipants$1(params);
 }
 
-function addGame({ matchUp, game }) {
-  if (typeof game !== "object")
-    return { error: INVALID_VALUES, context: { game } };
-  const { history = [] } = getHistory({ matchUp });
-  history.push(game);
-  return saveHistory({ matchUp, history });
+function getParticipantEventDetails({
+  tournamentRecord,
+  participantId
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!participantId)
+    return { error: MISSING_PARTICIPANT_ID };
+  const relevantParticipantIds = [participantId].concat(
+    (tournamentRecord.participants || []).filter(
+      (participant) => participant?.participantType && [TEAM, PAIR].includes(participant.participantType) && participant.individualParticipantIds?.includes(participantId)
+    ).map((participant) => participant.participantId)
+  );
+  const relevantEvents = (tournamentRecord.events || []).filter((event) => {
+    const enteredParticipantIds = (event?.entries || []).map(
+      (entry) => entry.participantId
+    );
+    return overlap(enteredParticipantIds, relevantParticipantIds);
+  }).map((event) => ({ eventName: event.eventName, eventId: event.eventId }));
+  return { eventDetails: relevantEvents };
 }
 
-function addShot({ matchUp, shot }) {
-  if (typeof shot !== "object")
-    return { error: MISSING_VALUE };
-  const { history = [] } = getHistory({ matchUp });
-  history.push(shot);
-  return saveHistory({ matchUp, history });
+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 addSet({ matchUp, set }) {
-  if (typeof set !== "object")
-    return { error: MISSING_VALUE };
-  const { history = [] } = getHistory({ matchUp });
-  history.push(set);
-  return saveHistory({ matchUp, history });
+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 redo({ matchUp }) {
-  const { history = [], undoHistory = [] } = getHistory({ matchUp });
-  if (undoHistory.length)
-    history.push(undoHistory.pop());
-  return saveHistory({ matchUp, history, undoHistory });
+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;
 }
 
-function undo({ matchUp }) {
-  const { history = [], undoHistory = [] } = getHistory({ matchUp });
-  undoHistory.push(history.pop());
-  return saveHistory({ matchUp, history, undoHistory });
+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)
+      )
+    );
+  });
+  return { scheduledMatchUps };
 }
 
-const umo = {
-  scoreboard: () => {
-  },
-  addPoints: () => {
-  },
-  addPoint: () => {
+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 historyGovernor = {
-  calculateHistoryScore,
-  setServingSide,
-  clearHistory,
-  addPoint,
-  addGame,
-  addShot,
-  addSet,
-  redo,
-  undo,
-  umo
-};
-
-function analyzeMatchUp(params) {
-  const { matchUp, sideNumber, setNumber, isTiebreakValue, isPointValue } = params || {};
-  let { matchUpFormat } = params || {};
-  if (!matchUp)
-    return { error: MISSING_MATCHUP };
-  matchUpFormat = matchUpFormat || matchUp?.matchUpFormat;
-  const matchUpScoringFormat = parse(matchUpFormat);
-  const isCompletedMatchUp = !!matchUp?.winningSide;
-  const sets = matchUp.score?.sets;
-  const setsCount = sets?.length;
-  const setIndex = setNumber && setNumber - 1;
-  const isExistingSet = !!sets?.find(
-    (set, index) => set.setNumber === setNumber && index === setIndex
-  );
-  const completedSets = sets?.filter((set) => set?.winningSide) || [];
-  const completedSetsCount = completedSets?.length || 0;
-  const setsFollowingCurrent = setNumber && sets?.slice(setNumber) || [];
-  const isLastSetWithValues = !!(setsCount && setNumber && // EVERY: is this a candidate for .every?
-  setsFollowingCurrent?.reduce((noValues, set) => {
-    return (!set || !set.side1Score && !set.side2Score && !set.side1TiebreakScore && !set.side2TiebreakScore && !set.side1PointScore && !set.side2PointScore) && noValues;
-  }, true));
-  const setObject = setNumber <= setsCount && sets.find((set) => set.setNumber === setNumber);
-  const specifiedSetAnalysis = setObject && analyzeSet({ setObject, matchUpScoringFormat });
+  const participantId = participant?.participantId;
+  if (!participantId || !participantIdMap[participantId])
+    return {};
   const {
-    isCompletedSet,
-    sideGameScores,
-    // sidePointScores,
-    sideTiebreakScores
-  } = specifiedSetAnalysis || {};
-  const isActiveSet = !!(setObject && !isCompletedSet && isLastSetWithValues || setNumber && setNumber === setsCount + 1 && !isCompletedMatchUp);
-  const isValidSideNumber = [1, 2].includes(sideNumber);
-  const sideIndex = isValidSideNumber ? sideNumber - 1 : 0;
-  const existingValue = setObject && isValidSideNumber && (!isTiebreakValue && !isPointValue && sideGameScores[sideIndex] !== void 0 && sideGameScores[sideIndex] || isTiebreakValue && sideTiebreakScores[sideIndex] !== void 0 && sideTiebreakScores[sideIndex]);
-  const hasExistingValue = !!existingValue;
-  const completedSetsHaveValidOutcomes = completedSets?.map(
-    (setObject2) => analyzeSet({ setObject: setObject2, matchUpScoringFormat }).isValidSetOutcome
-  ).reduce((valid, validOutcome) => valid && validOutcome, true);
-  const setsWinCounts = completedSets.reduce(
-    (counts, set) => {
-      const { winningSide } = set;
-      const winningSideIndex = winningSide - 1;
-      counts[winningSideIndex]++;
-      return counts;
-    },
-    [0, 0]
-  );
-  const matchUpWinningSide = matchUp?.winningSide;
-  const matchUpWinningSideIndex = matchUpWinningSide && matchUpWinningSide - 1;
-  const matchUpLosingSideIndex = 1 - matchUpWinningSideIndex;
-  const winningSideSetsCount = setsWinCounts[matchUpWinningSideIndex];
-  const losingSideSetsCount = setsWinCounts[matchUpLosingSideIndex];
-  const maxSetsCount = Math.max(...setsWinCounts);
-  const maxSetsInstances = instanceCount(setsWinCounts)[maxSetsCount];
-  const { bestOf } = matchUpScoringFormat || {};
-  const setsToWin = bestOf && Math.ceil(bestOf / 2) || 1;
-  const calculatedWinningSide = maxSetsCount === setsToWin && maxSetsInstances === 1 && setsWinCounts.indexOf(maxSetsCount) + 1 || void 0;
-  const validMatchUpWinningSide = winningSideSetsCount > losingSideSetsCount && matchUpWinningSide === calculatedWinningSide;
-  const validMatchUpOutcome = calculatedWinningSide && completedSetsHaveValidOutcomes && validMatchUpWinningSide;
-  return {
-    completedSetsHaveValidOutcomes,
-    validMatchUpWinningSide,
-    calculatedWinningSide,
-    matchUpScoringFormat,
-    validMatchUpOutcome,
-    isLastSetWithValues,
-    completedSetsCount,
-    isCompletedMatchUp,
-    isValidSideNumber,
-    hasExistingValue,
-    existingValue,
-    isExistingSet,
-    isActiveSet,
-    ...specifiedSetAnalysis
+    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 queryGovernor$1 = {
-  tallyParticipantResults,
-  matchUpIsComplete,
-  analyzeMatchUp,
-  getMatchUpType,
-  scoreHasValue,
-  validMatchUps,
-  validMatchUp
-};
-
-let keyedMatchUps = {};
-let matchUpId;
-function setState$2(value, deepCopyOption = true) {
-  if (!value)
-    return { error: MISSING_VALUE };
-  if (typeof value !== "object")
-    return { error: INVALID_OBJECT };
-  if (value.matchUpId) {
-    matchUpId = value.matchUpId;
-    keyedMatchUps[matchUpId] = deepCopyOption ? makeDeepCopy(value) : value;
-  } else if (Array.isArray(value)) {
-    for (const m of value.reverse()) {
-      if (m.matchUpId) {
-        keyedMatchUps[m.matchUpId] = deepCopyOption ? makeDeepCopy(m) : m;
-        if (!matchUpId)
-          matchUpId = m.matchUpId;
+  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;
+        }
       }
     }
-  } else {
-    for (const m of Object.values(value)) {
-      if (m.matchUpId) {
-        keyedMatchUps[m.matchUpId] = deepCopyOption ? makeDeepCopy(m) : m;
-        if (!matchUpId)
-          matchUpId = m.matchUpId;
+  }
+  if (withEvents && participantEvents) {
+    participant.events = participantEvents;
+    if (withSeeding) {
+      const seedingScales = Object.assign(
+        {},
+        ...(participant.timeItems || []).filter(({ itemType }) => itemType.split(".")[1] === SEEDING$1).map(({ itemType: seedingScaleName, itemValue: seedValue }) => ({
+          [seedingScaleName]: seedValue
+        }))
+      );
+      for (const participantEvent of participantEvents) {
+        const getScaleAccessor = (scaleName) => [SCALE$1, SEEDING$1, 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$1,
+              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;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  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$2, 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$2, 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
+              });
+            }
+          }
+        }
       }
-    }
-  }
-  return deepCopyOption ? makeDeepCopy(value) : value;
-}
-function getMatchUp() {
-  return keyedMatchUps[matchUpId];
-}
-function getMatchUps() {
-  return Object.values(keyedMatchUps);
-}
-function reset() {
-  matchUpId = void 0;
-  keyedMatchUps = {};
+    });
+  });
+  if (withStatistics)
+    participant.statistics = [winRatioStat];
+  return { scheduleConflicts, scheduleItems };
 }
-function getState$2(params) {
-  return makeDeepCopy(
-    keyedMatchUps[matchUpId],
-    params?.convertExtensions,
-    false,
-    params?.removeExtensions
+
+function getDrawDetails({
+  eventEntries,
+  sortConfig,
+  event
+}) {
+  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$1({
+        structure: mainStructure
+      })?.positionAssignments;
+      const drawSize = mainPositionAssignments?.length;
+      const qualifyingStructure = getDrawStructures({
+        stageSequence: 1,
+        stage: QUALIFYING,
+        drawDefinition
+      })?.structures?.[0];
+      const qualifyingPositionAssignments = mainStructure && getPositionAssignments$1({
+        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
+        }
+      };
+    })
   );
+  return { derivedInfo, drawDetails };
 }
 
-const matchUpEngine = (() => {
-  const engine = {
-    getState: (params) => getState$2(params),
-    version: () => factoryVersion(),
-    reset: () => {
-      reset();
-      return { ...SUCCESS };
-    },
-    drawId: void 0,
-    error: void 0,
-    success: false,
-    devContext: (contextCriteria) => {
-      setDevContext(contextCriteria);
-      return engine;
-    },
-    setState: (definition, deepCopyOption, deepCopyAttributes) => {
-      setDeepCopy(deepCopyOption, deepCopyAttributes);
-      const result = setState$2(definition);
-      return processResult(result);
-    }
+function processMatchUp({
+  relevantParticipantIdsMap,
+  participantFilters,
+  participantIdMap,
+  derivedDrawInfo,
+  eventDrawsCount,
+  drawDetails,
+  eventType,
+  matchUp
+}) {
+  const {
+    collectionId,
+    collectionPosition,
+    drawId,
+    drawName,
+    eventId,
+    eventName,
+    finishingRound,
+    finishingPositionRange,
+    processCodes,
+    loserTo,
+    matchUpId,
+    matchUpType,
+    matchUpFormat,
+    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 : [];
   };
-  function processResult(result) {
-    if (result?.error) {
-      engine.error = result.error;
-      engine.success = false;
-    } else {
-      engine.error = void 0;
-      engine.success = true;
-      engine.drawId = result.drawId;
-    }
-    return engine;
+  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);
   }
-  importGovernors([
-    tieFormatGovernor,
-    historyGovernor,
-    queryGovernor$1,
-    scoreGovernor
-  ]);
-  return engine;
-  function importGovernors(governors) {
-    governors.forEach((governor) => {
-      Object.keys(governor).forEach((methodName) => {
-        engine[methodName] = (params) => {
-          if (getDevContext()) {
-            return invoke({ params, governor, methodName });
-          } else {
-            try {
-              return invoke({ params, governor, methodName });
-            } catch (err) {
-              handleCaughtError({
-                engineName: "matchUpEngine",
-                methodName,
-                params,
-                err
-              });
+  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);
+      }
+    });
+    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
+          });
+        }
+        if (!participantIdMap[relevantParticipantId].events[eventId]) {
+          participantIdMap[relevantParticipantId].events[eventId] = {
+            partnerParticipantIds: [],
+            drawIds: [],
+            eventName,
+            eventId
+          };
+        }
+        const eventDrawIds = participantIdMap[relevantParticipantId].events[eventId].drawIds;
+        if (eventDrawIds && !eventDrawIds?.includes(drawId)) {
+          participantIdMap[relevantParticipantId].events[eventId].drawIds.push(
+            drawId
+          );
+        }
+        let partnerParticipantId;
+        if (participantType === INDIVIDUAL && matchUpType === DOUBLES_MATCHUP) {
+          const relevantParticipantInfo = filteredRelevantParticipantIds.find(
+            (participantInfo) => {
+              return participantInfo.relevantParticipantId !== relevantParticipantId && participantInfo.participantType === INDIVIDUAL;
+            }
+          );
+          partnerParticipantId = relevantParticipantInfo?.relevantParticipantId;
+        }
+        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
+            };
           }
-        };
+        );
+        const opponentParticipantInfo = filteredRelevantOpponents.map(
+          ({ relevantParticipantId: relevantParticipantId2, participantType: participantType2 }) => ({
+            participantId: relevantParticipantId2,
+            participantType: participantType2
+          })
+        );
+        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,
+            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;
+        }
+        if (winningSide) {
+          if (participantWon) {
+            participantIdMap[relevantParticipantId].wins++;
+          } else {
+            participantIdMap[relevantParticipantId].losses++;
+          }
+        }
+      }
+    );
+  });
+  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 invoke({ params, governor, methodName }) {
-    engine.error = void 0;
-    engine.success = false;
-    const matchUp = params?.matchUp || getMatchUp();
-    const matchUps = params?.matchUps || getMatchUps();
-    const snapshot = params?.rollbackOnError && makeDeepCopy(matchUp, false, true);
-    params = {
-      ...params,
-      matchUpId: matchUp?.matchUpId,
-      matchUps,
-      matchUp
-    };
-    const result = governor[methodName](params);
-    if (result?.error) {
-      if (snapshot)
-        setState$2(snapshot);
-      return { ...result, rolledBack: !!snapshot };
-    }
-    const notify = result?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
-    if (notify)
-      notifySubscribers();
-    if (notify || !result?.success || params?.doNotNotify)
-      deleteNotices();
-    return result;
-  }
-})();
+}
 
-function matchUpEngineAsync(test) {
-  const result = createInstanceState();
-  if (result.error && !test)
-    return result;
-  const engine = {
-    getState: (params) => getState$2(params),
-    version: () => factoryVersion(),
-    reset: () => {
-      reset();
-      return { ...SUCCESS };
-    },
-    drawId: void 0,
-    error: void 0,
-    success: false,
-    devContext: (contextCriteria) => {
-      setDevContext(contextCriteria);
-      return engine;
-    },
-    setState: (definition, deepCopyOption, deepCopyAttributes) => {
-      setDeepCopy(deepCopyOption, deepCopyAttributes);
-      const result2 = setState$2(definition);
-      return processResult(result2);
-    }
+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
+  });
+  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 : [];
   };
-  function processResult(result2) {
-    if (result2?.error) {
-      engine.error = result2.error;
-      engine.success = false;
-    } else {
-      engine.error = void 0;
-      engine.success = true;
-      engine.drawId = result2.drawId;
+  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
+          });
+        }
+      });
     }
-    return engine;
-  }
-  importGovernors([
-    tieFormatGovernor,
-    historyGovernor,
-    queryGovernor$1,
-    scoreGovernor
-  ]);
-  return engine;
-  async function importGovernors(governors) {
-    for (const governor of governors) {
-      const governorMethods = Object.keys(governor);
-      for (const methodName of governorMethods) {
-        engine[methodName] = async (params) => {
-          if (getDevContext()) {
-            return await invoke({ params, governor, methodName });
-          } else {
-            try {
-              return await invoke({ params, governor, methodName });
-            } catch (err) {
-              handleCaughtError({
-                engineName: "matchUpEngine",
-                methodName,
-                params,
-                err
-              });
-            }
-          }
-        };
-      }
+    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
+          });
+        }
+      });
     }
-  }
-  async function invoke({ params, governor, methodName }) {
-    engine.success = false;
-    engine.error = void 0;
-    const matchUp = params?.matchUp || getMatchUp();
-    const matchUps = params?.matchUps || getMatchUps();
-    const snapshot = params?.rollbackOnError && makeDeepCopy(matchUp, false, true);
-    params = {
-      ...params,
-      matchUpId: matchUp?.matchUpId,
-      matchUps,
-      matchUp
-    };
-    const result2 = governor[methodName](params);
-    if (result2?.error) {
-      if (snapshot)
-        setState$2(snapshot);
-      return { ...result2, rolledBack: !!snapshot };
+    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
+          );
+        }
+      });
     }
-    const notify = result2?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
-    if (notify)
-      await notifySubscribersAsync();
-    if (notify || !result2?.success || params?.doNotNotify)
-      deleteNotices();
-    return result2;
-  }
-}
-
-function newTournamentRecord(params) {
-  const attributes = params || {};
-  if (!attributes.tournamentId)
-    attributes.tournamentId = UUID();
-  if (attributes.startDate && !isISODateString(attributes.startDate) && !validDateString.test(attributes.startDate)) {
-    return { error: INVALID_DATE };
-  }
-  if (attributes.endDate && !isISODateString(attributes.endDate) && !validDateString.test(attributes.endDate)) {
-    return { error: INVALID_DATE };
-  }
-  if (attributes.extensions) {
-    attributes.extensions = attributes.extensions.filter(isValidExtension);
+  });
+  if (params.withMatchUps) {
+    getMatchUpDependencies({ tournamentRecord });
   }
-  return { ...attributes };
-}
-
-function setState$1(tournament, deepCopyOption) {
-  if (typeof tournament !== "object")
-    return { error: INVALID_OBJECT };
-  const tournamentId = tournament.unifiedTournamentId?.tournamentId || tournament.tournamentId;
-  if (!tournamentId)
-    return { error: MISSING_TOURNAMENT_ID };
-  const tournamentRecord = deepCopyOption !== false ? makeDeepCopy(tournament) : tournament;
-  setTournamentRecords({ [tournamentId]: tournamentRecord });
-  setTournamentId(tournamentId);
-  return tournamentRecord;
-}
-function getState$1({
-  convertExtensions = false,
-  removeExtensions = false,
-  tournamentId
-}) {
-  if (typeof tournamentId !== "string")
-    return {};
-  const tournamentRecord = getTournamentRecord(tournamentId);
-  return {
-    tournamentRecord: makeDeepCopy(
-      tournamentRecord,
-      convertExtensions,
-      false,
-      removeExtensions
-    )
-  };
-}
-function paramsMiddleware$1(tournamentRecord, params, prefetch) {
-  if (params) {
-    const drawId = params.drawId || params.matchUp?.drawId;
-    if (drawId) {
-      const { event, drawDefinition } = findEvent({
-        tournamentRecord,
-        drawId
+  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$2({
+            element: rawEvent.drawDefinitions[i],
+            // rawEvent because deepCopy has converted extensions
+            name: LINEUPS
+          });
+          if (extension)
+            drawDefinition.extensions = [extension];
+        }
       });
-      params = {
-        ...params,
-        event,
-        drawDefinition
+      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$1}`;
+      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
+        };
+      }
+      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 (prefetch) {
-        const matchUpsMap = getMatchUpsMap({ drawDefinition });
-        const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
+      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,
-          drawDefinition,
-          matchUpsMap
-        });
-        params.matchUpsMap = matchUpsMap;
-        params.inContextDrawMatchUps = inContextDrawMatchUps;
+          event
+        })?.matchUps;
+        matchUps?.forEach(
+          (matchUp) => processMatchUp({
+            relevantParticipantIdsMap,
+            participantFilters,
+            participantIdMap,
+            derivedDrawInfo,
+            eventDrawsCount,
+            drawDetails,
+            eventType,
+            matchUp
+          })
+        );
       }
-    }
-    if (params.eventId && !params.event) {
-      const { event } = findEvent({
-        eventId: params.eventId,
-        tournamentRecord
+    });
+  }
+  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
       });
-      if (event) {
-        params = { ...params, event };
+      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);
       }
     }
-  }
-  return params;
-}
-
-function getEligibleVoluntaryConsolationParticipants(params) {
-  if (!params.tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  return getEligibleVoluntaryConsolationParticipants$1(params);
+    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 };
 }
 
-function getParticipantEventDetails({
-  tournamentRecord,
-  participantId
-}) {
+function getTournamentParticipants(params) {
+  const {
+    participantFilters = {},
+    convertExtensions,
+    policyDefinitions,
+    withScheduleItems,
+    scheduleAnalysis,
+    withSignInStatus,
+    withTeamMatchUps,
+    // not implemented
+    tournamentRecord,
+    usePublishState,
+    withScaleValues,
+    withStatistics,
+    withGroupings,
+    withOpponents,
+    withMatchUps,
+    withSeeding,
+    withEvents,
+    withDraws,
+    inContext,
+    withISO2,
+    withIOC
+  } = params;
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  if (!participantId)
-    return { error: MISSING_PARTICIPANT_ID };
-  const relevantParticipantIds = [participantId].concat(
-    (tournamentRecord.participants || []).filter(
-      (participant) => participant?.participantType && [TEAM, PAIR].includes(participant.participantType) && participant.individualParticipantIds?.includes(participantId)
-    ).map((participant) => participant.participantId)
+  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
   );
-  const relevantEvents = (tournamentRecord.events || []).filter((event) => {
-    const enteredParticipantIds = (event?.entries || []).map(
-      (entry) => entry.participantId
+  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 (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,
+    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
+      })
     );
-    return overlap(enteredParticipantIds, relevantParticipantIds);
-  }).map((event) => ({ eventName: event.eventName, eventId: event.eventId }));
-  return { eventDetails: relevantEvents };
+  }
+  return {
+    participantIdsWithConflicts,
+    tournamentParticipants,
+    eventsPublishStatuses
+  };
 }
 
 function getParticipantMembership({
@@ -54089,6 +54090,11 @@ function updateCourtAvailability({ tournamentRecord }) {
       );
       return existing || { date, startTime, endTime };
     });
+    const defaultAvailability = court.dateAvailability?.find(
+      (availability) => !availability.date
+    );
+    if (defaultAvailability)
+      updatedDateAvailability.unshift(defaultAvailability);
     court.dateAvailability = updatedDateAvailability;
   }
   return { ...SUCCESS };
@@ -59028,7 +59034,7 @@ function generateDrawDefinition(params) {
       drawDefinition.links = [];
     drawDefinition.links.push(link);
   }
-  drawDefinition.drawName = params.drawName ?? drawType;
+  drawDefinition.drawName = params.drawName ?? (drawType && constantToString(drawType));
   if (typeof voluntaryConsolation === "object") {
     addVoluntaryConsolationStructure({
       ...voluntaryConsolation,