tods-competition-factory 7.2.0 → 7.3.1

package/README.md

@@ -142,7 +142,7 @@ Full documentation with interactive examples: **[courthive.github.io/competition
 
 ## Testing
 
-**13,000+ tests** covering draw generation and exit propagation, scheduling, scoring, participants and entries, team competition, publishing and embargo, ranking points and ratings, officiating and sanctioning.
+**13,700+ tests** covering draw generation and exit propagation, scheduling, scoring, participants and entries, team competition, publishing and embargo, ranking points and ratings, officiating and sanctioning.
 
 Beyond conventional unit and integration tests, the suite includes relational property suites (do/undo, idempotence, monotonicity), agreement oracles, and an at-scale randomized sweep with delta-debugging for exit propagation — added because full branch coverage of a propagation guard proved compatible with hundreds of wrong answers.
 

package/dist/esm/assemblies/generators/mocks/processLeagueProfiles.mjs

@@ -6,13 +6,14 @@ import { isNumeric } from '../../../tools/math.mjs';
 import { ANY, MALE, OTHER, MIXED, FEMALE } from '../../../constants/genderConstants.mjs';
 import tieFormatDefaults from '../templates/tieFormatDefaults.mjs';
 import { AD_HOC, DOUBLE_ROUND_ROBIN, MAIN } from '../../../constants/drawDefinitionConstants.mjs';
+import '../../../helpers/keyValueScore/constants.mjs';
 import '../../../mutate/matchUps/schedule/byeScheduling.mjs';
 import { TEAM } from '../../../constants/participantConstants.mjs';
 import { DIRECT_ACCEPTANCE } from '../../../constants/entryStatusValues.mjs';
 import { UUID } from '../../../tools/UUID.mjs';
-import '../../../helpers/keyValueScore/constants.mjs';
 import { COMPETITOR } from '../../../constants/participantRoleValues.mjs';
 import '../../../types/tournamentTypes.mjs';
+import '../../../mutate/matchUps/matchUpStatus/sideStatusCodes.mjs';
 import '../../../query/drawDefinition/predictDrawCompetitiveBands.mjs';
 import { generateDrawDefinition } from '../drawDefinitions/generateDrawDefinition/generateDrawDefinition.mjs';
 import { addParticipants } from '../../../mutate/participants/addParticipants.mjs';

package/dist/esm/assemblies/governors/scoreGovernor/index.mjs

@@ -23,9 +23,9 @@ export { deduceMatchUpFormat } from '../../../query/scoring/deduceMatchUpFormat.
 export { generateScoreString } from '../../generators/matchUps/generateScoreString.mjs';
 export { generateTieMatchUpScore } from '../../generators/tieMatchUpScore/generateTieMatchUpScore.mjs';
 export { getEpisodes } from '../../../query/scoring/getEpisodes.mjs';
+export { getMaxSetScore, getSetComplement, getTiebreakComplement } from '../../../query/matchUp/getComplement.mjs';
 export { getScore } from '../../../query/scoring/getScore.mjs';
 export { getScoreboard } from '../../../query/scoring/getScoreboard.mjs';
-export { getSetComplement, getTiebreakComplement } from '../../../query/matchUp/getComplement.mjs';
 export { getWinner } from '../../../query/scoring/getWinner.mjs';
 export { inferServeSide } from '../../../mutate/scoring/serveSideCalculator.mjs';
 export { isComplete } from '../../../query/scoring/isComplete.mjs';
@@ -34,6 +34,7 @@ export { keyValueScore } from '../../../helpers/keyValueScore/keyValueScore.mjs'
 export { parse as parseMatchUpFormat } from '../../../helpers/matchUpFormatCode/parse.mjs';
 export { parseScoreString } from '../../../tools/parseScoreString.mjs';
 export { resolvePointValue } from '../../../mutate/scoring/resolvePointValue.mjs';
+export { retainScoreForFormat } from '../../../query/matchUp/retainScoreForFormat.mjs';
 export { reverseScore } from '../../generators/score/reverseScore.mjs';
 export { stringify as stringifyMatchUpFormat } from '../../../helpers/matchUpFormatCode/stringify.mjs';
 export { toStatObjects } from '../../../query/scoring/statistics/toStatObjects.mjs';

package/dist/esm/assemblies/governors/scoreGovernor/query.mjs

@@ -2,7 +2,8 @@ export { validateMatchUpScore, validateSetScore } from '../../../validators/vali
 export { isValidMatchUpFormat } from '../../../validators/isValidMatchUpFormat.mjs';
 export { validateTieFormat } from '../../../validators/validateTieFormat.mjs';
 export { validateScore } from '../../../validators/validateScore.mjs';
-export { getSetComplement, getTiebreakComplement } from '../../../query/matchUp/getComplement.mjs';
+export { getMaxSetScore, getSetComplement, getTiebreakComplement } from '../../../query/matchUp/getComplement.mjs';
+export { retainScoreForFormat } from '../../../query/matchUp/retainScoreForFormat.mjs';
 export { checkScoreHasValue } from '../../../query/matchUp/checkScoreHasValue.mjs';
 export { checkSetIsComplete } from '../../../query/matchUp/checkSetIsComplete.mjs';
 export { analyzeScore } from '../../../query/matchUp/analyzeScore.mjs';

package/dist/esm/constants/matchUpStatusConstants.mjs

@@ -1,4 +1,4 @@
-import { CANCELLED, ABANDONED, COMPLETED, DEAD_RUBBER, DEFAULTED, DOUBLE_WALKOVER, DOUBLE_DEFAULT, RETIRED, WALKOVER, TO_BE_PLAYED, SUSPENDED, NOT_PLAYED, INCOMPLETE, IN_PROGRESS, CHALLENGED, BYE, AWAITING_RESULT } from './matchUpStatusValues.mjs';
+import { ABANDONED, AWAITING_RESULT, CANCELLED, CHALLENGED, DEAD_RUBBER, IN_PROGRESS, INCOMPLETE, NOT_PLAYED, SUSPENDED, TO_BE_PLAYED, COMPLETED, DEFAULTED, DOUBLE_WALKOVER, DOUBLE_DEFAULT, RETIRED, WALKOVER, BYE } from './matchUpStatusValues.mjs';
 
 const recoveryTimeRequiredMatchUpStatuses = [
     AWAITING_RESULT,

package/dist/esm/fixtures/policies/POLICY_PROGRESSION_DEFAULT.mjs

@@ -2,7 +2,7 @@ import { POLICY_TYPE_PROGRESSION } from '../../constants/policyConstants.mjs';
 
 const POLICY_PROGRESSION_DEFAULT = {
     [POLICY_TYPE_PROGRESSION]: {
-        doubleExitPropagateBye: false,
+        doubleExitPropagateBye: true,
         autoPlaceQualifiers: false,
         autoReplaceQualifiers: false,
         autoRemoveQualifiers: false,

package/dist/esm/mutate/drawDefinitions/matchUpGovernor/{matchUpStatusCodes.mjs → recordSourceSideProvenance.mjs}

@@ -1,9 +1,9 @@
-import { producedExitStatus, mergeSideExitProvenance } from '../../matchUps/matchUpStatus/sideExitProvenance.mjs';
+import { mergeSideExitProvenance, producedExitStatus } from '../../matchUps/matchUpStatus/sideExitProvenance.mjs';
 import { getPairedPreviousMatchUp } from '../../../query/matchUps/getPairedPreviousMatchup.mjs';
 import { definedAttributes } from '../../../tools/definedAttributes.mjs';
 import { TO_BE_PLAYED } from '../../../constants/matchUpStatusValues.mjs';
 
-function updateMatchUpStatusCodes({ inContextDrawMatchUps, sourceMatchUpStatus, sourceMatchUpId, matchUpsMap, matchUp, }) {
+function recordSourceSideProvenance({ inContextDrawMatchUps, sourceMatchUpStatus, sourceMatchUpId, matchUpsMap, matchUp, }) {
     const sourceMatchUp = inContextDrawMatchUps.find((matchUp) => matchUp.matchUpId === sourceMatchUpId);
     const { pairedPreviousMatchUp } = getPairedPreviousMatchUp({
         structureId: sourceMatchUp?.structureId,
@@ -18,17 +18,6 @@ function updateMatchUpStatusCodes({ inContextDrawMatchUps, sourceMatchUpStatus,
                 (sourceMatchUp?.roundPosition < pairedMatchUp?.roundPosition && 1) || 2
             :
                 (sourceMatchUp.structureId === pairedMatchUp?.structureId && 2) || 1;
-        matchUp.matchUpStatusCodes = (matchUp.matchUpStatusCodes ?? []).map((code) => {
-            const value = typeof code === 'object' && code !== null ? code : { code: code ?? undefined };
-            if (value.sideNumber === sourceSideNumber) {
-                return {
-                    ...value,
-                    matchUpStatus: producedExitStatus(sourceMatchUpStatus),
-                    previousMatchUpStatus: sourceMatchUpStatus,
-                };
-            }
-            return value;
-        });
         if (sourceMatchUpStatus && sourceMatchUpStatus !== TO_BE_PLAYED) {
             mergeSideExitProvenance({
                 matchUp,
@@ -44,4 +33,4 @@ function updateMatchUpStatusCodes({ inContextDrawMatchUps, sourceMatchUpStatus,
     }
 }
 
-export { updateMatchUpStatusCodes };
+export { recordSourceSideProvenance };

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

@@ -1,5 +1,6 @@
-import { withdrawByeClaim, withdrawByeClaimsFrom, byeClaimSurvives, getNativeSideExitProvenance, projectExitStatusCodes, setSideExitProvenance, retainForeignProvenance, deriveExitStateFromProvenance } from '../../matchUps/matchUpStatus/sideExitProvenance.mjs';
+import { withdrawByeClaim, withdrawByeClaimsFrom, byeClaimSurvives, getSideExitProvenance, retainPolicyCodes, setSideExitProvenance, retainForeignProvenance, deriveExitStateFromProvenance } from '../../matchUps/matchUpStatus/sideExitProvenance.mjs';
 import { removeDirectedBye, removeDirectedWinner } from '../../matchUps/drawPositions/removeDirectedParticipants.mjs';
+import { propagatesByeOnDoubleExit } from '../../matchUps/drawPositions/propagatesByeOnDoubleExit.mjs';
 import { getPairedPreviousMatchUp } from '../../../query/matchUps/getPairedPreviousMatchup.mjs';
 import { modifyMatchUpScore } from '../../matchUps/score/modifyMatchUpScore.mjs';
 import { decorateResult } from '../../../functions/global/decorateResult.mjs';
@@ -98,7 +99,7 @@ function removeDoubleExit(params) {
         if (anotherClaimSurvives) {
             return decorateResult({ result: { ...SUCCESS }, stack });
         }
-        if (appliedPolicies?.progression?.doubleExitPropagateBye || byePropagatedToLoserMatchUp) {
+        if (propagatesByeOnDoubleExit(appliedPolicies) || byePropagatedToLoserMatchUp) {
             removeDirectedBye({
                 drawPosition: loserTargetDrawPosition,
                 targetLink: loserTargetLink,
@@ -133,7 +134,7 @@ function removeDoubleExit(params) {
     return decorateResult({ result: { ...SUCCESS }, stack });
 }
 function carriesWithdrawnOrigin(matchUp, withdrawnSourceIds) {
-    const provenance = getNativeSideExitProvenance({ matchUp });
+    const provenance = getSideExitProvenance({ matchUp });
     if (!provenance)
         return false;
     return [1, 2].some((sideNumber) => {
@@ -170,7 +171,7 @@ function withdrawExitFromByeChain({ inContextDrawMatchUps, withdrawnSourceIds, d
         keyColors,
     });
     const result = modifyMatchUpScore({
-        matchUpStatusCodes: unwound.provenance ? projectExitStatusCodes(unwound.provenance) : [],
+        matchUpStatusCodes: retainPolicyCodes(noContextTargetMatchUp),
         removeWinningSide: unwound.winningSide === undefined,
         matchUpStatus: unwound.matchUpStatus,
         matchUpId: fromMatchUp.matchUpId,
@@ -308,7 +309,7 @@ function conditionallyRemoveDrawPosition(params) {
     if (result.error)
         return decorateResult({ result, stack });
     const carriesSomethingOfThisCascade = carriesWithdrawnOrigin(noContextTargetMatchUp, withdrawnSourceIds);
-    const holdsProvenance = !!getNativeSideExitProvenance({ matchUp: noContextTargetMatchUp });
+    const holdsProvenance = !!getSideExitProvenance({ matchUp: noContextTargetMatchUp });
     if (holdsProvenance && !carriesSomethingOfThisCascade) {
         pushGlobalLog({
             method: stack,
@@ -329,7 +330,7 @@ function conditionallyRemoveDrawPosition(params) {
     const removeScore = !pairedPreviousDoubleExit;
     result = modifyMatchUpScore({
         ...params,
-        matchUpStatusCodes: unwound.provenance ? projectExitStatusCodes(unwound.provenance) : [],
+        matchUpStatusCodes: retainPolicyCodes(noContextTargetMatchUp),
         removeWinningSide: unwound.winningSide === undefined,
         matchUpId: targetMatchUp.matchUpId,
         matchUp: noContextTargetMatchUp,
@@ -384,10 +385,10 @@ function getUnwoundState({ pairedPreviousDoubleExit, noContextTargetMatchUp, wit
     if (noContextTargetMatchUp.matchUpStatus === BYE) {
         return {
             matchUpStatus: BYE,
-            provenance: retainForeignProvenance(getNativeSideExitProvenance({ matchUp: noContextTargetMatchUp }), withdrawnSourceIds),
+            provenance: retainForeignProvenance(getSideExitProvenance({ matchUp: noContextTargetMatchUp }), withdrawnSourceIds),
         };
     }
-    const retained = retainForeignProvenance(getNativeSideExitProvenance({ matchUp: noContextTargetMatchUp }), withdrawnSourceIds);
+    const retained = retainForeignProvenance(getSideExitProvenance({ matchUp: noContextTargetMatchUp }), withdrawnSourceIds);
     if (pairedPreviousDoubleExit) {
         return {
             matchUpStatus: [DOUBLE_DEFAULT, DEFAULTED].includes(noContextTargetMatchUp?.matchUpStatus) ? DEFAULTED : WALKOVER,
@@ -397,7 +398,7 @@ function getUnwoundState({ pairedPreviousDoubleExit, noContextTargetMatchUp, wit
     if (targetDrawPositionIsBye({ drawDefinition, noContextTargetMatchUp, targetMatchUp })) {
         return {
             matchUpStatus: BYE,
-            provenance: retainForeignProvenance(getNativeSideExitProvenance({ matchUp: noContextTargetMatchUp }), withdrawnSourceIds),
+            provenance: retainForeignProvenance(getSideExitProvenance({ matchUp: noContextTargetMatchUp }), withdrawnSourceIds),
         };
     }
     if (isDoubleExit(noContextTargetMatchUp?.matchUpStatus)) {

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

@@ -1,20 +1,23 @@
-import { propagateUnfillableLoserBye } from '../../matchUps/drawPositions/propagateUnfillableLoserBye.mjs';
-import { assignDrawPositionBye, advanceDrawPosition } from '../../matchUps/drawPositions/assignDrawPositionBye.mjs';
+import { advanceDrawPosition, assignDrawPositionBye } from '../../matchUps/drawPositions/assignDrawPositionBye.mjs';
 import { getPairedPreviousMatchUpIsDoubleExit } from '../../../query/matchUps/getPairedPreviousMatchUpIsDoubleExit.mjs';
-import { assignMatchUpDrawPosition, directWinner } from '../../matchUps/drawPositions/drawPositionPlacement.mjs';
+import { propagateUnfillableLoserBye } from '../../matchUps/drawPositions/propagateUnfillableLoserBye.mjs';
+import { releaseAdvancedDrawPosition } from '../../matchUps/drawPositions/releaseAdvancedDrawPosition.mjs';
+import { directWinner, assignMatchUpDrawPosition } from '../../matchUps/drawPositions/drawPositionPlacement.mjs';
+import { propagatesByeOnDoubleExit } from '../../matchUps/drawPositions/propagatesByeOnDoubleExit.mjs';
 import { getExitWinningSide } from '../matchUpGovernor/getExitWinningSide.mjs';
+import { getAllStructureMatchUps } from '../../../query/matchUps/getAllStructureMatchUps.mjs';
 import { modifyMatchUpScore } from '../../matchUps/score/modifyMatchUpScore.mjs';
 import { getPositionAssignments } from '../../../query/drawDefinition/positionsGetter.mjs';
+import { isFedLoserEligible } from '../../../query/matchUp/isFedLoserEligible.mjs';
+import { isExit, isAnyExit, isDoubleExit } from '../../../validators/isExit.mjs';
 import { getAllDrawMatchUps } from '../../../query/matchUps/drawMatchUps.mjs';
 import { decorateResult } from '../../../functions/global/decorateResult.mjs';
 import { positionTargets } from '../../../query/matchUp/positionTargets.mjs';
+import { getMatchUpsMap } from '../../../query/matchUps/getMatchUpsMap.mjs';
 import { pushGlobalLog } from '../../../functions/global/globalLog.mjs';
-import { isExit, isDoubleExit, isAnyExit } from '../../../validators/isExit.mjs';
-import { getAllStructureMatchUps } from '../../../query/matchUps/getAllStructureMatchUps.mjs';
-import { isFedLoserEligible } from '../../../query/matchUp/isFedLoserEligible.mjs';
 import { findStructure } from '../../../acquire/findStructure.mjs';
 import { overlap } from '../../../tools/arrays.mjs';
-import { producedExitStatus, recordByeClaim, buildCarriedExitProvenance, getSideExitProvenance, projectExitStatusCodes, mergeSideExitProvenance, collapseDoubleExitStatus, buildSideExitProvenance } from '../../matchUps/matchUpStatus/sideExitProvenance.mjs';
+import { getExitSides, getSideExitProvenance, buildCarriedExitProvenance, retainPolicyCodes, mergeSideExitProvenance, producedExitStatus, recordByeClaim, collapseDoubleExitStatus, buildSideExitProvenance, deriveExitStateFromProvenance, deriveStatusCodes } from '../../matchUps/matchUpStatus/sideExitProvenance.mjs';
 import { MISSING_STRUCTURE, MISSING_MATCHUP, DRAW_POSITION_ASSIGNED } from '../../../constants/errorConditionConstants.mjs';
 import { CONTAINER, FIRST_MATCHUP } from '../../../constants/drawDefinitionConstants.mjs';
 import { BYE } from '../../../constants/matchUpStatusValues.mjs';
@@ -51,7 +54,7 @@ function doubleExitAdvancement(params) {
         winnerStatus: winnerMatchUp?.matchUpStatus,
         winnerDP: JSON.stringify(winnerMatchUp?.drawPositions),
     });
-    const loserTargetStillOpen = !!(appliedPolicies?.progression?.doubleExitPropagateBye &&
+    const loserTargetStillOpen = !!(propagatesByeOnDoubleExit(appliedPolicies) &&
         loserMatchUp?.matchUpStatus === BYE &&
         loserTargetDrawPosition !== undefined &&
         !getPositionAssignments({
@@ -135,19 +138,21 @@ function doubleExitAdvancement(params) {
         });
         if (result.error)
             return decorateResult({ result, stack });
-        const refreshed = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
-        const carried = carryExitOnward({
-            fromMatchUp: refreshed.find((m) => m.matchUpId === loserMatchUp.matchUpId) ?? loserMatchUp,
-            EXIT: producedExitStatus(params.matchUpStatus),
-            originMatchUpId: sourceMatchUp?.matchUpId,
-            inContextDrawMatchUps: refreshed,
-            drawDefinition,
-            matchUpsMap,
-            params,
-            stack,
-        });
-        if (carried.error)
-            return decorateResult({ result: carried, stack });
+        if (result.stamped) {
+            const refreshed = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
+            const carried = carryExitOnward({
+                fromMatchUp: refreshed.find((m) => m.matchUpId === loserMatchUp.matchUpId) ?? loserMatchUp,
+                EXIT: producedExitStatus(params.matchUpStatus),
+                originMatchUpId: sourceMatchUp?.matchUpId,
+                inContextDrawMatchUps: refreshed,
+                drawDefinition,
+                matchUpsMap,
+                params,
+                stack,
+            });
+            if (carried.error)
+                return decorateResult({ result: carried, stack });
+        }
     }
     if (winnerMatchUp) {
         logAdvancement(stack, {
@@ -169,7 +174,7 @@ function doubleExitAdvancement(params) {
 }
 function handleLoserMatchUp({ loserMatchUpIsEmptyExit, loserMatchUpIsDoubleExit, loserTargetDrawPosition, appliedPolicies, tournamentRecord, drawDefinition, sourceMatchUp, loserMatchUp, targetLinks, matchUpsMap, params, event, stack, }) {
     const { loserTargetLink } = targetLinks;
-    const propagateBye = appliedPolicies?.progression?.doubleExitPropagateBye;
+    const propagateBye = propagatesByeOnDoubleExit(appliedPolicies);
     const targetFedIn = loserMatchUp.hasFedDrawPosition;
     if (propagateBye || targetFedIn) {
         logAdvancement(stack, {
@@ -230,12 +235,12 @@ function stampExitOnByeHeldLoserTarget({ loserTargetDrawPosition, drawDefinition
     const { positionAssignments } = getPositionAssignments({ structureId: loserMatchUp.structureId, drawDefinition });
     const targetAssignment = positionAssignments?.find((assignment) => assignment.drawPosition === loserTargetDrawPosition);
     if (targetAssignment?.bye || targetAssignment?.participantId)
-        return { ...SUCCESS };
+        return { ...SUCCESS, stamped: false };
     const drawPositions = loserMatchUp.drawPositions ?? [];
     const positionIndex = drawPositions.indexOf(loserTargetDrawPosition);
     const exitingSideNumber = loserMatchUp.feedRound ? 1 : positionIndex + 1;
     if (positionIndex === -1 || (exitingSideNumber !== 1 && exitingSideNumber !== 2)) {
-        return { ...SUCCESS };
+        return { ...SUCCESS, stamped: false };
     }
     const noContextLoserMatchUp = matchUpsMap.drawMatchUps.find((matchUp) => matchUp.matchUpId === loserMatchUp.matchUpId);
     if (!noContextLoserMatchUp)
@@ -258,7 +263,7 @@ function stampExitOnByeHeldLoserTarget({ loserTargetDrawPosition, drawDefinition
         exitingSideNumber,
     });
     const result = modifyMatchUpScore({
-        matchUpStatusCodes: projectExitStatusCodes(provenance),
+        matchUpStatusCodes: retainPolicyCodes(noContextLoserMatchUp),
         appliedPolicies: params.appliedPolicies,
         matchUpId: loserMatchUp.matchUpId,
         matchUp: noContextLoserMatchUp,
@@ -269,7 +274,7 @@ function stampExitOnByeHeldLoserTarget({ loserTargetDrawPosition, drawDefinition
     if (result.error)
         return result;
     mergeSideExitProvenance({ matchUp: noContextLoserMatchUp, provenance });
-    return { ...SUCCESS };
+    return { ...SUCCESS, stamped: true };
 }
 function handleEmptyExitLoser({ loserTargetDrawPosition, drawDefinition, sourceMatchUp, loserMatchUp, matchUpsMap, params, stack, }) {
     const DOUBLE_EXIT = collapseDoubleExitStatus([params.matchUpStatus, loserMatchUp?.matchUpStatus]);
@@ -293,7 +298,7 @@ function handleEmptyExitLoser({ loserTargetDrawPosition, drawDefinition, sourceM
             ...getSideExitProvenance({ matchUp: noContextLoserMatchUp }),
             ...arrivingProvenance,
         };
-        const matchUpStatusCodes = projectExitStatusCodes(provenance);
+        const matchUpStatusCodes = retainPolicyCodes(noContextLoserMatchUp);
         const result = modifyMatchUpScore({
             ...params,
             matchUp: noContextLoserMatchUp,
@@ -305,37 +310,48 @@ function handleEmptyExitLoser({ loserTargetDrawPosition, drawDefinition, sourceM
         if (result.error)
             return result;
         mergeSideExitProvenance({ matchUp: noContextLoserMatchUp, provenance });
-        const refreshed = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
-        const convergedTargets = positionTargets({
-            matchUpId: loserMatchUp.matchUpId,
-            inContextDrawMatchUps: refreshed,
+        const onward = advanceConvergedWinner({
+            convergedMatchUp: loserMatchUp,
             drawDefinition,
+            matchUpsMap,
+            DOUBLE_EXIT,
+            params,
+            stack,
         });
-        const convergedWinnerMatchUp = convergedTargets?.targetMatchUps?.winnerMatchUp;
-        if (convergedWinnerMatchUp) {
-            logAdvancement(stack, {
-                color: 'cyan',
-                decision: 'CONVERGED_advance_its_own_winner',
-                from: loserMatchUp.matchUpId,
-                to: convergedWinnerMatchUp.matchUpId,
-            });
-            const onward = conditionallyAdvanceDrawPosition({
-                ...params,
-                inContextDrawMatchUps: refreshed,
-                matchUpId: convergedWinnerMatchUp.matchUpId,
-                targetMatchUp: convergedWinnerMatchUp,
-                sourceMatchUp: inContextLoserMatchUp(refreshed, loserMatchUp.matchUpId) ?? loserMatchUp,
-                matchUpStatus: DOUBLE_EXIT,
-                drawDefinition,
-                matchUpsMap,
-            });
-            if (onward?.error)
-                return onward;
-        }
+        if (onward?.error)
+            return onward;
         return result;
     }
     return { ...SUCCESS };
 }
+function advanceConvergedWinner({ convergedMatchUp, drawDefinition, matchUpsMap, DOUBLE_EXIT, params, stack }) {
+    const refreshed = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
+    const convergedTargets = positionTargets({
+        matchUpId: convergedMatchUp.matchUpId,
+        inContextDrawMatchUps: refreshed,
+        drawDefinition,
+    });
+    const convergedWinnerMatchUp = convergedTargets?.targetMatchUps?.winnerMatchUp;
+    if (!convergedWinnerMatchUp)
+        return { ...SUCCESS };
+    logAdvancement(stack, {
+        color: 'cyan',
+        decision: 'CONVERGED_advance_its_own_winner',
+        from: convergedMatchUp.matchUpId,
+        to: convergedWinnerMatchUp.matchUpId,
+    });
+    return conditionallyAdvanceDrawPosition({
+        ...params,
+        walkoverWinningSide: undefined,
+        inContextDrawMatchUps: refreshed,
+        matchUpId: convergedWinnerMatchUp.matchUpId,
+        targetMatchUp: convergedWinnerMatchUp,
+        sourceMatchUp: inContextLoserMatchUp(refreshed, convergedMatchUp.matchUpId) ?? convergedMatchUp,
+        matchUpStatus: DOUBLE_EXIT,
+        drawDefinition,
+        matchUpsMap,
+    });
+}
 function inContextLoserMatchUp(inContextDrawMatchUps, matchUpId) {
     return inContextDrawMatchUps.find((candidate) => candidate.matchUpId === matchUpId);
 }
@@ -369,6 +385,20 @@ function conditionallyAdvanceDrawPosition(params) {
         EXIT,
     });
     if (sameStructure && overlap(sourceDrawPositions, targetMatchUpDrawPositions)) {
+        if (isDoubleExit(params.matchUpStatus)) {
+            for (const drawPosition of targetMatchUpDrawPositions.filter((position) => sourceDrawPositions.includes(position))) {
+                releaseAdvancedDrawPosition({
+                    fromRoundNumber: targetMatchUp.roundNumber,
+                    structureId: targetMatchUp.structureId,
+                    withdrawingExit: true,
+                    event: params.event,
+                    tournamentRecord,
+                    drawDefinition,
+                    drawPosition,
+                    matchUpsMap,
+                });
+            }
+        }
         targetMatchUpDrawPositions = targetMatchUpDrawPositions.filter((drawPosition) => !sourceDrawPositions.includes(drawPosition));
     }
     if (sameStructure && targetMatchUpDrawPositions.length > 1)
@@ -455,11 +485,7 @@ function conditionallyAdvanceDrawPosition(params) {
         sourceMatchUpStatus,
         sourceSideNumber,
     });
-    const provenance = {
-        ...getSideExitProvenance({ matchUp: noContextTargetMatchUp }),
-        ...newProvenance,
-    };
-    const matchUpStatusCodes = newProvenance ? projectExitStatusCodes(provenance) : [];
+    const matchUpStatusCodes = retainPolicyCodes(noContextTargetMatchUp);
     logAdvancement(stack, {
         color: 'brightgreen',
         keyColors: { matchUpStatus: 'brightcyan', winningSide: 'brightyellow' },
@@ -482,9 +508,27 @@ function conditionallyAdvanceDrawPosition(params) {
     if (result.error)
         return decorateResult({ result, stack });
     mergeSideExitProvenance({ matchUp: noContextTargetMatchUp, provenance: newProvenance });
+    const merged = getSideExitProvenance({ matchUp: noContextTargetMatchUp });
+    const bothDelivered = [1, 2].every((sideNumber) => isDoubleExit(merged?.[sideNumber]?.previousMatchUpStatus));
+    const convergedAfterMerge = bothDelivered && !targetHoldsBye;
+    {
+        const derived = bothDelivered ? deriveExitStateFromProvenance(merged) : undefined;
+        if (derived && !targetHoldsBye && derived.matchUpStatus !== noContextTargetMatchUp.matchUpStatus) {
+            const reconcile = modifyMatchUpScore({
+                ...params,
+                removeWinningSide: derived.winningSide === undefined,
+                winningSide: derived.winningSide,
+                matchUp: noContextTargetMatchUp,
+                matchUpStatus: derived.matchUpStatus,
+                matchUpStatusCodes: deriveStatusCodes(noContextTargetMatchUp)});
+            if (reconcile.error)
+                return decorateResult({ result: reconcile, stack });
+        }
+    }
     return advanceFromTarget({
         pairedPreviousMatchUpIsDoubleExit,
         targetMatchUpDrawPositions,
+        convergedAfterMerge,
         noContextTargetMatchUp,
         inContextDrawMatchUps,
         walkoverWinningSide,
@@ -529,7 +573,17 @@ function inferSourceSideNumber({ inContextPairedPreviousMatchUp, pairedPreviousM
     });
     return sourceSideNumber;
 }
-function advanceFromTarget({ pairedPreviousMatchUpIsDoubleExit, targetMatchUpDrawPositions, noContextTargetMatchUp, inContextDrawMatchUps, walkoverWinningSide, nextWinnerMatchUp, drawDefinition, existingExit, matchUpStatus, targetMatchUp, matchUpsMap, targetData, DOUBLE_EXIT, structure, params, stack, EXIT, }) {
+function advanceFromTarget({ pairedPreviousMatchUpIsDoubleExit, targetMatchUpDrawPositions, convergedAfterMerge, noContextTargetMatchUp, inContextDrawMatchUps, walkoverWinningSide, nextWinnerMatchUp, drawDefinition, existingExit, matchUpStatus, targetMatchUp, matchUpsMap, targetData, DOUBLE_EXIT, structure, params, stack, EXIT, }) {
+    if (convergedAfterMerge && !existingExit) {
+        return advanceConvergedWinner({
+            convergedMatchUp: targetMatchUp,
+            drawDefinition,
+            matchUpsMap,
+            DOUBLE_EXIT,
+            params,
+            stack,
+        });
+    }
     if (existingExit) {
         logAdvancement(stack, {
             color: 'brightred',
@@ -656,7 +710,7 @@ function advanceByeAdvancedDrawPosition({ nextWinnerMatchUpDrawPositions, nextWi
             }),
         };
         const result = modifyMatchUpScore({
-            matchUpStatusCodes: projectExitStatusCodes(provenance),
+            matchUpStatusCodes: retainPolicyCodes(noContextNextWinnerMatchUp),
             appliedPolicies: params.appliedPolicies,
             matchUpId: noContextNextWinnerMatchUp.matchUpId,
             matchUp: noContextNextWinnerMatchUp,
@@ -815,7 +869,7 @@ function carryExitOnward({ inContextDrawMatchUps, drawDefinition, matchUpsMap, o
         matchUpStatus: holdsBye ? BYE : EXIT,
     });
     const result = modifyMatchUpScore({
-        matchUpStatusCodes: projectExitStatusCodes(provenance),
+        matchUpStatusCodes: retainPolicyCodes(noContextNextWinnerMatchUp),
         matchUpId: noContextNextWinnerMatchUp.matchUpId,
         appliedPolicies: params.appliedPolicies,
         matchUp: noContextNextWinnerMatchUp,
@@ -927,5 +981,149 @@ function advanceByeToLoserMatchUp(params) {
         event,
     });
 }
+function settleHeldExits({ tournamentRecord, appliedPolicies, drawDefinition, event }) {
+    const stack = 'settleHeldExits';
+    if (!drawDefinition || propagatesByeOnDoubleExit(appliedPolicies))
+        return { ...SUCCESS };
+    const matchUpsMap = getMatchUpsMap({ drawDefinition });
+    const carried = new Set();
+    for (let pass = 0; pass < 16; pass++) {
+        const inContextDrawMatchUps = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
+        let held;
+        for (const matchUp of inContextDrawMatchUps) {
+            if (carried.has(matchUp.matchUpId))
+                continue;
+            held = getHeldExit({ inContextDrawMatchUps, drawDefinition, matchUpsMap, matchUp });
+            if (held)
+                break;
+        }
+        if (!held)
+            break;
+        carried.add(held.holder.matchUpId);
+        const params = {
+            matchUpStatus: held.origin.previousMatchUpStatus ?? held.origin.matchUpStatus,
+            tournamentRecord,
+            appliedPolicies,
+            event,
+        };
+        const result = carryExitOnward({
+            originMatchUpId: held.origin.sourceMatchUpId,
+            EXIT: held.origin.matchUpStatus,
+            fromMatchUp: held.holder,
+            inContextDrawMatchUps,
+            drawDefinition,
+            matchUpsMap,
+            params,
+            stack,
+        });
+        if (result?.error)
+            return decorateResult({ result, stack });
+    }
+    const crossed = crossLinksThroughByes({ tournamentRecord, drawDefinition, matchUpsMap, event, stack });
+    if (crossed.error)
+        return decorateResult({ result: crossed, stack });
+    return { ...SUCCESS };
+}
+function crossLinksThroughByes({ tournamentRecord, drawDefinition, matchUpsMap, event, stack }) {
+    for (let pass = 0; pass < 16; pass++) {
+        const inContextDrawMatchUps = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
+        const crossing = inContextDrawMatchUps
+            .map((matchUp) => getByeCrossing({ inContextDrawMatchUps, drawDefinition, matchUp }))
+            .find(Boolean);
+        if (!crossing)
+            break;
+        logAdvancement(stack, {
+            color: 'cyan',
+            decision: 'BYE_advancement_crosses_winner_link',
+            fromMatchUpId: crossing.matchUp.matchUpId,
+            winnerMatchUpId: crossing.winnerMatchUp.matchUpId,
+        });
+        const result = directWinner({
+            winnerMatchUpDrawPositionIndex: crossing.winnerMatchUpDrawPositionIndex,
+            winningDrawPosition: crossing.drawPosition,
+            winnerTargetLink: crossing.winnerTargetLink,
+            sourceMatchUpId: crossing.matchUp.matchUpId,
+            winnerMatchUp: crossing.winnerMatchUp,
+            projectedWinningSide: undefined,
+            sourceMatchUpStatus: undefined,
+            dualMatchUp: undefined,
+            inContextDrawMatchUps,
+            tournamentRecord,
+            drawDefinition,
+            matchUpsMap,
+            event,
+        });
+        if (result.error)
+            return result;
+        const after = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
+        const target = after.find((matchUp) => matchUp.matchUpId === crossing.winnerMatchUp.matchUpId);
+        if (!target?.sides?.some((side) => side.participantId === crossing.participantId))
+            break;
+    }
+    return { ...SUCCESS };
+}
+function getByeCrossing({ inContextDrawMatchUps, drawDefinition, matchUp }) {
+    if (matchUp.collectionId || !matchUp.winnerMatchUpId)
+        return undefined;
+    const occupants = (matchUp.sides ?? []).filter((side) => side.participantId && !side.bye);
+    if (occupants.length !== 1 || !matchUpHoldsBye({ drawDefinition, matchUp }))
+        return undefined;
+    const { targetMatchUps, targetLinks } = positionTargets({
+        matchUpId: matchUp.matchUpId,
+        inContextDrawMatchUps,
+        drawDefinition,
+    });
+    const winnerMatchUp = targetMatchUps?.winnerMatchUp;
+    const winnerTargetLink = targetLinks?.winnerTargetLink;
+    if (!winnerMatchUp || !winnerTargetLink || winnerMatchUp.structureId === matchUp.structureId)
+        return undefined;
+    if (winnerMatchUp.winningSide)
+        return undefined;
+    const [{ participantId, drawPosition }] = occupants;
+    if (winnerMatchUp.sides?.some((side) => side.participantId === participantId))
+        return undefined;
+    return {
+        winnerMatchUpDrawPositionIndex: targetMatchUps.winnerMatchUpDrawPositionIndex,
+        winnerTargetLink,
+        winnerMatchUp,
+        participantId,
+        drawPosition,
+        matchUp,
+    };
+}
+function getHeldExit({ inContextDrawMatchUps, drawDefinition, matchUpsMap, matchUp }) {
+    if (matchUp.collectionId || matchUp.winningSide || !matchUp.winnerMatchUpId)
+        return undefined;
+    if (matchUp.sides?.some((side) => side.participantId))
+        return undefined;
+    if (!matchUpHoldsBye({ drawDefinition, matchUp }))
+        return undefined;
+    const stored = matchUpsMap.drawMatchUps.find((candidate) => candidate.matchUpId === matchUp.matchUpId);
+    const [exitSideNumber] = getExitSides({ matchUp: stored });
+    const origin = exitSideNumber ? getSideExitProvenance({ matchUp: stored })?.[exitSideNumber] : undefined;
+    if (!origin?.sourceMatchUpId || !isExit(origin.matchUpStatus))
+        return undefined;
+    const target = inContextDrawMatchUps.find((candidate) => candidate.matchUpId === matchUp.winnerMatchUpId);
+    if (!target || target.winningSide)
+        return undefined;
+    const arrivalSideNumber = getExitArrivalSideNumber({
+        nextWinnerMatchUp: target,
+        sourceMatchUp: matchUp,
+        inContextDrawMatchUps,
+    });
+    if (!arrivalSideNumber)
+        return undefined;
+    if (target.sides?.some((side) => side.sideNumber === arrivalSideNumber && side.participantId))
+        return undefined;
+    const storedTarget = matchUpsMap.drawMatchUps.find((candidate) => candidate.matchUpId === target.matchUpId);
+    const targetProvenance = getSideExitProvenance({ matchUp: storedTarget });
+    if (targetProvenance?.[arrivalSideNumber])
+        return undefined;
+    const opponentSide = target.sides?.find((side) => side.sideNumber === 3 - arrivalSideNumber);
+    const settledNow = !!opponentSide?.participantId || !!opponentSide?.bye;
+    if (!settledNow)
+        return undefined;
+    return { holder: matchUp, origin };
+}
 
-export { doubleExitAdvancement };
+export { doubleExitAdvancement, settleHeldExits };