tods-competition-factory 2.2.29 → 2.2.31

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.29';
+    return '2.2.31';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -1870,7 +1870,9 @@ function decorateResult({ context, result, stack, info }) {
         result.info = info;
     }
     if (result && typeof context === 'object' && Object.keys(context).length) {
-        Object.assign(result, definedAttributes(context));
+        if (!result.context)
+            result.context = {};
+        Object.assign(result.context, definedAttributes(context));
     }
     if (result && !result?.error && !result?.success) {
         Object.assign(result, { ...SUCCESS });
@@ -12235,62 +12237,6 @@ function getInitialRoundNumber({ drawPosition, matchUps = [] }) {
     return { initialRoundNumber };
 }
 
-const logColors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    dim: '\x1b[2m',
-    red: '\x1b[31m',
-    brightred: '\x1b[91m',
-    green: '\x1b[32m',
-    brightgreen: '\x1b[92m',
-    yellow: '\x1b[33m',
-    brightyellow: '\x1b[93m',
-    blue: '\x1b[34m',
-    brightblue: '\x1b[94m',
-    lightblue: '\x1b[105m',
-    magenta: '\x1b[35m',
-    brightmagenta: '\x1b[95m',
-    cyan: '\x1b[36m',
-    brightcyan: '\x1b[96m',
-    white: '\x1b[37m',
-    brightwhite: '\x1b[97m',
-};
-
-const globalLog = [];
-function pushGlobalLog(value, devContextOverride) {
-    if (isString(value))
-        value = { method: value };
-    if (devContextOverride || getDevContext())
-        globalLog.push(value);
-}
-function getGlobalLog(purge) {
-    const globalLogCopy = globalLog.slice();
-    return globalLogCopy;
-}
-function printGlobalLog(purge) {
-    const globalLogCopy = getGlobalLog();
-    const modifiedText = globalLogCopy.map((line) => {
-        const { color, keyColors, method, newline } = line;
-        const methodColor = Object.keys(logColors).includes(color) ? logColors[color] : logColors.cyan;
-        const bodyKeys = Object.keys(line).filter((key) => !['color', 'keyColors', 'method', 'newline'].includes(key));
-        const body = bodyKeys
-            .map((key) => {
-            const keyColor = keyColors && Object.keys(keyColors).includes(key) && logColors[keyColors[key]]
-                ? logColors[keyColors[key]]
-                : logColors.brightwhite;
-            return `${logColors.white}${key}: ${keyColor}${line[key]}`;
-        })
-            .join(', ');
-        const tabs = method?.length < 15 ? `\t\t` : '\t';
-        return [newline ? '\n' : '', methodColor, method, tabs, logColors.white, body, logColors.reset, '\n'].join('');
-    });
-    if (modifiedText?.length)
-        console.log(...modifiedText);
-}
-function purgeGlobalLog() {
-    globalLog.length = 0;
-}
-
 function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, matchUpsMap, structureId, structure, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -12301,7 +12247,6 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
     if (!structureId)
         ({ structureId } = structure);
     const stack = 'assignDrawPositionBye';
-    pushGlobalLog({ method: stack, color: 'cyan', drawPosition });
     if (!matchUpsMap) {
         matchUpsMap = getMatchUpsMap({ drawDefinition });
     }
@@ -12461,8 +12406,6 @@ function assignRoundRobinBYE({ tournamentRecord, drawDefinition, drawPosition, m
     });
 }
 function advanceDrawPosition({ drawPositionToAdvance, inContextDrawMatchUps, sourceDrawPositions, tournamentRecord, drawDefinition, matchUpsMap, matchUpId, event, }) {
-    const stack = 'advanceDrawPosition';
-    pushGlobalLog({ method: stack, color: 'cyan', drawPositionToAdvance });
     const matchUp = matchUpsMap.drawMatchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
     const inContextMatchUp = inContextDrawMatchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
     const structureId = inContextMatchUp?.structureId;
@@ -12575,14 +12518,6 @@ function advanceWinner({ drawPositionToAdvance, inContextDrawMatchUps, sourceDra
         winningSide: undefined,
         drawPositions,
     });
-    const changedDrawPosition = noContextWinnerMatchUp.drawPositions.find((position) => !twoDrawPositions.includes(position));
-    pushGlobalLog({
-        method: stack,
-        color: 'brightyellow',
-        changedDrawPosition,
-        pairedDrawPositionIsBye,
-        drawPositionIsBye,
-    });
     modifyMatchUpNotice({
         tournamentId: tournamentRecord?.tournamentId,
         matchUp: noContextWinnerMatchUp,
@@ -12637,8 +12572,6 @@ function advanceWinner({ drawPositionToAdvance, inContextDrawMatchUps, sourceDra
 }
 function assignFedDrawPositionBye({ loserTargetDrawPosition, tournamentRecord, loserTargetLink, drawDefinition, loserMatchUp, matchUpsMap, event, }) {
     const { roundNumber } = loserMatchUp;
-    const stack = 'assignFedDrawPositionBye';
-    pushGlobalLog({ method: stack, color: 'cyan', loserTargetDrawPosition });
     const mappedMatchUps = matchUpsMap?.mappedMatchUps || {};
     const loserStructureMatchUps = mappedMatchUps[loserMatchUp.structureId].matchUps;
     const { initialRoundNumber } = getInitialRoundNumber({
@@ -12682,6 +12615,65 @@ function modifyRoundRobinMatchUpsStatus({ positionAssignments, tournamentRecord,
     });
 }
 
+const logColors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    brightred: '\x1b[91m',
+    green: '\x1b[32m',
+    brightgreen: '\x1b[92m',
+    yellow: '\x1b[33m',
+    brightyellow: '\x1b[93m',
+    blue: '\x1b[34m',
+    brightblue: '\x1b[94m',
+    pinkbackground: '\x1b[105m',
+    magenta: '\x1b[35m',
+    brightmagenta: '\x1b[95m',
+    cyan: '\x1b[36m',
+    brightcyan: '\x1b[96m',
+    white: '\x1b[37m',
+    brightwhite: '\x1b[97m',
+};
+
+const globalLog = [];
+function pushGlobalLog(value, devContextOverride) {
+    if (isString(value))
+        value = { method: value };
+    if (devContextOverride || getDevContext())
+        globalLog.push(value);
+}
+function getGlobalLog(purge) {
+    const globalLogCopy = globalLog.slice();
+    return globalLogCopy;
+}
+function printGlobalLog(purge) {
+    const globalLogCopy = getGlobalLog();
+    const modifiedText = globalLogCopy.map((line) => {
+        const { color, keyColors, method, newline } = line;
+        const methodColor = Object.keys(logColors).includes(color) ? logColors[color] : logColors.cyan;
+        const bodyKeys = Object.keys(line).filter((key) => !['color', 'keyColors', 'method', 'newline'].includes(key));
+        const body = bodyKeys
+            .map((key) => {
+            const keyColor = (line[key] === undefined && logColors.red) ||
+                (keyColors &&
+                    Object.keys(keyColors).includes(key) &&
+                    logColors[keyColors[key]] &&
+                    logColors[keyColors[key]]) ||
+                logColors.brightwhite;
+            return `${logColors.white}${key}: ${keyColor}${line[key]}`;
+        })
+            .join(', ');
+        const tabs = (method?.length <= 12 && '\t\t\t') || (method?.length <= 20 && `\t\t`) || '\t';
+        return [newline ? '\n' : '', methodColor, method, tabs, logColors.white, body, logColors.reset, '\n'].join('');
+    });
+    if (modifiedText?.length)
+        console.log(...modifiedText);
+}
+function purgeGlobalLog() {
+    globalLog.length = 0;
+}
+
 function clearDrawPosition(params) {
     let { inContextDrawMatchUps, participantId, drawPosition } = params;
     const { tournamentRecord, drawDefinition, structureId, matchUpsMap, event } = params;
@@ -14673,13 +14665,14 @@ function addDrawEntry(params) {
 function addDrawEntries$1(params) {
     const stack = 'addDrawEntries';
     const { suppressDuplicateEntries = true, entryStatus = DIRECT_ACCEPTANCE, autoEntryPositions = true, ignoreStageSpace, participantIds, drawDefinition, stageSequence, stage = MAIN, roundTarget, extension, event, } = params;
+    const isAdHocDraw = drawDefinition.drawType === AD_HOC;
     if (!stage)
         return { error: MISSING_STAGE };
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (!Array.isArray(participantIds))
         return { error: INVALID_PARTICIPANT_IDS };
-    if (!getValidStage({ stage, drawDefinition })) {
+    if (!isAdHocDraw && !getValidStage({ stage, drawDefinition })) {
         return { error: INVALID_STAGE };
     }
     if (extension && !isValidExtension({ extension })) {
@@ -14696,11 +14689,14 @@ function addDrawEntries$1(params) {
         entryStatus,
         stage,
     });
-    if (!ignoreStageSpace && !spaceAvailable.success) {
+    if (!ignoreStageSpace && !spaceAvailable.success && !isAdHocDraw) {
         return { error: spaceAvailable.error };
     }
     const positionsAvailable = spaceAvailable.positionsAvailable ?? 0;
-    if (!ignoreStageSpace && stage !== VOLUNTARY_CONSOLATION && positionsAvailable < participantIds.length)
+    if (!ignoreStageSpace &&
+        !isAdHocDraw &&
+        stage !== VOLUNTARY_CONSOLATION &&
+        positionsAvailable < participantIds.length)
         return { error: PARTICIPANT_COUNT_EXCEEDS_DRAW_SIZE };
     const duplicateEntries = [];
     const drawId = drawDefinition.drawId;
@@ -16642,6 +16638,7 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
                 [DOUBLE_WALKOVER, DOUBLE_DEFAULT].includes(matchUp.matchUpStatus) &&
                 matchUp.matchUpStatus) ||
             TO_BE_PLAYED;
+    const isWalkover = !!([WALKOVER$2, DEFAULTED].includes(matchUp?.matchUpStatus) && matchUp?.winningSide);
     if (matchUp && positionAdded) {
         inContextDrawMatchUps =
             getAllDrawMatchUps({
@@ -16654,8 +16651,9 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
                 inContextDrawMatchUps,
                 drawPosition,
                 matchUpId,
-            })) ||
-            undefined;
+            }))
+            || (isWalkover && matchUp.winningSide)
+            || undefined;
         if (matchUp?.matchUpStatusCodes) {
             updateMatchUpStatusCodes({
                 inContextDrawMatchUps,
@@ -16668,7 +16666,7 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
         Object.assign(matchUp, {
             drawPositions: updatedDrawPositions,
             winningSide: exitWinningSide,
-            matchUpStatus,
+            matchUpStatus: isWalkover ? matchUp?.matchUpStatus : matchUpStatus,
         });
         modifyMatchUpNotice({
             tournamentId: tournamentRecord?.tournamentId,
@@ -16711,6 +16709,20 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
             }
         }
     }
+    else if (positionAssigned && isWalkover) {
+        if (winnerMatchUp) {
+            const result = assignMatchUpDrawPosition({
+                matchUpId: winnerMatchUp.matchUpId,
+                inContextDrawMatchUps,
+                tournamentRecord,
+                drawDefinition,
+                drawPosition,
+                matchUpsMap,
+            });
+            if (result.error)
+                return result;
+        }
+    }
     else if (winnerMatchUp && inContextMatchUp && !inContextMatchUp.feedRound) {
         const { pairedPreviousMatchUpIsDoubleExit } = getPairedPreviousMatchUpIsDoubleExit({
             targetMatchUp: matchUp,
@@ -23188,7 +23200,7 @@ function modifyMatchUpScore(params) {
 }
 
 function attemptToModifyScore(params) {
-    const { matchUpStatusCodes, matchUpStatus, structure, matchUp, dualMatchUp, inContextMatchUp, autoCalcDisabled } = params;
+    const { matchUpStatusCodes, matchUpStatus, structure, matchUp, dualMatchUp, inContextMatchUp, autoCalcDisabled, propagateExitStatus, } = params;
     const matchUpStatusIsValid = isDirectingMatchUpStatus({ matchUpStatus }) ||
         ([CANCELLED$1, ABANDONED$1].includes(matchUpStatus) && dualMatchUp) ||
         autoCalcDisabled;
@@ -23198,13 +23210,15 @@ function attemptToModifyScore(params) {
     const hasAdHocSides = (isAdHoc({ structure }) && participantsCount === 1) || (matchUpStatus === DEFAULTED && participantsCount);
     const validToScore = hasAdHocSides ||
         drawPositionsAssignedParticipantIds({ structure, matchUp, inContextMatchUp }) ||
-        params.appliedPolicies?.[POLICY_TYPE_SCORING]?.requireParticipantsForScoring === false;
+        params.appliedPolicies?.[POLICY_TYPE_SCORING]?.requireParticipantsForScoring === false ||
+        ([WALKOVER$2, DEFAULTED].includes(matchUpStatus) && participantsCount === 1 && propagateExitStatus);
     if (!validToScore)
         return decorateResult({ result: { error: MISSING_ASSIGNMENTS }, stack });
     const removeScore = [WALKOVER$2].includes(matchUpStatus);
     const updatedMatchUpStatus = matchUpStatusIsValid ? matchUpStatus : (params.winningSide && COMPLETED$1) || INCOMPLETE;
     const result = modifyMatchUpScore({
         ...params,
+        winningSide: params.winningSide,
         matchUpStatusCodes: (matchUpStatusIsValid && matchUpStatusCodes) || [],
         matchUpStatus: updatedMatchUpStatus,
         removeScore,
@@ -23720,7 +23734,7 @@ function directWinner({ winnerMatchUpDrawPositionIndex, inContextDrawMatchUps, p
             if (structure?.stage !== QUALIFYING) {
                 const error = 'winner target position unavaiallble';
                 console.log(error);
-                return { error };
+                decorateResult({ stack, result: { error } });
             }
         }
         if (structure?.seedAssignments && structure.structureId !== targetStructureId) {
@@ -23784,7 +23798,7 @@ function directWinner({ winnerMatchUpDrawPositionIndex, inContextDrawMatchUps, p
 }
 
 function directLoser(params) {
-    const { loserMatchUpDrawPositionIndex, inContextDrawMatchUps, projectedWinningSide, sourceMatchUpStatus, loserDrawPosition, tournamentRecord, loserTargetLink, drawDefinition, loserMatchUp, dualMatchUp, matchUpsMap, event, } = params;
+    const { loserMatchUpDrawPositionIndex, inContextDrawMatchUps, projectedWinningSide, propagateExitStatus, sourceMatchUpStatus, loserDrawPosition, tournamentRecord, loserTargetLink, drawDefinition, loserMatchUp, dualMatchUp, matchUpsMap, event, } = params;
     const stack = 'directLoser';
     const loserLinkCondition = loserTargetLink.linkCondition;
     const targetMatchUpDrawPositions = loserMatchUp.drawPositions || [];
@@ -23818,15 +23832,17 @@ function directLoser(params) {
     });
     const relevantAssignment = sourcePositionAssignments?.find((assignment) => assignment.drawPosition === loserDrawPosition);
     const loserParticipantId = relevantAssignment?.participantId;
+    const context = { loserParticipantId };
     const targetStructureId = loserTargetLink.target.structureId;
     const { positionAssignments: targetPositionAssignments } = structureAssignedDrawPositions({
         structureId: targetStructureId,
         drawDefinition,
     });
     const targetMatchUpPositionAssignments = targetPositionAssignments?.filter(({ drawPosition }) => targetMatchUpDrawPositions.includes(drawPosition));
-    const loserAlreadyDirected = targetMatchUpPositionAssignments?.some((assignment) => assignment.participantId === loserParticipantId);
+    const loserAlreadyDirected = targetMatchUpPositionAssignments?.some((assignment) => assignment.participantId && loserParticipantId && assignment.participantId === loserParticipantId);
+    const validExitToPropagate = propagateExitStatus && [RETIRED$1, WALKOVER$2, DEFAULTED].includes(sourceMatchUpStatus || '');
     if (loserAlreadyDirected) {
-        return { ...SUCCESS };
+        return { ...SUCCESS, stack };
     }
     const unfilledTargetMatchUpDrawPositions = targetMatchUpPositionAssignments
         ?.filter((assignment) => {
@@ -23840,11 +23856,15 @@ function directLoser(params) {
     const isFirstRoundValidDrawPosition = loserTargetLink.target.roundNumber === 1 && targetDrawPositionIsUnfilled;
     if (fedDrawPositionFMLC) {
         const result = loserLinkFedFMLC();
+        if (result.context)
+            Object.assign(context, result.context);
         if (result.error)
             return decorateResult({ result, stack });
     }
     else if (isFirstRoundValidDrawPosition) {
         const result = asssignLoserDrawPosition();
+        if (result.context)
+            Object.assign(context, result.context);
         if (result.error)
             return decorateResult({ result, stack });
     }
@@ -23864,6 +23884,9 @@ function directLoser(params) {
         });
         if (result.error)
             return decorateResult({ result, stack });
+        if (!result.error && validExitToPropagate && propagateExitStatus) {
+            return { stack, context: { progressExitStatus: true, loserParticipantId } };
+        }
     }
     else {
         const error = !targetDrawPositionIsUnfilled ? DRAW_POSITION_OCCUPIED : INVALID_DRAW_POSITION;
@@ -23912,7 +23935,7 @@ function directLoser(params) {
             }
         }
     }
-    return { ...SUCCESS };
+    return { ...SUCCESS, stack, context };
     function loserLinkFedFMLC() {
         const stack = 'loserLinkFedFMLC';
         if (validForConsolation) {
@@ -23946,6 +23969,9 @@ function directLoser(params) {
                 event,
             })
             : { error: MISSING_PARTICIPANT_ID };
+        if (!result.error && validExitToPropagate && propagateExitStatus) {
+            return { stack, context: { progressExitStatus: true } };
+        }
         return decorateResult({ result, stack: 'assignLoserDrawPosition' });
     }
 }
@@ -23958,7 +23984,7 @@ function directParticipants(params) {
     const matchUpStatusIsValid = isDirectingMatchUpStatus({
         matchUpStatus: params.matchUpStatus,
     });
-    const { dualWinningSideChange, projectedWinningSide, inContextDrawMatchUps, tournamentRecord, drawDefinition, matchUpStatus, dualMatchUp, matchUpsMap, winningSide, targetData, matchUpId, structure, matchUp, event, } = params;
+    const { dualWinningSideChange, inContextDrawMatchUps, projectedWinningSide, propagateExitStatus, matchUpStatusCodes, tournamentRecord, drawDefinition, matchUpStatus, dualMatchUp, matchUpsMap, winningSide, targetData, matchUpId, structure, matchUp, event, } = params;
     const isCollectionMatchUp = Boolean(matchUp.collectionId);
     const isAdHocMatchUp = isAdHoc({ structure });
     let drawPositions = matchUp.drawPositions;
@@ -23988,6 +24014,7 @@ function directParticipants(params) {
         const losingIndex = 1 - winningIndex;
         const winningDrawPosition = drawPositions[winningIndex];
         const loserDrawPosition = drawPositions[losingIndex];
+        const context = {};
         const { targetLinks: { loserTargetLink, winnerTargetLink, byeTargetLink }, targetMatchUps: { winnerMatchUpDrawPositionIndex, loserMatchUpDrawPositionIndex, winnerMatchUp, loserMatchUp, byeMatchUp, }, } = targetData;
         if (winnerMatchUp) {
             const result = directWinner({
@@ -24014,6 +24041,7 @@ function directParticipants(params) {
                 loserMatchUpDrawPositionIndex,
                 inContextDrawMatchUps,
                 projectedWinningSide,
+                propagateExitStatus,
                 loserDrawPosition,
                 tournamentRecord,
                 loserTargetLink,
@@ -24023,6 +24051,14 @@ function directParticipants(params) {
                 dualMatchUp,
                 event,
             });
+            if (result.context?.progressExitStatus) {
+                Object.assign(context, result.context, {
+                    sourceMatchUpStatus: (matchUpStatusIsValid && matchUpStatus) || COMPLETED$1,
+                    sourceMatchUpStatusCodes: matchUpStatusCodes || [],
+                    loserMatchUp,
+                    matchUpsMap,
+                });
+            }
             if (result.error)
                 return decorateResult({ result, stack });
         }
@@ -24040,11 +24076,11 @@ function directParticipants(params) {
             if (result.error)
                 return decorateResult({ result, stack });
         }
+        return decorateResult({ result: { ...SUCCESS, ...annotate }, stack, context });
     }
     else {
         return decorateResult({ result: { error: MISSING_DRAW_POSITIONS }, stack });
     }
-    return decorateResult({ result: { ...SUCCESS, ...annotate }, stack });
 }
 
 function generateAndPopulatePlayoffStructures(params) {
@@ -25596,7 +25632,7 @@ function getValidModifyAssignedPairAction({ tournamentParticipants, returnPartic
 }
 
 function isActiveDownstream(params) {
-    const { inContextDrawMatchUps, targetData, drawDefinition, relevantLink } = params;
+    const { inContextDrawMatchUps, targetData, drawDefinition, relevantLink, matchUpStatus, score, winningSide } = params;
     const fmlcBYE = relevantLink?.linkCondition === FIRST_MATCHUP && targetData?.matchUp?.matchUpStatus === BYE;
     if (fmlcBYE)
         return false;
@@ -25611,11 +25647,19 @@ function isActiveDownstream(params) {
     const loserIndex = loserTargetData?.targetMatchUps?.loserMatchUpDrawPositionIndex;
     const propagatedLoserParticipant = loserExitPropagation?.sides[loserIndex]?.participant;
     const loserMatchUpExit = [DEFAULTED, WALKOVER$2].includes(loserMatchUp?.matchUpStatus) && !propagatedLoserParticipant;
+    const loserMatchUpParticipantsCount = loserMatchUp?.sides?.reduce((acc, current) => (current?.participant ? ++acc : acc), 0) ?? 0;
+    const isLoserMatchUpAPropagatedExitStatus = loserMatchUp?.winningSide &&
+        [DEFAULTED, WALKOVER$2].includes(loserMatchUp?.matchUpStatus) &&
+        propagatedLoserParticipant &&
+        loserMatchUpParticipantsCount === 1;
+    const isClearScore = matchUpStatus === TO_BE_PLAYED && score?.scoreStringSide1 === '' && score?.scoreStringSide2 === '' && !winningSide;
     const winnerDrawPositionsCount = winnerMatchUp?.drawPositions?.filter(Boolean).length || 0;
-    if ((loserMatchUp?.winningSide && !loserMatchUpExit) ||
-        (winnerMatchUp?.winningSide &&
-            winnerDrawPositionsCount === 2 &&
-            (!winnerMatchUp.feedRound || ![WALKOVER$2, DEFAULTED].includes(winnerMatchUp?.matchUpStatus)))) {
+    if ((isLoserMatchUpAPropagatedExitStatus && isClearScore) ||
+        (!isLoserMatchUpAPropagatedExitStatus &&
+            ((loserMatchUp?.winningSide && !loserMatchUpExit) ||
+                (winnerMatchUp?.winningSide &&
+                    winnerDrawPositionsCount === 2 &&
+                    (!winnerMatchUp.feedRound || ![WALKOVER$2, DEFAULTED].includes(winnerMatchUp?.matchUpStatus)))))) {
         return true;
     }
     const winnerTargetData = winnerMatchUp &&
@@ -43379,11 +43423,6 @@ function removeDirectedLoser({ sourceMatchUpStatus, loserParticipantId, tourname
 function removeDirectedBye({ inContextDrawMatchUps, tournamentRecord, drawDefinition, drawPosition, matchUpsMap, targetLink, event, }) {
     const structureId = targetLink.target.structureId;
     const stack = 'removeDirectedBye';
-    pushGlobalLog({
-        color: 'brightyellow',
-        method: stack,
-        drawPosition,
-    });
     const result = clearDrawPosition({
         inContextDrawMatchUps,
         tournamentRecord,
@@ -43453,7 +43492,8 @@ function doubleExitAdvancement(params) {
         !loserMatchUp.sides?.map((side) => side.participantId ?? side.participant).filter(Boolean).length;
     if (loserMatchUp && loserMatchUp.matchUpStatus !== BYE) {
         const { loserTargetLink } = targetLinks;
-        if (appliedPolicies?.progression?.doubleExitPropagateBye) {
+        if (appliedPolicies?.progression?.doubleExitPropagateBye ||
+            (loserMatchUp.feedRound && loserMatchUp.sides?.[0]?.participantFed)) {
             const result = advanceByeToLoserMatchUp({
                 loserTargetDrawPosition,
                 tournamentRecord,
@@ -43773,8 +43813,9 @@ function attemptToSetMatchUpStatus(params) {
         (!directing && { error: UNRECOGNIZED_MATCHUP_STATUS }) ||
         (isDoubleExit && modifyScoreAndAdvanceDoubleExit(params)) ||
         (teamRoundRobinContext && scoreModification$1(params)) ||
+        (params.propagateExitStatus && scoreModification$1(params)) ||
         decorateResult({
-            result: { error: INVALID_MATCHUP_STATUS },
+            result: { error: INVALID_MATCHUP_STATUS, info: 'matchUpStatus: ' + matchUpStatus },
             stack,
         }));
 }
@@ -43986,6 +44027,7 @@ function placeQualifier(params) {
 function attemptToSetWinningSide(params) {
     const stack = 'attemptToSetWinningSide';
     let connectedStructures;
+    const context = {};
     const { appliedPolicies, disableAutoCalc, drawDefinition, dualMatchUp, winningSide, structure, matchUp } = params;
     if (dualMatchUp?._disableAutoCalc && disableAutoCalc !== false) {
         return attemptToModifyScore(params);
@@ -44005,6 +44047,8 @@ function attemptToSetWinningSide(params) {
             return result;
     }
     const result = directParticipants(params);
+    if (result.context?.progressExitStatus)
+        Object.assign(context, result.context);
     if (result.error)
         return decorateResult({ result, stack });
     let qualifierReplaced, qualifierPlaced;
@@ -44021,41 +44065,19 @@ function attemptToSetWinningSide(params) {
             connectedStructures,
             qualifierReplaced,
             qualifierPlaced,
+            context,
         }),
         stack,
     });
 }
 
-const keyColors = {
-    drawPositionToRemove: 'green',
-    iteration: 'brightred',
-    winner: 'green',
-    loser: 'brightred',
-};
 function removeDoubleExit(params) {
     const { inContextDrawMatchUps, appliedPolicies, drawDefinition, matchUpsMap, targetData, matchUp } = params;
-    const { matchUpId } = matchUp;
     let { iteration = 0 } = params;
     iteration += 1;
     const stack = 'removeDoubleExit';
-    pushGlobalLog({
-        color: 'brightyellow',
-        method: stack,
-        matchUpId,
-        iteration,
-        keyColors,
-    });
     const { targetMatchUps: { loserMatchUp, winnerMatchUp, loserTargetDrawPosition }, targetLinks: { loserTargetLink }, } = targetData;
     if (winnerMatchUp && winnerMatchUp.matchUpStatus !== BYE) {
-        const { stage, roundNumber, roundPosition, structureName } = winnerMatchUp;
-        pushGlobalLog({
-            winner: 'winner',
-            roundPosition,
-            structureName,
-            roundNumber,
-            keyColors,
-            stage,
-        });
         conditionallyRemoveDrawPosition({
             ...params,
             targetMatchUp: winnerMatchUp,
@@ -44083,16 +44105,6 @@ function removeDoubleExit(params) {
             drawDefinition,
             structureId: inContextLoserMatchUp.structureId,
         });
-        const { stage, roundNumber, roundPosition, feedRound, structureName } = loserMatchUp;
-        pushGlobalLog({
-            loser: 'loser',
-            roundPosition,
-            structureName,
-            roundNumber,
-            keyColors,
-            feedRound,
-            stage,
-        });
         if (appliedPolicies?.progression?.doubleExitPropagateBye || byePropagatedToLoserMatchUp) {
             removeDirectedBye({
                 drawPosition: loserTargetDrawPosition,
@@ -44118,7 +44130,6 @@ function removeDoubleExit(params) {
 function conditionallyRemoveDrawPosition(params) {
     const { inContextDrawMatchUps, appliedPolicies, drawDefinition, sourceMatchUp, targetMatchUp, matchUpsMap, structure, iteration, } = params;
     const stack = 'conditionallyRemoveDrawPosition';
-    pushGlobalLog({ method: stack, structureName: structure?.structureName, iteration });
     const nextTargetData = positionTargets({
         matchUpId: targetMatchUp.matchUpId,
         inContextDrawMatchUps,
@@ -44158,17 +44169,6 @@ function conditionallyRemoveDrawPosition(params) {
         }
     }
     if (nextWinnerMatchUp && drawPositionToRemove) {
-        const { stage, roundNumber, roundPosition, structureName } = nextWinnerMatchUp;
-        pushGlobalLog({
-            method: 'removeDirectedWinner',
-            drawPositionToRemove,
-            color: 'brightgreen',
-            roundPosition,
-            structureName,
-            roundNumber,
-            keyColors,
-            stage,
-        });
         removeDirectedWinner({
             winningDrawPosition: drawPositionToRemove,
             winnerMatchUp: nextWinnerMatchUp,
@@ -44295,7 +44295,6 @@ function noDownstreamDependencies(params) {
     const removeScore = params.removeScore || (!timedTieMatchUp && ![INCOMPLETE, ABANDONED$1].includes(matchUpStatus || INCOMPLETE));
     const removeWinningSide = (params.isCollectionMatchUp && params.dualMatchUp.winningSide && !params.projectedWinningSide) ||
         (matchUp.winningSide && !winningSide && !checkScoreHasValue({ score }));
-    const statusNotTBP = matchUpStatus && matchUpStatus !== TO_BE_PLAYED;
     const removeDirected = (removeScore) => {
         let connectedStructures;
         const { structure, drawDefinition, dualMatchUp, disableAutoCalc } = params;
@@ -44325,9 +44324,11 @@ function noDownstreamDependencies(params) {
         return scoreModification(params);
     }
     const triggerDualWinningSide = [CANCELLED$1, ABANDONED$1].includes(matchUpStatus) && params.dualWinningSideChange;
-    const result = ((winningSide || triggerDualWinningSide) && attemptToSetWinningSide(params)) ||
+    const statusNotToBePlayed = matchUpStatus && matchUpStatus !== TO_BE_PLAYED;
+    const propagateExitStatus = params.propagateExitStatus && [WALKOVER$2, DEFAULTED].includes(matchUpStatus);
+    const result = ((winningSide || triggerDualWinningSide || propagateExitStatus) && attemptToSetWinningSide(params)) ||
         (scoreWithNoWinningSide && removeDirected(removeScore)) ||
-        (statusNotTBP && attemptToSetMatchUpStatus(params)) ||
+        (statusNotToBePlayed && attemptToSetMatchUpStatus(params)) ||
         (removeWinningSide && removeDirected(removeScore)) ||
         (matchUp && scoreModification({ ...params, removeScore: true })) || {
         ...SUCCESS,
@@ -45154,10 +45155,10 @@ function swapWinnerLoser(params) {
 }
 
 function setMatchUpState(params) {
-    const stack = 'setMatchUpStatus';
+    const stack = 'setMatchUpState';
     if (params.matchUpStatus && [WALKOVER$2, DOUBLE_WALKOVER].includes(params.matchUpStatus))
         params.score = undefined;
-    const { allowChangePropagation, disableScoreValidation, tournamentRecords, tournamentRecord, disableAutoCalc, enableAutoCalc, drawDefinition, matchUpStatus, winningSide, matchUpId, event, score, } = params;
+    const { allowChangePropagation, disableScoreValidation, propagateExitStatus, tournamentRecords, tournamentRecord, disableAutoCalc, enableAutoCalc, drawDefinition, matchUpStatus, winningSide, matchUpId, event, score, } = params;
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (matchUpStatus && [CANCELLED$1, INCOMPLETE, ABANDONED$1, TO_BE_PLAYED].includes(matchUpStatus) && winningSide)
@@ -45287,6 +45288,7 @@ function setMatchUpState(params) {
         Object.assign(appliedPolicies, params.policyDefinitions);
     const participantCheck = checkParticipants({
         assignedDrawPositions,
+        propagateExitStatus,
         inContextMatchUp,
         appliedPolicies,
         drawDefinition,
@@ -45399,12 +45401,6 @@ function setMatchUpState(params) {
         return swapWinnerLoser(params);
     }
     const matchUpWinner = (winningSide && !matchUpTieId) || params.projectedWinningSide;
-    pushGlobalLog({
-        activeDownstream,
-        matchUpWinner,
-        method: stack,
-        winningSide,
-    });
     const result = (!activeDownstream && noDownstreamDependencies(params)) ||
         (matchUpWinner && winningSideWithDownstreamDependencies(params)) ||
         ((directingMatchUpStatus || params.autoCalcDisabled) && applyMatchUpValues(params)) || {
@@ -45460,7 +45456,7 @@ function applyMatchUpValues(params) {
     }
     return result;
 }
-function checkParticipants({ assignedDrawPositions, inContextMatchUp, appliedPolicies, drawDefinition, matchUpStatus, structure, matchUp, }) {
+function checkParticipants({ assignedDrawPositions, propagateExitStatus, inContextMatchUp, appliedPolicies, drawDefinition, matchUpStatus, structure, matchUp, }) {
     if (appliedPolicies?.[POLICY_TYPE_SCORING]?.requireParticipantsForScoring === false)
         return { ...SUCCESS };
     const participantsCount = inContextMatchUp?.sides?.map((side) => side.participantId).filter(Boolean).length;
@@ -45476,10 +45472,16 @@ function checkParticipants({ assignedDrawPositions, inContextMatchUp, appliedPol
             positionAssignments
                 ?.filter((assignment) => assignedDrawPositions.includes(assignment.drawPosition))
                 .every((assignment) => assignment.participantId));
+    if (matchUpStatus &&
+        [WALKOVER$2, DEFAULTED, DOUBLE_WALKOVER].includes(matchUpStatus) &&
+        participantsCount === 1 &&
+        propagateExitStatus) {
+        return { ...SUCCESS };
+    }
     if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && !requiredParticipants) {
         return decorateResult({
             info: 'matchUpStatus requires assigned participants',
-            context: { matchUpStatus, requiredParticipants },
+            context: { matchUpStatus, requiredParticipants, propagateExitStatus: propagateExitStatus, participantsCount },
             result: { error: INVALID_MATCHUP_STATUS },
         });
     }
@@ -45781,10 +45783,64 @@ function matchUpScore(params) {
     return { score: { sets, scoreStringSide1, scoreStringSide2 } };
 }
 
+function progressExitStatus({ sourceMatchUpStatusCodes, propagateExitStatus, sourceMatchUpStatus, loserParticipantId, tournamentRecord, drawDefinition, loserMatchUp, matchUpsMap, event, }) {
+    const stack = 'progressExitStatus';
+    const carryOverMatchUpStatus = ([WALKOVER$2, DEFAULTED].includes(sourceMatchUpStatus) && sourceMatchUpStatus) || WALKOVER$2;
+    const inContextMatchUps = getAllDrawMatchUps({
+        inContext: true,
+        drawDefinition,
+        matchUpsMap,
+    })?.matchUps;
+    let loserMatchUpStatus = carryOverMatchUpStatus;
+    const updatedLoserMatchUp = inContextMatchUps?.find((m) => m.matchUpId === loserMatchUp?.matchUpId);
+    if (updatedLoserMatchUp?.matchUpId && loserMatchUpStatus) {
+        let winningSide = undefined;
+        const statusCodes = updatedLoserMatchUp.matchUpStatusCodes?.map((sc) => (typeof sc === 'string' ? sc : 'WO')) ?? [];
+        const loserParticipantSide = updatedLoserMatchUp.sides?.find((s) => s.participantId === loserParticipantId);
+        if (loserParticipantSide?.sideNumber) {
+            const participantsCount = updatedLoserMatchUp?.sides?.reduce((count, current) => {
+                return current?.participantId ? count + 1 : count;
+            }, 0);
+            if (participantsCount === 1 && statusCodes.length === 0) {
+                winningSide = loserParticipantSide.sideNumber === 1 ? 2 : 1;
+                statusCodes[0] = sourceMatchUpStatusCodes[0];
+            }
+            else {
+                if (![WALKOVER$2, DEFAULTED].includes(loserMatchUp.matchUpStatus)) {
+                    winningSide = loserParticipantSide.sideNumber === 1 ? 2 : 1;
+                    statusCodes[0] = sourceMatchUpStatusCodes[0];
+                }
+                else {
+                    const currentStatusCode = statusCodes[0];
+                    statusCodes[loserParticipantSide.sideNumber - 1] = sourceMatchUpStatusCodes[0];
+                    const otherSide = loserParticipantSide.sideNumber === 1 ? 2 : 1;
+                    statusCodes[otherSide - 1] = currentStatusCode;
+                    loserMatchUpStatus = DOUBLE_WALKOVER;
+                    winningSide = undefined;
+                }
+            }
+        }
+        const result = setMatchUpState({
+            matchUpStatus: loserMatchUpStatus,
+            matchUpId: loserMatchUp.matchUpId,
+            matchUpStatusCodes: statusCodes,
+            allowChangePropagation: true,
+            propagateExitStatus,
+            tournamentRecord,
+            drawDefinition,
+            winningSide,
+            event,
+        });
+        return decorateResult({ result, stack, context: { progressExitStatus: true } });
+    }
+    return decorateResult({ result: { error: MISSING_MATCHUP }, stack });
+}
+
 function setMatchUpStatus(params) {
     const paramsCheck = checkRequiredParameters(params, [{ [MATCHUP_ID]: true, [DRAW_DEFINITION]: true }]);
     if (paramsCheck.error)
         return paramsCheck;
+    const stack = 'setMatchUpStatus';
     const tournamentRecords = resolveTournamentRecords(params);
     if (!params.drawDefinition) {
         const tournamentRecord = params.tournamentRecord ?? (params.tournamentId && tournamentRecords[params.tournamentId]);
@@ -45796,12 +45852,12 @@ function setMatchUpStatus(params) {
             tournamentRecord,
         });
         if (result.error)
-            return result;
+            return decorateResult({ stack, result });
         if (result.drawDefinition)
             params.drawDefinition = result.drawDefinition;
         params.event = result.event;
     }
-    const { disableScoreValidation, policyDefinitions, tournamentRecord, disableAutoCalc, enableAutoCalc, drawDefinition, matchUpId, schedule, event, notes, } = params;
+    const { disableScoreValidation, propagateExitStatus, policyDefinitions, tournamentRecord, disableAutoCalc, enableAutoCalc, drawDefinition, matchUpId, schedule, event, notes, } = params;
     const matchUpFormat = params.matchUpFormat || params.outcome?.matchUpFormat;
     const { policy } = findPolicy({
         policyType: POLICY_TYPE_SCORING,
@@ -45813,7 +45869,7 @@ function setMatchUpStatus(params) {
         undefined;
     const { outcome, setTBlast } = params;
     if (outcome?.winningSide && ![1, 2].includes(outcome.winningSide)) {
-        return { error: INVALID_WINNING_SIDE };
+        return decorateResult({ result: { error: INVALID_WINNING_SIDE }, stack });
     }
     if (matchUpFormat) {
         const result = setMatchUpMatchUpFormat({
@@ -45824,20 +45880,21 @@ function setMatchUpStatus(params) {
             event,
         });
         if (result.error)
-            return result;
+            return decorateResult({ stack, result });
     }
     if (outcome?.score?.sets && !outcome.score.scoreStringSide1) {
         const { score: scoreObject } = matchUpScore({ ...outcome, setTBlast });
         outcome.score = scoreObject;
         outcome.score.sets = outcome.score.sets.filter((set) => set.side1Score || set.side2Score || set.side1TiebreakScore || set.side2TiebreakScore);
     }
-    return setMatchUpState({
+    const result = setMatchUpState({
         matchUpStatusCodes: outcome?.matchUpStatusCodes,
         matchUpStatus: outcome?.matchUpStatus,
         winningSide: outcome?.winningSide,
         allowChangePropagation,
         disableScoreValidation,
         score: outcome?.score,
+        propagateExitStatus,
         tournamentRecords,
         policyDefinitions,
         tournamentRecord,
@@ -45850,6 +45907,30 @@ function setMatchUpStatus(params) {
         event,
         notes,
     });
+    if (result.context?.progressExitStatus) {
+        let iterate = true;
+        let failsafe = 0;
+        while (iterate && failsafe < 10) {
+            iterate = false;
+            failsafe += 1;
+            const progressResult = progressExitStatus({
+                sourceMatchUpStatusCodes: result.context.sourceMatchUpStatusCodes,
+                sourceMatchUpStatus: result.context.sourceMatchUpStatus,
+                loserParticipantId: result.context.loserParticipantId,
+                propagateExitStatus: params.propagateExitStatus,
+                tournamentRecord: params.tournamentRecord,
+                loserMatchUp: result.context.loserMatchUp,
+                matchUpsMap: result.context.matchUpsMap,
+                drawDefinition: params.drawDefinition,
+                event: params.event,
+            });
+            if (progressResult.context?.loserMatchUp) {
+                Object.assign(result.context, progressResult.context);
+                iterate = true;
+            }
+        }
+    }
+    return decorateResult({ result, stack });
 }
 
 function bulkMatchUpStatusUpdate(params) {
@@ -46972,7 +47053,7 @@ function getGroupedRounds({ scheduledRoundsDetails, greatestAverageMinutes, garm
         if (roundDetails.hash === lastHash || garmanSinglePass) {
             groupedMatchUpIds = groupedMatchUpIds.concat(roundDetails.matchUpIds);
         }
-        if (roundDetails.hash !== lastHash && false) ;
+        if (roundDetails.hash !== lastHash && !garmanSinglePass) ;
         averageMinutes = greatestAverageMinutes ;
         recoveryMinutes = roundDetails.recoveryMinutes;
         roundPeriodLength = roundDetails.roundPeriodLength;