tods-competition-factory 1.8.46 → 1.9.0

package/dist/index.mjs

@@ -1980,7 +1980,22 @@ function isString(obj) {
   return typeof obj === "string";
 }
 function isObject(obj) {
-  return typeof obj === "object";
+  return obj !== null && typeof obj === "object";
+}
+function objShallowEqual(o1, o2) {
+  if (!isObject(o1) || !isObject(o2))
+    return false;
+  const keys1 = Object.keys(o1);
+  const keys2 = Object.keys(o2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (o1[key] !== o2[key]) {
+      return false;
+    }
+  }
+  return true;
 }
 function createMap(objectArray, attribute) {
   if (!Array.isArray(objectArray))
@@ -2404,7 +2419,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.46";
+  return "1.9.0";
 }
 
 function getObjectTieFormat(obj) {
@@ -2490,34 +2505,6 @@ function decorateResult({
   return result ?? { success: true };
 }
 
-const ANY = "ANY";
-const MALE = "MALE";
-const MIXED = "MIXED";
-const OTHER$3 = "OTHER";
-const FEMALE = "FEMALE";
-const genderConstants = {
-  ANY,
-  MALE,
-  FEMALE,
-  MIXED,
-  OTHER: OTHER$3
-};
-
-const SINGLES_MATCHUP = "SINGLES";
-const SINGLES$1 = "SINGLES";
-const DOUBLES_MATCHUP = "DOUBLES";
-const DOUBLES$1 = "DOUBLES";
-const TEAM_MATCHUP = "TEAM";
-const TEAM$2 = "TEAM";
-const matchUpTypes = {
-  SINGLES_MATCHUP,
-  SINGLES: SINGLES$1,
-  DOUBLES_MATCHUP,
-  DOUBLES: DOUBLES$1,
-  TEAM_MATCHUP,
-  TEAM: TEAM$2
-};
-
 var DrawTypeEnum = /* @__PURE__ */ ((DrawTypeEnum2) => {
   DrawTypeEnum2["AdHoc"] = "AD_HOC";
   DrawTypeEnum2["Compass"] = "COMPASS";
@@ -2632,6 +2619,19 @@ var ParticipantTypeEnum = /* @__PURE__ */ ((ParticipantTypeEnum2) => {
   return ParticipantTypeEnum2;
 })(ParticipantTypeEnum || {});
 
+const ANY = "ANY";
+const MALE = "MALE";
+const MIXED = "MIXED";
+const OTHER$3 = "OTHER";
+const FEMALE = "FEMALE";
+const genderConstants = {
+  ANY,
+  MALE,
+  FEMALE,
+  MIXED,
+  OTHER: OTHER$3
+};
+
 const mixedGenderError = "MIXED events can not contain mixed singles or { gender: ANY } collections";
 const anyMixedError = "events with { gender: ANY } can not contain MIXED singles collections";
 function tieFormatGenderValidityCheck(params) {
@@ -2643,8 +2643,7 @@ function tieFormatGenderValidityCheck(params) {
       context: { gender },
       stack
     });
-  const eventType = params.eventType ?? params.referenceEvent?.eventType;
-  if (referenceGender === MIXED && (eventType !== TEAM$2 || gender === ANY || gender === MIXED && matchUpType !== TypeEnum.Doubles)) {
+  if (referenceGender === MIXED && (gender === ANY || gender === MIXED && matchUpType !== TypeEnum.Doubles)) {
     return decorateResult({
       result: { error: INVALID_GENDER, valid: false },
       info: mixedGenderError,
@@ -2932,7 +2931,6 @@ function validateTieFormat(params) {
       const { valid: valid2, errors: collectionDefinitionErrors } = validateCollectionDefinition({
         referenceCategory: params.category,
         referenceGender: params.gender,
-        eventType: params.eventType,
         collectionDefinition,
         checkCollectionIds,
         checkCategory,
@@ -2984,7 +2982,6 @@ function validateCollectionDefinition({
   checkGender = true,
   referenceCategory,
   referenceGender,
-  eventType,
   event
 }) {
   referenceGender = referenceGender ?? event?.gender;
@@ -3052,7 +3049,6 @@ function validateCollectionDefinition({
   }
   if (checkGender) {
     const result = tieFormatGenderValidityCheck({
-      eventType: eventType ?? event?.eventType,
       referenceGender,
       matchUpType,
       gender
@@ -3085,12 +3081,10 @@ function validateCollectionDefinition({
   return { valid: true };
 }
 function checkTieFormat({
-  tieFormat,
-  eventType
+  tieFormat
 }) {
   const result = validateTieFormat({
     checkCollectionIds: false,
-    eventType,
     tieFormat
   });
   if (result.error)
@@ -3503,6 +3497,21 @@ function calculatePercentages({
   });
 }
 
+const SINGLES_MATCHUP = "SINGLES";
+const SINGLES$1 = "SINGLES";
+const DOUBLES_MATCHUP = "DOUBLES";
+const DOUBLES$1 = "DOUBLES";
+const TEAM_MATCHUP = "TEAM";
+const TEAM$2 = "TEAM";
+const matchUpTypes = {
+  SINGLES_MATCHUP,
+  SINGLES: SINGLES$1,
+  DOUBLES_MATCHUP,
+  DOUBLES: DOUBLES$1,
+  TEAM_MATCHUP,
+  TEAM: TEAM$2
+};
+
 function getParticipantResults({
   participantIds,
   matchUpFormat,
@@ -4314,6 +4323,7 @@ function tallyParticipantResults({
   return result;
 }
 
+const ACTIVE_SUSPENSION = "activeSuspension";
 const APPLIED_POLICIES = "appliedPolicies";
 const AUDIT_POSITION_ACTIONS = "positionActions";
 const CONTEXT = "context";
@@ -4325,6 +4335,7 @@ const DRAW_DELETIONS = "drawDeletions";
 const DRAW_PROFILE = "drawProfile";
 const ENTRY_PROFILE = "entryProfile";
 const EVENT_PROFILE = "eventProfile";
+const EVENT_WITHDRAWAL_REQUESTS = "eventWithdrawalRequests";
 const FACTORY$1 = "factory";
 const FLIGHT_PROFILE = "flightProfile";
 const GROUPING_ATTRIBUTE = "groupingAttribute";
@@ -4343,6 +4354,7 @@ const SUB_ORDER = "subOrder";
 const TALLY = "tally";
 const TIE_FORMAT_MODIFICATIONS = "tieFormatModification";
 const extensionConstants = {
+  ACTIVE_SUSPENSION,
   APPLIED_POLICIES,
   AUDIT_POSITION_ACTIONS,
   CONTEXT,
@@ -4356,6 +4368,7 @@ const extensionConstants = {
   ENTRY_PROFILE,
   // used for drawGeneration; not relevant for anonymized tournaments
   EVENT_PROFILE,
+  EVENT_WITHDRAWAL_REQUESTS,
   FLIGHT_PROFILE,
   GROUPING_ATTRIBUTE,
   // for generating teams; not relevant for anonymized tournaments
@@ -6060,8 +6073,10 @@ function getMatchUpScheduleDetails({
   scheduleVisibilityFilters,
   afterRecoveryTimes,
   tournamentRecord,
+  usePublishState,
   scheduleTiming,
   matchUpFormat,
+  publishStatus,
   matchUpType,
   matchUp,
   event
@@ -6178,15 +6193,36 @@ function getMatchUpScheduleDetails({
     });
   } else {
     schedule = definedAttributes({
-      time,
+      milliseconds,
       startTime,
       endTime,
-      milliseconds
+      time
     });
   }
-  const hasCompletedStatus = matchUp.matchUpStatus && completedMatchUpStatuses.includes(matchUp.matchUpStatus);
   const { scheduledDate } = scheduledMatchUpDate({ matchUp });
   const { scheduledTime } = scheduledMatchUpTime({ matchUp });
+  if (usePublishState && publishStatus?.displaySettings?.draws) {
+    const drawSettings = publishStatus.displaySettings.draws;
+    const scheduleDetails = (drawSettings?.[matchUp.drawId] ?? drawSettings?.default)?.scheduleDetails;
+    if (scheduleDetails) {
+      const scheduleAttributes = (scheduleDetails.find(
+        (details) => scheduledDate && details.dates?.includes(scheduledDate)
+      ) ?? scheduleDetails.find((details) => !details.dates?.length))?.attributes;
+      if (scheduleAttributes) {
+        const template = Object.assign(
+          {},
+          ...Object.keys(schedule).map((key) => ({ [key]: true })),
+          // overwrite with publishStatus attributes
+          scheduleAttributes
+        );
+        schedule = attributeFilter({
+          source: schedule,
+          template
+        });
+      }
+    }
+  }
+  const hasCompletedStatus = matchUp.matchUpStatus && completedMatchUpStatuses.includes(matchUp.matchUpStatus);
   const endDate = hasCompletedStatus && (extractDate(endTime) || extractDate(scheduledDate) || extractDate(scheduledTime)) || void 0;
   return { schedule, endDate };
 }
@@ -8053,6 +8089,7 @@ function getAllStructureMatchUps({
   policyDefinitions,
   tournamentRecord,
   seedAssignments,
+  usePublishState,
   contextFilters,
   contextContent,
   matchUpFilters,
@@ -8060,6 +8097,7 @@ function getAllStructureMatchUps({
   scheduleTiming,
   contextProfile,
   drawDefinition,
+  publishStatus,
   context = {},
   exitProfiles,
   matchUpsMap,
@@ -8168,6 +8206,8 @@ function getAllStructureMatchUps({
         roundNamingProfile,
         initialRoundOfPlay,
         appliedPolicies,
+        usePublishState,
+        publishStatus,
         isRoundRobin,
         roundProfile,
         matchUp,
@@ -8237,6 +8277,8 @@ function getAllStructureMatchUps({
     tieDrawPositions,
     appliedPolicies: appliedPolicies2,
     isCollectionBye,
+    usePublishState: usePublishState2,
+    publishStatus: publishStatus2,
     matchUpTieId,
     isRoundRobin: isRoundRobin2,
     roundProfile: roundProfile2,
@@ -8262,8 +8304,10 @@ function getAllStructureMatchUps({
       scheduleVisibilityFilters: scheduleVisibilityFilters2,
       afterRecoveryTimes,
       tournamentRecord,
+      usePublishState: usePublishState2,
       scheduleTiming,
       matchUpFormat,
+      publishStatus: publishStatus2,
       matchUpType,
       matchUp,
       event: event2
@@ -8386,7 +8430,7 @@ function getAllStructureMatchUps({
       Object.assign(matchUpWithContext, makeDeepCopy({ sides }, true, true));
     }
     if (tournamentParticipants && matchUpWithContext.sides) {
-      const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
+      const participantAttributes = appliedPolicies2?.[POLICY_TYPE_PARTICIPANT];
       const getMappedParticipant = (participantId) => {
         const participant = participantMap?.[participantId]?.participant;
         return participant && attributeFilter({
@@ -8502,6 +8546,8 @@ function getAllStructureMatchUps({
             additionalContext: additionalContext2,
             appliedPolicies: appliedPolicies2,
             isCollectionBye: isCollectionBye2,
+            usePublishState: usePublishState2,
+            publishStatus: publishStatus2,
             matchUpTieId: matchUpTieId2,
             isRoundRobin: isRoundRobin2,
             roundProfile: roundProfile2,
@@ -8756,7 +8802,7 @@ function generateTieMatchUpScore(params) {
   const tieFormat = resolveTieFormat({ matchUp, drawDefinition, structure, event })?.tieFormat || params?.tieFormat;
   if (!tieFormat)
     return { error: MISSING_TIE_FORMAT };
-  const result = validateTieFormat({ tieFormat, eventType: event?.eventType });
+  const result = validateTieFormat({ tieFormat });
   if (result.error)
     return result;
   const collectionDefinitions = tieFormat?.collectionDefinitions || [];
@@ -9878,11 +9924,13 @@ function getStructureMatchUps({
   afterRecoveryTimes,
   policyDefinitions,
   tournamentRecord,
+  usePublishState,
   matchUpFilters,
   contextFilters,
   contextContent,
   participantMap,
   scheduleTiming,
+  publishStatus,
   contextProfile,
   drawDefinition,
   exitProfiles,
@@ -9903,13 +9951,15 @@ function getStructureMatchUps({
     afterRecoveryTimes,
     policyDefinitions,
     tournamentRecord,
-    drawDefinition,
+    usePublishState,
     matchUpFilters,
     contextFilters,
-    contextProfile,
     contextContent,
     participantMap,
     scheduleTiming,
+    publishStatus,
+    contextProfile,
+    drawDefinition,
     exitProfiles,
     matchUpsMap,
     structure,
@@ -10005,12 +10055,14 @@ function getDrawMatchUps(params) {
     afterRecoveryTimes,
     policyDefinitions,
     tournamentRecord,
+    usePublishState,
     contextFilters,
-    contextProfile,
-    drawDefinition,
     matchUpFilters,
     scheduleTiming,
     participantMap,
+    publishStatus,
+    contextProfile,
+    drawDefinition,
     nextMatchUps,
     inContext,
     context,
@@ -10065,9 +10117,11 @@ function getDrawMatchUps(params) {
       afterRecoveryTimes,
       policyDefinitions,
       tournamentRecord,
+      usePublishState,
+      contextContent,
       participantMap,
       scheduleTiming,
-      contextContent,
+      publishStatus,
       contextProfile,
       drawDefinition,
       exitProfiles,
@@ -15617,44 +15671,6 @@ const fixtures = {
   flagIOC
 };
 
-function addNationalityCode({
-  participant,
-  withISO2,
-  withIOC
-}) {
-  const { person, individualParticipants } = participant;
-  const persons = [person, individualParticipants?.map(({ person: person2 }) => person2)].flat().filter(Boolean);
-  function annotatePerson(person2) {
-    const { nationalityCode } = person2 || {};
-    if (nationalityCode) {
-      const country = countries.find(({ iso }) => iso === nationalityCode);
-      if (withIOC && country?.ioc && !person2.iocNationalityCode)
-        person2.iocNationalityCode = country.ioc;
-      if (withISO2 && country?.iso2 && !person2.iso2NationalityCode)
-        person2.iso2NationalityCode = country.iso2;
-      if (country?.label && !person2.countryName)
-        person2.countryName = country.label;
-    }
-  }
-  persons.forEach(annotatePerson);
-}
-
-function addIndividualParticipants({ participantMap, template }) {
-  const participantObjects = Object.values(participantMap);
-  for (const participantObject of participantObjects) {
-    const participant = participantObject.participant;
-    if (participant.individualParticipantIds?.length) {
-      participant.individualParticipants = [];
-      for (const participantId of participant.individualParticipantIds) {
-        const source = participantMap[participantId].participant;
-        participant.individualParticipants.push(
-          template ? attributeFilter({ template, source }) : source
-        );
-      }
-    }
-  }
-}
-
 function getTimeItem({
   returnPreviousValues,
   itemSubTypes,
@@ -15766,6 +15782,52 @@ function getParticipantTimeItem({
   return timeItem && { timeItem, previousItems } || { info };
 }
 
+function getEventPublishStatus({ event, status = PUBLIC }) {
+  const itemType = `${PUBLISH}.${STATUS$1}`;
+  return getEventTimeItem({
+    itemType,
+    event
+  })?.timeItem?.itemValue?.[status];
+}
+
+function addNationalityCode({
+  participant,
+  withISO2,
+  withIOC
+}) {
+  const { person, individualParticipants } = participant;
+  const persons = [person, individualParticipants?.map(({ person: person2 }) => person2)].flat().filter(Boolean);
+  function annotatePerson(person2) {
+    const { nationalityCode } = person2 || {};
+    if (nationalityCode) {
+      const country = countries.find(({ iso }) => iso === nationalityCode);
+      if (withIOC && country?.ioc && !person2.iocNationalityCode)
+        person2.iocNationalityCode = country.ioc;
+      if (withISO2 && country?.iso2 && !person2.iso2NationalityCode)
+        person2.iso2NationalityCode = country.iso2;
+      if (country?.label && !person2.countryName)
+        person2.countryName = country.label;
+    }
+  }
+  persons.forEach(annotatePerson);
+}
+
+function addIndividualParticipants({ participantMap, template }) {
+  const participantObjects = Object.values(participantMap);
+  for (const participantObject of participantObjects) {
+    const participant = participantObject.participant;
+    if (participant.individualParticipantIds?.length) {
+      participant.individualParticipants = [];
+      for (const participantId of participant.individualParticipantIds) {
+        const source = participantMap[participantId].participant;
+        participant.individualParticipants.push(
+          template ? attributeFilter({ template, source }) : source
+        );
+      }
+    }
+  }
+}
+
 const typeMap = {
   [GROUP]: "groupParticipantIds",
   [PAIR]: "pairParticipantIds",
@@ -16206,9 +16268,10 @@ function tournamentMatchUps(params) {
     useParticipantMap,
     tournamentRecord,
     inContext = true,
+    usePublishState,
     contextFilters,
-    contextProfile,
     matchUpFilters,
+    contextProfile,
     nextMatchUps,
     context
   } = params;
@@ -16246,6 +16309,7 @@ function tournamentMatchUps(params) {
       afterRecoveryTimes,
       policyDefinitions,
       tournamentRecord,
+      usePublishState,
       contextFilters,
       contextProfile,
       contextContent,
@@ -16291,9 +16355,10 @@ function eventMatchUps(params) {
     policyDefinitions,
     useParticipantMap,
     tournamentRecord,
+    usePublishState,
     contextFilters,
-    contextProfile,
     matchUpFilters,
+    contextProfile,
     nextMatchUps,
     tournamentId,
     inContext,
@@ -16336,6 +16401,7 @@ function eventMatchUps(params) {
       contextProfile,
       event
     });
+  const publishStatus = getEventPublishStatus({ event });
   const drawDefinitions = event.drawDefinitions ?? [];
   const eventResult = drawDefinitions.reduce((results, drawDefinition) => {
     const drawMatchUpsResult = getDrawMatchUps({
@@ -16347,12 +16413,14 @@ function eventMatchUps(params) {
       afterRecoveryTimes,
       policyDefinitions,
       tournamentRecord,
-      drawDefinition,
+      usePublishState,
       contextContent,
       contextFilters,
-      contextProfile,
       matchUpFilters,
       participantMap,
+      publishStatus,
+      contextProfile,
+      drawDefinition,
       nextMatchUps,
       inContext,
       event
@@ -16378,12 +16446,14 @@ function drawMatchUps$1({
   policyDefinitions,
   useParticipantMap,
   tournamentRecord,
+  usePublishState,
   contextFilters,
-  contextProfile,
   contextContent,
-  drawDefinition,
   matchUpFilters,
   participantMap,
+  publishStatus,
+  contextProfile,
+  drawDefinition,
   nextMatchUps,
   tournamentId,
   inContext,
@@ -16434,12 +16504,14 @@ function drawMatchUps$1({
     afterRecoveryTimes,
     policyDefinitions,
     tournamentRecord,
+    usePublishState,
     participantMap,
-    drawDefinition,
-    matchUpFilters,
+    contextContent,
     contextFilters,
+    matchUpFilters,
+    publishStatus,
     contextProfile,
-    contextContent,
+    drawDefinition,
     nextMatchUps,
     inContext,
     event
@@ -17145,6 +17217,7 @@ function competitionMatchUps({
   participantsProfile,
   tournamentRecords,
   policyDefinitions,
+  usePublishState,
   matchUpFilters,
   contextFilters,
   nextMatchUps,
@@ -17160,6 +17233,7 @@ function competitionMatchUps({
       participantsProfile,
       policyDefinitions,
       tournamentRecord,
+      usePublishState,
       matchUpFilters,
       contextFilters,
       nextMatchUps,
@@ -22552,6 +22626,11 @@ function getMatchUpDailyLimits({
   return { matchUpDailyLimits: dailyLimits };
 }
 
+function getDrawPublishStatus({ drawDetails, drawId }) {
+  const details = drawDetails?.[drawId]?.publishingDetail;
+  return details?.published;
+}
+
 function scheduledSortedMatchUps({
   schedulingProfile,
   matchUps = []
@@ -22676,11 +22755,10 @@ function competitionScheduleMatchUps(params) {
     status = PUBLIC,
     sortCourtsData
   } = params;
-  const timeItem = usePublishState ? getTournamentTimeItem({
+  const tournamentPublishStatus = usePublishState ? getTournamentTimeItem({
     tournamentRecord: tournamentRecords[activeTournamentId ?? getTournamentId()],
     itemType: `${PUBLISH}.${STATUS$1}`
-  }).timeItem : void 0;
-  const publishStatus = timeItem?.itemValue?.[status];
+  }).timeItem?.itemValue?.[status] : void 0;
   const allCompletedMatchUps = alwaysReturnCompleted ? competitionMatchUps({
     ...params,
     matchUpFilters: {
@@ -22689,7 +22767,7 @@ function competitionScheduleMatchUps(params) {
     },
     contextFilters: params.contextFilters
   }).completedMatchUps : [];
-  if (usePublishState && (!publishStatus || !Object.keys(publishStatus).length)) {
+  if (usePublishState && (!tournamentPublishStatus || !Object.keys(tournamentPublishStatus).length)) {
     return {
       completedMatchUps: allCompletedMatchUps,
       dateMatchUps: [],
@@ -22697,7 +22775,12 @@ function competitionScheduleMatchUps(params) {
       venues
     };
   }
-  const publishedDrawIds = usePublishState ? getCompetitionPublishedDrawIds({ tournamentRecords }).drawIds : void 0;
+  let publishedDrawIds, detailsMap;
+  if (usePublishState) {
+    ({ drawIds: publishedDrawIds, detailsMap } = getCompetitionPublishedDrawDetails({
+      tournamentRecords
+    }));
+  }
   if (publishedDrawIds?.length) {
     if (!params.contextFilters)
       params.contextFilters = {};
@@ -22709,34 +22792,34 @@ function competitionScheduleMatchUps(params) {
       );
     }
   }
-  if (publishStatus?.eventIds?.length) {
+  if (tournamentPublishStatus?.eventIds?.length) {
     if (!params.matchUpFilters)
       params.matchUpFilters = {};
     if (params.matchUpFilters?.eventIds) {
       if (!params.matchUpFilters.eventIds.length) {
-        params.matchUpFilters.eventIds = publishStatus.eventIds;
+        params.matchUpFilters.eventIds = tournamentPublishStatus.eventIds;
       } else {
         params.matchUpFilters.eventIds = params.matchUpFilters.eventIds.filter(
-          (eventId) => publishStatus.eventIds.includes(eventId)
+          (eventId) => tournamentPublishStatus.eventIds.includes(eventId)
         );
       }
     } else {
-      params.matchUpFilters.eventIds = publishStatus.eventIds;
+      params.matchUpFilters.eventIds = tournamentPublishStatus.eventIds;
     }
   }
-  if (publishStatus?.scheduledDates?.length) {
+  if (tournamentPublishStatus?.scheduledDates?.length) {
     if (!params.matchUpFilters)
       params.matchUpFilters = {};
     if (params.matchUpFilters.scheduledDates) {
       if (!params.matchUpFilters.scheduledDates.length) {
-        params.matchUpFilters.scheduledDates = publishStatus.scheduledDates;
+        params.matchUpFilters.scheduledDates = tournamentPublishStatus.scheduledDates;
       } else {
         params.matchUpFilters.scheduledDates = params.matchUpFilters.scheduledDates.filter(
-          (scheduledDate) => publishStatus.scheduledDates.includes(scheduledDate)
+          (scheduledDate) => tournamentPublishStatus.scheduledDates.includes(scheduledDate)
         );
       }
     } else {
-      params.matchUpFilters.scheduledDates = publishStatus.scheduledDates;
+      params.matchUpFilters.scheduledDates = tournamentPublishStatus.scheduledDates;
     }
   }
   if (alwaysReturnCompleted) {
@@ -22755,10 +22838,48 @@ function competitionScheduleMatchUps(params) {
     matchUpFilters: params.matchUpFilters,
     contextFilters: params.contextFilters
   });
-  const relevantMatchUps = [
+  let relevantMatchUps = [
     ...upcomingMatchUps ?? [],
     ...pendingMatchUps ?? []
   ];
+  if (detailsMap && Object.keys(detailsMap).length) {
+    relevantMatchUps = relevantMatchUps.filter((matchUp) => {
+      const { drawId, structureId, stage } = matchUp;
+      if (!detailsMap[drawId])
+        return false;
+      if (detailsMap[drawId].stageDetails) {
+        const stageKeys = Object.keys(detailsMap[drawId].stageDetails);
+        const unpublishedStages = stageKeys.filter(
+          (stage2) => !detailsMap[drawId].stageDetails[stage2].published
+        );
+        const publishedStages = stageKeys.filter(
+          (stage2) => detailsMap[drawId].stageDetails[stage2].published
+        );
+        if (unpublishedStages.length && unpublishedStages.includes(stage))
+          return false;
+        if (publishedStages.length && publishedStages.includes(stage))
+          return true;
+        return unpublishedStages.length && !unpublishedStages.includes(stage) && !publishedStages.length;
+      }
+      if (detailsMap[drawId].structureDetails) {
+        const structureIdKeys = Object.keys(
+          detailsMap[drawId].structureDetails
+        );
+        const unpublishedStructureIds = structureIdKeys.filter(
+          (structureId2) => !detailsMap[drawId].structureDetails[structureId2].published
+        );
+        const publishedStructureIds = structureIdKeys.filter(
+          (structureId2) => detailsMap[drawId].structureDetails[structureId2].published
+        );
+        if (unpublishedStructureIds.length && unpublishedStructureIds.includes(structureId))
+          return false;
+        if (publishedStructureIds.length && publishedStructureIds.includes(structureId))
+          return true;
+        return unpublishedStructureIds.length && !unpublishedStructureIds.includes(structureId) && !publishedStructureIds.length;
+      }
+      return true;
+    });
+  }
   const dateMatchUps = sortDateMatchUps ? scheduledSortedMatchUps({ matchUps: relevantMatchUps, schedulingProfile }) : relevantMatchUps;
   const courtsData = courts?.map((court) => {
     const matchUps = getCourtMatchUps(court);
@@ -22769,11 +22890,11 @@ function competitionScheduleMatchUps(params) {
     };
   });
   const result = {
-    courtsData,
     completedMatchUps: alwaysReturnCompleted ? allCompletedMatchUps : completedMatchUps,
     // completed matchUps for the filter date
     dateMatchUps,
     // all incomplete matchUps for the filter date
+    courtsData,
     groupInfo,
     venues
   };
@@ -22797,26 +22918,28 @@ function competitionScheduleMatchUps(params) {
     }) : courtMatchUps;
   }
 }
-function getCompetitionPublishedDrawIds({
+function getCompetitionPublishedDrawDetails({
   tournamentRecords
 }) {
   const drawIds = [];
+  const detailsMap = {};
   for (const tournamentRecord of Object.values(tournamentRecords)) {
     for (const event of tournamentRecord.events ?? []) {
-      const { timeItem } = getEventTimeItem({
-        itemType: `${PUBLISH}.${STATUS$1}`,
-        event
-      });
-      const pubState = timeItem?.itemValue?.[PUBLIC];
-      if (pubState?.drawIds?.length) {
-        drawIds.push(...pubState.drawIds);
-      } else {
-        const eventDrawIds = (event.drawDefinitions ?? []).map(({ drawId }) => drawId).filter(Boolean);
-        drawIds.push(...eventDrawIds);
+      const eventPubStatus = getEventPublishStatus({ event });
+      const drawDetails = eventPubStatus?.drawDetails;
+      if (isObject(drawDetails)) {
+        Object.assign(detailsMap, drawDetails);
+        drawIds.push(
+          ...Object.keys(drawDetails).filter(
+            (drawId) => getDrawPublishStatus({ drawId, drawDetails })
+          )
+        );
+      } else if (eventPubStatus?.drawIds?.length) {
+        drawIds.push(...eventPubStatus.drawIds);
       }
     }
   }
-  return { drawIds };
+  return { drawIds, detailsMap };
 }
 
 const { stageOrder } = drawDefinitionConstants;
@@ -23135,13 +23258,8 @@ function getEventEntries({ eventEntryStatuses, tournamentEvents }) {
 }
 
 function getEventPublishStatuses({ event }) {
-  const itemType = `${PUBLISH}.${STATUS$1}`;
-  const { timeItem } = getTimeItem({
-    element: event,
-    itemType
-  });
-  if (timeItem?.itemValue?.PUBLIC) {
-    const { drawIds: publishedDrawIds = [], seeding } = timeItem.itemValue.PUBLIC || {};
+  const eventPubStatus = getEventPublishStatus({ event });
+  if (eventPubStatus) {
     const publishedSeeding = {
       published: void 0,
       // seeding can be present for all entries in an event when no flights have been defined
@@ -23149,9 +23267,13 @@ function getEventPublishStatuses({ event }) {
       drawIds: []
       // seeding can be specific to drawIds
     };
-    if (seeding) {
-      Object.assign(publishedSeeding, timeItem.itemValue.PUBLIC.seeding);
+    if (eventPubStatus.seeding) {
+      Object.assign(publishedSeeding, eventPubStatus.seeding);
     }
+    const { drawDetails, drawIds } = eventPubStatus;
+    const publishedDrawIds = drawDetails && Object.keys(drawDetails).filter(
+      (drawId) => getDrawPublishStatus({ drawDetails, drawId })
+    ) || drawIds || [];
     return {
       publishedDrawIds,
       publishedSeeding
@@ -24108,7 +24230,7 @@ function getParticipantEntries(params) {
             const itemIsPrior = consideredMinutes >= scheduledMinutes;
             const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : itemIsPrior && timeStringMinutes(consideredItem.scheduledTime) < timeStringMinutes(notBeforeTime);
             if (timeOverlap && !(bothPotential && sameDraw) && itemIsPrior) {
-              const key = [scheduleItem.matchUpId, consideredItem.matchUpId].sort().join("|");
+              const key = [scheduleItem.matchUpId, consideredItem.matchUpId].sort(stringSort).join("|");
               participantAggregator.scheduleConflicts[key] = {
                 priorScheduledMatchUpId: scheduleItem.matchUpId,
                 matchUpIdWithConflict: consideredItem.matchUpId
@@ -26074,7 +26196,9 @@ function getDrawData(params) {
     policyDefinitions,
     tournamentRecord,
     inContext = true,
+    usePublishState,
     drawDefinition,
+    publishStatus,
     noDeepCopy,
     sortConfig,
     context,
@@ -26146,6 +26270,8 @@ function getDrawData(params) {
         tournamentParticipants,
         policyDefinitions,
         tournamentRecord,
+        usePublishState,
+        publishStatus,
         drawDefinition,
         inContext,
         structure,
@@ -26259,11 +26385,7 @@ function getEventData(params) {
     return { error: MISSING_EVENT };
   const { eventId } = event;
   const { tournamentId, endDate } = tournamentRecord;
-  const { timeItem } = getEventTimeItem({
-    itemType: `${PUBLISH}.${STATUS$1}`,
-    event
-  });
-  const publishStatus = timeItem?.itemValue?.[status];
+  const publishStatus = getEventPublishStatus({ event, status });
   const { participants: tournamentParticipants } = getParticipants$1({
     withGroupings: true,
     withEvents: false,
@@ -26272,9 +26394,51 @@ function getEventData(params) {
     // order is important!!
     tournamentRecord
   });
-  const stageFilter = ({ stage }) => !usePublishState || !publishStatus?.stages?.length || publishStatus.stages.includes(stage);
-  const structureFilter = ({ structureId }) => !usePublishState || !publishStatus?.structureIds?.length || publishStatus.structureIds.includes(structureId);
-  const drawFilter = ({ drawId }) => !usePublishState || !publishStatus?.drawIds?.length || publishStatus.drawIds.includes(drawId);
+  const stageFilter = ({ stage, drawId }) => {
+    if (!usePublishState)
+      return true;
+    const stageDetails = publishStatus?.drawDetails?.[drawId]?.stageDetails;
+    if (!stageDetails || !Object.keys(stageDetails).length)
+      return true;
+    return stageDetails[stage]?.published;
+  };
+  const structureFilter = ({ structureId, drawId }) => {
+    if (!usePublishState)
+      return true;
+    const structureDetails = publishStatus?.drawDetails?.[drawId]?.structureDetails;
+    if (!structureDetails || !Object.keys(structureDetails).length)
+      return true;
+    return structureDetails[structureId]?.published;
+  };
+  const drawFilter = ({ drawId }) => {
+    if (!usePublishState)
+      return true;
+    if (publishStatus.drawDetails) {
+      return publishStatus.drawDetails[drawId]?.publishingDetail?.published;
+    } else if (publishStatus.drawIds) {
+      return publishStatus.drawIds.includes(drawId);
+    }
+    return true;
+  };
+  const roundLimitMapper = ({ drawId, structure }) => {
+    if (!usePublishState)
+      return structure;
+    const roundLimit = publishStatus?.drawDetails?.[drawId]?.structureDetails?.[structure.structureId]?.roundLimit;
+    if (isConvertableInteger(roundLimit)) {
+      const roundNumbers = generateRange(1, roundLimit + 1);
+      const roundMatchUps = {};
+      const roundProfile = {};
+      for (const roundNumber of roundNumbers) {
+        if (structure.roundMatchUps[roundNumber]) {
+          roundMatchUps[roundNumber] = structure.roundMatchUps[roundNumber];
+          roundProfile[roundNumber] = structure.roundProfile[roundNumber];
+        }
+      }
+      structure.roundMatchUps = roundMatchUps;
+      structure.roundProfile = roundProfile;
+    }
+    return structure;
+  };
   const drawDefinitions = event.drawDefinitions || [];
   const drawsData = drawDefinitions.filter(drawFilter).map(
     (drawDefinition) => (({ drawInfo, structures }) => ({
@@ -26288,15 +26452,24 @@ function getEventData(params) {
         noDeepCopy: true,
         policyDefinitions,
         tournamentRecord,
+        usePublishState,
         drawDefinition,
+        publishStatus,
         sortConfig,
         event
       })
     )
-  ).map(({ structures, ...drawData }) => ({
-    ...drawData,
-    structures: structures?.filter(structureFilter)?.filter(stageFilter)
-  })).filter((drawData) => drawData.structures?.length);
+  ).map(({ structures, ...drawData }) => {
+    const filteredStructures = structures?.filter(
+      ({ stage, structureId }) => structureFilter({ structureId, drawId: drawData.drawId }) && stageFilter({ stage, drawId: drawData.drawId })
+    ).map(
+      (structure) => roundLimitMapper({ drawId: drawData.drawId, structure })
+    );
+    return {
+      ...drawData,
+      structures: filteredStructures
+    };
+  }).filter((drawData) => drawData.structures?.length);
   const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
   const venues = tournamentRecord.venues || [];
   const venuesData = venues.map(
@@ -26342,10 +26515,7 @@ function getEventData(params) {
     eventInfo,
     drawsData
   };
-  eventData.eventInfo.publish = {
-    createdAt: timeItem?.createdAt,
-    state: timeItem?.itemValue
-  };
+  eventData.eventInfo.publish = publishStatus;
   return { ...SUCCESS, eventData };
 }
 
@@ -33348,10 +33518,7 @@ function modifyCollectionDefinition$1({
     modifications.push({ collectionId, gender });
   }
   const modifiedTieFormat = definedAttributes(tieFormat);
-  result = validateTieFormat({
-    tieFormat: modifiedTieFormat,
-    eventType: event?.eventType
-  });
+  result = validateTieFormat({ tieFormat: modifiedTieFormat });
   if (result.error) {
     return decorateResult({ result, stack });
   }
@@ -33622,8 +33789,7 @@ function removeCollectionDefinition$1({
   matchUp = matchUp ?? result?.matchUp;
   const existingTieFormat = result?.tieFormat;
   const tieFormat = copyTieFormat(existingTieFormat);
-  const eventType = event?.eventType;
-  result = validateTieFormat({ tieFormat, eventType });
+  result = validateTieFormat({ tieFormat });
   if (result.error)
     return decorateResult({ result, stack });
   const targetCollection = tieFormat?.collectionDefinitions?.find(
@@ -33760,7 +33926,7 @@ function removeCollectionDefinition$1({
     });
   }
   const prunedTieFormat = definedAttributes(tieFormat);
-  result = validateTieFormat({ tieFormat: prunedTieFormat, eventType });
+  result = validateTieFormat({ tieFormat: prunedTieFormat });
   if (result.error)
     return decorateResult({ result, stack });
   if (eventId && event) {
@@ -33852,8 +34018,7 @@ function addCollectionDefinition$1({
   matchUp = matchUp ?? result?.matchUp;
   const existingTieFormat = matchUp?.tieFormat ?? result?.tieFormat;
   const tieFormat = copyTieFormat(existingTieFormat);
-  const eventType = event?.eventType;
-  result = validateTieFormat({ tieFormat, eventType });
+  result = validateTieFormat({ tieFormat });
   if (result?.error) {
     return decorateResult({ result: { error: result.error }, stack });
   }
@@ -33888,7 +34053,7 @@ function addCollectionDefinition$1({
   const addedMatchUps = [];
   let targetMatchUps = [];
   const prunedTieFormat = definedAttributes(tieFormat);
-  result = validateTieFormat({ tieFormat: prunedTieFormat, eventType });
+  result = validateTieFormat({ tieFormat: prunedTieFormat });
   if (result?.error) {
     return decorateResult({ result: { error: result.error }, stack });
   }
@@ -34176,10 +34341,7 @@ function collectionGroupUpdate({
     event
   });
   const prunedTieFormat = definedAttributes(tieFormat);
-  const result = validateTieFormat({
-    eventType: event?.eventType,
-    tieFormat: prunedTieFormat
-  });
+  const result = validateTieFormat({ tieFormat: prunedTieFormat });
   if (result.error)
     return result;
   if (eventId && event) {
@@ -34229,7 +34391,7 @@ function removeCollectionGroup$1({
   const originalValueGoal = existingTieFormat?.winCriteria.valueGoal;
   const wasAggregateValue = existingTieFormat?.winCriteria.aggregateValue;
   const tieFormat = copyTieFormat(existingTieFormat);
-  result = validateTieFormat({ tieFormat, eventType: event?.eventType });
+  result = validateTieFormat({ tieFormat });
   if (result.error)
     return decorateResult({ result, stack });
   const modifiedCollectionIds = [];
@@ -34316,7 +34478,7 @@ function addCollectionGroup$1({
   const existingTieFormat = result?.tieFormat;
   const originalValueGoal = existingTieFormat?.winCriteria.valueGoal;
   const tieFormat = copyTieFormat(existingTieFormat);
-  result = validateTieFormat({ tieFormat, eventType: event.eventType });
+  result = validateTieFormat({ tieFormat });
   if (result.error)
     return decorateResult({ result, stack });
   for (const collectionDefinition of tieFormat.collectionDefinitions) {
@@ -34380,10 +34542,7 @@ function modifyTieFormat$1({
   event
 }) {
   const stack = "modifyTieFormat";
-  if (!validateTieFormat({
-    tieFormat: modifiedTieFormat,
-    eventType: event?.eventType
-  }).valid) {
+  if (!validateTieFormat({ tieFormat: modifiedTieFormat }).valid) {
     return decorateResult({
       result: { error: INVALID_TIE_FORMAT },
       info: "falied validation",
@@ -42945,8 +43104,7 @@ function generateDrawTypeAndModifyDrawDefinition$1(params) {
   const drawDefinition = modifyOriginal ? params.drawDefinition : makeDeepCopy(params.drawDefinition, false, true);
   let { tieFormat, matchUpType } = params;
   if (tieFormat) {
-    const eventType = params.event?.eventType;
-    const result2 = validateTieFormat({ tieFormat, eventType });
+    const result2 = validateTieFormat({ tieFormat });
     if (result2.error)
       return result2;
   }
@@ -45413,8 +45571,7 @@ function generateVoluntaryConsolation$1(params) {
     return { error: INVALID_DRAW_SIZE };
   let { tieFormat, matchUpType } = params;
   if (tieFormat) {
-    const eventType = params.event?.eventType;
-    const result2 = validateTieFormat({ tieFormat, eventType });
+    const result2 = validateTieFormat({ tieFormat });
     if (result2.error)
       return result2;
   }
@@ -51416,13 +51573,12 @@ function addParticipantContext(params) {
         (extensionKey) => eventInfo[extensionKey] = event[extensionKey]
       );
       const eventEntries = event.entries || [];
-      const itemType = `${PUBLISH}.${STATUS$1}`;
-      const { timeItem } = getEventTimeItem({
-        itemType,
-        event
-      });
-      if (timeItem?.itemValue?.PUBLIC) {
-        const { drawIds: publishedDrawIds = [], seeding } = timeItem.itemValue.PUBLIC || {};
+      const pubStatus = getEventPublishStatus({ event });
+      if (isObject(pubStatus)) {
+        const { drawIds, drawDetails: drawDetails2, seeding } = pubStatus;
+        const publishedDrawIds = drawDetails2 ? Object.keys(drawDetails2).filter(
+          (drawId) => getDrawPublishStatus({ drawId, drawDetails: drawDetails2 })
+        ) : drawIds ?? [];
         const publishedSeeding = {
           published: void 0,
           // seeding can be present for all entries in an event when no flights have been defined
@@ -51431,7 +51587,7 @@ function addParticipantContext(params) {
           // seeding can be specific to drawIds
         };
         if (seeding)
-          Object.assign(publishedSeeding, timeItem.itemValue.PUBLIC.seeding);
+          Object.assign(publishedSeeding, pubStatus.seeding);
         eventsPublishStatuses[eventId] = {
           publishedDrawIds,
           publishedSeeding
@@ -53116,6 +53272,27 @@ const participantGovernor = {
   getParticipants: getParticipants$1
 };
 
+function modifyEventPublishStatus({
+  removePriorValues = true,
+  status = PUBLIC,
+  statusObject,
+  event
+}) {
+  if (!isObject(statusObject))
+    return { error: INVALID_VALUES };
+  const publishStatus = getEventPublishStatus({ event, status });
+  const itemType = `${PUBLISH}.${STATUS$1}`;
+  const updatedTimeItem = {
+    itemValue: { [status]: { ...publishStatus, ...statusObject } },
+    itemType
+  };
+  return addEventTimeItem({
+    timeItem: updatedTimeItem,
+    removePriorValues,
+    event
+  });
+}
+
 function publishEventSeeding({
   removePriorValues = true,
   stageSeedingScaleNames,
@@ -53129,31 +53306,27 @@ function publishEventSeeding({
     return { error: MISSING_TOURNAMENT_RECORD };
   if (!event)
     return { error: MISSING_EVENT };
-  const itemType = `${PUBLISH}.${STATUS$1}`;
-  const { timeItem } = getEventTimeItem({
-    itemType,
-    event
-  });
-  const itemValue = timeItem?.itemValue || { [status]: {} };
-  const updatedSeedingScaleNames = (itemValue[status].seeding?.seedingScaleNames || seedingScaleNames) && {
-    ...itemValue[status].seeding?.seedingScaleNames,
+  const eventPubStatus = getEventPublishStatus({ event, status });
+  const updatedSeedingScaleNames = (eventPubStatus?.seeding?.seedingScaleNames || seedingScaleNames) && {
+    ...eventPubStatus?.seeding?.seedingScaleNames,
     ...seedingScaleNames
   };
-  const updatedStageSeedingScaleNames = (itemValue[status].seeding?.stageSeedingScaleNames || stageSeedingScaleNames) && {
-    ...itemValue[status].seeding?.stageSeedingScaleNames,
+  const updatedStageSeedingScaleNames = (eventPubStatus?.seeding?.stageSeedingScaleNames || stageSeedingScaleNames) && {
+    ...eventPubStatus?.seeding?.stageSeedingScaleNames,
     ...stageSeedingScaleNames
   };
-  itemValue[status].seeding = definedAttributes({
+  const seeding = definedAttributes({
     stageSeedingScaleNames: updatedStageSeedingScaleNames,
     seedingScaleNames: updatedSeedingScaleNames,
     published: true,
     drawIds
   });
-  const updatedTimeItem = {
-    itemValue,
-    itemType
-  };
-  addEventTimeItem({ event, timeItem: updatedTimeItem, removePriorValues });
+  modifyEventPublishStatus({
+    statusObject: { seeding },
+    removePriorValues,
+    status,
+    event
+  });
   addNotice({
     topic: PUBLISH_EVENT_SEEDING,
     payload: {
@@ -53169,6 +53342,7 @@ function unPublishEventSeeding({
   seedingScaleNames,
   tournamentRecord,
   status = PUBLIC,
+  drawIds,
   stages,
   event
 }) {
@@ -53176,34 +53350,39 @@ function unPublishEventSeeding({
     return { error: MISSING_TOURNAMENT_RECORD };
   if (!event)
     return { error: MISSING_EVENT };
-  const itemType = `${PUBLISH}.${STATUS$1}`;
-  const { timeItem } = getEventTimeItem({
-    itemType,
-    event
-  });
-  const itemValue = timeItem?.itemValue || { [status]: {} };
-  if (itemValue[status]) {
-    if (Array.isArray(stages) && itemValue[status].seeding?.stageSeedingScaleNames) {
+  const eventPubStatus = getEventPublishStatus({ event });
+  if (eventPubStatus) {
+    const seeding = eventPubStatus.seeding;
+    if (Array.isArray(stages) && seeding.stageSeedingScaleNames) {
       for (const stage of stages) {
-        if (itemValue[status].seeding.stageSeedingScaleNames[stage]) {
-          delete itemValue[status].seeding.stageSeedingScaleNames[stage];
+        if (seeding.stageSeedingScaleNames[stage]) {
+          delete seeding.stageSeedingScaleNames[stage];
         }
       }
     }
-    if (Array.isArray(seedingScaleNames) && itemValue[status].seeding?.seedingScaleNames) {
-      itemValue[status].seeding.seedingScaleNames = itemValue[status].seeding.seedingScaleNames.filter(
+    if (Array.isArray(seedingScaleNames) && seeding?.seedingScaleNames) {
+      seeding.seedingScaleNames = seeding.seedingScaleNames.filter(
         (scaleName) => !seedingScaleNames.includes(scaleName)
       );
     }
-    if (!stages && !seedingScaleNames) {
-      delete itemValue[status].seeding;
+    if (Array.isArray(drawIds) && seeding?.drawIds) {
+      seeding.drawIds = seeding.drawIds.filter(
+        (drawId) => !drawIds.includes(drawId)
+      );
+    }
+    if (!Object.values(seeding.stageSeedingScaleNames ?? {}).length && !seeding.seedingScaleNames?.length && !seeding.drawIds?.length || !stages && !seedingScaleNames && !drawIds?.length) {
+      delete seeding.stageSeedingScaleNames;
+      delete seeding.seedingScaleNames;
+      delete seeding.drawIds;
+      seeding.published = false;
     }
+    modifyEventPublishStatus({
+      statusObject: { seeding },
+      removePriorValues,
+      status,
+      event
+    });
   }
-  const updatedTimeItem = {
-    itemValue,
-    itemType
-  };
-  addEventTimeItem({ event, timeItem: updatedTimeItem, removePriorValues });
   addNotice({
     topic: UNPUBLISH_EVENT_SEEDING,
     payload: {
@@ -53289,13 +53468,10 @@ function getAllEventData({ tournamentRecord, policyDefinitions }) {
         }
       };
     });
-    const { timeItem } = getEventTimeItem({
-      itemType: `${PUBLISH}.${STATUS$1}`,
-      event
-    });
+    const publish = getEventPublishStatus({ event });
     Object.assign(eventInfo, {
-      publish: timeItem?.itemValue,
-      drawsData
+      drawsData,
+      publish
     });
     return eventInfo;
   });
@@ -53303,6 +53479,49 @@ function getAllEventData({ tournamentRecord, policyDefinitions }) {
   return { allEventData };
 }
 
+function setEventDisplay({
+  removePriorValues,
+  tournamentRecord,
+  displaySettings,
+  status = PUBLIC,
+  event
+}) {
+  if (!tournamentRecord)
+    return decorateResult({ result: { error: MISSING_TOURNAMENT_RECORD } });
+  if (!event)
+    return decorateResult({ result: { error: MISSING_EVENT } });
+  if (!isObject(displaySettings))
+    return decorateResult({ result: { error: MISSING_VALUE } });
+  if (isObject(displaySettings.draws)) {
+    for (const key of Object.keys(displaySettings.draws)) {
+      const details = displaySettings.draws[key].scheduleDetails ?? [];
+      if (details.length) {
+        const scheduleDetails = [];
+        for (const detail of details) {
+          const existingDetail = scheduleDetails.find(
+            (sd) => objShallowEqual(sd.attributes, detail.attributes)
+          );
+          if (existingDetail?.dates && detail.dates) {
+            existingDetail.dates.push(...detail.dates);
+          } else {
+            scheduleDetails.push(detail);
+          }
+        }
+        displaySettings.draws[key].scheduleDetails = scheduleDetails;
+      }
+    }
+  }
+  const result = modifyEventPublishStatus({
+    statusObject: { displaySettings },
+    removePriorValues,
+    status,
+    event
+  });
+  if (result.error)
+    return result;
+  return { ...SUCCESS };
+}
+
 function unPublishEvent({
   removePriorValues = true,
   tournamentRecord,
@@ -53320,9 +53539,20 @@ function unPublishEvent({
   });
   const itemValue = timeItem?.itemValue || { [status]: {} };
   delete itemValue[status].structureIds;
+  delete itemValue[status].drawDetails;
   delete itemValue[status].drawIds;
   const updatedTimeItem = { itemValue, itemType };
   addEventTimeItem({ event, timeItem: updatedTimeItem, removePriorValues });
+  modifyEventPublishStatus({
+    statusObject: {
+      structureIds: void 0,
+      drawIds: void 0,
+      seeding: void 0
+    },
+    removePriorValues,
+    status,
+    event
+  });
   addNotice({
     topic: UNPUBLISH_EVENT,
     payload: {
@@ -53334,7 +53564,6 @@ function unPublishEvent({
 }
 
 function publishEvent(params) {
-  let { policyDefinitions, drawIds, structureIds, stages } = params;
   const {
     includePositionAssignments,
     removePriorValues,
@@ -53342,67 +53571,128 @@ function publishEvent(params) {
     status = PUBLIC,
     event,
     drawIdsToRemove,
-    drawIdsToAdd,
-    stagesToRemove,
-    stagesToAdd,
-    structureIdsToRemove,
-    structureIdsToAdd
+    drawIdsToAdd
   } = params;
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
   if (!event)
     return { error: MISSING_EVENT };
-  if (!policyDefinitions) {
-    const { appliedPolicies } = getAppliedPolicies({ tournamentRecord, event });
-    policyDefinitions = appliedPolicies;
-  }
-  const itemType = `${PUBLISH}.${STATUS$1}`;
+  const { appliedPolicies } = getAppliedPolicies({ tournamentRecord, event });
+  const policyDefinitions = {
+    ...appliedPolicies,
+    ...params.policyDefinitions
+  };
   const eventDrawIds = event.drawDefinitions?.map(({ drawId }) => drawId) ?? [];
-  const { timeItem } = getEventTimeItem({
-    itemType,
-    event
-  });
-  if (!drawIds && !drawIdsToAdd && !drawIdsToRemove) {
-    drawIds = eventDrawIds;
-  } else if (!drawIds && (drawIdsToAdd?.length || drawIdsToRemove?.length)) {
-    drawIds = timeItem?.itemValue?.PUBLIC?.drawIds || [];
-  }
-  drawIds = (drawIds ?? []).filter(
-    (drawId) => !drawIdsToRemove?.length || !drawIdsToRemove.includes(drawId)
+  const keyedDrawIds = params.drawDetails ? Object.keys(params.drawDetails) : [];
+  const specifiedDrawIds = keyedDrawIds.length ? [] : params.drawIds;
+  const drawIdsToValidate = (drawIdsToAdd ?? []).concat(
+    ...drawIdsToRemove ?? [],
+    ...specifiedDrawIds ?? [],
+    ...keyedDrawIds
   );
-  if (drawIdsToAdd?.length) {
-    drawIds = unique(
-      drawIds.concat(
-        ...drawIdsToAdd.filter((drawId) => eventDrawIds.includes(drawId))
-      )
-    );
-  }
-  if (!structureIds && (structureIdsToAdd?.length || structureIdsToRemove?.length)) {
-    structureIds = timeItem?.itemValue?.PUBLIC?.structureIds || [];
-  }
-  structureIds = (structureIds ?? []).filter(
-    (structureId) => !structureIdsToRemove?.length || !structureIdsToRemove.includes(structureId)
+  const invalidDrawIds = drawIdsToValidate.filter(
+    (drawId) => !eventDrawIds.includes(drawId)
   );
-  if (structureIdsToAdd?.length) {
-    structureIds = unique(structureIds.concat(...structureIdsToAdd));
-  }
-  if (!stages && (stagesToAdd?.length || stagesToRemove?.length)) {
-    stages = timeItem?.itemValue?.PUBLIC?.stages || [];
+  if (invalidDrawIds.length) {
+    return decorateResult({
+      result: { error: DRAW_DEFINITION_NOT_FOUND },
+      context: { invalidDrawIds }
+    });
   }
-  stages = (stages ?? []).filter(
-    (stage) => !stagesToRemove?.length || !stagesToRemove.includes(stage)
-  );
-  if (stagesToAdd?.length) {
-    stages = unique(stages.concat(...stagesToAdd));
+  const pubStatus = getEventPublishStatus({ event, status });
+  const drawDetails = pubStatus?.drawDetails || {};
+  for (const drawId of eventDrawIds) {
+    if (!drawIdsToValidate.length || drawIdsToValidate.includes(drawId)) {
+      if (drawIdsToRemove?.includes(drawId) || specifiedDrawIds?.length && !specifiedDrawIds.includes(drawId)) {
+        drawDetails[drawId] = {
+          ...drawDetails[drawId],
+          publishingDetail: { published: false }
+        };
+      } else if (drawIdsToAdd?.includes(drawId) || specifiedDrawIds?.includes(drawId) || !specifiedDrawIds?.length) {
+        drawDetails[drawId] = {
+          ...drawDetails[drawId],
+          publishingDetail: { published: true }
+        };
+      }
+    }
+    if (params.drawDetails?.[drawId]) {
+      const newDetail = params.drawDetails[drawId];
+      let structureDetails = newDetail.structureDetails ?? drawDetails[drawId].structureDetails;
+      const stageDetails = newDetail.stageDetails ?? drawDetails[drawId].stageDetails ?? {};
+      const {
+        structureIdsToRemove = [],
+        structureIdsToAdd = [],
+        publishingDetail = {},
+        stagesToRemove = [],
+        stagesToAdd = []
+      } = newDetail;
+      if (structureIdsToAdd || stagesToAdd)
+        publishingDetail.published = true;
+      drawDetails[drawId] = {
+        publishingDetail,
+        structureDetails,
+        stageDetails
+      };
+      if (structureIdsToAdd.length || structureIdsToRemove.length) {
+        const drawStructureIds = (event.drawDefinitions?.find(
+          (drawDefinition) => drawDefinition.drawId === drawId
+        )?.structures ?? []).map(({ structureId }) => structureId);
+        const structureIdsToValidate = (structureIdsToAdd ?? []).concat(
+          structureIdsToRemove ?? []
+        );
+        const invalidStructureIds = structureIdsToValidate.filter(
+          (structureId) => !drawStructureIds.includes(structureId)
+        );
+        if (invalidStructureIds.length) {
+          return decorateResult({
+            result: { error: STRUCTURE_NOT_FOUND },
+            context: { invalidStructureIds }
+          });
+        }
+        structureDetails = structureDetails ?? {};
+        for (const structureId of drawStructureIds) {
+          if (structureIdsToRemove.includes(structureId)) {
+            structureDetails[structureId] = { published: false };
+          } else {
+            structureDetails[structureId] = { published: true };
+          }
+        }
+        drawDetails[drawId].structureDetails = structureDetails;
+      }
+      const drawStages = (event.drawDefinitions?.find(
+        (drawDefinition) => drawDefinition.drawId === drawId
+      )?.structures ?? []).map(({ stage }) => stage);
+      if (stagesToAdd.length) {
+        for (const stage of stagesToAdd) {
+          stageDetails[stage] = { published: true };
+        }
+        for (const stage of drawStages) {
+          if (!stageDetails[stage]) {
+            stageDetails[stage] = { published: false };
+          }
+        }
+      }
+      if (stagesToAdd.length || stagesToRemove.length) {
+        for (const stage of stagesToRemove) {
+          stageDetails[stage] = { published: false };
+        }
+        for (const stage of drawStages) {
+          if (!stageDetails[stage]) {
+            stageDetails[stage] = { published: true };
+          }
+        }
+      }
+      if (stagesToAdd.length || stagesToRemove.length) {
+        drawDetails[drawId].stageDetails = stageDetails;
+      }
+    }
   }
-  const existingStatusValue = timeItem?.itemValue?.[status];
-  const updatedTimeItem = {
-    itemValue: {
-      [status]: { ...existingStatusValue, drawIds, structureIds, stages }
-    },
-    itemType
-  };
-  addEventTimeItem({ event, timeItem: updatedTimeItem, removePriorValues });
+  modifyEventPublishStatus({
+    statusObject: { drawDetails },
+    removePriorValues,
+    status,
+    event
+  });
   const { eventData } = getEventData({
     includePositionAssignments,
     usePublishState: true,
@@ -53410,10 +53700,6 @@ function publishEvent(params) {
     policyDefinitions,
     event
   });
-  const publishState = eventData?.eventInfo?.publish?.state;
-  eventData.drawsData = eventData.drawsData.filter(
-    ({ drawId }) => publishState?.PUBLIC?.drawIds.includes(drawId)
-  );
   addNotice({
     payload: { eventData, tournamentId: tournamentRecord.tournamentId },
     topic: PUBLISH_EVENT
@@ -53430,6 +53716,7 @@ const publishingGovernor = {
   getDrawData,
   unPublishEventSeeding,
   publishEventSeeding,
+  setEventDisplay,
   unPublishEvent,
   publishEvent,
   unPublishOrderOfPlay: unPublishOrderOfPlay$1,
@@ -53864,7 +54151,7 @@ function generateLineUps(params) {
   if (!tieFormat && !drawDefinition)
     return { error: DRAW_DEFINITION_NOT_FOUND };
   tieFormat = tieFormat ?? resolveTieFormat({ drawDefinition, event })?.tieFormat;
-  if (validateTieFormat({ tieFormat, eventType: params.event?.eventType }).error)
+  if (validateTieFormat({ tieFormat }).error)
     return { error: INVALID_TIE_FORMAT };
   if (typeof scaleAccessor !== "object" && !useDefaultEventRanking)
     return { error: INVALID_VALUES, context: { scaleAccessor } };
@@ -56524,6 +56811,9 @@ function deleteDrawDefinitions(params) {
     bye
   }) => ({ bye, qualifier, drawPosition, participantId });
   const allowDeletionWithScoresPresent = force || appliedPolicies?.[POLICY_TYPE_SCORING]?.allowDeletionWithScoresPresent?.drawDefinitions;
+  const publishStatus = getEventPublishStatus({ event }) ?? {};
+  let updatedDrawIds = publishStatus.drawIds ?? (publishStatus.drawDetails && Object.keys(publishStatus.drawDetails)) ?? [];
+  let publishedDrawsDeleted;
   const drawIdsWithScoresPresent = [];
   const filteredDrawDefinitions = event.drawDefinitions.filter(
     (drawDefinition) => {
@@ -56545,6 +56835,10 @@ function deleteDrawDefinitions(params) {
             (entry) => STRUCTURE_ENTERED_TYPES.includes(entry.entryStatus)
           );
         }
+        if (updatedDrawIds.includes(drawId2)) {
+          updatedDrawIds = updatedDrawIds.filter((id) => id !== drawId2);
+          publishedDrawsDeleted = true;
+        }
         const mainStructure = getDrawStructures({
           stageSequence: 1,
           drawDefinition,
@@ -56616,29 +56910,19 @@ function deleteDrawDefinitions(params) {
     addEventExtension$1({ event, extension });
   }
   checkSchedulingProfile({ tournamentRecord });
-  const itemType = `${PUBLISH}.${STATUS$1}`;
-  const { timeItem } = getTimeItem({ element: event, itemType });
-  const publishStatus = timeItem?.itemValue?.[PUBLIC];
-  let publishedDrawsDeleted;
-  for (const drawId2 of drawIds) {
-    const drawPublished = publishStatus?.drawIds?.includes(drawId2);
-    if (drawPublished) {
-      publishedDrawsDeleted = true;
-      const updatedDrawIds = publishStatus.drawIds?.filter(
-        (publishedDrawId) => publishedDrawId !== drawId2
-      ) || [];
-      const timeItem2 = {
-        itemType: `${PUBLISH}.${STATUS$1}`,
-        itemValue: {
-          [PUBLIC]: {
-            drawIds: updatedDrawIds
-          }
-        }
+  if (publishedDrawsDeleted) {
+    const drawDetails = {};
+    for (const drawId2 of updatedDrawIds) {
+      drawDetails[drawId2] = publishStatus.drawDetails?.[drawId2] ?? {
+        published: true
       };
-      const result = addEventTimeItem({ event, timeItem: timeItem2 });
-      if (result.error)
-        return { error: result.error };
     }
+    const result = modifyEventPublishStatus({
+      statusObject: { drawDetails },
+      event
+    });
+    if (result.error)
+      return { error: result.error };
   }
   if (auditTrail.length) {
     addNotice({ topic: AUDIT, payload: auditTrail });
@@ -56654,9 +56938,14 @@ function deleteDrawDefinitions(params) {
   });
   addDrawDeletionTelemetry({ event, deletedDrawsDetail, auditData });
   if (autoPublish && publishedDrawsDeleted) {
-    const result = publishEvent({ tournamentRecord, event, policyDefinitions });
+    const result = publishEvent({
+      drawIdsToRemove: drawIds,
+      policyDefinitions,
+      tournamentRecord,
+      event
+    });
     if (result.error)
-      console.log("publish error", result);
+      return { ...SUCCESS, info: result.error };
   }
   return { ...SUCCESS };
 }
@@ -57291,10 +57580,7 @@ function addEvent({
   };
   if (event.eventType === TypeEnum.Team) {
     if (event.tieFormat) {
-      const result = validateTieFormat({
-        tieFormat: event.tieFormat,
-        eventType: event.eventType
-      });
+      const result = validateTieFormat({ tieFormat: event.tieFormat });
       if (result.error)
         return result;
     } else if (event.tieFormatName) {
@@ -59705,8 +59991,7 @@ function generateDrawDefinition(params) {
     const result = validateTieFormat({
       gender: event?.gender,
       enforceGender,
-      tieFormat,
-      event
+      tieFormat
     });
     if (result.error)
       return decorateResult({ result, stack });
@@ -59725,10 +60010,7 @@ function generateDrawDefinition(params) {
     const equivalentInScope = matchUpFormat && event?.matchUpFormat === matchUpFormat || event?.tieFormat && tieFormat && JSON.stringify(event.tieFormat) === JSON.stringify(tieFormat);
     if (!equivalentInScope) {
       if (tieFormat) {
-        const result = checkTieFormat({
-          eventType: event.eventType,
-          tieFormat
-        });
+        const result = checkTieFormat({ tieFormat });
         if (result.error)
           return decorateResult({ result, stack });
         drawDefinition.tieFormat = result.tieFormat ?? tieFormat;
@@ -60059,7 +60341,7 @@ function generateDrawDefinition(params) {
     drawDefinition.links.push(link);
   }
   drawDefinition.drawName = params.drawName ?? (drawType && constantToString(drawType));
-  if (typeof voluntaryConsolation === "object") {
+  if (typeof voluntaryConsolation === "object" && drawSize >= 4) {
     addVoluntaryConsolationStructure({
       ...voluntaryConsolation,
       tournamentRecord,
@@ -61010,10 +61292,8 @@ function bulkUpdatePublishedEventIds({ tournamentRecord, outcomes }) {
     if (eventId && drawId) {
       if (!eventIdsMap2[eventId]) {
         eventIdsMap2[eventId] = [drawId];
-      } else {
-        if (!eventIdsMap2[eventId].includes(drawId)) {
-          eventIdsMap2[eventId].push(drawId);
-        }
+      } else if (!eventIdsMap2[eventId].includes(drawId)) {
+        eventIdsMap2[eventId].push(drawId);
       }
     }
     return eventIdsMap2;
@@ -61023,14 +61303,14 @@ function bulkUpdatePublishedEventIds({ tournamentRecord, outcomes }) {
     (event) => relevantEventsIds.includes(event.eventId)
   );
   const publishedEventIds = relevantEvents.filter((event) => {
-    const { timeItem } = getEventTimeItem({
-      itemType: `${PUBLISH}.${STATUS$1}`,
-      event
-    });
-    const pubState = timeItem?.itemValue;
+    const pubStatus = getEventPublishStatus({ event });
+    const { drawDetails, drawIds } = pubStatus ?? {};
     const { eventId } = event;
     const publishedDrawIds = eventIdsMap[eventId].filter((drawId) => {
-      return pubState?.[PUBLIC]?.drawIds?.includes(drawId);
+      const keyedDrawIds = drawDetails ? Object.keys(pubStatus.drawDetails).filter(
+        (drawId2) => getDrawPublishStatus({ drawId: drawId2, drawDetails })
+      ) : [];
+      return drawIds?.includes(drawId) || keyedDrawIds.includes(drawId);
     });
     return publishedDrawIds.length;
   }).map((event) => event.eventId);