tods-competition-factory 2.2.31 → 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.31';
+    return '2.2.32-beta.0';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -1880,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,
@@ -12237,7 +12284,63 @@ 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 assignDrawPositionBye({ provisionalPositioning, isPositionAction, tournamentRecord, drawDefinition, drawPosition, loserMatchUp, matchUpsMap, structureId, structure, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (!structure)
@@ -12247,6 +12350,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 +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);
@@ -12269,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({
@@ -12293,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) {
@@ -12406,6 +12514,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 +12628,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 +12690,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 +12735,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;
@@ -14974,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,
@@ -23200,7 +23272,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;
@@ -23935,7 +24007,7 @@ function directLoser(params) {
             }
         }
     }
-    return { ...SUCCESS, stack, context };
+    return decorateResult({ result: { ...SUCCESS }, stack, context });
     function loserLinkFedFMLC() {
         const stack = 'loserLinkFedFMLC';
         if (validForConsolation) {
@@ -25632,7 +25704,7 @@ function getValidModifyAssignedPairAction({ tournamentParticipants, returnPartic
 }
 
 function isActiveDownstream(params) {
-    const { inContextDrawMatchUps, targetData, drawDefinition, relevantLink, matchUpStatus, score, winningSide } = 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;
@@ -25647,15 +25719,15 @@ 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 isLoserMatchUpAPropagatedExitStatus = loserMatchUp?.winningSide &&
-        [DEFAULTED, WALKOVER$2].includes(loserMatchUp?.matchUpStatus) &&
-        propagatedLoserParticipant &&
-        loserMatchUpParticipantsCount === 1;
+    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 ((isLoserMatchUpAPropagatedExitStatus && isClearScore) ||
-        (!isLoserMatchUpAPropagatedExitStatus &&
+    if ((hasLoserMatchUpUpstreamWOMatches && loserMatchUp?.matchUpStatus === DOUBLE_WALKOVER && isClearScore) ||
+        (hasLoserMatchUpUpstreamWOMatches && isLoserMatchUpWO && isClearScore) ||
+        (!isLoserMatchUpWalkoverWithOnePlayer &&
             ((loserMatchUp?.winningSide && !loserMatchUpExit) ||
                 (winnerMatchUp?.winningSide &&
                     winnerDrawPositionsCount === 2 &&
@@ -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;
@@ -43402,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);
@@ -43423,6 +43503,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,
@@ -43490,6 +43575,7 @@ 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 ||
@@ -43499,15 +43585,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 +43650,7 @@ function conditionallyAdvanceDrawPosition(params) {
         const { loserTargetLink } = targetLinks;
         const result = advanceByeToLoserMatchUp({
             loserTargetDrawPosition: nextLoserTargetDrawPosition,
+            loserMatchUp: nextLoserMatchUp,
             tournamentRecord,
             loserTargetLink,
             drawDefinition,
@@ -43757,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)
@@ -43768,6 +43857,7 @@ function advanceByeToLoserMatchUp(params) {
         drawDefinition,
         structureId,
         matchUpsMap,
+        loserMatchUp,
         event,
     });
 }
@@ -44071,13 +44161,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 +44218,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 +44253,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 +44293,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,
@@ -45155,7 +45290,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;
@@ -45401,6 +45536,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 +45622,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,6 +45926,12 @@ function matchUpScore(params) {
 
 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,
@@ -45795,7 +45942,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) => {
@@ -45852,7 +45999,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 +46016,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 +46027,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 +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;
@@ -48966,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 &&
@@ -49450,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)
@@ -50254,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,
@@ -50653,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);
@@ -50695,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
@@ -51729,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;