tods-competition-factory 2.2.38 → 2.2.40

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.38';
+    return '2.2.40';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -1992,8 +1992,15 @@ function getNumber$1(formatstring) {
 }
 function timedSetFormat(matchUpFormatObject) {
     let value = `T${matchUpFormatObject.minutes}`;
-    if (matchUpFormatObject.based)
-        value += matchUpFormatObject.based;
+    if (matchUpFormatObject.based === 'A') {
+        value += 'A';
+    }
+    else if (matchUpFormatObject.based === 'P') {
+        value += 'P';
+    }
+    if (matchUpFormatObject.tiebreakFormat?.tiebreakTo) {
+        value += `/TB${matchUpFormatObject.tiebreakFormat.tiebreakTo}`;
+    }
     if (matchUpFormatObject.modifier)
         value += `@${matchUpFormatObject.modifier}`;
     return value;
@@ -2005,7 +2012,8 @@ function getSetFormat(matchUpFormatObject, preserveRedundant) {
     if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && setLimit === 1) {
         return timedSetFormat(matchUpFormatObject.setFormat);
     }
-    const setLimitCode = (setLimit && `${SET}${setLimit}`) || '';
+    const exactlySuffix = exactly && exactly !== 1 ? 'X' : '';
+    const setLimitCode = (setLimit && `${SET}${setLimit}${exactlySuffix}`) || '';
     const setCountValue = stringifySet(matchUpFormatObject.setFormat, preserveRedundant);
     const setCode = (setCountValue && `S:${setCountValue}`) || '';
     const finalSetCountValue = stringifySet(matchUpFormatObject.finalSetFormat, preserveRedundant);
@@ -2079,9 +2087,12 @@ function parse(matchUpFormatCode) {
 }
 function setsMatch(formatstring) {
     const parts = formatstring.split('-');
-    const setsCount = getNumber(parts[0].slice(3));
-    const bestOf = setsCount === 1 || setsCount % 2 !== 0 ? setsCount : undefined;
-    const exactly = setsCount !== 1 && setsCount % 2 === 0 ? setsCount : undefined;
+    const setsPart = parts[0].slice(3);
+    const hasExactlySuffix = setsPart.endsWith('X');
+    const setsCountString = hasExactlySuffix ? setsPart.slice(0, -1) : setsPart;
+    const setsCount = getNumber(setsCountString);
+    const bestOf = hasExactlySuffix && setsCount !== 1 ? undefined : setsCount;
+    const exactly = hasExactlySuffix && setsCount !== 1 ? setsCount : undefined;
     const setFormat = parts && parseSetFormat(parts[1]);
     const finalSetFormat = parts && parseSetFormat(parts[2]);
     const timed = (setFormat && setFormat.timed) || (finalSetFormat && finalSetFormat.timed);
@@ -2099,44 +2110,56 @@ function setsMatch(formatstring) {
         return result;
 }
 function parseSetFormat(formatstring) {
-    if (formatstring?.[1] === ':') {
-        const parts = formatstring.split(':');
-        const setType = setTypes$1[parts[0]];
-        const setFormatString = parts[1];
-        if (setType && setFormatString) {
-            const isTiebreakSet = setFormatString.startsWith('TB');
-            if (isTiebreakSet) {
-                const tiebreakSet = parseTiebreakFormat(setFormatString);
-                if (tiebreakSet === false)
-                    return false;
-                return typeof tiebreakSet === 'object' ? { tiebreakSet } : undefined;
-            }
-            const timedSet = setFormatString.startsWith('T');
-            if (timedSet)
-                return parseTimedSet(setFormatString);
-            const parts = formatstring.match(/^[FS]:(\d+)([A-Za-z]*)/);
-            const NoAD = (parts && isNoAD(parts[2])) || false;
-            const validNoAD = !parts?.[2] || NoAD;
-            const setTo = parts ? getNumber(parts[1]) : undefined;
-            const tiebreakAtValue = parseTiebreakAt(setFormatString);
-            const validTiebreakAt = tiebreakAtValue !== false;
-            const tiebreakAt = (validTiebreakAt && tiebreakAtValue) || setTo;
-            const tiebreakFormat = parseTiebreakFormat(setFormatString.split('/')[1]);
-            const validTiebreak = tiebreakFormat !== false;
-            const result = { setTo };
-            if (NoAD)
-                result.NoAD = true;
-            if (tiebreakFormat) {
-                result.tiebreakFormat = tiebreakFormat;
-                result.tiebreakAt = tiebreakAt;
-            }
-            else {
-                result.noTiebreak = true;
-            }
-            return (setTo && validNoAD && validTiebreak && validTiebreakAt && result) || false;
-        }
+    if (formatstring?.[1] !== ':')
+        return undefined;
+    const parts = formatstring.split(':');
+    const setType = setTypes$1[parts[0]];
+    const setFormatString = parts[1];
+    if (!setType || !setFormatString)
+        return undefined;
+    return parseSetFormatString(formatstring, setFormatString);
+}
+function parseSetFormatString(formatstring, setFormatString) {
+    if (setFormatString.startsWith('TB')) {
+        return parseTiebreakSetFormat(setFormatString);
     }
-    return undefined;
+    if (setFormatString.startsWith('T')) {
+        return parseTimedSet(setFormatString);
+    }
+    return parseStandardSetFormat(formatstring, setFormatString);
+}
+function parseTiebreakSetFormat(setFormatString) {
+    const tiebreakSet = parseTiebreakFormat(setFormatString);
+    if (tiebreakSet === false)
+        return false;
+    return typeof tiebreakSet === 'object' ? { tiebreakSet } : undefined;
+}
+function parseStandardSetFormat(formatstring, setFormatString) {
+    const parts = /^[FS]:(\d+)([A-Za-z]*)/.exec(formatstring);
+    const NoAD = (parts && isNoAD(parts[2])) || false;
+    const validNoAD = !parts?.[2] || NoAD;
+    const setTo = parts ? getNumber(parts[1]) : undefined;
+    const tiebreakAtValue = parseTiebreakAt(setFormatString);
+    const validTiebreakAt = tiebreakAtValue !== false;
+    const tiebreakAt = (validTiebreakAt && tiebreakAtValue) || setTo;
+    const tiebreakFormat = parseTiebreakFormat(setFormatString.split('/')[1]);
+    const validTiebreak = tiebreakFormat !== false;
+    if (!setTo || !validNoAD || !validTiebreak || !validTiebreakAt)
+        return false;
+    return buildSetFormatResult(setTo, NoAD, tiebreakFormat, tiebreakAt);
+}
+function buildSetFormatResult(setTo, NoAD, tiebreakFormat, tiebreakAt) {
+    const result = { setTo };
+    if (NoAD)
+        result.NoAD = true;
+    if (tiebreakFormat) {
+        result.tiebreakFormat = tiebreakFormat;
+        result.tiebreakAt = tiebreakAt;
+    }
+    else {
+        result.noTiebreak = true;
+    }
+    return result;
 }
 function parseTiebreakAt(setFormatString, expectNumber = true) {
     const tiebreakAtValue = setFormatString?.indexOf('@') > 0 && setFormatString.split('@');
@@ -2147,59 +2170,73 @@ function parseTiebreakAt(setFormatString, expectNumber = true) {
     return undefined;
 }
 function parseTiebreakFormat(formatstring) {
-    if (formatstring) {
-        if (formatstring.startsWith('TB')) {
-            const modifier = parseTiebreakAt(formatstring, false);
-            const parts = formatstring.match(/^TB(\d+)([A-Za-z]*)/);
-            const tiebreakToString = parts?.[1];
-            const NoAD = parts && isNoAD(parts[2]);
-            const validNoAD = !parts?.[2] || NoAD;
-            const tiebreakTo = getNumber(tiebreakToString);
-            if (tiebreakTo && validNoAD) {
-                const result = { tiebreakTo };
-                if (modifier && typeof modifier === 'string' && !isConvertableInteger(modifier)) {
-                    result.modifier = modifier;
-                }
-                if (NoAD)
-                    result.NoAD = true;
-                return result;
-            }
-            else {
-                return false;
-            }
-        }
-        else {
-            return false;
-        }
+    if (!formatstring)
+        return undefined;
+    if (!formatstring.startsWith('TB'))
+        return false;
+    return parseTiebreakDetails(formatstring);
+}
+function parseTiebreakDetails(formatstring) {
+    const modifier = parseTiebreakAt(formatstring, false);
+    const parts = /^TB(\d+)([A-Za-z]*)/.exec(formatstring);
+    const tiebreakToString = parts?.[1];
+    const NoAD = parts && isNoAD(parts[2]);
+    const validNoAD = !parts?.[2] || NoAD;
+    const tiebreakTo = getNumber(tiebreakToString);
+    if (!tiebreakTo || !validNoAD)
+        return false;
+    const result = { tiebreakTo };
+    if (modifier && typeof modifier === 'string' && !isConvertableInteger(modifier)) {
+        result.modifier = modifier;
     }
-    return undefined;
+    if (NoAD)
+        result.NoAD = true;
+    return result;
 }
 function parseTimedSet(formatstring) {
     const timestring = formatstring.slice(1);
-    const parts = timestring.match(/^(\d+)(@?[A-Za-z]*)/);
+    const parts = /^(\d+)([PGA])?(?:\/TB(\d+))?(@?[A-Za-z]*)?/.exec(timestring);
     const minutes = getNumber(parts?.[1]);
     if (!minutes)
         return;
     const setFormat = { timed: true, minutes };
-    const based = parts?.[2];
-    const validModifier = [undefined, 'P', 'G'].includes(based);
-    if (based && !validModifier) {
-        const modifier = timestring.match(/^(\d+)(@)([A-Za-z]+)$/)?.[3];
+    const scoringMethod = parts?.[2];
+    if (scoringMethod === 'A') {
+        setFormat.based = 'A';
+    }
+    else if (scoringMethod === 'P') {
+        setFormat.based = 'P';
+    }
+    else if (scoringMethod === 'G') {
+        setFormat.based = 'G';
+    }
+    const setTiebreakTo = parts?.[3];
+    if (setTiebreakTo) {
+        const tiebreakToNumber = getNumber(setTiebreakTo);
+        if (tiebreakToNumber) {
+            setFormat.tiebreakFormat = { tiebreakTo: tiebreakToNumber };
+        }
+    }
+    const legacyModifier = parts?.[4];
+    const validModifier = [undefined, 'P', 'G', ''].includes(legacyModifier);
+    if (legacyModifier && !validModifier) {
+        const modifier = /^(\d+)([PGA])?(?:\/TB\d+)?(@)([A-Za-z]+)$/.exec(timestring)?.[4];
         if (modifier) {
             setFormat.modifier = modifier;
             return setFormat;
         }
         return;
     }
-    if (based)
-        setFormat.based = parts[2];
+    if (legacyModifier)
+        setFormat.based = legacyModifier;
     return setFormat;
 }
 function isNoAD(formatstring) {
-    return formatstring && formatstring.indexOf(NOAD) >= 0;
+    return formatstring?.includes(NOAD);
 }
 function getNumber(formatstring) {
-    return !isNaN(Number(formatstring)) ? Number(formatstring) : 0;
+    const num = Number(formatstring);
+    return Number.isNaN(num) ? 0 : num;
 }
 
 function isValidMatchUpFormat({ matchUpFormat }) {
@@ -32114,7 +32151,7 @@ function tidyScore(params) {
     doProcess(processingOrder);
     let isValid = isValidPattern(score);
     if (!isValid) {
-        score = incomingScore.toString().replace(/\D/g, '');
+        score = incomingScore.toString().replaceAll(/\D/g, '');
         if (attributes?.removed) {
             attributes.removed = undefined;
         }
@@ -32147,6 +32184,179 @@ var help = {
     tidyScore: tidyScore
 };
 
+function validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete) {
+    if (allowIncomplete) {
+        return { isValid: true };
+    }
+    if (winnerScore === 0 && loserScore === 0) {
+        return { isValid: false, error: 'Tiebreak-only set requires both scores' };
+    }
+    if (winnerScore < tiebreakSetTo) {
+        return {
+            isValid: false,
+            error: `Tiebreak-only set winner must reach at least ${tiebreakSetTo}, got ${winnerScore}`,
+        };
+    }
+    if (scoreDiff < 2) {
+        return {
+            isValid: false,
+            error: `Tiebreak-only set must be won by at least 2 points, got ${winnerScore}-${loserScore}`,
+        };
+    }
+    if (winnerScore === tiebreakSetTo && loserScore > tiebreakSetTo - 2) {
+        return {
+            isValid: false,
+            error: `Tiebreak-only set at ${tiebreakSetTo}-${loserScore} requires playing past ${tiebreakSetTo}`,
+        };
+    }
+    if (winnerScore > tiebreakSetTo && scoreDiff !== 2) {
+        return {
+            isValid: false,
+            error: `Tiebreak-only set past ${tiebreakSetTo} must be won by exactly 2 points, got ${winnerScore}-${loserScore}`,
+        };
+    }
+    return { isValid: true };
+}
+function validateTiebreakSetGames(winnerScore, loserScore, setTo, tiebreakAt) {
+    const expectedWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
+    const expectedLoserScore = tiebreakAt;
+    if (winnerScore !== expectedWinnerScore) {
+        return {
+            isValid: false,
+            error: `Tiebreak set winner must have ${expectedWinnerScore} games, got ${winnerScore}`,
+        };
+    }
+    if (loserScore !== expectedLoserScore) {
+        return {
+            isValid: false,
+            error: `Tiebreak set loser must have ${expectedLoserScore} games, got ${loserScore}`,
+        };
+    }
+    return { isValid: true };
+}
+function validateExplicitTiebreakScore(side1TiebreakScore, side2TiebreakScore, tiebreakFormat) {
+    const tbWinnerScore = Math.max(side1TiebreakScore || 0, side2TiebreakScore || 0);
+    const tbLoserScore = Math.min(side1TiebreakScore || 0, side2TiebreakScore || 0);
+    const tbDiff = tbWinnerScore - tbLoserScore;
+    const tbTo = tiebreakFormat.tiebreakTo || 7;
+    if (tbWinnerScore < tbTo) {
+        return {
+            isValid: false,
+            error: `Tiebreak winner must reach ${tbTo} points, got ${tbWinnerScore}`,
+        };
+    }
+    if (tbDiff < 2) {
+        return {
+            isValid: false,
+            error: `Tiebreak must be won by 2 points, got ${tbWinnerScore}-${tbLoserScore}`,
+        };
+    }
+    if (tbLoserScore >= tbTo - 1 && tbDiff > 2) {
+        return {
+            isValid: false,
+            error: `Tiebreak score ${tbWinnerScore}-${tbLoserScore} is invalid`,
+        };
+    }
+    return { isValid: true };
+}
+function validateTwoGameMargin(side1Score, side2Score, setTo, tiebreakAt) {
+    if (!tiebreakAt)
+        return { isValid: true };
+    if (side1Score === setTo + 1 && side2Score < setTo - 1) {
+        return {
+            isValid: false,
+            error: `With tiebreak format, if side 1 has ${setTo + 1} games, side 2 must be at least ${setTo - 1}, got ${side2Score}`,
+        };
+    }
+    if (side2Score === setTo + 1 && side1Score < setTo - 1) {
+        return {
+            isValid: false,
+            error: `With tiebreak format, if side 2 has ${setTo + 1} games, side 1 must be at least ${setTo - 1}, got ${side1Score}`,
+        };
+    }
+    return { isValid: true };
+}
+function validateRegularSetCompletion(winnerScore, loserScore, scoreDiff, setTo, tiebreakAt) {
+    if (winnerScore < setTo) {
+        return {
+            isValid: false,
+            error: `Set winner must reach ${setTo} games, got ${winnerScore}`,
+        };
+    }
+    const isTiebreakWon = tiebreakAt && winnerScore === setTo && loserScore === tiebreakAt && scoreDiff === 1;
+    if (scoreDiff < 2 && !isTiebreakWon) {
+        return {
+            isValid: false,
+            error: `Set must be won by at least 2 games, got ${winnerScore}-${loserScore}`,
+        };
+    }
+    if (tiebreakAt) {
+        if (loserScore >= tiebreakAt && !isTiebreakWon) {
+            return {
+                isValid: false,
+                error: `When tied at ${tiebreakAt}-${tiebreakAt}, must play tiebreak. Use format like ${tiebreakAt + 1}-${tiebreakAt}(5)`,
+            };
+        }
+        const maxWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
+        if (winnerScore > maxWinnerScore) {
+            return {
+                isValid: false,
+                error: `With tiebreak format, set score cannot exceed ${maxWinnerScore}-${tiebreakAt}. Got ${winnerScore}-${loserScore}`,
+            };
+        }
+    }
+    else if (winnerScore > setTo + 10) {
+        return {
+            isValid: false,
+            error: `Set score ${winnerScore}-${loserScore} exceeds reasonable limits`,
+        };
+    }
+    return { isValid: true };
+}
+function parseSetScores(set, isTiebreakOnlyFormat, hasTiebreakScores) {
+    const side1TiebreakScore = set.side1TiebreakScore;
+    const side2TiebreakScore = set.side2TiebreakScore;
+    const side1Score = isTiebreakOnlyFormat && hasTiebreakScores ? side1TiebreakScore : set.side1Score || set.side1 || 0;
+    const side2Score = isTiebreakOnlyFormat && hasTiebreakScores ? side2TiebreakScore : set.side2Score || set.side2 || 0;
+    return { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore };
+}
+function validateTiebreakSet(winnerScore, loserScore, setTo, tiebreakAt, side1TiebreakScore, side2TiebreakScore, tiebreakFormat) {
+    if (setTo && tiebreakAt) {
+        const validation = validateTiebreakSetGames(winnerScore, loserScore, setTo, tiebreakAt);
+        if (!validation.isValid)
+            return validation;
+    }
+    const hasExplicitTiebreak = side1TiebreakScore !== undefined || side2TiebreakScore !== undefined;
+    if (hasExplicitTiebreak && tiebreakFormat) {
+        return validateExplicitTiebreakScore(side1TiebreakScore, side2TiebreakScore, tiebreakFormat);
+    }
+    return { isValid: true };
+}
+function validateIncompleteSet(winnerScore, loserScore, setTo) {
+    if (setTo && (winnerScore > setTo + 10 || loserScore > setTo + 10)) {
+        return {
+            isValid: false,
+            error: `Set score ${winnerScore}-${loserScore} exceeds expected range for ${setTo}-game sets`,
+        };
+    }
+    return { isValid: true };
+}
+function validateRegularSet(scores, setFormat, allowIncomplete) {
+    const { side1: side1Score, side2: side2Score, winner: winnerScore, loser: loserScore, diff: scoreDiff } = scores;
+    const { setTo, tiebreakAt } = setFormat;
+    if (setTo && tiebreakAt) {
+        const marginValidation = validateTwoGameMargin(side1Score, side2Score, setTo, tiebreakAt);
+        if (!marginValidation.isValid)
+            return marginValidation;
+    }
+    if (allowIncomplete) {
+        return validateIncompleteSet(winnerScore, loserScore, setTo);
+    }
+    if (setTo) {
+        return validateRegularSetCompletion(winnerScore, loserScore, scoreDiff, setTo, tiebreakAt);
+    }
+    return { isValid: true };
+}
 function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     if (!matchUpFormat)
         return { isValid: true };
@@ -32159,152 +32369,21 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     const { setTo, tiebreakAt, tiebreakFormat, tiebreakSet } = setFormat;
     const tiebreakSetTo = tiebreakSet?.tiebreakTo;
     const isTiebreakOnlyFormat = !!tiebreakSetTo && !setTo;
-    const side1TiebreakScore = set.side1TiebreakScore;
-    const side2TiebreakScore = set.side2TiebreakScore;
-    const hasTiebreakScores = side1TiebreakScore !== undefined && side2TiebreakScore !== undefined;
-    const side1Score = isTiebreakOnlyFormat && hasTiebreakScores ? side1TiebreakScore : set.side1Score || set.side1 || 0;
-    const side2Score = isTiebreakOnlyFormat && hasTiebreakScores ? side2TiebreakScore : set.side2Score || set.side2 || 0;
+    const hasTiebreakScores = set.side1TiebreakScore !== undefined && set.side2TiebreakScore !== undefined;
+    const { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore } = parseSetScores(set, isTiebreakOnlyFormat, hasTiebreakScores);
     const winnerScore = Math.max(side1Score, side2Score);
     const loserScore = Math.min(side1Score, side2Score);
     const scoreDiff = winnerScore - loserScore;
     if (isTiebreakOnlyFormat) {
-        if (allowIncomplete) {
-            return { isValid: true };
-        }
-        if (side1Score === 0 && side2Score === 0) {
-            return { isValid: false, error: 'Tiebreak-only set requires both scores' };
-        }
-        if (winnerScore < tiebreakSetTo) {
-            return {
-                isValid: false,
-                error: `Tiebreak-only set winner must reach at least ${tiebreakSetTo}, got ${winnerScore}`,
-            };
-        }
-        if (scoreDiff < 2) {
-            return {
-                isValid: false,
-                error: `Tiebreak-only set must be won by at least 2 points, got ${winnerScore}-${loserScore}`,
-            };
-        }
-        if (winnerScore === tiebreakSetTo && loserScore > tiebreakSetTo - 2) {
-            return {
-                isValid: false,
-                error: `Tiebreak-only set at ${tiebreakSetTo}-${loserScore} requires playing past ${tiebreakSetTo}`,
-            };
-        }
-        if (winnerScore > tiebreakSetTo && scoreDiff !== 2) {
-            return {
-                isValid: false,
-                error: `Tiebreak-only set past ${tiebreakSetTo} must be won by exactly 2 points, got ${winnerScore}-${loserScore}`,
-            };
-        }
-        return { isValid: true };
+        return validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete ?? false);
     }
     const hasExplicitTiebreak = side1TiebreakScore !== undefined || side2TiebreakScore !== undefined;
     const isImplicitTiebreak = setTo && winnerScore === setTo + 1 && loserScore === setTo;
     const hasTiebreak = hasExplicitTiebreak || isImplicitTiebreak;
     if (hasTiebreak) {
-        if (setTo && tiebreakAt) {
-            const expectedWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
-            const expectedLoserScore = tiebreakAt;
-            if (winnerScore !== expectedWinnerScore) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak set winner must have ${expectedWinnerScore} games, got ${winnerScore}`,
-                };
-            }
-            if (loserScore !== expectedLoserScore) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak set loser must have ${expectedLoserScore} games, got ${loserScore}`,
-                };
-            }
-        }
-        if (hasExplicitTiebreak && tiebreakFormat) {
-            const tbWinnerScore = Math.max(side1TiebreakScore || 0, side2TiebreakScore || 0);
-            const tbLoserScore = Math.min(side1TiebreakScore || 0, side2TiebreakScore || 0);
-            const tbDiff = tbWinnerScore - tbLoserScore;
-            const tbTo = tiebreakFormat.tiebreakTo || 7;
-            if (tbWinnerScore < tbTo) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak winner must reach ${tbTo} points, got ${tbWinnerScore}`,
-                };
-            }
-            if (tbDiff < 2) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak must be won by 2 points, got ${tbWinnerScore}-${tbLoserScore}`,
-                };
-            }
-            if (tbLoserScore >= tbTo - 1 && tbDiff > 2) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak score ${tbWinnerScore}-${tbLoserScore} is invalid`,
-                };
-            }
-        }
-    }
-    else {
-        if (setTo && tiebreakAt) {
-            if (side1Score === setTo + 1 && side2Score < setTo - 1) {
-                return {
-                    isValid: false,
-                    error: `With tiebreak format, if side 1 has ${setTo + 1} games, side 2 must be at least ${setTo - 1}, got ${side2Score}`,
-                };
-            }
-            if (side2Score === setTo + 1 && side1Score < setTo - 1) {
-                return {
-                    isValid: false,
-                    error: `With tiebreak format, if side 2 has ${setTo + 1} games, side 1 must be at least ${setTo - 1}, got ${side1Score}`,
-                };
-            }
-        }
-        if (allowIncomplete) {
-            if (setTo && (winnerScore > setTo + 10 || loserScore > setTo + 10)) {
-                return {
-                    isValid: false,
-                    error: `Set score ${winnerScore}-${loserScore} exceeds expected range for ${setTo}-game sets`,
-                };
-            }
-            return { isValid: true };
-        }
-        if (setTo && winnerScore < setTo) {
-            return {
-                isValid: false,
-                error: `Set winner must reach ${setTo} games, got ${winnerScore}`,
-            };
-        }
-        const isTiebreakWon = tiebreakAt && winnerScore === setTo && loserScore === tiebreakAt && scoreDiff === 1;
-        if (scoreDiff < 2 && !isTiebreakWon) {
-            return {
-                isValid: false,
-                error: `Set must be won by at least 2 games, got ${winnerScore}-${loserScore}`,
-            };
-        }
-        if (tiebreakAt) {
-            if (loserScore >= tiebreakAt && !isTiebreakWon) {
-                return {
-                    isValid: false,
-                    error: `When tied at ${tiebreakAt}-${tiebreakAt}, must play tiebreak. Use format like ${tiebreakAt + 1}-${tiebreakAt}(5)`,
-                };
-            }
-            const maxWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
-            if (winnerScore > maxWinnerScore) {
-                return {
-                    isValid: false,
-                    error: `With tiebreak format, set score cannot exceed ${maxWinnerScore}-${tiebreakAt}. Got ${winnerScore}-${loserScore}`,
-                };
-            }
-        }
-        else if (winnerScore > setTo + 10) {
-            return {
-                isValid: false,
-                error: `Set score ${winnerScore}-${loserScore} exceeds reasonable limits`,
-            };
-        }
+        return validateTiebreakSet(winnerScore, loserScore, setTo, tiebreakAt, side1TiebreakScore, side2TiebreakScore, tiebreakFormat);
     }
-    return { isValid: true };
+    return validateRegularSet({ side1: side1Score, side2: side2Score, winner: winnerScore, loser: loserScore, diff: scoreDiff }, { setTo, tiebreakAt }, allowIncomplete);
 }
 function validateMatchUpScore(sets, matchUpFormat, matchUpStatus) {
     if (!sets || sets.length === 0) {
@@ -32383,12 +32462,39 @@ function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, win
             const excessiveSetScore = !setValues.noTiebreak && maxSetScore > setValues.setTo + 1;
             return !excessiveSetScore;
         });
-    const calculatedWinningSide = ((!matchUpFormat || maxSetsCount === setsToWin) &&
-        maxSetsInstances === 1 &&
-        setsWinCounts.indexOf(maxSetsCount) + 1) ||
-        undefined;
+    const isAggregateScoring = matchUpScoringFormat?.setFormat?.based === 'A' || matchUpScoringFormat?.finalSetFormat?.based === 'A';
+    let calculatedWinningSide;
+    if (isAggregateScoring && sets.length > 0) {
+        const aggregateTotals = sets.reduce((totals, set) => {
+            if (set.side1Score !== undefined || set.side2Score !== undefined) {
+                totals[0] += set.side1Score ?? 0;
+                totals[1] += set.side2Score ?? 0;
+            }
+            return totals;
+        }, [0, 0]);
+        if (aggregateTotals[0] > aggregateTotals[1]) {
+            calculatedWinningSide = 1;
+        }
+        else if (aggregateTotals[1] > aggregateTotals[0]) {
+            calculatedWinningSide = 2;
+        }
+        else {
+            const tiebreakSet = sets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
+            if (tiebreakSet) {
+                calculatedWinningSide = tiebreakSet.winningSide;
+            }
+        }
+    }
+    else {
+        calculatedWinningSide =
+            ((!matchUpFormat || maxSetsCount === setsToWin) &&
+                maxSetsInstances === 1 &&
+                setsWinCounts.indexOf(maxSetsCount) + 1) ||
+                undefined;
+    }
     const valid = !!(validSets &&
-        ((winningSide && winningSideSetsCount > losingSideSetsCount && winningSide === calculatedWinningSide) ||
+        ((winningSide && isAggregateScoring && winningSide === calculatedWinningSide) ||
+            (winningSide && !isAggregateScoring && winningSideSetsCount > losingSideSetsCount && winningSide === calculatedWinningSide) ||
             (winningSide && irregularEnding) ||
             (!winningSide &&
                 !calculatedWinningSide &&
@@ -36509,9 +36615,9 @@ function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData }) {
     const maxCourtOrder = courtsData?.reduce((order, court) => {
         const matchUps = court.matchUps || [];
         const courtOrder = Math.max(0, ...matchUps.map((m) => m.schedule.courtOrder || 0));
-        return courtOrder > order ? courtOrder : order;
+        return Math.max(courtOrder, order);
     }, 1);
-    const rowsCount = minRowsCount ? Math.max(minRowsCount, maxCourtOrder) : maxCourtOrder;
+    const rowsCount = Math.max(minRowsCount || 0, maxCourtOrder);
     const rowBuilder = generateRange(0, rowsCount).map((rowIndex) => ({
         matchUps: generateRange(0, courtsData.length).map((courtIndex) => {
             const courtInfo = courtsData[courtIndex];
@@ -37282,24 +37388,22 @@ function competitionScheduleMatchUps(params) {
         ({ drawIds: publishedDrawIds, detailsMap } = getCompetitionPublishedDrawDetails({ tournamentRecords }));
     }
     if (publishedDrawIds?.length) {
-        if (!params.contextFilters)
-            params.contextFilters = {};
-        if (!params.contextFilters?.drawIds) {
-            params.contextFilters.drawIds = publishedDrawIds;
+        params.contextFilters ??= {};
+        if (params.contextFilters.drawIds) {
+            params.contextFilters.drawIds = params.contextFilters.drawIds.filter((drawId) => publishedDrawIds.includes(drawId));
         }
         else {
-            params.contextFilters.drawIds = params.contextFilters.drawIds.filter((drawId) => publishedDrawIds.includes(drawId));
+            params.contextFilters.drawIds = publishedDrawIds;
         }
     }
     if (tournamentPublishStatus?.eventIds?.length) {
-        if (!params.matchUpFilters)
-            params.matchUpFilters = {};
+        params.matchUpFilters ??= {};
         if (params.matchUpFilters?.eventIds) {
-            if (!params.matchUpFilters.eventIds.length) {
-                params.matchUpFilters.eventIds = tournamentPublishStatus.eventIds;
+            if (params.matchUpFilters.eventIds.length) {
+                params.matchUpFilters.eventIds = params.matchUpFilters.eventIds.filter((eventId) => tournamentPublishStatus.eventIds.includes(eventId));
             }
             else {
-                params.matchUpFilters.eventIds = params.matchUpFilters.eventIds.filter((eventId) => tournamentPublishStatus.eventIds.includes(eventId));
+                params.matchUpFilters.eventIds = tournamentPublishStatus.eventIds;
             }
         }
         else {
@@ -37307,14 +37411,13 @@ function competitionScheduleMatchUps(params) {
         }
     }
     if (tournamentPublishStatus?.scheduledDates?.length) {
-        if (!params.matchUpFilters)
-            params.matchUpFilters = {};
+        params.matchUpFilters ??= {};
         if (params.matchUpFilters.scheduledDates) {
-            if (!params.matchUpFilters.scheduledDates.length) {
-                params.matchUpFilters.scheduledDates = tournamentPublishStatus.scheduledDates;
+            if (params.matchUpFilters.scheduledDates.length) {
+                params.matchUpFilters.scheduledDates = params.matchUpFilters.scheduledDates.filter((scheduledDate) => tournamentPublishStatus.scheduledDates.includes(scheduledDate));
             }
             else {
-                params.matchUpFilters.scheduledDates = params.matchUpFilters.scheduledDates.filter((scheduledDate) => tournamentPublishStatus.scheduledDates.includes(scheduledDate));
+                params.matchUpFilters.scheduledDates = tournamentPublishStatus.scheduledDates;
             }
         }
         else {
@@ -37322,8 +37425,7 @@ function competitionScheduleMatchUps(params) {
         }
     }
     if (alwaysReturnCompleted) {
-        if (!params.matchUpFilters)
-            params.matchUpFilters = {};
+        params.matchUpFilters ??= {};
         if (params.matchUpFilters?.excludeMatchUpStatuses?.length) {
             if (!params.matchUpFilters.excludeMatchUpStatuses.includes(COMPLETED$1)) {
                 params.matchUpFilters.excludeMatchUpStatuses.push(COMPLETED$1);
@@ -37390,7 +37492,7 @@ function competitionScheduleMatchUps(params) {
     };
     if (withCourtGridRows) {
         const { rows, courtPrefix } = courtGridRows({
-            minRowsCount: minCourtGridRows,
+            minRowsCount: Math.max(minCourtGridRows || 0, dateMatchUps.length || 0),
             courtsData,
         });
         result.courtPrefix = courtPrefix;
@@ -51976,7 +52078,7 @@ function generateTournamentRecord(params) {
             return result;
     }
     if (params.drawProfiles) {
-        const result = processDrawProfiles({
+        const result = processDrawProfiles$1({
             allUniqueParticipantIds,
             ratingsParameters: ratingsParameters$1,
             tournamentRecord,
@@ -51988,7 +52090,7 @@ function generateTournamentRecord(params) {
             return result;
     }
     if (params.eventProfiles) {
-        const result = processEventProfiles({
+        const result = processEventProfiles$1({
             allUniqueParticipantIds,
             ratingsParameters: ratingsParameters$1,
             tournamentRecord,
@@ -52013,7 +52115,7 @@ function generateTournamentRecord(params) {
         drawIds,
     });
 }
-function processDrawProfiles(params) {
+function processDrawProfiles$1(params) {
     const { tournamentRecord, drawProfiles, allUniqueParticipantIds, eventIds, drawIds } = params;
     let drawIndex = 0;
     for (const drawProfile of drawProfiles) {
@@ -52045,7 +52147,7 @@ function processDrawProfiles(params) {
         drawIndex += 1;
     }
 }
-function processEventProfiles(params) {
+function processEventProfiles$1(params) {
     const { eventProfiles, allUniqueParticipantIds, eventIds, drawIds } = params;
     let eventIndex = 0;
     for (const eventProfile of eventProfiles) {
@@ -52372,164 +52474,150 @@ function generatePairParticipantName({ individualParticipantIds, individualParti
     return participantName;
 }
 
-function modifyTournamentRecord(params) {
-    const { ratingsParameters: ratingsParameters$1 = ratingsParameters, participantsProfile = {}, matchUpStatusProfile, completeAllMatchUps, autoEntryPositions, hydrateCollections, randomWinningSide, schedulingProfile, tournamentRecord, autoSchedule, eventProfiles, periodLength, venueProfiles, drawProfiles, isMock, uuids, } = params;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    const allUniqueParticipantIds = [];
-    const eventIds = [];
-    const drawIds = [];
-    eventProfiles?.forEach((eventProfile) => {
-        const event = tournamentRecord.events?.find((event, index) => (eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex) ||
-            (eventProfile.eventName && event.eventName === eventProfile.eventName) ||
-            (eventProfile.eventId && event.eventId === eventProfile.eventId));
-        if (event?.gender) {
-            eventProfile.gender = event.gender;
-        }
-    });
-    const participantsCount = tournamentRecord.participants?.length || undefined;
-    if (participantsCount && participantsProfile?.idPrefix) {
-        participantsProfile.idPrefix = `${participantsProfile.idPrefix}-${participantsCount}`;
+function processExistingEvent({ event, eventProfile, tournamentRecord, allUniqueParticipantIds, drawIds }) {
+    const { gender, category, eventType } = event;
+    const { drawProfiles, publish } = eventProfile;
+    const eventParticipantType = (isMatchUpEventType(SINGLES)(eventType) && INDIVIDUAL) ||
+        (isMatchUpEventType(DOUBLES)(eventType) && PAIR) ||
+        eventType;
+    if (drawProfiles) {
+        const { stageParticipantsCount, uniqueParticipantsCount, uniqueParticipantStages } = getStageParticipantsCount({
+            drawProfiles,
+            category,
+            gender,
+        });
+        const { uniqueDrawParticipants = [], uniqueParticipantIds = [] } = uniqueParticipantStages
+            ? generateEventParticipants({
+                event: { eventType, category, gender },
+                uniqueParticipantsCount,
+                participantsProfile: eventProfile.participantsProfile,
+                ratingsParameters: eventProfile.ratingsParameters,
+                tournamentRecord,
+                eventProfile,
+                uuids: eventProfile.uuids,
+            })
+            : {};
+        allUniqueParticipantIds.push(...uniqueParticipantIds);
+        const { stageParticipants } = getStageParticipants({
+            targetParticipants: tournamentRecord.participants || [],
+            allUniqueParticipantIds,
+            stageParticipantsCount,
+            eventParticipantType,
+        });
+        let result = generateFlights({
+            uniqueDrawParticipants,
+            autoEntryPositions: eventProfile.autoEntryPositions,
+            stageParticipants,
+            tournamentRecord,
+            drawProfiles,
+            category,
+            gender,
+            event,
+        });
+        if (result.error)
+            return result;
+        result = generateFlightDrawDefinitions({
+            matchUpStatusProfile: eventProfile.matchUpStatusProfile,
+            completeAllMatchUps: eventProfile.completeAllMatchUps,
+            randomWinningSide: eventProfile.randomWinningSide,
+            tournamentRecord,
+            drawProfiles,
+            isMock: eventProfile.isMock,
+            event,
+        });
+        if (result.error)
+            return result;
+        drawIds.push(...result.drawIds);
     }
-    const result = addTournamentParticipants({
-        startDate: tournamentRecord.startDate,
-        participantsProfile,
-        tournamentRecord,
-        eventProfiles,
-        drawProfiles,
-        uuids,
-    });
-    if (!result.success)
-        return result;
-    if (eventProfiles) {
-        let eventIndex = tournamentRecord.events?.length || 0;
-        for (const eventProfile of eventProfiles) {
-            const { ratingsParameters } = eventProfile;
-            const event = tournamentRecord.events?.find((event, index) => (eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex) ||
-                (eventProfile.eventName && event.eventName === eventProfile.eventName) ||
-                (eventProfile.eventId && event.eventId === eventProfile.eventId));
-            if (!event) {
-                const result = generateEventWithFlights({
-                    startDate: tournamentRecord.startDate,
-                    allUniqueParticipantIds,
-                    matchUpStatusProfile,
-                    participantsProfile,
-                    completeAllMatchUps,
-                    autoEntryPositions,
-                    randomWinningSide,
-                    ratingsParameters,
-                    tournamentRecord,
-                    eventProfile,
-                    eventIndex,
-                    uuids,
-                });
-                if (result.error)
-                    return result;
-                const { eventId, drawIds: generatedDrawIds, uniqueParticipantIds } = result;
-                if (generatedDrawIds)
-                    drawIds.push(...generatedDrawIds);
-                eventIds.push(eventId);
-                if (uniqueParticipantIds?.length)
-                    allUniqueParticipantIds.push(...uniqueParticipantIds);
-                eventIndex += 1;
-            }
-            else {
-                const { gender, category, eventType } = event;
-                const { drawProfiles, publish } = eventProfile;
-                const eventParticipantType = (isMatchUpEventType(SINGLES)(eventType) && INDIVIDUAL) ||
-                    (isMatchUpEventType(DOUBLES)(eventType) && PAIR) ||
-                    eventType;
-                if (drawProfiles) {
-                    const { stageParticipantsCount, uniqueParticipantsCount, uniqueParticipantStages } = getStageParticipantsCount({
-                        drawProfiles,
-                        category,
-                        gender,
-                    });
-                    const { uniqueDrawParticipants = [], uniqueParticipantIds = [] } = uniqueParticipantStages
-                        ? generateEventParticipants({
-                            event: { eventType, category, gender },
-                            uniqueParticipantsCount,
-                            participantsProfile,
-                            ratingsParameters,
-                            tournamentRecord,
-                            eventProfile,
-                            uuids,
-                        })
-                        : {};
-                    allUniqueParticipantIds.push(...uniqueParticipantIds);
-                    const { stageParticipants } = getStageParticipants({
-                        targetParticipants: tournamentRecord.participants || [],
-                        allUniqueParticipantIds,
-                        stageParticipantsCount,
-                        eventParticipantType,
-                    });
-                    let result = generateFlights({
-                        uniqueDrawParticipants,
-                        autoEntryPositions,
-                        stageParticipants,
-                        tournamentRecord,
-                        drawProfiles,
-                        category,
-                        gender,
-                        event,
-                    });
-                    if (result.error)
-                        return result;
-                    result = generateFlightDrawDefinitions({
-                        matchUpStatusProfile,
-                        completeAllMatchUps,
-                        randomWinningSide,
-                        tournamentRecord,
-                        drawProfiles,
-                        isMock,
-                        event,
-                    });
-                    if (result.error)
-                        return result;
-                    drawIds.push(...result.drawIds);
-                }
-                if (publish) {
-                    publishEvent({ tournamentRecord, event });
-                }
-            }
-        }
+    if (publish) {
+        publishEvent({ tournamentRecord, event });
     }
-    if (drawProfiles) {
-        let drawIndex = (tournamentRecord.events || [])
-            .map((event) => event.drawDefinitions?.map(() => 1) || [])
-            .flat()
-            .reduce((a, b) => a + b, 0);
-        for (const drawProfile of drawProfiles) {
-            let result = generateEventWithDraw({
-                startDate: tournamentRecord.startDate,
-                allUniqueParticipantIds,
-                matchUpStatusProfile,
-                participantsProfile,
-                completeAllMatchUps,
-                autoEntryPositions,
-                hydrateCollections,
-                randomWinningSide,
-                ratingsParameters: ratingsParameters$1,
+    return SUCCESS;
+}
+function findEventByProfile(events, eventProfile) {
+    return events?.find((event, index) => (eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex) ||
+        (eventProfile.eventName && event.eventName === eventProfile.eventName) ||
+        (eventProfile.eventId && event.eventId === eventProfile.eventId));
+}
+function processEventProfiles({ eventProfiles, tournamentRecord, allUniqueParticipantIds, eventIds, drawIds, params }) {
+    let eventIndex = tournamentRecord.events?.length || 0;
+    for (const eventProfile of eventProfiles) {
+        const event = findEventByProfile(tournamentRecord.events, eventProfile);
+        if (event) {
+            const result = processExistingEvent({
+                event,
+                eventProfile: { ...eventProfile, ...params },
                 tournamentRecord,
-                drawProfile,
-                drawIndex,
-                uuids,
+                allUniqueParticipantIds,
+                drawIds,
             });
             if (result.error)
                 return result;
-            const { drawId, eventId, event, uniqueParticipantIds } = result;
-            result = addEvent({ tournamentRecord, event, internalUse: true });
+        }
+        else {
+            const result = generateEventWithFlights({
+                startDate: tournamentRecord.startDate,
+                allUniqueParticipantIds,
+                matchUpStatusProfile: params.matchUpStatusProfile,
+                participantsProfile: params.participantsProfile,
+                completeAllMatchUps: params.completeAllMatchUps,
+                autoEntryPositions: params.autoEntryPositions,
+                randomWinningSide: params.randomWinningSide,
+                ratingsParameters: eventProfile.ratingsParameters,
+                tournamentRecord,
+                eventProfile,
+                eventIndex,
+                uuids: params.uuids,
+            });
             if (result.error)
                 return result;
-            if (drawId)
-                drawIds.push(drawId);
+            const { eventId, drawIds: generatedDrawIds, uniqueParticipantIds } = result;
+            if (generatedDrawIds)
+                drawIds.push(...generatedDrawIds);
             eventIds.push(eventId);
             if (uniqueParticipantIds?.length)
                 allUniqueParticipantIds.push(...uniqueParticipantIds);
-            drawIndex += 1;
+            eventIndex += 1;
         }
     }
-    const venueIds = venueProfiles?.length ? generateVenues({ tournamentRecord, venueProfiles }) : [];
+    return SUCCESS;
+}
+function processDrawProfiles({ drawProfiles, tournamentRecord, allUniqueParticipantIds, eventIds, drawIds, params }) {
+    let drawIndex = (tournamentRecord.events || [])
+        .flatMap((event) => event.drawDefinitions?.map(() => 1) || [])
+        .reduce((a, b) => a + b, 0);
+    for (const drawProfile of drawProfiles) {
+        let result = generateEventWithDraw({
+            startDate: tournamentRecord.startDate,
+            allUniqueParticipantIds,
+            matchUpStatusProfile: params.matchUpStatusProfile,
+            participantsProfile: params.participantsProfile,
+            completeAllMatchUps: params.completeAllMatchUps,
+            autoEntryPositions: params.autoEntryPositions,
+            hydrateCollections: params.hydrateCollections,
+            randomWinningSide: params.randomWinningSide,
+            ratingsParameters: params.ratingsParameters,
+            tournamentRecord,
+            drawProfile,
+            drawIndex,
+            uuids: params.uuids,
+        });
+        if (result.error)
+            return result;
+        const { drawId, eventId, event, uniqueParticipantIds } = result;
+        result = addEvent({ tournamentRecord, event, internalUse: true });
+        if (result.error)
+            return result;
+        if (drawId)
+            drawIds.push(drawId);
+        eventIds.push(eventId);
+        if (uniqueParticipantIds?.length)
+            allUniqueParticipantIds.push(...uniqueParticipantIds);
+        drawIndex += 1;
+    }
+    return SUCCESS;
+}
+function applySchedulingProfile({ schedulingProfile, autoSchedule, periodLength, tournamentRecord }) {
     let scheduledRounds;
     let schedulerResult = {};
     if (schedulingProfile?.length) {
@@ -52551,6 +52639,69 @@ function modifyTournamentRecord(params) {
             });
         }
     }
+    return { scheduledRounds, schedulerResult };
+}
+function modifyTournamentRecord(params) {
+    const { participantsProfile = {}, schedulingProfile, tournamentRecord, autoSchedule, eventProfiles, periodLength, venueProfiles, drawProfiles, uuids, } = params;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const allUniqueParticipantIds = [];
+    const eventIds = [];
+    const drawIds = [];
+    eventProfiles?.forEach((eventProfile) => {
+        const event = findEventByProfile(tournamentRecord.events, eventProfile);
+        if (event?.gender) {
+            eventProfile.gender = event.gender;
+        }
+    });
+    const participantsCount = tournamentRecord.participants?.length || undefined;
+    if (participantsCount && participantsProfile?.idPrefix) {
+        participantsProfile.idPrefix = `${participantsProfile.idPrefix}-${participantsCount}`;
+    }
+    const result = addTournamentParticipants({
+        startDate: tournamentRecord.startDate,
+        participantsProfile,
+        tournamentRecord,
+        eventProfiles,
+        drawProfiles,
+        uuids,
+    });
+    if (!result.success)
+        return result;
+    if (eventProfiles) {
+        const eventResult = processEventProfiles({
+            eventProfiles,
+            tournamentRecord,
+            allUniqueParticipantIds,
+            eventIds,
+            drawIds,
+            params,
+        });
+        if (eventResult.error)
+            return eventResult;
+    }
+    if (drawProfiles) {
+        const drawResult = processDrawProfiles({
+            drawProfiles,
+            tournamentRecord,
+            allUniqueParticipantIds,
+            eventIds,
+            drawIds,
+            params,
+        });
+        if (drawResult.error)
+            return drawResult;
+    }
+    const venueIds = venueProfiles?.length ? generateVenues({ tournamentRecord, venueProfiles }) : [];
+    const schedulingResult = applySchedulingProfile({
+        schedulingProfile,
+        autoSchedule,
+        periodLength,
+        tournamentRecord,
+    });
+    if (schedulingResult.error)
+        return schedulingResult;
+    const { scheduledRounds, schedulerResult } = schedulingResult;
     const totalParticipantsCount = tournamentRecord.participants.length;
     return {
         totalParticipantsCount,