tods-competition-factory 1.8.22 → 1.8.24

package/dist/index.mjs

@@ -2382,7 +2382,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.22";
+  return "1.8.24";
 }
 
 function getObjectTieFormat(obj) {
@@ -3811,18 +3811,17 @@ function getTallyReport({ matchUps, order, report }) {
         readable.push(excluded);
       } else {
         const floatSort = (a, b) => parseFloat(step.reversed ? a : b) - parseFloat(step.reversed ? b : a);
+        const participantsCount = step.groups ? Object.values(step.groups).flat(Infinity).length : step.participantIds?.length ?? 0;
         const getExplanation = (step2) => {
-          Object.keys(step2.groups).sort(floatSort).forEach((key) => {
+          step2.groups && Object.keys(step2.groups).sort(floatSort).forEach((key) => {
             const participantNames = step2.groups[key].map((participantId) => participants[participantId]).join(", ");
             const explanation = `${key} ${step2.attribute}: ${participantNames}`;
             readable.push(explanation);
           });
         };
         const reversed = step.reversed ? " in reverse order" : "";
-        const participantsCount = Object.values(step.groups).flat(
-          Infinity
-        ).length;
-        const description = `Step ${i + 1}: ${participantsCount} particiants were grouped${reversed} by ${step.attribute}`;
+        const action = step.groups ? "grouped" : "separated";
+        const description = `Step ${i + 1}: ${participantsCount} particiants were ${action}${reversed} by ${step.attribute}`;
         readable.push(description);
         if (step.idsFilter) {
           const note = `${step.attribute} was calculated considering ONLY TIED PARTICIPANTS`;
@@ -3838,7 +3837,7 @@ function getTallyReport({ matchUps, order, report }) {
     const { participantId, resolved } = orderEntry;
     const pOrder = orderEntry.groupOrder || orderEntry.provisionalOrder;
     readable.push(
-      `${pOrder}: ${participants[participantId]} => resolved: ${resolved}`
+      `${pOrder}: ${participants[participantId]} => resolved: ${!!resolved}`
     );
   });
   return readable.join("\r\n");
@@ -3927,7 +3926,7 @@ function getGroupOrder(params) {
   report.push({ attribute, groups: orderedTallyGroups });
   const groupOrder = Object.keys(orderedTallyGroups).map((key) => parseFloat(key)).sort((a, b) => b - a).map((key) => orderedTallyGroups[key]).map((participantIds) => {
     const result = groupSubSort({ participantIds, ...params });
-    report.push(result.report);
+    report.push(...result.report || []);
     return result.order;
   }).flat(Infinity);
   let groupPosition = 1;
@@ -4019,7 +4018,7 @@ function processAttribute({
         tallyPolicy,
         matchUps
       });
-      report.push(result.report);
+      report.push(...result.report || []);
       return result.order;
     }).flat(Infinity);
   }
@@ -4033,6 +4032,9 @@ function groupSubSort({
   tallyPolicy,
   matchUps
 }) {
+  const excludedDirectives = [];
+  const report = [];
+  let result;
   if (participantIds?.length === 1) {
     const participantId = participantIds[0];
     return {
@@ -4041,13 +4043,13 @@ function groupSubSort({
   }
   if (participantIds?.length === 2 && (!tallyPolicy?.headToHead || !tallyPolicy.headToHead.disabled && !disableHeadToHead)) {
     const result2 = headToHeadWinner({ participantIds, participantResults });
-    if (result2)
-      return { order: [result2], headToHeadWinner: result2[0].participantId };
+    if (result2) {
+      const headToHeadWinner2 = result2[0].participantId;
+      report.push({ attribute: "head2Head", participantIds, headToHeadWinner: headToHeadWinner2 });
+      return { order: [result2], headToHeadWinner: headToHeadWinner2, report };
+    }
   }
   const directives = tallyPolicy?.tallyDirectives || headToHeadTallyDirectives;
-  const excludedDirectives = [];
-  const report = [];
-  let result;
   const filteredDirectives = directives.filter((directive) => {
     const keepDirective = isNumeric(directive.maxParticipants) && participantIds?.length > directive.maxParticipants ? false : true;
     if (!keepDirective)
@@ -4857,7 +4859,7 @@ function getMatchUpFormatTiming({
 }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  eventType = eventType || event?.eventType || TypeEnum.Singles;
+  eventType = eventType ?? event?.eventType ?? TypeEnum.Singles;
   const defaultTiming = {
     averageTimes: [{ minutes: { default: defaultAverageMinutes } }],
     recoveryTimes: [{ minutes: { default: defaultRecoveryMinutes } }]
@@ -5507,7 +5509,7 @@ function findVenue({
   if (!venue && tournamentRecords) {
     const linkedTournamentIds = getLinkedTournamentIds({
       tournamentRecords
-    }).linkedTournamentIds || [];
+    }).linkedTournamentIds ?? [];
     const relevantIds = linkedTournamentIds[tournamentRecord.tournamentId];
     for (const tournamentId of relevantIds) {
       const record = tournamentRecords[tournamentId];
@@ -6185,7 +6187,7 @@ function getPairedParticipant({
       result: { error: MISSING_PARTICIPANT_IDS },
       stack
     });
-  tournamentParticipants = tournamentParticipants || tournamentRecord?.participants || [];
+  tournamentParticipants = tournamentParticipants ?? tournamentRecord?.participants ?? [];
   const existingPairedParticipants = tournamentParticipants.filter(
     (participant) => participant.participantType === PAIR && intersection(participantIds, participant.individualParticipantIds).length === participantIds.length && participant.individualParticipantIds.length === participantIds.length
   );
@@ -7775,7 +7777,8 @@ const POLICY_ROUND_NAMING_DEFAULT = {
   [POLICY_TYPE_ROUND_NAMING]: {
     policyName: "Round Naming Default",
     namingConventions: {
-      round: "Round"
+      round: "Round",
+      pre: "Pre"
     },
     qualifyingFinishMap: {
       1: "Final"
@@ -7819,12 +7822,11 @@ function getRoundContextProfile({
   const roundNamingProfile = {};
   const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
   const isQualifying = structure.stage === QUALIFYING;
-  const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
   const qualifyingStageSequences = isQualifying ? Math.max(
     ...(drawDefinition?.structures ?? []).filter((structure2) => structure2.stage === QUALIFYING).map(({ stageSequence }) => stageSequence ?? 1),
     0
   ) : 0;
-  const preQualifyingSequence = qualifyingStageSequences ? qualifyingStageSequences - (structure.stageSequence || 1) || "" : "";
+  const preQualifyingSequence = (structure.stageSequence ?? 1) < qualifyingStageSequences ? structure.stageSequence ?? 1 : "";
   const preQualifyingAffix = preQualifyingSequence ? roundNamingPolicy?.affixes?.preQualifying || defaultRoundNamingPolicy.affixes.preQualifying || "" : "";
   const roundNamingMap = roundNamingPolicy?.roundNamingMap || defaultRoundNamingPolicy.roundNamingMap || {};
   const abbreviatedRoundNamingMap = roundNamingPolicy?.abbreviatedRoundNamingMap || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
@@ -7848,6 +7850,7 @@ function getRoundContextProfile({
       })
     );
   } else {
+    const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
     Object.assign(
       roundNamingProfile,
       ...roundProfileKeys.map((round) => {
@@ -8133,7 +8136,13 @@ function getAllStructureMatchUps({
       matchUps
     }));
   }
-  return { matchUps, roundMatchUps, roundProfile, collectionPositionMatchUps };
+  return {
+    collectionPositionMatchUps,
+    roundMatchUps,
+    roundProfile,
+    matchUpsMap,
+    matchUps
+  };
   function addMatchUpContext({
     scheduleVisibilityFilters: scheduleVisibilityFilters2,
     sourceDrawPositionRanges,
@@ -10116,8 +10125,10 @@ function modifyMatchUpScore({
         const matchUpFilters = isDualMatchUp ? { matchUpTypes: [TEAM$2] } : void 0;
         const { matchUps } = getAllStructureMatchUps({
           afterRecoveryTimes: false,
+          tournamentRecord,
           inContext: true,
           matchUpFilters,
+          drawDefinition,
           structure: structure2,
           event
         });
@@ -17811,7 +17822,7 @@ function parseScoreString({
       isSide1: winningSide === 2,
       tiebreakTo
     });
-    const setTiebreak = side1TiebreakPerspective || [];
+    const setTiebreak = side1TiebreakPerspective ?? [];
     const [side1Score, side2Score] = setScores || [];
     const [side1TiebreakScore, side2TiebreakScore] = matchTiebreak || setTiebreak || [];
     return {
@@ -18001,7 +18012,9 @@ function getSuper(values, index) {
     values.slice(index, index + 2),
     index ? values.slice(0, 1) : values.slice(2)
   ].map((n) => parseInt(n.join("")));
-  const scores = index ? parts.reverse() : parts;
+  if (index)
+    parts.reverse();
+  const scores = parts;
   const diff = Math.abs(scores.reduce((a, b) => +a - +b));
   if (diff >= 2)
     return scores.join("-");
@@ -19012,7 +19025,7 @@ function handleNumeric(params) {
       if (superParse && score !== superParse) {
         applied.push("parsedSuperPattern");
       }
-      score = superParse || score;
+      score = superParse ?? score;
     }
   }
   return { score, applied, matchUpStatus };
@@ -19053,7 +19066,9 @@ function sensibleSets({ score, matchUpStatus, attributes }) {
         const maxSetScore = Math.max(...sideScores);
         const maxIndex = setScores.indexOf(maxSetScore);
         const sensibleSetScores = [maxSetScore, maxSetScore - 1];
-        const sensibleSetScore = maxIndex ? sensibleSetScores.reverse().join("-") : sensibleSetScores.join("-");
+        if (maxIndex)
+          sensibleSetScores.reverse();
+        const sensibleSetScore = sensibleSetScores.join("-");
         return sensibleSetScore + tiebreak;
       }
     } else if (set.length === 2 && isNumeric(set)) {
@@ -19072,7 +19087,7 @@ function sensibleSets({ score, matchUpStatus, attributes }) {
         const splitMax = max.toString().split("");
         const reasonable = splitMax.find(
           (value) => parseInt(value) > min || index && parseInt(value) <= maxSetValue
-        ) || splitMax[0];
+        ) ?? splitMax[0];
         if (reasonable) {
           set = minIndex ? [reasonable, min].join("-") : [min, reasonable].join("-");
         }
@@ -19536,7 +19551,6 @@ function getVenuesAndCourts({
   tournamentIds.forEach((tournamentId) => {
     const tournamentRecord = tournamentRecords[tournamentId];
     for (const venue of tournamentRecord.venues || []) {
-      tournamentRecord.venues;
       if (venueIds.length && !venueIds.includes(venue.venueId))
         continue;
       if (ignoreDisabled) {
@@ -21007,7 +21021,7 @@ function getContainedStructures({
   const containerStructures = {};
   const structureContainers = drawDefinitions.map((dd) => dd?.structures?.filter((structure) => structure?.structures)).flat().filter(Boolean);
   for (const structureContainer of structureContainers) {
-    const { structures, structureId } = structureContainer || {};
+    const { structures, structureId } = structureContainer ?? {};
     structures && structureId && (containedStructures[structureId] = structures?.map(
       (structure) => structure.structureId
     )) && structures.forEach(
@@ -23079,7 +23093,10 @@ function getAffectedTargetStructureIds({
   return { structureIds };
 }
 
-function getPlayoffStructures({ drawDefinition, structureId }) {
+function getPlayoffStructures({
+  drawDefinition,
+  structureId
+}) {
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
   const { structure } = findStructure({ drawDefinition, structureId });
@@ -23214,7 +23231,7 @@ function allPlayoffPositionsFilled(params) {
           return assignment?.bye || assignment?.participantId;
         }
       ).length;
-      return structurePositionsFilled && allFilled;
+      return !!(structurePositionsFilled && allFilled);
     },
     !!playoffStructures.length
   );
@@ -27875,7 +27892,7 @@ function filterParticipants({
       );
       if (event.eventType === SINGLES)
         return enteredParticipantIds;
-      const individualParticipantIds = (tournamentRecord?.participants || []).filter(
+      const individualParticipantIds = (tournamentRecord?.participants ?? []).filter(
         (participant) => enteredParticipantIds.includes(participant.participantId)
       ).map((participant) => participant.individualParticipantIds).flat(1);
       return enteredParticipantIds.concat(...individualParticipantIds);
@@ -28242,7 +28259,7 @@ function addPenalty$1({
     return { error: MISSING_PARTICIPANT_ID };
   if (!penaltyType)
     return { error: MISSING_PENALTY_TYPE };
-  const participants = tournamentRecord?.participants || [];
+  const participants = tournamentRecord?.participants ?? [];
   const relevantParticipants = participants.filter(
     (participant) => participantIds.includes(participant.participantId)
   );
@@ -28285,13 +28302,13 @@ function removePenalty$1({
     return { error: MISSING_TOURNAMENT_RECORD };
   if (!penaltyId)
     return { error: MISSING_PENALTY_ID };
-  const participants = tournamentRecord?.participants || [];
+  const participants = tournamentRecord?.participants ?? [];
   const modifiedParticipants = [];
   let penaltyRemoved = false;
   let removedPenalty;
   participants.forEach((participant) => {
     let participantModified = false;
-    participant.penalties = (participant.penalties || []).filter((penalty) => {
+    participant.penalties = (participant.penalties ?? []).filter((penalty) => {
       if (penalty.penaltyId === penaltyId) {
         participantModified = true;
         if (!penaltyRemoved) {
@@ -28320,10 +28337,10 @@ function getTournamentPenalties({
 }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  const participants = tournamentRecord?.participants || [];
+  const participants = tournamentRecord?.participants ?? [];
   const allPenalties = participants.reduce((penalties, participant) => {
     const { participantId } = participant;
-    (participant.penalties || []).forEach((penalty) => {
+    (participant.penalties ?? []).forEach((penalty) => {
       const { penaltyId } = penalty || {};
       if (penalties[penaltyId]) {
         penalties[penaltyId].participants.push(participantId);
@@ -28349,7 +28366,7 @@ function modifyPenalty$1({
     return { error: INVALID_VALUES, modifications };
   if (!penaltyId)
     return { error: MISSING_PENALTY_ID };
-  const participants = tournamentRecord?.participants || [];
+  const participants = tournamentRecord?.participants ?? [];
   const validAttributes = Object.keys(penaltyTemplate()).filter(
     (attribute) => attribute !== "penaltyId"
   );
@@ -28362,7 +28379,7 @@ function modifyPenalty$1({
   const modifiedParticipants = [];
   participants.forEach((participant) => {
     let participantModified = false;
-    participant.penalties = (participant.penalties || []).map((penalty) => {
+    participant.penalties = (participant.penalties ?? []).map((penalty) => {
       if (penalty.penaltyId === penaltyId) {
         participantModified = true;
         validModificationAttributes.forEach(
@@ -28399,7 +28416,7 @@ function addPenalty(params) {
     if (tournamentParticipantIds.length) {
       const result = addPenalty$1({
         ...params,
-        penaltyId: params.penaltyId || penaltyId,
+        penaltyId: params.penaltyId ?? penaltyId,
         tournamentRecord,
         participantIds: tournamentParticipantIds
       });
@@ -28438,7 +28455,7 @@ function getCompetitionPenalties({
   const allPenalties = [];
   for (const tournamentRecord of Object.values(tournamentRecords)) {
     const { penalties } = getTournamentPenalties({ tournamentRecord });
-    allPenalties.push(...penalties || []);
+    allPenalties.push(...penalties ?? []);
   }
   return { penalties: allPenalties };
 }
@@ -33748,18 +33765,18 @@ function clearScheduledMatchUps$1({
   const inContextMatchUps = allTournamentMatchUps({
     matchUpFilters: { scheduledDates },
     tournamentRecord
-  }).matchUps || [];
+  }).matchUps ?? [];
   const relevantMatchUpIds = inContextMatchUps.filter(
     (matchUp) => matchUp.matchUpStatus && !ignoreMatchUpStatuses.includes(matchUp.matchUpStatus) && hasSchedule({ schedule: matchUp.schedule, scheduleAttributes }) && (!venueIds?.length || venueIds.includes(matchUp.schedule.venueId))
   ).map(getMatchUpId);
   const matchUps = allTournamentMatchUps({
     tournamentRecord,
     inContext: false
-  }).matchUps || [];
+  }).matchUps ?? [];
   let clearedScheduleCount = 0;
   for (const matchUp of matchUps) {
     if (relevantMatchUpIds.includes(matchUp.matchUpId)) {
-      matchUp.timeItems = (matchUp.timeItems || []).filter(
+      matchUp.timeItems = (matchUp.timeItems ?? []).filter(
         (timeItem) => timeItem?.itemType && ![
           ALLOCATE_COURTS,
           ASSIGN_COURT,
@@ -36712,12 +36729,12 @@ function matchUpActions$1({
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
   if (!drawId) {
-    const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps || [];
+    const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps ?? [];
     drawId = matchUps.reduce((drawId2, candidate) => {
       return candidate.matchUpId === matchUpId ? candidate.drawId : drawId2;
     }, void 0);
-    const events = tournamentRecord.events || [];
-    const drawDefinitions = events.map((event2) => event2.drawDefinitions || []).flat();
+    const events = tournamentRecord.events ?? [];
+    const drawDefinitions = events.map((event2) => event2.drawDefinitions ?? []).flat();
     drawDefinition = drawDefinitions.reduce(
       (drawDefinition2, candidate) => {
         return candidate.drawId === drawId ? candidate : drawDefinition2;
@@ -36731,7 +36748,7 @@ function matchUpActions$1({
     drawDefinition,
     event
   });
-  policyDefinitions = policyDefinitions || attachedPolicy;
+  policyDefinitions = policyDefinitions ?? attachedPolicy;
   if (drawDefinition) {
     return matchUpActions$2({
       tournamentParticipants: tournamentRecord.participants,
@@ -37107,7 +37124,7 @@ function deleteVenue$1({
   const matchUpsToUnschedule = allTournamentMatchUps({
     tournamentRecord,
     contextFilters
-  }).matchUps || [];
+  }).matchUps ?? [];
   if (!matchUpsToUnschedule.length || force) {
     for (const matchUp of matchUpsToUnschedule) {
       const result = removeCourtAssignment({
@@ -37122,7 +37139,7 @@ function deleteVenue$1({
     return deletionMessage({ matchUpsCount: matchUpsToUnschedule.length });
   }
   let deleted;
-  tournamentRecord.venues = (tournamentRecord.venues || []).filter(
+  tournamentRecord.venues = (tournamentRecord.venues ?? []).filter(
     (venue) => {
       if (venue?.venueId !== venueId)
         return true;
@@ -37334,7 +37351,7 @@ function deleteCourt$1({
     courtId
   });
   if (!matchUps?.length || force) {
-    for (const matchUp of matchUps || []) {
+    for (const matchUp of matchUps ?? []) {
       const result2 = removeCourtAssignment({
         matchUpId: matchUp.matchUpId,
         drawId: matchUp.drawId,
@@ -37345,7 +37362,7 @@ function deleteCourt$1({
         return result2;
     }
     if (venue) {
-      venue.courts = (venue.courts || []).filter((courtRecord) => {
+      venue.courts = (venue.courts ?? []).filter((courtRecord) => {
         return courtRecord.courtId !== courtId;
       });
       if (!disableNotice)
@@ -38608,7 +38625,7 @@ function treeMatchUps({
     uuids
   }));
   roundNumber++;
-  roundLimit = roundLimit || qualifyingRoundNumber;
+  roundLimit = roundLimit ?? qualifyingRoundNumber;
   while (roundNodes.length > 1) {
     if (qualifyingPositions && roundNodes.length === qualifyingPositions) {
       roundLimit = roundNumber - 1;
@@ -38636,7 +38653,7 @@ function treeMatchUps({
     roundLimit = roundNumber - 1;
   } else {
     matchUps = matchUps.filter(
-      (matchUp) => roundLimit && (matchUp.roundNumber || 0) <= roundLimit
+      (matchUp) => roundLimit && (matchUp.roundNumber ?? 0) <= roundLimit
     );
   }
   return { drawSize, matchUps, roundsCount, roundLimit };
@@ -38769,7 +38786,6 @@ function generateQualifyingStructures({
       roundTarget,
       linkType
     });
-    targetRoundQualifiersCount = 0;
     roundTarget += 1;
   }
   return {
@@ -38784,6 +38800,7 @@ function generateQualifyingStructures({
 
 function getStructureRoundProfile({
   drawDefinition,
+  matchUpsMap,
   structureId
 }) {
   const result = findStructure({
@@ -38791,9 +38808,12 @@ function getStructureRoundProfile({
     structureId
   });
   if (result.error)
-    return result;
-  const { matchUps } = getAllStructureMatchUps({ structure: result.structure });
-  return getRoundMatchUps$1({ matchUps });
+    return decorateResult({ result });
+  const { matchUps } = getAllStructureMatchUps({
+    structure: result.structure,
+    matchUpsMap
+  });
+  return { ...getRoundMatchUps$1({ matchUps }), matchUps, matchUpsMap };
 }
 
 function getFinishingPositionSourceRoundsMap({
@@ -38844,16 +38864,18 @@ function roundValueRanges(values) {
 
 function getPositionsPlayedOff({
   drawDefinition,
-  structureIds
+  structureIds,
+  matchUpsMap
 }) {
   if (structureIds && !Array.isArray(structureIds))
     return { error: INVALID_VALUES, context: { structureIds } };
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
-  structureIds = structureIds || (drawDefinition.structures || []).filter((structure) => structure.stage !== QUALIFYING).map(({ structureId }) => structureId);
+  structureIds = structureIds ?? (drawDefinition.structures ?? []).filter((structure) => structure.stage !== QUALIFYING).map(({ structureId }) => structureId);
   const allFinishingPositionRanges = structureIds.map((structureId) => {
     const { roundProfile } = getStructureRoundProfile({
       drawDefinition,
+      matchUpsMap,
       structureId
     });
     const values = roundProfile && Object.values(roundProfile);
@@ -38948,18 +38970,19 @@ function getPlayoffRoundsRanges({ playoffSourceRounds, roundProfile }) {
 function getAvailablePlayoffProfiles$1({ drawDefinition, structureId }) {
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
-  const { positionsNotPlayedOff, positionsPlayedOff } = getPositionsPlayedOff({
+  const { matchUps, matchUpsMap } = allDrawMatchUps$1({
+    inContext: true,
     drawDefinition
   });
+  const { positionsNotPlayedOff, positionsPlayedOff } = getPositionsPlayedOff({
+    drawDefinition,
+    matchUpsMap
+  });
   const { structures } = getDrawStructures({ drawDefinition });
   const filteredStructures = structures.filter(
     (structure) => !structureId && structure.stage !== VOLUNTARY_CONSOLATION || structure.structureId === structureId
   );
   const available = {};
-  const matchUps = allDrawMatchUps$1({
-    inContext: true,
-    drawDefinition
-  }).matchUps;
   for (const structure of filteredStructures) {
     const structureId2 = structure?.structureId;
     const result = availablePlayoffProfiles({
@@ -43378,11 +43401,147 @@ function generateVoluntaryConsolation$1(params) {
   return { links, structures, ...SUCCESS };
 }
 
+function getStructureGroups({
+  drawDefinition
+}) {
+  const structures = drawDefinition.structures || [];
+  const links = drawDefinition.links || [];
+  const structureProfiles = /* @__PURE__ */ new Map();
+  const initStructureProfile = (structureId) => {
+    const profile = structureProfiles.get(structureId) || structureProfiles.set(structureId, {
+      drawSources: [],
+      drawTargets: [],
+      progeny: [],
+      sources: [],
+      targets: []
+    }) && structureProfiles.get(structureId);
+    if (profile && !profile?.stage) {
+      const structure = structures.find(
+        (structure2) => structure2.structureId === structureId
+      );
+      profile.stage = structure?.stage;
+    }
+    return profile;
+  };
+  const sourceStructureIds = {};
+  const hasDrawFeedProfile = {};
+  let linkedStructureIds = links.map((link) => {
+    const sourceId = link.source.structureId;
+    const targetId = link.target.structureId;
+    const sourceProfile = initStructureProfile(sourceId);
+    const targetProfile = initStructureProfile(targetId);
+    if ([BOTTOM_UP, TOP_DOWN, RANDOM, WATERFALL].includes(link.target.feedProfile)) {
+      sourceProfile?.targets.push(targetId);
+      targetProfile?.sources.push(sourceId);
+    } else if (link.target.feedProfile === DRAW) {
+      targetProfile?.drawSources.push(sourceId);
+      sourceProfile?.drawTargets.push(targetId);
+    }
+    hasDrawFeedProfile[targetId] = hasDrawFeedProfile[targetId] || link.target.feedProfile === DRAW;
+    sourceStructureIds[targetId] = unique([
+      ...sourceStructureIds[targetId] || [],
+      sourceId
+    ]).filter(Boolean);
+    return [link.source.structureId, link.target.structureId];
+  });
+  for (const structureId of structureProfiles.keys()) {
+    const profile = structureProfiles.get(structureId);
+    if (profile) {
+      const sourceIds = profile.targets ?? [];
+      while (sourceIds.length) {
+        const sourceId = sourceIds.pop();
+        const sourceProfile = sourceId && structureProfiles[sourceId];
+        if (sourceProfile?.targets?.length) {
+          sourceIds.push(...sourceProfile.targets);
+        } else if (sourceProfile) {
+          profile.rootStage = sourceProfile.stage;
+        }
+      }
+      if (!profile.rootStage)
+        profile.rootStage = profile.stage;
+      if (!profile.targets?.length) {
+        const targetIds = profile.sources ?? [];
+        while (targetIds.length) {
+          const targetId = targetIds.pop();
+          const targetProfile = targetId && structureProfiles[targetId];
+          if (targetProfile?.sources?.length) {
+            for (const id of targetProfile.sources) {
+              if (!profile.progeny?.includes(id))
+                profile.progeny?.push(id);
+            }
+            targetIds.push(...targetProfile.sources);
+          }
+        }
+      }
+    }
+  }
+  let maxQualifyingDepth = 0;
+  for (const structureId of structureProfiles.keys()) {
+    const profile = structureProfiles.get(structureId);
+    if (profile && profile.rootStage === QUALIFYING) {
+      const drawTargets = [profile.drawTargets?.[0]];
+      let distanceFromMain = 0;
+      while (drawTargets.length) {
+        distanceFromMain += 1;
+        const drawTarget = drawTargets.pop();
+        const targetProfile = drawTarget ? structureProfiles.get(drawTarget) : void 0;
+        if (targetProfile?.drawTargets?.length) {
+          drawTargets.push(targetProfile.drawTargets[0]);
+        }
+      }
+      profile.distanceFromMain = distanceFromMain;
+      if (distanceFromMain > maxQualifyingDepth)
+        maxQualifyingDepth = distanceFromMain;
+    }
+  }
+  const iterations = linkedStructureIds.length;
+  generateRange(0, Math.ceil(iterations / 2)).forEach(() => {
+    linkedStructureIds = generateRange(0, iterations).map((index) => {
+      const structureIds = linkedStructureIds[index];
+      const mergedWithOverlappingIds = linkedStructureIds.reduce((biggest, ids) => {
+        const hasOverlap = overlap(structureIds, ids);
+        return hasOverlap ? biggest.concat(...ids) : biggest;
+      }, []) || [];
+      return unique(structureIds.concat(...mergedWithOverlappingIds));
+    });
+  });
+  const groupedStructureIds = linkedStructureIds[0];
+  const identityLink = (a, b) => intersection(a, b).length === a.length;
+  const allLinkStructuresLinked = linkedStructureIds.slice(1).reduce((allLinkStructuresLinked2, ids) => {
+    return allLinkStructuresLinked2 && identityLink(ids, groupedStructureIds);
+  }, true);
+  const structureGroups = [groupedStructureIds].filter(Boolean);
+  const linkCheck = [groupedStructureIds].filter(Boolean);
+  structures.forEach((structure) => {
+    const { structureId, stage } = structure;
+    const existingGroup = structureGroups.find((group) => {
+      return group.includes(structureId);
+    });
+    if (!existingGroup) {
+      structureGroups.push([structureId]);
+      if (stage !== VOLUNTARY_CONSOLATION)
+        linkCheck.push([structureId]);
+    }
+  });
+  const allStructuresLinked = allLinkStructuresLinked && linkCheck.length === 1;
+  if (!links?.length && structures.length === 1) {
+    initStructureProfile(structures[0].structureId);
+  }
+  return {
+    structureProfiles: Object.fromEntries(structureProfiles),
+    allStructuresLinked,
+    maxQualifyingDepth,
+    sourceStructureIds,
+    hasDrawFeedProfile,
+    structureGroups
+  };
+}
+
 function generateQualifyingStructure$1(params) {
   if (!params.drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
   const stack = "generateQualifyingStructure";
-  let drawSize = params.drawSize || coerceEven(params.participantsCount);
+  let drawSize = params.drawSize ?? coerceEven(params.participantsCount);
   const {
     qualifyingRoundNumber,
     qualifyingPositions,
@@ -43390,6 +43549,7 @@ function generateQualifyingStructure$1(params) {
     structureOptions,
     appliedPolicies,
     drawDefinition,
+    matchUpFormat,
     structureName,
     structureId,
     roundTarget,
@@ -43401,68 +43561,29 @@ function generateQualifyingStructure$1(params) {
   let roundLimit, roundsCount, structure, matchUps;
   let qualifiersCount = 0;
   let finishingPositions;
-  let stageSequence = 1;
+  const stageSequence = 1;
   if (!isConvertableInteger(drawSize)) {
     return decorateResult({ result: { error: MISSING_DRAW_SIZE }, stack });
   }
-  const result = findStructure({
-    structureId: targetStructureId,
-    drawDefinition
-  });
-  if (result.error) {
+  const { structureProfiles } = getStructureGroups({ drawDefinition });
+  const structureProfile = structureProfiles[targetStructureId];
+  if (!structureProfile) {
     return decorateResult({
+      result: { error: STRUCTURE_NOT_FOUND },
       context: { targetStructureId },
-      result,
       stack
     });
   }
-  if (!result.structure)
-    return { error: STRUCTURE_NOT_FOUND };
-  const targetStructure = result.structure;
-  const matchUpType = targetStructure.matchUpType;
-  if (targetStructure.stage === QUALIFYING) {
-    if (targetStructure.stageSequence && targetStructure.stageSequence > 1) {
-      stageSequence = targetStructure.stageSequence - 1;
-    } else {
-      let nextStructureId = targetStructureId;
-      let nextStageSequence = 2;
-      let chainModified;
-      while (!chainModified && nextStructureId) {
-        targetStructure.stageSequence = nextStageSequence;
-        const targetTargetStructureId = drawDefinition.links?.find(
-          (link2) => link2.source.structureId === nextStructureId
-        )?.target?.structureId;
-        nextStructureId = targetTargetStructureId;
-        nextStageSequence += 1;
-        if (!targetTargetStructureId) {
-          chainModified = true;
-        } else {
-          const result2 = findStructure({
-            structureId: targetTargetStructureId,
-            drawDefinition
-          });
-          if (!result2.structure)
-            return { error: STRUCTURE_NOT_FOUND };
-          if (result2.error) {
-            return decorateResult({
-              context: { targetTargetStructureId },
-              result: result2,
-              stack
-            });
-          }
-          if (result2.structure.stage !== QUALIFYING)
-            chainModified = true;
-        }
-      }
-    }
-  }
+  const matchUpType = drawDefinition.matchUpType;
   const roundTargetName = roundTarget ? `${roundTarget}-` : "";
-  const stageSequenceName = `${stageSequence}`;
-  const qualifyingStructureName = structureName || (roundTargetName || stageSequenceName ? `${constantToString(QUALIFYING)} ${roundTargetName}${stageSequenceName}` : constantToString(QUALIFYING));
+  const isPreQualifying = structureProfile.stage === QUALIFYING;
+  const preQualifyingNaming = appliedPolicies?.[POLICY_TYPE_ROUND_NAMING]?.namingConventions?.pre ?? POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING]?.namingConventions?.pre;
+  const pre = isPreQualifying && preQualifyingNaming ? `${preQualifyingNaming}-` : "";
+  const qualifyingStructureName = structureName ?? (roundTargetName ? `${pre}${constantToString(QUALIFYING)} ${roundTargetName}` : `${pre}${constantToString(QUALIFYING)}`);
   if (drawType === ROUND_ROBIN) {
     const { maxRoundNumber, structures, groupCount } = generateRoundRobin({
-      structureName: structureName || qualifyingStructureName,
-      structureId: structureId || uuids?.pop(),
+      structureName: structureName ?? qualifyingStructureName,
+      structureId: structureId ?? uuids?.pop(),
       stage: QUALIFYING,
       structureOptions,
       appliedPolicies,
@@ -43491,10 +43612,11 @@ function generateQualifyingStructure$1(params) {
     if (!roundLimit)
       roundLimit = roundsCount;
     structure = structureTemplate({
-      structureName: structureName || qualifyingStructureName,
-      structureId: structureId || uuids?.pop(),
+      structureName: structureName ?? qualifyingStructureName,
+      structureId: structureId ?? uuids?.pop(),
       qualifyingRoundNumber: roundLimit,
       stage: QUALIFYING,
+      matchUpFormat,
       stageSequence,
       matchUpType,
       roundLimit,
@@ -43512,13 +43634,13 @@ function generateQualifyingStructure$1(params) {
     )?.length;
   }
   const linkType = drawType === ROUND_ROBIN ? LinkTypeEnum.Position : LinkTypeEnum.Winner;
-  const { link } = generateQualifyingLink({
+  const link = structure && roundLimit && generateQualifyingLink({
     sourceStructureId: structure.structureId,
     sourceRoundNumber: roundLimit,
     targetStructureId,
     finishingPositions,
     linkType
-  });
+  })?.link;
   return {
     qualifyingDrawPositionsCount: drawSize,
     qualifiersCount,
@@ -43558,6 +43680,15 @@ function attachQualifyingStructure$1({
     drawDefinition.links = [];
   drawDefinition.structures.push(structure);
   drawDefinition.links.push(link);
+  const { maxQualifyingDepth, structureProfiles } = getStructureGroups({
+    drawDefinition
+  });
+  for (const structure2 of drawDefinition.structures) {
+    const profile = structureProfiles[structure2.structureId];
+    if (profile.distanceFromMain) {
+      structure2.stageSequence = maxQualifyingDepth + 1 - profile.distanceFromMain;
+    }
+  }
   const matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
   addMatchUpsNotice({
     drawDefinition,
@@ -43781,6 +43912,10 @@ function getAdvancingParticipantId(matchUp) {
 }
 
 function addQualifyingStructure$1(params) {
+  if (!params.drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  if (!params.targetStructureId)
+    return { error: MISSING_STRUCTURE_ID };
   const result = generateQualifyingStructure$1(params);
   if (result.error)
     return result;
@@ -44078,21 +44213,26 @@ function removeStructure({
     ({ stage, stageSequence }) => stage === MAIN && stageSequence === 1
   );
   const isMainStageSequence1 = structureId === mainStageSequence1.structureId;
-  const hasQualifying = structures.find(({ stage }) => stage === QUALIFYING);
-  if (isMainStageSequence1 && !hasQualifying) {
+  const qualifyingStructureIds = structures.filter(({ stage }) => stage === QUALIFYING).map(extractAttributes("structureId"));
+  if (isMainStageSequence1 && !qualifyingStructureIds.length) {
     return { error: CANNOT_REMOVE_MAIN_STRUCTURE };
   }
+  const structureIds = structures.map(extractAttributes("structureId"));
   const removedMatchUpIds = [];
   const idsToRemove = [structureId];
   const getTargetedStructureIds = (structureId2) => drawDefinition.links?.map(
     (link) => link.source.structureId === structureId2 && link.target.structureId !== mainStageSequence1.structureId && link.target.structureId
   ).filter(Boolean);
-  const structureIds = structures.map(({ structureId: structureId2 }) => structureId2);
-  const targetedStructureIdsMap = Object.assign(
-    {},
-    ...structureIds.map((structureId2) => ({
-      [structureId2]: getTargetedStructureIds(structureId2)
-    }))
+  const getQualifyingSourceStructureIds = (structureId2) => drawDefinition.links?.map(
+    (link) => qualifyingStructureIds.includes(link.source.structureId) && link.target.structureId === structureId2 && link.source.structureId
+  ).filter(Boolean);
+  const isQualifyingStructure = qualifyingStructureIds.includes(structureId);
+  const relatedStructureIdsMap = /* @__PURE__ */ new Map();
+  structureIds.forEach(
+    (id) => relatedStructureIdsMap.set(
+      id,
+      isQualifyingStructure ? getQualifyingSourceStructureIds(id) : getTargetedStructureIds(id)
+    )
   );
   while (idsToRemove.length) {
     const idBeingRemoved = idsToRemove.pop();
@@ -44115,7 +44255,8 @@ function removeStructure({
         }
       );
     }
-    const targetedStructureIds = idBeingRemoved && targetedStructureIdsMap[idBeingRemoved].filter(
+    const targetedStructureIds = idBeingRemoved && // targetedStructureIdsMap[idBeingRemoved].filter(
+    relatedStructureIdsMap.get(idBeingRemoved)?.filter(
       (id) => (
         // IMPORTANT: only delete MAIN stageSequence: 1 if specified to protect against DOUBLE_ELIMINATION scenario
         id !== mainStageSequence1.structureId || structureId === mainStageSequence1.structureId
@@ -44912,7 +45053,7 @@ function modifyEntriesStatus({
     }).assignedParticipantIds ?? [];
     assignedParticipantIds.push(...participantIds2);
   });
-  const tournamentParticipants = tournamentRecord?.participants || [];
+  const tournamentParticipants = tournamentRecord?.participants ?? [];
   const validEntryStatusForAllParticipantIds = participantIds.every(
     (participantId) => {
       const participantType = findParticipant({
@@ -44960,7 +45101,7 @@ function modifyEntriesStatus({
   const autoPosition = ({ flight: flight2, drawDefinition: drawDefinition2 }) => {
     if (event) {
       event.entries = refreshEntryPositions({
-        entries: event.entries || []
+        entries: event.entries ?? []
       });
     }
     if (flight2) {
@@ -44991,7 +45132,7 @@ function modifyEntriesStatus({
     }
     return { ...SUCCESS };
   };
-  const entryPositionsExist = event?.entries?.find(({ entryPosition }) => entryPosition) || flight?.drawEntries?.find(({ entryPosition }) => entryPosition) || drawDefinition?.entries?.find(({ entryPosition }) => entryPosition);
+  const entryPositionsExist = event?.entries?.find(({ entryPosition }) => entryPosition) ?? (flight?.drawEntries?.find(({ entryPosition }) => entryPosition) || drawDefinition?.entries?.find(({ entryPosition }) => entryPosition));
   if (autoEntryPositions && !entryPositionsExist)
     autoPosition({ flight, drawDefinition });
   if (flight || drawDefinition) {
@@ -44999,7 +45140,7 @@ function modifyEntriesStatus({
     if (result.error)
       return decorateResult({ result, stack });
   }
-  const generatedDrawIds = event?.drawDefinitions?.map(({ drawId: drawId2 }) => drawId2) || [];
+  const generatedDrawIds = event?.drawDefinitions?.map(({ drawId: drawId2 }) => drawId2) ?? [];
   const flightsNoDraw = flightProfile?.flights?.filter(
     (flight2) => !generatedDrawIds.includes(flight2.drawId)
   ) || [];
@@ -45008,7 +45149,7 @@ function modifyEntriesStatus({
     if (result?.error)
       return decorateResult({ result, stack });
   }
-  const singleDraw = flightProfile?.flights?.length === 1 && (event?.drawDefinitions?.length || 0) <= flightProfile?.flights?.length;
+  const singleDraw = flightProfile?.flights?.length === 1 && (event?.drawDefinitions?.length ?? 0) <= flightProfile?.flights?.length;
   if (!flight && !drawDefinition && entryStatus && DRAW_SPECIFIC_STATUSES.includes(entryStatus)) {
     return { error: ENTRY_STATUS_NOT_ALLOWED_FOR_EVENT };
   }
@@ -45046,7 +45187,7 @@ function modifyEntriesStatus({
   }
   if (autoEntryPositions)
     autoPosition({ flight, drawDefinition });
-  for (const drawDefinition2 of event?.drawDefinitions || []) {
+  for (const drawDefinition2 of event?.drawDefinitions ?? []) {
     if (modifiedDrawIds.length && !modifiedDrawIds.includes(drawDefinition2.drawId))
       continue;
     modifyDrawNotice({
@@ -45412,7 +45553,7 @@ function removeEventEntries({
   if (!participantIds?.length)
     return { ...SUCCESS, participantIdsRemoved: [] };
   const participantIdsRemoved = [];
-  event.entries = (event.entries || []).filter((entry) => {
+  event.entries = (event.entries ?? []).filter((entry) => {
     const keepEntry = !participantIds.includes(entry?.participantId);
     if (!keepEntry)
       participantIdsRemoved.push(entry.participantId);
@@ -45430,7 +45571,7 @@ function removeEventEntries({
     );
   });
   event.drawDefinitions?.forEach((drawDefinition) => {
-    drawDefinition.entries = (drawDefinition.entries || []).filter(
+    drawDefinition.entries = (drawDefinition.entries ?? []).filter(
       (entry) => !participantIds.includes(entry.participantId)
     );
   });
@@ -45611,7 +45752,7 @@ function removeIndividualParticipantIds({
     });
   if (!groupingParticipantId || !individualParticipantIds)
     return decorateResult({ result: { error: MISSING_VALUE }, stack });
-  const tournamentParticipants = tournamentRecord.participants || [];
+  const tournamentParticipants = tournamentRecord.participants ?? [];
   const groupingParticipant = tournamentParticipants.find(
     (participant) => {
       return participant.participantId === groupingParticipantId;
@@ -45638,8 +45779,8 @@ function removeIndividualParticipantIds({
   if (error)
     return decorateResult({ result, stack });
   if (addIndividualParticipantsToEvents) {
-    for (const event of tournamentRecord.events || []) {
-      const enteredIds = (event.entries || []).map(({ participantId }) => participantId).filter(Boolean);
+    for (const event of tournamentRecord.events ?? []) {
+      const enteredIds = (event.entries ?? []).map(({ participantId }) => participantId).filter(Boolean);
       if (enteredIds.includes(groupingParticipantId)) {
         const participantIdsToEnter = removed?.filter(
           (participantId) => !enteredIds.includes(participantId)
@@ -45690,7 +45831,7 @@ function removeParticipantIdsFromGroupingParticipant({
   const groupingParticipantEventIds = inContextGroupingParticipant?.events?.map(
     ({ eventId }) => eventId
   );
-  const updatedIndividualParticipantIds = (groupingParticipant.individualParticipantIds || []).filter((participantId) => {
+  const updatedIndividualParticipantIds = (groupingParticipant.individualParticipantIds ?? []).filter((participantId) => {
     const targetParticipant = individualParticipantIds?.includes(participantId);
     const scoredParticipantGroupingMatchUps = targetParticipant && participants?.find((participant) => participant.participantId === participantId)?.matchUps.filter(
       ({ eventId }) => groupingParticipantEventIds.includes(eventId)
@@ -45703,25 +45844,25 @@ function removeParticipantIdsFromGroupingParticipant({
     }
     if (removeParticipant) {
       removed.push(participantId);
-      for (const event of tournamentRecord.events || []) {
-        for (const drawDefinition of event.drawDefinitions || []) {
+      for (const event of tournamentRecord.events ?? []) {
+        for (const drawDefinition of event.drawDefinitions ?? []) {
           const { extension } = findExtension$2({
             element: drawDefinition,
             name: LINEUPS
           });
-          let lineUp = extension?.value[groupingParticipant.participantId];
+          const lineUp = extension?.value[groupingParticipant.participantId];
           if (extension && lineUp) {
-            lineUp = lineUp.filter(
+            extension.value[groupingParticipant.participantId] = lineUp.filter(
               (assignment) => assignment.participantId !== participantId
             );
             addExtension$1({ element: drawDefinition, extension });
             addDrawNotice({ drawDefinition });
           }
-          const matchUps = allDrawMatchUps$1({ drawDefinition, inContext: false }).matchUps || [];
+          const matchUps = allDrawMatchUps$1({ drawDefinition, inContext: false }).matchUps ?? [];
           for (const matchUp of matchUps) {
-            const sides = matchUp.sides || [];
+            const sides = matchUp.sides ?? [];
             for (const side of sides) {
-              const lineUp2 = side.lineUp || [];
+              const lineUp2 = side.lineUp ?? [];
               const containsParticipant = lineUp2.find(
                 (assignment) => assignment.participantId === participantId
               );
@@ -45765,7 +45906,7 @@ function removeParticipantIdsFromAllTeams({
 }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  const tournamentParticipants = tournamentRecord.participants || [];
+  const tournamentParticipants = tournamentRecord.participants ?? [];
   const { participants, mappedMatchUps } = getParticipants$1({
     withMatchUps: true,
     tournamentRecord,
@@ -45811,7 +45952,7 @@ function deleteParticipants(params) {
     const matchUps = allTournamentMatchUps({
       matchUpFilters: { drawIds: teamDrawIds, matchUpTypes: [DOUBLES$1] },
       tournamentRecord
-    }).matchUps || [];
+    }).matchUps ?? [];
     const placedPairParticipantIds2 = matchUps.map(({ sides }) => sides?.map(({ participantId }) => participantId)).flat().filter(Boolean);
     return intersection(placedPairParticipantIds2, participantIds);
   };
@@ -45934,7 +46075,7 @@ function destroyGroupEntry({
   if (!event.eventType || ![TypeEnum.Doubles, TypeEnum.Team].includes(event.eventType)) {
     return decorateResult({ result: { error: INVALID_EVENT_TYPE }, stack });
   }
-  const tournamentParticipants = tournamentRecord.participants || [];
+  const tournamentParticipants = tournamentRecord.participants ?? [];
   const participant = tournamentParticipants.find(
     (participant2) => participant2.participantId === participantId
   );
@@ -45946,7 +46087,7 @@ function destroyGroupEntry({
   ) || participant.participantType === TEAM$1 && event.eventType !== TEAM$1 || participant.participantType === PAIR && event.eventType !== DOUBLES) {
     return { error: INVALID_PARTICIPANT_TYPE };
   }
-  const eventEntries = event.entries || [];
+  const eventEntries = event.entries ?? [];
   const entry = eventEntries.find(
     (entry2) => entry2.participantId === participantId
   );
@@ -46052,7 +46193,7 @@ function removeDrawPositionAssignment(params) {
       tournamentRecord: tournamentRecord2,
       participantId
     });
-    const { participantType, individualParticipantIds } = participant || {};
+    const { participantType, individualParticipantIds } = participant ?? {};
     if (destroyPair && participantType === PAIR) {
       const result2 = destroyPairEntry({
         tournamentRecord: tournamentRecord2,
@@ -49587,12 +49728,12 @@ function getParticipantEventDetails({
   if (!participantId)
     return { error: MISSING_PARTICIPANT_ID };
   const relevantParticipantIds = [participantId].concat(
-    (tournamentRecord.participants || []).filter(
+    (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(
+  const relevantEvents = (tournamentRecord.events ?? []).filter((event) => {
+    const enteredParticipantIds = (event?.entries ?? []).map(
       (entry) => entry.participantId
     );
     return overlap(enteredParticipantIds, relevantParticipantIds);
@@ -49633,7 +49774,7 @@ function getRelevantParticipantIdsMap({
 }) {
   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 allParticipants = tournamentRecords ? Object.values(tournamentRecords).map((tournamentRecord2) => tournamentRecord2?.participants || []).flat() : tournamentRecord?.participants ?? [];
   const relevantParticipantIdsMap = Object.assign(
     {},
     ...allParticipants.map(
@@ -49901,7 +50042,7 @@ function annotateParticipant(params) {
   );
   const scheduledMatchUps = participantScheduledMatchUps({
     matchUps: allParticipantMatchUps
-  })?.scheduledMatchUps || [];
+  })?.scheduledMatchUps ?? [];
   const { scheduledMinutesDifference } = scheduleAnalysis || {};
   const dates = Object.keys(scheduledMatchUps);
   dates.forEach((date) => {
@@ -50706,7 +50847,7 @@ function getParticipantMembership({
     participantFilters: { participantTypes: [TEAM, PAIR, GROUP] },
     tournamentRecord
   });
-  const memberOf = (participants || []).filter((participant) => {
+  const memberOf = (participants ?? []).filter((participant) => {
     return participant.individualParticipantIds?.includes(participantId);
   });
   return memberOf.reduce((groupingTypesMap, participant) => {
@@ -50732,7 +50873,7 @@ function getParticipantSchedules({
   const matchUps = allTournamentMatchUps({
     tournamentRecord,
     contextFilters
-  }).matchUps || [];
+  }).matchUps ?? [];
   const matchUpsMap = Object.assign(
     {},
     ...matchUps.map((matchUp) => ({ [matchUp.matchUpId]: matchUp }))
@@ -50743,7 +50884,7 @@ function getParticipantSchedules({
   const sourceMatchUpIds = getMatchUpDependencies({
     tournamentRecord,
     matchUps
-  }).sourceMatchUpIds || [];
+  }).sourceMatchUpIds ?? [];
   const participantAggregator = {};
   for (const matchUp of scheduledMatchUps) {
     const { sides } = matchUp;
@@ -50753,13 +50894,11 @@ function getParticipantSchedules({
         return [side.participant].concat(
           ...side.participant.individualParticipants || []
         );
-      } else {
-        if (sourceMatchUpIds[matchUp.matchUpId] && !relevantSourceMatchUps) {
-          relevantSourceMatchUps = (sourceMatchUpIds[matchUp.matchUpId] || []).map((matchUpId) => matchUpsMap[matchUpId]).filter(({ winningSide, bye }) => !winningSide && !bye);
-        }
+      } else if (sourceMatchUpIds[matchUp.matchUpId] && !relevantSourceMatchUps) {
+        relevantSourceMatchUps = (sourceMatchUpIds[matchUp.matchUpId] || []).map((matchUpId) => matchUpsMap[matchUpId]).filter(({ winningSide, bye }) => !winningSide && !bye);
       }
       return void 0;
-    }).filter(Boolean).flat() || [];
+    }).filter(Boolean).flat() ?? [];
     for (const participant of participants) {
       const { participantId } = participant;
       if (!participantAggregator[participantId]) {
@@ -50890,7 +51029,7 @@ function addPersons({
   const tournamentParticipants = getParticipants$1({
     participantFilters: { participantTypes: [INDIVIDUAL] },
     tournamentRecord
-  })?.participants || [];
+  })?.participants ?? [];
   if (participantRole === COMPETITOR) {
     persons.filter(({ pairedPersons }) => pairedPersons).forEach(({ personId, pairedPersons }) => {
       Array.isArray(pairedPersons) && pairedPersons.forEach((pairing) => {
@@ -50965,7 +51104,7 @@ function addIndividualParticipantIds({
     });
   if (!groupingParticipantId || !individualParticipantIds)
     return decorateResult({ result: { error: MISSING_VALUE }, stack });
-  const tournamentParticipants = tournamentRecord.participants || [];
+  const tournamentParticipants = tournamentRecord.participants ?? [];
   const groupingParticipant = tournamentParticipants.find(
     (participant) => participant.participantId === groupingParticipantId
   );
@@ -51126,7 +51265,7 @@ function generateTeamsFromParticipantAttribute({
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
   const teams = {};
-  const individualParticipants = (tournamentRecord.participants || []).filter(
+  const individualParticipants = (tournamentRecord.participants ?? []).filter(
     ({ participantType, participantRole }) => participantType === INDIVIDUAL && participantRole === COMPETITOR
   );
   let teamIndex = 0;
@@ -51139,15 +51278,15 @@ function generateTeamsFromParticipantAttribute({
     if (attributeValue) {
       if (!Object.keys(teams).includes(attributeValue)) {
         teams[attributeValue] = {
-          participantName: teamNames?.[teamIndex] || attributeValue,
-          participantId: uuids?.pop() || UUID(),
+          participantName: teamNames?.[teamIndex] ?? attributeValue,
+          participantId: uuids?.pop() ?? UUID(),
           individualParticipantIds: [],
           participantRole: COMPETITOR,
           participantType: TEAM
         };
         const extension = {
-          name: GROUPING_ATTRIBUTE,
-          value: personAttribute || participantAttribute
+          value: personAttribute ?? participantAttribute,
+          name: GROUPING_ATTRIBUTE
         };
         addExtension$1({ element: teams[attributeValue], extension });
         teamIndex += 1;
@@ -51158,7 +51297,7 @@ function generateTeamsFromParticipantAttribute({
     }
   }
   const groupingAttributes = Object.keys(teams);
-  const overlappingTeamParticipantIds = (tournamentRecord.participants || []).map((participant) => {
+  const overlappingTeamParticipantIds = (tournamentRecord.participants ?? []).map((participant) => {
     if (participant.participantType !== TEAM)
       return void 0;
     if (participant.participantRole !== COMPETITOR)
@@ -51303,16 +51442,16 @@ function scaledTeamAssignment({
       error: MISSING_VALUE
     };
   }
-  let participantIdsToAssign = individualParticipantIds || scaledParticipants.map(({ participantId }) => participantId);
+  let participantIdsToAssign = individualParticipantIds ?? scaledParticipants.map(({ participantId }) => participantId);
   if (reverseAssignmentOrder) {
     teamParticipantIds?.reverse();
     initialTeamIndex += 1;
   }
   if (initialTeamIndex > (teamParticipantIds?.length || 0) - 1)
     initialTeamIndex = 0;
-  const orderedTeamParticipantIds = teamParticipantIds?.slice(initialTeamIndex).concat(...teamParticipantIds.slice(0, initialTeamIndex)) || [];
+  const orderedTeamParticipantIds = teamParticipantIds?.slice(initialTeamIndex).concat(...teamParticipantIds.slice(0, initialTeamIndex)) ?? [];
   const relevantTeams = [];
-  for (const participant of tournamentRecord.participants || []) {
+  for (const participant of tournamentRecord.participants ?? []) {
     const { participantId, participantType } = participant;
     if (!orderedTeamParticipantIds.includes(participantId))
       continue;
@@ -51322,7 +51461,7 @@ function scaledTeamAssignment({
   }
   if (teamsCount && relevantTeams.length < teamsCount) {
     const addCount = teamsCount - (relevantTeams?.length || 0);
-    const nameBase = teamNameBase || "Team";
+    const nameBase = teamNameBase ?? "Team";
     const teamParticipants = generateRange(0, addCount).map((i) => ({
       participantName: `${nameBase} ${i + 1}`,
       participantType: TEAM_PARTICIPANT,
@@ -51361,7 +51500,7 @@ function scaledTeamAssignment({
     return { error: NO_CANDIDATES, info: "Nothing to be done" };
   }
   if (!scaledParticipants.length) {
-    for (const participant of tournamentRecord.participants || []) {
+    for (const participant of tournamentRecord.participants ?? []) {
       const { participantId, participantType } = participant;
       if (!participantIdsToAssign.includes(participantId))
         continue;
@@ -51399,10 +51538,10 @@ function scaledTeamAssignment({
     relevantTeams.reverse();
   }
   const relevantTeamParticipantIds = relevantTeams.map(getParticipantId);
-  for (const event2 of tournamentRecord.events || []) {
+  for (const event2 of tournamentRecord.events ?? []) {
     if (event2.eventType !== TEAM_EVENT)
       continue;
-    const relevantTeamEntries = (event2.entries || []).filter(
+    const relevantTeamEntries = (event2.entries ?? []).filter(
       (entry) => relevantTeamParticipantIds.includes(entry.participantId)
     );
     for (const relevantEntry of relevantTeamEntries) {
@@ -51411,11 +51550,11 @@ function scaledTeamAssignment({
         (teamParticipant) => teamParticipant.participantId === relevantTeamParticipantId
       );
       const individualParticipantIds2 = relevantTeam?.individualParticipantIds;
-      event2.entries = (event2.entries || []).filter(
+      event2.entries = (event2.entries ?? []).filter(
         (entry) => !individualParticipantIds2.includes(entry.participantId)
       );
-      (event2.drawDefinitions || []).forEach((drawDefinition) => {
-        drawDefinition.entries = (drawDefinition.entries || []).filter(
+      (event2.drawDefinitions ?? []).forEach((drawDefinition) => {
+        drawDefinition.entries = (drawDefinition.entries ?? []).filter(
           (entry) => !individualParticipantIds2.includes(entry.participantId)
         );
       });
@@ -52329,59 +52468,6 @@ function unPublishEvent({
   return { eventId: event.eventId, ...SUCCESS };
 }
 
-function getStructureGroups({ drawDefinition }) {
-  const links = drawDefinition.links || [];
-  const sourceStructureIds = {};
-  const hasDrawFeedProfile = {};
-  let linkedStructureIds = links.map((link) => {
-    const sourceId = link.source.structureId;
-    const targetId = link.target.structureId;
-    hasDrawFeedProfile[targetId] = hasDrawFeedProfile[targetId] || link.target.feedProfile === DRAW;
-    sourceStructureIds[targetId] = unique([
-      ...sourceStructureIds[targetId] || [],
-      sourceId
-    ]).filter(Boolean);
-    return [link.source.structureId, link.target.structureId];
-  });
-  const iterations = linkedStructureIds.length;
-  generateRange(0, Math.ceil(iterations / 2)).forEach(() => {
-    linkedStructureIds = generateRange(0, iterations).map((index) => {
-      const structureIds = linkedStructureIds[index];
-      const mergedWithOverlappingIds = linkedStructureIds.reduce((biggest, ids) => {
-        const hasOverlap = overlap(structureIds, ids);
-        return hasOverlap ? biggest.concat(...ids) : biggest;
-      }, []) || [];
-      return unique(structureIds.concat(...mergedWithOverlappingIds));
-    });
-  });
-  const groupedStructureIds = linkedStructureIds[0];
-  const identityLink = (a, b) => intersection(a, b).length === a.length;
-  const allLinkStructuresLinked = linkedStructureIds.slice(1).reduce((allLinkStructuresLinked2, ids) => {
-    return allLinkStructuresLinked2 && identityLink(ids, groupedStructureIds);
-  }, true);
-  const structureGroups = [groupedStructureIds].filter(Boolean);
-  const linkCheck = [groupedStructureIds].filter(Boolean);
-  const structures = drawDefinition.structures || [];
-  structures.forEach((structure) => {
-    const { structureId, stage } = structure;
-    const existingGroup = structureGroups.find((group) => {
-      return group.includes(structureId);
-    });
-    if (!existingGroup) {
-      structureGroups.push([structureId]);
-      if (stage !== VOLUNTARY_CONSOLATION)
-        linkCheck.push(structureId);
-    }
-  });
-  const allStructuresLinked = allLinkStructuresLinked && linkCheck.length === 1;
-  return {
-    allStructuresLinked,
-    sourceStructureIds,
-    hasDrawFeedProfile,
-    structureGroups
-  };
-}
-
 function getDrawData(params) {
   const {
     tournamentParticipants = [],
@@ -52440,12 +52526,18 @@ function getDrawData(params) {
       }
       return structure;
     }).sort((a, b) => structureSort(a, b, sortConfig)).map((structure) => {
-      const { structureId } = structure;
+      if (!structure)
+        return;
+      const structureId = structure?.structureId;
       let seedAssignments = [];
-      if ([MAIN, CONSOLATION, PLAY_OFF].includes(structure.stage)) {
+      if (structure.stage && [
+        StageTypeEnum.Main,
+        StageTypeEnum.Consolation,
+        StageTypeEnum.PlayOff
+      ].includes(structure.stage)) {
         seedAssignments = mainStageSeedAssignments;
       }
-      if (structure.stage === QUALIFYING) {
+      if (structure?.stage === QUALIFYING) {
         seedAssignments = qualificationStageSeedAssignments;
       }
       const { matchUps, roundMatchUps, roundProfile } = getAllStructureMatchUps({
@@ -52476,7 +52568,7 @@ function getDrawData(params) {
           participantResult: extension.value
         };
       }).filter((f) => f?.participantResult);
-      const structureInfo = (({
+      const structureInfo = structure ? (({
         stageSequence,
         structureName,
         structureType,
@@ -52488,7 +52580,7 @@ function getDrawData(params) {
         structureType,
         matchUpFormat,
         stage
-      }))(structure);
+      }))(structure) : {};
       structureInfo.sourceStructureIds = sourceStructureIds[structureId];
       structureInfo.hasDrawFeedProfile = hasDrawFeedProfile[structureId];
       structureInfo.positionAssignments = positionAssignments;
@@ -52682,7 +52774,7 @@ function publishEvent(params) {
     policyDefinitions = appliedPolicies;
   }
   const itemType = `${PUBLISH}.${STATUS$1}`;
-  const eventDrawIds = event.drawDefinitions?.map(({ drawId }) => drawId) || [];
+  const eventDrawIds = event.drawDefinitions?.map(({ drawId }) => drawId) ?? [];
   const { timeItem } = getEventTimeItem({
     itemType,
     event
@@ -52692,7 +52784,7 @@ function publishEvent(params) {
   } else if (!drawIds && (drawIdsToAdd?.length || drawIdsToRemove?.length)) {
     drawIds = timeItem?.itemValue?.PUBLIC?.drawIds || [];
   }
-  drawIds = (drawIds || []).filter(
+  drawIds = (drawIds ?? []).filter(
     (drawId) => !drawIdsToRemove?.length || !drawIdsToRemove.includes(drawId)
   );
   if (drawIdsToAdd?.length) {
@@ -52705,7 +52797,7 @@ function publishEvent(params) {
   if (!structureIds && (structureIdsToAdd?.length || structureIdsToRemove?.length)) {
     structureIds = timeItem?.itemValue?.PUBLIC?.structureIds || [];
   }
-  structureIds = (structureIds || []).filter(
+  structureIds = (structureIds ?? []).filter(
     (structureId) => !structureIdsToRemove?.length || !structureIdsToRemove.includes(structureId)
   );
   if (structureIdsToAdd?.length) {
@@ -52714,7 +52806,7 @@ function publishEvent(params) {
   if (!stages && (stagesToAdd?.length || stagesToRemove?.length)) {
     stages = timeItem?.itemValue?.PUBLIC?.stages || [];
   }
-  stages = (stages || []).filter(
+  stages = (stages ?? []).filter(
     (stage) => !stagesToRemove?.length || !stagesToRemove.includes(stage)
   );
   if (stagesToAdd?.length) {
@@ -54033,14 +54125,14 @@ function analyzeDraws({ tournamentRecord }) {
       const positionsAssigned = positionAssignments?.filter(
         ({ participantId }) => participantId
       );
-      positionsAssignedCount += positionsAssigned?.length || 0;
-      const unassignedPositionsCount = (positionAssignments?.length || 0) - (positionsAssigned?.length || 0);
+      positionsAssignedCount += positionsAssigned?.length ?? 0;
+      const unassignedPositionsCount = (positionAssignments?.length ?? 0) - (positionsAssigned?.length ?? 0);
       const { roundMatchUps, roundProfile, roundNumbers, maxMatchUpsCount } = getRoundMatchUps$1({ matchUps: inContextStructureMatchUps });
       const activeRounds = roundProfile && Object.keys(roundProfile).filter((roundNumber) => !roundProfile[roundNumber].inactiveRound).map((roundNumber) => parseInt(roundNumber));
       const inactiveRounds = roundProfile && Object.keys(roundProfile).filter((roundNumber) => roundProfile[roundNumber].inactiveRound).map((roundNumber) => parseInt(roundNumber));
       const inactiveStructure = roundProfile && Object.values(roundProfile).every((profile) => profile.inactiveRound);
       return {
-        positionsAssignedCount: positionsAssigned?.length || 0,
+        positionsAssignedCount: positionsAssigned?.length ?? 0,
         maxWinningSideFirstRoundPosition,
         unassignedPositionsCount,
         inactiveStructure,
@@ -54166,7 +54258,7 @@ function updateCourtAvailability({ tournamentRecord }) {
       courts.push(...venue.courts);
   }
   for (const court of courts) {
-    const { startTime, endTime } = (court.dateAvailability || []).reduce(
+    const { startTime, endTime } = (court.dateAvailability ?? []).reduce(
       (extents, availability) => {
         const startMinutes = timeStringMinutes(extents.startTime);
         const endMinutes = timeStringMinutes(extents.endTime);
@@ -54182,7 +54274,7 @@ function updateCourtAvailability({ tournamentRecord }) {
       const existing = court.dateAvailability?.find(
         (availability) => availability.date === date
       );
-      return existing || { date, startTime, endTime };
+      return existing ?? { date, startTime, endTime };
     });
     const defaultAvailability = court.dateAvailability?.find(
       (availability) => !availability.date
@@ -54399,7 +54491,7 @@ function clearMatchUpSchedule({
   }).matchUps?.[0];
   if (!matchUp)
     return { error: MATCHUP_NOT_FOUND };
-  const newTimeItems = (matchUp.timeItems || []).filter(
+  const newTimeItems = (matchUp.timeItems ?? []).filter(
     (timeItem) => timeItem?.itemType && !scheduleAttributes.includes(timeItem?.itemType)
   );
   matchUp.timeItems = newTimeItems;
@@ -54605,7 +54697,7 @@ function getEntryStatusReports({
       drawDefinitionsCount += 1;
       const stageFilter = ({ stage, stageSequence }) => stage === MAIN && stageSequence === 1 || stage === QUALIFYING;
       const structures = params.structures ?? [];
-      const assignedParticipantIds = structures.filter(stageFilter).flatMap(({ positionAssignments }) => positionAssignments).map(({ participantId }) => participantId).filter(Boolean);
+      const assignedParticipantIds = structures.filter(stageFilter).flatMap(({ positionAssignments }) => positionAssignments).filter(Boolean).map(({ participantId }) => participantId);
       const entryFilter = ({ participantId }) => assignedParticipantIds.includes(participantId);
       const createEntryProfile = (params2) => {
         const { participantId, entryStatus, entryStage } = params2;
@@ -55303,7 +55395,7 @@ function assignMatchUpSideParticipant({
     matchUp.sides = [1, 2].map((currentSideNumber) => {
       const existingSide = matchUp.sides?.find(
         (side) => side.sideNumber === currentSideNumber
-      ) || { sideNumber: currentSideNumber };
+      ) ?? { sideNumber: currentSideNumber };
       return sideNumber === currentSideNumber ? { ...existingSide, participantId } : existingSide;
     });
     if (noSideNumberProvided) {
@@ -55703,7 +55795,7 @@ function removeTieMatchUpParticipantId(params) {
     const tieMatchUpSide = inContextTieMatchUp?.sides?.find(
       (side2) => side2.sideNumber === dualMatchUpSide?.sideNumber
     );
-    const { participantId: pairParticipantId } = tieMatchUpSide || {};
+    const { participantId: pairParticipantId } = tieMatchUpSide ?? {};
     const pairParticipant = pairParticipantId && getParticipants$1({
       participantFilters: { participantIds: [pairParticipantId] },
       tournamentRecord,
@@ -55739,26 +55831,24 @@ function removeTieMatchUpParticipantId(params) {
           if (result.error)
             console.log("cleanup", { result });
         }
-      } else {
-        if (individualParticipantIds.length === 1) {
-          const { participant: existingParticipant } = getPairedParticipant({
-            participantIds: individualParticipantIds,
+      } else if (individualParticipantIds.length === 1) {
+        const { participant: existingParticipant } = getPairedParticipant({
+          participantIds: individualParticipantIds,
+          tournamentRecord
+        });
+        if (!existingParticipant) {
+          const newPairParticipant = {
+            participantRole: COMPETITOR,
+            individualParticipantIds,
+            participantType: PAIR
+          };
+          const result = addParticipant$1({
+            participant: newPairParticipant,
+            pairOverride: true,
             tournamentRecord
           });
-          if (!existingParticipant) {
-            const newPairParticipant = {
-              participantRole: COMPETITOR,
-              individualParticipantIds,
-              participantType: PAIR
-            };
-            const result = addParticipant$1({
-              participant: newPairParticipant,
-              pairOverride: true,
-              tournamentRecord
-            });
-            if (result.error)
-              return decorateResult({ result, stack });
-          }
+          if (result.error)
+            return decorateResult({ result, stack });
         }
       }
     } else {
@@ -55820,9 +55910,9 @@ function getPositionAssignments({
     structure
   });
   return {
-    error,
-    positionAssignments: assignments || [],
-    structureId: structure?.structureId
+    positionAssignments: assignments ?? [],
+    structureId: structure?.structureId,
+    error
   };
 }
 
@@ -56168,7 +56258,7 @@ function addEventEntryPairs({
     return { error: MISSING_EVENT };
   if (event.eventType !== DOUBLES$1)
     return { error: INVALID_EVENT_TYPE };
-  const tournamentParticipants = tournamentRecord.participants || [];
+  const tournamentParticipants = tournamentRecord.participants ?? [];
   const individualParticipantIds = tournamentParticipants.filter((participant) => participant.participantType === INDIVIDUAL).map((participant) => participant.participantId);
   const invalidParticipantIds = individualParticipantIds.filter(
     (participantId) => !individualParticipantIds.includes(participantId)
@@ -56183,7 +56273,7 @@ function addEventEntryPairs({
   const existingParticipantIdPairs = tournamentParticipants.filter((participant) => participant.participantType === PAIR).map((participant) => participant.individualParticipantIds);
   const provisionalParticipants = participantIdPairs.map(
     (individualParticipantIds2) => ({
-      participantId: uuids?.pop() || UUID(),
+      participantId: uuids?.pop() ?? UUID(),
       participantRole: COMPETITOR,
       individualParticipantIds: individualParticipantIds2,
       participantType: PAIR
@@ -56325,7 +56415,7 @@ function assignSeedPositions(params) {
   const { seedAssignments, seedLimit } = result;
   const mergeObject = Object.assign(
     {},
-    ...(seedAssignments || []).filter((assignment) => assignment.seedNumber).map((assignment) => ({ [assignment.seedNumber]: assignment }))
+    ...(seedAssignments ?? []).filter((assignment) => assignment.seedNumber).map((assignment) => ({ [assignment.seedNumber]: assignment }))
   );
   assignments.forEach((newAssignment) => {
     const { seedNumber } = newAssignment;
@@ -56606,17 +56696,14 @@ function addEvent({
       context
     };
   }
-  const eventRecord = Object.assign(
-    {},
-    {
-      drawDefinitions: [],
-      eventType: TypeEnum.Singles,
-      entries: [],
-      startDate,
-      endDate
-    },
-    event
-  );
+  const eventRecord = {
+    drawDefinitions: [],
+    eventType: TypeEnum.Singles,
+    entries: [],
+    startDate,
+    endDate,
+    ...event
+  };
   if (event.eventType === TypeEnum.Team) {
     if (event.tieFormat) {
       const result = validateTieFormat({ tieFormat: event.tieFormat });
@@ -56646,7 +56733,7 @@ function addEvent({
     if (!suppressNotifications) {
       const { topics } = getTopics();
       if (topics.includes(ADD_MATCHUPS)) {
-        const matchUps = allEventMatchUps({ event }).matchUps || [];
+        const matchUps = allEventMatchUps({ event }).matchUps ?? [];
         addMatchUpsNotice({
           tournamentId: tournamentRecord?.tournamentId,
           eventId: event.eventId,
@@ -57263,11 +57350,9 @@ function setMatchUpFormat({
           drawDefinition: drawDefinition2
         });
       }
-    } else {
-      if (event2.matchUpFormat !== matchUpFormat) {
-        event2.matchUpFormat = matchUpFormat;
-        modificationsCount += 1;
-      }
+    } else if (event2.matchUpFormat !== matchUpFormat) {
+      event2.matchUpFormat = matchUpFormat;
+      modificationsCount += 1;
     }
   }
   if (!modificationsCount)
@@ -57488,7 +57573,7 @@ function getScaledEntries({
 }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  entries = entries || event?.entries || [];
+  entries = entries ?? event?.entries ?? [];
   const stageEntries = entries.filter(
     (entry) => (!stage || !entry.entryStage || entry.entryStage === stage) && (!stageSequence || !entry.entryStageSequence || entry.entryStageSequence === stageSequence) && STRUCTURE_SELECTED_STATUSES.includes(entry.entryStatus)
   );
@@ -57807,7 +57892,7 @@ function generateFlightProfile(params) {
   } = params;
   if (!event)
     return { error: MISSING_EVENT };
-  const eventEntries = event.entries || [];
+  const eventEntries = event.entries ?? [];
   const { flightProfile } = getFlightProfile({ event });
   if (flightProfile && attachFlightProfile$1 && !deleteExisting) {
     return { error: EXISTING_PROFILE };
@@ -57856,7 +57941,7 @@ function generateFlightProfile(params) {
     const flightNumber = index + 1;
     return {
       flightNumber,
-      drawId: uuids?.pop() || UUID(),
+      drawId: uuids?.pop() ?? UUID(),
       drawEntries: getDrawEntries(splitEntries[index]),
       drawName: drawNames?.length && drawNames[index] || `${drawNameRoot} ${flightNumber}`
     };
@@ -58152,7 +58237,7 @@ function pruneDrawDefinition({
     const structureData = drawAnalysis.structuresData.find(
       ({ structureId }) => mainStructure.structureId === structureId
     );
-    const matchUps = mainStructure.matchUps || [];
+    const matchUps = mainStructure.matchUps ?? [];
     relevantMatchUps = matchUps.sort((a, b) => a.roundPosition - b.roundPosition).filter(
       ({ roundNumber }) => !structureData.inactiveRounds.includes(roundNumber)
     );
@@ -58167,7 +58252,7 @@ function pruneDrawDefinition({
         (matchUpId) => !matchPlayMatchUpIds.includes(matchUpId)
       );
       deletedMatchUpIds.push(...matchUpIdsToDelete);
-      const existingDrawPositionPairings = matchPlayMatchUps.flatMap((matchUp) => matchUp.drawPositions || []).filter(Boolean);
+      const existingDrawPositionPairings = matchPlayMatchUps.flatMap((matchUp) => matchUp.drawPositions ?? []).filter(Boolean);
       const existingDrawPositions = existingDrawPositionPairings.flat();
       const drawPositionsMap = Object.assign(
         {},
@@ -58224,7 +58309,7 @@ function modifyEventEntries({
     return { error: MISSING_TOURNAMENT_RECORD };
   if (!event)
     return { error: MISSING_EVENT };
-  const tournamentParticipants = tournamentRecord.participants || [];
+  const tournamentParticipants = tournamentRecord.participants ?? [];
   const individualParticipantIds = tournamentParticipants.filter((participant) => participant.participantType === INDIVIDUAL).map((participant) => participant.participantId);
   const incomingIndividualParticipantIds = unpairedParticipantIds.concat(...participantIdPairs).flat(Infinity);
   const invalidParticipantIds = incomingIndividualParticipantIds.filter(
@@ -58274,7 +58359,7 @@ function modifyEventEntries({
       entryStage
     })
   );
-  event.entries = (event.entries || []).filter(
+  event.entries = (event.entries ?? []).filter(
     (entry) => entry.entryStage === entryStage
   );
   event.entries = event.entries.concat(
@@ -58305,7 +58390,7 @@ function addFlight({
   if (!drawName)
     return decorateResult({ result: { error: MISSING_VALUE }, stack });
   if (drawEntries?.length) {
-    const enteredParticipantIds = (event.entries || []).map(
+    const enteredParticipantIds = (event.entries ?? []).map(
       extractAttributes("participantId")
     );
     const flightParticipantIds = drawEntries.map(
@@ -59429,7 +59514,10 @@ function isValidForQualifying({ structureId, drawDefinition }) {
   if (result.error)
     return result;
   const targetFeedProfiles = result.links.target.flatMap((t) => t.target.feedProfile).filter(Boolean);
-  const valid = !intersection([BOTTOM_UP, TOP_DOWN, RANDOM], targetFeedProfiles).length;
+  const valid = !intersection(
+    [BOTTOM_UP, TOP_DOWN, RANDOM, WATERFALL],
+    targetFeedProfiles
+  ).length;
   return { ...SUCCESS, valid };
 }
 
@@ -59786,7 +59874,7 @@ function getPredictiveAccuracy(params) {
   const ascending = scaleProfile?.ascending ?? params.ascending ?? false;
   const valueAccessor = scaleProfile?.accessor ?? params.valueAccessor;
   const ratingsRangeDifference = Array.isArray(scaleProfile?.range) ? Math.abs(scaleProfile.range[0] - scaleProfile.range[1]) : 0;
-  const zoneMargin = isConvertableInteger(zonePct) && ratingsRangeDifference ? (zonePct || 0 / 100) * ratingsRangeDifference : params.zoneMargin || ratingsRangeDifference;
+  const zoneMargin = isConvertableInteger(zonePct) && ratingsRangeDifference ? (zonePct ?? 0 / 100) * ratingsRangeDifference : params.zoneMargin ?? ratingsRangeDifference;
   const contextProfile = { withScaleValues: true, withCompetitiveness: true };
   const contextFilters = {
     matchUpTypes: matchUpType ? [matchUpType] : [SINGLES$1, DOUBLES$1]
@@ -59824,7 +59912,7 @@ function getPredictiveAccuracy(params) {
   }
   const relevantMatchUps = matchUps.filter(
     ({ winningSide, score, sides, matchUpStatus }) => ![RETIRED$1, DEFAULTED, WALKOVER$2, DEAD_RUBBER, ABANDONED$1].includes(
-      matchUpStatus || ""
+      matchUpStatus ?? ""
     ) && scoreHasValue({ score }) && sides?.length === 2 && winningSide
   );
   const accuracy = getGroupingAccuracy({
@@ -61101,7 +61189,7 @@ function getTournamentPoints({
     policyTypes: [POLICY_TYPE_RANKING_POINTS],
     tournamentRecord
   });
-  const pointsPolicy = policyDefinitions?.[POLICY_TYPE_RANKING_POINTS] || attachedPolicies?.[POLICY_TYPE_RANKING_POINTS];
+  const pointsPolicy = policyDefinitions?.[POLICY_TYPE_RANKING_POINTS] ?? attachedPolicies?.[POLICY_TYPE_RANKING_POINTS];
   if (!pointsPolicy)
     return { error: MISSING_POLICY_DEFINITION };
   const awardProfiles = pointsPolicy.awardProfiles;
@@ -61116,7 +61204,7 @@ function getTournamentPoints({
   const personPoints = {};
   const teamPoints = {};
   const pairPoints = {};
-  for (const participant of participantsWithOutcomes || []) {
+  for (const participant of participantsWithOutcomes ?? []) {
     const { participantType, participantId, person, draws } = participant;
     for (const draw of draws) {
       const { drawId, structureParticipation, eventId } = draw;
@@ -61424,8 +61512,9 @@ function generateDynamicRatings({
     matchUpFilters: { matchUpIds, matchUpStatuses: completedMatchUpStatuses },
     tournamentRecord,
     inContext: true
-  }).matchUps || [];
-  for (const matchUp of matchUps.sort(matchUpSort)) {
+  }).matchUps ?? [];
+  matchUps.sort(matchUpSort);
+  for (const matchUp of matchUps) {
     const { endDate, matchUpFormat, score, sides, winningSide } = matchUp;
     const matchUpType = matchUp.matchUpType;
     const scaleAttributes = {
@@ -61441,12 +61530,12 @@ function generateDynamicRatings({
     };
     const sideParticipantIds = Object.assign(
       {},
-      ...(sides || []).map((side) => {
+      ...(sides ?? []).map((side) => {
         const { sideNumber, participant } = side;
         return sideNumber && {
           [sideNumber]: [
             participant?.participantId,
-            ...participant?.individualParticipantIds || []
+            ...participant?.individualParticipantIds ?? []
           ].filter(Boolean).flat()
         };
       })
@@ -62983,11 +63072,10 @@ function generateParticipants(params) {
     }
     if (ratingType && ratingsParameters$1[ratingType]) {
       const { ratingMax, ratingMin, ratingAttributes } = category;
-      const ratingParameters = Object.assign(
-        {},
-        ratingsParameters$1[ratingType],
-        ratingAttributes || {}
-      );
+      const ratingParameters = {
+        ...ratingsParameters$1[ratingType],
+        ...ratingAttributes || {}
+      };
       const {
         attributes = {},
         decimalsCount,
@@ -63326,15 +63414,13 @@ function getParticipantsCount({
       } else if (drawSize + alternatesCount && drawSize + alternatesCount > largestDoublesDraw) {
         largestDoublesDraw = drawSize + alternatesCount;
       }
-    } else {
-      if (requiresUniqueParticipants) {
-        const additionalParticipantsCount = drawSize + alternatesCount;
-        if (gender)
-          gendersCount[gender] += additionalParticipantsCount;
-        uniqueParticipantsCount += additionalParticipantsCount;
-      } else if (drawSize && drawSize > largestSinglesDraw) {
-        largestSinglesDraw = drawSize + alternatesCount;
-      }
+    } else if (requiresUniqueParticipants) {
+      const additionalParticipantsCount = drawSize + alternatesCount;
+      if (gender)
+        gendersCount[gender] += additionalParticipantsCount;
+      uniqueParticipantsCount += additionalParticipantsCount;
+    } else if (drawSize && drawSize > largestSinglesDraw) {
+      largestSinglesDraw = drawSize + alternatesCount;
     }
   };
   eventProfiles?.forEach((eventProfile) => {
@@ -64270,7 +64356,7 @@ function generateVenues({
   for (const [index, venueProfile] of venueProfiles.entries()) {
     const {
       venueAbbreviation,
-      venueId = uuids?.pop() || UUID(),
+      venueId = uuids?.pop() ?? UUID(),
       dateAvailability,
       startTime = "07:00",
       endTime = "19:00",
@@ -64533,7 +64619,7 @@ function generateScheduledRounds({
   const containedStructures = getContainedStructures({
     tournamentRecord
   }).containedStructures;
-  const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps || [];
+  const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps ?? [];
   const { tournamentId } = tournamentRecord;
   const scheduledRounds = [];
   for (const dateProfile of schedulingProfile) {
@@ -64554,7 +64640,7 @@ function generateScheduledRounds({
           if (roundNumber && !winnerFinishingPositionRange) {
             structureId = Object.keys(containedStructures).find(
               (containingStructureId) => containedStructures[containingStructureId].includes(structureId)
-            ) || structureId;
+            ) ?? structureId;
           }
           const roundToSchedule = {
             tournamentId,