tods-competition-factory 2.2.31 → 2.2.32-beta.1

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.31';
+    return '2.2.32-beta.1';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -653,6 +653,10 @@ const INCOMPATIBLE_MATCHUP_STATUS = {
     message: 'Incompatible matchUpStatus',
     code: 'ERR_INCOMPATIBLE_MATCHUP_STATUS',
 };
+const PROPAGATED_EXITS_DOWNSTREAM = {
+    message: 'Propagated exits downstream',
+    code: 'ERR_PROPAGATED_EXITS_DOWNSTREAM',
+};
 const INVALID_MATCHUP_STATUS = {
     message: 'Invalid matchUpStatus',
     code: 'ERR_INVALID_MATCHUP_STATUS',
@@ -1880,38 +1884,85 @@ function decorateResult({ context, result, stack, info }) {
     return result ?? { success: true };
 }
 
-const ANY = 'ANY';
-const MALE = 'MALE';
-const MIXED = 'MIXED';
-const OTHER$3 = 'OTHER';
+const FEMALE_ABBR = 'F';
+const OTHER_ABBR = 'O';
+const MIXED_ABBR = 'X';
+const MALE_ABBR = 'M';
+const ANY_ABBR = 'A';
 const FEMALE = 'FEMALE';
+const OTHER$3 = 'OTHER';
+const MIXED = 'MIXED';
+const MALE = 'MALE';
+const ANY = 'ANY';
 const genderConstants = {
-    ANY,
-    MALE,
+    FEMALE_ABBR,
+    OTHER_ABBR,
+    MIXED_ABBR,
+    MALE_ABBR,
+    ANY_ABBR,
     FEMALE,
     MIXED,
     OTHER: OTHER$3,
+    MALE,
+    ANY,
 };
 
+function isFemale(gender) {
+    return [FEMALE, FEMALE_ABBR].includes(gender);
+}
+
+function isMale(gender) {
+    return [MALE, MALE_ABBR].includes(gender);
+}
+
+function isMixed(gender) {
+    return [MIXED, MIXED_ABBR].includes(gender);
+}
+
+function isAny(gender) {
+    return [ANY, ANY_ABBR].includes(gender);
+}
+
+function coercedGender(gender) {
+    if (gender) {
+        if (isFemale(gender))
+            return FEMALE;
+        if (isMixed(gender))
+            return MIXED;
+        if (isMale(gender))
+            return MALE;
+        if (isAny(gender))
+            return ANY;
+    }
+    return OTHER$3;
+}
+
+function isGendered(gender) {
+    return isFemale(gender) || isMale(gender);
+}
+
 const mixedGenderError = 'MIXED events can not contain mixed singles or { gender: ANY } collections';
 const anyMixedError = 'events with { gender: ANY } can not contain MIXED singles collections';
 function tieFormatGenderValidityCheck(params) {
     const stack = 'tieFormatGenderValidityCheck';
     const { referenceGender, matchUpType, gender } = params;
-    if (referenceGender && gender && [MALE, FEMALE].includes(referenceGender) && referenceGender !== gender)
+    if (referenceGender &&
+        gender &&
+        isGendered(referenceGender) &&
+        coercedGender(referenceGender) !== coercedGender(gender))
         return decorateResult({
             result: { valid: false, error: INVALID_GENDER },
             context: { gender },
             stack,
         });
-    if (referenceGender === MIXED && (gender === ANY || (gender === MIXED && matchUpType !== DOUBLES$1))) {
+    if (isMixed(referenceGender) && (isAny(gender) || (isMixed(gender) && matchUpType !== DOUBLES$1))) {
         return decorateResult({
             result: { error: INVALID_GENDER, valid: false },
             info: mixedGenderError,
             stack,
         });
     }
-    if (referenceGender === ANY && gender === MIXED && matchUpType !== DOUBLES$1)
+    if (isAny(referenceGender) && isMixed(gender) && matchUpType !== DOUBLES$1)
         return decorateResult({
             result: { error: INVALID_GENDER, valid: false },
             info: anyMixedError,
@@ -12237,7 +12288,67 @@ function getInitialRoundNumber({ drawPosition, matchUps = [] }) {
     return { initialRoundNumber };
 }
 
-function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, matchUpsMap, structureId, structure, event, }) {
+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 isExit(matchUpStatus) {
+    return [DEFAULTED, WALKOVER$2].includes(matchUpStatus);
+}
+
+function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, loserMatchUp, matchUpsMap, structureId, structure, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (!structure)
@@ -12247,6 +12358,7 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
     if (!structureId)
         ({ structureId } = structure);
     const stack = 'assignDrawPositionBye';
+    pushGlobalLog({ method: stack, color: 'cyan', drawPosition });
     if (!matchUpsMap) {
         matchUpsMap = getMatchUpsMap({ drawDefinition });
     }
@@ -12259,8 +12371,9 @@ 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 drawPositionIsActive = activeDrawPositions?.includes(drawPosition);
-    if (drawPositionIsActive) {
+    if (drawPositionIsActive && !hasPropagatedStatus) {
         return { error: DRAW_POSITION_ACTIVE };
     }
     const positionAssignment = positionAssignments?.find((assignment) => assignment.drawPosition === drawPosition);
@@ -12269,7 +12382,7 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
     const { filled, containsBye, assignedParticipantId } = drawPositionFilled(positionAssignment);
     if (containsBye)
         return { ...SUCCESS };
-    if (filled && !containsBye) {
+    if (filled && !containsBye && !hasPropagatedStatus) {
         return decorateResult({ result: { error: DRAW_POSITION_ASSIGNED }, stack });
     }
     const appliedPolicies = getAppliedPolicies({
@@ -12293,6 +12406,9 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
     positionAssignments?.forEach((assignment) => {
         if (assignment.drawPosition === drawPosition) {
             assignment.bye = true;
+            if (hasPropagatedStatus) {
+                assignment.participantId = undefined;
+            }
         }
     });
     if (structure.structureType === CONTAINER) {
@@ -12406,6 +12522,8 @@ 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;
@@ -12518,6 +12636,14 @@ 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,
@@ -12572,6 +12698,8 @@ 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({
@@ -12615,65 +12743,6 @@ 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;
@@ -12904,12 +12973,10 @@ function removeDrawPosition$1({ inContextDrawMatchUps, positionAssignments, tour
     const matchUpAssignments = positionAssignments.filter(({ drawPosition }) => targetMatchUp.drawPositions?.includes(drawPosition));
     const matchUpContainsBye = matchUpAssignments.filter((assignment) => assignment.bye).length;
     const newMatchUpStatus = (matchUpContainsBye && BYE) ||
-        (targetMatchUp.matchUpStatus &&
-            [DEFAULTED, WALKOVER$2].includes(targetMatchUp.matchUpStatus) &&
-            targetMatchUp.matcHUpStatus) ||
+        (targetMatchUp.matchUpStatus && isExit(targetMatchUp.matchUpStatus) && targetMatchUp.matcHUpStatus) ||
         TO_BE_PLAYED;
     targetMatchUp.matchUpStatus = newMatchUpStatus;
-    if (targetMatchUp.matchUpStatus && [WALKOVER$2, DEFAULTED].includes(targetMatchUp.matchUpStatus))
+    if (targetMatchUp.matchUpStatus && isExit(targetMatchUp.matchUpStatus))
         targetMatchUp.winningSide = undefined;
     const removedDrawPosition = initialDrawPositions?.find((position) => !targetMatchUp.drawPositions?.includes(position));
     const noChange = initialDrawPositions?.includes(drawPosition) &&
@@ -14189,7 +14256,7 @@ function getParticipantEntries(params) {
                     const scheduledMinutes = timeStringMinutes$1(scheduledTime);
                     for (const consideredItem of scheduleItemsToConsider) {
                         const ignoreItem = consideredItem.matchUpId === scheduleItem.matchUpId ||
-                            ([WALKOVER$2, DEFAULTED].includes(consideredItem.matchUpStatus) && !consideredItem.checkScoreHasValue);
+                            (isExit(consideredItem.matchUpStatus) && !consideredItem.checkScoreHasValue);
                         if (ignoreItem)
                             continue;
                         const typeChange = scheduleItem.matchUpType !== consideredItem.matchUpType;
@@ -14974,21 +15041,32 @@ function addEventEntries(params) {
         if (validSingles &&
             (!event.gender ||
                 !genderEnforced ||
-                [MIXED, ANY].includes(event.gender) ||
-                event.gender === participant.person?.sex)) {
+                isMixed(event.gender) ||
+                isAny(event.gender) ||
+                coercedGender(event.gender) === coercedGender(participant.person?.sex))) {
             return true;
         }
         if (validDoubles && !isUngrouped(entryStatus)) {
             return true;
         }
         if (event.eventType === DOUBLES$1 && participant.participantType === INDIVIDUAL && isUngrouped(entryStatus)) {
+            if (event.gender &&
+                genderEnforced &&
+                !(isMixed(event.gender) || isAny(event.gender)) &&
+                coercedGender(event.gender) !== coercedGender(participant.person?.sex)) {
+                mismatchedGender.push({
+                    participantId: participant.participantId,
+                    sex: participant.person?.sex,
+                });
+                return false;
+            }
             return true;
         }
         if (validSingles &&
             event.gender &&
             genderEnforced &&
-            ![MIXED, ANY].includes(event.gender) &&
-            event.gender !== participant.person?.sex) {
+            !(isMixed(event.gender) || isAny(event.gender)) &&
+            coercedGender(event.gender) !== coercedGender(participant.person?.sex)) {
             mismatchedGender.push({
                 participantId: participant.participantId,
                 sex: participant.person?.sex,
@@ -16627,9 +16705,7 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
     });
     const matchUpAssignments = positionAssignments?.filter((assignment) => updatedDrawPositions.includes(assignment.drawPosition));
     const isByeMatchUp = matchUpAssignments?.find(({ bye }) => bye);
-    const isDoubleExitExit = matchUp?.matchUpStatus &&
-        [WALKOVER$2, DEFAULTED].includes(matchUp.matchUpStatus) &&
-        updatedDrawPositions.filter(Boolean).length < 2;
+    const isDoubleExitExit = matchUp?.matchUpStatus && isExit(matchUp.matchUpStatus) && updatedDrawPositions.filter(Boolean).length < 2;
     matchUpStatus =
         (isByeMatchUp && BYE) ||
             matchUpStatus ||
@@ -16638,7 +16714,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);
+    const isPropagatedExit = !!(isExit(matchUp?.matchUpStatus) && matchUp?.winningSide);
     if (matchUp && positionAdded) {
         inContextDrawMatchUps =
             getAllDrawMatchUps({
@@ -16652,7 +16728,7 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
                 drawPosition,
                 matchUpId,
             }))
-            || (isWalkover && matchUp.winningSide)
+            || (isPropagatedExit && matchUp.winningSide)
             || undefined;
         if (matchUp?.matchUpStatusCodes) {
             updateMatchUpStatusCodes({
@@ -16666,7 +16742,7 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
         Object.assign(matchUp, {
             drawPositions: updatedDrawPositions,
             winningSide: exitWinningSide,
-            matchUpStatus: isWalkover ? matchUp?.matchUpStatus : matchUpStatus,
+            matchUpStatus: isPropagatedExit ? matchUp?.matchUpStatus : matchUpStatus,
         });
         modifyMatchUpNotice({
             tournamentId: tournamentRecord?.tournamentId,
@@ -16709,7 +16785,7 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
             }
         }
     }
-    else if (positionAssigned && isWalkover) {
+    else if (positionAssigned && isPropagatedExit) {
         if (winnerMatchUp) {
             const result = assignMatchUpDrawPosition({
                 matchUpId: winnerMatchUp.matchUpId,
@@ -23200,7 +23276,7 @@ function modifyMatchUpScore(params) {
 }
 
 function attemptToModifyScore(params) {
-    const { matchUpStatusCodes, matchUpStatus, structure, matchUp, dualMatchUp, inContextMatchUp, autoCalcDisabled, propagateExitStatus, } = params;
+    const { propagateExitStatus, matchUpStatusCodes, autoCalcDisabled, inContextMatchUp, matchUpStatus, dualMatchUp, structure, matchUp, } = params;
     const matchUpStatusIsValid = isDirectingMatchUpStatus({ matchUpStatus }) ||
         ([CANCELLED$1, ABANDONED$1].includes(matchUpStatus) && dualMatchUp) ||
         autoCalcDisabled;
@@ -23211,7 +23287,7 @@ function attemptToModifyScore(params) {
     const validToScore = hasAdHocSides ||
         drawPositionsAssignedParticipantIds({ structure, matchUp, inContextMatchUp }) ||
         params.appliedPolicies?.[POLICY_TYPE_SCORING]?.requireParticipantsForScoring === false ||
-        ([WALKOVER$2, DEFAULTED].includes(matchUpStatus) && participantsCount === 1 && propagateExitStatus);
+        (isExit(matchUpStatus) && participantsCount === 1 && propagateExitStatus);
     if (!validToScore)
         return decorateResult({ result: { error: MISSING_ASSIGNMENTS }, stack });
     const removeScore = [WALKOVER$2].includes(matchUpStatus);
@@ -23935,7 +24011,7 @@ function directLoser(params) {
             }
         }
     }
-    return { ...SUCCESS, stack, context };
+    return decorateResult({ result: { ...SUCCESS }, stack, context });
     function loserLinkFedFMLC() {
         const stack = 'loserLinkFedFMLC';
         if (validForConsolation) {
@@ -25632,7 +25708,7 @@ function getValidModifyAssignedPairAction({ tournamentParticipants, returnPartic
 }
 
 function isActiveDownstream(params) {
-    const { inContextDrawMatchUps, targetData, drawDefinition, relevantLink, matchUpStatus, score, winningSide } = params;
+    const { inContextDrawMatchUps, targetData, drawDefinition, relevantLink } = params;
     const fmlcBYE = relevantLink?.linkCondition === FIRST_MATCHUP && targetData?.matchUp?.matchUpStatus === BYE;
     if (fmlcBYE)
         return false;
@@ -25646,20 +25722,16 @@ function isActiveDownstream(params) {
     const loserExitPropagation = loserTargetData?.targetMatchUps?.loserMatchUp;
     const loserIndex = loserTargetData?.targetMatchUps?.loserMatchUpDrawPositionIndex;
     const propagatedLoserParticipant = loserExitPropagation?.sides[loserIndex]?.participant;
-    const loserMatchUpExit = [DEFAULTED, WALKOVER$2].includes(loserMatchUp?.matchUpStatus) && !propagatedLoserParticipant;
+    const isLoserMatchUpWO = isExit(loserMatchUp?.matchUpStatus);
+    const loserMatchUpExit = isLoserMatchUpWO && !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 isLoserMatchUpWalkoverWithOnePlayer = loserMatchUp?.winningSide && isLoserMatchUpWO && loserMatchUpParticipantsCount === 1;
     const winnerDrawPositionsCount = winnerMatchUp?.drawPositions?.filter(Boolean).length || 0;
-    if ((isLoserMatchUpAPropagatedExitStatus && isClearScore) ||
-        (!isLoserMatchUpAPropagatedExitStatus &&
-            ((loserMatchUp?.winningSide && !loserMatchUpExit) ||
-                (winnerMatchUp?.winningSide &&
-                    winnerDrawPositionsCount === 2 &&
-                    (!winnerMatchUp.feedRound || ![WALKOVER$2, DEFAULTED].includes(winnerMatchUp?.matchUpStatus)))))) {
+    if (!isLoserMatchUpWalkoverWithOnePlayer &&
+        ((loserMatchUp?.winningSide && !loserMatchUpExit) ||
+            (winnerMatchUp?.winningSide &&
+                winnerDrawPositionsCount === 2 &&
+                (!winnerMatchUp.feedRound || !isExit(winnerMatchUp?.matchUpStatus))))) {
         return true;
     }
     const winnerTargetData = winnerMatchUp &&
@@ -25803,7 +25875,7 @@ const matchUpActionConstants = {
 function collectionMatchUpActions({ specifiedPolicyDefinitions, inContextDrawMatchUps, matchUpParticipantIds, matchUpActionsPolicy, inContextMatchUp, policyActions, enforceGender, participantId, sideNumber, matchUpId, matchUp, drawId, side, }) {
     const validActions = [];
     const firstFoundSide = inContextMatchUp.sides?.find((side) => side.participant);
-    const assignedGender = inContextMatchUp.gender === MIXED &&
+    const assignedGender = isMixed(inContextMatchUp.gender) &&
         inContextMatchUp.sideNumber &&
         inContextMatchUp.sides?.filter((side) => side.particiapntId).length === 1 &&
         firstFoundSide?.participant?.person?.sex;
@@ -25822,9 +25894,9 @@ function collectionMatchUpActions({ specifiedPolicyDefinitions, inContextDrawMat
     const inContextDualMatchUp = inContextDrawMatchUps?.find((drawMatchUp) => drawMatchUp.matchUpId === inContextMatchUp.matchUpTieId);
     const availableIndividualParticipants = inContextDualMatchUp?.sides?.map((side) => side?.participant?.individualParticipants?.filter(({ participantId, person }) => !existingParticipantIds?.includes(participantId) &&
         (!gender ||
-            gender === ANY ||
+            isAny(gender) ||
             person.sex === gender ||
-            (gender === MIXED && !assignedGender) ||
+            (isMixed(gender) && !assignedGender) ||
             (assignedGender && person.sex !== assignedGender))));
     const availableParticipants = sideNumber
         ? availableIndividualParticipants?.[sideNumber - 1]
@@ -27219,15 +27291,16 @@ function getValidGender(params) {
         [];
     const validPairGender = !eventGender ||
         !pairGender?.length ||
-        ANY === eventGender ||
-        ([MALE, FEMALE].includes(eventGender) && pairGender[0] === eventGender) ||
-        (MIXED === eventGender &&
+        isAny(eventGender) ||
+        (isGendered(eventGender) && coercedGender(pairGender[0]) === coercedGender(eventGender)) ||
+        (isMixed(eventGender) &&
             ((pairGender.length === 1 && participant.individualParticipantIds?.length === 1) || pairGender.length === 2));
     const personGender = participant?.person?.sex;
     const validPersonGender = !participant?.person ||
         !eventGender ||
-        [ANY, MIXED].includes(eventGender) ||
-        ([MALE, FEMALE].includes(eventGender) && personGender === eventGender);
+        isMixed(eventGender) ||
+        isAny(eventGender) ||
+        (isGendered(eventGender) && coercedGender(personGender) === coercedGender(eventGender));
     return !genderEnforced || (validPairGender && validPersonGender);
 }
 
@@ -39055,16 +39128,16 @@ function addEventEntryPairs(params) {
     const invalidParticipantIdPairs = participantIdPairs.filter((pair) => {
         if (pair.length !== 2)
             return true;
-        if (!event.gender || event.gender === ANY)
+        if (!event.gender || isAny(event.gender))
             return false;
         if (!genderMap.has(pair[0]) || !genderMap.has(pair[1]))
             return true;
         const participantGenders = pair.map((id) => genderMap.get(id));
-        let invalidParticiapntGenders = (event.gender === MALE && (participantGenders[0] !== MALE || participantGenders[1] !== MALE)) ||
-            (event.gender === FEMALE && (participantGenders[0] !== FEMALE || participantGenders[1] !== FEMALE));
-        if (event.gender === MIXED) {
+        let invalidParticiapntGenders = (isMale(event.gender) && (!isMale(participantGenders[0]) || !isMale(participantGenders[1]))) ||
+            (isFemale(event.gender) && (!isFemale(participantGenders[0]) || !isFemale(participantGenders[1])));
+        if (isMixed(event.gender)) {
             participantGenders.sort(stringSort);
-            if (participantGenders[0] !== FEMALE || participantGenders[1] !== MALE)
+            if (!isFemale(participantGenders[0]) || !isMale(participantGenders[1]))
                 invalidParticiapntGenders = true;
         }
         return invalidParticiapntGenders;
@@ -39426,8 +39499,10 @@ function generateEventsFromTieFormat(params) {
         for (const participant of params.tournamentRecord.participants ?? []) {
             if (individualParticipantIds?.includes(participant.participantId)) {
                 const gender = participant.person?.sex;
-                if (gender && [MALE, FEMALE].includes(gender)) {
-                    genderedParticipants[gender].push(participant.participantId);
+                if (gender && isGendered(gender)) {
+                    const coerced = coercedGender(gender);
+                    if (coerced)
+                        genderedParticipants[coerced].push(participant.participantId);
                 }
             }
         }
@@ -39447,9 +39522,9 @@ function generateEventsFromTieFormat(params) {
         };
         if (params.addEntriesFromTeams) {
             const entryStatus = eventType === DOUBLES_EVENT ? UNGROUPED : params.entryStatus || DIRECT_ACCEPTANCE;
-            const participantIds = eventGender === MIXED
+            const participantIds = isMixed(eventGender)
                 ? [...genderedParticipants[MALE], ...genderedParticipants[FEMALE]]
-                : (genderedParticipants[eventGender] ?? []);
+                : (genderedParticipants[coercedGender(eventGender) || OTHER$3] ?? []);
             if (participantIds.length) {
                 const result = addEventEntries({
                     participantIds,
@@ -40916,9 +40991,9 @@ function getParticipantsProfile({ enteredParticipants }) {
 function checkGenderUpdates({ noFlightsNoDraws, enteredParticipantGenders, eventUpdates, stack }) {
     const validGender = !enteredParticipantGenders.length ||
         !eventUpdates.gender ||
-        eventUpdates.gender === ANY ||
+        isAny(eventUpdates.gender) ||
         (enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender) ||
-        (noFlightsNoDraws && eventUpdates.gender === MIXED);
+        (noFlightsNoDraws && isMixed(eventUpdates.gender));
     return eventUpdates.gender && !validGender
         ? decorateResult({
             context: { gender: eventUpdates.gender, validGender },
@@ -41440,7 +41515,8 @@ function generateLineUps(params) {
                 const participantIds = [];
                 generateRange(0, singlesMatchUp ? 1 : 2).forEach((i) => {
                     const nextParticipantId = typeSort?.find((participant) => {
-                        const targetGender = gender && (([MALE, FEMALE].includes(gender) && gender) || (gender === MIXED && [MALE, FEMALE][i]));
+                        const coerced = coercedGender(gender);
+                        const targetGender = coerced && ((isGendered(gender) && coerced) || (isMixed(gender) && [MALE, FEMALE][i]));
                         return ((!targetGender || targetGender === participant.person?.sex) &&
                             !collectionParticipantIds.includes(participant.participantId));
                     })?.participantId;
@@ -42243,8 +42319,8 @@ function replaceTieMatchUpParticipantId(params) {
     const newParticipant = targetParticipants.find(({ participantId }) => participantId === newParticipantId);
     const genderEnforced = (params.enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
     if (genderEnforced &&
-        [MALE, FEMALE].includes(inContextTieMatchUp?.gender) &&
-        inContextTieMatchUp?.gender !== newParticipant?.person?.sex) {
+        isGendered(inContextTieMatchUp?.gender) &&
+        coercedGender(inContextTieMatchUp?.gender) !== coercedGender(newParticipant?.person?.sex)) {
         return { error: INVALID_PARTICIPANT, info: 'Gender mismatch' };
     }
     const substitutionProcessCodes = matchUpActionsPolicy?.processCodes?.substitution;
@@ -42704,8 +42780,8 @@ function assignTieMatchUpParticipantId(params) {
         POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
     const genderEnforced = (params.enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
     if (genderEnforced &&
-        [MALE, FEMALE].includes(inContextTieMatchUp?.gender) &&
-        inContextTieMatchUp?.gender !== participantToAssign.person?.sex) {
+        isGendered(inContextTieMatchUp?.gender) &&
+        coercedGender(inContextTieMatchUp?.gender) !== coercedGender(participantToAssign.person?.sex)) {
         return { error: INVALID_PARTICIPANT, info: 'Gender mismatch' };
     }
     const { individualParticipantIds, participantType } = participantToAssign;
@@ -43186,10 +43262,8 @@ function removeDrawPosition({ inContextDrawMatchUps, positionAssignments, source
     const matchUpAssignments = positionAssignments.filter(({ drawPosition }) => matchUp.drawPositions?.includes(drawPosition));
     const matchUpContainsBye = matchUpAssignments.filter((assignment) => assignment.bye).length;
     matchUp.matchUpStatus =
-        (matchUpContainsBye && BYE) ||
-            ([DEFAULTED, WALKOVER$2].includes(matchUp.matchUpStatus) && matchUp.matchUpStatus) ||
-            TO_BE_PLAYED;
-    if ([WALKOVER$2, DEFAULTED].includes(matchUp.matchUpStatus))
+        (matchUpContainsBye && BYE) || (isExit(matchUp.matchUpStatus) && matchUp.matchUpStatus) || TO_BE_PLAYED;
+    if (isExit(matchUp.matchUpStatus))
         matchUp.winningSide = undefined;
     if (matchUp.matchUpStatusCodes) {
         updateMatchUpStatusCodes({
@@ -43402,6 +43476,10 @@ function removeDirectedLoser({ sourceMatchUpStatus, loserParticipantId, tourname
             delete assignment.participantId;
         }
     });
+    if (sourceMatchUpId && sourceMatchUpStatus) {
+        const targetMatchUp = matchUpsMap?.drawMatchUps?.find(({ matchUpId }) => matchUpId === loserMatchUp.matchUpId);
+        targetMatchUp.matchUpStatusCodes = sourceMatchUpStatus === DOUBLE_WALKOVER ? ['WO', 'WO'] : [];
+    }
     structure.seedAssignments = (structure.seedAssignments ?? []).filter((assignment) => assignment.participantId !== loserParticipantId);
     if (dualMatchUp) {
         const drawPositionSideIndex = loserMatchUp?.sides.reduce((sideIndex, side, i) => (side.drawPosition === relevantDrawPosition ? i : sideIndex), undefined);
@@ -43423,6 +43501,11 @@ 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,
@@ -43488,8 +43571,9 @@ function doubleExitAdvancement(params) {
         return decorateResult({ result: { ...SUCCESS }, stack });
     const { matchUp: sourceMatchUp, targetMatchUps, targetLinks } = targetData;
     const { loserMatchUp, winnerMatchUp, loserTargetDrawPosition } = targetMatchUps;
-    const loserMatchUpIsEmptyExit = [WALKOVER$2, DEFAULTED].includes(loserMatchUp?.matchUpStatus) &&
+    const loserMatchUpIsEmptyExit = isExit(loserMatchUp?.matchUpStatus) &&
         !loserMatchUp.sides?.map((side) => side.participantId ?? side.participant).filter(Boolean).length;
+    const loserMatchUpIsDoubleExit = loserMatchUp?.matchUpStatus === DOUBLE_WALKOVER;
     if (loserMatchUp && loserMatchUp.matchUpStatus !== BYE) {
         const { loserTargetLink } = targetLinks;
         if (appliedPolicies?.progression?.doubleExitPropagateBye ||
@@ -43499,15 +43583,17 @@ function doubleExitAdvancement(params) {
                 tournamentRecord,
                 loserTargetLink,
                 drawDefinition,
+                loserMatchUp,
                 matchUpsMap,
                 event,
             });
             if (result.error)
                 return decorateResult({ result, stack });
         }
-        else if (!loserMatchUpIsEmptyExit) {
+        else if (!loserMatchUpIsDoubleExit) {
             const { feedRound, drawPositions, matchUpId } = loserMatchUp;
-            const walkoverWinningSide = feedRound ? 2 : 2 - drawPositions.indexOf(loserTargetDrawPosition);
+            let walkoverWinningSide = feedRound ? 2 : 2 - drawPositions.indexOf(loserTargetDrawPosition);
+            walkoverWinningSide = loserMatchUpIsEmptyExit ? loserMatchUp.winningSide : walkoverWinningSide;
             const result = conditionallyAdvanceDrawPosition({
                 ...params,
                 targetMatchUp: loserMatchUp,
@@ -43562,6 +43648,7 @@ function conditionallyAdvanceDrawPosition(params) {
         const { loserTargetLink } = targetLinks;
         const result = advanceByeToLoserMatchUp({
             loserTargetDrawPosition: nextLoserTargetDrawPosition,
+            loserMatchUp: nextLoserMatchUp,
             tournamentRecord,
             loserTargetLink,
             drawDefinition,
@@ -43580,7 +43667,7 @@ function conditionallyAdvanceDrawPosition(params) {
                 inContextDrawMatchUps,
             })) ||
         undefined;
-    const existingExit = [WALKOVER$2, DEFAULTED].includes(noContextTargetMatchUp.matchUpStatus) && !drawPositions.length;
+    const existingExit = isExit(noContextTargetMatchUp.matchUpStatus) && !drawPositions.length;
     const isFinal = noContextTargetMatchUp.finishingRound === 1;
     const matchUpStatus = existingExit && !isFinal ? DOUBLE_EXIT : EXIT;
     const inContextPairedPreviousMatchUp = inContextDrawMatchUps.find((candidate) => candidate.matchUpId === pairedPreviousMatchUp.matchUpId);
@@ -43698,7 +43785,7 @@ function conditionallyAdvanceDrawPosition(params) {
                     matchUpsMap,
                 });
             }
-            else if ([WALKOVER$2, DEFAULTED].includes(nextWinnerMatchUp.matchUpStatus)) {
+            else if (isExit(nextWinnerMatchUp.matchUpStatus)) {
                 const result = doubleExitAdvancement({
                     ...params,
                     matchUpId: noContextNextWinnerMatchUp.matchUpId,
@@ -43731,7 +43818,7 @@ function conditionallyAdvanceDrawPosition(params) {
                 walkoverWinningSide,
             });
         }
-        const matchUpStatus = [WALKOVER$2, DEFAULTED].includes(noContextNextWinnerMatchUp.matchUpStatus) ? EXIT : DOUBLE_EXIT;
+        const matchUpStatus = isExit(noContextNextWinnerMatchUp.matchUpStatus) ? EXIT : DOUBLE_EXIT;
         const result = modifyMatchUpScore({
             matchUpId: noContextNextWinnerMatchUp.matchUpId,
             appliedPolicies: params.appliedPolicies,
@@ -43757,7 +43844,7 @@ function conditionallyAdvanceDrawPosition(params) {
     return decorateResult({ result: { ...SUCCESS }, stack });
 }
 function advanceByeToLoserMatchUp(params) {
-    const { loserTargetDrawPosition, tournamentRecord, loserTargetLink, drawDefinition, matchUpsMap, event } = params;
+    const { loserTargetDrawPosition, tournamentRecord, loserTargetLink, drawDefinition, matchUpsMap, event, loserMatchUp, } = params;
     const structureId = loserTargetLink?.target?.structureId;
     const { structure } = findStructure({ drawDefinition, structureId });
     if (!structure)
@@ -43768,6 +43855,7 @@ function advanceByeToLoserMatchUp(params) {
         drawDefinition,
         structureId,
         matchUpsMap,
+        loserMatchUp,
         event,
     });
 }
@@ -44071,13 +44159,36 @@ function attemptToSetWinningSide(params) {
     });
 }
 
+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,
@@ -44105,6 +44216,16 @@ 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,
@@ -44130,6 +44251,7 @@ 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,
@@ -44169,6 +44291,17 @@ 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,
@@ -44325,7 +44458,7 @@ function noDownstreamDependencies(params) {
     }
     const triggerDualWinningSide = [CANCELLED$1, ABANDONED$1].includes(matchUpStatus) && params.dualWinningSideChange;
     const statusNotToBePlayed = matchUpStatus && matchUpStatus !== TO_BE_PLAYED;
-    const propagateExitStatus = params.propagateExitStatus && [WALKOVER$2, DEFAULTED].includes(matchUpStatus);
+    const propagateExitStatus = params.propagateExitStatus && isExit(matchUpStatus);
     const result = ((winningSide || triggerDualWinningSide || propagateExitStatus) && attemptToSetWinningSide(params)) ||
         (scoreWithNoWinningSide && removeDirected(removeScore)) ||
         (statusNotToBePlayed && attemptToSetMatchUpStatus(params)) ||
@@ -45072,6 +45205,15 @@ function addMatchUpResumeTime({ removePriorValues, tournamentRecord, drawDefinit
     }
 }
 
+function hasPropagatedExitDownstream(params) {
+    const { targetData, matchUpsMap } = params;
+    const { targetMatchUps: { loserMatchUp }, } = targetData;
+    const isLoserMatchUpWO = isExit(loserMatchUp?.matchUpStatus);
+    const hasLoserMatchUpUpstreamWOMatches = !!matchUpsMap?.drawMatchUps.find((m) => m.loserMatchUpId === loserMatchUp?.matchUpId && isExit(m.matchUpStatus));
+    return ((hasLoserMatchUpUpstreamWOMatches && loserMatchUp?.matchUpStatus === DOUBLE_WALKOVER) ||
+        (hasLoserMatchUpUpstreamWOMatches && isLoserMatchUpWO));
+}
+
 function getProjectedDualWinningSide({ drawDefinition, matchUpStatus, matchUpsMap, winningSide, dualMatchUp, tieFormat, structure, matchUp, event, score, }) {
     const projectedDualMatchUp = makeDeepCopy(dualMatchUp, undefined, true);
     for (const tieMatchUp of projectedDualMatchUp?.tieMatchUps || []) {
@@ -45155,7 +45297,7 @@ function swapWinnerLoser(params) {
 }
 
 function setMatchUpState(params) {
-    const stack = 'setMatchUpState';
+    const stack = 'setMatchUpStatus';
     if (params.matchUpStatus && [WALKOVER$2, DOUBLE_WALKOVER].includes(params.matchUpStatus))
         params.score = undefined;
     const { allowChangePropagation, disableScoreValidation, propagateExitStatus, tournamentRecords, tournamentRecord, disableAutoCalc, enableAutoCalc, drawDefinition, matchUpStatus, winningSide, matchUpId, event, score, } = params;
@@ -45209,6 +45351,13 @@ function setMatchUpState(params) {
         structure,
         matchUp,
     });
+    const isClearScore = matchUpStatus === TO_BE_PLAYED && score?.scoreStringSide1 === '' && score?.scoreStringSide2 === '' && !winningSide;
+    const propagatedExitDownStream = hasPropagatedExitDownstream(params);
+    if (propagatedExitDownStream && isClearScore) {
+        return {
+            error: PROPAGATED_EXITS_DOWNSTREAM,
+        };
+    }
     const activeDownstream = isActiveDownstream(params);
     let dualWinningSideChange;
     if (isTeam) {
@@ -45401,6 +45550,12 @@ 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)) || {
@@ -45481,7 +45636,7 @@ function checkParticipants({ assignedDrawPositions, propagateExitStatus, inConte
     if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && !requiredParticipants) {
         return decorateResult({
             info: 'matchUpStatus requires assigned participants',
-            context: { matchUpStatus, requiredParticipants, propagateExitStatus: propagateExitStatus, participantsCount },
+            context: { matchUpStatus, requiredParticipants },
             result: { error: INVALID_MATCHUP_STATUS },
         });
     }
@@ -45785,7 +45940,13 @@ function matchUpScore(params) {
 
 function progressExitStatus({ sourceMatchUpStatusCodes, propagateExitStatus, sourceMatchUpStatus, loserParticipantId, tournamentRecord, drawDefinition, loserMatchUp, matchUpsMap, event, }) {
     const stack = 'progressExitStatus';
-    const carryOverMatchUpStatus = ([WALKOVER$2, DEFAULTED].includes(sourceMatchUpStatus) && sourceMatchUpStatus) || WALKOVER$2;
+    pushGlobalLog({
+        matchUpId: loserMatchUp?.matchUpId,
+        matchUpStatus: sourceMatchUpStatus,
+        color: 'magenta',
+        method: stack,
+    });
+    const carryOverMatchUpStatus = (isExit(sourceMatchUpStatus) && sourceMatchUpStatus) || WALKOVER$2;
     const inContextMatchUps = getAllDrawMatchUps({
         inContext: true,
         drawDefinition,
@@ -45795,7 +45956,7 @@ function progressExitStatus({ sourceMatchUpStatusCodes, propagateExitStatus, sou
     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 statusCodes = updatedLoserMatchUp.matchUpStatusCodes?.map((sc) => (typeof sc === 'string' ? sc : OUTCOME_WALKOVER)) ?? [];
         const loserParticipantSide = updatedLoserMatchUp.sides?.find((s) => s.participantId === loserParticipantId);
         if (loserParticipantSide?.sideNumber) {
             const participantsCount = updatedLoserMatchUp?.sides?.reduce((count, current) => {
@@ -45806,7 +45967,7 @@ function progressExitStatus({ sourceMatchUpStatusCodes, propagateExitStatus, sou
                 statusCodes[0] = sourceMatchUpStatusCodes[0];
             }
             else {
-                if (![WALKOVER$2, DEFAULTED].includes(loserMatchUp.matchUpStatus)) {
+                if (!isExit(loserMatchUp.matchUpStatus)) {
                     winningSide = loserParticipantSide.sideNumber === 1 ? 2 : 1;
                     statusCodes[0] = sourceMatchUpStatusCodes[0];
                 }
@@ -45852,7 +46013,7 @@ function setMatchUpStatus(params) {
             tournamentRecord,
         });
         if (result.error)
-            return decorateResult({ stack, result });
+            return result;
         if (result.drawDefinition)
             params.drawDefinition = result.drawDefinition;
         params.event = result.event;
@@ -45869,7 +46030,7 @@ function setMatchUpStatus(params) {
         undefined;
     const { outcome, setTBlast } = params;
     if (outcome?.winningSide && ![1, 2].includes(outcome.winningSide)) {
-        return decorateResult({ result: { error: INVALID_WINNING_SIDE }, stack });
+        return { error: INVALID_WINNING_SIDE };
     }
     if (matchUpFormat) {
         const result = setMatchUpMatchUpFormat({
@@ -45880,7 +46041,7 @@ function setMatchUpStatus(params) {
             event,
         });
         if (result.error)
-            return decorateResult({ stack, result });
+            return result;
     }
     if (outcome?.score?.sets && !outcome.score.scoreStringSide1) {
         const { score: scoreObject } = matchUpScore({ ...outcome, setTBlast });
@@ -48924,7 +49085,7 @@ var namesData$1 = {
 
 function generatePersonData(params) {
     const { count = 100, sex } = params || {};
-    if (!count || (sex && ![MALE, FEMALE].includes(sex)))
+    if (!count || (sex && !isGendered(sex)))
         return { personData: [], error: INVALID_VALUES };
     const buffer = Math.ceil(count * 1.3);
     const { lastNames, firstFemale, firstMale } = namesData$1;
@@ -48966,8 +49127,8 @@ function generatePersons(params) {
     const { personExtensions, consideredDate, isMock = true, gendersCount, personData, category, sex } = params || {};
     if (isNaN(count))
         return { error: INVALID_VALUES };
-    const maleCount = gendersCount?.[MALE] || (sex === MALE && count) || 0;
-    const femaleCount = gendersCount?.[FEMALE] || (sex === FEMALE && count) || 0;
+    const maleCount = gendersCount?.[MALE] || (isMale(sex) && count) || 0;
+    const femaleCount = gendersCount?.[FEMALE] || (isFemale(sex) && count) || 0;
     count = Math.max(count, maleCount + femaleCount);
     const defaultCount = count - (maleCount + femaleCount);
     const defaultMalePersonData = (maleCount &&
@@ -49450,12 +49611,13 @@ function processTieFormat(params) {
     const tieFormat = isObject(params.tieFormat) ? params.tieFormat : tieFormatDefaults({ namedFormat: tieFormatName });
     tieFormat?.collectionDefinitions?.filter(Boolean).forEach((collectionDefinition) => {
         const { category, collectionId, matchUpType, matchUpCount, gender } = collectionDefinition;
-        if ([MALE, FEMALE].includes(gender)) {
+        if (isGendered(gender)) {
+            const coerced = coercedGender(gender);
             const required = matchUpCount * (matchUpType === DOUBLES$1 ? 2 : 1);
-            if (genders[gender] < required)
-                genders[gender] = required;
+            if (coerced && genders[coerced] < required)
+                genders[coerced] = required;
         }
-        else if (gender === MIXED) {
+        else if (isMixed(gender)) {
             if (genders[MALE] < matchUpCount)
                 genders[MALE] = matchUpCount;
             if (genders[FEMALE] < matchUpCount)
@@ -49728,7 +49890,7 @@ function generateOutcome(params) {
         COMPLETED$1,
     ])[1];
     const noScore = { sets: [], scoreStringSide1: '', side2ScoreString: '' };
-    if ([WALKOVER$2, DEFAULTED].includes(matchUpStatus)) {
+    if (isExit(matchUpStatus)) {
         winningSide = winningSide || randomInt(1, 2);
         const outcome = {
             score: noScore,
@@ -50254,7 +50416,7 @@ function generateEventParticipants(params) {
     const participantsCount = eventProfile.drawProfiles?.length
         ? mainParticipantsCount + qualifyingParticipantsCount
         : (eventProfile.participantsProfile?.participantsCount ?? 0);
-    const sex = [MALE, FEMALE].includes(gender) ? gender : undefined;
+    const sex = isGendered(gender) ? gender : undefined;
     const idPrefix = participantsProfile?.idPrefix ? `E-${eventIndex}-${participantsProfile?.idPrefix}` : undefined;
     const { participants: uniqueFlightParticipants } = generateParticipants({
         uuids: eventProfile.uuids || uuids,
@@ -50653,8 +50815,9 @@ function generateEventWithDraw(params) {
                 drawSize,
             }));
             Object.keys(genders).forEach((key) => {
-                if ([MALE, FEMALE].includes(key) && genders[key]) {
-                    gendersCount[key] = drawSize * genders[key];
+                const coerced = coercedGender(key);
+                if (coerced && isGendered(key) && genders[coerced]) {
+                    gendersCount[coerced] = drawSize * genders[coerced];
                 }
             });
             individualParticipantCount = teamSize * ((drawSize || 0) + qualifyingParticipantsCount);
@@ -50695,7 +50858,7 @@ function generateEventWithDraw(params) {
                 : [];
             const femaleIndividualParticipantIds = genders[FEMALE]
                 ? unique
-                    .filter(({ participantType, person }) => participantType === INDIVIDUAL && person?.sex === FEMALE)
+                    .filter(({ participantType, person }) => participantType === INDIVIDUAL && isFemale(person?.sex))
                     .map(getParticipantId)
                 : [];
             const remainingParticipantIds = unique
@@ -51729,8 +51892,9 @@ function anonymizeTournamentRecord({ keepExtensions = [], anonymizeParticipantNa
     const individualParticipants = (tournamentRecord.participants || []).filter(({ participantType }) => participantType === INDIVIDUAL);
     const gendersCount = individualParticipants.reduce((counts, participant) => {
         const gender = participant.person?.sex;
-        if ([MALE, FEMALE].includes(gender)) {
-            counts[gender] += 1;
+        const coerced = coercedGender(gender);
+        if (coerced && isGendered(gender)) {
+            counts[coerced] += 1;
         }
         else {
             counts[OTHER$3] += 1;