tods-competition-factory 7.3.1 → 7.4.0

package/dist/esm/mutate/drawDefinitions/matchUpGovernor/noDownstreamDependencies.mjs

@@ -8,6 +8,7 @@ import { checkConnectedStructures } from './checkConnectedStructures.mjs';
 import { attemptToSetWinningSide } from './attemptToSetWinningSide.mjs';
 import { decorateResult } from '../../../functions/global/decorateResult.mjs';
 import { attemptToModifyScore } from './attemptToModifyScore.mjs';
+import { unwindDualDoubleExit } from './unwindDualDoubleExit.mjs';
 import { pushGlobalLog } from '../../../functions/global/globalLog.mjs';
 import { isExit, isDoubleExit } from '../../../validators/isExit.mjs';
 import { removeDoubleExit } from './removeDoubleExit.mjs';
@@ -25,6 +26,9 @@ function noDownstreamDependencies(params) {
         if (result.error)
             return decorateResult({ result, stack });
     }
+    const dualUnwound = unwindDualDoubleExit(params);
+    if (dualUnwound.error)
+        return decorateResult({ result: dualUnwound, stack });
     const doubleExit = isDoubleExit(matchUpStatus);
     const preserveScoreStatuses = [IN_PROGRESS, SUSPENDED, CANCELLED, ABANDONED, INCOMPLETE];
     const scoreWithNoWinningSide = checkScoreHasValue({ score }) &&

package/dist/esm/mutate/drawDefinitions/matchUpGovernor/removeDoubleExit.mjs

@@ -1,18 +1,17 @@
-import { withdrawByeClaim, withdrawByeClaimsFrom, byeClaimSurvives, getSideExitProvenance, retainPolicyCodes, setSideExitProvenance, retainForeignProvenance, deriveExitStateFromProvenance } from '../../matchUps/matchUpStatus/sideExitProvenance.mjs';
 import { removeDirectedBye, removeDirectedWinner } from '../../matchUps/drawPositions/removeDirectedParticipants.mjs';
 import { propagatesByeOnDoubleExit } from '../../matchUps/drawPositions/propagatesByeOnDoubleExit.mjs';
 import { getPairedPreviousMatchUp } from '../../../query/matchUps/getPairedPreviousMatchup.mjs';
 import { modifyMatchUpScore } from '../../matchUps/score/modifyMatchUpScore.mjs';
 import { decorateResult } from '../../../functions/global/decorateResult.mjs';
-import { chunkArray, intersection, overlap } from '../../../tools/arrays.mjs';
 import { positionTargets } from '../../../query/matchUp/positionTargets.mjs';
 import { pushGlobalLog } from '../../../functions/global/globalLog.mjs';
 import { findStructure } from '../../../acquire/findStructure.mjs';
+import { intersection, overlap } from '../../../tools/arrays.mjs';
 import { isDoubleExit } from '../../../validators/isExit.mjs';
-import { FIRST_MATCHUP } from '../../../constants/drawDefinitionConstants.mjs';
+import { withdrawByeClaim, withdrawByeClaimsFrom, byeClaimSurvives, getSideExitProvenance, retainPolicyCodes, setSideExitProvenance, retainForeignProvenance, deriveExitStateFromProvenance } from '../../matchUps/matchUpStatus/sideExitProvenance.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';
 import { completedMatchUpStatuses } from '../../../constants/matchUpStatusConstants.mjs';
-import { BYE, DOUBLE_DEFAULT, DOUBLE_WALKOVER, DEFAULTED, WALKOVER, TO_BE_PLAYED } from '../../../constants/matchUpStatusValues.mjs';
+import { BYE, DOUBLE_WALKOVER, DOUBLE_DEFAULT, DEFAULTED, WALKOVER, TO_BE_PLAYED } from '../../../constants/matchUpStatusValues.mjs';
 
 const keyColors = {
     drawPositionToRemove: 'green',
@@ -61,19 +60,6 @@ function removeDoubleExit(params) {
     const claimSideNumber = (rawLoserMatchUp?.drawPositions ?? []).indexOf(loserTargetDrawPosition) + 1 || 1;
     withdrawByeClaim({ matchUp: rawLoserMatchUp, sideNumber: claimSideNumber, claimantMatchUpId: matchUpId });
     withdrawByeClaimsFrom({ matchUps: matchUpsMap?.drawMatchUps, claimantMatchUpId: matchUpId });
-    const isFMLC = targetData?.targetLinks?.loserTargetLink?.linkCondition === FIRST_MATCHUP;
-    if (byePropagatedToLoserMatchUp && isFMLC) {
-        const roundMatchUps = inContextDrawMatchUps.filter(({ roundNumber, structureId }) => structureId === matchUp.structureId && roundNumber === 1);
-        const roundPositions = roundMatchUps.map(({ roundPosition }) => roundPosition);
-        const pairedPositions = chunkArray(roundPositions.toSorted((a, b) => a - b), 2).find((chunk) => chunk.includes(matchUp.roundPosition));
-        const pairedMatchUpStatuses = roundMatchUps
-            .filter(({ roundPosition }) => pairedPositions.includes(roundPosition))
-            ?.map(({ matchUpStatus }) => matchUpStatus);
-        const pairedMatchUpIsDoubleExit = pairedMatchUpStatuses.every((matchUpStatus) => [DOUBLE_DEFAULT, DOUBLE_WALKOVER].includes(matchUpStatus));
-        if (pairedMatchUpIsDoubleExit) {
-            return decorateResult({ result: { ...SUCCESS }, stack });
-        }
-    }
     if (loserMatchUp && (loserMatchUp.matchUpStatus !== BYE || byePropagatedToLoserMatchUp)) {
         const inContextLoserMatchUp = inContextDrawMatchUps.find(({ matchUpId }) => matchUpId === loserMatchUp.matchUpId);
         const { structure: loserStructure } = findStructure({

package/dist/esm/mutate/drawDefinitions/matchUpGovernor/unwindDualDoubleExit.mjs

@@ -0,0 +1,13 @@
+import { removeDoubleExit } from './removeDoubleExit.mjs';
+import { isDoubleExit } from '../../../validators/isExit.mjs';
+import { SUCCESS } from '../../../constants/resultConstants.mjs';
+
+function unwindDualDoubleExit(params) {
+    const { isCollectionMatchUp, dualMatchUp, matchUpsMap } = params;
+    if (!isCollectionMatchUp || !isDoubleExit(dualMatchUp?.matchUpStatus))
+        return { ...SUCCESS };
+    const rawDual = matchUpsMap?.drawMatchUps?.find((candidate) => candidate.matchUpId === dualMatchUp.matchUpId) ?? dualMatchUp;
+    return removeDoubleExit({ ...params, matchUp: rawDual });
+}
+
+export { unwindDualDoubleExit };

package/dist/esm/mutate/drawDefinitions/positionGovernor/doubleExitAdvancement.mjs

@@ -773,6 +773,13 @@ function getExitArrivalSideNumber({ inContextDrawMatchUps, nextWinnerMatchUp, so
     if (nextWinnerMatchUp.feedRound) {
         return sourceMatchUp.structureId === nextWinnerMatchUp.structureId ? 2 : 1;
     }
+    const sourcePositions = (sourceMatchUp.drawPositions ?? []).filter(Boolean);
+    const targetPositions = (nextWinnerMatchUp.drawPositions ?? []).filter(Boolean);
+    if (targetPositions.length === 2) {
+        const seated = nextWinnerMatchUp.sides?.find((side) => side?.sideNumber && side.drawPosition && sourcePositions.includes(side.drawPosition));
+        if (seated)
+            return seated.sideNumber;
+    }
     const feeders = inContextDrawMatchUps
         .filter(({ winnerMatchUpId, loserMatchUpId }) => winnerMatchUpId === nextWinnerMatchUp.matchUpId || loserMatchUpId === nextWinnerMatchUp.matchUpId)
         .sort((a, b) => a.roundPosition - b.roundPosition);

package/dist/esm/mutate/matchUps/drawPositions/assignDrawPositionBye.mjs

@@ -172,6 +172,22 @@ function assignDrawPositionBye({ byeFromPropagation, provisionalPositioning, pre
         if (result.error)
             return result;
     }
+    else if (matchUp &&
+        roundNumber &&
+        roundNumber > (getInitialRoundNumber({ drawPosition, matchUps }).initialRoundNumber ?? 0)) {
+        const result = assignByeToLoserTarget({
+            byeFromPropagation,
+            inContextDrawMatchUps,
+            preserveScheduling,
+            tournamentRecord,
+            drawDefinition,
+            matchUpsMap,
+            matchUp,
+            event,
+        });
+        if (result?.error)
+            return result;
+    }
     modifyPositionAssignmentsNotice({
         tournamentId: tournamentRecord?.tournamentId,
         drawDefinition,
@@ -422,11 +438,6 @@ function advanceWinner({ sourceRoundPosition, byeFromPropagation, drawPositionTo
         context: stack,
         drawDefinition,
     });
-    const { targetLinks: { loserTargetLink }, targetMatchUps: { loserMatchUp, loserTargetDrawPosition }, } = positionTargets({
-        matchUpId: winnerMatchUp.matchUpId,
-        inContextDrawMatchUps,
-        drawDefinition,
-    });
     if (pairedDrawPositionIsBye || drawPositionIsBye) {
         const advancingDrawPosition = pairedDrawPositionIsBye ? drawPositionToAdvance : pairedDrawPosition;
         if (advancingDrawPosition) {
@@ -440,38 +451,55 @@ function advanceWinner({ sourceRoundPosition, byeFromPropagation, drawPositionTo
                 matchUpsMap,
             });
         }
-        else if (drawPositionIsBye && loserTargetLink && loserMatchUp) {
-            if (loserMatchUp.feedRound) {
-                assignFedDrawPositionBye({
-                    byeFromPropagation,
-                    loserTargetDrawPosition,
-                    preserveScheduling,
-                    tournamentRecord,
-                    loserTargetLink,
-                    drawDefinition,
-                    loserMatchUp,
-                    matchUpsMap,
-                });
-            }
-            else {
-                const sourceStructureRoundPosition = winnerMatchUp.roundPosition;
-                const targetDrawPositionIndex = 1 - (sourceStructureRoundPosition % 2);
-                const targetDrawPosition = loserMatchUp.drawPositions[targetDrawPositionIndex];
-                const result = assignDrawPositionBye({
-                    byeFromPropagation,
-                    structureId: loserTargetLink.target.structureId,
-                    drawPosition: targetDrawPosition,
-                    preserveScheduling,
-                    tournamentRecord,
-                    drawDefinition,
-                    event,
-                });
-                if (result.error)
-                    return result;
-            }
+        else if (drawPositionIsBye) {
+            const result = assignByeToLoserTarget({
+                matchUp: winnerMatchUp,
+                byeFromPropagation,
+                inContextDrawMatchUps,
+                preserveScheduling,
+                tournamentRecord,
+                drawDefinition,
+                matchUpsMap,
+                event,
+            });
+            if (result?.error)
+                return result;
         }
     }
 }
+function assignByeToLoserTarget({ byeFromPropagation, inContextDrawMatchUps, preserveScheduling, tournamentRecord, drawDefinition, matchUpsMap, matchUp, event, }) {
+    const { targetLinks: { loserTargetLink }, targetMatchUps: { loserMatchUp, loserTargetDrawPosition }, } = positionTargets({
+        matchUpId: matchUp.matchUpId,
+        inContextDrawMatchUps,
+        drawDefinition,
+    });
+    if (!loserTargetLink || !loserMatchUp)
+        return { ...SUCCESS };
+    if (loserMatchUp.feedRound) {
+        return assignFedDrawPositionBye({
+            byeFromPropagation,
+            loserTargetDrawPosition,
+            preserveScheduling,
+            tournamentRecord,
+            loserTargetLink,
+            drawDefinition,
+            loserMatchUp,
+            matchUpsMap,
+        });
+    }
+    const sourceStructureRoundPosition = matchUp.roundPosition;
+    const targetDrawPositionIndex = 1 - (sourceStructureRoundPosition % 2);
+    const targetDrawPosition = loserMatchUp.drawPositions[targetDrawPositionIndex];
+    return assignDrawPositionBye({
+        byeFromPropagation,
+        structureId: loserTargetLink.target.structureId,
+        drawPosition: targetDrawPosition,
+        preserveScheduling,
+        tournamentRecord,
+        drawDefinition,
+        event,
+    });
+}
 function arrivalIntoProvenanceOnlyExit({ existingDrawPositions, drawPositionToAdvance, pairedDrawPositionIsBye, sourceRoundPosition, drawPositionIsBye, holdsParticipant, inContextMatchUp, matchUp, ...context }) {
     const exitSides = Object.keys(matchUp.sideExitProvenance ?? {}).map(Number);
     const applies = isExit(matchUp.matchUpStatus) &&

package/dist/esm/mutate/matchUps/drawPositions/positionClear.mjs

@@ -1,7 +1,7 @@
-import { retainByeClaimsOnly, clearSideExitProvenance } from '../matchUpStatus/sideExitProvenance.mjs';
 import { modifyRoundRobinMatchUpsStatus } from '../matchUpStatus/modifyRoundRobinMatchUpsStatus.mjs';
 import { modifyPositionAssignmentsNotice, modifyMatchUpNotice } from '../../notifications/drawNotifications.mjs';
 import { structureAssignedDrawPositions, getPositionAssignments } from '../../../query/drawDefinition/positionsGetter.mjs';
+import { releaseLinkedWinnerAdvancement } from './releaseLinkedWinnerAdvancement.mjs';
 import { getStructureDrawPositionProfiles } from '../../../query/structure/getStructureDrawPositionProfiles.mjs';
 import { normalizeDrawPositions } from './normalizeDrawPositions.mjs';
 import { getAllStructureMatchUps } from '../../../query/matchUps/getAllStructureMatchUps.mjs';
@@ -15,6 +15,7 @@ import { pushGlobalLog } from '../../../functions/global/globalLog.mjs';
 import { findStructure } from '../../../acquire/findStructure.mjs';
 import { ensureInt } from '../../../tools/ensureInt.mjs';
 import { overlap } from '../../../tools/arrays.mjs';
+import { clearSideExitProvenance, deriveExitStateFromProvenance, retainByeClaimsOnly } from '../matchUpStatus/sideExitProvenance.mjs';
 import { BYE, TO_BE_PLAYED } from '../../../constants/matchUpStatusValues.mjs';
 import { CONTAINER, DRAW } from '../../../constants/drawDefinitionConstants.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';
@@ -80,7 +81,6 @@ function drawPositionRemovals({ inContextDrawMatchUps, tournamentRecord, drawDef
         drawDefinition,
         structure,
     }).positionAssignments ?? [];
-    const withdrawsPropagatedBye = positionAssignments.some((assignment) => assignment.drawPosition === drawPosition && assignment.bye && assignment.byeFromPropagation);
     const drawPositionCleared = positionAssignments.some((assignment) => {
         if (assignment.drawPosition === drawPosition) {
             delete assignment.participantId;
@@ -123,7 +123,6 @@ function drawPositionRemovals({ inContextDrawMatchUps, tournamentRecord, drawDef
             return;
         }
         removeSubsequentRoundsParticipant({
-            withdrawsPropagatedBye,
             inContextDrawMatchUps,
             targetDrawPosition,
             tournamentRecord,
@@ -133,7 +132,6 @@ function drawPositionRemovals({ inContextDrawMatchUps, tournamentRecord, drawDef
             matchUpsMap,
         });
         removeDrawPosition({
-            withdrawsPropagatedBye,
             inContextDrawMatchUps,
             positionAssignments,
             tournamentRecord,
@@ -147,7 +145,7 @@ function drawPositionRemovals({ inContextDrawMatchUps, tournamentRecord, drawDef
     });
     return { tasks, drawPositionCleared, positionAssignments };
 }
-function removeSubsequentRoundsParticipant({ withdrawsPropagatedBye, inContextDrawMatchUps, targetDrawPosition, tournamentRecord, drawDefinition, matchUpsMap, roundNumber, structureId, }) {
+function removeSubsequentRoundsParticipant({ inContextDrawMatchUps, targetDrawPosition, tournamentRecord, drawDefinition, matchUpsMap, roundNumber, structureId, }) {
     const { structure } = findStructure({ drawDefinition, structureId });
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
@@ -169,7 +167,6 @@ function removeSubsequentRoundsParticipant({ withdrawsPropagatedBye, inContextDr
     }).positionAssignments ?? [];
     relevantMatchUps?.forEach((matchUp) => removeDrawPosition({
         drawPosition: targetDrawPosition,
-        withdrawsPropagatedBye,
         targetMatchUp: matchUp,
         inContextDrawMatchUps,
         positionAssignments,
@@ -180,7 +177,7 @@ function removeSubsequentRoundsParticipant({ withdrawsPropagatedBye, inContextDr
     }));
     return { ...SUCCESS };
 }
-function removeDrawPosition({ withdrawsPropagatedBye, inContextDrawMatchUps, positionAssignments, tournamentRecord, drawDefinition, targetMatchUp, drawPosition, matchUpsMap, structure, event, }) {
+function removeDrawPosition({ inContextDrawMatchUps, positionAssignments, tournamentRecord, drawDefinition, targetMatchUp, drawPosition, matchUpsMap, structure, event, }) {
     const stack = 'removeDrawPosition';
     const initialDrawPositions = targetMatchUp.drawPositions?.slice();
     const initialMatchUpStatus = targetMatchUp.matchUpStatus;
@@ -192,13 +189,26 @@ function removeDrawPosition({ withdrawsPropagatedBye, inContextDrawMatchUps, pos
         drawPosition,
         matchUps,
     });
-    const keepsByeAdvancement = !!withdrawsPropagatedBye &&
-        advancedByOpponentsBye({ matchUps: matchUps ?? [], positionAssignments, targetMatchUp, drawPosition });
+    const keepsByeAdvancement = advancedByOpponentsBye({
+        matchUps: matchUps ?? [],
+        positionAssignments,
+        targetMatchUp,
+        drawPosition,
+    });
     if (!keepsByeAdvancement &&
         targetMatchUp.roundNumber &&
         initialRoundNumber &&
         targetMatchUp.roundNumber > initialRoundNumber) {
         targetMatchUp.drawPositions = normalizeDrawPositions((targetMatchUp.drawPositions ?? []).map((currentDrawPosition) => currentDrawPosition === drawPosition ? undefined : currentDrawPosition));
+        releaseLinkedWinnerAdvancement({
+            roundNumber: targetMatchUp.roundNumber,
+            structureId: structure.structureId,
+            tournamentRecord,
+            drawDefinition,
+            drawPosition,
+            matchUpsMap,
+            event,
+        });
     }
     handleTeamPositionRemoval({
         inContextDrawMatchUps,
@@ -313,11 +323,18 @@ function updateMatchUpStatusAfterRemoval({ initialDrawPositions, initialMatchUpS
     targetMatchUp.winningSide = undefined;
     if (targetMatchUp.matchUpStatusCodes?.length)
         targetMatchUp.matchUpStatusCodes = [];
-    const retainedClaims = retainByeClaimsOnly(targetMatchUp.sideExitProvenance);
-    clearSideExitProvenance(targetMatchUp);
-    if (retainedClaims)
-        targetMatchUp.sideExitProvenance = retainedClaims;
     const removedDrawPosition = initialDrawPositions?.find((position) => !targetMatchUp.drawPositions?.includes(position));
+    const clearedIndex = initialDrawPositions?.indexOf(drawPosition) ?? -1;
+    const clearedSideNumber = clearedIndex >= 0 ? clearedIndex + 1 : undefined;
+    const retained = retainProvenanceBesideRemoval(targetMatchUp.sideExitProvenance, clearedSideNumber);
+    clearSideExitProvenance(targetMatchUp);
+    if (retained)
+        targetMatchUp.sideExitProvenance = retained;
+    const rederived = !matchUpContainsBye && retained ? deriveExitStateFromProvenance(retained) : undefined;
+    if (rederived) {
+        targetMatchUp.matchUpStatus = rederived.matchUpStatus;
+        targetMatchUp.winningSide = rederived.winningSide;
+    }
     const noChange = initialDrawPositions?.includes(drawPosition) &&
         initialMatchUpStatus === targetMatchUp.matchUpStatus &&
         initialWinningSide === targetMatchUp.winningSide;
@@ -340,6 +357,23 @@ function updateMatchUpStatusAfterRemoval({ initialDrawPositions, initialMatchUpS
     }
     return matchUpContainsBye;
 }
+function retainProvenanceBesideRemoval(provenance, clearedSideNumber) {
+    if (!provenance)
+        return undefined;
+    if (!clearedSideNumber)
+        return retainByeClaimsOnly(provenance);
+    const retained = {};
+    for (const sideNumber of [1, 2]) {
+        const entry = provenance[sideNumber];
+        if (!entry)
+            continue;
+        if (sideNumber !== clearedSideNumber)
+            retained[sideNumber] = { ...entry };
+        else if (entry.byeClaims?.length)
+            retained[sideNumber] = { byeClaims: [...entry.byeClaims] };
+    }
+    return Object.keys(retained).length ? retained : undefined;
+}
 function handleLoserMatchUpRemoval({ loserMatchUpDrawPositionIndex, inContextDrawMatchUps, tournamentRecord, drawDefinition, loserMatchUp, matchUpsMap, event, stack, }) {
     const { drawPositions, roundNumber } = loserMatchUp;
     if (roundNumber === 1) {

package/dist/esm/mutate/matchUps/matchUpStatus/reconcileDecider.mjs

@@ -4,7 +4,8 @@ import { getAllDrawMatchUps } from '../../../query/matchUps/drawMatchUps.mjs';
 import { positionTargets } from '../../../query/matchUp/positionTargets.mjs';
 import { getMatchUpsMap } from '../../../query/matchUps/getMatchUpsMap.mjs';
 import { findStructure } from '../../../acquire/findStructure.mjs';
-import { DEAD_RUBBER, TO_BE_PLAYED } from '../../../constants/matchUpStatusValues.mjs';
+import { isAnyExit } from '../../../validators/isExit.mjs';
+import { BYE, DEAD_RUBBER, TO_BE_PLAYED } from '../../../constants/matchUpStatusValues.mjs';
 import { WINNER, LOSER } from '../../../constants/drawDefinitionConstants.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';
 
@@ -38,6 +39,8 @@ function reconcileDecider({ winningSideBefore, tournamentRecord, drawDefinition,
     const holdsAResult = !!decider.winningSide || !!decider.score?.sets?.length;
     if (!holdsAResult && decider.matchUpStatus === matchUpStatus)
         return { ...SUCCESS };
+    if (!holdsAResult && (decider.matchUpStatus === BYE || isAnyExit(decider.matchUpStatus)))
+        return { ...SUCCESS };
     return modifyMatchUpScore({
         matchUpId: decider.matchUpId,
         removeWinningSide: true,

package/dist/esm/mutate/matchUps/matchUpStatus/setMatchUpState.mjs

@@ -1,13 +1,12 @@
-import { feedEligibilityChange } from './feedEligibilityGuard.mjs';
 import { noDownstreamDependencies } from '../../drawDefinitions/matchUpGovernor/noDownstreamDependencies.mjs';
 import { generateTieMatchUpScore } from '../../../assemblies/generators/tieMatchUpScore/generateTieMatchUpScore.mjs';
 import { isNonDirectingMatchUpStatus, isDirectingMatchUpStatus } from '../../../query/matchUp/checkStatusType.mjs';
 import { addMatchUpScheduleItems } from '../schedule/scheduleItems/scheduleItems.mjs';
 import { hasPropagatedExitDownstream } from '../../../query/drawDefinition/hasPropagatedExitDownstream.mjs';
+import { feedEligibilityChange } from './feedEligibilityGuard.mjs';
 import { getProjectedDualWinningSide } from '../../../query/matchUp/getProjectedDualWinningSide.mjs';
-import { updateTieMatchUpScore } from '../score/updateTieMatchUpScore.mjs';
-import { getMatchUpStatusScopeViolation } from '../../../query/matchUps/getMatchUpStatusScopeViolation.mjs';
 import { setFirstClassOrExtension } from '../../extensions/setFirstClassOrExtension.mjs';
+import { updateTieMatchUpScore } from '../score/updateTieMatchUpScore.mjs';
 import { isMatchUpEventType } from '../../../helpers/matchUpEventTypes/isMatchUpEventType.mjs';
 import { resolveTieFormat } from '../../../query/hierarchical/tieFormats/resolveTieFormat.mjs';
 import { swapWinnerLoser } from '../drawPositions/swapWinnerLoser.mjs';
@@ -29,6 +28,7 @@ import { isAdHoc } from '../../../query/drawDefinition/isAdHoc.mjs';
 import { findStructure } from '../../../acquire/findStructure.mjs';
 import { isDoubleExit } from '../../../validators/isExit.mjs';
 import { isObject } from '../../../tools/objects.mjs';
+import { getMatchUpStatusScopeViolation } from '../../../query/matchUps/getMatchUpStatusScopeViolation.mjs';
 import { POLICY_TYPE_PROGRESSION, POLICY_TYPE_SCORING } from '../../../constants/policyConstants.mjs';
 import { DISABLE_AUTO_CALC } from '../../../constants/extensionConstants.mjs';
 import { QUALIFYING } from '../../../constants/drawDefinitionConstants.mjs';
@@ -388,6 +388,14 @@ function resolveAndApplyOutcome({ params, isTeam, dualWinningSideChange, activeD
         winningSide,
     });
     const hasPropagated = !!matchUp.winningSide || isDoubleExit(matchUp.matchUpStatus);
+    if (params.isCollectionMatchUp && isDoubleExit(params.dualMatchUp?.matchUpStatus) && activeDownstream) {
+        return decorateResult({
+            result: { error: CANNOT_CHANGE_OUTCOME },
+            info: 'the dual holds a double exit whose produced result has been played on',
+            context: { dualMatchUpId: params.dualMatchUp.matchUpId, dualMatchUpStatus: params.dualMatchUp.matchUpStatus },
+            stack,
+        });
+    }
     let result;
     if (!activeDownstream || !hasPropagated) {
         result = noDownstreamDependencies(params);

package/dist/esm/mutate/venues/modifyCourt.mjs

@@ -39,7 +39,7 @@ function courtModification({ tournamentRecord, disableNotice, venueMatchUps, mod
         return { error: INVALID_OBJECT };
     const result = findCourt({ tournamentRecord, courtId });
     if (result.error)
-        return result;
+        return { error: result.error };
     const { venue, court } = result;
     const validAttributes = Object.keys(courtTemplate()).filter((attribute) => attribute !== 'courtId');
     const validModificationAttributes = Object.keys(modifications).filter((attribute) => validAttributes.includes(attribute));

package/dist/esm/package.json.mjs

@@ -1,3 +1,3 @@
-var version = "7.3.1";
+var version = "7.4.0";
 
 export { version };

package/dist/esm/query/matchUp/checkSetIsComplete.mjs

@@ -15,10 +15,9 @@ function checkSetIsComplete({ ignoreTiebreak = false, matchUpScoringFormat, matc
     const requiresTiebreak = isTiebreakSet ||
         (side1Score >= setTo && side2Score >= setTo) ||
         (tiebreakAt && tiebreakAt < setTo && (side1Score === tiebreakAt || side2Score === tiebreakAt));
-    const tiebreakIsValid = ignoreTiebreak ||
-        (requiresTiebreak &&
-            ((leadingSide === 1 && set.side1TiebreakScore > set.side2TiebreakScore) ||
-                (leadingSide === 2 && set.side2TiebreakScore > set.side1TiebreakScore)));
+    const leaderHoldsTiebreak = (leadingSide === 1 && set.side1TiebreakScore > set.side2TiebreakScore) ||
+        (leadingSide === 2 && set.side2TiebreakScore > set.side1TiebreakScore);
+    const tiebreakIsValid = ignoreTiebreak || (requiresTiebreak && leaderHoldsTiebreak && tiebreakReachesTarget(set, setFormat, isTiebreakSet));
     const declaredWinBy = setFormat.winBy;
     const winMargin = (!requiresTiebreak && setFormat.NoAD) || requiresTiebreak || (isTiebreakSet && setFormat.tiebreakFormat?.NoAD)
         ? 1
@@ -28,6 +27,16 @@ function checkSetIsComplete({ ignoreTiebreak = false, matchUpScoringFormat, matc
     return !!(((isTimedSet && hasScore) || validNormalSetScore || isTiebreakSet) &&
         (!requiresTiebreak || tiebreakIsValid));
 }
+function tiebreakReachesTarget(set, setFormat, isTiebreakSet) {
+    const tiebreakFormat = isTiebreakSet ? setFormat?.tiebreakSet : setFormat?.tiebreakFormat;
+    const tiebreakTo = tiebreakFormat?.tiebreakTo;
+    if (typeof tiebreakTo !== 'number')
+        return true;
+    const high = Math.max(set.side1TiebreakScore ?? 0, set.side2TiebreakScore ?? 0);
+    const low = Math.min(set.side1TiebreakScore ?? 0, set.side2TiebreakScore ?? 0);
+    const margin = tiebreakFormat?.NoAD ? 1 : Math.min(2, tiebreakTo);
+    return high >= tiebreakTo && high - low >= margin;
+}
 function getLeadingSide({ set }) {
     if (set.side1Score || set.side2Score) {
         if (set.side1Score > set.side2Score)

package/dist/esm/query/matchUp/getComplement.mjs

@@ -76,7 +76,7 @@ const getMaxSetScore = (params) => {
     if (tiebreakAt < setTo)
         return setTo;
     const ceiling = setTo + 1;
-    if (opponentScore !== undefined && opponentScore < setTo)
+    if (opponentScore !== undefined && opponentScore < setTo - 1)
         return setTo;
     return ceiling;
 };

package/dist/esm/validators/validateMatchUpScore.mjs

@@ -144,6 +144,17 @@ function parseSetScores(set, isTiebreakOnlyFormat, hasTiebreakScores) {
     const side2Score = isTiebreakOnlyFormat && hasTiebreakScores ? side2TiebreakScore : set.side2Score || set.side2 || 0;
     return { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore };
 }
+function validateTiebreakWinner(side1Score, side2Score, side1TiebreakScore, side2TiebreakScore) {
+    if (side1TiebreakScore === undefined || side2TiebreakScore === undefined)
+        return undefined;
+    if (side1Score === side2Score || side1TiebreakScore === side2TiebreakScore)
+        return undefined;
+    const gamesWinner = side1Score > side2Score ? 1 : 2;
+    const pointsWinner = side1TiebreakScore > side2TiebreakScore ? 1 : 2;
+    if (gamesWinner === pointsWinner)
+        return undefined;
+    return { isValid: false, error: `Set winner must win the tiebreak: side ${gamesWinner} won the set` };
+}
 function validateTiebreakSet(winnerScore, loserScore, setTo, tiebreakAt, side1TiebreakScore, side2TiebreakScore, tiebreakFormat) {
     if (setTo && tiebreakAt) {
         const validation = validateTiebreakSetGames(winnerScore, loserScore, setTo, tiebreakAt);
@@ -226,6 +237,9 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     const isImplicitTiebreak = setTo && winnerScore === setTo + 1 && loserScore === setTo;
     const hasTiebreak = hasExplicitTiebreak || isImplicitTiebreak;
     if (hasTiebreak) {
+        const contradiction = validateTiebreakWinner(side1Score, side2Score, side1TiebreakScore, side2TiebreakScore);
+        if (contradiction)
+            return contradiction;
         return validateTiebreakSet(winnerScore, loserScore, setTo, tiebreakAt, side1TiebreakScore, side2TiebreakScore, tiebreakFormat);
     }
     return validateRegularSet({ side1: side1Score, side2: side2Score, winner: winnerScore, loser: loserScore, diff: scoreDiff }, { setTo, tiebreakAt, NoAD: setFormat.NoAD, winBy: setFormat.winBy }, allowIncomplete);