tods-competition-factory 2.2.16 → 2.2.18

package/dist/tods-competition-factory.d.ts

@@ -2874,8 +2874,8 @@ declare function addVoluntaryConsolationStage(params: any): {
 interface ResetQualifyingStructureArgs {
     tournamentRecord?: Tournament;
     drawDefinition: DrawDefinition;
-    event?: Event$1;
     structureId: string;
+    event?: Event$1;
 }
 declare function resetQualifyingStructure({ tournamentRecord, drawDefinition, event, structureId, }: ResetQualifyingStructureArgs): {
     error: {
@@ -3649,6 +3649,7 @@ type GenerateDrawTypeAndModify = {
     matchUpType?: EventTypeUnion;
     drawDefinition: DrawDefinition;
     drawTypeCoercion?: boolean;
+    qualifyingOnly?: boolean;
     modifyOriginal?: boolean;
     qualifiersCount?: number;
     stageSequence?: number;
@@ -3789,16 +3790,19 @@ declare function generateDrawDefinition(params: GenerateDrawDefinitionArgs): Res
 };
 
 type GenerateQualifyingStructureArgs = {
+    hasExistingDrawDefinition?: boolean;
     appliedPolicies?: PolicyDefinitions;
     qualifyingRoundNumber: number;
     drawDefinition: DrawDefinition;
     qualifyingPositions?: number;
     participantsCount?: number;
     targetStructureId: string;
+    qualifyingOnly?: boolean;
     drawType?: DrawTypeUnion;
     structureOptions?: any;
     matchUpFormat?: string;
     structureName?: string;
+    tieFormat?: TieFormat;
     structureId?: string;
     roundTarget: number;
     drawSize?: number;
@@ -3824,6 +3828,7 @@ type GenerateDrawStructuresAndLinksArgs = {
     overwriteExisting?: boolean;
     drawTypeCoercion?: boolean;
     staggeredEntry?: boolean;
+    qualifyingOnly?: boolean;
     qualifyingProfiles?: any;
     structureName?: string;
     tieFormat?: TieFormat;

package/dist/tods-competition-factory.development.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.16';
+    return '2.2.18';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -15575,22 +15575,7 @@ function withdrawParticipantAtDrawPosition(params) {
     return removeDrawPositionAssignment(params);
 }
 
-function capitalizeFirst(str) {
-    return !isString(str)
-        ? str
-        : str
-            .split(' ')
-            .map((name) => name
-            .split('')
-            .map((c, i) => (i ? c.toLowerCase() : c.toUpperCase()))
-            .join(''))
-            .join(' ');
-}
-function constantToString(str) {
-    return !isString(str) ? '' : capitalizeFirst(str.replace(/_/g, ' '));
-}
-
-const structureTemplate = ({ finishingPosition = ROUND_OUTCOME, qualifyingRoundNumber, structureAbbreviation, seedAssignments = [], stageSequence = 1, structureOrder, seedingProfile, matchUpFormat, structureType, structureName, matchUpType, matchUps = [], structureId, roundOffset, roundLimit, stageOrder, structures, stage, }) => {
+const structureTemplate = ({ finishingPosition = ROUND_OUTCOME, hasExistingDrawDefinition, qualifyingRoundNumber, structureAbbreviation, seedAssignments = [], stageSequence = 1, qualifyingOnly, structureOrder, seedingProfile, matchUpFormat, structureType, structureName, matchUps = [], matchUpType, structureId, roundOffset, roundLimit, stageOrder, structures, tieFormat, stage, }) => {
     const structure = {
         structureId: structureId ?? UUID(),
         structureAbbreviation,
@@ -15600,6 +15585,8 @@ const structureTemplate = ({ finishingPosition = ROUND_OUTCOME, qualifyingRoundN
         stageSequence,
         structureName,
     };
+    if (qualifyingOnly || (hasExistingDrawDefinition && tieFormat))
+        structure.tieFormat = tieFormat;
     if (structureOrder)
         structure.structureOrder = structureOrder;
     if (structureType)
@@ -15637,6 +15624,21 @@ const structureTemplate = ({ finishingPosition = ROUND_OUTCOME, qualifyingRoundN
     return structure;
 };
 
+function capitalizeFirst(str) {
+    return !isString(str)
+        ? str
+        : str
+            .split(' ')
+            .map((name) => name
+            .split('')
+            .map((c, i) => (i ? c.toLowerCase() : c.toUpperCase()))
+            .join(''))
+            .join(' ');
+}
+function constantToString(str) {
+    return !isString(str) ? '' : capitalizeFirst(str.replace(/_/g, ' '));
+}
+
 function addVoluntaryConsolationStructure({ structureName = constantToString(VOLUNTARY_CONSOLATION), structureAbbreviation, drawDefinition, matchUpType, structureId, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -15717,7 +15719,7 @@ const roundRobinGroups = {
 };
 
 function generateRoundRobin(params) {
-    const { groupNameBase = 'Group', playoffAttributes, stageSequence = 1, structureOptions, appliedPolicies, seedingProfile, stage = MAIN, matchUpType, roundTarget, structureId, groupNames, drawSize, idPrefix, isMock, uuids, } = params;
+    const { hasExistingDrawDefinition, groupNameBase = 'Group', playoffAttributes, stageSequence = 1, structureOptions, appliedPolicies, qualifyingOnly, seedingProfile, stage = MAIN, matchUpType, roundTarget, structureId, groupNames, tieFormat, drawSize, idPrefix, isMock, uuids, } = params;
     const structureName = params.structureName ?? playoffAttributes?.['0']?.name ?? constantToString(MAIN);
     const { groupCount, groupSize } = deriveGroups({
         structureOptions,
@@ -15739,21 +15741,26 @@ function generateRoundRobin(params) {
         const structureName = groupNames?.[structureOrder - 1] ?? `${groupNameBase} ${structureOrder}`;
         return structureTemplate({
             structureId: uuids?.pop(),
+            hasExistingDrawDefinition,
             structureType: ITEM,
             finishingPosition,
+            qualifyingOnly,
             structureOrder,
             structureName,
+            tieFormat,
             matchUps,
         });
     });
     const structure = structureTemplate({
         structureId: structureId ?? uuids?.pop(),
+        hasExistingDrawDefinition,
         structureType: CONTAINER,
         finishingPosition,
         seedingProfile,
         structureName,
         stageSequence,
         structures,
+        tieFormat,
         stage,
     });
     if (roundTarget)
@@ -19728,6 +19735,9 @@ function resetQualifyingStructure({ tournamentRecord, drawDefinition, event, str
     const structure = drawDefinition.structures?.find((structure) => structure.stage === QUALIFYING && structure.structureId === structureId);
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
+    const scoresPresent = structure.matchUps?.some(({ matchUpStatus, score }) => checkScoreHasValue({ score }) ?? completedMatchUpStatuses.includes(matchUpStatus));
+    if (scoresPresent)
+        return { error: SCORES_PRESENT };
     const removedMatchUpIds = structure.matchUps?.map(({ matchUpId }) => matchUpId) || [];
     structure.positionAssignments = [];
     structure.seedAssignments = [];
@@ -20073,6 +20083,38 @@ function generateQualifyingLink({ targetEntryRound = 1, finishingPositions, sour
     return { link };
 }
 
+function generateTieMatchUps({ matchUp, tieFormat, isMock, uuids }) {
+    const { collectionDefinitions } = tieFormat ?? {};
+    const tieMatchUps = (collectionDefinitions ?? [])
+        .map((collectionDefinition) => generateCollectionMatchUps({ matchUp, collectionDefinition, uuids, isMock }))
+        .filter(Boolean)
+        .flat();
+    return { tieMatchUps };
+}
+function generateCollectionMatchUps({ collectionPositionOffset = 0, collectionDefinition, matchUpsLimit, matchUp, isMock, uuids, }) {
+    const { matchUpCount, matchUpType, collectionId, processCodes } = collectionDefinition || {};
+    const numberToGenerate = matchUpsLimit ?? matchUpCount ?? 0;
+    const getMatchUpId = (index) => {
+        if (!isMock && !matchUp?.isMock)
+            return uuids?.pop() ?? UUID();
+        const collectionId = collectionDefinition?.collectionId;
+        return uuids?.pop() ?? `${matchUp?.matchUpId}-${collectionId}-TMU-${index + 1}`;
+    };
+    return generateRange(0, numberToGenerate).map((index) => {
+        const collectionPosition = collectionPositionOffset + index + 1;
+        return {
+            sides: [{ sideNumber: 1 }, { sideNumber: 2 }],
+            matchUpId: getMatchUpId(index),
+            matchUpStatus: TO_BE_PLAYED,
+            collectionPosition,
+            collectionId,
+            processCodes,
+            matchUpType,
+            isMock,
+        };
+    });
+}
+
 function generateMatchUpId({ roundPosition, roundNumber, idPrefix, uuids }) {
     return idPrefix ? `${idPrefix}-${roundNumber}-${roundPosition}` : uuids?.pop() || UUID();
 }
@@ -20200,7 +20242,7 @@ function generateQualifyingStructure(params) {
         return decorateResult({ result: { error: INVALID_VALUES }, stack });
     }
     let drawSize = params.drawSize ?? coerceEven(params.participantsCount);
-    const { qualifyingRoundNumber, qualifyingPositions, targetStructureId, structureOptions, appliedPolicies, drawDefinition, matchUpFormat, structureName, structureId, roundTarget, drawType, idPrefix, isMock, uuids, } = params;
+    const { hasExistingDrawDefinition, qualifyingRoundNumber, qualifyingPositions, targetStructureId, structureOptions, appliedPolicies, qualifyingOnly, drawDefinition, matchUpFormat, structureName, structureId, roundTarget, tieFormat, drawType, idPrefix, isMock, uuids, } = params;
     if (!params.drawSize)
         return decorateResult({
             result: { error: MISSING_DRAW_SIZE },
@@ -20240,12 +20282,15 @@ function generateQualifyingStructure(params) {
         const { maxRoundNumber, structures, groupCount } = generateRoundRobin({
             structureName: structureName ?? qualifyingStructureName,
             structureId: structureId ?? uuids?.pop(),
+            hasExistingDrawDefinition,
             stage: QUALIFYING,
             structureOptions,
             appliedPolicies,
+            qualifyingOnly,
             stageSequence,
             matchUpType,
             roundTarget,
+            tieFormat,
             idPrefix,
             drawSize,
             isMock,
@@ -20297,6 +20342,13 @@ function generateQualifyingStructure(params) {
             finishingPositions,
             linkType,
         })?.link;
+    if (tieFormat) {
+        matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
+        matchUps?.forEach((matchUp) => {
+            const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
+            Object.assign(matchUp, { tieMatchUps, matchUpType });
+        });
+    }
     return {
         qualifyingDrawPositionsCount: drawSize,
         qualifiersCount,
@@ -21513,38 +21565,6 @@ function generatePlayoffLink({ playoffStructureId, finishingPositions, sourceStr
     };
 }
 
-function generateTieMatchUps({ matchUp, tieFormat, isMock, uuids }) {
-    const { collectionDefinitions } = tieFormat ?? {};
-    const tieMatchUps = (collectionDefinitions ?? [])
-        .map((collectionDefinition) => generateCollectionMatchUps({ matchUp, collectionDefinition, uuids, isMock }))
-        .filter(Boolean)
-        .flat();
-    return { tieMatchUps };
-}
-function generateCollectionMatchUps({ collectionPositionOffset = 0, collectionDefinition, matchUpsLimit, matchUp, isMock, uuids, }) {
-    const { matchUpCount, matchUpType, collectionId, processCodes } = collectionDefinition || {};
-    const numberToGenerate = matchUpsLimit ?? matchUpCount ?? 0;
-    const getMatchUpId = (index) => {
-        if (!isMock && !matchUp?.isMock)
-            return uuids?.pop() ?? UUID();
-        const collectionId = collectionDefinition?.collectionId;
-        return uuids?.pop() ?? `${matchUp?.matchUpId}-${collectionId}-TMU-${index + 1}`;
-    };
-    return generateRange(0, numberToGenerate).map((index) => {
-        const collectionPosition = collectionPositionOffset + index + 1;
-        return {
-            sides: [{ sideNumber: 1 }, { sideNumber: 2 }],
-            matchUpId: getMatchUpId(index),
-            matchUpStatus: TO_BE_PLAYED,
-            collectionPosition,
-            collectionId,
-            processCodes,
-            matchUpType,
-            isMock,
-        };
-    });
-}
-
 function generateAndPopulateRRplayoffStructures(params) {
     const stack = 'generateAndPopulateRRplayoffStructures';
     if (!params.playoffGroups) {
@@ -21586,11 +21606,7 @@ function generateAndPopulateRRplayoffStructures(params) {
         const tieFormat = resolveTieFormat({ drawDefinition, event })?.tieFormat;
         if (tieFormat) {
             addedMatchUps.forEach((matchUp) => {
-                const { tieMatchUps } = generateTieMatchUps({
-                    isMock: params.isMock,
-                    tieFormat,
-                    matchUp,
-                });
+                const { tieMatchUps } = generateTieMatchUps({ isMock: params.isMock, tieFormat, matchUp });
                 Object.assign(matchUp, { tieMatchUps, matchUpType: TEAM_MATCHUP });
             });
         }
@@ -21919,36 +21935,37 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
     const bestOfGames = parsedGroupMatchUpFormat.bestOf;
     const bracketSetsToWin = (bestOfGames && Math.ceil(bestOfGames / 2)) || 1;
     const bracketGamesForSet = parsedGroupMatchUpFormat.setFormat?.setTo;
+    const precision = Math.pow(10, tallyPolicy?.precision || 3);
     Object.keys(participantResults).forEach((participantId) => {
         const setsWon = participantResults[participantId].setsWon;
         const setsLost = participantResults[participantId].setsLost;
         const setsTotal = tallyPolicy?.groupTotalSetsPlayed
             ? totalSets
             : perPlayer * (bracketSetsToWin || 0) || setsWon + setsLost;
-        let setsPct = Math.round((setsWon / setsTotal) * 1000) / 1000;
+        let setsPct = Math.round((setsWon / setsTotal) * precision) / precision;
         if (setsPct === Infinity || isNaN(setsPct))
             setsPct = setsTotal;
         const tieMatchUpsWon = participantResults[participantId].tieMatchUpsWon;
         const tieMatchUpsLost = participantResults[participantId].tieMatchUpsLost;
         const tieMatchUpsTotal = tieMatchUpsWon + tieMatchUpsLost;
-        let tieMatchUpsPct = Math.round((tieMatchUpsWon / tieMatchUpsTotal) * 1000) / 1000;
+        let tieMatchUpsPct = Math.round((tieMatchUpsWon / tieMatchUpsTotal) * precision) / precision;
         if (tieMatchUpsPct === Infinity || isNaN(tieMatchUpsPct))
             tieMatchUpsPct = tieMatchUpsWon;
         const matchUpsWon = participantResults[participantId].matchUpsWon;
         const matchUpsLost = participantResults[participantId].matchUpsLost;
         const matchUpsTotal = matchUpsWon + matchUpsLost;
-        let matchUpsPct = Math.round((matchUpsWon / matchUpsTotal) * 1000) / 1000;
+        let matchUpsPct = Math.round((matchUpsWon / matchUpsTotal) * precision) / precision;
         if (matchUpsPct === Infinity || isNaN(matchUpsPct))
             matchUpsPct = matchUpsWon;
         const gamesWon = participantResults[participantId].gamesWon || 0;
         const gamesLost = participantResults[participantId].gamesLost || 0;
         const minimumExpectedGames = (perPlayer || 0) * (bracketSetsToWin || 0) * (bracketGamesForSet || 0);
         const gamesTotal = Math.max(minimumExpectedGames, gamesWon + gamesLost);
-        let gamesPct = Math.round((gamesWon / gamesTotal) * 1000) / 1000;
+        let gamesPct = Math.round((gamesWon / gamesTotal) * precision) / precision;
         if (gamesPct === Infinity || isNaN(gamesPct))
             gamesPct = 0;
         const pointsTotal = participantResults[participantId].pointsWon + participantResults[participantId].pointsLost;
-        let pointsPct = Math.round((participantResults[participantId].pointsWon / pointsTotal) * 1000) / 1000;
+        let pointsPct = Math.round((participantResults[participantId].pointsWon / pointsTotal) * precision) / precision;
         if (pointsPct === Infinity || isNaN(pointsPct))
             pointsPct = 0;
         participantResults[participantId].setsWon = setsWon;
@@ -27051,7 +27068,7 @@ var query$b = {
     positionActions: positionActions
 };
 
-function generateQualifyingStructures({ qualifyingProfiles, appliedPolicies, idPrefix, isMock, uuids, }) {
+function generateQualifyingStructures({ hasExistingDrawDefinition, qualifyingProfiles, appliedPolicies, qualifyingOnly, tieFormat, idPrefix, isMock, uuids, }) {
     const stack = 'generateQualifyingSTructures';
     const qualifyingDetails = [];
     const structures = [];
@@ -27085,12 +27102,15 @@ function generateQualifyingStructures({ qualifyingProfiles, appliedPolicies, idP
                 const { structures, groupCount, maxRoundNumber } = generateRoundRobin({
                     structureName: structureProfile.structureName || qualifyingStructureName,
                     structureId: structureId || uuids?.pop(),
+                    hasExistingDrawDefinition,
                     stage: QUALIFYING,
                     structureOptions,
                     appliedPolicies,
+                    qualifyingOnly,
                     stageSequence,
                     matchUpType,
                     roundTarget,
+                    tieFormat,
                     drawSize,
                     idPrefix,
                     isMock,
@@ -27115,11 +27135,14 @@ function generateQualifyingStructures({ qualifyingProfiles, appliedPolicies, idP
                     structureName: structureProfile.structureName || qualifyingStructureName,
                     structureId: structureId || uuids?.pop(),
                     qualifyingRoundNumber: roundLimit,
+                    hasExistingDrawDefinition,
                     stage: QUALIFYING,
+                    qualifyingOnly,
                     matchUpFormat,
                     stageSequence,
                     matchUpType,
                     roundLimit,
+                    tieFormat,
                     matchUps,
                 });
                 if (roundTarget) {
@@ -27147,6 +27170,13 @@ function generateQualifyingStructures({ qualifyingProfiles, appliedPolicies, idP
             linkType = drawType === ROUND_ROBIN ? POSITION : WINNER;
             finalQualifyingStructureId = structure.structureId;
             finalQualifyingRoundNumber = roundLimit;
+            if (tieFormat) {
+                matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
+                matchUps?.forEach((matchUp) => {
+                    const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
+                    Object.assign(matchUp, { tieMatchUps, matchUpType });
+                });
+            }
             structures.push(structure);
             stageSequence += 1;
         }
@@ -27457,7 +27487,7 @@ function luckyRoundProfiles(drawSize) {
 }
 
 function getGenerators(params) {
-    const { playoffAttributes, stageSequence = 1, stage = MAIN, matchUpType, drawSize, uuids } = params;
+    const { playoffAttributes, stageSequence = 1, stage = MAIN, tieFormat, matchUpType, drawSize, uuids } = params;
     const getPrefixedStructureId = () => {
         if (!params.isMock && !params.idPrefix)
             return undefined;
@@ -27476,6 +27506,7 @@ function getGenerators(params) {
             structureName,
             matchUpType,
             structureId,
+            tieFormat,
             matchUps,
             stage,
         });
@@ -27529,6 +27560,7 @@ function getGenerators(params) {
                 matchUpType,
                 structureId,
                 stage: MAIN,
+                tieFormat,
                 matchUps,
             });
             return { structures: [structure], links: [], ...SUCCESS };
@@ -27548,7 +27580,7 @@ function getGenerators(params) {
 }
 
 function generateDrawStructuresAndLinks(params) {
-    const { enforceMinimumDrawSize = true, overwriteExisting, appliedPolicies, staggeredEntry, drawDefinition, tieFormat, isMock, uuids, } = params || {};
+    const { enforceMinimumDrawSize = true, overwriteExisting, appliedPolicies, qualifyingOnly, staggeredEntry, drawDefinition, tieFormat, isMock, uuids, } = params || {};
     const drawSize = ensureInt(params.drawSize);
     const drawTypeCoercion = params.drawTypeCoercion ?? getDrawTypeCoercion({ appliedPolicies, drawType: params.drawType });
     const stack = 'generateDrawStructuresAndLinks';
@@ -27613,6 +27645,8 @@ function generateDrawStructuresAndLinks(params) {
             idPrefix: params.idPrefix,
             qualifyingProfiles,
             appliedPolicies,
+            qualifyingOnly,
+            tieFormat,
             isMock,
             uuids,
         });
@@ -27787,11 +27821,7 @@ function generateDrawTypeAndModifyDrawDefinition(params) {
     if (tieFormat) {
         matchUps?.forEach((matchUp) => {
             if (!existingMatchUpIds.includes(matchUp.matchUpId)) {
-                const { tieMatchUps } = generateTieMatchUps({
-                    tieFormat,
-                    matchUp,
-                    isMock,
-                });
+                const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
                 Object.assign(matchUp, { tieMatchUps, matchUpType });
             }
         });
@@ -32383,13 +32413,16 @@ function getDrawFormat(params) {
 
 function processExistingDrawDefinition(params) {
     const drawDefinition = params.drawDefinition;
-    const { existingQualifyingPlaceholderStructureId, appliedPolicies, drawEntries, structureId, idPrefix, isMock, event, } = params;
+    const { existingQualifyingPlaceholderStructureId, appliedPolicies, qualifyingOnly, drawEntries, structureId, tieFormat, idPrefix, isMock, event, } = params;
     const qualifyingProfiles = params.qualifyingProfiles;
     const qualifyingResult = qualifyingProfiles?.length
         ? generateQualifyingStructures({
+            hasExistingDrawDefinition: true,
             uuids: params.uuids,
             qualifyingProfiles,
             appliedPolicies,
+            qualifyingOnly,
+            tieFormat,
             idPrefix,
             isMock,
         })
@@ -33130,7 +33163,7 @@ function checkTieFormat({ tieFormat }) {
     return { tieFormat };
 }
 
-function checkFormatScopeEquivalence({ tournamentRecord, drawDefinition, matchUpFormat, matchUpType, tieFormat, event, }) {
+function checkFormatScopeEquivalence({ existingQualifyingStructures, tournamentRecord, drawDefinition, matchUpFormat, matchUpType, tieFormat, event, }) {
     if (matchUpFormat || tieFormat) {
         const equivalentInScope = (matchUpFormat && event?.matchUpFormat === matchUpFormat) ||
             (event?.tieFormat && tieFormat && JSON.stringify(event.tieFormat) === JSON.stringify(tieFormat));
@@ -33139,7 +33172,10 @@ function checkFormatScopeEquivalence({ tournamentRecord, drawDefinition, matchUp
                 const result = checkTieFormat({ tieFormat });
                 if (result.error)
                     return result;
-                drawDefinition.tieFormat = result.tieFormat ?? tieFormat;
+                const existingQualifyingTieFormats = existingQualifyingStructures?.every((structure) => structure.tieFormat);
+                if (!existingQualifyingStructures?.length || existingQualifyingTieFormats) {
+                    drawDefinition.tieFormat = result.tieFormat ?? tieFormat;
+                }
             }
             else if (matchUpFormat) {
                 const result = setMatchUpMatchUpFormat({
@@ -33307,10 +33343,17 @@ function existingPolicyDefinitions({ policyDefinitions, appliedPolicies, policie
 }
 
 function setUpDrawGeneration(params) {
-    const { tournamentRecord, matchUpFormat, appliedPolicies, policyDefinitions, matchUpType, tieFormat, drawType, stack, event, } = params;
+    const { tournamentRecord, policyDefinitions, appliedPolicies, matchUpFormat, matchUpType, tieFormat, drawType, stack, event, } = params;
     const existingDrawDefinition = params.drawId
         ? event?.drawDefinitions?.find((d) => d.drawId === params.drawId)
         : undefined;
+    const structureId = existingDrawDefinition?.structures?.find((structure) => structure.stage === MAIN && structure.stageSequence === 1)?.structureId;
+    const existingQualifyingStructures = existingDrawDefinition
+        ? existingDrawDefinition.structures?.filter((structure) => structure.stage === QUALIFYING)
+        : [];
+    const existingQualifyingPlaceholderStructureId = existingQualifyingStructures?.length === 1 &&
+        !existingQualifyingStructures[0].matchUps?.length &&
+        existingQualifyingStructures[0].structureId;
     if (existingDrawDefinition && drawType !== existingDrawDefinition.drawType)
         existingDrawDefinition.drawType = drawType;
     const drawDefinition = existingDrawDefinition ??
@@ -33320,6 +33363,7 @@ function setUpDrawGeneration(params) {
             drawType,
         });
     const equivalenceResult = checkFormatScopeEquivalence({
+        existingQualifyingStructures,
         tournamentRecord,
         drawDefinition,
         matchUpFormat,
@@ -33332,13 +33376,6 @@ function setUpDrawGeneration(params) {
     const attachmentResult = policyAttachment({ appliedPolicies, policyDefinitions, drawDefinition, stack });
     if (attachmentResult.error)
         return attachmentResult;
-    const structureId = existingDrawDefinition?.structures?.find((structure) => structure.stage === MAIN && structure.stageSequence === 1)?.structureId;
-    const existingQualifyingStructures = existingDrawDefinition
-        ? existingDrawDefinition.structures?.filter((structure) => structure.stage === QUALIFYING)
-        : [];
-    const existingQualifyingPlaceholderStructureId = existingQualifyingStructures?.length === 1 &&
-        !existingQualifyingStructures[0].matchUps?.length &&
-        existingQualifyingStructures[0].structureId;
     return { drawDefinition, structureId, existingDrawDefinition, existingQualifyingPlaceholderStructureId };
 }
 
@@ -33375,7 +33412,7 @@ function generateOrGetExisting(params) {
 }
 
 function qualifyingGeneration(params) {
-    const { qualifyingPlaceholder, qualifyingProfiles, existingDrawDefinition, positioningReports, appliedPolicies, qualifyingOnly, drawDefinition, seedingProfile, participants, structureId, entries, stack, } = params;
+    const { qualifyingPlaceholder, existingDrawDefinition, positioningReports, qualifyingProfiles, appliedPolicies, qualifyingOnly, drawDefinition, seedingProfile, participants, structureId, tieFormat, entries, stack, } = params;
     const generateQualifyingPlaceholder = qualifyingPlaceholder && !qualifyingProfiles?.length && !existingDrawDefinition;
     const qualifyingConflicts = [];
     if (qualifyingProfiles) {
@@ -33438,6 +33475,8 @@ function qualifyingGeneration(params) {
         const qualifyingStructure = structureTemplate({
             structureName: constantToString(QUALIFYING),
             stage: QUALIFYING,
+            qualifyingOnly,
+            tieFormat,
         });
         const { link } = generateQualifyingLink({
             sourceStructureId: qualifyingStructure.structureId,