tods-competition-factory 2.1.13 → 2.1.15

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.13';
+    return '2.1.15';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -9414,46 +9414,6 @@ function scheduledMatchUpDate({ timeStamp, schedule, matchUp }) {
         : schedule;
 }
 
-function matchUpAllocatedCourts({ timeStamp, schedule, matchUp }) {
-    const { itemValue: allocatedCourts, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: ALLOCATE_COURTS,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { allocatedCourts: makeDeepCopy(allocatedCourts, false, true) }
-        : schedule;
-}
-
-function matchUpAssignedCourtId({ timeStamp, schedule, matchUp }) {
-    const { itemValue: courtId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: ASSIGN_COURT,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { courtId }
-        : schedule;
-}
-
-function matchUpAssignedVenueId({ timeStamp, schedule, matchUp }) {
-    const { itemValue: venueId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: ASSIGN_VENUE,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { venueId }
-        : schedule;
-}
-
-function matchUpTimeModifiers({ timeStamp, schedule, matchUp }) {
-    const { itemValue: timeModifiers, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: TIME_MODIFIERS,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { timeModifiers }
-        : schedule;
-}
-
 function timeDate$1(value) {
     if (validTimeString.test(value)) {
         const dateString = getUTCdateString();
@@ -9523,30 +9483,6 @@ function msToTime(s) {
     return pad((s / 3.6e6) | 0) + ':' + pad(((s % 3.6e6) / 6e4) | 0) + ':' + pad(((s % 6e4) / 1000) | 0);
 }
 
-function matchUpCourtOrder({ timeStamp, schedule, matchUp }) {
-    const { itemValue: courtOrder, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: COURT_ORDER,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { courtOrder }
-        : schedule;
-}
-
-function getHomeParticipantId(params) {
-    const { timeStamp, schedule, matchUp } = params;
-    const paramsCheck = checkRequiredParameters(params, [{ [MATCHUP]: true }]);
-    if (paramsCheck.error)
-        return paramsCheck;
-    const { itemValue: homeParticipantId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
-        timeItems: matchUp?.timeItems || [],
-        itemType: HOME_PARTICIPANT_ID,
-    });
-    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
-        ? { homeParticipantId }
-        : schedule;
-}
-
 function matchUpStartTime({ matchUp }) {
     const timeItems = matchUp?.timeItems || [];
     const getTimeStamp = (item) => (!item.createdAt ? 0 : new Date(item.createdAt).getTime());
@@ -9716,11 +9652,14 @@ function getCourtInfo({ tournamentRecord, internalUse, courtId }) {
     return { ...SUCCESS, courtInfo: makeDeepCopy(courtInfo, false, internalUse) };
 }
 
-function getVenueData({ tournamentRecord, venueId }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!venueId)
-        return { error: MISSING_VENUE_ID };
+function getVenueData(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true },
+        { venueId: true, [ERROR]: MISSING_VENUE_ID },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord, venueId } = params;
     const result = findVenue({ tournamentRecord, venueId });
     if (result.error)
         return result;
@@ -9879,15 +9818,21 @@ function getMatchUpScheduleDetails(params) {
     let schedule;
     const { eventIds, drawIds } = scheduleVisibilityFilters ?? {};
     if ((!eventIds || eventIds.includes(matchUp.eventId)) && (!drawIds || drawIds.includes(matchUp.drawId))) {
-        const scheduleSource = { matchUp };
-        const { allocatedCourts } = matchUpAllocatedCourts(scheduleSource);
-        const { homeParticipantId } = getHomeParticipantId(scheduleSource);
-        const { scheduledTime } = scheduledMatchUpTime(scheduleSource);
-        const { timeModifiers } = matchUpTimeModifiers(scheduleSource);
-        let { scheduledDate } = scheduledMatchUpDate(scheduleSource);
-        const { venueId } = matchUpAssignedVenueId(scheduleSource);
-        const { courtId } = matchUpAssignedCourtId(scheduleSource);
-        const { courtOrder } = matchUpCourtOrder(scheduleSource);
+        const getTimeStamp = (item) => (!item.createdAt ? 0 : new Date(item.createdAt).getTime());
+        const timeItemMap = new Map();
+        const sortedTimeItems = matchUp.timeItems?.toSorted((a, b) => getTimeStamp(a) - getTimeStamp(b)) ?? [];
+        for (const timeItem of sortedTimeItems) {
+            timeItemMap.set(timeItem.itemType, timeItem.itemValue);
+        }
+        const homeParticipantId = timeItemMap.get(HOME_PARTICIPANT_ID);
+        const allocatedCourts = timeItemMap.get(ALLOCATE_COURTS);
+        const scheduledTime = timeItemMap.get(SCHEDULED_TIME);
+        const timeModifiers = timeItemMap.get(TIME_MODIFIERS);
+        let scheduledDate = timeItemMap.get(SCHEDULED_DATE);
+        const official = timeItemMap.get(ASSIGN_OFFICIAL);
+        const courtOrder = timeItemMap.get(COURT_ORDER);
+        const venueId = timeItemMap.get(ASSIGN_VENUE);
+        const courtId = timeItemMap.get(ASSIGN_COURT);
         let timeAfterRecovery, averageMinutes, recoveryMinutes, typeChangeRecoveryMinutes, typeChangeTimeAfterRecovery;
         const eventType = matchUp.matchUpType ?? matchUpType;
         if (scheduleTiming && scheduledTime && afterRecoveryTimes && eventType) {
@@ -9944,15 +9889,16 @@ function getMatchUpScheduleDetails(params) {
             scheduledDate,
             scheduledTime,
             isoDateString,
-            allocatedCourts,
             homeParticipantId,
-            timeModifiers,
             venueAbbreviation,
+            allocatedCourts,
+            timeModifiers,
             venueName,
             venueId,
             courtOrder,
             courtName,
             courtId,
+            official,
             typeChangeRecoveryMinutes,
             recoveryMinutes,
             averageMinutes,
@@ -10549,6 +10495,36 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
     return matchUpWithContext;
 }
 
+function matchUpAllocatedCourts({ timeStamp, schedule, matchUp }) {
+    const { itemValue: allocatedCourts, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: ALLOCATE_COURTS,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { allocatedCourts: makeDeepCopy(allocatedCourts, false, true) }
+        : schedule;
+}
+
+function matchUpAssignedCourtId({ timeStamp, schedule, matchUp }) {
+    const { itemValue: courtId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: ASSIGN_COURT,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { courtId }
+        : schedule;
+}
+
+function matchUpAssignedVenueId({ timeStamp, schedule, matchUp }) {
+    const { itemValue: venueId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: ASSIGN_VENUE,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { venueId }
+        : schedule;
+}
+
 function filterMatchUps(params) {
     if (!Array.isArray(params.matchUps))
         return [];
@@ -12251,10 +12227,13 @@ function pushGlobalLog(value, devContextOverride) {
 }
 function getGlobalLog(purge) {
     const globalLogCopy = globalLog.slice();
+    if (purge) {
+        globalLog.length = 0;
+    }
     return globalLogCopy;
 }
 function printGlobalLog(purge) {
-    const globalLogCopy = getGlobalLog();
+    const globalLogCopy = getGlobalLog(purge);
     const modifiedText = globalLogCopy.map((line) => {
         const { color, keyColors, method, newline } = line;
         const methodColor = Object.keys(logColors).includes(color) ? logColors[color] : logColors.cyan;
@@ -13774,7 +13753,7 @@ function processSides(params) {
 }
 
 function getParticipantEntries(params) {
-    const { participantFilters, convertExtensions, policyDefinitions, tournamentRecord, usePublishState, contextProfile, participantMap, withPotentialMatchUps, withRankingProfile, withScheduleItems, scheduleAnalysis, withTeamMatchUps, withStatistics, withOpponents, withMatchUps, withSeeding, withEvents, withDraws, } = params;
+    const { participantFilters, convertExtensions, policyDefinitions, tournamentRecord, usePublishState, participantMap, contextProfile, withPotentialMatchUps, withRankingProfile, withScheduleItems, scheduleAnalysis, withTeamMatchUps, withStatistics, withOpponents, withMatchUps, withSeeding, withEvents, withDraws, } = params;
     const targetParticipantIds = participantFilters?.participantIds;
     const getRelevantParticipantIds = (participantId) => {
         const relevantParticipantIds = [participantId];
@@ -13888,10 +13867,8 @@ function getParticipantEntries(params) {
                 const assignedParticipantIds = structures
                     .filter(({ stage, stageSequence }) => (stage === MAIN && stageSequence === 1) || stage === QUALIFYING)
                     .flatMap((structure) => {
+                    const { positionAssignments } = getPositionAssignments$1({ structure });
                     const { seedAssignments, stageSequence, stage } = structure;
-                    const { positionAssignments } = getPositionAssignments$1({
-                        structure,
-                    });
                     if (stage === MAIN) {
                         drawSize = positionAssignments?.length ?? 0;
                         mainPositionAssignments = positionAssignments;
@@ -19134,9 +19111,7 @@ function automatedPositioning(params) {
 }
 
 function automatedPlayoffPositioning(params) {
-    const { applyPositioning = true, provisionalPositioning, tournamentRecord, drawDefinition, seedingProfile, structureId, placeByes, seedsOnly, event, } = params;
-    if (!event)
-        return { error: EVENT_NOT_FOUND };
+    const { applyPositioning = true, provisionalPositioning, tournamentRecord, drawDefinition, seedingProfile, structureId, placeByes, seedsOnly, } = params;
     if (!drawDefinition)
         return { error: DRAW_DEFINITION_NOT_FOUND };
     const structureIsComplete = isCompletedStructure({
@@ -20880,7 +20855,7 @@ function availablePlayoffProfiles({ playoffPositions, drawDefinition, structure,
 function getPositionRangeMap({ playoffGroups, drawDefinition, structureId }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
-    if (typeof structureId !== 'string' || !Array.isArray(playoffGroups)) {
+    if (!isString(structureId) || !Array.isArray(playoffGroups)) {
         return { error: INVALID_VALUES };
     }
     const playoffGroupFinishingPostions = playoffGroups.map(({ finishingPositions }) => finishingPositions).flat();
@@ -21491,7 +21466,7 @@ function generateAndPopulateRRplayoffStructures(params) {
         });
     }
     const { sourceStructureId, requireSequential, tournamentRecord, drawDefinition, playoffGroups, groupCount, groupSize, event, } = params;
-    const { structures: playoffStructures = [], links: playoffLinks = [], finishingPositionTargets, positionRangeMap, error, } = processPlayoffGroups({
+    const processResult = processPlayoffGroups({
         requireSequential,
         sourceStructureId,
         playoffGroups,
@@ -21499,8 +21474,9 @@ function generateAndPopulateRRplayoffStructures(params) {
         groupSize,
         ...params,
     });
-    if (error)
-        return { error };
+    if (processResult.error)
+        return decorateResult({ result: processResult, stack });
+    const { structures: playoffStructures = [], links: playoffLinks = [], finishingPositionTargets, positionRangeMap, } = processResult;
     const positionsPlayedOff = finishingPositionTargets
         ?.map(({ finishingPositions }) => finishingPositions)
         .flat()
@@ -28715,10 +28691,14 @@ function generateScoreString(params) {
             return `[${tiebreakScore.join('-')}]`;
         }
         const lowTiebreakScore = Math.min(t1, t2);
+        const lowTiebreakSide = lowTiebreakScore === t1 ? 1 : 2;
         const tiebreak = lowTiebreakScore ? `(${lowTiebreakScore})` : '';
         const s1 = side1Score || (isNumeric(side1Score) || autoComplete ? 0 : '');
         const s2 = side2Score || (isNumeric(side2Score) || autoComplete ? 0 : '');
-        let scoreString = reverseScores ? `${[s2, s1].join('-')}${tiebreak}` : `${[s1, s2].join('-')}${tiebreak}`;
+        const includeTiebreak = (sideNumber) => (lowTiebreakSide === sideNumber ? tiebreak : '');
+        const ss1 = `${s1}${includeTiebreak(1)}`;
+        const ss2 = `${s2}${includeTiebreak(2)}`;
+        let scoreString = reverseScores ? `${[ss2, ss1].join('-')}` : `${[ss1, ss2].join('-')}`;
         if (['-', ' '].includes(scoreString))
             scoreString = '';
         return scoreString;
@@ -29361,13 +29341,14 @@ function getMatchUpWinner({ matchUpFormat, matchUpStatus, winningSide, sets }) {
     return { matchUpWinningSide };
 }
 
-function checkSetIsComplete({ ignoreTiebreak = false, matchUpScoringFormat, matchUpFormat, isTiebreakSet, isDecidingSet, set, }) {
+function checkSetIsComplete({ ignoreTiebreak = false, matchUpScoringFormat, matchUpFormat, isTiebreakSet, isDecidingSet, isTimedSet, set, }) {
     if (!set)
         return { error: MISSING_VALUE, info: 'missing set' };
     matchUpScoringFormat = matchUpScoringFormat || (matchUpFormat && parse(matchUpFormat));
     const setFormat = (isDecidingSet && matchUpScoringFormat.finalSetFormat) || matchUpScoringFormat?.setFormat || {};
     const { side1Score, side2Score } = set;
     const { setTo, tiebreakAt } = setFormat;
+    const hasScore = side1Score || side2Score;
     const leadingSide = getLeadingSide({ set });
     const scoreDiff = Math.abs(side1Score - side2Score);
     const containsSetTo = side1Score >= setTo || side2Score >= setTo;
@@ -29383,7 +29364,8 @@ function checkSetIsComplete({ ignoreTiebreak = false, matchUpScoringFormat, matc
         : 2;
     const hasWinMargin = scoreDiff >= winMargin;
     const validNormalSetScore = containsSetTo && (hasWinMargin || requiresTiebreak);
-    return !!((validNormalSetScore || isTiebreakSet) && (!requiresTiebreak || tiebreakIsValid));
+    return !!(((isTimedSet && hasScore) || validNormalSetScore || isTiebreakSet) &&
+        (!requiresTiebreak || tiebreakIsValid));
 }
 function getLeadingSide({ set }) {
     if (set.side1Score || set.side2Score) {
@@ -31919,18 +31901,17 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '' }) {
         .filter(Boolean)
         .map((set, index) => parseSet({ set, setNumber: index + 1 }));
     function parseSet({ set, setNumber }) {
-        const matchTiebreak = set?.startsWith('[') &&
-            set
-                .split('[')[1]
-                .split(']')[0]
-                .split('-')
-                .map((sideScore) => parseInt(sideScore));
-        const setString = (set.includes('(') && set.split('(')[0]) || (set.includes('[') && set.split('[')[0]) || set;
+        const inParentheses = /\(([^)]+)\)/;
+        const inBrackets = /\[([^)]+)\]/;
+        const tiebreak = inParentheses.exec(set);
+        const supertiebreak = inBrackets.exec(set);
+        const matchTiebreak = set?.startsWith('[') && supertiebreak && supertiebreak[1].split('-').map((sideScore) => parseInt(sideScore));
+        const setString = (tiebreak && set.replace(tiebreak[0], '')) || (supertiebreak && set.replace(supertiebreak[0], '')) || set;
         const setScores = !matchTiebreak && setString.split('-').map((sideScore) => parseInt(sideScore));
         const winningSide = matchTiebreak
             ? (matchTiebreak[0] > matchTiebreak[1] && 1) || (matchTiebreak[0] < matchTiebreak[1] && 2) || undefined
             : (setScores[0] > setScores[1] && 1) || (setScores[0] < setScores[1] && 2) || undefined;
-        const setTiebreakLowScore = set.includes('(') ? set.split('(')[1].split(')')[0] : undefined;
+        const setTiebreakLowScore = tiebreak ? tiebreak[1] : undefined;
         const side1TiebreakPerspective = setTiebreakLowScore &&
             getTiebreakComplement({
                 lowValue: setTiebreakLowScore,
@@ -31951,7 +31932,7 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '' }) {
     }
 }
 
-function getSetWinningSide({ matchUpScoringFormat, isDecidingSet, isTiebreakSet, setObject, }) {
+function getSetWinningSide({ matchUpScoringFormat, isDecidingSet, isTiebreakSet, isTimedSet, setObject, }) {
     if (!setObject)
         return undefined;
     const leadingSide = getLeadingSide({ set: setObject });
@@ -31960,6 +31941,7 @@ function getSetWinningSide({ matchUpScoringFormat, isDecidingSet, isTiebreakSet,
         set: setObject,
         isDecidingSet,
         isTiebreakSet,
+        isTimedSet,
     });
     return (setIsComplete && leadingSide) || undefined;
 }
@@ -31969,13 +31951,14 @@ function analyzeSet(params) {
     if (!setObject)
         return { error: MISSING_SET_OBJECT };
     const { setNumber } = setObject || {};
-    const { bestOf } = matchUpScoringFormat || {};
-    const isDecidingSet = !!(setNumber && bestOf && setNumber === bestOf);
+    const { bestOf, exactly } = matchUpScoringFormat || {};
+    const maxSetNumber = bestOf || exactly;
+    const isDecidingSet = !!(setNumber && maxSetNumber && setNumber === maxSetNumber);
     const setFormat = (isDecidingSet && matchUpScoringFormat?.finalSetFormat) || matchUpScoringFormat?.setFormat;
     const expectTiebreakSet = !!setFormat?.tiebreakSet;
     const expectTimedSet = !!setFormat?.timed;
     const expectStandardSet = !expectTiebreakSet && !expectTimedSet;
-    const isValidSetNumber = !!(setNumber && bestOf && setNumber <= bestOf);
+    const isValidSetNumber = !!(setNumber && maxSetNumber && setNumber <= maxSetNumber);
     const sideGameScores = [setObject?.side1Score, setObject?.side2Score];
     const sidePointScores = [setObject?.side1PointScore, setObject?.side2PointScore];
     const sideTiebreakScores = [setObject?.side1TiebreakScore, setObject?.side2TiebreakScore];
@@ -31991,26 +31974,28 @@ function analyzeSet(params) {
     const isTiebreakSet = !!(tiebreakScoresCount && !gameScoresCount);
     const isCompletedSet = !!setObject?.winningSide;
     const { error: standardSetError, result: isValidStandardSetOutcome } = checkValidStandardSetOutcome({
-        setObject,
-        setFormat,
-        sideGameScores,
         sideTiebreakScores,
+        sideGameScores,
+        setFormat,
+        setObject,
     });
     const { error: tiebreakSetError, result: isValidTiebreakSetOutcome } = checkValidTiebreakSetOutcome({
+        sideTiebreakScores,
         setObject,
         setFormat,
-        sideTiebreakScores,
     });
     const isValidSetOutcome = (expectStandardSet && !isTiebreakSet && isValidStandardSetOutcome) ||
-        (expectTiebreakSet && isTiebreakSet && isValidTiebreakSetOutcome);
+        (expectTiebreakSet && isTiebreakSet && isValidTiebreakSetOutcome) ||
+        expectTimedSet;
     const isValidSet = isValidSetNumber &&
         !(expectTiebreakSet && !isTiebreakSet) &&
         !(expectStandardSet && isTiebreakSet) &&
         (!isCompletedSet || isValidSetOutcome);
     const winningSide = getSetWinningSide({
+        isTimedSet: expectTimedSet,
+        matchUpScoringFormat,
         isDecidingSet,
         isTiebreakSet,
-        matchUpScoringFormat,
         setObject,
     });
     const analysis = {
@@ -33807,35 +33792,115 @@ function getAggregateTeamResults(params) {
     const paramsCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true }]);
     if (paramsCheck.error)
         return paramsCheck;
+    const bonusPoints = params.finishingPositionRangeBounsPoints || {};
+    const teamBonusPointHashes = {};
+    const getTeamParticipant = (participant) => {
+        const individualTeams = participant?.individualParticipants?.map((i) => i.teams?.length === 1 && i.teams[0]);
+        return ((participant?.teams?.length === 1 && participant?.teams?.[0]) ||
+            (individualTeams?.[0].participantId === individualTeams?.[1].participantId && individualTeams?.[0]));
+    };
+    const { matchUps, participants } = getParticipants({
+        participantFilters: { participantTypes: [INDIVIDUAL] },
+        withRankingProfile: true,
+        withStatistics: true,
+        ...params,
+    });
+    for (const participant of participants ?? []) {
+        if (participant.participantType === TEAM_PARTICIPANT)
+            continue;
+        if (participant.draws?.[0]?.drawId === 'draw-0-3') {
+            console.log(participant.participantType, participant.draws[0].finishingPositionRange);
+        }
+        const teamParticipant = getTeamParticipant(participant);
+        if (!teamParticipant)
+            continue;
+        for (const draw of participant?.draws ?? []) {
+            const finishingPositionRange = draw?.finishingPositionRange?.join('-');
+            if (finishingPositionRange && bonusPoints?.[finishingPositionRange]) {
+                const teamParticipantId = teamParticipant?.participantId;
+                const drawId = draw?.drawId;
+                const hash = `${teamParticipantId}|${drawId}|${finishingPositionRange}`;
+                teamBonusPointHashes[hash] = bonusPoints[finishingPositionRange];
+            }
+        }
+    }
+    const initializeResults = (teamName) => ({
+        teamName,
+        standingPoints: 0,
+        pointsPlayed: 0,
+        pointsPct: 0,
+        points: 0,
+        bonus: 0,
+        diff: 0,
+        loss: 0,
+        win: 0,
+    });
+    const increment = (results, key, value) => {
+        if (results[key] === undefined)
+            results[key] = 0;
+        results[key] += value;
+    };
+    const individualResults = {};
     const teamResults = {};
-    for (const matchUp of allTournamentMatchUps(params)?.matchUps ?? []) {
+    for (const matchUp of matchUps ?? []) {
         const { sides, matchUpFormat } = matchUp;
         const parsedMatchUpFormat = matchUpFormat && parse(matchUpFormat);
         if (sides?.length === 2 &&
             parsedMatchUpFormat.setFormat?.timed &&
             (!parsedMatchUpFormat.finalSetFormat || parsedMatchUpFormat.finalSetFormat?.timed)) {
             for (const side of sides) {
-                const individualTeams = side?.participant?.individualParticipants?.map((i) => i.teams?.length === 1 && i.teams[0]);
-                const teamParticipant = (side?.participant?.teams?.length === 1 && side?.participant?.teams?.[0]) ||
-                    (individualTeams?.[0].participantId === individualTeams?.[1].participantId && individualTeams?.[0]);
+                const teamParticipant = getTeamParticipant(side.participant);
                 const teamParticipantId = teamParticipant?.participantId;
+                const participantId = side.participant?.participantId;
+                const teamName = teamParticipant?.participantName;
                 const sideNumber = side.sideNumber;
+                const individualParticipantIds = side.participant?.individualParticipantIds || (participantId && [participantId]) || [];
+                individualParticipantIds.forEach((individualParticipantId) => {
+                    if (individualParticipantId && !individualResults[individualParticipantId]) {
+                        individualResults[individualParticipantId] = initializeResults(teamName);
+                    }
+                });
                 if (teamParticipantId && sideNumber) {
-                    if (!teamResults[teamParticipantId]) {
-                        teamResults[teamParticipantId] = { score: 0, diff: 0, teamName: teamParticipant.participantName };
+                    if (!teamResults[teamParticipantId])
+                        teamResults[teamParticipantId] = initializeResults(teamName);
+                    const resultObjects = [
+                        ...individualParticipantIds.map((id) => individualResults[id]),
+                        teamResults[teamParticipantId],
+                    ];
+                    if (matchUp.winningSide) {
+                        if (sideNumber === matchUp.winningSide) {
+                            resultObjects.forEach((resultObject) => increment(resultObject, 'win', 1));
+                        }
+                        else {
+                            resultObjects.forEach((resultObject) => increment(resultObject, 'loss', 1));
+                        }
                     }
-                    for (const set of matchUp.score?.sets ?? []) {
+                    const sets = matchUp.score?.sets || [];
+                    for (const set of sets) {
                         const opponentPoints = set?.[`side${3 - sideNumber}Score`] || 0;
                         const points = set?.[`side${sideNumber}Score`] || 0;
                         const diff = points - opponentPoints;
-                        teamResults[teamParticipantId].score += points;
-                        teamResults[teamParticipantId].diff += diff;
+                        resultObjects.forEach((resultObject) => increment(resultObject, 'pointsPlayed', points + opponentPoints));
+                        resultObjects.forEach((resultObject) => increment(resultObject, 'points', points));
+                        resultObjects.forEach((resultObject) => increment(resultObject, 'diff', diff));
                     }
                 }
             }
         }
     }
-    return { ...SUCCESS, teamResults };
+    for (const hash of Object.keys(teamBonusPointHashes)) {
+        const [teamParticipantId] = hash.split('|');
+        if (teamResults[teamParticipantId]) {
+            teamResults[teamParticipantId].bonus += teamBonusPointHashes[hash];
+            teamResults[teamParticipantId].pointsPct = parseFloat((teamResults[teamParticipantId].points / teamResults[teamParticipantId].pointsPlayed).toFixed(2));
+            teamResults[teamParticipantId].standingPoints =
+                teamResults[teamParticipantId].win + teamResults[teamParticipantId].bonus;
+        }
+    }
+    for (const individualParticipantId of Object.keys(individualResults)) {
+        individualResults[individualParticipantId].pointsPct = parseFloat((individualResults[individualParticipantId].points / individualResults[individualParticipantId].pointsPlayed).toFixed(2));
+    }
+    return { ...SUCCESS, individualResults, teamResults };
 }
 
 function checkIsDual(tournamentRecord) {
@@ -34961,13 +35026,12 @@ function getEventData(params) {
         })
             .filter((drawData) => drawData.structures?.length)
         : undefined;
-    const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
-    const venues = tournamentRecord.venues || [];
+    const venues = Array.isArray(tournamentRecord.venues) ? tournamentRecord.venues : [];
     const venuesData = venues.map((venue) => (({ venueData }) => ({
         ...venueData,
     }))(getVenueData({
-        tournamentRecord,
         venueId: venue.venueId,
+        tournamentRecord,
     })));
     const eventInfo = (({ eventId, eventName, eventType, eventLevel, surfaceCategory, matchUpFormat, category, gender, startDate, endDate, ballType, discipline, }) => ({
         eventId,
@@ -34987,6 +35051,7 @@ function getEventData(params) {
         element: event,
         name: DISPLAY,
     }).extension?.value;
+    const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
     const eventData = {
         tournamentInfo,
         venuesData,
@@ -35011,6 +35076,87 @@ var query$5 = {
     getVenueData: getVenueData
 };
 
+function processNextMatchUps({ matchUpPotentialParticipantIds, matchUpNotBeforeTimes, timeAfterRecovery, matchUp, }) {
+    const { individualParticipantIds } = getIndividualParticipantIds(matchUp);
+    timeAfterRecovery = timeAfterRecovery ?? matchUp.schedule?.timeAfterRecovery;
+    const addPotentialParticipantIds = (targetMatchUpId) => {
+        if (!matchUpPotentialParticipantIds[targetMatchUpId])
+            matchUpPotentialParticipantIds[targetMatchUpId] = [];
+        matchUpPotentialParticipantIds[targetMatchUpId] = unique(matchUpPotentialParticipantIds[targetMatchUpId].concat(...individualParticipantIds));
+    };
+    const updateNotBeforeTime = (matchUpId) => {
+        if (timeAfterRecovery &&
+            (!matchUpNotBeforeTimes[matchUpId] || timeAfterRecovery > matchUpNotBeforeTimes[matchUpId])) {
+            matchUpNotBeforeTimes[matchUpId] = timeAfterRecovery;
+        }
+    };
+    const winnerMatchUpId = matchUp.winnerTo?.matchUpId || matchUp.winnerMatchUpId;
+    if (winnerMatchUpId) {
+        timeAfterRecovery && updateNotBeforeTime(winnerMatchUpId);
+        addPotentialParticipantIds(winnerMatchUpId);
+    }
+    const loserMatchUpId = matchUp.loserTo?.matchUpId || matchUp.loserMatchUpId;
+    if (loserMatchUpId) {
+        timeAfterRecovery && updateNotBeforeTime(loserMatchUpId);
+        addPotentialParticipantIds(loserMatchUpId);
+    }
+    if (matchUp.sidesTo?.length) {
+        matchUp.sidesTo.forEach(({ matchUpId }) => {
+            if (matchUpId) {
+                timeAfterRecovery && updateNotBeforeTime(matchUpId);
+                addPotentialParticipantIds(matchUpId);
+            }
+        });
+    }
+}
+
+function getMatchUpsToSchedule(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [MATCHUPS]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { matchUpPotentialParticipantIds, scheduleCompletedMatchUps, dateScheduledMatchUpIds, matchUpNotBeforeTimes, matchUpScheduleTimes, orderedMatchUpIds, clearDate, matchUps, } = params;
+    const alreadyScheduledMatchUpIds = Object.keys(matchUpScheduleTimes);
+    const matchUpsToSchedule = (orderedMatchUpIds ?? [])
+        .map((matchUpId) => matchUps.find((matchUp) => matchUp.matchUpId === matchUpId))
+        .filter(Boolean)
+        .filter((matchUp) => {
+        const alreadyScheduled = !clearDate &&
+            (dateScheduledMatchUpIds.includes(matchUp.matchUpId) || alreadyScheduledMatchUpIds.includes(matchUp.matchUpId));
+        const doNotSchedule = [
+            BYE,
+            DEFAULTED,
+            COMPLETED$1,
+            ABANDONED$1,
+            RETIRED$1,
+            WALKOVER$2,
+            DOUBLE_WALKOVER,
+            DOUBLE_DEFAULT,
+        ].includes(matchUp?.matchUpStatus);
+        return (scheduleCompletedMatchUps ||
+            (!alreadyScheduled && !matchUp.winningSide && !doNotSchedule));
+    });
+    const matchUpMap = matchUpPotentialParticipantIds && matchUpNotBeforeTimes
+        ? matchUpsToSchedule.reduce((aggregator, matchUp) => {
+            const { drawId, tournamentId } = matchUp;
+            if (!aggregator.matchUpMap[tournamentId])
+                aggregator.matchUpMap[tournamentId] = {};
+            if (!aggregator.matchUpMap[tournamentId][drawId]) {
+                aggregator.matchUpMap[tournamentId][drawId] = [matchUp];
+            }
+            else {
+                aggregator.matchUpMap[tournamentId][drawId].push(matchUp);
+            }
+            processNextMatchUps({
+                matchUpPotentialParticipantIds,
+                matchUpNotBeforeTimes,
+                matchUp,
+            });
+            return aggregator;
+        }, { matchUpMap: {} }).matchUpMap
+        : {};
+    return { matchUpsToSchedule, matchUpMap };
+}
+
 function findMatchUpFormatTiming({ defaultRecoveryMinutes = 0, defaultAverageMinutes, tournamentRecords, matchUpFormat, categoryName, categoryType, tournamentId, eventType, eventId, }) {
     if (!isValidMatchUpFormat({ matchUpFormat }))
         return { error: UNRECOGNIZED_MATCHUP_FORMAT };
@@ -35038,23 +35184,27 @@ function findMatchUpFormatTiming({ defaultRecoveryMinutes = 0, defaultAverageMin
     };
 }
 
-function getScheduledRoundsDetails({ scheduleCompletedMatchUps, containedStructureIds, tournamentRecords, periodLength = 30, matchUps, rounds, }) {
+function getScheduledRoundsDetails(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [ANY_OF]: { tournamentRecords: false, tournamentRecord: false } },
+        { rounds: true, [OF_TYPE]: ARRAY },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { scheduleCompletedMatchUps, periodLength = 30 } = params;
+    const tournamentRecords = params.tournamentRecords ||
+        (params.tournamentRecord && {
+            [params.tournamentRecord.tournamentId]: params.tournamentRecord,
+        }) ||
+        {};
     if (typeof tournamentRecords !== 'object')
         return { error: MISSING_TOURNAMENT_RECORDS };
-    if (!Array.isArray(rounds))
-        return { error: MISSING_VALUE, info: mustBeAnArray('rounds') };
     const matchUpFormatCohorts = {};
     const orderedMatchUpIds = [];
-    rounds.sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
-    containedStructureIds =
-        containedStructureIds ??
-            Object.assign({}, ...Object.values(tournamentRecords).map((tournamentRecord) => getContainedStructures({ tournamentRecord }).containedStructures));
-    if (!matchUps) {
-        ({ matchUps } = allCompetitionMatchUps({
-            nextMatchUps: true,
-            tournamentRecords,
-        }));
-    }
+    const rounds = params.rounds.toSorted((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
+    const containedStructureIds = params.containedStructureIds ??
+        Object.assign({}, ...Object.values(tournamentRecords).map((tournamentRecord) => getContainedStructures({ tournamentRecord }).containedStructures));
+    const matchUps = params.matchUps ?? allCompetitionMatchUps({ nextMatchUps: true, tournamentRecords }).matchUps;
     let greatestAverageMinutes = 0;
     const recoveryMinutesMap = {};
     const averageMinutesMap = {};
@@ -35699,6 +35849,7 @@ var query$4 = {
     __proto__: null,
     courtGridRows: courtGridRows,
     findVenue: findVenue,
+    getMatchUpsToSchedule: getMatchUpsToSchedule,
     getPersonRequests: getPersonRequests,
     getProfileRounds: getProfileRounds,
     getScheduledRoundsDetails: getScheduledRoundsDetails,
@@ -36890,6 +37041,20 @@ function calculateWinCriteria({ collectionDefinitions = [], collectionGroups = [
     return { valueGoal, ...SUCCESS };
 }
 
+function getHomeParticipantId(params) {
+    const { timeStamp, schedule, matchUp } = params;
+    const paramsCheck = checkRequiredParameters(params, [{ [MATCHUP]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { itemValue: homeParticipantId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: HOME_PARTICIPANT_ID,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { homeParticipantId }
+        : schedule;
+}
+
 function getMatchUpContextIds({ matchUps, matchUpId }) {
     if (!validMatchUps(matchUps))
         return { error: INVALID_VALUES };
@@ -37232,8 +37397,8 @@ function analyzeMatchUp(params) {
     const losingSideSetsCount = setsWinCounts[matchUpLosingSideIndex];
     const maxSetsCount = Math.max(...setsWinCounts);
     const maxSetsInstances = instanceCount(setsWinCounts)[maxSetsCount];
-    const { bestOf } = matchUpScoringFormat ?? {};
-    const setsToWin = (bestOf && Math.ceil(bestOf / 2)) || 1;
+    const { bestOf, exactly } = matchUpScoringFormat ?? {};
+    const setsToWin = (bestOf && Math.ceil(bestOf / 2)) || exactly || 1;
     const calculatedWinningSide = (maxSetsCount === setsToWin && maxSetsInstances === 1 && setsWinCounts.indexOf(maxSetsCount) + 1) || undefined;
     const validMatchUpWinningSide = winningSideSetsCount > losingSideSetsCount && matchUpWinningSide === calculatedWinningSide;
     const validMatchUpOutcome = calculatedWinningSide && completedSetsHaveValidOutcomes && validMatchUpWinningSide;
@@ -37711,6 +37876,7 @@ var index$f = {
     getMatchUpType: getMatchUpType,
     getMatchUpsMap: getMatchUpsMap,
     getMatchUpsStats: getMatchUpsStats,
+    getMatchUpsToSchedule: getMatchUpsToSchedule,
     getMaxEntryPosition: getMaxEntryPosition,
     getModifiedMatchUpFormatTiming: getModifiedMatchUpFormatTiming,
     getPairedParticipant: getPairedParticipant,
@@ -43904,6 +44070,16 @@ function setMatchUpHomeParticipantId(params) {
     });
 }
 
+function matchUpTimeModifiers({ timeStamp, schedule, matchUp }) {
+    const { itemValue: timeModifiers, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
+        timeItems: matchUp?.timeItems || [],
+        itemType: TIME_MODIFIERS,
+    });
+    return !schedule || (itemTimeStamp && timeStamp && new Date(itemTimeStamp).getTime() > new Date(timeStamp).getTime())
+        ? { timeModifiers }
+        : schedule;
+}
+
 function addMatchUpScheduledTime(params) {
     const stack = 'addMatchUpScheduledTime';
     let matchUp = params.matchUp;
@@ -46101,40 +46277,6 @@ function checkDependenciesScheduled({ matchUpScheduleTimes, matchUpDependencies,
     return { dependenciesScheduled, remainingDependencies };
 }
 
-function processNextMatchUps({ matchUpPotentialParticipantIds, matchUpNotBeforeTimes, timeAfterRecovery, matchUp, }) {
-    const { individualParticipantIds } = getIndividualParticipantIds(matchUp);
-    timeAfterRecovery = timeAfterRecovery ?? matchUp.schedule?.timeAfterRecovery;
-    const addPotentialParticipantIds = (targetMatchUpId) => {
-        if (!matchUpPotentialParticipantIds[targetMatchUpId])
-            matchUpPotentialParticipantIds[targetMatchUpId] = [];
-        matchUpPotentialParticipantIds[targetMatchUpId] = unique(matchUpPotentialParticipantIds[targetMatchUpId].concat(...individualParticipantIds));
-    };
-    const updateNotBeforeTime = (matchUpId) => {
-        if (timeAfterRecovery &&
-            (!matchUpNotBeforeTimes[matchUpId] || timeAfterRecovery > matchUpNotBeforeTimes[matchUpId])) {
-            matchUpNotBeforeTimes[matchUpId] = timeAfterRecovery;
-        }
-    };
-    const winnerMatchUpId = matchUp.winnerTo?.matchUpId || matchUp.winnerMatchUpId;
-    if (winnerMatchUpId) {
-        timeAfterRecovery && updateNotBeforeTime(winnerMatchUpId);
-        addPotentialParticipantIds(winnerMatchUpId);
-    }
-    const loserMatchUpId = matchUp.loserTo?.matchUpId || matchUp.loserMatchUpId;
-    if (loserMatchUpId) {
-        timeAfterRecovery && updateNotBeforeTime(loserMatchUpId);
-        addPotentialParticipantIds(loserMatchUpId);
-    }
-    if (matchUp.sidesTo?.length) {
-        matchUp.sidesTo.forEach(({ matchUpId }) => {
-            if (matchUpId) {
-                timeAfterRecovery && updateNotBeforeTime(matchUpId);
-                addPotentialParticipantIds(matchUpId);
-            }
-        });
-    }
-}
-
 function checkParticipantProfileInitialization({ individualParticipantProfiles, participantId }) {
     if (!individualParticipantProfiles[participantId]) {
         individualParticipantProfiles[participantId] = {
@@ -46372,47 +46514,6 @@ function processAlreadyScheduledMatchUps({ matchUpPotentialParticipantIds, indiv
     };
 }
 
-function getMatchUpsToSchedule({ matchUpPotentialParticipantIds, scheduleCompletedMatchUps, dateScheduledMatchUpIds, matchUpNotBeforeTimes, matchUpScheduleTimes, orderedMatchUpIds, clearDate, matchUps, }) {
-    const alreadyScheduledMatchUpIds = Object.keys(matchUpScheduleTimes);
-    const matchUpsToSchedule = orderedMatchUpIds
-        .map((matchUpId) => matchUps.find((matchUp) => matchUp.matchUpId === matchUpId))
-        .filter(Boolean)
-        .filter((matchUp) => {
-        const alreadyScheduled = !clearDate &&
-            (dateScheduledMatchUpIds.includes(matchUp.matchUpId) || alreadyScheduledMatchUpIds.includes(matchUp.matchUpId));
-        const doNotSchedule = [
-            BYE,
-            DEFAULTED,
-            COMPLETED$1,
-            ABANDONED$1,
-            RETIRED$1,
-            WALKOVER$2,
-            DOUBLE_WALKOVER,
-            DOUBLE_DEFAULT,
-        ].includes(matchUp?.matchUpStatus);
-        return (scheduleCompletedMatchUps ||
-            (!alreadyScheduled && !matchUp.winningSide && !doNotSchedule));
-    });
-    const { matchUpMap } = matchUpsToSchedule.reduce((aggregator, matchUp) => {
-        const { drawId, tournamentId } = matchUp;
-        if (!aggregator.matchUpMap[tournamentId])
-            aggregator.matchUpMap[tournamentId] = {};
-        if (!aggregator.matchUpMap[tournamentId][drawId]) {
-            aggregator.matchUpMap[tournamentId][drawId] = [matchUp];
-        }
-        else {
-            aggregator.matchUpMap[tournamentId][drawId].push(matchUp);
-        }
-        processNextMatchUps({
-            matchUpPotentialParticipantIds,
-            matchUpNotBeforeTimes,
-            matchUp,
-        });
-        return aggregator;
-    }, { matchUpMap: {} });
-    return { matchUpsToSchedule, matchUpMap };
-}
-
 function generateBookings({ defaultRecoveryMinutes = 0, averageMatchUpMinutes = 90, dateScheduledMatchUps, tournamentRecords, venueIds = [], periodLength, scheduleDate, matchUps, }) {
     if (typeof tournamentRecords !== 'object')
         return { error: MISSING_TOURNAMENT_RECORDS };
@@ -46707,6 +46808,41 @@ function checkRecoveryTime({ individualParticipantProfiles, matchUpNotBeforeTime
     return { enoughTime };
 }
 
+function auditAutoScheduling({ autoSchedulingAudit, tournamentRecords }) {
+    addNotice({ topic: AUDIT, payload: autoSchedulingAudit });
+    const getCount = (obj) => {
+        if (!obj)
+            return 0;
+        const values = Object.values(obj);
+        return values.reduce((count, value) => count + value.length || 0, 0);
+    };
+    const profileRoundsCount = (autoSchedulingAudit?.schedulingProfile || []).reduce((count, dateProfile) => count + dateProfile.venues.reduce((vc, venue) => vc + venue.rounds.length, 0), 0);
+    const itemValue = {
+        scheduledDatesCount: autoSchedulingAudit.scheduledDates?.length,
+        noTimeMatchUpIdsCount: getCount(autoSchedulingAudit?.noTimeMatchUpIds),
+        scheduledMatchUpIdsCount: getCount(autoSchedulingAudit?.scheduledMatchUpIds),
+        overLimitMatchUpIdsCount: getCount(autoSchedulingAudit?.overLimitMatchUpIds),
+        requestConflictsCount: getCount(autoSchedulingAudit?.requestConflicts),
+        profileRoundsCount,
+    };
+    const timeItem = {
+        itemType: AUTO_SCHEDULING_AUDIT,
+        itemValue,
+    };
+    for (const tournamentRecord of Object.values(tournamentRecords)) {
+        const tournamentId = tournamentRecord.tournamentId;
+        if (hasTopic(AUDIT)) {
+            addNotice({
+                payload: { type: AUTO_SCHEDULING_AUDIT, tournamentId, detail: itemValue },
+                topic: AUDIT,
+            });
+        }
+        else {
+            addTournamentTimeItem({ tournamentRecord, timeItem });
+        }
+    }
+}
+
 function checkDailyLimits({ matchUpPotentialParticipantIds, individualParticipantProfiles, matchUpDailyLimits = {}, matchUp, }) {
     const { enteredIndividualParticipantIds } = getIndividualParticipantIds(matchUp);
     const { matchUpId, matchUpType } = matchUp;
@@ -46860,41 +46996,6 @@ function bulkScheduleMatchUps(params) {
     return warnings.length ? { ...SUCCESS, scheduled, warnings } : { ...SUCCESS, scheduled };
 }
 
-function auditAutoScheduling({ autoSchedulingAudit, tournamentRecords }) {
-    addNotice({ topic: AUDIT, payload: autoSchedulingAudit });
-    const getCount = (obj) => {
-        if (!obj)
-            return 0;
-        const values = Object.values(obj);
-        return values.reduce((count, value) => count + value.length || 0, 0);
-    };
-    const profileRoundsCount = (autoSchedulingAudit?.schedulingProfile || []).reduce((count, dateProfile) => count + dateProfile.venues.reduce((vc, venue) => vc + venue.rounds.length, 0), 0);
-    const itemValue = {
-        scheduledDatesCount: autoSchedulingAudit.scheduledDates?.length,
-        noTimeMatchUpIdsCount: getCount(autoSchedulingAudit?.noTimeMatchUpIds),
-        scheduledMatchUpIdsCount: getCount(autoSchedulingAudit?.scheduledMatchUpIds),
-        overLimitMatchUpIdsCount: getCount(autoSchedulingAudit?.overLimitMatchUpIds),
-        requestConflictsCount: getCount(autoSchedulingAudit?.requestConflicts),
-        profileRoundsCount,
-    };
-    const timeItem = {
-        itemType: AUTO_SCHEDULING_AUDIT,
-        itemValue,
-    };
-    for (const tournamentRecord of Object.values(tournamentRecords)) {
-        const tournamentId = tournamentRecord.tournamentId;
-        if (hasTopic(AUDIT)) {
-            addNotice({
-                payload: { type: AUTO_SCHEDULING_AUDIT, tournamentId, detail: itemValue },
-                topic: AUDIT,
-            });
-        }
-        else {
-            addTournamentTimeItem({ tournamentRecord, timeItem });
-        }
-    }
-}
-
 function jinnScheduler({ schedulingProfileModifications, checkPotentialRequestConflicts, scheduleCompletedMatchUps, schedulingProfileIssues, dateSchedulingProfiles, containedStructureIds, matchUpDependencies, matchUpDailyLimits, clearScheduleDates, tournamentRecords, schedulingProfile, personRequests, periodLength, matchUps, courts, dryRun, }) {
     const scheduleTimesRemaining = {};
     const skippedScheduleTimes = {};
@@ -49225,8 +49326,8 @@ function generateOutcome(params) {
         winningSide = winningSide || randomInt(1, 2);
         const outcome = {
             score: noScore,
-            winningSide,
             matchUpStatus,
+            winningSide,
         };
         const scoreDefaulted = matchUpStatus === DEFAULTED && randomInt(1, 100) > 100 - defaultWithScorePercent;
         if (!scoreDefaulted)
@@ -49236,49 +49337,46 @@ function generateOutcome(params) {
         return { outcome: { score: noScore, matchUpStatus } };
     }
     const parsedFormat = parse(matchUpFormat);
-    const { bestOf, setFormat, finalSetFormat } = parsedFormat ?? {};
+    const { bestOf = 1, exactly, setFormat, finalSetFormat } = parsedFormat ?? {};
     const sets = [];
     const weightedSide = randomInt(0, 1);
     const weightedRange = winningSide
         ? [winningSide - 1]
         : [...generateRange(0, sideWeight).map(() => weightedSide), 1 - weightedSide];
     const incompleteSet = [RETIRED$1, DEFAULTED, INCOMPLETE, SUSPENDED].includes(matchUpStatus);
-    const incompleteAt = incompleteSet && (randomPop(generateRange(1, bestOf)) || 1);
+    const incompleteAt = incompleteSet && (randomPop(generateRange(1, exactly || bestOf)) || 1);
     let weightedWinningSide;
-    for (const setNumber of generateRange(1, (bestOf ?? 0) + 1)) {
-        const isFinalSet = setNumber === bestOf;
+    const setsToGenerate = generateRange(1, (exactly ?? bestOf) + 1);
+    for (const setNumber of setsToGenerate) {
+        const isFinalSet = setNumber === (exactly ?? bestOf);
         const { set, incomplete, winningSideNumber } = generateSet({
+            setFormat: (isFinalSet && finalSetFormat) || setFormat,
             incomplete: incompleteAt === setNumber,
-            matchUpStatus,
             pointsPerMinute,
-            setFormat: (isFinalSet && finalSetFormat) || setFormat,
-            setNumber,
+            matchUpStatus,
             weightedRange,
+            setNumber,
         });
         sets.push(set);
         if (incomplete) {
             weightedWinningSide = winningSideNumber;
             break;
         }
-        const analysis = analyzeMatchUp({
-            matchUp: { score: { sets }, matchUpFormat },
-        });
+        const analysis = analyzeMatchUp({ matchUp: { score: { sets }, matchUpFormat } });
         if (analysis.calculatedWinningSide)
             break;
     }
-    const analysis = analyzeMatchUp({
-        matchUp: { score: { sets }, matchUpFormat },
-    });
+    const analysis = analyzeMatchUp({ matchUp: { score: { sets }, matchUpFormat, winningSide } });
     const matchUpWinningSide = weightedWinningSide ? winningSide || weightedWinningSide : analysis.calculatedWinningSide;
     const { score } = matchUpScore({
-        score: { sets },
         winningSide: matchUpWinningSide,
+        score: { sets },
         matchUpStatus,
     });
     const outcome = {
-        score,
         winningSide: matchUpWinningSide,
         matchUpStatus,
+        score,
     };
     return { outcome };
 }
@@ -49404,13 +49502,8 @@ function completeDrawMatchUps(params) {
     const sortedStructures = drawDefinition.structures.slice().sort(structureSort);
     let completedCount = 0;
     const { matchUps: firstRoundDualMatchUps, matchUpsMap } = getAllDrawMatchUps({
-        contextFilters: {
-            stages: [MAIN, QUALIFYING],
-        },
-        matchUpFilters: {
-            matchUpTypes: [TEAM$2],
-            roundNumbers: [1],
-        },
+        matchUpFilters: { matchUpTypes: [TEAM$2], roundNumbers: [1] },
+        contextFilters: { stages: [MAIN, QUALIFYING] },
         inContext: true,
         drawDefinition,
     });
@@ -49504,11 +49597,16 @@ function completeDrawMatchUps(params) {
     }
     const scoreString = typeof completeAllMatchUps === 'string' && completeAllMatchUps;
     const matchUpStatus = scoreString && COMPLETED$1;
-    for (const structure of sortedStructures) {
+    const isRoundRobinWithPlayoff = sortedStructures.length === 2 &&
+        sortedStructures[0].finishingPosition === WIN_RATIO$1 &&
+        intersection(sortedStructures.map(({ stage }) => stage), [MAIN, PLAY_OFF]).length === 2;
+    const structureIds = sortedStructures.map(({ structureId }) => structureId);
+    for (const structureId of structureIds) {
         if (completedCount >= completionGoal)
             break;
-        const { matchUps } = getAllStructureMatchUps({
-            matchUpFilters: { matchUpTypes: [DOUBLES$1, SINGLES$1] },
+        const structure = drawDefinition.structures.find((structure) => structure.structureId === structureId);
+        const matchUps = getAllStructureMatchUps({
+            contextFilters: { matchUpTypes: [DOUBLES$1, SINGLES$1] },
             afterRecoveryTimes: false,
             tournamentRecord,
             inContext: true,
@@ -49516,7 +49614,10 @@ function completeDrawMatchUps(params) {
             matchUpsMap,
             structure,
             event,
-        });
+        }).matchUps;
+        if (!matchUps.length) {
+            console.log('##', drawDefinition);
+        }
         const sortedMatchUpIds = matchUps
             .filter(({ winningSide }) => !winningSide)
             .sort(matchUpSort)
@@ -49537,8 +49638,8 @@ function completeDrawMatchUps(params) {
             const targetMatchUp = matchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
             const isDoubleExit = [DOUBLE_WALKOVER, DOUBLE_DEFAULT].includes(targetMatchUp.matchUpStatus);
             if (targetMatchUp?.readyToScore && !isDoubleExit) {
+                const winningSide = !randomWinningSide && 1;
                 const result = smartComplete({
-                    winningSide: !randomWinningSide && 1,
                     matchUpStatusProfile,
                     tournamentRecord,
                     drawDefinition,
@@ -49546,6 +49647,7 @@ function completeDrawMatchUps(params) {
                     matchUpFormat,
                     matchUpStatus,
                     scoreString,
+                    winningSide,
                     event,
                 });
                 if (result?.error)
@@ -49553,6 +49655,13 @@ function completeDrawMatchUps(params) {
                 completedCount += 1;
             }
         }
+        if (isRoundRobinWithPlayoff && structure.finishingPosition === WIN_RATIO$1 && params.completeRoundRobinPlayoffs) {
+            automatedPlayoffPositioning({
+                structureId: structure.structureId,
+                applyPositioning: true,
+                drawDefinition,
+            });
+        }
     }
     return { ...SUCCESS, completedCount };
 }
@@ -54823,6 +54932,7 @@ var index$5 = {
     findVenue: findVenue,
     generateBookings: generateBookings,
     generateVirtualCourts: generateVirtualCourts,
+    getMatchUpsToSchedule: getMatchUpsToSchedule,
     getPersonRequests: getPersonRequests,
     getProfileRounds: getProfileRounds,
     getScheduledRoundsDetails: getScheduledRoundsDetails,
@@ -56514,20 +56624,30 @@ function copyTournamentRecord(params) {
     const tournamentDayMilliseconds = startDate && endDate ? new Date(extractDate(endDate)).getTime() - new Date(extractDate(startDate)).getTime() : 0;
     const tournamentDays = tournamentDayMilliseconds / dayMilliseconds;
     const newEndDate = params.endDate || addDays(params.startDate, tournamentDays);
+    const filteredTimeItems = (timeItems) => timeItems?.filter(({ itemType }) => params.itemTypeList?.includes(itemType));
+    const filteredExtensions = (extensions) => extensions?.filter(({ name }) => params.extensionList?.includes(name));
     const copyParticipant = (participant) => {
-        const { timeItems, ...rest } = participant;
-        return { ...rest };
+        const { timeItems, extensions, ...rest } = participant;
+        return makeDeepCopy({ ...rest, timeItems: filteredTimeItems(timeItems), extensions: filteredExtensions(extensions) }, false, true);
     };
     const copyEvent = (event) => {
-        const { drawDefinitions, ...rest } = event;
-        return { ...rest };
+        const { drawDefinitions, timeItems, extensions, startDate, endDate, ...rest } = event;
+        return makeDeepCopy({
+            extensions: filteredExtensions(extensions),
+            timeItems: filteredTimeItems(timeItems),
+            startDate: params.startDate,
+            endDate: newEndDate,
+            ...rest,
+        }, false, true);
     };
     const tournamentRecord = {
         participants: params.copyParticipants ? params.tournamentRecord.participants?.map(copyParticipant) ?? [] : [],
-        parentOrganisation: { ...params.tournamentRecord.parentOrganisation },
+        parentOrganisation: makeDeepCopy({ ...params.tournamentRecord.parentOrganisation }, false, true),
+        venues: makeDeepCopy(params.tournamentRecord.venues ?? [], false, true),
+        extensions: filteredExtensions(params.tournamentRecord.extensions),
+        timeItems: filteredTimeItems(params.tournamentRecord.timeItems),
         events: params.tournamentRecord.events?.map(copyEvent) ?? [],
-        weekdays: { ...params.tournamentRecord.weekdays },
-        venues: { ...params.tournamentRecord.venues },
+        weekdays: [...(params.tournamentRecord.weekdays ?? [])],
         tournamentName: params.tournamentName,
         startDate: params.startDate,
         tournamentId: UUID(),