tods-competition-factory 7.0.0 → 7.1.0

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

@@ -0,0 +1,115 @@
+import { addMatchUpScheduledDate } from '../../../mutate/matchUps/schedule/scheduleItems/addMatchUpScheduledDate.mjs';
+import { addMatchUpScheduledTime } from '../../../mutate/matchUps/schedule/scheduledTime.mjs';
+import { scheduleProfileGrid } from '../../../mutate/matchUps/schedule/scheduleProfileGrid.mjs';
+import { decorateResult } from '../../../functions/global/decorateResult.mjs';
+import { extractDate } from '../../../tools/plainDate.mjs';
+import { allTournamentMatchUps } from '../../../query/matchUps/getAllTournamentMatchUps.mjs';
+import { INVALID_VALUES, INVALID_DATE } from '../../../constants/errorConditionConstants.mjs';
+import { SUCCESS } from '../../../constants/resultConstants.mjs';
+
+function isoMinute(date) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${p(date.getMonth() + 1)}-${p(date.getDate())}T${p(date.getHours())}:${p(date.getMinutes())}`;
+}
+function scheduledInstant(matchUp) {
+    const { scheduledDate, scheduledTime } = matchUp?.schedule ?? {};
+    if (!scheduledTime)
+        return undefined;
+    const time = scheduledTime.includes('T') ? scheduledTime.split('T')[1] : scheduledTime;
+    const [h, m] = String(time).split(':');
+    if (h === undefined || m === undefined)
+        return undefined;
+    const datePart = scheduledDate ? String(scheduledDate).split('T')[0] : undefined;
+    if (!datePart)
+        return undefined;
+    const [y, mo, d] = datePart.split('-').map(Number);
+    const instant = new Date(y, (mo ?? 1) - 1, d ?? 1, Number(h), Number(m));
+    return isNaN(instant.getTime()) ? undefined : instant;
+}
+function applyScenarioProfile({ tournamentRecord, scenarioProfile }) {
+    if (typeof scenarioProfile !== 'object' || scenarioProfile === null)
+        return { error: INVALID_VALUES };
+    const { anchor = 'NOW', minutesBeforeAnchor = 0, assignCourts } = scenarioProfile;
+    if (typeof minutesBeforeAnchor !== 'number' || !isFinite(minutesBeforeAnchor))
+        return { error: INVALID_VALUES };
+    const anchorDate = anchor === 'NOW' ? new Date() : new Date(anchor);
+    if (isNaN(anchorDate.getTime()))
+        return { error: INVALID_VALUES };
+    if (assignCourts) {
+        const tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
+        const scheduleDates = [
+            ...new Set((allTournamentMatchUps({ tournamentRecord }).matchUps ?? [])
+                .map((m) => m.schedule?.scheduledDate)
+                .filter(Boolean)
+                .map((d) => String(d).split('T')[0])),
+        ];
+        if (scheduleDates.length)
+            scheduleProfileGrid({ tournamentRecords, scheduleDates });
+    }
+    const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps ?? [];
+    const scheduled = matchUps
+        .map((matchUp) => ({ matchUp, instant: scheduledInstant(matchUp) }))
+        .filter((entry) => !!entry.instant);
+    if (!scheduled.length)
+        return { ...SUCCESS, shiftedCount: 0, anchoredTo: anchorDate.toISOString() };
+    const earliest = Math.min(...scheduled.map((entry) => entry.instant.getTime()));
+    const target = anchorDate.getTime() - minutesBeforeAnchor * 60_000;
+    const deltaMs = target - earliest;
+    const drawMap = {};
+    for (const event of tournamentRecord.events ?? []) {
+        for (const drawDefinition of event.drawDefinitions ?? [])
+            drawMap[drawDefinition.drawId] = drawDefinition;
+    }
+    const shifts = scheduled
+        .filter(({ matchUp }) => drawMap[matchUp.drawId])
+        .map(({ matchUp, instant }) => ({ matchUp, shifted: new Date(instant.getTime() + deltaMs) }));
+    const startBound = tournamentRecord?.startDate && new Date(extractDate(tournamentRecord.startDate) ?? '').getTime();
+    const endBound = tournamentRecord?.endDate && new Date(extractDate(tournamentRecord.endDate) ?? '').getTime();
+    if (startBound && endBound) {
+        const outside = shifts.find(({ shifted }) => {
+            const dayMs = new Date(isoMinute(shifted).split('T')[0]).getTime();
+            return dayMs < startBound || dayMs > endBound;
+        });
+        if (outside) {
+            return decorateResult({
+                result: { error: INVALID_DATE },
+                info: `anchoring would move a matchUp to ${isoMinute(outside.shifted).split('T')[0]}, outside the tournament's dates`,
+                stack: 'applyScenarioProfile',
+            });
+        }
+    }
+    let shiftedCount = 0;
+    for (const { matchUp, shifted } of shifts) {
+        const drawDefinition = drawMap[matchUp.drawId];
+        const isoShifted = isoMinute(shifted);
+        const targetDate = isoShifted.split('T')[0];
+        if (targetDate !== String(matchUp.schedule?.scheduledDate ?? '').split('T')[0]) {
+            const dateResult = addMatchUpScheduledDate({
+                scheduledDate: targetDate,
+                matchUpId: matchUp.matchUpId,
+                disableNotice: true,
+                tournamentRecord,
+                drawDefinition,
+            });
+            if (dateResult?.error)
+                return decorateResult({ result: dateResult, stack: 'applyScenarioProfile' });
+        }
+        const result = addMatchUpScheduledTime({
+            scheduledTime: isoShifted,
+            matchUpId: matchUp.matchUpId,
+            disableNotice: true,
+            tournamentRecord,
+            drawDefinition,
+        });
+        if (!result?.error)
+            shiftedCount += 1;
+    }
+    return {
+        ...SUCCESS,
+        anchoredTo: anchorDate.toISOString(),
+        shiftMinutes: Math.round(deltaMs / 60_000),
+        shiftedCount,
+    };
+}
+
+export { applyScenarioProfile };

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

@@ -196,7 +196,12 @@ function completeDrawMatchUps(params) {
     const isRoundRobinWithPlayoff = sortedStructures.length === 2 &&
         sortedStructures[0].finishingPosition === WIN_RATIO &&
         intersection(sortedStructures.map(({ stage }) => stage), [MAIN, PLAY_OFF]).length === 2;
-    const structureIds = sortedStructures.map(({ structureId }) => structureId);
+    const requestedStructureIds = params.structureIds;
+    const structureIds = sortedStructures
+        .filter((structure) => !requestedStructureIds?.length ||
+        requestedStructureIds.includes(structure.structureId) ||
+        (structure.structures ?? []).some((child) => requestedStructureIds.includes(child.structureId)))
+        .map(({ structureId }) => structureId);
     const maxPasses = 10;
     let passCount = 0;
     let previousCompleted = -1;

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

@@ -5,6 +5,7 @@ import { addTournamentParticipants } from './addTournamentParticipants.mjs';
 import { addParticipants } from '../../../mutate/participants/addParticipants.mjs';
 import { generateEventWithFlights } from './generateEventWithFlights.mjs';
 import { generateScheduledRounds } from './generateScheduledRounds.mjs';
+import { applyScenarioProfile } from './applyScenarioProfile.mjs';
 import { generateEventWithDraw } from './generateEventWithDraw.mjs';
 import { processLeagueProfiles } from './processLeagueProfiles.mjs';
 import { cycleMutationStatus } from '../../../global/state/globalState.mjs';
@@ -92,12 +93,18 @@ function generateTournamentRecord(params) {
     const { scheduledRounds = undefined, schedulerResult = {} } = schedulingProfile
         ? scheduleRounds({ ...params, tournamentRecord })
         : {};
+    const scenarioResult = params?.scenarioProfile
+        ? applyScenarioProfile({ tournamentRecord, scenarioProfile: params.scenarioProfile })
+        : undefined;
+    if (scenarioResult?.error)
+        return scenarioResult;
     cycleMutationStatus();
     return definedAttributes({
         ...SUCCESS,
         tournamentRecord,
         scheduledRounds,
         schedulerResult,
+        scenarioResult,
         eventIds,
         venueIds,
         drawIds,

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

@@ -35,6 +35,7 @@ export { automatedPositioning } from '../../../mutate/drawDefinitions/automatedP
 export { checkValidEntries } from '../../../validators/checkValidEntries.mjs';
 export { deleteAdHocMatchUps } from '../../../mutate/structures/deleteAdHocMatchUps.mjs';
 export { publicFindDrawDefinition as findDrawDefinition } from '../../../acquire/findDrawDefinition.mjs';
+export { getAdditionalSeedsAllowance } from '../../../query/drawDefinition/getAdditionalSeedsAllowance.mjs';
 export { getAssignedParticipantIds } from '../../../query/drawDefinition/getAssignedParticipantIds.mjs';
 export { getAvailableMatchUpsCount } from '../../generators/drawDefinitions/drawTypes/adHoc/getAvailableMatchUpsCount.mjs';
 export { getAvailablePlayoffProfiles } from '../../../query/drawDefinition/getAvailablePlayoffProfiles.mjs';

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

@@ -27,6 +27,7 @@ export { isValidSeedPosition } from '../../../query/drawDefinition/seedGetter.mj
 export { getSwissChart } from '../../../query/drawDefinitions/swiss/getSwissChart.mjs';
 export { validatePlayoffGroups } from '../../../validators/validatePlayoffGroups.mjs';
 export { getDraftState } from '../../../query/drawDefinition/draft/getDraftState.mjs';
+export { getAdditionalSeedsAllowance } from '../../../query/drawDefinition/getAdditionalSeedsAllowance.mjs';
 export { getSeedsCount } from '../../../query/drawDefinition/getSeedsCount.mjs';
 export { getTeamLineUp } from '../../../query/drawDefinition/getTeamLineUp.mjs';
 export { checkValidEntries } from '../../../validators/checkValidEntries.mjs';

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

@@ -4,6 +4,7 @@ import * as mutate from './mutate.mjs';
 export { mutate };
 import * as query from './query.mjs';
 export { query };
+export { addAdditionalSeed } from '../../../mutate/drawDefinitions/entryGovernor/addAdditionalSeed.mjs';
 export { addDrawDefinition } from '../../../mutate/drawDefinitions/addDrawDefinition.mjs';
 export { addEvent } from '../../../mutate/events/addEvent.mjs';
 export { addFlight } from '../../../mutate/events/addFlight.mjs';

package/dist/esm/assemblies/governors/eventGovernor/mutate.mjs

@@ -8,6 +8,7 @@ export { modifyPairAssignment } from '../../../mutate/drawDefinitions/modifyPair
 export { updateDrawIdsOrder } from '../../../mutate/events/updateDrawIdsOrder.mjs';
 export { addDrawDefinition } from '../../../mutate/drawDefinitions/addDrawDefinition.mjs';
 export { deleteDrawDefinitions } from '../../../mutate/events/deleteDrawDefinitions.mjs';
+export { addAdditionalSeed } from '../../../mutate/drawDefinitions/entryGovernor/addAdditionalSeed.mjs';
 export { assignSeedPositions } from '../../../mutate/events/assignSeedPositions.mjs';
 export { attachFlightProfile } from '../../../mutate/events/attachFlightProfile.mjs';
 export { removeScaleValues } from '../../../mutate/entries/removeScaleValues.mjs';

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

@@ -12,8 +12,10 @@ export { getPublishState } from '../../../query/publishing/getPublishState.mjs';
 export { getRoundVisibilityState } from '../../../query/publishing/getRoundVisibilityState.mjs';
 export { getStructureData } from '../../../query/drawDefinition/getStructureData.mjs';
 export { getTournamentPublishStatus } from '../../../query/tournaments/getTournamentPublishStatus.mjs';
+export { getTournamentVisibleFrom, isTournamentVisible } from '../../../query/publishing/tournamentVisibility.mjs';
 export { getVenueData } from '../../../query/venues/getVenueData.mjs';
 export { isEmbargoed, isVisiblyPublished } from '../../../query/publishing/isEmbargoed.mjs';
+export { isTournamentPublished } from '../../../query/publishing/isTournamentPublished.mjs';
 export { publishEvent } from '../../../mutate/publishing/publishEvent.mjs';
 export { publishEventSeeding, unPublishEventSeeding } from '../../../mutate/publishing/eventSeeding.mjs';
 export { publishOrderOfPlay } from '../../../mutate/timeItems/publishOrderOfPlay.mjs';

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

@@ -1,6 +1,8 @@
 export { getTournamentPublishStatus } from '../../../query/tournaments/getTournamentPublishStatus.mjs';
 export { bulkUpdatePublishedEventIds } from '../../../query/event/bulkUpdatePublishedEventIds.mjs';
+export { getTournamentVisibleFrom, isTournamentVisible } from '../../../query/publishing/tournamentVisibility.mjs';
 export { getRoundVisibilityState } from '../../../query/publishing/getRoundVisibilityState.mjs';
+export { isTournamentPublished } from '../../../query/publishing/isTournamentPublished.mjs';
 export { isEmbargoed, isVisiblyPublished } from '../../../query/publishing/isEmbargoed.mjs';
 export { getEventPublishStatus } from '../../../query/event/getEventPublishStatus.mjs';
 export { getPublishState } from '../../../query/publishing/getPublishState.mjs';

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

@@ -55,7 +55,9 @@ export { compareTieFormats } from '../../../query/hierarchical/tieFormats/compar
 export { getTieFormat } from '../../../query/hierarchical/getTieFormat.mjs';
 export { getTournamentPublishStatus } from '../../../query/tournaments/getTournamentPublishStatus.mjs';
 export { bulkUpdatePublishedEventIds } from '../../../query/event/bulkUpdatePublishedEventIds.mjs';
+export { getTournamentVisibleFrom, isTournamentVisible } from '../../../query/publishing/tournamentVisibility.mjs';
 export { getRoundVisibilityState } from '../../../query/publishing/getRoundVisibilityState.mjs';
+export { isTournamentPublished } from '../../../query/publishing/isTournamentPublished.mjs';
 export { isEmbargoed, isVisiblyPublished } from '../../../query/publishing/isEmbargoed.mjs';
 export { getEventPublishStatus } from '../../../query/event/getEventPublishStatus.mjs';
 export { getPublishState } from '../../../query/publishing/getPublishState.mjs';
@@ -162,6 +164,7 @@ export { isValidSeedPosition } from '../../../query/drawDefinition/seedGetter.mj
 export { getSwissChart } from '../../../query/drawDefinitions/swiss/getSwissChart.mjs';
 export { validatePlayoffGroups } from '../../../validators/validatePlayoffGroups.mjs';
 export { getDraftState } from '../../../query/drawDefinition/draft/getDraftState.mjs';
+export { getAdditionalSeedsAllowance } from '../../../query/drawDefinition/getAdditionalSeedsAllowance.mjs';
 export { getSeedsCount } from '../../../query/drawDefinition/getSeedsCount.mjs';
 export { getTeamLineUp } from '../../../query/drawDefinition/getTeamLineUp.mjs';
 export { checkValidEntries } from '../../../validators/checkValidEntries.mjs';

package/dist/esm/constants/errorConditionConstants.mjs

@@ -162,6 +162,10 @@ const MISSING_SEEDCOUNT_THRESHOLDS = {
     message: 'Missing seedCountThresholds',
     code: 'ERR_MISSING_SEED_COUNT_THRESHOLD',
 };
+const ADDITIONAL_SEEDS_EXHAUSTED = {
+    message: 'seeding policy allows no further additional seeds',
+    code: 'ERR_ADDITIONAL_SEEDS_EXHAUSTED',
+};
 const INVALID_ACTION = {
     message: 'Invalid action',
     code: 'ERR_INVALID_ACTION',
@@ -1075,6 +1079,7 @@ const errorConditionConstants = {
     SCHEDULED_MATCHUPS,
     SCORES_PRESENT,
     SEEDSCOUNT_GREATER_THAN_DRAW_SIZE,
+    ADDITIONAL_SEEDS_EXHAUSTED,
     STAGE_SEQUENCE_LIMIT,
     STRUCTURE_NOT_FOUND,
     TEAM_NOT_FOUND,
@@ -1088,4 +1093,4 @@ const errorConditionConstants = {
     VENUE_EXISTS,
 };
 
-export { ANACHRONISM, BOOKING_NOT_FOUND, CANNOT_CHANGE_FEED_ELIGIBILITY, CANNOT_CHANGE_OUTCOME, CANNOT_CHANGE_WINNING_SIDE, CANNOT_MODIFY_PARTICIPANT_TYPE, CANNOT_MODIFY_TIEFORMAT, CANNOT_REMOVE_MAIN_STRUCTURE, CANNOT_REMOVE_PARTICIPANTS, CAPACITY_EXCEEDED, CATEGORY_MISMATCH, CONFLICTING_TIME_ZONES, COURT_EXISTS, COURT_NOT_FOUND, DRAW_DEFINITION_NOT_FOUND, DRAW_ID_EXISTS, DRAW_POSITION_ACTIVE, DRAW_POSITION_ASSIGNED, DRAW_POSITION_NOT_CLEARED, DRAW_POSITION_NOT_FOUND, DRAW_POSITION_OCCUPIED, DRAW_SIZE_MISMATCH, DUPLICATE_ENTRY, DUPLICATE_VALUE, ENTRY_STATUS_NOT_ALLOWED_FOR_EVENT, ENTRY_STATUS_NOT_ALLOWED_IN_STAGE, EVENT_EXISTS, EVENT_NOT_FOUND, EXISTING_DRAFT, EXISTING_DRAW_DEFINITIONS, EXISTING_END_TIME, EXISTING_FLIGHT, EXISTING_MATCHUPS, EXISTING_MATCHUP_ID, EXISTING_OUTCOME, EXISTING_PARTICIPANT, EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT, EXISTING_POLICY_TYPE, EXISTING_PROFILE, EXISTING_ROUND, EXISTING_ROUND_PARTICIPANT, EXISTING_STAGE, EXISTING_STRUCTURE, INCOMPATIBLE_MATCHUP_STATUS, INCOMPLETE_SOURCE_STRUCTURE, INSUFFICIENT_DRAW_POSITIONS, INSUFFICIENT_UUIDS, INVALID_ACTION, INVALID_ASSIGNMENT, INVALID_ATTESTATION_SUBJECT, INVALID_ATTRIBUTION, INVALID_BOOKINGS, INVALID_CATEGORY, INVALID_COLLECTION_DEFINITION, INVALID_CONFIGURATION, INVALID_DATE, INVALID_DATE_AVAILABILITY, INVALID_DRAW_DEFINITION, INVALID_DRAW_POSITION, INVALID_DRAW_POSITION_FOR_SEEDING, INVALID_DRAW_SIZE, INVALID_DRAW_TYPE, INVALID_EMBARGO, INVALID_END_TIME, INVALID_ENTRIES, INVALID_ENTRY_STATUS, INVALID_EVENT_TYPE, INVALID_GAME_SCORES, INVALID_GENDER, INVALID_MATCHUP, INVALID_MATCHUP_FORMAT, INVALID_MATCHUP_STATUS, INVALID_MATCHUP_STATUS_BYE, INVALID_OBJECT, INVALID_PARTICIPANT, INVALID_PARTICIPANT_ID, INVALID_PARTICIPANT_IDS, INVALID_PARTICIPANT_ROLE, INVALID_PARTICIPANT_SEEDING, INVALID_PARTICIPANT_TYPE, INVALID_POLICY_DEFINITION, INVALID_RECORDS, INVALID_RESUME_TIME, INVALID_SCALE_ITEM, INVALID_SCORE, INVALID_SEED_NUMBER, INVALID_SEED_POSITION, INVALID_SET_NUMBER, INVALID_SIDE_NUMBER, INVALID_STAGE, INVALID_START_TIME, INVALID_STOP_TIME, INVALID_STRUCTURE, INVALID_TIE_FORMAT, INVALID_TIME, INVALID_TIME_ITEM, INVALID_TIME_ZONE, INVALID_TOURNAMENT_DATES, INVALID_TOURNAMENT_RECORD, INVALID_VALUES, INVALID_WINNING_SIDE, LUCKY_DRAW_BYE_LIMIT, MATCHUPS_COMPLETED_OUTSIDE_DATES, MATCHUPS_SCHEDULED_OUTSIDE_DATES, MATCHUP_HAS_SCHEDULING, MATCHUP_NOT_FOUND, MATCHUP_STATUS_OUT_OF_SCOPE, METHOD_NOT_FOUND, MISSING_ASSIGNMENTS, MISSING_ASYNC_STATE_PROVIDER, MISSING_AVOIDANCE_POLICY, MISSING_BIRTH_DATE, MISSING_COLLECTION_DEFINITION, MISSING_CONTEXT, MISSING_COURTS_INFO, MISSING_COURT_ID, MISSING_DATE, MISSING_DATE_AVAILABILITY, MISSING_DATE_RANGE, MISSING_DRAW_DEFINITION, MISSING_DRAW_ID, MISSING_DRAW_POSITION, MISSING_DRAW_POSITIONS, MISSING_DRAW_SIZE, MISSING_ENTRIES, MISSING_EVENT, MISSING_MAIN_STRUCTURE, MISSING_MATCHUP, MISSING_MATCHUPS, MISSING_MATCHUP_FORMAT, MISSING_MATCHUP_ID, MISSING_MATCHUP_IDS, MISSING_PARTICIPANT, MISSING_PARTICIPANTS, MISSING_PARTICIPANT_COUNT, MISSING_PARTICIPANT_ID, MISSING_PARTICIPANT_IDS, MISSING_PARTICIPANT_ROLE, MISSING_PENALTY_ID, MISSING_PENALTY_TYPE, MISSING_PERSON_DETAILS, MISSING_POLICY_ATTRIBUTES, MISSING_POLICY_DEFINITION, MISSING_POLICY_TYPE, MISSING_POSITION_ASSIGNMENTS, MISSING_QUALIFIED_PARTICIPANTS, MISSING_ROUND_NUMBER, MISSING_SCHEDULE, MISSING_SCORING_POLICY, MISSING_SEEDCOUNT_THRESHOLDS, MISSING_SEEDING_POLICY, MISSING_SEED_ASSIGNMENTS, MISSING_SET_NUMBER, MISSING_SET_OBJECT, MISSING_SIDE_NUMBER, MISSING_STAGE, MISSING_STRUCTURE, MISSING_STRUCTURES, MISSING_STRUCTURE_ID, MISSING_TARGET_LINK, MISSING_TIE_FORMAT, MISSING_TIME_ITEM, MISSING_TIME_ITEMS, MISSING_TOURNAMENT_ID, MISSING_TOURNAMENT_RECORD, MISSING_TOURNAMENT_RECORDS, MISSING_VALUE, MISSING_VENUE_ID, MODIFICATIONS_FAILED, MUTATION_LOCKED, MUTATION_LOCK_EXISTS, MUTATION_LOCK_NOT_FOUND, NOT_FOUND, NOT_IMPLEMENTED, NO_CANDIDATES, NO_DRAW_POSITIONS_AVAILABLE_FOR_QUALIFIERS, NO_MODIFICATIONS_APPLIED, NO_PARTICIPANTS_GENERATED, NO_PARTICIPANT_REMOVED, NO_STAGE_SPACE_AVAILABLE_FOR_ENTRY_STATUS, NO_VALID_ACTIONS, NO_VALID_ATTRIBUTES, NO_VALID_DATES, PARTICIPANT_COUNT_EXCEEDS_DRAW_SIZE, PARTICIPANT_ENTRY_NOT_FOUND, PARTICIPANT_ID_EXISTS, PARTICIPANT_NOT_CHECKED_IN, PARTICIPANT_NOT_ENTERED_IN_STAGE, PARTICIPANT_NOT_FOUND, PARTICIPANT_NOT_FOUND_IN_STAGE, PARTICIPANT_PAIR_EXISTS, PENALTY_NOT_FOUND, POLICY_NOT_ATTACHED, POLICY_NOT_FOUND, PROPAGATED_EXITS_DOWNSTREAM, REGISTRATION_NOT_FOUND, RESULT_NOT_VALIDATED, SCHEDULED_MATCHUPS, SCHEDULE_CONFLICT_COURT_UNAVAILABLE, SCHEDULE_CONFLICT_DOUBLE_BOOKING, SCHEDULE_LOCKED, SCHEDULE_NOT_CLEARED, SCHEDULE_SCENARIO_EXISTS, SCHEDULE_SCENARIO_NOT_FOUND, SCORES_PRESENT, SEEDSCOUNT_GREATER_THAN_DRAW_SIZE, SHARED_INDIVIDUAL_PARTICIPANT, STAGE_SEQUENCE_LIMIT, STRUCTURE_NOT_FOUND, TEAM_NOT_FOUND, TOURNAMENT_CATEGORY_IN_USE, UNABLE_TO_ASSIGN_COURT, UNAUTHORIZED_LOCK_OPERATION, UNLINKED_STRUCTURES, UNRECOGNIZED_DRAW_TYPE, UNRECOGNIZED_MATCHUP_FORMAT, UNRECOGNIZED_MATCHUP_STATUS, UNSUPPORTED_IN_LEGACY_MODE, UNWRITABLE_SCHEDULE_ATTRIBUTES, VALUE_UNCHANGED, VENUE_EXISTS, VENUE_NOT_FOUND, errorConditionConstants };
+export { ADDITIONAL_SEEDS_EXHAUSTED, ANACHRONISM, BOOKING_NOT_FOUND, CANNOT_CHANGE_FEED_ELIGIBILITY, CANNOT_CHANGE_OUTCOME, CANNOT_CHANGE_WINNING_SIDE, CANNOT_MODIFY_PARTICIPANT_TYPE, CANNOT_MODIFY_TIEFORMAT, CANNOT_REMOVE_MAIN_STRUCTURE, CANNOT_REMOVE_PARTICIPANTS, CAPACITY_EXCEEDED, CATEGORY_MISMATCH, CONFLICTING_TIME_ZONES, COURT_EXISTS, COURT_NOT_FOUND, DRAW_DEFINITION_NOT_FOUND, DRAW_ID_EXISTS, DRAW_POSITION_ACTIVE, DRAW_POSITION_ASSIGNED, DRAW_POSITION_NOT_CLEARED, DRAW_POSITION_NOT_FOUND, DRAW_POSITION_OCCUPIED, DRAW_SIZE_MISMATCH, DUPLICATE_ENTRY, DUPLICATE_VALUE, ENTRY_STATUS_NOT_ALLOWED_FOR_EVENT, ENTRY_STATUS_NOT_ALLOWED_IN_STAGE, EVENT_EXISTS, EVENT_NOT_FOUND, EXISTING_DRAFT, EXISTING_DRAW_DEFINITIONS, EXISTING_END_TIME, EXISTING_FLIGHT, EXISTING_MATCHUPS, EXISTING_MATCHUP_ID, EXISTING_OUTCOME, EXISTING_PARTICIPANT, EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT, EXISTING_POLICY_TYPE, EXISTING_PROFILE, EXISTING_ROUND, EXISTING_ROUND_PARTICIPANT, EXISTING_STAGE, EXISTING_STRUCTURE, INCOMPATIBLE_MATCHUP_STATUS, INCOMPLETE_SOURCE_STRUCTURE, INSUFFICIENT_DRAW_POSITIONS, INSUFFICIENT_UUIDS, INVALID_ACTION, INVALID_ASSIGNMENT, INVALID_ATTESTATION_SUBJECT, INVALID_ATTRIBUTION, INVALID_BOOKINGS, INVALID_CATEGORY, INVALID_COLLECTION_DEFINITION, INVALID_CONFIGURATION, INVALID_DATE, INVALID_DATE_AVAILABILITY, INVALID_DRAW_DEFINITION, INVALID_DRAW_POSITION, INVALID_DRAW_POSITION_FOR_SEEDING, INVALID_DRAW_SIZE, INVALID_DRAW_TYPE, INVALID_EMBARGO, INVALID_END_TIME, INVALID_ENTRIES, INVALID_ENTRY_STATUS, INVALID_EVENT_TYPE, INVALID_GAME_SCORES, INVALID_GENDER, INVALID_MATCHUP, INVALID_MATCHUP_FORMAT, INVALID_MATCHUP_STATUS, INVALID_MATCHUP_STATUS_BYE, INVALID_OBJECT, INVALID_PARTICIPANT, INVALID_PARTICIPANT_ID, INVALID_PARTICIPANT_IDS, INVALID_PARTICIPANT_ROLE, INVALID_PARTICIPANT_SEEDING, INVALID_PARTICIPANT_TYPE, INVALID_POLICY_DEFINITION, INVALID_RECORDS, INVALID_RESUME_TIME, INVALID_SCALE_ITEM, INVALID_SCORE, INVALID_SEED_NUMBER, INVALID_SEED_POSITION, INVALID_SET_NUMBER, INVALID_SIDE_NUMBER, INVALID_STAGE, INVALID_START_TIME, INVALID_STOP_TIME, INVALID_STRUCTURE, INVALID_TIE_FORMAT, INVALID_TIME, INVALID_TIME_ITEM, INVALID_TIME_ZONE, INVALID_TOURNAMENT_DATES, INVALID_TOURNAMENT_RECORD, INVALID_VALUES, INVALID_WINNING_SIDE, LUCKY_DRAW_BYE_LIMIT, MATCHUPS_COMPLETED_OUTSIDE_DATES, MATCHUPS_SCHEDULED_OUTSIDE_DATES, MATCHUP_HAS_SCHEDULING, MATCHUP_NOT_FOUND, MATCHUP_STATUS_OUT_OF_SCOPE, METHOD_NOT_FOUND, MISSING_ASSIGNMENTS, MISSING_ASYNC_STATE_PROVIDER, MISSING_AVOIDANCE_POLICY, MISSING_BIRTH_DATE, MISSING_COLLECTION_DEFINITION, MISSING_CONTEXT, MISSING_COURTS_INFO, MISSING_COURT_ID, MISSING_DATE, MISSING_DATE_AVAILABILITY, MISSING_DATE_RANGE, MISSING_DRAW_DEFINITION, MISSING_DRAW_ID, MISSING_DRAW_POSITION, MISSING_DRAW_POSITIONS, MISSING_DRAW_SIZE, MISSING_ENTRIES, MISSING_EVENT, MISSING_MAIN_STRUCTURE, MISSING_MATCHUP, MISSING_MATCHUPS, MISSING_MATCHUP_FORMAT, MISSING_MATCHUP_ID, MISSING_MATCHUP_IDS, MISSING_PARTICIPANT, MISSING_PARTICIPANTS, MISSING_PARTICIPANT_COUNT, MISSING_PARTICIPANT_ID, MISSING_PARTICIPANT_IDS, MISSING_PARTICIPANT_ROLE, MISSING_PENALTY_ID, MISSING_PENALTY_TYPE, MISSING_PERSON_DETAILS, MISSING_POLICY_ATTRIBUTES, MISSING_POLICY_DEFINITION, MISSING_POLICY_TYPE, MISSING_POSITION_ASSIGNMENTS, MISSING_QUALIFIED_PARTICIPANTS, MISSING_ROUND_NUMBER, MISSING_SCHEDULE, MISSING_SCORING_POLICY, MISSING_SEEDCOUNT_THRESHOLDS, MISSING_SEEDING_POLICY, MISSING_SEED_ASSIGNMENTS, MISSING_SET_NUMBER, MISSING_SET_OBJECT, MISSING_SIDE_NUMBER, MISSING_STAGE, MISSING_STRUCTURE, MISSING_STRUCTURES, MISSING_STRUCTURE_ID, MISSING_TARGET_LINK, MISSING_TIE_FORMAT, MISSING_TIME_ITEM, MISSING_TIME_ITEMS, MISSING_TOURNAMENT_ID, MISSING_TOURNAMENT_RECORD, MISSING_TOURNAMENT_RECORDS, MISSING_VALUE, MISSING_VENUE_ID, MODIFICATIONS_FAILED, MUTATION_LOCKED, MUTATION_LOCK_EXISTS, MUTATION_LOCK_NOT_FOUND, NOT_FOUND, NOT_IMPLEMENTED, NO_CANDIDATES, NO_DRAW_POSITIONS_AVAILABLE_FOR_QUALIFIERS, NO_MODIFICATIONS_APPLIED, NO_PARTICIPANTS_GENERATED, NO_PARTICIPANT_REMOVED, NO_STAGE_SPACE_AVAILABLE_FOR_ENTRY_STATUS, NO_VALID_ACTIONS, NO_VALID_ATTRIBUTES, NO_VALID_DATES, PARTICIPANT_COUNT_EXCEEDS_DRAW_SIZE, PARTICIPANT_ENTRY_NOT_FOUND, PARTICIPANT_ID_EXISTS, PARTICIPANT_NOT_CHECKED_IN, PARTICIPANT_NOT_ENTERED_IN_STAGE, PARTICIPANT_NOT_FOUND, PARTICIPANT_NOT_FOUND_IN_STAGE, PARTICIPANT_PAIR_EXISTS, PENALTY_NOT_FOUND, POLICY_NOT_ATTACHED, POLICY_NOT_FOUND, PROPAGATED_EXITS_DOWNSTREAM, REGISTRATION_NOT_FOUND, RESULT_NOT_VALIDATED, SCHEDULED_MATCHUPS, SCHEDULE_CONFLICT_COURT_UNAVAILABLE, SCHEDULE_CONFLICT_DOUBLE_BOOKING, SCHEDULE_LOCKED, SCHEDULE_NOT_CLEARED, SCHEDULE_SCENARIO_EXISTS, SCHEDULE_SCENARIO_NOT_FOUND, SCORES_PRESENT, SEEDSCOUNT_GREATER_THAN_DRAW_SIZE, SHARED_INDIVIDUAL_PARTICIPANT, STAGE_SEQUENCE_LIMIT, STRUCTURE_NOT_FOUND, TEAM_NOT_FOUND, TOURNAMENT_CATEGORY_IN_USE, UNABLE_TO_ASSIGN_COURT, UNAUTHORIZED_LOCK_OPERATION, UNLINKED_STRUCTURES, UNRECOGNIZED_DRAW_TYPE, UNRECOGNIZED_MATCHUP_FORMAT, UNRECOGNIZED_MATCHUP_STATUS, UNSUPPORTED_IN_LEGACY_MODE, UNWRITABLE_SCHEDULE_ATTRIBUTES, VALUE_UNCHANGED, VENUE_EXISTS, VENUE_NOT_FOUND, errorConditionConstants };

package/dist/esm/constants/index.mjs

@@ -24,6 +24,7 @@ export { requestConstants } from './requestConstants.mjs';
 export { availabilityConstants, dayStateConstants } from './dayStateConstants.mjs';
 export { resourceContants } from './resourceConstants.mjs';
 export { resultConstants } from './resultConstants.mjs';
+export { ADDITIONAL_SEED_BASES, seedingBasisConstants } from './seedingConstants.mjs';
 export { actionMethodConstants } from './actionMethodConstants.mjs';
 export { bookingTypeConstants } from './bookingTypeConstants.mjs';
 export { scaleConstants } from './scaleConstants.mjs';

package/dist/esm/constants/seedingBasisValues.mjs

@@ -0,0 +1,6 @@
+const ORGANISER_DISCRETION = 'ORGANISER_DISCRETION';
+const PROTECTED_RANKING = 'PROTECTED_RANKING';
+const RANKING = 'RANKING';
+const RATING = 'RATING';
+
+export { ORGANISER_DISCRETION, PROTECTED_RANKING, RANKING, RATING };

package/dist/esm/constants/seedingConstants.mjs

@@ -0,0 +1,11 @@
+import { ORGANISER_DISCRETION, PROTECTED_RANKING, RATING, RANKING } from './seedingBasisValues.mjs';
+
+const seedingBasisConstants = {
+    ORGANISER_DISCRETION,
+    PROTECTED_RANKING,
+    RANKING,
+    RATING,
+};
+const ADDITIONAL_SEED_BASES = [ORGANISER_DISCRETION, PROTECTED_RANKING];
+
+export { ADDITIONAL_SEED_BASES, ORGANISER_DISCRETION, PROTECTED_RANKING, RANKING, RATING, seedingBasisConstants };

package/dist/esm/index.mjs

@@ -38,9 +38,10 @@ export { index$7 as factoryConstants };
 export { SportEnum } from './types/competitionFormat.mjs';
 export { AssignmentStatusEnum, CertificationFamilyEnum, CertificationLevelEnum, CertificationStatusEnum, ConflictSeverityEnum, ConflictTypeEnum, EvaluationStatusEnum, OfficialRoleSubtypeEnum, ScoringMethodEnum, ScoringTypeEnum } from './types/officiatingTypes.mjs';
 export { AmendmentSeverityEnum, AmendmentStatusEnum, ComplianceItemStatusEnum, ComplianceItemTypeEnum, ComplianceStatusEnum, EndorsementStatusEnum, SanctioningRelationshipEnum, SanctioningStatusEnum } from './types/sanctioningTypes.mjs';
-export { AddressTypeEnum, AuthorityRoleEnum, BallTypeEnum, BookingTypeEnum, CategoryEnum, ContactRelationshipEnum, CountryCodeEnum, CourtPositionEnum, CurrencyUnitEnum, DisciplineEnum, DrawStatusEnum, DrawTypeEnum, EntryRestrictionEnum, EntryStatusEnum, EventTypeEnum, FinishingPositionEnum, GenderEnum, IndoorOutdoorEnum, LengthUnitEnum, LinkTypeEnum, MatchUpStatusEnum, OnlineResourceTypeEnum, OrganisationTypeEnum, ParticipantRoleEnum, ParticipantStatusEnum, ParticipantTypeEnum, PayloadProfileEnum, PenaltyTypeEnum, PlayingDoubleHandCodeEnum, PlayingHandCodeEnum, PositioningProfileEnum, PracticeRegistrationStatusEnum, RecognitionEnum, SanctionDecisionEnum, SanctionEnforcementEnum, SanctionFeeKindEnum, SeedingProfileEnum, SelectionProcessEnum, SexEnum, ShotDetailEnum, ShotOutcomeEnum, ShotTypeEnum, StageTypeEnum, StructureTypeEnum, SurfaceCategoryEnum, TieScoreSourceEnum, TierMovementEnum, TournamentLevelEnum, TournamentStatusEnum, WeekdayEnum, WeightUnitEnum, WheelchairClassEnum, WinReasonEnum } from './types/tournamentTypes.mjs';
+export { AddressTypeEnum, AuthorityRoleEnum, BallTypeEnum, BookingTypeEnum, CategoryEnum, ContactRelationshipEnum, CountryCodeEnum, CourtPositionEnum, CurrencyUnitEnum, DisciplineEnum, DrawStatusEnum, DrawTypeEnum, EntryRestrictionEnum, EntryStatusEnum, EventTypeEnum, FinishingPositionEnum, GenderEnum, IndoorOutdoorEnum, LengthUnitEnum, LinkTypeEnum, MatchUpStatusEnum, OnlineResourceTypeEnum, OrganisationTypeEnum, ParticipantRoleEnum, ParticipantStatusEnum, ParticipantTypeEnum, PayloadProfileEnum, PenaltyTypeEnum, PlayingDoubleHandCodeEnum, PlayingHandCodeEnum, PositioningProfileEnum, PracticeRegistrationStatusEnum, RecognitionEnum, SanctionDecisionEnum, SanctionEnforcementEnum, SanctionFeeKindEnum, SeedingBasisEnum, SeedingProfileEnum, SelectionProcessEnum, SexEnum, ShotDetailEnum, ShotOutcomeEnum, ShotTypeEnum, StageTypeEnum, StructureTypeEnum, SurfaceCategoryEnum, TieScoreSourceEnum, TierMovementEnum, TournamentLevelEnum, TournamentStatusEnum, WeekdayEnum, WeightUnitEnum, WheelchairClassEnum, WinReasonEnum } from './types/tournamentTypes.mjs';
 export { toStatObjects } from './query/scoring/statistics/toStatObjects.mjs';
 export { calculateMatchStatistics } from './query/scoring/statistics/standalone.mjs';
+export { ADDITIONAL_SEED_BASES, seedingBasisConstants } from './constants/seedingConstants.mjs';
 export { AvailabilityEngine } from './assemblies/engines/availability/AvailabilityEngine.mjs';
 export { EventNotFoundError, InvalidDateError, InvalidValuesError, MatchUpNotFoundError, MissingDrawDefinitionError, MissingEventError, MissingOfficialRecordError, MissingSanctioningRecordError, MissingTournamentRecordError, MissingTournamentRecordsError, MissingValueError, ParticipantNotFoundError, StructureNotFoundError } from './errors/subclasses.mjs';
 export { FactoryError } from './errors/FactoryError.mjs';

package/dist/esm/mutate/drawDefinitions/entryGovernor/addAdditionalSeed.mjs

@@ -0,0 +1,62 @@
+import { getAdditionalSeedsAllowance } from '../../../query/drawDefinition/getAdditionalSeedsAllowance.mjs';
+import { participantInEntries } from '../../../query/drawDefinition/entryGetter.mjs';
+import { assignSeed } from './seedAssignment.mjs';
+import { decorateResult } from '../../../functions/global/decorateResult.mjs';
+import { findStructure } from '../../../acquire/findStructure.mjs';
+import { SUCCESS } from '../../../constants/resultConstants.mjs';
+import { STRUCTURE_NOT_FOUND, INVALID_PARTICIPANT_ID, SEEDSCOUNT_GREATER_THAN_DRAW_SIZE, ADDITIONAL_SEEDS_EXHAUSTED } from '../../../constants/errorConditionConstants.mjs';
+
+function addAdditionalSeed(params) {
+    const { tournamentRecord, drawDefinition, seedingProfile, participantId, structureId, eventId, event } = params;
+    const stack = 'addAdditionalSeed';
+    const { structure } = findStructure({ drawDefinition, structureId });
+    if (!structure)
+        return { error: STRUCTURE_NOT_FOUND };
+    if (!participantId || !participantInEntries({ drawDefinition, participantId }))
+        return decorateResult({ result: { error: INVALID_PARTICIPANT_ID }, context: { participantId }, stack });
+    const allowance = getAdditionalSeedsAllowance({
+        participantsCount: params.participantsCount,
+        tournamentRecord,
+        drawDefinition,
+        structureId,
+        event,
+    });
+    if (allowance.error)
+        return allowance;
+    const { additionalSeedsRemaining = 0, thresholdSeedsCount = 0, seedLimit = 0, drawSize = 0 } = allowance;
+    const seedNumber = seedLimit + 1;
+    if (seedNumber > drawSize)
+        return decorateResult({
+            result: { error: SEEDSCOUNT_GREATER_THAN_DRAW_SIZE },
+            context: { seedNumber, drawSize },
+            stack,
+        });
+    const isAdditional = seedNumber > thresholdSeedsCount;
+    if (isAdditional && additionalSeedsRemaining < 1)
+        return decorateResult({
+            result: { error: ADDITIONAL_SEEDS_EXHAUSTED },
+            context: { seedNumber, thresholdSeedsCount, ...allowance },
+            stack,
+        });
+    structure.seedLimit = seedNumber;
+    const result = assignSeed({
+        seedValue: params.seedValue ?? seedNumber,
+        seedingBasis: params.seedingBasis,
+        tournamentRecord,
+        drawDefinition,
+        seedingProfile,
+        participantId,
+        structureId,
+        seedNumber,
+        eventId,
+        event,
+    });
+    if (result?.error) {
+        structure.seedLimit = seedLimit;
+        structure.seedAssignments = (structure.seedAssignments ?? []).filter((assignment) => assignment.seedNumber !== seedNumber);
+        return result;
+    }
+    return { ...SUCCESS, seedNumber };
+}
+
+export { addAdditionalSeed };

package/dist/esm/mutate/drawDefinitions/entryGovernor/seedAssignment.mjs

@@ -9,7 +9,7 @@ import { findStructure } from '../../../acquire/findStructure.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';
 import { INVALID_PARTICIPANT_ID, INVALID_DRAW_POSITION_FOR_SEEDING, INVALID_SEED_NUMBER } from '../../../constants/errorConditionConstants.mjs';
 
-function assignSeed({ provisionalPositioning, tournamentRecord, drawDefinition, seedingProfile, participantId, seedBlockInfo, structureId, seedNumber, seedValue, eventId, event, }) {
+function assignSeed({ provisionalPositioning, tournamentRecord, drawDefinition, seedingProfile, participantId, seedBlockInfo, structureId, seedingBasis, seedNumber, seedValue, eventId, event, }) {
     const stack = 'assignSeed';
     const { structure } = findStructure({ drawDefinition, structureId });
     const { positionAssignments } = structureAssignedDrawPositions({ structure });
@@ -50,7 +50,7 @@ function assignSeed({ provisionalPositioning, tournamentRecord, drawDefinition,
             });
     }
     if (!seedNumbers.includes(seedNumber)) {
-        seedAssignments.push({ seedNumber, seedValue });
+        seedAssignments.push({ seedNumber, seedValue, seedingBasis });
     }
     let success;
     seedAssignments.forEach((assignment) => {
@@ -61,6 +61,8 @@ function assignSeed({ provisionalPositioning, tournamentRecord, drawDefinition,
             assignment.participantId = participantId;
             if (!seedingProfile?.groupSeedingThreshold && !flighted)
                 assignment.seedValue = seedValue ?? seedNumber;
+            if (seedingBasis)
+                assignment.seedingBasis = seedingBasis;
             success = true;
         }
     });

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

@@ -27,15 +27,16 @@ function initializeStructureSeedAssignments({ requireParticipantCount = true, en
         roundRobinGroupsCount,
         drawSize,
     })?.seedGroups;
-    const { seedsCount: maxSeedsCount } = getSeedsCount({
+    const { seedsCount: maxSeedsCount, additionalSeedsAllowed = 0 } = getSeedsCount({
         policyDefinitions: appliedPolicies,
         requireParticipantCount,
         drawSizeProgression,
         participantsCount,
         drawSize,
     });
-    if (maxSeedsCount && appliedPolicies?.[POLICY_TYPE_SEEDING] && seedsCount > maxSeedsCount && enforcePolicyLimits) {
-        seedsCount = maxSeedsCount;
+    const policyCeiling = maxSeedsCount ? maxSeedsCount + additionalSeedsAllowed : 0;
+    if (policyCeiling && appliedPolicies?.[POLICY_TYPE_SEEDING] && seedsCount > policyCeiling && enforcePolicyLimits) {
+        seedsCount = policyCeiling;
     }
     structure.seedLimit = seedsCount;
     structure.seedAssignments = generateRange(1, seedsCount + 1).map((seedNumber) => {

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

@@ -16,6 +16,7 @@ import { assignSeed } from '../../drawDefinitions/entryGovernor/seedAssignment.m
 import { getAllStructureMatchUps } from '../../../query/matchUps/getAllStructureMatchUps.mjs';
 import { getInitialRoundNumber } from '../../../query/matchUps/getInitialRoundNumber.mjs';
 import { updateSideLineUp } from '../lineUps/updateSideLineUp.mjs';
+import { isUnscoredOutcome } from '../../../query/matchUp/getDrawPositionWinCount.mjs';
 import { isLuckyBasedDraw } from '../../../query/drawDefinition/isLuckyBasedDraw.mjs';
 import { getAppliedPolicies } from '../../../query/extensions/getAppliedPolicies.mjs';
 import { isValidSeedPosition } from '../../../query/drawDefinition/seedGetter.mjs';
@@ -38,7 +39,7 @@ import { isExit } from '../../../validators/isExit.mjs';
 import { overlap } from '../../../tools/arrays.mjs';
 import { CONTAINER, MAIN, CONSOLATION, PLAY_OFF, QUALIFYING, FIRST_MATCHUP } from '../../../constants/drawDefinitionConstants.mjs';
 import { MISSING_PARTICIPANT_ID, STRUCTURE_NOT_FOUND, INVALID_MATCHUP, INVALID_DRAW_POSITION_FOR_SEEDING, INVALID_DRAW_POSITION, EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT, DRAW_POSITION_ACTIVE, DRAW_POSITION_ASSIGNED } from '../../../constants/errorConditionConstants.mjs';
-import { BYE, TO_BE_PLAYED, DOUBLE_WALKOVER, DOUBLE_DEFAULT, COMPLETED, RETIRED } from '../../../constants/matchUpStatusValues.mjs';
+import { BYE, TO_BE_PLAYED, DOUBLE_WALKOVER, DOUBLE_DEFAULT } from '../../../constants/matchUpStatusValues.mjs';
 
 function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus, tournamentRecord, sourceMatchUpId, drawDefinition, matchUpStatus, drawPosition, matchUpsMap, matchUpId, event, }) {
     const stack = 'assignMatchUpDrawPosition';
@@ -347,7 +348,7 @@ function propagateConsolationBye({ updatedDrawPositions, loserTargetDrawPosition
         matchUpsMap,
     });
     const firstRoundMatchUps = structureMatchUps.filter(({ drawPositions, roundNumber }) => roundNumber === 1 && overlap(drawPositions, updatedDrawPositions));
-    const byePropagation = firstRoundMatchUps.every(({ matchUpStatus }) => [COMPLETED, RETIRED].includes(matchUpStatus));
+    const byePropagation = firstRoundMatchUps.every(({ matchUpStatus, winningSide, score }) => !!winningSide && !isUnscoredOutcome({ matchUpStatus, score }));
     if (byePropagation && loserMatchUp) {
         const { structureId } = loserMatchUp;
         const result = assignDrawPositionBye({

package/dist/esm/mutate/matchUps/matchUpFormat/applyMatchUpFormat.mjs

@@ -6,7 +6,7 @@ import { findStructure } from '../../../acquire/findStructure.mjs';
 import { MATCHUP_FORMAT, DRAW_DEFINITION } from '../../../constants/attributeConstants.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';
 import { TEAM } from '../../../constants/eventConstants.mjs';
-import { UNRECOGNIZED_MATCHUP_FORMAT, INVALID_MATCHUP, INVALID_EVENT_TYPE } from '../../../constants/errorConditionConstants.mjs';
+import { UNRECOGNIZED_MATCHUP_FORMAT, INVALID_EVENT_TYPE, INVALID_MATCHUP } from '../../../constants/errorConditionConstants.mjs';
 
 function applyMatchUpFormat(params) {
     let structureIds = params.structureIds;
@@ -18,19 +18,10 @@ function applyMatchUpFormat(params) {
         return { error: UNRECOGNIZED_MATCHUP_FORMAT };
     const stack = 'setMatchUpFormat';
     if (matchUpId) {
-        const result = findDrawMatchUp({
-            drawDefinition,
-            matchUpId,
-            event,
-        });
-        if (result.error)
-            return result;
-        const matchUp = result.matchUp;
-        if (matchUp?.matchUpType === TEAM)
-            return {
-                info: 'Cannot set matchUpFormat when { matchUpType: TEAM }',
-                error: INVALID_MATCHUP,
-            };
+        const check = checkMatchUpFormatApplication({ drawDefinition, matchUpFormat, matchUpId, event });
+        if (check.error)
+            return check;
+        const matchUp = check.matchUp;
         if (matchUp) {
             matchUp.matchUpFormat = matchUpFormat;
             modifyMatchUpNotice({
@@ -70,5 +61,19 @@ function applyMatchUpFormat(params) {
     modifyDrawNotice({ drawDefinition, structureIds });
     return { ...SUCCESS };
 }
+function checkMatchUpFormatApplication(params) {
+    const { drawDefinition, matchUpFormat, matchUpId, event } = params;
+    if (!isValidMatchUpFormat({ matchUpFormat }))
+        return { error: UNRECOGNIZED_MATCHUP_FORMAT };
+    const result = findDrawMatchUp({ drawDefinition, matchUpId, event });
+    if (result.error)
+        return { error: result.error };
+    if (result.matchUp?.matchUpType === TEAM)
+        return {
+            info: 'Cannot set matchUpFormat when { matchUpType: TEAM }',
+            error: INVALID_MATCHUP,
+        };
+    return { matchUp: result.matchUp };
+}
 
-export { applyMatchUpFormat };
+export { applyMatchUpFormat, checkMatchUpFormatApplication };

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

@@ -70,6 +70,7 @@ function setMatchUpState(params) {
     if (revertError)
         return revertError;
     const impliedCompletionError = checkImpliedCompletionGuard({
+        incomingMatchUpFormat: params.matchUpFormat,
         matchUpStatus,
         winningSide,
         score,
@@ -129,7 +130,11 @@ function setMatchUpState(params) {
         };
     }
     if (score && !isTeam && !disableScoreValidation) {
-        const matchUpFormat = matchUp.matchUpFormat ?? structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event?.matchUpFormat;
+        const matchUpFormat = params.matchUpFormat ??
+            matchUp.matchUpFormat ??
+            structure?.matchUpFormat ??
+            drawDefinition?.matchUpFormat ??
+            event?.matchUpFormat;
         const result = validateScore({
             existingMatchUpStatus: matchUp.matchUpStatus,
             matchUpFormat,
@@ -241,7 +246,7 @@ function checkCompletedRevertGuard({ matchUp, matchUpStatus, winningSide, score,
         stack: 'setMatchUpStatus',
     });
 }
-function checkImpliedCompletionGuard({ matchUpStatus, winningSide, score, isTeam, matchUp, structure, drawDefinition, event, }) {
+function checkImpliedCompletionGuard({ incomingMatchUpFormat, matchUpStatus, winningSide, score, isTeam, matchUp, structure, drawDefinition, event, }) {
     if (isTeam || !matchUpStatus || !REVERT_GUARDED_STATUSES.has(matchUpStatus))
         return undefined;
     if (!winningSide && !checkScoreHasValue({ score }))
@@ -254,7 +259,11 @@ function checkImpliedCompletionGuard({ matchUpStatus, winningSide, score, isTeam
             stack: 'setMatchUpStatus',
         });
     }
-    const matchUpFormat = matchUp?.matchUpFormat ?? structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event?.matchUpFormat;
+    const matchUpFormat = incomingMatchUpFormat ??
+        matchUp?.matchUpFormat ??
+        structure?.matchUpFormat ??
+        drawDefinition?.matchUpFormat ??
+        event?.matchUpFormat;
     if (!matchUpFormat)
         return undefined;
     const { calculatedWinningSide } = analyzeMatchUp({ matchUp: { score, matchUpFormat }, matchUpFormat });
@@ -354,17 +363,17 @@ function resolveAndApplyOutcome({ params, isTeam, dualWinningSideChange, activeD
     const { allowChangePropagation, tournamentRecords, tournamentRecord, drawDefinition, winningSide, matchUpId, matchUpTieId, matchUp, } = params;
     const { schedule } = params;
     if (schedule) {
-        const result = addMatchUpScheduleItems({
+        const check = addMatchUpScheduleItems({
             disableNotice: true,
+            validateOnly: true,
             tournamentRecords,
             tournamentRecord,
             drawDefinition,
             matchUpId,
             schedule,
         });
-        if (result.error) {
-            return result;
-        }
+        if (check.error)
+            return check;
     }
     const validWinningSideSwap = !isTeam && !dualWinningSideChange && winningSide && matchUp.winningSide && matchUp.winningSide !== winningSide;
     if (allowChangePropagation && validWinningSideSwap && matchUp.roundPosition) {
@@ -392,6 +401,18 @@ function resolveAndApplyOutcome({ params, isTeam, dualWinningSideChange, activeD
     else {
         result = { error: NO_VALID_ACTIONS };
     }
+    if (!result?.error && schedule) {
+        const scheduleResult = addMatchUpScheduleItems({
+            disableNotice: true,
+            tournamentRecords,
+            tournamentRecord,
+            drawDefinition,
+            matchUpId,
+            schedule,
+        });
+        if (scheduleResult.error)
+            return decorateResult({ result: scheduleResult, stack });
+    }
     if (!result?.error)
         applyScoredTime({ matchUp });
     return decorateResult({ result, stack });