tods-competition-factory 2.2.33 → 2.2.35

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.33';
+    return '2.2.35';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -2206,11 +2206,11 @@ function isValidMatchUpFormat({ matchUpFormat }) {
     if (!isString(matchUpFormat) || matchUpFormat === '')
         return false;
     const parsedFormat = parse(matchUpFormat);
-    const setParts = matchUpFormat.match(/-S:([1-9])+\/TB(\d{1,2})@?([1-9]?)*/);
+    const setParts = /-S:([1-9])+\/TB(\d{1,2})@?([1-9]?)/.exec(matchUpFormat);
     const setsTo = setParts?.[1];
     const tiebreakTo = setParts?.[2];
     const tiebreakAt = setParts?.[3];
-    const finalSetParts = matchUpFormat.match(/-F:([1-9])+\/TB(\d{1,2})@?([1-9]?)*/);
+    const finalSetParts = /-F:([1-9])+\/TB(\d{1,2})@?([1-9]?)/.exec(matchUpFormat);
     const finalSetTo = finalSetParts?.[1];
     const finalSetTiebreakTo = finalSetParts?.[2];
     const finalTiebreakAt = finalSetParts?.[3];
@@ -10372,6 +10372,10 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
                 else if (setFormat?.tiebreakSet || setFormat?.timed) {
                     set.tiebreakSet = true;
                 }
+                if (set.tiebreakSet && [1, 2].includes(set.winningSide)) {
+                    set.side1Score = set.winningSide === 1 ? 1 : 0;
+                    set.side2Score = set.winningSide === 2 ? 1 : 0;
+                }
                 return set;
             });
         }
@@ -10442,11 +10446,11 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
                             participant.entryStage = entryStage;
                         }
                     }
-                    if (hydrateParticipants !== false) {
-                        Object.assign(side, { participant });
+                    if (hydrateParticipants === false) {
+                        Object.assign(side, { participant: { entryStage, entryStatus } });
                     }
                     else {
-                        Object.assign(side, { participant: { entryStage, entryStatus } });
+                        Object.assign(side, { participant });
                     }
                 }
             }
@@ -10554,7 +10558,7 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
             });
         });
     }
-    const hasParticipants = matchUpWithContext.sides && matchUpWithContext.sides.filter((side) => side?.participantId).length === 2;
+    const hasParticipants = matchUpWithContext.sides?.filter((side) => side?.participantId).length === 2;
     const hasNoWinner = !matchUpWithContext.winningSide;
     const readyToScore = scoringActive && hasParticipants && hasNoWinner;
     Object.assign(matchUpWithContext, { readyToScore, hasContext: true });
@@ -12359,9 +12363,7 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
         ({ structureId } = structure);
     const stack = 'assignDrawPositionBye';
     pushGlobalLog({ method: stack, color: 'cyan', drawPosition });
-    if (!matchUpsMap) {
-        matchUpsMap = getMatchUpsMap({ drawDefinition });
-    }
+    matchUpsMap ??= getMatchUpsMap({ drawDefinition });
     const { positionAssignments } = getPositionAssignments$1({ structure });
     const { activeDrawPositions } = getStructureDrawPositionProfiles({
         drawDefinition,
@@ -12371,7 +12373,8 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
     if (currentAssignment?.bye) {
         return { ...SUCCESS };
     }
-    const hasPropagatedStatus = !!(loserMatchUp && matchUpsMap.drawMatchUps.find((m) => m.loserMatchUpId === loserMatchUp?.matchUpId && isExit(m.matchUpStatus)));
+    const hasPropagatedStatus = !!(loserMatchUp &&
+        matchUpsMap.drawMatchUps.find((m) => m.loserMatchUpId === loserMatchUp?.matchUpId && isExit(m.matchUpStatus)));
     const drawPositionIsActive = activeDrawPositions?.includes(drawPosition);
     if (drawPositionIsActive && !hasPropagatedStatus) {
         return { error: DRAW_POSITION_ACTIVE };
@@ -16727,9 +16730,9 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
                 inContextDrawMatchUps,
                 drawPosition,
                 matchUpId,
-            }))
-            || (isPropagatedExit && matchUp.winningSide)
-            || undefined;
+            })) ||
+            (isPropagatedExit && matchUp.winningSide) ||
+            undefined;
         if (matchUp?.matchUpStatusCodes) {
             updateMatchUpStatusCodes({
                 inContextDrawMatchUps,
@@ -22085,7 +22088,7 @@ function countGames({ matchUpFormat = FORMAT_STANDARD, winningSide: matchUpWinni
             const based = parsedMatchUpFormat?.[whichFormat]?.based;
             const isTiebreakSet = parsedMatchUpFormat?.[whichFormat].tiebreakSet;
             const { side1Score, side2Score } = set;
-            if (isGamesBased(based)) {
+            if (isGamesBased(based) && !isTiebreakSet) {
                 gamesTally[0].push(ensureInt(side1Score || 0));
                 gamesTally[1].push(ensureInt(side2Score || 0));
             }
@@ -22560,6 +22563,42 @@ function processOutcome$1({ winningParticipantId, losingParticipantId, participa
     }
 }
 
+function addExplanation(step, participants, readable, floatSort) {
+    if (!step.groups)
+        return;
+    Object.keys(step.groups)
+        .sort(floatSort)
+        .forEach((key) => {
+        const participantNames = step.groups[key].map((participantId) => participants[participantId]).join(', ');
+        const explanation = `${key} ${step.attribute}: ${participantNames}`;
+        readable.push(explanation);
+    });
+}
+function processReportStep(step, i, participants, readable) {
+    if (step.excludedDirectives?.length) {
+        const attributes = step.excludedDirectives.map(({ attribute }) => attribute).join(', ');
+        const note = `${attributes.length} directives were excluded due to participants limit}`;
+        readable.push(note);
+        const excluded = `Excluded: ${attributes}`;
+        readable.push(excluded);
+    }
+    else {
+        const floatSort = (a, b) => Number.parseFloat(step.reversed ? a : b) - Number.parseFloat(step.reversed ? b : a);
+        const participantsCount = step.groups
+            ? Object.values(step.groups).flat(Infinity).length
+            : (step.participantIds?.length ?? 0);
+        const reversed = step.reversed ? ' in reverse order' : '';
+        const action = step.groups ? 'grouped' : 'separated';
+        const description = `Step ${i + 1}: ${participantsCount} particiants were ${action}${reversed} by ${step.attribute}`;
+        readable.push(description);
+        if (step.idsFilter) {
+            const note = `${step.attribute} was calculated considering ONLY TIED PARTICIPANTS`;
+            readable.push(note);
+        }
+        addExplanation(step, participants, readable, floatSort);
+    }
+    readable.push('----------------------');
+}
 function getTallyReport({ matchUps, order, report }) {
     const participants = {};
     matchUps.forEach(({ sides }) => {
@@ -22572,41 +22611,7 @@ function getTallyReport({ matchUps, order, report }) {
     const readable = [];
     if (Array.isArray(report)) {
         report.forEach((step, i) => {
-            if (step.excludedDirectives?.length) {
-                const attributes = step.excludedDirectives.map(({ attribute }) => attribute).join(', ');
-                const note = `${attributes.length} directives were excluded due to participants limit}`;
-                readable.push(note);
-                const excluded = `Excluded: ${attributes}`;
-                readable.push(excluded);
-            }
-            else {
-                const floatSort = (a, b) => parseFloat(step.reversed ? a : b) - parseFloat(step.reversed ? b : a);
-                const participantsCount = step.groups
-                    ? Object.values(step.groups).flat(Infinity).length
-                    : (step.participantIds?.length ?? 0);
-                const getExplanation = (step) => {
-                    step.groups &&
-                        Object.keys(step.groups)
-                            .sort(floatSort)
-                            .forEach((key) => {
-                            const participantNames = step.groups[key]
-                                .map((participantId) => participants[participantId])
-                                .join(', ');
-                            const explanation = `${key} ${step.attribute}: ${participantNames}`;
-                            readable.push(explanation);
-                        });
-                };
-                const reversed = step.reversed ? ' in reverse order' : '';
-                const action = step.groups ? 'grouped' : 'separated';
-                const description = `Step ${i + 1}: ${participantsCount} particiants were ${action}${reversed} by ${step.attribute}`;
-                readable.push(description);
-                if (step.idsFilter) {
-                    const note = `${step.attribute} was calculated considering ONLY TIED PARTICIPANTS`;
-                    readable.push(note);
-                }
-                getExplanation(step);
-            }
-            readable.push('----------------------');
+            processReportStep(step, i, participants, readable);
         });
     }
     readable.push('Final Order:');
@@ -29082,7 +29087,10 @@ function generateScoreString(params) {
         const t1 = side1TiebreakScore || (isNumeric(side1TiebreakScore) || (tbscores && autoComplete) ? 0 : '');
         const t2 = side2TiebreakScore || (isNumeric(side2TiebreakScore) || (tbscores && autoComplete) ? 0 : '');
         if (isTiebreakSet) {
-            const tiebreakScore = reverseScores ? [t2, t1] : [t1, t2];
+            const useGameScores = hasGameScores(currentSet) && !tbscores;
+            const score1 = useGameScores ? side1Score : t1;
+            const score2 = useGameScores ? side2Score : t2;
+            const tiebreakScore = reverseScores ? [score2, score1] : [score1, score2];
             return `[${tiebreakScore.join('-')}]`;
         }
         const lowTiebreakScore = tbscores ? Math.min(t1, t2) : '';
@@ -31902,6 +31910,29 @@ function handleRetired({ score, profile, applied }) {
     }
     return { score };
 }
+function handleDefaulted({ score, profile, applied }) {
+    score = score?.toString().toLowerCase();
+    const re = /^(.*\d+.*)(def|defaulted)+[A-Za-z ]*$/;
+    if (re.test(score)) {
+        const [leading] = score.match(re).slice(1);
+        applied.push('handleDefaulted');
+        return { score: leading.trim(), matchUpStatus: 'defaulted', applied };
+    }
+    const providerDefaulted = profile?.matchUpStatuses?.defaulted;
+    const additionalDefaulted = Array.isArray(providerDefaulted)
+        ? providerDefaulted
+        : [providerDefaulted].filter(Boolean);
+    const defaulted = ['dft', ...additionalDefaulted].find((def) => score?.endsWith(def));
+    if (defaulted) {
+        applied.push('handleDefaulted');
+        return {
+            matchUpStatus: 'defaulted',
+            score: score?.replace(defaulted, '').trim(),
+            applied,
+        };
+    }
+    return { score };
+}
 function removeDanglingBits({ score, attributes }) {
     if (score.endsWith(' am') || score.endsWith(' pm'))
         score = '';
@@ -32001,6 +32032,7 @@ const transforms = {
     matchKnownPatterns: matchKnownPatterns,
     removeDanglingBits: removeDanglingBits,
     removeErroneous: removeErroneous,
+    handleDefaulted: handleDefaulted,
     handleWalkover: handleWalkover,
     properTiebreak: properTiebreak,
     handleNumeric: handleNumeric,
@@ -32019,6 +32051,7 @@ const processingOrder = [
     'handleNumeric',
     'handleWalkover',
     'handleRetired',
+    'handleDefaulted',
     'replaceOh',
     'stringScore',
     'punctuationAdjustments',
@@ -32114,6 +32147,179 @@ var help = {
     tidyScore: tidyScore
 };
 
+function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
+    if (!matchUpFormat)
+        return { isValid: true };
+    const parsed = parse(matchUpFormat);
+    if (!parsed)
+        return { isValid: true };
+    const setFormat = isDecidingSet && parsed.finalSetFormat ? parsed.finalSetFormat : parsed.setFormat;
+    if (!setFormat)
+        return { isValid: true };
+    const { setTo, tiebreakAt, tiebreakFormat, tiebreakSet } = setFormat;
+    const tiebreakSetTo = tiebreakSet?.tiebreakTo;
+    const isTiebreakOnlyFormat = !!tiebreakSetTo && !setTo;
+    const side1Score = set.side1Score || 0;
+    const side2Score = set.side2Score || 0;
+    const side1TiebreakScore = set.side1TiebreakScore;
+    const side2TiebreakScore = set.side2TiebreakScore;
+    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 (loserScore < tiebreakSetTo - 1) {
+            return {
+                isValid: false,
+                error: `Tiebreak-only set loser must be at least ${tiebreakSetTo - 1} when winner exceeds ${tiebreakSetTo}, got ${loserScore}`,
+            };
+        }
+        if (scoreDiff !== 2) {
+            return {
+                isValid: false,
+                error: `Tiebreak-only set must be won by exactly 2 points, got ${winnerScore}-${loserScore}`,
+            };
+        }
+        return { isValid: true };
+    }
+    const hasExplicitTiebreak = side1TiebreakScore !== undefined || side2TiebreakScore !== undefined;
+    const isImplicitTiebreak = setTo && winnerScore === setTo + 1 && loserScore === setTo;
+    const isLikelyTiebreak = tiebreakAt && winnerScore === tiebreakAt - 1 && loserScore === tiebreakAt - 2;
+    const hasTiebreak = hasExplicitTiebreak || isImplicitTiebreak || isLikelyTiebreak;
+    if (hasTiebreak) {
+        if (setTo && !isLikelyTiebreak) {
+            if (winnerScore !== setTo + 1) {
+                return {
+                    isValid: false,
+                    error: `Tiebreak set winner must have ${setTo + 1} games, got ${winnerScore}`,
+                };
+            }
+            if (loserScore !== setTo) {
+                return {
+                    isValid: false,
+                    error: `Tiebreak set loser must have ${setTo} games when tied, 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}`,
+            };
+        }
+        if (scoreDiff < 2) {
+            return {
+                isValid: false,
+                error: `Set must be won by at least 2 games, got ${winnerScore}-${loserScore}`,
+            };
+        }
+        if (tiebreakAt) {
+            if (loserScore >= tiebreakAt) {
+                return {
+                    isValid: false,
+                    error: `When tied at ${tiebreakAt}-${tiebreakAt}, must play tiebreak. Use format like ${tiebreakAt + 1}-${tiebreakAt}(5)`,
+                };
+            }
+            if (winnerScore > setTo + 1) {
+                return {
+                    isValid: false,
+                    error: `With tiebreak format, set score cannot exceed ${setTo + 1}-${setTo - 1}. Got ${winnerScore}-${loserScore}`,
+                };
+            }
+        }
+        else {
+            if (winnerScore > setTo + 10) {
+                return {
+                    isValid: false,
+                    error: `Set score ${winnerScore}-${loserScore} exceeds reasonable limits`,
+                };
+            }
+        }
+    }
+    return { isValid: true };
+}
+function validateMatchUpScore(sets, matchUpFormat, matchUpStatus) {
+    if (!sets || sets.length === 0) {
+        return { isValid: true };
+    }
+    const bestOfMatch = matchUpFormat?.match(/SET(\d+)/)?.[1];
+    const bestOfSets = bestOfMatch ? Number.parseInt(bestOfMatch) : 3;
+    const hasIncompleteSet = sets.some((set) => !set.winningSide);
+    const isIrregularEnding = [RETIRED$1, WALKOVER$2, DEFAULTED].includes(matchUpStatus || '');
+    const allowIncomplete = isIrregularEnding || (!matchUpStatus && hasIncompleteSet);
+    for (let i = 0; i < sets.length; i++) {
+        const isDecidingSet = bestOfSets === 1 || i + 1 === bestOfSets;
+        const setValidation = validateSetScore(sets[i], matchUpFormat, isDecidingSet, allowIncomplete);
+        if (!setValidation.isValid) {
+            return {
+                isValid: false,
+                error: `Set ${i + 1}: ${setValidation.error}`,
+            };
+        }
+    }
+    return { isValid: true };
+}
+
 function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }) {
     const sets = score?.sets ?? [];
     const completedSets = sets?.filter((set) => set?.winningSide) || [];
@@ -32126,7 +32332,9 @@ function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, win
         return counts;
     }, [0, 0]);
     const matchUpWinningSideIndex = winningSide ? winningSide - 1 : undefined;
-    const matchUpLosingSideIndex = matchUpWinningSideIndex !== undefined ? 1 - matchUpWinningSideIndex : undefined;
+    const matchUpLosingSideIndex = matchUpWinningSideIndex !== undefined && [0, 1].includes(matchUpWinningSideIndex)
+        ? 1 - matchUpWinningSideIndex
+        : undefined;
     const winningSideSetsCount = matchUpWinningSideIndex !== undefined && setsWinCounts[matchUpWinningSideIndex];
     const losingSideSetsCount = matchUpLosingSideIndex !== undefined && setsWinCounts[matchUpLosingSideIndex];
     const matchUpScoringFormat = matchUpFormat ? parse(matchUpFormat) : undefined;
@@ -32289,32 +32497,69 @@ function getHighTiebreakValue(params) {
     return tiebreakTo;
 }
 
-function parseScoreString({ tiebreakTo = 7, scoreString = '' }) {
+function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
+    let isTiebreakOnlyFormat = false;
+    if (matchUpFormat) {
+        try {
+            const parsed = parse(matchUpFormat);
+            const tiebreakSetTo = parsed?.setFormat?.tiebreakSet?.tiebreakTo;
+            const regularSetTo = parsed?.setFormat?.setTo;
+            isTiebreakOnlyFormat = !!tiebreakSetTo && !regularSetTo;
+        }
+        catch (e) {
+        }
+    }
     return scoreString
         ?.split(' ')
         .filter(Boolean)
         .map((set, index) => parseSet({ set, setNumber: index + 1 }));
     function parseSet({ set, setNumber }) {
         const inParentheses = /\(([^)]+)\)/;
-        const inBrackets = /\[([^)]+)\]/;
+        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 = tiebreak ? tiebreak[1] : undefined;
-        const side1TiebreakPerspective = setTiebreakLowScore &&
-            getTiebreakComplement({
-                lowValue: setTiebreakLowScore,
-                isSide1: winningSide === 2,
-                tiebreakTo,
-            });
-        const setTiebreak = side1TiebreakPerspective ?? [];
-        const [side1Score, side2Score] = setScores || [];
-        const [side1TiebreakScore, side2TiebreakScore] = matchTiebreak || setTiebreak || [];
+        const bracketed = inBrackets.exec(set);
+        const isTiebreakOnlySet = set?.startsWith('[') && bracketed;
+        let side1Score;
+        let side2Score;
+        let side1TiebreakScore;
+        let side2TiebreakScore;
+        let winningSide;
+        if (isTiebreakOnlySet) {
+            const bracketedScores = bracketed[1].split('-').map((score) => parseInt(score));
+            if (isTiebreakOnlyFormat) {
+                side1Score = bracketedScores[0];
+                side2Score = bracketedScores[1];
+                winningSide = (side1Score > side2Score && 1) || (side1Score < side2Score && 2) || undefined;
+            }
+            else {
+                side1TiebreakScore = bracketedScores[0];
+                side2TiebreakScore = bracketedScores[1];
+                winningSide = (side1TiebreakScore > side2TiebreakScore && 1) || (side1TiebreakScore < side2TiebreakScore && 2) || undefined;
+            }
+        }
+        else {
+            const setString = (tiebreak && set.replace(tiebreak[0], '')) || (bracketed && set.replace(bracketed[0], '')) || set;
+            const setScores = setString.split('-').map((score) => parseInt(score));
+            side1Score = setScores[0];
+            side2Score = setScores[1];
+            winningSide = (side1Score > side2Score && 1) || (side1Score < side2Score && 2) || undefined;
+            if (tiebreak) {
+                const setTiebreakLowScore = tiebreak[1];
+                const side1TiebreakPerspective = getTiebreakComplement({
+                    lowValue: setTiebreakLowScore,
+                    isSide1: winningSide === 2,
+                    tiebreakTo,
+                });
+                if (Array.isArray(side1TiebreakPerspective)) {
+                    [side1TiebreakScore, side2TiebreakScore] = side1TiebreakPerspective;
+                }
+            }
+            if (bracketed && !isTiebreakOnlySet) {
+                const matchTiebreakScores = bracketed[1].split('-').map((score) => parseInt(score));
+                side1TiebreakScore = matchTiebreakScores[0];
+                side2TiebreakScore = matchTiebreakScores[1];
+            }
+        }
         return {
             side1Score,
             side2Score,
@@ -32596,7 +32841,9 @@ var query$a = {
     getTiebreakComplement: getTiebreakComplement,
     isValidMatchUpFormat: isValidMatchUpFormat,
     parseScoreString: parseScoreString,
+    validateMatchUpScore: validateMatchUpScore,
     validateScore: validateScore,
+    validateSetScore: validateSetScore,
     validateTieFormat: validateTieFormat
 };
 
@@ -32631,7 +32878,9 @@ var scoreGovernor = {
     tidyScore: tidyScore,
     umo: umo,
     undo: undo,
+    validateMatchUpScore: validateMatchUpScore,
     validateScore: validateScore,
+    validateSetScore: validateSetScore,
     validateTieFormat: validateTieFormat
 };
 
@@ -38487,6 +38736,42 @@ function checkDrawTypeIsAllowed(params) {
     return { ...SUCCESS };
 }
 
+function hydrateRoundNames(params) {
+    const { drawDefinition, appliedPolicies } = params;
+    const roundNamingPolicy = appliedPolicies?.[POLICY_TYPE_ROUND_NAMING];
+    const matchUpsMap = getMatchUpsMap({ drawDefinition });
+    drawDefinition.structures?.forEach((structure) => {
+        const matchUps = getMappedStructureMatchUps({
+            structureId: structure.structureId,
+            matchUpsMap,
+        });
+        const result = getRoundContextProfile({
+            roundNamingPolicy,
+            drawDefinition,
+            structure,
+            matchUps,
+        });
+        const { roundNamingProfile, roundProfile } = result;
+        const structures = structure.structures || [structure];
+        structures.forEach((itemStructure) => {
+            (itemStructure.matchUps ?? []).forEach((matchUp) => {
+                const roundNumber = matchUp?.roundNumber?.toString();
+                if (roundNumber) {
+                    const roundName = roundNamingProfile?.[roundNumber]?.roundName;
+                    const abbreviatedRoundName = roundNamingProfile?.[roundNumber]?.abbreviatedRoundName;
+                    const feedRound = roundProfile?.[roundNumber]?.feedRound;
+                    Object.assign(matchUp, {
+                        abbreviatedRoundName,
+                        feedRound,
+                        roundName,
+                    });
+                }
+            });
+        });
+    });
+    return { drawDefinition };
+}
+
 function generateDrawDefinition(params) {
     const { voluntaryConsolation, tournamentRecord, event } = params;
     const stack = 'generateDrawDefinition';
@@ -38561,38 +38846,8 @@ function generateDrawDefinition(params) {
     }
     if (params.hydrateRoundNames) {
         const roundNamingPolicy = appliedPolicies?.[POLICY_TYPE_ROUND_NAMING];
-        if (roundNamingPolicy) {
-            const matchUpsMap = getMatchUpsMap({ drawDefinition });
-            drawDefinition.structures?.forEach((structure) => {
-                const matchUps = getMappedStructureMatchUps({
-                    structureId: structure.structureId,
-                    matchUpsMap,
-                });
-                const result = getRoundContextProfile({
-                    roundNamingPolicy,
-                    drawDefinition,
-                    structure,
-                    matchUps,
-                });
-                const { roundNamingProfile, roundProfile } = result;
-                const structures = structure.structures || [structure];
-                structures.forEach((itemStructure) => {
-                    (itemStructure.matchUps ?? []).forEach((matchUp) => {
-                        const roundNumber = matchUp?.roundNumber?.toString();
-                        if (roundNumber) {
-                            const roundName = roundNamingProfile?.[roundNumber]?.roundName;
-                            const abbreviatedRoundName = roundNamingProfile?.[roundNumber]?.abbreviatedRoundName;
-                            const feedRound = roundProfile?.[roundNumber]?.feedRound;
-                            Object.assign(matchUp, {
-                                abbreviatedRoundName,
-                                feedRound,
-                                roundName,
-                            });
-                        }
-                    });
-                });
-            });
-        }
+        if (roundNamingPolicy)
+            hydrateRoundNames({ drawDefinition, appliedPolicies });
     }
     return {
         existingDrawDefinition: !!existingDrawDefinition,
@@ -45982,8 +46237,7 @@ function progressExitStatus({ sourceMatchUpStatusCodes, propagateExitStatus, sou
         color: 'magenta',
         method: stack,
     });
-    const carryOverMatchUpStatus = (isExit(sourceMatchUpStatus) && (sourceMatchUpStatus !== RETIRED$1) && sourceMatchUpStatus)
-        || WALKOVER$2;
+    const carryOverMatchUpStatus = (isExit(sourceMatchUpStatus) && sourceMatchUpStatus !== RETIRED$1 && sourceMatchUpStatus) || WALKOVER$2;
     const inContextMatchUps = getAllDrawMatchUps({
         inContext: true,
         drawDefinition,
@@ -46848,7 +47102,22 @@ function generateOutcomeFromScoreString(params) {
         };
     if (winningSide && ![1, 2, undefined].includes(winningSide))
         return { error: INVALID_VALUES, winningSide };
-    const neutralParsedSets = scoreString && parseScoreString({ scoreString });
+    const neutralParsedSets = scoreString && parseScoreString({ scoreString, matchUpFormat });
+    const isBracketNotation = scoreString?.trim().startsWith('[');
+    let inferredWinningSide = winningSide;
+    if (!inferredWinningSide && matchUpFormat && neutralParsedSets) {
+        const setsWon = { side1: 0, side2: 0 };
+        neutralParsedSets.forEach((set) => {
+            if (set.winningSide === 1)
+                setsWon.side1++;
+            else if (set.winningSide === 2)
+                setsWon.side2++;
+        });
+        if (setsWon.side1 > setsWon.side2)
+            inferredWinningSide = 1;
+        else if (setsWon.side2 > setsWon.side1)
+            inferredWinningSide = 2;
+    }
     const score = {};
     const winningScoreString = generateScoreString({
         sets: neutralParsedSets,
@@ -46861,7 +47130,11 @@ function generateOutcomeFromScoreString(params) {
         matchUpFormat,
         setTBlast,
     });
-    if (winningSide === 2) {
+    if (isBracketNotation) {
+        score.scoreStringSide1 = winningScoreString;
+        score.scoreStringSide2 = losingScoreString;
+    }
+    else if (inferredWinningSide === 2) {
         score.scoreStringSide1 = losingScoreString;
         score.scoreStringSide2 = winningScoreString;
     }
@@ -46869,11 +47142,11 @@ function generateOutcomeFromScoreString(params) {
         score.scoreStringSide1 = winningScoreString;
         score.scoreStringSide2 = losingScoreString;
     }
-    score.sets = parseScoreString({ scoreString: score.scoreStringSide1 });
+    score.sets = parseScoreString({ scoreString: score.scoreStringSide1, matchUpFormat });
     return definedAttributes({
         outcome: {
             matchUpStatus,
-            winningSide,
+            winningSide: inferredWinningSide,
             score,
         },
     });
@@ -57258,6 +57531,24 @@ var generate$1 = {
     createTournamentRecord: createTournamentRecord
 };
 
+function hydrateTournamentRecord(params) {
+    const { tournamentRecord, eventProfiles = [], directives, policyDefinitions } = params;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const events = tournamentRecord.events || [];
+    events.forEach((event) => {
+        const eventProfile = eventProfiles.find((ep) => ep.eventId && ep.eventId === event.eventId);
+        if (eventProfile?.directives?.hydrateRoundNames || directives?.hydrateRoundNames) {
+            event.drawDefinitions?.forEach((drawDefinition) => {
+                const roundNamingPolicy = eventProfile?.policyDefinitions?.[POLICY_TYPE_ROUND_NAMING] || policyDefinitions?.[POLICY_TYPE_ROUND_NAMING];
+                if (roundNamingPolicy)
+                    hydrateRoundNames({ drawDefinition, appliedPolicies: policyDefinitions });
+            });
+        }
+    });
+    return { tournamentRecord };
+}
+
 const ABANDONED = 'ABANDONED';
 const ACTIVE = 'ACTIVE';
 const CANCELLED = 'CANCELLED';
@@ -57649,6 +57940,7 @@ var mutate$1 = {
     addTimeItem: addTimeItem,
     addTournamentExtension: addTournamentExtension,
     addTournamentTimeItem: addTournamentTimeItem,
+    hydrateTournamentRecord: hydrateTournamentRecord,
     removeDrawDefinitionExtension: removeDrawDefinitionExtension,
     removeEventExtension: removeEventExtension,
     removeExtension: removeExtension,
@@ -57696,6 +57988,7 @@ var index$3 = {
     getTournamentPoints: getTournamentPoints,
     getTournamentStructures: getTournamentStructures,
     getTournamentTimeItem: getTournamentTimeItem,
+    hydrateTournamentRecord: hydrateTournamentRecord,
     mutate: mutate$1,
     query: query$7,
     removeDrawDefinitionExtension: removeDrawDefinitionExtension,