tods-competition-factory 7.6.0 → 7.7.0

package/README.md

@@ -142,7 +142,7 @@ Full documentation with interactive examples: **[courthive.github.io/competition
 
 ## Testing
 
-**15,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.
+**15,800+ 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/acquire/findStructure.mjs

@@ -1,6 +1,7 @@
 import { checkRequiredParameters } from '../helpers/parameters/checkRequiredParameters.mjs';
 import { firstClassOrExtension } from './firstClassOrExtension.mjs';
 import { structureSort } from '../functions/sorters/structureSort.mjs';
+import { structuresOf } from './structureMembers.mjs';
 import { MISSING_DRAW_DEFINITION, MISSING_STRUCTURES, STRUCTURE_NOT_FOUND } from '../constants/errorConditionConstants.mjs';
 import { STRUCTURE_ID, DRAW_DEFINITION } from '../constants/attributeConstants.mjs';
 import { validStages, ITEM } from '../constants/drawDefinitionConstants.mjs';
@@ -13,13 +14,14 @@ function findStructure(params) {
     const { drawDefinition, structureId } = params;
     const { structures } = getDrawStructures({ drawDefinition });
     const allStructures = structures?.flatMap((structure) => {
-        return structure.structures ? [...structure.structures].concat(structure) : structure;
+        const contained = structuresOf(structure);
+        return contained ? [...contained].concat(structure) : structure;
     });
     const structure = allStructures?.find((structure) => structure.structureId === structureId);
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
     const containingStructure = structure.structureType === ITEM
-        ? allStructures?.find((s) => s.structures?.some((s) => s.structureId === structureId))
+        ? allStructures?.find((s) => structuresOf(s)?.some((s) => s.structureId === structureId))
         : undefined;
     return { structure, containingStructure };
 }

package/dist/esm/acquire/structureMembers.mjs

@@ -0,0 +1,11 @@
+function matchUpsOf(structure) {
+    return structure && 'matchUps' in structure ? structure.matchUps : undefined;
+}
+function positionAssignmentsOf(structure) {
+    return structure && 'positionAssignments' in structure ? structure.positionAssignments : undefined;
+}
+function structuresOf(structure) {
+    return structure && 'structures' in structure ? structure.structures : undefined;
+}
+
+export { matchUpsOf, positionAssignmentsOf, structuresOf };

package/dist/esm/assemblies/engines/scoring/ScoringEngine.mjs

@@ -13,6 +13,25 @@ import { nowIso } from '../../../tools/clock.mjs';
 import { addPoint, deriveServer, deriveServerBase, checkStandardSetWon, checkAndFinalizeMatch } from '../../../mutate/scoring/addPoint.mjs';
 import { COMPLETED, TO_BE_PLAYED, IN_PROGRESS } from '../../../constants/matchUpStatusValues.mjs';
 
+function deriveInitialLineUps(matchUp) {
+    const sides = (matchUp.sides ?? []).filter((side) => side.lineUp?.length);
+    if (!sides.length)
+        return undefined;
+    const lineUps = {};
+    for (const side of sides)
+        lineUps[side.sideNumber] = side.lineUp.map((tc) => ({ ...tc }));
+    const entries = matchUp.history?.entries;
+    const substitutions = entries
+        ? entries.filter((e) => e.type === 'substitution').map((e) => e.data)
+        : (matchUp.history?.substitutions ?? []);
+    for (const sub of [...substitutions].reverse()) {
+        const lineUp = lineUps[sub.sideNumber];
+        const index = lineUp?.findIndex((tc) => tc.participantId === sub.inParticipantId) ?? -1;
+        if (index !== -1)
+            lineUp[index] = { ...lineUp[index], participantId: sub.outParticipantId };
+    }
+    return lineUps;
+}
 class ScoringEngine {
     constructor(options = {}) {
         this.pointMultipliers = [];
@@ -43,6 +62,7 @@ class ScoringEngine {
         this.isDoubles = matchUp.matchUpType === 'DOUBLES';
         this.redoStack = [];
         this.initialScore = undefined;
+        this.initialLineUps = deriveInitialLineUps(matchUp);
         this.cacheFormatStructure();
     }
     getState() {
@@ -53,18 +73,15 @@ class ScoringEngine {
         const prevTotalGames = this.state.score.sets.reduce((sum, s) => sum + (s.side1Score || 0) + (s.side2Score || 0), 0);
         const prevCompletedSets = this.state.score.sets.filter((s) => s.winningSide !== undefined).length;
         const prevComplete = this.state.matchUpStatus === COMPLETED;
-        const activePlayersSnapshot = this.hasLineUp() ? this.getActivePlayers() : undefined;
+        const activePlayers = this.activePlayersForPoint();
         this.state = addPoint(this.state, options, {
             pointMultipliers: this.pointMultipliers,
         });
-        if (activePlayersSnapshot) {
+        if ((this.state.history?.points.length || 0) === pointIndex)
+            return;
+        if (activePlayers) {
             const lastPoint = this.state.history.points[this.state.history.points.length - 1];
-            if (this.isDoubles) {
-                lastPoint.activePlayers = [activePlayersSnapshot.side1, activePlayersSnapshot.side2];
-            }
-            else {
-                lastPoint.activePlayers = [activePlayersSnapshot.side1[0] || '', activePlayersSnapshot.side2[0] || ''];
-            }
+            lastPoint.activePlayers = activePlayers;
         }
         if (options.penaltyType) {
             const lastPoint = this.state.history.points[this.state.history.points.length - 1];
@@ -393,6 +410,12 @@ class ScoringEngine {
     hasLineUp() {
         return this.state.sides.some((s) => s.lineUp && s.lineUp.length > 0);
     }
+    activePlayersForPoint() {
+        if (!this.hasLineUp())
+            return undefined;
+        const { side1, side2 } = this.getActivePlayers();
+        return this.isDoubles ? [side1, side2] : [side1[0] || '', side2[0] || ''];
+    }
     setPointMultipliers(multipliers) {
         this.pointMultipliers = multipliers;
     }
@@ -445,8 +468,14 @@ class ScoringEngine {
         const point = this.state.history?.points[pointIndex];
         if (point) {
             Object.assign(point, metadata);
+            const entry = this.pointEntry(pointIndex);
+            if (entry)
+                Object.assign(entry.data, metadata);
         }
     }
+    pointEntry(pointIndex) {
+        return this.state.history?.entries?.find((e) => e.type === 'point' && e.pointIndex === pointIndex);
+    }
     markHardBoundary(options) {
         const set = this.state.score.sets[options.setIndex];
         if (!set)
@@ -463,32 +492,32 @@ class ScoringEngine {
             return;
         const shouldRecalculate = options?.recalculate !== false;
         const point = points[pointIndex];
-        if (newData.winner !== undefined)
-            point.winner = newData.winner;
-        if (newData.server !== undefined)
-            point.server = newData.server;
-        if (newData.timestamp !== undefined)
-            point.timestamp = newData.timestamp;
-        if (newData.rallyLength !== undefined)
-            point.rallyLength = newData.rallyLength;
-        if (newData.wrongSide !== undefined)
-            point.wrongSide = newData.wrongSide;
-        if (newData.wrongServer !== undefined)
-            point.wrongServer = newData.wrongServer;
-        if (newData.penaltyPoint !== undefined)
-            point.penaltyPoint = newData.penaltyPoint;
+        const entry = this.pointEntry(pointIndex);
+        const edits = Object.fromEntries(Object.entries(newData).filter(([, value]) => value !== undefined));
+        const pointEdits = { ...edits };
+        const entryEdits = { ...edits };
+        if (edits.winner !== undefined) {
+            pointEdits.winningSide = edits.winner + 1;
+            entryEdits.winningSide = undefined;
+        }
+        else if (edits.winningSide !== undefined) {
+            pointEdits.winner = edits.winningSide - 1;
+            entryEdits.winner = undefined;
+        }
+        if (edits.server !== undefined) {
+            pointEdits.serverSideNumber = edits.server + 1;
+            entryEdits.serverSideNumber = undefined;
+        }
+        else if (edits.serverSideNumber !== undefined) {
+            pointEdits.server = edits.serverSideNumber - 1;
+            entryEdits.server = undefined;
+        }
+        Object.assign(point, pointEdits);
+        if (entry)
+            Object.assign(entry.data, entryEdits);
         if (!shouldRecalculate)
             return;
         const entries = this.state.history?.entries;
-        if (entries) {
-            const pointEntry = entries.find((e) => e.type === 'point' && e.pointIndex === pointIndex);
-            if (pointEntry) {
-                if (newData.winner !== undefined)
-                    pointEntry.data.winner = newData.winner;
-                if (newData.server !== undefined)
-                    pointEntry.data.server = newData.server;
-            }
-        }
         if (entries && entries.length > 0) {
             this.rebuildFromEntries();
         }
@@ -691,12 +720,19 @@ class ScoringEngine {
         this.state = newState;
         for (const entry of entries) {
             switch (entry.type) {
-                case 'point':
+                case 'point': {
+                    const activePlayers = this.activePlayersForPoint();
+                    const pointCount = this.state.history?.points.length || 0;
                     this.state = addPoint(this.state, entry.data, {
                         pointMultipliers: this.pointMultipliers,
                     });
                     this.state.history.entries = newState.history.entries;
+                    const points = this.state.history.points;
+                    const played = points.length > pointCount ? points.at(-1) : undefined;
+                    if (activePlayers && played)
+                        played.activePlayers = activePlayers;
                     break;
+                }
                 case 'set':
                     this.applyAddSet(entry.data);
                     break;
@@ -759,6 +795,11 @@ class ScoringEngine {
             matchUpId: this.matchUpId,
             isDoubles: this.isDoubles,
         });
+        for (const side of newState.sides) {
+            const lineUp = this.state.sides.find((s) => s.sideNumber === side.sideNumber)?.lineUp;
+            if (lineUp)
+                side.lineUp = lineUp.map((tc) => ({ ...tc }));
+        }
         if (this.initialScore) {
             this.applyInitialScore(newState, this.initialScore);
             if (newState.matchUpStatus === TO_BE_PLAYED) {
@@ -766,15 +807,24 @@ class ScoringEngine {
             }
         }
         for (const point of currentPoints) {
+            const pointCount = newState.history?.points.length || 0;
             newState = addPoint(newState, {
                 winner: point.winner,
                 server: point.server,
                 timestamp: point.timestamp,
                 rallyLength: point.rallyLength,
                 result: point.result,
+                penaltyType: point.penaltyType,
+                penaltyPoint: point.penaltyPoint,
+                wrongSide: point.wrongSide,
+                wrongServer: point.wrongServer,
             }, {
                 pointMultipliers: this.pointMultipliers,
             });
+            const replayed = newState.history?.points ?? [];
+            const played = replayed.length > pointCount ? replayed.at(-1) : undefined;
+            if (point.activePlayers && played)
+                played.activePlayers = point.activePlayers;
         }
         this.state = newState;
     }

package/dist/esm/assemblies/generators/drawDefinitions/autoSeeding.mjs

@@ -25,14 +25,16 @@ function autoSeeding({ tournamentRecord, drawDefinition, policyDefinitions, scal
         entries,
         stage,
     }).scaledEntries ?? [];
-    const { scaleItemsWithParticipantIds } = generateSeedingScaleItems({
+    const seedingResult = generateSeedingScaleItems({
         scaleAttributes,
         scaledEntries,
         stageEntries,
         seedsCount,
         scaleName,
     });
-    return { scaleItemsWithParticipantIds };
+    if (seedingResult.error)
+        return seedingResult;
+    return { scaleItemsWithParticipantIds: seedingResult.scaleItemsWithParticipantIds };
 }
 
 export { autoSeeding };

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/adHoc/drawMatic/drawMatic.mjs

@@ -50,8 +50,6 @@ function drawMatic(params) {
     return { ...SUCCESS, matchUps, roundResults };
 }
 function getAdHocStructure(params) {
-    if (params.structureId)
-        return params.structureId;
     const drawDefinition = params.drawDefinition;
     const targetStructure = drawDefinition?.structures
         ?.filter((structure) => structure.stageSequence === 1)
@@ -60,7 +58,7 @@ function getAdHocStructure(params) {
         const structureIsAdHoc = isAdHoc({ structure });
         return structureIsAdHoc && orderNumber > (stageOrder[targetStructure?.stage] || 1) ? structure : targetStructure;
     }, undefined);
-    const structure = drawDefinition?.structures?.find((structure) => structure.structureId === targetStructure?.structureId);
+    const structure = drawDefinition?.structures?.find((structure) => structure.structureId === (params.structureId ?? targetStructure?.structureId));
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
     const structureIsAdHoc = isAdHoc({ structure });

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/adHoc/drawMatic/generateDrawMaticRound.mjs

@@ -1,9 +1,10 @@
 import { getCompetitionPolicy } from '../../../../../../query/drawDefinition/competition/getCompetitionPolicy.mjs';
 import { getCompetitionState } from '../../../../../../query/drawDefinition/competition/getCompetitionState.mjs';
 import { buildIndividualIdsMap } from '../../../../../../query/participants/individualParticipantIds.mjs';
-import { generateDynamicRatings } from '../../../../scales/generateDynamicRatings.mjs';
 import { generateAdHocMatchUps } from '../generateAdHocMatchUps.mjs';
+import { generateDynamicRatings } from '../../../../scales/generateDynamicRatings.mjs';
 import { findStructure } from '../../../../../../acquire/findStructure.mjs';
+import { matchUpsOf } from '../../../../../../acquire/structureMembers.mjs';
 import { getPairingsData } from './getPairingsData.mjs';
 import { getEncounters } from './getEncounters.mjs';
 import { getPairings } from './getPairings.mjs';
@@ -27,7 +28,7 @@ function generateDrawMaticRound(params) {
         return { error: MISSING_STRUCTURE };
     if (!participantIds?.length)
         return { error: MISSING_PARTICIPANT_IDS };
-    const consideredMatchUps = [...(iterationMatchUps ?? []), ...(structure?.matchUps ?? [])];
+    const consideredMatchUps = [...(iterationMatchUps ?? []), ...(matchUpsOf(structure) ?? [])];
     const { encounters } = getEncounters({ matchUps: consideredMatchUps });
     const tournamentParticipants = tournamentRecord?.participants ?? [];
     let modifiedScaleValues = {};
@@ -43,10 +44,10 @@ function generateDrawMaticRound(params) {
         }
     }
     else if (dynamicRatings) {
-        const roundNumbers = unique(structure?.matchUps ? structure.matchUps.map(({ roundNumber }) => roundNumber) : []);
+        const roundNumbers = unique(matchUpsOf(structure)?.map(({ roundNumber }) => roundNumber) ?? []);
         const lastRoundNumber = Math.max(...roundNumbers, 0);
         if (lastRoundNumber) {
-            const matchUpIds = structure?.matchUps
+            const matchUpIds = matchUpsOf(structure)
                 ?.filter(({ roundNumber }) => roundNumber === lastRoundNumber)
                 .map(({ matchUpId }) => matchUpId);
             const result = generateDynamicRatings({

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/adHoc/getAvailableMatchUpsCount.mjs

@@ -1,4 +1,5 @@
 import { checkRequiredParameters } from '../../../../../helpers/parameters/checkRequiredParameters.mjs';
+import { matchUpsOf, structuresOf } from '../../../../../acquire/structureMembers.mjs';
 import { MISSING_STRUCTURE_ID, STRUCTURE_NOT_FOUND, INVALID_STRUCTURE } from '../../../../../constants/errorConditionConstants.mjs';
 import { STRUCTURE_SELECTED_STATUSES } from '../../../../../constants/entryStatusConstants.mjs';
 import { ROUND_OUTCOME } from '../../../../../constants/drawDefinitionConstants.mjs';
@@ -16,13 +17,13 @@ function getAvailableMatchUpsCount(params) {
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
     let structureHasRoundPositions;
-    const existingMatchUps = structure.matchUps ?? [];
+    const existingMatchUps = matchUpsOf(structure) ?? [];
     const lastRoundNumber = existingMatchUps?.reduce((roundNumber, matchUp) => {
         if (matchUp.roundPosition)
             structureHasRoundPositions = true;
         return (matchUp?.roundNumber || 0) > roundNumber ? matchUp.roundNumber : roundNumber;
     }, 0);
-    if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
+    if (structuresOf(structure) || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
         return { error: INVALID_STRUCTURE };
     }
     const selectedEntries = drawDefinition?.entries?.filter((entry) => {
@@ -31,7 +32,7 @@ function getAvailableMatchUpsCount(params) {
     }) ?? [];
     const roundMatchUpsCount = Math.floor(selectedEntries?.length / 2) || 1;
     const targetRoundNumber = roundNumber ?? lastRoundNumber ?? 1;
-    const existingRoundMatchUps = structure.matchUps?.filter((matchUp) => matchUp.roundNumber === targetRoundNumber)?.length ?? 0;
+    const existingRoundMatchUps = matchUpsOf(structure)?.filter((matchUp) => matchUp.roundNumber === targetRoundNumber)?.length ?? 0;
     const maxRemaining = roundMatchUpsCount - existingRoundMatchUps;
     const availableMatchUpsCount = maxRemaining > 0 ? maxRemaining : 0;
     return { ...SUCCESS, availableMatchUpsCount, lastRoundNumber, roundMatchUpsCount };

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/adHoc/swiss/generateSwissRound.mjs

@@ -7,6 +7,7 @@ import { getParticipantIds } from '../drawMatic/getParticipantIds.mjs';
 import { generateAdHocMatchUps } from '../generateAdHocMatchUps.mjs';
 import { getAdHocRatings } from '../drawMatic/getAdHocRatings.mjs';
 import { generateSwissPairings } from './swissPairing.mjs';
+import { positionAssignmentsOf, matchUpsOf } from '../../../../../../acquire/structureMembers.mjs';
 import { findStructure } from '../../../../../../acquire/findStructure.mjs';
 import { findExtension } from '../../../../../../acquire/findExtension.mjs';
 import { WINNER, QUALIFYING } from '../../../../../../constants/drawDefinitionConstants.mjs';
@@ -28,7 +29,7 @@ function generateSwissRound(params) {
     if (idsResult.error)
         return idsResult;
     const entryParticipantIds = idsResult.participantIds ?? [];
-    const positionParticipantIds = structure.positionAssignments
+    const positionParticipantIds = positionAssignmentsOf(structure)
         ?.map((pa) => pa.participantId)
         .filter((pid) => !!pid) ?? [];
     const qualifierWinnerIds = getQualifierWinners({ drawDefinition, targetStructureId: structure.structureId });
@@ -63,7 +64,7 @@ function generateSwissRound(params) {
     }
     const swissPolicy = params.swissPolicy ??
         findExtension({ element: drawDefinition, name: 'swissPolicy' })?.extension?.value;
-    const existingMatchUps = structure.matchUps ?? [];
+    const existingMatchUps = matchUpsOf(structure) ?? [];
     const { participantIdPairings, byeParticipantId } = generateSwissPairings({
         allowDraws: swissPolicy?.allowDraws,
         matchUps: existingMatchUps,

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/generateVoluntaryConsolation.mjs

@@ -49,7 +49,8 @@ function generateVoluntaryConsolation(params) {
     const structureCount = stageStructures.length;
     if (structureCount > 1)
         return { error: STAGE_SEQUENCE_LIMIT };
-    if (stageStructures?.[0]?.matchUps?.length)
+    const existingMatchUps = getAllStructureMatchUps({ structure: stageStructures?.[0] }).matchUps;
+    if (existingMatchUps.length)
         return { error: EXISTING_STRUCTURE };
     const structureId = stageStructures?.[0]?.structureId;
     Object.assign(params, definedAttributes({

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/luckyDraw.mjs

@@ -70,7 +70,9 @@ function luckyRoundProfiles(drawSize) {
     const intDrawSize = ensureInt(drawSize);
     let participantsCount = intDrawSize % 2 ? intDrawSize + 1 : intDrawSize;
     const preFeedRound = !!(Math.ceil(participantsCount / 2) % 2);
-    const rounds = [{ participantsCount, preFeedRound }];
+    const rounds = [
+        { participantsCount, preFeedRound },
+    ];
     while (participantsCount > 2) {
         const nextRound = Math.ceil(participantsCount / 2);
         const nextIsFinal = nextRound === 1;

package/dist/esm/assemblies/generators/drawDefinitions/generateAndPopulatePlayoffStructures.mjs

@@ -5,6 +5,7 @@ import { generatePlayoffStructures } from './drawTypes/playoffStructures.mjs';
 import { directParticipants } from '../../../mutate/matchUps/drawPositions/directParticipants.mjs';
 import { resolveTieFormat } from '../../../query/hierarchical/tieFormats/resolveTieFormat.mjs';
 import { getAllStructureMatchUps } from '../../../query/matchUps/getAllStructureMatchUps.mjs';
+import { getSideDrawPosition } from '../../../query/matchUps/getDrawPositionSides.mjs';
 import { isLuckyBasedDraw } from '../../../query/drawDefinition/isLuckyBasedDraw.mjs';
 import { matchUpCompletion } from '../../../query/matchUp/checkMatchUpIsComplete.mjs';
 import { processPlayoffGroups } from './drawTypes/processPlayoffGroups.mjs';
@@ -14,6 +15,7 @@ import { getAllDrawMatchUps } from '../../../query/matchUps/drawMatchUps.mjs';
 import { positionTargets } from '../../../query/matchUp/positionTargets.mjs';
 import { getMatchUpId } from '../../../functions/global/extractors.mjs';
 import { pushGlobalLog } from '../../../functions/global/globalLog.mjs';
+import { structuresOf } from '../../../acquire/structureMembers.mjs';
 import { findStructure } from '../../../acquire/findStructure.mjs';
 import { addGoesTo } from '../../../query/matchUps/addGoesTo.mjs';
 import { generateTieMatchUps } from './tieMatchUps.mjs';
@@ -162,7 +164,7 @@ function generateAndPopulatePlayoffStructures(params) {
             });
         }
     }
-    advanceCompletedMatchUps({
+    const advanced = advanceCompletedMatchUps({
         inContextDrawMatchUps,
         sourceStructureId,
         tournamentRecord,
@@ -171,13 +173,17 @@ function generateAndPopulatePlayoffStructures(params) {
         structure,
         event,
     });
-    advanceByeMatchUps({
+    if (advanced?.error)
+        return decorateResult({ result: advanced, stack });
+    const byesAdvanced = advanceByeMatchUps({
         inContextDrawMatchUps,
         sourceStructureId,
         tournamentRecord,
         drawDefinition,
         event,
     });
+    if (byesAdvanced?.error)
+        return decorateResult({ result: byesAdvanced, stack });
     const matchUpModifications = buildMatchUpModifications({
         inContextDrawMatchUps,
         sourceStructureId,
@@ -187,6 +193,8 @@ function generateAndPopulatePlayoffStructures(params) {
         params,
         stack,
     });
+    if (!Array.isArray(matchUpModifications))
+        return decorateResult({ result: matchUpModifications, stack });
     return {
         structures: newStructures,
         matchUpModifications,
@@ -212,7 +220,7 @@ function resolvePlayoffParams(params, stack) {
     if (!structure) {
         return { error: true, earlyReturn: decorateResult({ result: { error: STRUCTURE_NOT_FOUND }, stack }) };
     }
-    if (structure.structureType === CONTAINER || structure.structures) {
+    if (structure.structureType === CONTAINER || structuresOf(structure)) {
         return {
             error: true,
             earlyReturn: generateAndPopulateRRplayoffStructures({
@@ -291,7 +299,7 @@ function generatePositionBasedPlayoffs({ sourceStructureId, tournamentRecord, dr
         inContext: true,
         drawDefinition,
     });
-    advanceCompletedMatchUps({
+    const advanced = advanceCompletedMatchUps({
         inContextDrawMatchUps,
         sourceStructureId,
         tournamentRecord,
@@ -300,13 +308,17 @@ function generatePositionBasedPlayoffs({ sourceStructureId, tournamentRecord, dr
         structure,
         event,
     });
-    advanceByeMatchUps({
+    if (advanced?.error)
+        return decorateResult({ result: advanced, stack });
+    const byesAdvanced = advanceByeMatchUps({
         inContextDrawMatchUps,
         sourceStructureId,
         tournamentRecord,
         drawDefinition,
         event,
     });
+    if (byesAdvanced?.error)
+        return decorateResult({ result: byesAdvanced, stack });
     return {
         structures: playoffStructures,
         links: playoffLinks,
@@ -337,13 +349,15 @@ function computePlayoffDrawSize({ finishingPositionsCount, isLuckyDraw, roundNum
 }
 function advanceCompletedMatchUps({ inContextDrawMatchUps, sourceStructureId, tournamentRecord, drawDefinition, matchUpsMap, structure, event, }) {
     const completedMatchUps = inContextDrawMatchUps?.filter((matchUp) => matchUpCompletion(matchUp) && matchUp.structureId === sourceStructureId);
-    completedMatchUps?.forEach((matchUp) => {
+    for (const matchUp of completedMatchUps ?? []) {
         const { matchUpId, score, winningSide } = matchUp;
         const targetData = positionTargets({
             inContextDrawMatchUps,
             drawDefinition,
             matchUpId,
         });
+        if (targetData.error)
+            return targetData;
         const result = directParticipants({
             inContextDrawMatchUps,
             tournamentRecord,
@@ -359,21 +373,31 @@ function advanceCompletedMatchUps({ inContextDrawMatchUps, sourceStructureId, to
         });
         if (result.error)
             pushGlobalLog({ method: 'generateAndPopulatePlayoffStructures', error: result.error });
-    });
+    }
+    return undefined;
 }
-function advanceByeMatchUps({ inContextDrawMatchUps, sourceStructureId, tournamentRecord, drawDefinition, event }) {
+function advanceByeMatchUps({ inContextDrawMatchUps, sourceStructureId, tournamentRecord, drawDefinition, event, }) {
     const byeMatchUps = inContextDrawMatchUps?.filter((matchUp) => matchUp.matchUpStatus === BYE && matchUp.structureId === sourceStructureId);
-    byeMatchUps?.forEach((matchUp) => {
+    for (const matchUp of byeMatchUps ?? []) {
         const { matchUpId } = matchUp;
         const targetData = positionTargets({
             inContextDrawMatchUps,
             drawDefinition,
             matchUpId,
         });
+        if (targetData.error)
+            return targetData;
         const { targetLinks: { loserTargetLink }, targetMatchUps: { loserMatchUpDrawPositionIndex, loserMatchUp }, } = targetData;
-        if (loserTargetLink && loserMatchUp) {
+        if (loserTargetLink && loserMatchUp?.drawPositions && loserMatchUpDrawPositionIndex !== undefined) {
             const targetStructureId = loserTargetLink.target.structureId;
-            const targetDrawPosition = loserMatchUp.drawPositions[loserMatchUpDrawPositionIndex];
+            const targetDrawPosition = getSideDrawPosition({
+                sideNumber: loserMatchUpDrawPositionIndex + 1,
+                structureId: targetStructureId,
+                matchUp: loserMatchUp,
+                drawDefinition,
+            });
+            if (!targetDrawPosition)
+                continue;
             const result = assignDrawPositionBye({
                 drawPosition: targetDrawPosition,
                 structureId: targetStructureId,
@@ -384,15 +408,19 @@ function advanceByeMatchUps({ inContextDrawMatchUps, sourceStructureId, tourname
             if (result.error)
                 pushGlobalLog({ method: 'generateAndPopulatePlayoffStructures', error: result.error });
         }
-    });
+    }
+    return undefined;
 }
 function buildMatchUpModifications({ inContextDrawMatchUps, sourceStructureId, tournamentRecord, drawDefinition, matchUpsMap, params, stack, }) {
     const matchUpModifications = [];
-    const goesToMap = addGoesTo({
+    const goesTo = addGoesTo({
         inContextDrawMatchUps,
         drawDefinition,
         matchUpsMap,
-    }).goesToMap;
+    });
+    if (goesTo.error)
+        return goesTo;
+    const goesToMap = goesTo.goesToMap;
     const { structure: sourceStructure } = findStructure({
         drawDefinition: params.drawDefinition,
         structureId: sourceStructureId,
@@ -427,4 +455,4 @@ function buildMatchUpModifications({ inContextDrawMatchUps, sourceStructureId, t
     return matchUpModifications;
 }
 
-export { generateAndPopulatePlayoffStructures };
+export { advanceByeMatchUps, generateAndPopulatePlayoffStructures };

package/dist/esm/assemblies/generators/drawDefinitions/generateDrawDefinition/generateNewDrawDefinition.mjs

@@ -1,13 +1,18 @@
 import { generateDrawTypeAndModifyDrawDefinition } from '../generateDrawTypeAndModifyDrawDefinition.mjs';
 import { generateQualifyingLink } from '../links/generateQualifyingLink.mjs';
 import { addDrawEntry } from '../../../../mutate/drawDefinitions/entryGovernor/addDrawEntries.mjs';
+import { getQualifiersCount } from '../../../../query/drawDefinition/getQualifiersCount.mjs';
 import { isLuckyBasedDraw } from '../../../../query/drawDefinition/isLuckyBasedDraw.mjs';
 import structureTemplate from '../../templates/structureTemplate.mjs';
+import { getStageEntries } from '../../../../query/drawDefinition/stageGetter.mjs';
+import { decorateResult } from '../../../../functions/global/decorateResult.mjs';
 import { isAdHocType } from '../../../../query/drawDefinition/isAdHocType.mjs';
 import { constantToString } from '../../../../tools/strings.mjs';
 import { generateAdHoc } from './generateAdHoc.mjs';
 import { prepareStage } from './prepareStage.mjs';
 import { ensureInt } from '../../../../tools/ensureInt.mjs';
+import { DIRECT_ENTRY_STATUSES } from '../../../../constants/entryStatusConstants.mjs';
+import { INSUFFICIENT_DRAW_POSITIONS } from '../../../../constants/errorConditionConstants.mjs';
 import { MAIN, QUALIFYING, POSITION } from '../../../../constants/drawDefinitionConstants.mjs';
 import { WITHDRAWN } from '../../../../constants/entryStatusValues.mjs';
 
@@ -60,6 +65,9 @@ function generateNewDrawDefinition(params) {
         drawDefinition.links ??= [];
         drawDefinition.links.push(link);
     }
+    const fitResult = checkMainFits({ ...params, drawDefinition, mainStructureId });
+    if (fitResult.error)
+        return fitResult;
     const seedsCount = isLuckyBasedDraw(drawType) ? 0 : ensureInt(params.seedsCount ?? 0);
     const structureResult = prepareStage({
         ...params,
@@ -112,5 +120,21 @@ function addEntries(params) {
     }
     return { error: undefined };
 }
+function checkMainFits(params) {
+    const { drawDefinition, mainStructureId, qualifyingOnly, drawSize, drawType, qualifiersCount } = params;
+    if (!drawDefinition || !mainStructureId || qualifyingOnly || !drawSize || isAdHocType(drawType))
+        return {};
+    const stageScope = { stage: MAIN, stageSequence: 1, drawDefinition };
+    const directEntries = getStageEntries({ ...stageScope, entryStatuses: DIRECT_ENTRY_STATUSES });
+    const derivedQualifiersCount = getQualifiersCount({ ...stageScope, structureId: mainStructureId }).qualifiersCount;
+    const reservedQualifiersCount = derivedQualifiersCount || qualifiersCount || 0;
+    if (directEntries.length + reservedQualifiersCount <= drawSize)
+        return {};
+    return decorateResult({
+        context: { drawSize, directEntriesCount: directEntries.length, qualifiersCount: reservedQualifiersCount },
+        result: { error: INSUFFICIENT_DRAW_POSITIONS },
+        stack: 'generateNewDrawDefinition',
+    });
+}
 
 export { generateNewDrawDefinition };