tods-competition-factory 2.1.13 → 2.1.14

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.14';
 }
 
 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());
@@ -9879,15 +9815,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 +9886,16 @@ function getMatchUpScheduleDetails(params) {
             scheduledDate,
             scheduledTime,
             isoDateString,
-            allocatedCourts,
             homeParticipantId,
-            timeModifiers,
             venueAbbreviation,
+            allocatedCourts,
+            timeModifiers,
             venueName,
             venueId,
             courtOrder,
             courtName,
             courtId,
+            official,
             typeChangeRecoveryMinutes,
             recoveryMinutes,
             averageMinutes,
@@ -10549,6 +10492,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 +12224,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 +13750,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 +13864,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 +19108,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 +20852,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 +21463,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 +21471,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 +28688,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 +29338,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 +29361,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 +31898,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 +31929,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 +31938,7 @@ function getSetWinningSide({ matchUpScoringFormat, isDecidingSet, isTiebreakSet,
         set: setObject,
         isDecidingSet,
         isTiebreakSet,
+        isTimedSet,
     });
     return (setIsComplete && leadingSide) || undefined;
 }
@@ -31969,13 +31948,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 +31971,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 +33789,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) {
@@ -36890,6 +36952,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 +37308,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;
@@ -43904,6 +43980,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;
@@ -49225,8 +49311,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 +49322,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 +49487,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 +49582,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 +49599,10 @@ function completeDrawMatchUps(params) {
             matchUpsMap,
             structure,
             event,
-        });
+        }).matchUps;
+        if (!matchUps.length) {
+            console.log('##', drawDefinition);
+        }
         const sortedMatchUpIds = matchUps
             .filter(({ winningSide }) => !winningSide)
             .sort(matchUpSort)
@@ -49537,8 +49623,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 +49632,7 @@ function completeDrawMatchUps(params) {
                     matchUpFormat,
                     matchUpStatus,
                     scoreString,
+                    winningSide,
                     event,
                 });
                 if (result?.error)
@@ -49553,6 +49640,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 };
 }
@@ -56514,17 +56608,27 @@ 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),
+        extensions: filteredExtensions(params.tournamentRecord.extensions),
+        timeItems: filteredTimeItems(params.tournamentRecord.timeItems),
         events: params.tournamentRecord.events?.map(copyEvent) ?? [],
         weekdays: { ...params.tournamentRecord.weekdays },
         venues: { ...params.tournamentRecord.venues },