tods-competition-factory 2.2.30 → 2.2.32-beta.0

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.30';
+    return '2.2.32-beta.0';
 }
 
 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 });
@@ -1878,38 +1880,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,
@@ -12291,7 +12340,7 @@ function purgeGlobalLog() {
     globalLog.length = 0;
 }
 
-function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, matchUpsMap, structureId, structure, event, }) {
+function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, loserMatchUp, matchUpsMap, structureId, structure, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (!structure)
@@ -12314,8 +12363,9 @@ function assignDrawPositionBye({ provisionalPositioning, isPositionAction, tourn
     if (currentAssignment?.bye) {
         return { ...SUCCESS };
     }
+    const hasPropagatedStatus = !!(loserMatchUp && matchUpsMap.drawMatchUps.find((m) => m.loserMatchUpId === loserMatchUp?.matchUpId && [DEFAULTED, WALKOVER$2].includes(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);
@@ -12324,7 +12374,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({
@@ -12348,6 +12398,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) {
@@ -14982,21 +15035,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,
@@ -16646,6 +16710,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({
@@ -16658,8 +16723,9 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
                 inContextDrawMatchUps,
                 drawPosition,
                 matchUpId,
-            })) ||
-            undefined;
+            }))
+            || (isWalkover && matchUp.winningSide)
+            || undefined;
         if (matchUp?.matchUpStatusCodes) {
             updateMatchUpStatusCodes({
                 inContextDrawMatchUps,
@@ -16672,7 +16738,7 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
         Object.assign(matchUp, {
             drawPositions: updatedDrawPositions,
             winningSide: exitWinningSide,
-            matchUpStatus,
+            matchUpStatus: isWalkover ? matchUp?.matchUpStatus : matchUpStatus,
         });
         modifyMatchUpNotice({
             tournamentId: tournamentRecord?.tournamentId,
@@ -16715,6 +16781,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,
@@ -23192,7 +23272,7 @@ function modifyMatchUpScore(params) {
 }
 
 function attemptToModifyScore(params) {
-    const { matchUpStatusCodes, matchUpStatus, structure, matchUp, dualMatchUp, inContextMatchUp, autoCalcDisabled } = params;
+    const { propagateExitStatus, matchUpStatusCodes, autoCalcDisabled, inContextMatchUp, matchUpStatus, dualMatchUp, structure, matchUp, } = params;
     const matchUpStatusIsValid = isDirectingMatchUpStatus({ matchUpStatus }) ||
         ([CANCELLED$1, ABANDONED$1].includes(matchUpStatus) && dualMatchUp) ||
         autoCalcDisabled;
@@ -23202,13 +23282,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,
@@ -23724,7 +23806,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) {
@@ -23788,7 +23870,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 || [];
@@ -23822,15 +23904,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) => {
@@ -23844,11 +23928,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 });
     }
@@ -23868,6 +23956,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;
@@ -23916,7 +24007,7 @@ function directLoser(params) {
             }
         }
     }
-    return { ...SUCCESS };
+    return decorateResult({ result: { ...SUCCESS }, stack, context });
     function loserLinkFedFMLC() {
         const stack = 'loserLinkFedFMLC';
         if (validForConsolation) {
@@ -23950,6 +24041,9 @@ function directLoser(params) {
                 event,
             })
             : { error: MISSING_PARTICIPANT_ID };
+        if (!result.error && validExitToPropagate && propagateExitStatus) {
+            return { stack, context: { progressExitStatus: true } };
+        }
         return decorateResult({ result, stack: 'assignLoserDrawPosition' });
     }
 }
@@ -23962,7 +24056,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;
@@ -23992,6 +24086,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({
@@ -24018,6 +24113,7 @@ function directParticipants(params) {
                 loserMatchUpDrawPositionIndex,
                 inContextDrawMatchUps,
                 projectedWinningSide,
+                propagateExitStatus,
                 loserDrawPosition,
                 tournamentRecord,
                 loserTargetLink,
@@ -24027,6 +24123,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 });
         }
@@ -24044,11 +24148,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) {
@@ -25600,7 +25704,7 @@ function getValidModifyAssignedPairAction({ tournamentParticipants, returnPartic
 }
 
 function isActiveDownstream(params) {
-    const { inContextDrawMatchUps, targetData, drawDefinition, relevantLink } = params;
+    const { inContextDrawMatchUps, targetData, drawDefinition, relevantLink, matchUpStatus, score, winningSide, matchUpsMap } = params;
     const fmlcBYE = relevantLink?.linkCondition === FIRST_MATCHUP && targetData?.matchUp?.matchUpStatus === BYE;
     if (fmlcBYE)
         return false;
@@ -25615,11 +25719,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 isLoserMatchUpWO = [DEFAULTED, WALKOVER$2].includes(loserMatchUp?.matchUpStatus);
+    const hasLoserMatchUpUpstreamWOMatches = !!matchUpsMap?.drawMatchUps.find((m) => m.loserMatchUpId === loserMatchUp?.matchUpId && [DEFAULTED, WALKOVER$2, WITHDRAWN].includes(m.matchUpStatus));
+    const loserMatchUpParticipantsCount = loserMatchUp?.sides?.reduce((acc, current) => (current?.participant ? ++acc : acc), 0) ?? 0;
+    const isLoserMatchUpWalkoverWithOnePlayer = loserMatchUp?.winningSide && isLoserMatchUpWO && 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 ((hasLoserMatchUpUpstreamWOMatches && loserMatchUp?.matchUpStatus === DOUBLE_WALKOVER && isClearScore) ||
+        (hasLoserMatchUpUpstreamWOMatches && isLoserMatchUpWO && isClearScore) ||
+        (!isLoserMatchUpWalkoverWithOnePlayer &&
+            ((loserMatchUp?.winningSide && !loserMatchUpExit) ||
+                (winnerMatchUp?.winningSide &&
+                    winnerDrawPositionsCount === 2 &&
+                    (!winnerMatchUp.feedRound || ![WALKOVER$2, DEFAULTED].includes(winnerMatchUp?.matchUpStatus)))))) {
         return true;
     }
     const winnerTargetData = winnerMatchUp &&
@@ -25763,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;
@@ -25782,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]
@@ -27179,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);
 }
 
@@ -39015,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;
@@ -39386,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);
                 }
             }
         }
@@ -39407,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,
@@ -40876,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 },
@@ -41400,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;
@@ -42203,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;
@@ -42664,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;
@@ -43362,6 +43478,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);
@@ -43455,23 +43575,27 @@ function doubleExitAdvancement(params) {
     const { loserMatchUp, winnerMatchUp, loserTargetDrawPosition } = targetMatchUps;
     const loserMatchUpIsEmptyExit = [WALKOVER$2, DEFAULTED].includes(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) {
+        if (appliedPolicies?.progression?.doubleExitPropagateBye ||
+            (loserMatchUp.feedRound && loserMatchUp.sides?.[0]?.participantFed)) {
             const result = advanceByeToLoserMatchUp({
                 loserTargetDrawPosition,
                 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,
@@ -43526,6 +43650,7 @@ function conditionallyAdvanceDrawPosition(params) {
         const { loserTargetLink } = targetLinks;
         const result = advanceByeToLoserMatchUp({
             loserTargetDrawPosition: nextLoserTargetDrawPosition,
+            loserMatchUp: nextLoserMatchUp,
             tournamentRecord,
             loserTargetLink,
             drawDefinition,
@@ -43721,7 +43846,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)
@@ -43732,6 +43857,7 @@ function advanceByeToLoserMatchUp(params) {
         drawDefinition,
         structureId,
         matchUpsMap,
+        loserMatchUp,
         event,
     });
 }
@@ -43777,8 +43903,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,
         }));
 }
@@ -43990,6 +44117,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);
@@ -44009,6 +44137,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;
@@ -44025,6 +44155,7 @@ function attemptToSetWinningSide(params) {
             connectedStructures,
             qualifierReplaced,
             qualifierPlaced,
+            context,
         }),
         stack,
     });
@@ -44299,7 +44430,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;
@@ -44329,9 +44459,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,
@@ -45161,7 +45293,7 @@ function setMatchUpState(params) {
     const stack = 'setMatchUpStatus';
     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)
@@ -45291,6 +45423,7 @@ function setMatchUpState(params) {
         Object.assign(appliedPolicies, params.policyDefinitions);
     const participantCheck = checkParticipants({
         assignedDrawPositions,
+        propagateExitStatus,
         inContextMatchUp,
         appliedPolicies,
         drawDefinition,
@@ -45464,7 +45597,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;
@@ -45480,6 +45613,12 @@ 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',
@@ -45785,10 +45924,70 @@ function matchUpScore(params) {
     return { score: { sets, scoreStringSide1, scoreStringSide2 } };
 }
 
+function progressExitStatus({ sourceMatchUpStatusCodes, propagateExitStatus, sourceMatchUpStatus, loserParticipantId, tournamentRecord, drawDefinition, loserMatchUp, matchUpsMap, event, }) {
+    const stack = 'progressExitStatus';
+    pushGlobalLog({
+        matchUpId: loserMatchUp?.matchUpId,
+        matchUpStatus: sourceMatchUpStatus,
+        color: 'magenta',
+        method: stack,
+    });
+    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 : OUTCOME_WALKOVER)) ?? [];
+        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]);
@@ -45805,7 +46004,7 @@ function setMatchUpStatus(params) {
             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,
@@ -45835,13 +46034,14 @@ function setMatchUpStatus(params) {
         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,
@@ -45854,6 +46054,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) {
@@ -48847,7 +49071,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;
@@ -48889,8 +49113,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 &&
@@ -49373,12 +49597,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)
@@ -50177,7 +50402,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,
@@ -50576,8 +50801,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);
@@ -50618,7 +50844,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
@@ -51652,8 +51878,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;