tods-competition-factory 1.8.24 → 1.8.26

package/dist/index.mjs

@@ -1021,6 +1021,10 @@ const SCHEDULED_MATCHUPS = {
   message: "Scheduled matchUps",
   code: "ERR_SCHEDULED_MATCHUPS"
 };
+const SCORES_PRESENT = {
+  message: "Scores present",
+  code: "ERR_SCORES_PRESENT"
+};
 const errorConditionConstants = {
   ANACHRONISM,
   CANNOT_CHANGE_WINNING_SIDE,
@@ -1183,6 +1187,7 @@ const errorConditionConstants = {
   POLICY_NOT_FOUND,
   SCHEDULE_NOT_CLEARED,
   SCHEDULED_MATCHUPS,
+  SCORES_PRESENT,
   SEEDSCOUNT_GREATER_THAN_DRAW_SIZE,
   STAGE_SEQUENCE_LIMIT,
   STRUCTURE_NOT_FOUND,
@@ -1293,18 +1298,21 @@ function cycleMutationStatus$1() {
   return status;
 }
 function addNotice$1({ topic, payload, key }) {
-  syncGlobalState.modified = true;
   if (typeof topic !== "string" || typeof payload !== "object") {
     return;
   }
-  if (syncGlobalState.disableNotifications || !syncGlobalState.subscriptions[topic])
+  if (!syncGlobalState.disableNotifications)
+    syncGlobalState.modified = true;
+  if (syncGlobalState.disableNotifications || !syncGlobalState.subscriptions[topic]) {
     return;
+  }
   if (key) {
     syncGlobalState.notices = syncGlobalState.notices.filter(
       (notice) => !(notice.topic === topic && notice.key === key)
     );
   }
   syncGlobalState.notices.push({ topic, payload, key });
+  return { ...SUCCESS };
 }
 function getNotices$1({ topic }) {
   const notices = syncGlobalState.notices.filter((notice) => notice.topic === topic).map((notice) => notice.payload);
@@ -2382,7 +2390,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.24";
+  return "1.8.26";
 }
 
 function getObjectTieFormat(obj) {
@@ -6446,41 +6454,6 @@ function getMatchUpType(params) {
   return { matchUpType };
 }
 
-function modifyEntryProfile({
-  drawDefinition,
-  attributes
-}) {
-  let { extension } = findDrawDefinitionExtension({
-    name: ENTRY_PROFILE,
-    drawDefinition
-  });
-  const entryProfile = extension?.value || {};
-  attributes.forEach((attribute) => {
-    Object.keys(attribute).forEach((key) => {
-      if (!entryProfile[key]) {
-        entryProfile[key] = attribute[key];
-      } else {
-        Object.assign(entryProfile[key], attribute[key]);
-      }
-    });
-  });
-  extension = {
-    name: ENTRY_PROFILE,
-    value: entryProfile
-  };
-  addDrawDefinitionExtension({ drawDefinition, extension });
-  return { entryProfile };
-}
-
-function getEntryProfile({ drawDefinition }) {
-  const { extension } = findDrawDefinitionExtension({
-    name: ENTRY_PROFILE,
-    drawDefinition
-  });
-  const entryProfile = extension?.value || {};
-  return { entryProfile };
-}
-
 const MAIN = "MAIN";
 const QUALIFYING = "QUALIFYING";
 const CONSOLATION = "CONSOLATION";
@@ -6530,6 +6503,7 @@ const WINNER = "WINNER";
 const LOSER = "LOSER";
 const FIRST_MATCHUP = "FIRST_MATCHUP";
 const AD_HOC = "AD_HOC";
+const FLEX_ROUNDS = "AD_HOC";
 const FEED_IN$1 = "FEED_IN";
 const COMPASS = "COMPASS";
 const OLYMPIC = "OLYMPIC";
@@ -6621,6 +6595,7 @@ const drawDefinitionConstants = {
   LOSER,
   AD_HOC,
   FEED_IN: FEED_IN$1,
+  FLEX_ROUNDS,
   COMPASS,
   PLAY_OFF,
   OLYMPIC,
@@ -6746,6 +6721,118 @@ function getDrawStructures({
   }
 }
 
+function getAllPositionedParticipantIds({
+  drawDefinition
+}) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  const stagePositionedParticipantIds = {};
+  const allPositionedParticipantIds = (drawDefinition.structures || []).map((structure) => {
+    const stage = structure.stage;
+    if (!stagePositionedParticipantIds[stage])
+      stagePositionedParticipantIds[stage] = [];
+    const { positionAssignments } = getPositionAssignments$1({ structure });
+    const particiapntIds = positionAssignments?.map(extractAttributes("participantId")).filter(Boolean) ?? [];
+    stagePositionedParticipantIds[stage].push(...particiapntIds);
+    return particiapntIds;
+  }).flat();
+  return { allPositionedParticipantIds, stagePositionedParticipantIds };
+}
+function getPositionAssignments$1({
+  drawDefinition,
+  structureId,
+  structure
+}) {
+  let error, positionAssignments = [];
+  if (!structure) {
+    if (!drawDefinition) {
+      return { positionAssignments, error: MISSING_DRAW_DEFINITION };
+    }
+    ({ structure, error } = findStructure({ drawDefinition, structureId }));
+    if (error)
+      return { positionAssignments, error };
+  }
+  if (structure.structures) {
+    positionAssignments = [].concat(
+      ...structure.structures.map((structure2) => {
+        return getPositionAssignments$1({ structure: structure2 }).positionAssignments;
+      })
+    );
+  } else if (structure.positionAssignments) {
+    positionAssignments = structure.positionAssignments;
+  } else {
+    error = MISSING_POSITION_ASSIGNMENTS;
+  }
+  return { positionAssignments, error };
+}
+function structureAssignedDrawPositions({
+  drawDefinition,
+  structureId,
+  structure
+}) {
+  const positionAssignments = getPositionAssignments$1({
+    drawDefinition,
+    structureId,
+    structure
+  })?.positionAssignments || [];
+  const assignedPositions = positionAssignments?.filter((assignment) => {
+    return assignment.participantId ?? assignment.bye ?? assignment.qualifier;
+  });
+  const allPositionsAssigned = positionAssignments && positionAssignments?.length === assignedPositions?.length;
+  const unassignedPositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && !assignment.bye && !assignment.qualifier;
+  });
+  const byePositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && assignment.bye;
+  });
+  const qualifierPositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && assignment.qualifier;
+  });
+  return {
+    allPositionsAssigned,
+    positionAssignments,
+    unassignedPositions,
+    assignedPositions,
+    qualifierPositions,
+    byePositions
+  };
+}
+
+function modifyEntryProfile({
+  drawDefinition,
+  attributes
+}) {
+  let { extension } = findDrawDefinitionExtension({
+    name: ENTRY_PROFILE,
+    drawDefinition
+  });
+  const entryProfile = extension?.value || {};
+  attributes.forEach((attribute) => {
+    Object.keys(attribute).forEach((key) => {
+      if (!entryProfile[key]) {
+        entryProfile[key] = attribute[key];
+      } else {
+        Object.assign(entryProfile[key], attribute[key]);
+      }
+    });
+  });
+  extension = {
+    name: ENTRY_PROFILE,
+    value: entryProfile
+  };
+  addDrawDefinitionExtension({ drawDefinition, extension });
+  return { entryProfile };
+}
+
+function getEntryProfile({ drawDefinition }) {
+  const { extension } = findDrawDefinitionExtension({
+    name: ENTRY_PROFILE,
+    drawDefinition
+  });
+  const entryProfile = extension?.value || {};
+  return { entryProfile };
+}
+
 const ALTERNATE = EntryStatusEnum.Alternate;
 const CONFIRMED = EntryStatusEnum.Confirmed;
 const DIRECT_ACCEPTANCE = EntryStatusEnum.DirectAcceptance;
@@ -6987,6 +7074,7 @@ function getStageWildcardEntriesCount({ stage, drawDefinition }) {
 
 function getStructureSeedAssignments({
   provisionalPositioning,
+  returnAllProxies,
   drawDefinition,
   structureId,
   structure
@@ -6995,6 +7083,9 @@ function getStructureSeedAssignments({
   if (!structure) {
     ({ structure, error } = findStructure({ drawDefinition, structureId }));
   }
+  const positionAssignments = getPositionAssignments$1({
+    structure
+  }).positionAssignments;
   if (error || !structure)
     return { seedAssignments: [], error: STRUCTURE_NOT_FOUND };
   if (!structureId)
@@ -7008,18 +7099,22 @@ function getStructureSeedAssignments({
     structureId,
     stage
   });
-  const seedProxies = entries ? entries.filter((entry) => entry.placementGroup === 1).sort((a, b) => {
+  const proxiedEntries = entries ? entries.filter((entry) => entry.placementGroup === 1).sort((a, b) => {
     return a.GEMscore < b.GEMscore && 1 || a.GEMscore > b.GEMscore && -1 || 0;
   }).map((entry, index) => {
     const seedNumber = index + 1;
     return {
       participantId: entry.participantId,
       seedValue: seedNumber,
-      seedNumber,
-      seedProxy: true
+      seedProxy: true,
       // flag so that proxy seeding information doesn't get used externally
+      seedNumber
     };
   }) : [];
+  const seedProxies = proxiedEntries?.slice(
+    0,
+    returnAllProxies ? proxiedEntries.length : positionAssignments.length / 2
+  );
   if (seedProxies.length) {
     seedAssignments = seedProxies;
   } else if (structure.seedAssignments) {
@@ -7028,7 +7123,13 @@ function getStructureSeedAssignments({
     error = MISSING_SEED_ASSIGNMENTS;
   }
   const seedLimit = structure.seedLimit || structure?.positionAssignments?.length;
-  return { seedAssignments, seedLimit, stage, stageSequence, error };
+  return {
+    seedAssignments,
+    stageSequence,
+    seedLimit,
+    stage,
+    error
+  };
 }
 
 function getExitProfiles({ drawDefinition }) {
@@ -7307,83 +7408,6 @@ function getSourceDrawPositionRanges({
   return { sourceDrawPositionRanges };
 }
 
-function getAllPositionedParticipantIds({
-  drawDefinition
-}) {
-  if (!drawDefinition)
-    return { error: MISSING_DRAW_DEFINITION };
-  const stagePositionedParticipantIds = {};
-  const allPositionedParticipantIds = (drawDefinition.structures || []).map((structure) => {
-    const stage = structure.stage;
-    if (!stagePositionedParticipantIds[stage])
-      stagePositionedParticipantIds[stage] = [];
-    const { positionAssignments } = getPositionAssignments$1({ structure });
-    const particiapntIds = positionAssignments?.map(extractAttributes("participantId")).filter(Boolean) ?? [];
-    stagePositionedParticipantIds[stage].push(...particiapntIds);
-    return particiapntIds;
-  }).flat();
-  return { allPositionedParticipantIds, stagePositionedParticipantIds };
-}
-function getPositionAssignments$1({
-  drawDefinition,
-  structureId,
-  structure
-}) {
-  let error, positionAssignments = [];
-  if (!structure) {
-    if (!drawDefinition) {
-      return { positionAssignments, error: MISSING_DRAW_DEFINITION };
-    }
-    ({ structure, error } = findStructure({ drawDefinition, structureId }));
-    if (error)
-      return { positionAssignments, error };
-  }
-  if (structure.structures) {
-    positionAssignments = [].concat(
-      ...structure.structures.map((structure2) => {
-        return getPositionAssignments$1({ structure: structure2 }).positionAssignments;
-      })
-    );
-  } else if (structure.positionAssignments) {
-    positionAssignments = structure.positionAssignments;
-  } else {
-    error = MISSING_POSITION_ASSIGNMENTS;
-  }
-  return { positionAssignments, error };
-}
-function structureAssignedDrawPositions({
-  drawDefinition,
-  structureId,
-  structure
-}) {
-  const positionAssignments = getPositionAssignments$1({
-    drawDefinition,
-    structureId,
-    structure
-  })?.positionAssignments || [];
-  const assignedPositions = positionAssignments?.filter((assignment) => {
-    return assignment.participantId ?? assignment.bye ?? assignment.qualifier;
-  });
-  const allPositionsAssigned = positionAssignments && positionAssignments?.length === assignedPositions?.length;
-  const unassignedPositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && !assignment.bye && !assignment.qualifier;
-  });
-  const byePositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && assignment.bye;
-  });
-  const qualifierPositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && assignment.qualifier;
-  });
-  return {
-    allPositionsAssigned,
-    positionAssignments,
-    unassignedPositions,
-    assignedPositions,
-    qualifierPositions,
-    byePositions
-  };
-}
-
 function getOrderedDrawPositions({
   drawPositions,
   roundProfile,
@@ -23753,6 +23777,7 @@ function getSeedingThresholds({
 
 function getValidSeedBlocks({
   provisionalPositioning,
+  returnAllProxies,
   appliedPolicies,
   drawDefinition,
   allPositions,
@@ -23768,6 +23793,7 @@ function getValidSeedBlocks({
   });
   const { seedAssignments } = getStructureSeedAssignments({
     provisionalPositioning,
+    returnAllProxies,
     drawDefinition,
     structure
   });
@@ -24002,6 +24028,7 @@ function getNextSeedBlock(params) {
   } = params;
   const { structure } = findStructure({ drawDefinition, structureId });
   const { seedAssignments } = getStructureSeedAssignments({
+    returnAllProxies: params.returnAllProxies,
     provisionalPositioning,
     drawDefinition,
     structure
@@ -24013,6 +24040,7 @@ function getNextSeedBlock(params) {
   const assignedDrawPositions = positionsWithParticipants?.map((assignment) => assignment.drawPosition).filter(Boolean);
   const { appliedPolicies } = getAppliedPolicies({ drawDefinition });
   const validSeedBlocks = seedBlockInfo?.validSeedBlocks || structure && getValidSeedBlocks({
+    returnAllProxies: params.returnAllProxies,
     provisionalPositioning,
     appliedPolicies,
     drawDefinition,
@@ -41569,8 +41597,7 @@ function randomUnseededSeparation({
   structureId,
   avoidance,
   drawSize,
-  entries,
-  // entries for the specific stage of drawDefinition
+  // entries, // entries for the specific stage of drawDefinition
   event
 }) {
   if (!avoidance) {
@@ -41608,10 +41635,11 @@ function randomUnseededSeparation({
   const isRoundRobin = structure?.structureType === CONTAINER;
   const params = isRoundRobin ? { structure, matchUps, allDrawPositions, roundsToSeparate } : { matchUps, allDrawPositions, roundsToSeparate };
   const { drawPositionGroups, drawPositionChunks } = isRoundRobin ? roundRobinParticipantGroups(params) : eliminationParticipantGroups(params);
-  const idCollections = {};
-  idCollections.groupParticipants = participants.filter((participant) => participant.participantType === GROUP).map((participant) => participant.participantId);
-  idCollections.teamParticipants = participants.filter((participant) => participant.participantType === TEAM).map((participant) => participant.participantId);
-  idCollections.pairParticipants = participants.filter((participant) => participant.participantType === PAIR).map((participant) => participant.participantId);
+  const idCollections = {
+    groupParticipants: participants.filter((participant) => participant.participantType === GROUP).map((participant) => participant.participantId),
+    teamParticipants: participants.filter((participant) => participant.participantType === TEAM).map((participant) => participant.participantId),
+    pairParticipants: participants.filter((participant) => participant.participantType === PAIR).map((participant) => participant.participantId)
+  };
   const allGroups = getAttributeGroupings({
     targetParticipantIds: unseededParticipantIds,
     policyAttributes,
@@ -41672,8 +41700,8 @@ function randomUnseededSeparation({
         policyAttributes,
         idCollections,
         allGroups,
-        drawSize,
-        entries
+        drawSize
+        // entries,
       })
     );
     const candidates = noPairPriorityCandidates.concat(...pairedPriorityCandidates).filter((candidate2) => !candidate2.errors?.length);
@@ -42043,11 +42071,11 @@ function getSeedOrderByePositions({
   const strictSeedOrderByePositions = getOrderedByePositions({
     orderedSeedDrawPositions: orderedSortedFirstRoundSeededDrawPositions,
     relevantMatchUps
-  }).slice(0, positionedSeeds.length);
+  }).slice(0, byesToPlace);
   const blockSeedOrderByePositions = getOrderedByePositions({
     orderedSeedDrawPositions: blockSortedRandomDrawPositions,
     relevantMatchUps
-  }).slice(0, positionedSeeds.length);
+  }).slice(0, byesToPlace);
   return {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
@@ -42729,7 +42757,6 @@ function automatedPositioning$1({
       event
     }) : void 0;
     if (result2?.error) {
-      console.log("positionByes", { result: result2 });
       return handleErrorCondition(result2);
     }
     unseededByePositions = result2?.unseededByePositions;
@@ -42852,6 +42879,7 @@ function automatedPlayoffPositioning(params) {
   );
   const structurePositionAssignments = [];
   const participants = tournamentRecord?.participants;
+  const positioningReports = [];
   if (playoffStructures) {
     for (const structure of playoffStructures) {
       const { structureId: playoffStructureId } = structure;
@@ -42873,9 +42901,11 @@ function automatedPlayoffPositioning(params) {
           structureId: playoffStructureId
         });
       }
+      if (result.positioningReport)
+        positioningReports.push(result.positioningReport);
     }
   }
-  return { ...SUCCESS, structurePositionAssignments };
+  return { ...SUCCESS, structurePositionAssignments, positioningReports };
 }
 
 function generateAndPopulateRRplayoffStructures(params) {
@@ -43538,9 +43568,15 @@ function getStructureGroups({
 }
 
 function generateQualifyingStructure$1(params) {
-  if (!params.drawDefinition)
-    return { error: MISSING_DRAW_DEFINITION };
   const stack = "generateQualifyingStructure";
+  if (!params.drawDefinition)
+    return decorateResult({
+      result: { error: MISSING_DRAW_DEFINITION },
+      stack
+    });
+  if (params.drawSize && !isConvertableInteger(params.drawSize) || params.participantsCount && !isConvertableInteger(params.participantsCount) || params.qualifyingPositions && !isConvertableInteger(params.qualifyingPositions)) {
+    return decorateResult({ result: { error: INVALID_VALUES }, stack });
+  }
   let drawSize = params.drawSize ?? coerceEven(params.participantsCount);
   const {
     qualifyingRoundNumber,
@@ -43558,13 +43594,22 @@ function generateQualifyingStructure$1(params) {
     isMock,
     uuids
   } = params;
+  if (!params.drawSize)
+    return decorateResult({
+      result: { error: MISSING_DRAW_SIZE },
+      context: { drawSize },
+      stack
+    });
+  if (qualifyingPositions && qualifyingPositions >= params.drawSize)
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { drawSize, qualifyingPositions },
+      stack
+    });
   let roundLimit, roundsCount, structure, matchUps;
   let qualifiersCount = 0;
   let finishingPositions;
   const stageSequence = 1;
-  if (!isConvertableInteger(drawSize)) {
-    return decorateResult({ result: { error: MISSING_DRAW_SIZE }, stack });
-  }
   const { structureProfiles } = getStructureGroups({ drawDefinition });
   const structureProfile = structureProfiles[targetStructureId];
   if (!structureProfile) {
@@ -43650,6 +43695,19 @@ function generateQualifyingStructure$1(params) {
   };
 }
 
+function resequenceStructures({ drawDefinition }) {
+  const { maxQualifyingDepth, structureProfiles } = getStructureGroups({
+    drawDefinition
+  });
+  for (const structure of drawDefinition.structures) {
+    const profile = structureProfiles[structure.structureId];
+    if (profile.distanceFromMain) {
+      structure.stageSequence = maxQualifyingDepth + 1 - profile.distanceFromMain;
+    }
+  }
+  return { ...SUCCESS };
+}
+
 function attachQualifyingStructure$1({
   drawDefinition,
   tournamentId,
@@ -43680,15 +43738,7 @@ function attachQualifyingStructure$1({
     drawDefinition.links = [];
   drawDefinition.structures.push(structure);
   drawDefinition.links.push(link);
-  const { maxQualifyingDepth, structureProfiles } = getStructureGroups({
-    drawDefinition
-  });
-  for (const structure2 of drawDefinition.structures) {
-    const profile = structureProfiles[structure2.structureId];
-    if (profile.distanceFromMain) {
-      structure2.stageSequence = maxQualifyingDepth + 1 - profile.distanceFromMain;
-    }
-  }
+  resequenceStructures({ drawDefinition });
   const matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
   addMatchUpsNotice({
     drawDefinition,
@@ -44199,7 +44249,8 @@ function removeStructure({
   tournamentRecord,
   drawDefinition,
   structureId,
-  event
+  event,
+  force
 }) {
   if (typeof structureId !== "string")
     return { error: INVALID_VALUES };
@@ -44209,10 +44260,21 @@ function removeStructure({
     return { error: MISSING_STRUCTURE_ID };
   const structures = drawDefinition.structures || [];
   const removedStructureIds = [];
+  const structure = structures.find(
+    (structure2) => structure2.structureId === structureId
+  );
+  if (!structure)
+    return { error: STRUCTURE_NOT_FOUND };
+  const structureMatchUps = getAllStructureMatchUps({ structure }).matchUps;
+  const scoresPresent = structureMatchUps.some(
+    ({ score }) => scoreHasValue({ score })
+  );
+  if (scoresPresent && !force)
+    return { error: SCORES_PRESENT };
   const mainStageSequence1 = structures.find(
     ({ stage, stageSequence }) => stage === MAIN && stageSequence === 1
   );
-  const isMainStageSequence1 = structureId === mainStageSequence1.structureId;
+  const isMainStageSequence1 = structureId === mainStageSequence1?.structureId;
   const qualifyingStructureIds = structures.filter(({ stage }) => stage === QUALIFYING).map(extractAttributes("structureId"));
   if (isMainStageSequence1 && !qualifyingStructureIds.length) {
     return { error: CANNOT_REMOVE_MAIN_STRUCTURE };
@@ -44221,11 +44283,11 @@ function removeStructure({
   const removedMatchUpIds = [];
   const idsToRemove = [structureId];
   const getTargetedStructureIds = (structureId2) => drawDefinition.links?.map(
-    (link) => link.source.structureId === structureId2 && link.target.structureId !== mainStageSequence1.structureId && link.target.structureId
-  ).filter(Boolean);
+    (link) => link.source.structureId === structureId2 && link.target.structureId !== mainStageSequence1?.structureId && link.target.structureId
+  ).filter(Boolean) ?? [];
   const getQualifyingSourceStructureIds = (structureId2) => drawDefinition.links?.map(
     (link) => qualifyingStructureIds.includes(link.source.structureId) && link.target.structureId === structureId2 && link.source.structureId
-  ).filter(Boolean);
+  ).filter(Boolean) ?? [];
   const isQualifyingStructure = qualifyingStructureIds.includes(structureId);
   const relatedStructureIdsMap = /* @__PURE__ */ new Map();
   structureIds.forEach(
@@ -44236,11 +44298,11 @@ function removeStructure({
   );
   while (idsToRemove.length) {
     const idBeingRemoved = idsToRemove.pop();
-    const { structure } = findStructure({
+    const { structure: structure2 } = findStructure({
       structureId: idBeingRemoved,
       drawDefinition
     });
-    const { matchUps: matchUps2 } = getAllStructureMatchUps({ structure });
+    const { matchUps: matchUps2 } = getAllStructureMatchUps({ structure: structure2 });
     const matchUpIds = getMatchUpIds(matchUps2);
     removedMatchUpIds.push(...matchUpIds);
     drawDefinition.links = drawDefinition.links?.filter(
@@ -44248,10 +44310,10 @@ function removeStructure({
     ) || [];
     if (!isMainStageSequence1 || idBeingRemoved !== structureId) {
       drawDefinition.structures = (drawDefinition.structures ?? []).filter(
-        (structure2) => {
-          if (idBeingRemoved && idBeingRemoved === structure2.structureId)
+        (structure3) => {
+          if (idBeingRemoved && idBeingRemoved === structure3.structureId)
             removedStructureIds.push(idBeingRemoved);
-          return structure2.structureId !== idBeingRemoved;
+          return structure3.structureId !== idBeingRemoved;
         }
       );
     }
@@ -44259,7 +44321,7 @@ function removeStructure({
     relatedStructureIdsMap.get(idBeingRemoved)?.filter(
       (id) => (
         // IMPORTANT: only delete MAIN stageSequence: 1 if specified to protect against DOUBLE_ELIMINATION scenario
-        id !== mainStageSequence1.structureId || structureId === mainStageSequence1.structureId
+        id !== mainStageSequence1?.structureId || structureId === mainStageSequence1.structureId
       )
     );
     if (targetedStructureIds?.length)
@@ -44282,6 +44344,7 @@ function removeStructure({
       mainStageSequence1.extensions = [];
     }
   }
+  isQualifyingStructure && resequenceStructures({ drawDefinition });
   deleteMatchUpsNotice({
     tournamentId: tournamentRecord?.tournamentId,
     matchUpIds: removedMatchUpIds,
@@ -47906,6 +47969,7 @@ function getValidAssignmentActions({
   if (!ignoreSeedPositions) {
     const result = getNextSeedBlock({
       provisionalPositioning,
+      returnAllProxies: true,
       randomize: true,
       drawDefinition,
       structureId,
@@ -48431,6 +48495,7 @@ function positionActions$1(params) {
       action: SEED_VALUE
     }) && isAvailableAction({ policyActions, action: SEED_VALUE }) && isValidSeedPosition({ drawDefinition, structureId, drawPosition }) && validToAssignSeed) {
       const { seedAssignments } = getStructureSeedAssignments({
+        returnAllProxies: true,
         drawDefinition,
         structure
       });
@@ -48457,6 +48522,7 @@ function positionActions$1(params) {
       action: REMOVE_SEED
     }) && isAvailableAction({ policyActions, action: REMOVE_SEED }) && isValidSeedPosition({ drawDefinition, structureId, drawPosition }) && validToAssignSeed) {
       const { seedAssignments } = getStructureSeedAssignments({
+        returnAllProxies: true,
         drawDefinition,
         structure
       });