tods-competition-factory 7.1.1 → 7.2.0

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

@@ -150,6 +150,10 @@ function withdrawExitFromByeChain({ inContextDrawMatchUps, withdrawnSourceIds, d
     if (!noContextTargetMatchUp || !carriesWithdrawnOrigin(noContextTargetMatchUp, withdrawnSourceIds)) {
         return { ...SUCCESS };
     }
+    const priorWinningSide = noContextTargetMatchUp.winningSide;
+    const advancedDrawPosition = priorWinningSide
+        ? (noContextTargetMatchUp.drawPositions ?? [])[priorWinningSide - 1]
+        : undefined;
     const unwound = getUnwoundState({
         pairedPreviousDoubleExit: false,
         noContextTargetMatchUp,
@@ -191,6 +195,23 @@ function withdrawExitFromByeChain({ inContextDrawMatchUps, withdrawnSourceIds, d
     const nextWinnerMatchUp = targetMatchUps?.winnerMatchUp;
     if (!nextWinnerMatchUp?.matchUpId)
         return { ...SUCCESS };
+    if (advancedDrawPosition && nextWinnerMatchUp.structureId === fromMatchUp.structureId) {
+        pushGlobalLog({
+            method: 'withdrawExitFromByeChain',
+            decision: 'take_back_advanced_winner',
+            nextWinnerMatchUpId: nextWinnerMatchUp.matchUpId,
+            advancedDrawPosition,
+            color: 'brightcyan',
+            keyColors,
+        });
+        removeDirectedWinner({
+            winningDrawPosition: advancedDrawPosition,
+            winnerMatchUp: nextWinnerMatchUp,
+            inContextDrawMatchUps,
+            drawDefinition,
+            matchUpsMap,
+        });
+    }
     return withdrawExitFromByeChain({
         fromMatchUp: nextWinnerMatchUp,
         inContextDrawMatchUps,

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

@@ -1,3 +1,4 @@
+import { propagateUnfillableLoserBye } from '../../matchUps/drawPositions/propagateUnfillableLoserBye.mjs';
 import { assignDrawPositionBye, advanceDrawPosition } from '../../matchUps/drawPositions/assignDrawPositionBye.mjs';
 import { getPairedPreviousMatchUpIsDoubleExit } from '../../../query/matchUps/getPairedPreviousMatchUpIsDoubleExit.mjs';
 import { assignMatchUpDrawPosition, directWinner } from '../../matchUps/drawPositions/drawPositionPlacement.mjs';
@@ -638,7 +639,12 @@ function advanceByeAdvancedDrawPosition({ nextWinnerMatchUpDrawPositions, nextWi
         const advancingParticipantId = inContextDrawMatchUps
             .find((candidate) => candidate.matchUpId === noContextNextWinnerMatchUp.matchUpId)
             ?.sides?.find((side) => side.drawPosition === nextDrawPositionToAdvance)?.participantId;
-        const winningSide = advancingParticipantId || !occupiedSide ? occupiedSide : 3 - occupiedSide;
+        const arrivalSideNumber = getExitArrivalSideNumber({
+            inContextDrawMatchUps,
+            nextWinnerMatchUp,
+            sourceMatchUp: targetMatchUp,
+        });
+        const winningSide = advancingParticipantId || !occupiedSide ? occupiedSide : 3 - (arrivalSideNumber ?? occupiedSide);
         const exitingSideNumber = isExit(EXIT) && winningSide ? 3 - winningSide : undefined;
         const provenance = {
             ...getSideExitProvenance({ matchUp: noContextNextWinnerMatchUp }),
@@ -728,7 +734,9 @@ function opponentFeederCanDeliver({ inContextDrawMatchUps, nextWinnerMatchUp, so
         const holdsParticipant = feeder.sides?.some((side) => side.participantId);
         if (holdsParticipant)
             return true;
-        return !isAnyExit(feeder.matchUpStatus) && feeder.matchUpStatus !== BYE;
+        if (feeder.matchUpStatus === BYE)
+            return !!feeder.sides?.some((side) => side && !side.participantId && !side.bye);
+        return !isAnyExit(feeder.matchUpStatus);
     });
 }
 function matchUpHoldsBye({ drawDefinition, matchUp }) {
@@ -760,7 +768,15 @@ function carryExitOnward({ inContextDrawMatchUps, drawDefinition, matchUpsMap, o
     });
     if (!arrivalSideNumber)
         return decorateResult({ result: { ...SUCCESS }, stack });
-    if (nextWinnerMatchUp.sides?.some((side) => side.participantId) || isAnyExit(nextWinnerMatchUp.matchUpStatus)) {
+    const arrivingSideOccupied = !!nextWinnerMatchUp.sides?.some((side) => side?.sideNumber === arrivalSideNumber && side?.participantId);
+    if (arrivingSideOccupied || isAnyExit(nextWinnerMatchUp.matchUpStatus)) {
+        logAdvancement(stack, {
+            color: 'brightyellow',
+            decision: arrivingSideOccupied ? 'exit_not_carried_arriving_side_occupied' : 'exit_not_carried_convergence',
+            nextWinnerMatchUpId: nextWinnerMatchUp.matchUpId,
+            fromMatchUpId: fromMatchUp.matchUpId,
+            arrivalSideNumber,
+        });
         return decorateResult({ result: { ...SUCCESS }, stack });
     }
     const noContextNextWinnerMatchUp = matchUpsMap.drawMatchUps.find((matchUp) => matchUp.matchUpId === nextWinnerMatchUp.matchUpId);
@@ -777,6 +793,9 @@ function carryExitOnward({ inContextDrawMatchUps, drawDefinition, matchUpsMap, o
         });
         return decorateResult({ result: { ...SUCCESS }, stack });
     }
+    const opponentSideNumber = arrivalSideNumber === 1 ? 2 : 1;
+    const settledOpponentSide = nextWinnerMatchUp.sides?.find((side) => side?.sideNumber === opponentSideNumber && side?.participantId && !side?.bye);
+    const settledOpponentSideNumber = settledOpponentSide ? opponentSideNumber : undefined;
     const provenance = {
         ...getSideExitProvenance({ matchUp: noContextNextWinnerMatchUp }),
         ...buildCarriedExitProvenance({
@@ -800,7 +819,7 @@ function carryExitOnward({ inContextDrawMatchUps, drawDefinition, matchUpsMap, o
         matchUpId: noContextNextWinnerMatchUp.matchUpId,
         appliedPolicies: params.appliedPolicies,
         matchUp: noContextNextWinnerMatchUp,
-        winningSide: undefined,
+        winningSide: !holdsBye ? settledOpponentSideNumber : undefined,
         matchUpStatus: holdsBye ? BYE : EXIT,
         removeScore: true,
         drawDefinition,
@@ -808,6 +827,36 @@ function carryExitOnward({ inContextDrawMatchUps, drawDefinition, matchUpsMap, o
     if (result.error)
         return decorateResult({ result, stack });
     mergeSideExitProvenance({ matchUp: noContextNextWinnerMatchUp, provenance });
+    if (!holdsBye && settledOpponentSideNumber && settledOpponentSide?.drawPosition) {
+        logAdvancement(stack, {
+            color: 'brightcyan',
+            keyColors: { decision: 'brightgreen' },
+            decision: 'carried_exit_advances_settled_opponent',
+            nextWinnerMatchUpId: nextWinnerMatchUp.matchUpId,
+            drawPositionToAdvance: settledOpponentSide.drawPosition,
+            winningSide: settledOpponentSideNumber,
+        });
+        const advanced = advanceDrawPosition({
+            inContextDrawMatchUps: getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [],
+            drawPositionToAdvance: settledOpponentSide.drawPosition,
+            matchUpId: noContextNextWinnerMatchUp.matchUpId,
+            tournamentRecord: params.tournamentRecord,
+            event: params.event,
+            drawDefinition,
+            matchUpsMap,
+        });
+        if (advanced?.error)
+            return decorateResult({ result: advanced, stack });
+        const unfillable = propagateUnfillableLoserBye({
+            matchUpId: noContextNextWinnerMatchUp.matchUpId,
+            tournamentRecord: params.tournamentRecord,
+            event: params.event,
+            drawDefinition,
+            matchUpsMap,
+        });
+        if (unfillable?.error)
+            return decorateResult({ result: unfillable, stack });
+    }
     if (!holdsBye)
         return decorateResult({ result: { ...SUCCESS }, stack });
     const refreshed = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? inContextDrawMatchUps;

package/dist/esm/mutate/drawDefinitions/resetDrawDefinition.mjs

@@ -1,5 +1,6 @@
 import { modifyDrawNotice, modifyMatchUpNotice } from '../notifications/drawNotifications.mjs';
 import { normalizeDrawPositions } from '../matchUps/drawPositions/normalizeDrawPositions.mjs';
+import { clearSideExitProvenance } from '../matchUps/matchUpStatus/sideExitProvenance.mjs';
 import { getAllStructureMatchUps } from '../../query/matchUps/getAllStructureMatchUps.mjs';
 import { isLuckyBasedDraw } from '../../query/drawDefinition/isLuckyBasedDraw.mjs';
 import { removeExtension } from '../extensions/removeExtension.mjs';
@@ -144,7 +145,13 @@ function resetStructureMatchUps({ removeScheduling, tournamentRecord, removeAssi
         });
     }
 }
+function clearExitResidue(matchUp) {
+    if (matchUp.matchUpStatusCodes?.length)
+        matchUp.matchUpStatusCodes = [];
+    clearSideExitProvenance(matchUp);
+}
 function resetMatchUpScore({ matchUp, isLuckyDraw, removeAssignments, roundNumber, isRoundRobin, playedPositions }) {
+    clearExitResidue(matchUp);
     if (isLuckyDraw) {
         if (!removeAssignments && matchUp.matchUpStatus === BYE) ;
         else {

package/dist/esm/mutate/matchUps/drawPositions/assignDrawPositionBye.mjs

@@ -575,4 +575,4 @@ function assignFedDrawPositionBye({ byeFromPropagation, loserTargetDrawPosition,
     }
 }
 
-export { advanceDrawPosition, assignDrawPositionBye };
+export { advanceDrawPosition, assignDrawPositionBye, assignFedDrawPositionBye };

package/dist/esm/mutate/matchUps/drawPositions/drawPositionPlacement.mjs

@@ -6,7 +6,7 @@ import { getPairedPreviousMatchUpIsDoubleExit } from '../../../query/matchUps/ge
 import { getUpdatedDrawPositions } from '../../drawDefinitions/matchUpGovernor/getUpdatedDrawPositions.mjs';
 import { updateMatchUpStatusCodes } from '../../drawDefinitions/matchUpGovernor/matchUpStatusCodes.mjs';
 import { getStructureDrawPositionProfiles } from '../../../query/structure/getStructureDrawPositionProfiles.mjs';
-import { isPropagatedExit, clearResolvedSideExitProvenance } from '../matchUpStatus/sideExitProvenance.mjs';
+import { isPropagatedExit, isProjectedExitCode, clearResolvedSideExitProvenance } from '../matchUpStatus/sideExitProvenance.mjs';
 import { getExitWinningSide } from '../../drawDefinitions/matchUpGovernor/getExitWinningSide.mjs';
 import { removeLineUpSubstitutions } from '../../drawDefinitions/removeLineUpSubstitutions.mjs';
 import { getMatchUpsMap, getMappedStructureMatchUps } from '../../../query/matchUps/getMatchUpsMap.mjs';
@@ -26,6 +26,7 @@ import { getRoundMatchUps } from '../../../query/matchUps/getRoundMatchUps.mjs';
 import { decorateResult } from '../../../functions/global/decorateResult.mjs';
 import { getAllDrawMatchUps } from '../../../query/matchUps/drawMatchUps.mjs';
 import { positionTargets } from '../../../query/matchUp/positionTargets.mjs';
+import { propagateUnfillableLoserBye } from './propagateUnfillableLoserBye.mjs';
 import { assignDrawPositionBye } from './assignDrawPositionBye.mjs';
 import { getParticipantId } from '../../../functions/global/extractors.mjs';
 import { pushGlobalLog } from '../../../functions/global/globalLog.mjs';
@@ -106,7 +107,8 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
         !!matchUp?.roundNumber &&
         !!initialRoundNumber &&
         matchUp.roundNumber > initialRoundNumber;
-    if (matchUp && positionAdded) {
+    const resolvesPendingExit = !positionAdded && isPropagatedExit$1 && slotNewlyOccupied;
+    if (matchUp && (positionAdded || resolvesPendingExit)) {
         applyPositionToMatchUp({
             updatedDrawPositions,
             holdsPropagatedExit,
@@ -189,6 +191,15 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
     });
     if (byeResult?.error)
         return byeResult;
+    const unfillableResult = propagateUnfillableLoserBye({
+        matchUpId: matchUp?.matchUpId,
+        tournamentRecord,
+        drawDefinition,
+        matchUpsMap,
+        event,
+    });
+    if (unfillableResult?.error)
+        return unfillableResult;
     return { ...SUCCESS };
 }
 function resolveMatchUpStatus({ isByeMatchUp, matchUpStatus, isDoubleExitExit, matchUp }) {
@@ -200,10 +211,12 @@ function resolveMatchUpStatus({ isByeMatchUp, matchUpStatus, isDoubleExitExit, m
             matchUp.matchUpStatus) ||
         TO_BE_PLAYED);
 }
-function exitCodeString(code) {
+function policyCodeString(code) {
     if (typeof code === 'string')
         return code || undefined;
-    return code?.matchUpStatusCode ?? code?.code ?? code?.matchUpStatus ?? undefined;
+    if (isProjectedExitCode(code))
+        return undefined;
+    return code?.matchUpStatusCode ?? code?.code ?? undefined;
 }
 function applyPositionToMatchUp({ updatedDrawPositions, sourceMatchUpStatus, holdsPropagatedExit, isPropagatedExit, isDoubleExitExit, tournamentRecord, inContextMatchUp, sourceMatchUpId, drawDefinition, matchUpStatus, drawPosition, matchUpsMap, matchUpId, matchUp, stack, event, }) {
     const refreshedMatchUps = getAllDrawMatchUps({
@@ -222,7 +235,10 @@ function applyPositionToMatchUp({ updatedDrawPositions, sourceMatchUpStatus, hol
         undefined;
     if (advancedExitWinningSide && !isDoubleExitExit) {
         const exitSideNumber = advancedExitWinningSide === 1 ? 2 : 1;
-        const carriedCode = (matchUp.matchUpStatusCodes ?? []).map(exitCodeString).find(Boolean);
+        const carriedCode = (matchUp.matchUpStatusCodes ?? [])
+            .filter((code) => !isProjectedExitCode(code))
+            .map(policyCodeString)
+            .find(Boolean);
         const matchUpStatusCodes = [];
         if (carriedCode) {
             for (let i = 0; i < exitSideNumber - 1; i++)

package/dist/esm/mutate/matchUps/drawPositions/propagateUnfillableLoserBye.mjs

@@ -0,0 +1,63 @@
+import { getSideExitProvenance, carriedExitStatus, recordByeClaim } from '../matchUpStatus/sideExitProvenance.mjs';
+import { getPositionAssignments } from '../../../query/drawDefinition/positionsGetter.mjs';
+import { assignDrawPositionBye, assignFedDrawPositionBye } from './assignDrawPositionBye.mjs';
+import { getAllDrawMatchUps } from '../../../query/matchUps/drawMatchUps.mjs';
+import { positionTargets } from '../../../query/matchUp/positionTargets.mjs';
+import { isExit } from '../../../validators/isExit.mjs';
+
+function propagateUnfillableLoserBye({ tournamentRecord, drawDefinition, matchUpsMap, matchUpId, event, }) {
+    if (!matchUpId || !drawDefinition || !matchUpsMap)
+        return undefined;
+    const matchUp = matchUpsMap.drawMatchUps?.find((candidate) => candidate.matchUpId === matchUpId);
+    if (!matchUp?.winningSide || !isExit(matchUp.matchUpStatus))
+        return undefined;
+    const provenance = getSideExitProvenance({ matchUp }) ?? {};
+    const exitingSides = [1, 2].filter((sideNumber) => carriedExitStatus(provenance[sideNumber]));
+    if (exitingSides.length !== 1)
+        return undefined;
+    if (matchUp.winningSide === exitingSides[0])
+        return undefined;
+    const inContextDrawMatchUps = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
+    const inContextMatchUp = inContextDrawMatchUps.find((candidate) => candidate.matchUpId === matchUpId);
+    const { targetLinks: { loserTargetLink }, targetMatchUps: { loserMatchUp, loserTargetDrawPosition }, } = positionTargets({ inContextDrawMatchUps, drawDefinition, matchUpId });
+    if (!loserMatchUp || !loserTargetDrawPosition || !loserTargetLink)
+        return undefined;
+    if (loserMatchUp.structureId === inContextMatchUp?.structureId)
+        return undefined;
+    const { positionAssignments } = getPositionAssignments({ drawDefinition, structureId: loserMatchUp.structureId });
+    const targetAssignment = positionAssignments?.find((assignment) => assignment.drawPosition === loserTargetDrawPosition);
+    if (targetAssignment?.participantId || targetAssignment?.bye)
+        return undefined;
+    const result = loserMatchUp.roundNumber === 1
+        ? assignDrawPositionBye({
+            structureId: loserMatchUp.structureId,
+            drawPosition: loserTargetDrawPosition,
+            byeFromPropagation: true,
+            tournamentRecord,
+            drawDefinition,
+            matchUpsMap,
+            event,
+        })
+        : assignFedDrawPositionBye({
+            loserTargetDrawPosition,
+            byeFromPropagation: true,
+            loserTargetLink,
+            tournamentRecord,
+            drawDefinition,
+            loserMatchUp,
+            matchUpsMap,
+            event,
+        });
+    if (result?.error)
+        return result;
+    const refreshed = getAllDrawMatchUps({ inContext: true, drawDefinition, matchUpsMap })?.matchUps ?? [];
+    const inContextTarget = refreshed.find((candidate) => candidate.matchUpId === loserMatchUp.matchUpId);
+    const claimSideNumber = (inContextTarget?.sides ?? []).find((side) => side?.drawPosition === loserTargetDrawPosition)?.sideNumber;
+    if (claimSideNumber === 1 || claimSideNumber === 2) {
+        const rawLoserMatchUp = matchUpsMap.drawMatchUps?.find((candidate) => candidate.matchUpId === loserMatchUp.matchUpId);
+        recordByeClaim({ claimantMatchUpId: matchUpId, sideNumber: claimSideNumber, matchUp: rawLoserMatchUp });
+    }
+    return undefined;
+}
+
+export { propagateUnfillableLoserBye };

package/dist/esm/mutate/matchUps/matchUpStatus/sideExitProvenance.mjs

@@ -81,6 +81,17 @@ function clearSideExitProvenance(matchUp) {
     if (matchUp)
         delete matchUp.sideExitProvenance;
 }
+function retainByeClaimsOnly(provenance) {
+    if (!provenance)
+        return undefined;
+    const retained = {};
+    for (const sideNumber of [1, 2]) {
+        const claims = provenance[sideNumber]?.byeClaims;
+        if (claims?.length)
+            retained[sideNumber] = { byeClaims: [...claims] };
+    }
+    return Object.keys(retained).length ? retained : undefined;
+}
 function clearResolvedSideExitProvenance(matchUp) {
     if (!matchUp || isAnyExit(matchUp.matchUpStatus) || matchUp.matchUpStatus === BYE)
         return;
@@ -218,6 +229,13 @@ function projectExitStatusCodes(provenance) {
         sideNumber,
     }));
 }
+function isProjectedExitCode(code) {
+    if (!code || typeof code !== 'object')
+        return false;
+    if (code.matchUpStatusCode || code.code)
+        return false;
+    return !!(code.matchUpStatus || code.previousMatchUpStatus || code.sideNumber);
+}
 function isPropagatedExit({ matchUp }) {
     return !!getSideExitProvenance({ matchUp });
 }
@@ -304,4 +322,4 @@ function withdrawProducedExits({ mappedMatchUps, sourceMatchUpId, }) {
     return withdrawn;
 }
 
-export { buildCarriedExitProvenance, buildSideExitProvenance, byeClaimSurvives, carriedExitStatus, clearResolvedSideExitProvenance, clearSideExitProvenance, collapseDoubleExitStatus, deriveExitStateFromProvenance, exitOutcomeCode, exitProducedBy, getNativeSideExitProvenance, getSideExitProvenance, isPropagatedExit, mergeSideExitProvenance, producedExitStatus, projectExitStatusCodes, recordByeClaim, retainForeignProvenance, setSideExitProvenance, withdrawByeClaim, withdrawByeClaimsFrom, withdrawProducedExits };
+export { buildCarriedExitProvenance, buildSideExitProvenance, byeClaimSurvives, carriedExitStatus, clearResolvedSideExitProvenance, clearSideExitProvenance, collapseDoubleExitStatus, deriveExitStateFromProvenance, exitOutcomeCode, exitProducedBy, getNativeSideExitProvenance, getSideExitProvenance, isProjectedExitCode, isPropagatedExit, mergeSideExitProvenance, producedExitStatus, projectExitStatusCodes, recordByeClaim, retainByeClaimsOnly, retainForeignProvenance, setSideExitProvenance, withdrawByeClaim, withdrawByeClaimsFrom, withdrawProducedExits };

package/dist/esm/mutate/matchUps/score/modifyMatchUpScore.mjs

@@ -1,7 +1,7 @@
 import { updateAssignmentParticipantResults } from '../../drawDefinitions/matchUpGovernor/updateAssignmentParticipantResults.mjs';
 import { processCompetitionMatchUp } from '../../drawDefinitions/competition/processCompetitionMatchUp.mjs';
 import { updateInContextMatchUp, modifyMatchUpNotice } from '../../notifications/drawNotifications.mjs';
-import { clearResolvedSideExitProvenance } from '../matchUpStatus/sideExitProvenance.mjs';
+import { retainByeClaimsOnly, clearResolvedSideExitProvenance } from '../matchUpStatus/sideExitProvenance.mjs';
 import { getCompetitionPolicy } from '../../../query/drawDefinition/competition/getCompetitionPolicy.mjs';
 import { getAllStructureMatchUps } from '../../../query/matchUps/getAllStructureMatchUps.mjs';
 import { getAppliedPolicies } from '../../../query/extensions/getAppliedPolicies.mjs';
@@ -24,7 +24,7 @@ import { CONTAINER } from '../../../constants/drawDefinitionConstants.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';
 import { TEAM } from '../../../constants/matchUpTypes.mjs';
 import { completedMatchUpStatuses } from '../../../constants/matchUpStatusConstants.mjs';
-import { DEFAULTED, IN_PROGRESS, WALKOVER, DOUBLE_WALKOVER, AWAITING_RESULT, SUSPENDED, INCOMPLETE } from '../../../constants/matchUpStatusValues.mjs';
+import { DEFAULTED, BYE, IN_PROGRESS, WALKOVER, DOUBLE_WALKOVER, AWAITING_RESULT, SUSPENDED, INCOMPLETE } from '../../../constants/matchUpStatusValues.mjs';
 
 function modifyMatchUpScore(params) {
     const stack = 'modifyMatchUpScore';
@@ -158,7 +158,9 @@ function resolveDualMatchUpTarget({ isDualMatchUp, drawDefinition, matchUpId, ma
 function applyScoreAndStatus({ matchUpStatusCodes, removeWinningSide, matchUpStatus, matchUpFormat, removeScore, winningSide, matchUp, score, }) {
     const walkoverStatuses = new Set([WALKOVER, DOUBLE_WALKOVER]);
     if ((matchUpStatus && walkoverStatuses.has(matchUpStatus)) || removeScore) {
-        const survivingProvenance = isAnyExit(matchUpStatus) ? matchUp.sideExitProvenance : undefined;
+        const survivingProvenance = isAnyExit(matchUpStatus)
+            ? matchUp.sideExitProvenance
+            : retainByeClaimsOnly(matchUpStatus === BYE ? matchUp.sideExitProvenance : undefined);
         Object.assign(matchUp, { ...toBePlayed });
         if (survivingProvenance)
             matchUp.sideExitProvenance = survivingProvenance;

package/dist/esm/package.json.mjs

@@ -1,3 +1,3 @@
-var version = "7.1.1";
+var version = "7.2.0";
 
 export { version };

package/dist/esm/query/drawDefinition/getDrawInconsistencies.mjs

@@ -1,5 +1,6 @@
-import { getStructureInconsistencies, isPropagatedExit } from './getStructureInconsistencies.mjs';
-import { finalize } from '../integrity/inconsistency.mjs';
+import { isPropagatedExit } from '../../mutate/matchUps/matchUpStatus/sideExitProvenance.mjs';
+import { getStructureInconsistencies } from './getStructureInconsistencies.mjs';
+import { finalize, hasErrorSeverity } from '../integrity/inconsistency.mjs';
 import { isFedLoserEligible } from '../matchUp/isFedLoserEligible.mjs';
 import { getAllDrawMatchUps } from '../matchUps/drawMatchUps.mjs';
 import { WINNER, LOSER, QUALIFYING } from '../../constants/drawDefinitionConstants.mjs';
@@ -80,7 +81,7 @@ function droppedProgressionForLink(link, sourceStructure, sourceStructureMatchUp
         (!link.source?.roundNumber || matchUp.roundNumber === link.source.roundNumber));
     const inconsistencies = [];
     for (const matchUp of roundMatchUps) {
-        if (isPropagatedExit(matchUp))
+        if (isPropagatedExit({ matchUp }))
             continue;
         const loserSideNumber = matchUp.winningSide === 1 ? 2 : 1;
         const sideNumber = isLoserLink ? loserSideNumber : matchUp.winningSide;
@@ -152,7 +153,7 @@ function getDrawInconsistencies(params) {
     const progressionInconsistencies = getProgressionInconsistencies(drawDefinition, inContextDrawMatchUps, structureById);
     const combined = [...structureInconsistencies, ...linkInconsistencies, ...progressionInconsistencies];
     const finalized = finalize(combined, { scope: 'DRAW', drawId });
-    return { ...SUCCESS, valid: finalized.length === 0, inconsistencies: finalized };
+    return { ...SUCCESS, valid: !hasErrorSeverity(finalized), inconsistencies: finalized };
 }
 
 export { DANGLING_LINK, DROPPED_PROGRESSION, INELIGIBLE_PROGRESSION, LINK_MISSING_SOURCE_ROUND, SCAN_ERROR, getDrawInconsistencies };

package/dist/esm/query/drawDefinition/getStructureInconsistencies.mjs

@@ -1,8 +1,8 @@
-import { getNativeSideExitProvenance, isPropagatedExit as isPropagatedExit$1 } from '../../mutate/matchUps/matchUpStatus/sideExitProvenance.mjs';
-import { finalize } from '../integrity/inconsistency.mjs';
+import { isPropagatedExit, getNativeSideExitProvenance } from '../../mutate/matchUps/matchUpStatus/sideExitProvenance.mjs';
+import { finalize, hasErrorSeverity } from '../integrity/inconsistency.mjs';
 import { getAllDrawMatchUps } from '../matchUps/drawMatchUps.mjs';
 import { isExit, isAnyExit } from '../../validators/isExit.mjs';
-import { BYE, DOUBLE_WALKOVER, DOUBLE_DEFAULT } from '../../constants/matchUpStatusValues.mjs';
+import { BYE, DOUBLE_WALKOVER, DOUBLE_DEFAULT, TO_BE_PLAYED } from '../../constants/matchUpStatusValues.mjs';
 import { MISSING_DRAW_DEFINITION } from '../../constants/errorConditionConstants.mjs';
 import { CONTAINER } from '../../constants/drawDefinitionConstants.mjs';
 import { SUCCESS } from '../../constants/resultConstants.mjs';
@@ -16,13 +16,11 @@ const DRAW_POSITIONS_NOT_SORTED = 'DRAW_POSITIONS_NOT_SORTED';
 const EXIT_CODE_ON_WINNER_SIDE = 'EXIT_CODE_ON_WINNER_SIDE';
 const EXIT_WITHOUT_LOSER = 'EXIT_WITHOUT_LOSER';
 const PROPAGATED_EXIT_LOST = 'PROPAGATED_EXIT_LOST';
+const STALLED_POSITION = 'STALLED_POSITION';
 function codeString(code) {
     const value = typeof code === 'string' ? code : code?.code;
     return value || undefined;
 }
-function isPropagatedExit(matchUp) {
-    return isPropagatedExit$1({ matchUp });
-}
 function assignmentOccupied(assignment) {
     return !!(assignment && (assignment.participantId || assignment.bye || assignment.qualifier));
 }
@@ -150,6 +148,40 @@ function getLostPropagatedExitInconsistency(matchUp) {
         matchUpStatus,
     };
 }
+function getStalledPositionInconsistencies(scoped, allDrawMatchUps, roundRobinGroupStructureIds) {
+    const playableShape = (matchUp) => !matchUp.winningSide && (!matchUp.matchUpStatus || matchUp.matchUpStatus === TO_BE_PLAYED);
+    const occupants = (matchUp) => (matchUp.sides ?? []).filter((side) => side?.participantId && !side?.bye);
+    const drawMatchUps = allDrawMatchUps.filter((matchUp) => !matchUp.collectionId);
+    const anythingPlayable = drawMatchUps.some((matchUp) => playableShape(matchUp) && occupants(matchUp).length === 2);
+    if (anythingPlayable)
+        return [];
+    const hasStarted = drawMatchUps.some((matchUp) => matchUp.winningSide);
+    if (!hasStarted)
+        return [];
+    const inconsistencies = [];
+    for (const matchUp of scoped) {
+        if (roundRobinGroupStructureIds.has(matchUp.structureId))
+            continue;
+        if (matchUp.winningSide)
+            continue;
+        if ((matchUp.sides ?? []).some((side) => side?.bye))
+            continue;
+        const present = occupants(matchUp);
+        if (present.length !== 1)
+            continue;
+        inconsistencies.push({
+            matchUpId: matchUp.matchUpId,
+            structureId: matchUp.structureId,
+            issueType: STALLED_POSITION,
+            severity: 'warning',
+            message: `side ${present[0].sideNumber} holds a participant whose opponent can never arrive — ` +
+                `no matchUp in the draw is playable`,
+            sideNumber: present[0].sideNumber,
+            matchUpStatus: matchUp.matchUpStatus,
+        });
+    }
+    return inconsistencies;
+}
 function getStructureInconsistencies(params) {
     const { drawDefinition, structureId, matchUpsMap } = params;
     if (!drawDefinition)
@@ -160,6 +192,7 @@ function getStructureInconsistencies(params) {
     const inconsistencies = getPhantomPositionInconsistencies(drawDefinition, structureId);
     const roundRobinGroupStructureIds = new Set();
     collectRoundRobinGroupStructureIds(drawDefinition.structures, roundRobinGroupStructureIds);
+    inconsistencies.push(...getStalledPositionInconsistencies(scoped, inContextDrawMatchUps, roundRobinGroupStructureIds));
     for (const matchUp of scoped) {
         const { winningSide, matchUpStatus, matchUpStatusCodes, sides, matchUpId, drawPositions } = matchUp;
         const filledPositions = (drawPositions ?? []).filter((drawPosition) => typeof drawPosition === 'number');
@@ -205,7 +238,7 @@ function getStructureInconsistencies(params) {
             loserSide?.drawPosition &&
             !loserSide.participantId &&
             !loserSide.bye &&
-            !isPropagatedExit(matchUp)) {
+            !isPropagatedExit({ matchUp })) {
             inconsistencies.push({
                 ...base,
                 issueType: EXIT_WITHOUT_LOSER,
@@ -217,7 +250,7 @@ function getStructureInconsistencies(params) {
             inconsistencies.push(advancement);
     }
     const finalized = finalize(inconsistencies, { scope: 'STRUCTURE' });
-    return { ...SUCCESS, valid: finalized.length === 0, inconsistencies: finalized };
+    return { ...SUCCESS, valid: !hasErrorSeverity(finalized), inconsistencies: finalized };
 }
 
-export { BYE_ADVANCEMENT_MISSING, DRAW_POSITIONS_NOT_SORTED, DRAW_POSITION_UNASSIGNED, EXIT_CODE_ON_WINNER_SIDE, EXIT_WITHOUT_LOSER, PROPAGATED_EXIT_LOST, WINNER_NOT_ADVANCED, WINNING_SIDE_ADVANCEMENT_MISMATCH, WINNING_SIDE_WITHOUT_PARTICIPANT, getStructureInconsistencies, isPropagatedExit };
+export { BYE_ADVANCEMENT_MISSING, DRAW_POSITIONS_NOT_SORTED, DRAW_POSITION_UNASSIGNED, EXIT_CODE_ON_WINNER_SIDE, EXIT_WITHOUT_LOSER, PROPAGATED_EXIT_LOST, STALLED_POSITION, WINNER_NOT_ADVANCED, WINNING_SIDE_ADVANCEMENT_MISMATCH, WINNING_SIDE_WITHOUT_PARTICIPANT, getStructureInconsistencies };

package/dist/esm/query/drawDefinition/isActiveDownstream.mjs

@@ -41,8 +41,8 @@ function isActiveDownstream(params) {
         const provenance = getSideExitProvenance({ matchUp: candidate });
         return !occupiedSides.every((side) => provenance?.[side.sideNumber]);
     };
-    const winnerSideResolved = !!winnerMatchUp?.sides?.find((s) => s?.sideNumber === winnerMatchUp.winningSide)
-        ?.participant;
+    const winnerSideResolved = !!winnerMatchUp?.sides?.find((s) => s?.sideNumber === winnerMatchUp.winningSide)?.participant &&
+        !isPropagatedExit({ matchUp: winnerMatchUp });
     if (contestedDoubleExit(loserMatchUp) || contestedDoubleExit(winnerMatchUp)) {
         return true;
     }

package/dist/esm/query/event/getEventInconsistencies.mjs

@@ -1,6 +1,6 @@
 import { getDrawInconsistencies } from '../drawDefinition/getDrawInconsistencies.mjs';
 import { expectedParticipantType } from './participantTypeForEvent.mjs';
-import { finalize } from '../integrity/inconsistency.mjs';
+import { finalize, hasErrorSeverity } from '../integrity/inconsistency.mjs';
 import { getParticipants } from '../participants/getParticipants.mjs';
 import { MISSING_EVENT } from '../../constants/errorConditionConstants.mjs';
 import { INDIVIDUAL, PAIR } from '../../constants/participantConstants.mjs';
@@ -62,7 +62,7 @@ function getEventInconsistencies(params) {
     const typeMismatches = getParticipantTypeMismatches(params, participantMap);
     const combined = [...drawInconsistencies, ...typeMismatches];
     const finalized = finalize(combined, { scope: 'EVENT', eventId });
-    return { ...SUCCESS, valid: finalized.length === 0, inconsistencies: finalized };
+    return { ...SUCCESS, valid: !hasErrorSeverity(finalized), inconsistencies: finalized };
 }
 
 export { EVENT_PARTICIPANT_TYPE_MISMATCH, getEventInconsistencies };

package/dist/esm/query/integrity/inconsistency.mjs

@@ -18,6 +18,9 @@ function fnv1a(input) {
     }
     return (hash >>> 0).toString(16).padStart(8, '0');
 }
+function hasErrorSeverity(inconsistencies) {
+    return (inconsistencies ?? []).some((inconsistency) => inconsistency.severity === 'error');
+}
 function inconsistencyFingerprint(inc) {
     const key = IDENTITY_FIELDS.map((field) => `${field}=${inc[field] ?? ''}`).join('|');
     return fnv1a(key);
@@ -31,4 +34,4 @@ function finalize(inconsistencies, context) {
     });
 }
 
-export { finalize, inconsistencyFingerprint };
+export { finalize, hasErrorSeverity, inconsistencyFingerprint };

package/dist/esm/query/matchUps/scheduling/getMatchUpReadiness.mjs

@@ -116,6 +116,11 @@ function freeAfter(matchUp, timing) {
     const finish = finishOf(matchUp, timing);
     return finish === null ? null : finish + timing.recoveryMinutes;
 }
+function occupiedFrom(matchUp) {
+    return (parseClockMinutes(matchUp.schedule?.startTime) ??
+        parseClockMinutes(matchUp.schedule?.scheduledTime) ??
+        parseClockMinutes(matchUp.schedule?.endTime));
+}
 function skipReasonFor(target) {
     if (target.matchUpStatus === BYE)
         return 'bye';
@@ -213,6 +218,9 @@ function clashFindings(target, startMinutes, matchUps, timingFor) {
                 overlappedIds.add(clash.participantId);
             continue;
         }
+        const from = occupiedFrom(neighbour);
+        if (from !== null && from > startMinutes)
+            continue;
         const free = freeAfter(neighbour, timing);
         if (free === null || free <= startMinutes)
             continue;

package/dist/esm/query/tournaments/getTournamentInconsistencies.mjs

@@ -1,5 +1,5 @@
 import { getEventInconsistencies } from '../event/getEventInconsistencies.mjs';
-import { finalize } from '../integrity/inconsistency.mjs';
+import { finalize, hasErrorSeverity } from '../integrity/inconsistency.mjs';
 import { getParticipants } from '../participants/getParticipants.mjs';
 import { MISSING_TOURNAMENT_RECORD } from '../../constants/errorConditionConstants.mjs';
 import { INDIVIDUAL } from '../../constants/participantConstants.mjs';
@@ -42,7 +42,7 @@ function getTournamentInconsistencies(params) {
     const identityInconsistencies = getIdentityDuplications(tournamentRecord);
     const combined = [...eventInconsistencies, ...identityInconsistencies];
     const finalized = finalize(combined, { scope: 'TOURNAMENT', tournamentId });
-    return { ...SUCCESS, valid: finalized.length === 0, inconsistencies: finalized };
+    return { ...SUCCESS, valid: !hasErrorSeverity(finalized), inconsistencies: finalized };
 }
 
 export { PARTICIPANT_IDENTITY_DUPLICATION, getTournamentInconsistencies };