tods-competition-factory 2.2.18 → 2.2.20

package/dist/tods-competition-factory.development.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.18';
+    return '2.2.20';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -585,6 +585,10 @@ const MISSING_STRUCTURE = {
     message: 'Missing structure',
     code: 'ERR_MISSING_STRUCTURE',
 };
+const MISSING_MAIN_STRUCTURE = {
+    message: 'Missing MAIN structure',
+    code: 'ERR_MISSING_MAIN_STRUCTURE',
+};
 const UNLINKED_STRUCTURES = {
     message: 'drawDefinition contains unlinked structures',
     code: 'ERR_MISSING_STRUCTURE_LINKS',
@@ -873,6 +877,10 @@ const MISSING_PARTICIPANT_ID = {
     message: 'Missing participantId',
     code: 'ERR_MISSING_PARTICIPANT_ID',
 };
+const MISSING_QUALIFIED_PARTICIPANTS = {
+    message: 'Missing qualified participants',
+    code: 'ERR_MISSING_QUALIFIED_PARTICIPANTS',
+};
 const PARTICIPANT_NOT_FOUND = {
     message: 'Participant Not Found',
     code: 'ERR_NOT_FOUND_PARTICIPANT',
@@ -1241,6 +1249,7 @@ const errorConditionConstants = {
     MISSING_DRAW_SIZE,
     MISSING_ENTRIES,
     MISSING_EVENT,
+    MISSING_QUALIFIED_PARTICIPANTS,
     MISSING_MATCHUP_FORMAT,
     MISSING_MATCHUP_ID,
     MISSING_MATCHUP_IDS,
@@ -1271,6 +1280,7 @@ const errorConditionConstants = {
     MISSING_STAGE,
     MISSING_STRUCTURE_ID,
     MISSING_STRUCTURE,
+    MISSING_MAIN_STRUCTURE,
     MISSING_STRUCTURES,
     MISSING_TARGET_LINK,
     MISSING_TIE_FORMAT,
@@ -10261,14 +10271,14 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
         tournamentRecord?.processCodes;
     const competitiveProfile = contextProfile?.withCompetitiveness && getMatchUpCompetitiveProfile({ ...contextContent, matchUp });
     const finishingPositionRange = matchUp.finishingPositionRange ?? additionalContext.finishingPositionRange;
+    const roundOfPlay = stage !== QUALIFYING && isConvertableInteger(initialRoundOfPlay) && initialRoundOfPlay + (roundNumber || 0);
     const onlyDefined = (obj) => definedAttributes(obj, undefined, true);
     const matchUpWithContext = {
         ...onlyDefined(context),
         ...onlyDefined({
-            matchUpFormat: matchUp.matchUpType === TEAM$1 ? undefined : matchUpFormat,
-            tieFormat: matchUp.matchUpType !== TEAM$1 ? undefined : tieFormat,
+            matchUpFormat: matchUpType === TEAM$1 ? undefined : matchUpFormat,
+            tieFormat: matchUpType !== TEAM$1 ? undefined : tieFormat,
             gender: collectionDefinition?.gender ?? event?.gender,
-            roundOfPlay: stage !== QUALIFYING && isConvertableInteger(initialRoundOfPlay) && initialRoundOfPlay + (roundNumber || 0),
             endDate: matchUp.endDate ?? endDate,
             discipline: event?.discipline,
             category: matchUpCategory,
@@ -10289,6 +10299,7 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
             roundOffset,
             structureId,
             roundNumber,
+            roundOfPlay,
             feedRound,
             roundName,
             drawName,
@@ -17435,22 +17446,6 @@ function swapAdHocRounds(params) {
     return { ...SUCCESS };
 }
 
-function qualifierDrawPositionAssignment$1({ qualifyingParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }) {
-    return positionParticipantAction({
-        positionActionName: 'qualifierDrawPositionAssignment',
-        participantId: qualifyingParticipantId,
-        isQualifierPosition: true,
-        tournamentRecord,
-        drawDefinition,
-        drawPosition,
-        structureId,
-    });
-}
-
-function qualifierDrawPositionAssignment(params) {
-    return qualifierDrawPositionAssignment$1(params);
-}
-
 function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, event, }) {
     return positionParticipantAction({
         positionActionName: 'alternateDrawPositionAssignment',
@@ -17464,60 +17459,6 @@ function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRec
     });
 }
 
-function modifySeedAssignment({ validation = true, tournamentRecord, drawDefinition, participantId, structureId, seedValue, event, }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId)
-        return { error: MISSING_STRUCTURE_ID };
-    const participant = (tournamentRecord?.participants ?? []).find((participant) => participant.participantId === participantId);
-    if (tournamentRecord && !participant)
-        return { error: INVALID_PARTICIPANT_ID };
-    const { structure } = findStructure({ drawDefinition, structureId });
-    if (!structure)
-        return { error: STRUCTURE_NOT_FOUND };
-    const validValue = !validation ||
-        isNumeric(seedValue) ||
-        seedValue === undefined ||
-        seedValue === '' ||
-        (typeof seedValue === 'string' && seedValue.split('-').every((v) => isNumeric(v) && ensureInt(v) > 0));
-    if (!validValue)
-        return { error: INVALID_VALUES };
-    const { seedAssignments } = getStructureSeedAssignments({
-        drawDefinition,
-        structure,
-    });
-    const seedNumbers = seedAssignments?.map((assignment) => assignment.seedNumber);
-    const existingAssginment = seedAssignments?.find((assignment) => assignment.participantId === participantId);
-    if (existingAssginment) {
-        const newValue = typeof seedValue === 'string'
-            ? (seedValue.includes('-') &&
-                seedValue
-                    .split('-')
-                    .map((v) => parseInt(v))
-                    .join('-')) ||
-                (parseInt(seedValue) > 0 && parseInt(seedValue)) ||
-                ''
-            : (seedValue && seedValue > 0 && seedValue) || '';
-        existingAssginment.seedValue = newValue;
-    }
-    else {
-        const seedNumber = Math.max(0, ...(seedNumbers || [])) + 1;
-        const seedAssignment = { seedNumber, participantId };
-        if (seedValue)
-            seedAssignment.seedValue = seedValue;
-        if (!structure.seedAssignments)
-            structure.seedAssignments = [];
-        structure.seedAssignments.push(seedAssignment);
-    }
-    modifySeedAssignmentsNotice({
-        tournamentId: tournamentRecord?.tournamentId,
-        eventId: event?.eventId,
-        drawDefinition,
-        structure,
-    });
-    return { ...SUCCESS };
-}
-
 function getPlayoffStructures({ drawDefinition, structureId }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -18597,21 +18538,7 @@ function getStructurePositionedSeeds({ provisionalPositioning, drawDefinition, s
 
 function getBlockSortedRandomDrawPositions({ orderedSortedFirstRoundSeededDrawPositions: strictOrder, validSeedBlocks, byesToPlace, }) {
     const drawPositions = [];
-    validSeedBlocks.forEach((seedBlock) => {
-        const leftToPlace = byesToPlace - drawPositions.length;
-        if (leftToPlace > seedBlock.drawPositions.length) {
-            drawPositions.push(...seedBlock.drawPositions);
-        }
-        else {
-            const nestedDrawPositions = nestArray(chunkArray(seedBlock.drawPositions, 2));
-            let drawPosition;
-            let desiredPosition = strictOrder[drawPositions.length];
-            while ((drawPosition = popFromLargerSide(nestedDrawPositions, desiredPosition))) {
-                drawPositions.push(drawPosition);
-                desiredPosition = strictOrder[drawPositions.length];
-            }
-        }
-    });
+    validSeedBlocks.forEach((seedBlock) => processSeedBlock(seedBlock, byesToPlace, drawPositions, strictOrder));
     const blockSortedRandom = drawPositions.map((p) => (Array.isArray(p) ? shuffleArray(p) : p)).flat(Infinity);
     if (isOdd(byesToPlace)) {
         const blockFirstSeedNumbers = validSeedBlocks.map((block) => block.seedNumbers[0]);
@@ -18620,14 +18547,38 @@ function getBlockSortedRandomDrawPositions({ orderedSortedFirstRoundSeededDrawPo
     }
     return blockSortedRandom;
 }
+function processSeedBlock(seedBlock, byesToPlace, drawPositions, strictOrder) {
+    const leftToPlace = byesToPlace - drawPositions.length;
+    if (leftToPlace > seedBlock.drawPositions.length) {
+        drawPositions.push(...seedBlock.drawPositions);
+    }
+    else {
+        const nestedDrawPositions = nestArray(chunkArray(seedBlock.drawPositions, 2));
+        placeDrawPositions(nestedDrawPositions, drawPositions, strictOrder);
+    }
+}
+function placeDrawPositions(nestedDrawPositions, drawPositions, strictOrder) {
+    let drawPosition;
+    let desiredPosition = strictOrder[drawPositions.length];
+    while ((drawPosition = popFromLargerSide(nestedDrawPositions, desiredPosition))) {
+        drawPositions.push(drawPosition);
+        desiredPosition = strictOrder[drawPositions.length];
+    }
+}
 function popFromLargerSide(arr, desiredPosition) {
     if (Array.isArray(arr) && arr.length !== 2)
         return arr.pop();
     if (!Array.isArray(arr[0])) {
-        if (arr.includes(desiredPosition))
-            return arr.indexOf(desiredPosition) ? arr.pop() : arr.shift();
-        return Math.round(Math.random()) ? arr.pop() : arr.shift();
+        return handleNonNestedArray(arr, desiredPosition);
     }
+    return handleNestedArray(arr, desiredPosition);
+}
+function handleNonNestedArray(arr, desiredPosition) {
+    if (arr.includes(desiredPosition))
+        return arr.indexOf(desiredPosition) ? arr.pop() : arr.shift();
+    return Math.round(Math.random()) ? arr.pop() : arr.shift();
+}
+function handleNestedArray(arr, desiredPosition) {
     const side1 = arr[0].flat(Infinity).length;
     const side2 = arr[1].flat(Infinity).length;
     if (side1 === side2) {
@@ -19225,6 +19176,197 @@ function automatedPlayoffPositioning(params) {
     return { ...SUCCESS, structurePositionAssignments, positioningReports };
 }
 
+function modifySeedAssignment({ validation = true, tournamentRecord, drawDefinition, participantId, structureId, seedValue, event, }) {
+    if (!drawDefinition)
+        return { error: MISSING_DRAW_DEFINITION };
+    if (!structureId)
+        return { error: MISSING_STRUCTURE_ID };
+    const participant = (tournamentRecord?.participants ?? []).find((participant) => participant.participantId === participantId);
+    if (tournamentRecord && !participant)
+        return { error: INVALID_PARTICIPANT_ID };
+    const { structure } = findStructure({ drawDefinition, structureId });
+    if (!structure)
+        return { error: STRUCTURE_NOT_FOUND };
+    const validValue = !validation ||
+        isNumeric(seedValue) ||
+        seedValue === undefined ||
+        seedValue === '' ||
+        (typeof seedValue === 'string' && seedValue.split('-').every((v) => isNumeric(v) && ensureInt(v) > 0));
+    if (!validValue)
+        return { error: INVALID_VALUES };
+    const { seedAssignments } = getStructureSeedAssignments({
+        drawDefinition,
+        structure,
+    });
+    const seedNumbers = seedAssignments?.map((assignment) => assignment.seedNumber);
+    const existingAssginment = seedAssignments?.find((assignment) => assignment.participantId === participantId);
+    if (existingAssginment) {
+        const newValue = typeof seedValue === 'string'
+            ? (seedValue.includes('-') &&
+                seedValue
+                    .split('-')
+                    .map((v) => parseInt(v))
+                    .join('-')) ||
+                (parseInt(seedValue) > 0 && parseInt(seedValue)) ||
+                ''
+            : (seedValue && seedValue > 0 && seedValue) || '';
+        existingAssginment.seedValue = newValue;
+    }
+    else {
+        const seedNumber = Math.max(0, ...(seedNumbers || [])) + 1;
+        const seedAssignment = { seedNumber, participantId };
+        if (seedValue)
+            seedAssignment.seedValue = seedValue;
+        if (!structure.seedAssignments)
+            structure.seedAssignments = [];
+        structure.seedAssignments.push(seedAssignment);
+    }
+    modifySeedAssignmentsNotice({
+        tournamentId: tournamentRecord?.tournamentId,
+        eventId: event?.eventId,
+        drawDefinition,
+        structure,
+    });
+    return { ...SUCCESS };
+}
+
+function qualifierDrawPositionAssignment({ qualifyingParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }) {
+    return positionParticipantAction({
+        positionActionName: 'qualifierDrawPositionAssignment',
+        participantId: qualifyingParticipantId,
+        isQualifierPosition: true,
+        tournamentRecord,
+        drawDefinition,
+        drawPosition,
+        structureId,
+    });
+}
+
+function getSourceStructureIdsAndRelevantLinks({ targetRoundNumber, finishingPosition, drawDefinition, structureId, linkType, }) {
+    const { links } = getStructureLinks({
+        drawDefinition,
+        structureId,
+    }) || {};
+    const sourceLinks = (links?.target || [])
+        .filter(({ linkType: structureLinkType }) => structureLinkType === linkType)
+        .filter(({ target }) => !targetRoundNumber || targetRoundNumber === target.roundNumber);
+    const relevantLinks = sourceLinks
+        .map((link) => {
+        const sourceStructureId = link.source.structureId;
+        const { structure: sourceStructure } = findStructure({
+            structureId: sourceStructureId,
+            drawDefinition,
+        });
+        if (finishingPosition && sourceStructure?.finishingPosition !== finishingPosition)
+            return undefined;
+        return link;
+    })
+        .filter(Boolean);
+    const sourceStructureIds = relevantLinks.map(({ source }) => source.structureId);
+    return { sourceStructureIds, relevantLinks };
+}
+
+function qualifierProgression({ targetRoundNumber = 1, tournamentRecord, drawDefinition, event, }) {
+    const paramsCheck = checkRequiredParameters({ drawDefinition, event, tournamentRecord }, [
+        { [DRAW_DEFINITION]: true, [EVENT]: true, [TOURNAMENT_RECORD]: true },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const assignedParticipants = [];
+    const qualifyingParticipantIds = [];
+    const mainStructure = drawDefinition.structures?.find((structure) => structure.stage === MAIN && structure.stageSequence === 1);
+    if (!mainStructure)
+        return decorateResult({ result: { error: MISSING_MAIN_STRUCTURE } });
+    const appliedPolicies = getAppliedPolicies({ tournamentRecord, drawDefinition, structure: mainStructure, event }).appliedPolicies ?? {};
+    const policy = appliedPolicies[POLICY_TYPE_POSITION_ACTIONS];
+    const requireCompletedStructures = policy?.requireCompletedStructures;
+    const { qualifierPositions, positionAssignments } = structureAssignedDrawPositions({ structure: mainStructure });
+    if (!qualifierPositions.length)
+        return decorateResult({ result: { error: NO_DRAW_POSITIONS_AVAILABLE_FOR_QUALIFIERS } });
+    const assignedParticipantIds = positionAssignments.map((assignment) => assignment.participantId).filter(Boolean);
+    const { relevantLinks: eliminationSourceLinks } = getSourceStructureIdsAndRelevantLinks({
+        structureId: mainStructure.structureId,
+        targetRoundNumber,
+        linkType: WINNER,
+        drawDefinition,
+    }) || {};
+    const { relevantLinks: roundRobinSourceLinks } = getSourceStructureIdsAndRelevantLinks({
+        structureId: mainStructure.structureId,
+        targetRoundNumber,
+        linkType: POSITION,
+        drawDefinition,
+    }) || {};
+    for (const sourceLink of eliminationSourceLinks) {
+        const structure = drawDefinition.structures?.find((structure) => structure.structureId === sourceLink.source.structureId);
+        if (structure?.stage !== QUALIFYING)
+            continue;
+        const structureCompleted = isCompletedStructure({ structureId: sourceLink.source.structureId, drawDefinition });
+        if (!requireCompletedStructures || structureCompleted) {
+            const qualifyingRoundNumber = structure.qualifyingRoundNumber;
+            const { matchUps } = getAllStructureMatchUps({
+                matchUpFilters: {
+                    ...(qualifyingRoundNumber && { roundNumbers: [qualifyingRoundNumber] }),
+                    hasWinningSide: true,
+                },
+                afterRecoveryTimes: false,
+                inContext: true,
+                structure,
+            });
+            for (const matchUp of matchUps) {
+                const relevantSide = matchUp.matchUpStatus === BYE && matchUp.sides?.find(({ participantId }) => participantId);
+                const winningSide = matchUp.sides.find((side) => side?.sideNumber === matchUp.winningSide);
+                if (winningSide || relevantSide) {
+                    const { participantId } = winningSide || relevantSide || {};
+                    if (participantId && !assignedParticipantIds.includes(participantId)) {
+                        qualifyingParticipantIds.push(participantId);
+                    }
+                }
+            }
+        }
+    }
+    for (const sourceLink of roundRobinSourceLinks) {
+        const structure = drawDefinition?.structures?.find((structure) => structure.structureId === sourceLink.source.structureId);
+        if (structure?.stage !== QUALIFYING)
+            continue;
+        const structureCompleted = isCompletedStructure({
+            structureId: sourceLink.source.structureId,
+            drawDefinition,
+        });
+        if (structureCompleted) {
+            const { positionAssignments } = getPositionAssignments$1({ structure });
+            const relevantParticipantIds = positionAssignments
+                ?.map((assignment) => {
+                const participantId = assignment.participantId;
+                const results = findExtension({ element: assignment, name: TALLY }).extension?.value;
+                return results ? { participantId, groupOrder: results?.groupOrder } : {};
+            })
+                .filter(({ groupOrder, participantId }) => groupOrder === 1 && !assignedParticipantIds.includes(participantId))
+                .map(({ participantId }) => participantId) ?? [];
+            if (relevantParticipantIds)
+                qualifyingParticipantIds.push(...relevantParticipantIds);
+        }
+    }
+    if (!qualifyingParticipantIds.length)
+        return decorateResult({ result: { error: MISSING_QUALIFIED_PARTICIPANTS } });
+    qualifierPositions.forEach((position) => {
+        const randomParticipantId = randomPop(qualifyingParticipantIds);
+        if (randomParticipantId) {
+            const positionAssignmentResult = qualifierDrawPositionAssignment({
+                qualifyingParticipantId: randomParticipantId,
+                structureId: mainStructure.structureId,
+                drawPosition: position.drawPosition,
+                tournamentRecord,
+                drawDefinition,
+            });
+            positionAssignmentResult?.success &&
+                assignedParticipants.push({ participantId: randomParticipantId, drawPosition: position.drawPosition });
+        }
+    });
+    return decorateResult({
+        result: definedAttributes({ ...SUCCESS, assignedParticipants }),
+    });
+}
+
 function setStructureOrder({ drawDefinition, orderMap }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -21930,7 +22072,7 @@ function isGamesBased(based) {
     return !isPointsBased(based);
 }
 
-function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy, perPlayer, totalSets }) {
+function calculatePercentages({ participantResults, groupingTotal, matchUpFormat, tallyPolicy, totalGames, perPlayer, totalSets, }) {
     const parsedGroupMatchUpFormat = (matchUpFormat && parse(matchUpFormat)) || {};
     const bestOfGames = parsedGroupMatchUpFormat.bestOf;
     const bracketSetsToWin = (bestOfGames && Math.ceil(bestOfGames / 2)) || 1;
@@ -21939,7 +22081,7 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
     Object.keys(participantResults).forEach((participantId) => {
         const setsWon = participantResults[participantId].setsWon;
         const setsLost = participantResults[participantId].setsLost;
-        const setsTotal = tallyPolicy?.groupTotalSetsPlayed
+        const setsTotal = tallyPolicy?.groupTotalSetsPlayed || groupingTotal === 'setsPct'
             ? totalSets
             : perPlayer * (bracketSetsToWin || 0) || setsWon + setsLost;
         let setsPct = Math.round((setsWon / setsTotal) * precision) / precision;
@@ -21960,7 +22102,9 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
         const gamesWon = participantResults[participantId].gamesWon || 0;
         const gamesLost = participantResults[participantId].gamesLost || 0;
         const minimumExpectedGames = (perPlayer || 0) * (bracketSetsToWin || 0) * (bracketGamesForSet || 0);
-        const gamesTotal = Math.max(minimumExpectedGames, gamesWon + gamesLost);
+        const gamesTotal = tallyPolicy?.groupTotalGamesPlayed || groupingTotal === 'gamesPct'
+            ? totalGames
+            : Math.max(minimumExpectedGames, gamesWon + gamesLost);
         let gamesPct = Math.round((gamesWon / gamesTotal) * precision) / precision;
         if (gamesPct === Infinity || isNaN(gamesPct))
             gamesPct = 0;
@@ -21983,7 +22127,7 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
     });
 }
 
-function getParticipantResults({ participantIds, pressureRating, matchUpFormat, tallyPolicy, perPlayer, matchUps, }) {
+function getParticipantResults({ participantIds, pressureRating, groupingTotal, matchUpFormat, tallyPolicy, perPlayer, matchUps, }) {
     const participantResults = {};
     const excludeMatchUpStatuses = tallyPolicy?.excludeMatchUpStatuses || [];
     const filteredMatchUps = matchUps?.filter((matchUp) => {
@@ -21991,12 +22135,19 @@ function getParticipantResults({ participantIds, pressureRating, matchUpFormat,
             (!participantIds?.length ||
                 intersection(participantIds, [getSideId(matchUp, 0), getSideId(matchUp, 1)]).length === 2));
     });
-    const allSets = filteredMatchUps?.flatMap(({ score, tieMatchUps }) => tieMatchUps
+    const allSetsCount = filteredMatchUps?.flatMap(({ score, tieMatchUps }) => tieMatchUps
         ? tieMatchUps
             .filter(({ matchUpStatus }) => !excludeMatchUpStatuses.includes(matchUpStatus))
             .flatMap(({ score }) => score?.sets?.length ?? 0)
         : (score?.sets?.length ?? 0));
-    const totalSets = allSets?.reduce((a, b) => a + b, 0);
+    const totalSets = allSetsCount?.reduce((a, b) => a + b, 0);
+    const getGames = (score) => score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0) + (set?.side2Score ?? 0), 0) ?? 0;
+    const allGamesCount = filteredMatchUps?.flatMap(({ score, tieMatchUps }) => tieMatchUps
+        ? tieMatchUps
+            .filter(({ matchUpStatus }) => !excludeMatchUpStatuses.includes(matchUpStatus))
+            .flatMap(({ score }) => getGames(score))
+        : getGames(score));
+    const totalGames = allGamesCount?.reduce((a, b) => a + b, 0);
     for (const matchUp of filteredMatchUps ?? []) {
         const { matchUpStatus, tieMatchUps, tieFormat, score, winningSide, sides } = matchUp;
         const manualGamesOverride = tieFormat && matchUp._disableAutoCalc && tieFormat.collectionDefinitions.every(({ scoreValue }) => scoreValue);
@@ -22140,9 +22291,9 @@ function getParticipantResults({ participantIds, pressureRating, matchUpFormat,
                 });
             }
         }
-        const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
-        const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
         if (manualGamesOverride) {
+            const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
+            const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
             const side1participantId = sides?.find(({ sideNumber }) => sideNumber === 1)?.participantId;
             const side2participantId = sides?.find(({ sideNumber }) => sideNumber === 2)?.participantId;
             checkInitializeParticipant(participantResults, side1participantId);
@@ -22159,8 +22310,10 @@ function getParticipantResults({ participantIds, pressureRating, matchUpFormat,
     }
     calculatePercentages({
         participantResults,
+        groupingTotal,
         matchUpFormat,
         tallyPolicy,
+        totalGames,
         perPlayer,
         totalSets,
     });
@@ -22513,9 +22666,10 @@ function isComplete({ participantResults, participantsCount }) {
     const participantsFinished = resultsArray.filter((r) => participantsCount - 1 === r.results.matchUpsWon + r.results.matchUpsLost + r.results.matchUpsCancelled);
     return participantsCount === participantsFinished.length;
 }
-function processAttribute({ disableHeadToHead, participantIds, matchUpFormat, tallyPolicy, attribute, idsFilter, matchUps, reversed, }) {
+function processAttribute({ disableHeadToHead, participantIds, matchUpFormat, groupTotals, tallyPolicy, attribute, idsFilter, matchUps, reversed, }) {
     const { participantResults } = getParticipantResults({
         participantIds: idsFilter && participantIds,
+        groupingTotal: groupTotals && attribute,
         matchUpFormat,
         tallyPolicy,
         matchUps,
@@ -22578,11 +22732,12 @@ function groupSubSort({ participantResults, disableHeadToHead, participantIds, m
     });
     if (excludedDirectives.length)
         report.push({ excludedDirectives, participantIds });
-    filteredDirectives.every(({ attribute, reversed, idsFilter, disableHeadToHead }) => {
+    filteredDirectives.every(({ attribute, reversed, idsFilter, groupTotals, disableHeadToHead }) => {
         result = processAttribute({
             disableHeadToHead,
             participantIds,
             matchUpFormat,
+            groupTotals,
             tallyPolicy,
             attribute,
             idsFilter,
@@ -22645,8 +22800,8 @@ function tallyParticipantResults({ policyDefinitions, generateReport, pressureRa
         participantResults,
         participantsCount,
         matchUpFormat,
-        tallyPolicy,
         subOrderMap,
+        tallyPolicy,
     });
     if (pressureRating)
         addPressureOrder({ participantResults });
@@ -25115,6 +25270,7 @@ var mutate$c = {
     modifySeedAssignment: modifySeedAssignment,
     pruneDrawDefinition: pruneDrawDefinition,
     qualifierDrawPositionAssignment: qualifierDrawPositionAssignment,
+    qualifierProgression: qualifierProgression,
     removeDrawPositionAssignment: removeDrawPositionAssignment,
     removeRoundMatchUps: removeRoundMatchUps,
     removeSeededParticipant: removeSeededParticipant,
@@ -25401,30 +25557,6 @@ function publicFindDrawDefinition(params) {
     return { drawDefinition: makeDeepCopy(drawDefinition) };
 }
 
-function getSourceStructureIdsAndRelevantLinks({ targetRoundNumber, finishingPosition, drawDefinition, structureId, linkType, }) {
-    const { links } = getStructureLinks({
-        drawDefinition,
-        structureId,
-    }) || {};
-    const sourceLinks = (links?.target || [])
-        .filter(({ linkType: structureLinkType }) => structureLinkType === linkType)
-        .filter(({ target }) => !targetRoundNumber || targetRoundNumber === target.roundNumber);
-    const relevantLinks = sourceLinks
-        .map((link) => {
-        const sourceStructureId = link.source.structureId;
-        const { structure: sourceStructure } = findStructure({
-            structureId: sourceStructureId,
-            drawDefinition,
-        });
-        if (finishingPosition && sourceStructure?.finishingPosition !== finishingPosition)
-            return undefined;
-        return link;
-    })
-        .filter(Boolean);
-    const sourceStructureIds = relevantLinks.map(({ source }) => source.structureId);
-    return { sourceStructureIds, relevantLinks };
-}
-
 function getValidModifyAssignedPairAction({ tournamentParticipants, returnParticipants, drawPosition, participant, drawId, event, }) {
     const availableIndividualParticipantIds = event?.entries
         ?.filter(({ entryStatus }) => [UNGROUPED, UNPAIRED].includes(entryStatus))
@@ -38419,6 +38551,7 @@ var index$e = {
     positionActions: positionActions,
     pruneDrawDefinition: pruneDrawDefinition,
     qualifierDrawPositionAssignment: qualifierDrawPositionAssignment,
+    qualifierProgression: qualifierProgression,
     query: query$b,
     removeDrawPositionAssignment: removeDrawPositionAssignment,
     removeRoundMatchUps: removeRoundMatchUps,
@@ -58490,7 +58623,7 @@ function executeFunction(engine, method, params, methodName, engineType) {
     const augmentedParams = params ? paramsMiddleware(tournamentRecords, params) : undefined;
     if (augmentedParams?.error)
         return augmentedParams;
-    const result = invoke({
+    const result = invoke$1({
         params: augmentedParams,
         tournamentRecords,
         tournamentRecord,
@@ -58501,7 +58634,7 @@ function executeFunction(engine, method, params, methodName, engineType) {
     engineLogging({ result, methodName, elapsed, params: paramsToLog, engineType });
     return result;
 }
-function invoke({ tournamentRecords, tournamentRecord, params, methodName, method }) {
+function invoke$1({ tournamentRecords, tournamentRecord, params, methodName, method }) {
     if (getDevContext()) {
         return method({ tournamentRecords, tournamentRecord, ...params });
     }
@@ -59009,58 +59142,58 @@ const matchUpEngine = (() => {
         }
         return engine;
     }
-    importGovernors([scoreGovernor]);
+    importGovernors(engine, [scoreGovernor]);
     return engine;
-    function importGovernors(governors) {
-        governors.forEach((governor) => {
-            Object.keys(governor).forEach((methodName) => {
-                engine[methodName] = (params) => {
-                    if (getDevContext()) {
-                        return invoke({ params, governor, methodName });
+})();
+function importGovernors(engine, governors) {
+    governors.forEach((governor) => {
+        Object.keys(governor).forEach((methodName) => {
+            engine[methodName] = (params) => {
+                if (getDevContext()) {
+                    return invoke(engine, { params, governor, methodName });
+                }
+                else {
+                    try {
+                        return invoke(engine, { params, governor, methodName });
                     }
-                    else {
-                        try {
-                            return invoke({ params, governor, methodName });
-                        }
-                        catch (err) {
-                            handleCaughtError({
-                                engineName: 'matchUpEngine',
-                                methodName,
-                                params,
-                                err,
-                            });
-                        }
+                    catch (err) {
+                        handleCaughtError({
+                            engineName: 'matchUpEngine',
+                            methodName,
+                            params,
+                            err,
+                        });
                     }
-                };
-            });
+                }
+            };
         });
+    });
+}
+function invoke(engine, { params, governor, methodName }) {
+    engine.error = undefined;
+    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(snapshot);
+        return { ...result, rolledBack: !!snapshot };
     }
-    function invoke({ params, governor, methodName }) {
-        engine.error = undefined;
-        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(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;
-    }
-})();
+    const notify = result?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
+    if (notify)
+        notifySubscribers();
+    if (notify || !result?.success || params?.doNotNotify)
+        deleteNotices();
+    return result;
+}
 
 let devContextSet = false;
 const mocksEngine = (() => {