tods-competition-factory 1.7.13 → 1.7.15

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.13";
+  return "1.7.15";
 }
 
 function getObjectTieFormat(obj) {
@@ -2426,8 +2426,9 @@ function decorateResult({
   if (result && Array.isArray(result?.stack) && typeof stack === "string") {
     result.stack.push(stack);
   }
-  if (info && result?.error)
-    result.error.info = info;
+  if (result && info) {
+    result.info = info;
+  }
   if (result && typeof context === "object" && Object.keys(context).length) {
     Object.assign(result, definedAttributes(context));
   }
@@ -2557,34 +2558,28 @@ function validateTieFormat(params) {
   const tieFormat = params?.tieFormat;
   const stack = "validateTieFormat";
   const errors = [];
-  if (typeof tieFormat !== "object") {
+  if (!params || !tieFormat || typeof tieFormat !== "object") {
     errors.push("tieFormat must be an object");
     return decorateResult({
-      result: {
-        context: { tieFormat, errors },
-        error: INVALID_TIE_FORMAT,
-        stack
-      }
+      result: { error: INVALID_TIE_FORMAT },
+      context: { tieFormat, errors },
+      stack
     });
   }
   if (typeof tieFormat.winCriteria !== "object") {
     errors.push("tieFormat.winCriteria must be an object");
     return decorateResult({
-      result: {
-        context: { tieFormat, errors },
-        error: INVALID_TIE_FORMAT,
-        stack
-      }
+      result: { error: INVALID_TIE_FORMAT },
+      context: { tieFormat, errors },
+      stack
     });
   }
   if (!Array.isArray(tieFormat.collectionDefinitions)) {
     errors.push(mustBeAnArray("tieFormat.collectionDefinitions"));
     return decorateResult({
-      result: {
-        context: { tieFormat, errors },
-        error: INVALID_TIE_FORMAT,
-        stack
-      }
+      result: { error: INVALID_TIE_FORMAT },
+      context: { tieFormat, errors },
+      stack
     });
   }
   let aggregateValueImperative;
@@ -2617,11 +2612,9 @@ function validateTieFormat(params) {
       );
     }
     return decorateResult({
-      result: {
-        context: { tieFormat, errors, aggregateValueImperative },
-        error: INVALID_TIE_FORMAT,
-        stack
-      }
+      context: { tieFormat, errors, aggregateValueImperative },
+      result: { error: INVALID_TIE_FORMAT },
+      stack
     });
   }
   const collectionIds = tieFormat.collectionDefinitions.map(
@@ -2632,11 +2625,9 @@ function validateTieFormat(params) {
   const result = { valid, errors };
   if (!valid) {
     return decorateResult({
-      result: {
-        context: { tieFormat, errors },
-        error: INVALID_TIE_FORMAT,
-        stack
-      }
+      result: { error: INVALID_TIE_FORMAT },
+      context: { tieFormat, errors },
+      stack
     });
   }
   return result;
@@ -2695,7 +2686,7 @@ function validateCollectionDefinition({
     errors.push(`collectionValue is not type number: ${collectionValue}`);
   }
   if (collectionValueProfiles) {
-    const result = validateCollectionValueProfile({
+    const result = validateCollectionValueProfiles({
       collectionValueProfiles,
       matchUpCount
     });
@@ -2726,7 +2717,7 @@ function checkTieFormat(tieFormat) {
   }
   return { tieFormat };
 }
-function validateCollectionValueProfile({
+function validateCollectionValueProfiles({
   collectionValueProfiles,
   matchUpCount
 }) {
@@ -4813,19 +4804,15 @@ function findEvent({
 }) {
   const stack = "findEvent";
   if (!tournamentRecord)
-    return {
-      event: void 0,
-      drawDefinition: void 0,
-      ...decorateResult({
-        result: { error: MISSING_TOURNAMENT_RECORD },
-        stack
-      })
-    };
-  const events = tournamentRecord?.events || [];
+    return decorateResult({
+      result: { error: MISSING_TOURNAMENT_RECORD },
+      stack
+    });
+  const events = tournamentRecord?.events ?? [];
   if (drawId) {
     let drawDefinition;
     const event = events.find((event2) => {
-      const drawDefinitions = event2?.drawDefinitions || [];
+      const drawDefinitions = event2?.drawDefinitions ?? [];
       const targetDrawDefinition = drawDefinitions.find(
         (drawDefinition2) => drawDefinition2.drawId === drawId
       );
@@ -4904,7 +4891,7 @@ function addExtension$1(params) {
     });
   if (!params.element.extensions)
     params.element.extensions = [];
-  const creationTime = params.creationTime !== void 0 ? params.creationTime : true;
+  const creationTime = params?.creationTime ?? true;
   if (creationTime) {
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     Object.assign(params.extension, { createdAt });
@@ -5455,7 +5442,7 @@ function findCourt({
   } else if (tournamentRecords) {
     const linkedTournamentIds = getLinkedTournamentIds({
       tournamentRecords
-    }).linkedTournamentIds || [];
+    }).linkedTournamentIds ?? [];
     const relevantIds = linkedTournamentIds[tournamentRecord.tournamentId];
     for (const tournamentId of relevantIds) {
       const record = tournamentRecords[tournamentId];
@@ -16570,6 +16557,10 @@ function proConflicts({
   return { courtIssues, rowIssues };
 }
 
+function stringSort(a, b) {
+  return (a || "").localeCompare(b || "");
+}
+
 function getTieFormatDesc(tieFormat) {
   if (!tieFormat)
     return {};
@@ -16652,7 +16643,30 @@ function compareTieFormats({
   ancestorDifferences.groupsCount = descendantDifferences.groupsCount ? -1 * descendantDifferences.groupsCount : 0;
   const valueDifference = descendantDifferences.collectionsValue.totalValue - ancestorDifferences.collectionsValue.totalValue;
   const matchUpCountDifference = descendantDifferences.collectionsValue.totalMatchUps - ancestorDifferences.collectionsValue.totalMatchUps;
-  const different = nameDifference || orderDifference || ancestorDesc !== descendantDesc || valueDifference !== 0;
+  const assignmentValuesCountDifference = ancestorDifferences.collectionsValue.assignmentValues.length !== descendantDifferences.collectionsValue.assignmentValues.length;
+  const assignmentValuesDifference = ancestorDifferences.collectionsValue.assignmentValues.some(
+    (assignment, i) => {
+      const comparisonAssignment = descendantDifferences.collectionsValue.assignmentValues[i];
+      if (!comparisonAssignment)
+        return true;
+      if (assignment.valueKey !== comparisonAssignment.valueKey)
+        return true;
+      if (assignment.value !== comparisonAssignment.value)
+        return true;
+      if (Array.isArray(assignment.value)) {
+        return assignment.value.every(
+          (value, i2) => comparisonAssignment.value[i2] === value
+        );
+      }
+      return false;
+    }
+  );
+  const different = nameDifference || orderDifference || ancestorDesc !== descendantDesc || assignmentValuesCountDifference || assignmentValuesDifference || valueDifference !== 0;
+  const invalidValues = [
+    ...ancestorDifferences.collectionsValue.invalidValues,
+    ...descendantDifferences.collectionsValue.invalidValues
+  ];
+  const invalid = invalidValues.length && invalidValues;
   return {
     matchUpFormatDifferences,
     matchUpCountDifference,
@@ -16664,12 +16678,15 @@ function compareTieFormats({
     descendantDesc,
     ancestorDesc,
     ...SUCCESS,
-    different
+    different,
+    invalid
   };
 }
 function getCollectionsValue(definitions) {
+  const invalidValues = [];
+  const assignmentValues = [];
   let totalMatchUps = 0;
-  const collectionIds = Object.keys(definitions);
+  const collectionIds = Object.keys(definitions).sort(stringSort);
   const totalValue = collectionIds.reduce((total, collectionId) => {
     const collectionDefinition = definitions[collectionId];
     const {
@@ -16680,6 +16697,24 @@ function getCollectionsValue(definitions) {
       scoreValue,
       setValue
     } = collectionDefinition;
+    const valueAssignments = {
+      collectionValueProfiles,
+      collectionValue,
+      matchUpValue,
+      scoreValue,
+      setValue
+    };
+    const valueKeys = Object.keys(valueAssignments).filter(
+      (key) => ![void 0, null].includes(valueAssignments[key])
+    );
+    if (valueKeys.length !== 1) {
+      invalidValues.push({ collectionId });
+    }
+    const valueKey = valueKeys[0];
+    if (valueKey) {
+      const value = valueKey === "collectionValueProfiles" ? Object.values(collectionValueProfiles) : valueAssignments[valueKey];
+      assignmentValues.push({ valueKey, value });
+    }
     totalMatchUps += matchUpCount;
     if (collectionValueProfiles)
       return total + collectionValueProfiles.reduce(
@@ -16697,7 +16732,7 @@ function getCollectionsValue(definitions) {
     }
     return total;
   }, 0);
-  return { totalValue, totalMatchUps };
+  return { totalValue, totalMatchUps, invalidValues, assignmentValues };
 }
 
 function dehydrateMatchUps({ tournamentRecord }) {
@@ -20759,7 +20794,7 @@ function removeSubsequentRoundsParticipant({
   const positionAssignments = getPositionAssignments$1({
     drawDefinition,
     structureId
-  }).positionAssignments || [];
+  }).positionAssignments ?? [];
   relevantMatchUps?.forEach(
     (matchUp) => removeDrawPosition({
       drawPosition: targetDrawPosition,
@@ -20789,7 +20824,7 @@ function removeDrawPosition({
   const initialDrawPositions = targetMatchUp.drawPositions?.slice();
   const initialMatchUpStatus = targetMatchUp.matchUpStatus;
   const initialWinningSide = targetMatchUp.winningSide;
-  matchUpsMap = matchUpsMap || getMatchUpsMap({ drawDefinition });
+  matchUpsMap = matchUpsMap ?? getMatchUpsMap({ drawDefinition });
   const mappedMatchUps = matchUpsMap.mappedMatchUps;
   const matchUps = mappedMatchUps[structure.structureId].matchUps;
   const { initialRoundNumber } = getInitialRoundNumber({
@@ -20797,7 +20832,7 @@ function removeDrawPosition({
     matchUps
   });
   if (targetMatchUp.roundNumber && initialRoundNumber && targetMatchUp.roundNumber > initialRoundNumber) {
-    const drawPositions = (targetMatchUp.drawPositions || []).map(
+    const drawPositions = (targetMatchUp.drawPositions ?? []).map(
       (currentDrawPosition) => currentDrawPosition === drawPosition ? void 0 : currentDrawPosition
     );
     targetMatchUp.drawPositions = drawPositions;
@@ -20806,7 +20841,7 @@ function removeDrawPosition({
     const inContextTargetMatchUp = inContextDrawMatchUps?.find(
       (matchUp) => matchUp.matchUpId === targetMatchUp.matchUpId
     );
-    const sides = inContextTargetMatchUp?.sides || [];
+    const sides = inContextTargetMatchUp?.sides ?? [];
     const drawPositionSideIndex = sides.reduce(
       (index, side, i) => side.drawPosition === drawPosition ? i : index,
       void 0
@@ -22025,9 +22060,7 @@ function assignMatchUpDrawPosition({
     return { ...SUCCESS };
   } else {
     return decorateResult({
-      result: {
-        error: DRAW_POSITION_ASSIGNED
-      },
+      result: { error: DRAW_POSITION_ASSIGNED },
       context: { drawPosition },
       stack
     });
@@ -23104,8 +23137,8 @@ function getSeedGroups({
       return {
         seedGroups: void 0,
         ...decorateResult({
-          result: { error: INVALID_VALUES },
           context: { roundRobinGroupsCount },
+          result: { error: INVALID_VALUES },
           stack
         })
       };
@@ -23149,8 +23182,8 @@ function getSeedingThresholds({
     const invalid = !validGroupsCounts?.includes(roundRobinGroupsCount);
     if (invalid) {
       return decorateResult({
-        result: { error: INVALID_VALUES },
-        context: { roundRobinGroupsCount }
+        context: { roundRobinGroupsCount },
+        result: { error: INVALID_VALUES }
       });
     }
   }
@@ -24257,7 +24290,8 @@ function directLoser(params) {
     if (result.error)
       return decorateResult({ result, stack });
   } else if (loserParticipantId && isFeedRound) {
-    const fedDrawPosition = unfilledTargetMatchUpDrawPositions.sort(numericSort)[0];
+    unfilledTargetMatchUpDrawPositions.sort(numericSort);
+    const fedDrawPosition = unfilledTargetMatchUpDrawPositions[0];
     const result = assignDrawPosition$1({
       participantId: loserParticipantId,
       structureId: targetStructureId,
@@ -25244,7 +25278,7 @@ function setMatchUpStatus$2(params) {
     drawDefinition
   });
   if (score && matchUp.matchUpType !== TEAM$2 && !disableScoreValidation) {
-    const matchUpFormat = matchUp.matchUpFormat || structure?.matchUpFormat || drawDefinition?.matchUpFormat || event?.matchUpFormat;
+    const matchUpFormat = matchUp.matchUpFormat ?? structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event?.matchUpFormat;
     const result2 = validateScore({
       existingMatchUpStatus: matchUp.matchUpStatus,
       matchUpFormat,
@@ -25265,9 +25299,9 @@ function setMatchUpStatus$2(params) {
   ).every((assignment) => assignment.participantId);
   if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && !bothSideParticipants) {
     return decorateResult({
-      result: { error: INVALID_MATCHUP_STATUS },
       info: "present in participantRequiredMatchUpStatuses",
-      context: { matchUpStatus, bothSideParticipants }
+      context: { matchUpStatus, bothSideParticipants },
+      result: { error: INVALID_MATCHUP_STATUS }
     });
   }
   const appliedPolicies = getAppliedPolicies({
@@ -25390,8 +25424,8 @@ function winningSideWithDownstreamDependencies(params) {
     return applyMatchUpValues(params);
   } else {
     return decorateResult({
-      result: { error: CANNOT_CHANGE_WINNING_SIDE },
       stack: "winningSideWithDownstreamDependencies",
+      result: { error: CANNOT_CHANGE_WINNING_SIDE },
       context: { winningSide, matchUp }
     });
   }
@@ -25795,14 +25829,14 @@ function addDrawDefinition$1(params) {
   if (relevantFlight && !drawEntriesPresentInFlight) {
     return decorateResult({
       result: {
-        error: INVALID_DRAW_DEFINITION,
-        context: {
-          drawEntriesPresentInFlight,
-          matchingEventEntries,
-          relevantFlight
-        },
-        info: "Draw entries are not present in flight or do not match entryStatuses"
-      }
+        error: INVALID_DRAW_DEFINITION
+      },
+      context: {
+        drawEntriesPresentInFlight,
+        matchingEventEntries,
+        relevantFlight
+      },
+      info: "Draw entries are not present in flight or do not match entryStatuses"
     });
   }
   if (modifyEventEntries) {
@@ -25821,9 +25855,9 @@ function addDrawDefinition$1(params) {
   if (eventEntries && !matchingEventEntries)
     return decorateResult({
       result: {
-        error: INVALID_DRAW_DEFINITION,
+        info: "Draw entries do not match event entryStatuses",
         context: { matchingEventEntries, eventEntries },
-        info: "Draw entries do not match event entryStatuses"
+        error: INVALID_DRAW_DEFINITION
       }
     });
   const flightNumbers = flightProfile?.flights?.map(
@@ -26002,10 +26036,8 @@ function addParticipant$1({
       });
     } else if (participant.individualParticipantIds.length !== 2 && !pairOverride) {
       return decorateResult({
-        result: {
-          error: INVALID_PARTICIPANT_IDS,
-          info: "PAIR must be 2 individualParticipantIds"
-        },
+        info: "PAIR must be 2 individualParticipantIds",
+        result: { error: INVALID_PARTICIPANT_IDS },
         stack
       });
     } else {
@@ -29622,7 +29654,12 @@ function getTieFormat$1({
   }
   if (!tieFormat)
     return decorateResult({ result: { error: MISSING_TIE_FORMAT }, stack });
-  return { ...SUCCESS, tieFormat, matchUp, structure };
+  return {
+    ...SUCCESS,
+    structure,
+    tieFormat,
+    matchUp
+  };
 }
 
 function tieFormatTelemetry({ drawDefinition, auditData }) {
@@ -29637,13 +29674,59 @@ function tieFormatTelemetry({ drawDefinition, auditData }) {
   addExtension$1({ element: drawDefinition, extension: updatedExtension });
 }
 
+function generateTieMatchUps({
+  tieFormat,
+  isMock,
+  uuids
+}) {
+  const { collectionDefinitions } = tieFormat ?? {};
+  const tieMatchUps = (collectionDefinitions ?? []).map(
+    (collectionDefinition) => generateCollectionMatchUps({ collectionDefinition, uuids, isMock })
+  ).filter(Boolean).flat();
+  return { tieMatchUps };
+}
+function generateCollectionMatchUps({
+  collectionPositionOffset = 0,
+  collectionDefinition,
+  matchUpsLimit,
+  // internal use allows generation of missing matchUps on "reset"
+  isMock,
+  uuids
+}) {
+  const { matchUpCount, matchUpType, collectionId, processCodes } = collectionDefinition || {};
+  const numberToGenerate = matchUpsLimit ?? matchUpCount ?? 0;
+  return generateRange(0, numberToGenerate).map((index) => {
+    const collectionPosition = collectionPositionOffset + index + 1;
+    return {
+      sides: [{ sideNumber: 1 }, { sideNumber: 2 }],
+      matchUpId: uuids?.pop() || UUID(),
+      matchUpStatus: MatchUpStatusEnum.ToBePlayed,
+      collectionPosition,
+      collectionId,
+      processCodes,
+      matchUpType,
+      isMock
+    };
+  });
+}
+
 function validUpdate({ matchUp, updateInProgressMatchUps }) {
   return !matchUp.winningSide && ![completedMatchUpStatuses].includes(matchUp.matchUpStatus) && (updateInProgressMatchUps || matchUp.matchUpStatus !== IN_PROGRESS$1 && !scoreHasValue(matchUp));
 }
 
-function mapsCheck(map1, map2) {
-  const referenceKeys = Object.keys(map1);
-  return intersection(referenceKeys, Object.keys(map2)).length === referenceKeys.length;
+function checkStructureMatchUpCounts({ from, to }) {
+  const referenceKeys = Object.keys(from);
+  const sameKeys = intersection(referenceKeys, Object.keys(to)).length === referenceKeys.length;
+  const differentMatchUpsCount = referenceKeys.filter(
+    (collectionId) => from[collectionId] !== to[collectionId]
+  );
+  const matchUpsCountChanges = differentMatchUpsCount.map((collectionId) => ({
+    countChange: to[collectionId] - from[collectionId],
+    collectionId
+  }));
+  const sameMatchUpsCount = referenceKeys.every((key) => from[key] === to[key]);
+  const equivalent = sameKeys && sameMatchUpsCount;
+  return { equivalent, matchUpsCountChanges };
 }
 function updateTieFormat({
   updateInProgressMatchUps,
@@ -29653,10 +29736,15 @@ function updateTieFormat({
   tieFormat,
   eventId,
   matchUp,
-  event
+  event,
+  uuids
 }) {
+  console.log("booo", { matchUp });
   const stack = "updateTieFormat";
+  const tournamentId = tournamentRecord?.tournamentId;
   let modifiedStructuresCount = 0;
+  let modifiedMatchUpsCount = 0;
+  let addedMatchUpsCount = 0;
   let modifiedCount = 0;
   const collectionMap = tieFormat?.collectionDefinitions.reduce(
     (instanceMap, def) => {
@@ -29670,7 +29758,7 @@ function updateTieFormat({
       instanceMap[def.collectionId] = (instanceMap[def.collectionId] || 0) + def.matchUpCount;
       return instanceMap;
     }, {});
-    return mapsCheck(collectionMap, cMap);
+    return checkStructureMatchUpCounts({ from: cMap, to: collectionMap }).equivalent;
   };
   const drawDefaultTieFormat = getTieFormat$1({ drawDefinition })?.tieFormat;
   const eventDefaultTieFormat = getTieFormat$1({ event })?.tieFormat;
@@ -29678,7 +29766,7 @@ function updateTieFormat({
     for (const drawDefinition2 of event.drawDefinitions ?? []) {
       processDrawDefinition({ drawDefinition: drawDefinition2 });
     }
-    event.tieFormat = tieFormat;
+    event.tieFormat = copyTieFormat(tieFormat);
     modifiedCount += 1;
   } else if (matchUp) {
     if (!matchUp.tieMatchUps) {
@@ -29687,54 +29775,83 @@ function updateTieFormat({
     const matchUpMap = instanceCount(
       matchUp.tieMatchUps?.map(({ collectionId }) => collectionId)
     );
-    if (mapsCheck(collectionMap, matchUpMap)) {
+    const check = checkStructureMatchUpCounts({
+      to: collectionMap,
+      from: matchUpMap
+    });
+    const { changes, changesArePossible, cannotChangeReaon } = getMatchUpChangesArePossible({
+      matchUp,
+      check
+    });
+    if (check.equivalent) {
       if (validUpdate({ matchUp, updateInProgressMatchUps })) {
-        matchUp.tieFormat = tieFormat;
+        matchUp.tieFormat = copyTieFormat(tieFormat);
         modifiedCount += 1;
       } else {
         return decorateResult({
           result: { error: CANNOT_MODIFY_TIEFORMAT },
-          info: "matchUp is IN_PROGRESS or COMPLETE"
+          info: "matchUp is IN_PROGRESS or COMPLETE",
+          stack
         });
       }
+    } else if (changesArePossible) {
+      makeChanges({ tieFormat, matchUp, changes, uuids });
     } else {
       return decorateResult({
         context: { collectionMap, matchUpMap },
         result: { error: INVALID_TIE_FORMAT },
-        info: "on matchUp",
+        info: cannotChangeReaon || "specified changes not possible",
         stack
       });
     }
+    modifiedMatchUpsCount += 1;
     modifyMatchUpNotice({
-      tournamentId: tournamentRecord?.tournamentId,
       eventId: event?.eventId,
       context: stack,
       drawDefinition,
+      tournamentId,
       matchUp
     });
   } else if (structure) {
-    const inheritedTieFormat = drawDefaultTieFormat || eventDefaultTieFormat;
+    const inheritedTieFormat = drawDefaultTieFormat ?? eventDefaultTieFormat;
     const modified = processStructure({
       inheritedTieFormat,
       structure
-    })?.modifiedCount;
-    if (modified)
-      modifiedStructuresCount += modified;
-    structure.tieFormat = tieFormat;
-    modifiedCount += 1;
-    modifyDrawNotice({
+    })?.modifiedMatchUpsCount;
+    if (modified) {
+      modifiedMatchUpsCount += modified;
+      modifiedStructuresCount += 1;
+      modifiedCount += 1;
+    }
+    const different = !structure.tieFormat || compareTieFormats({
+      ancestor: structure.tieFormat,
+      descendant: tieFormat
+    }).different;
+    if (different) {
+      structure.tieFormat = copyTieFormat(tieFormat);
+      modifiedStructuresCount += 1;
+      modifiedCount += 1;
+    }
+    (modified || different) && drawDefinition && modifyDrawNotice({
       structureIds: [structure.structureId],
       eventId: event?.eventId,
       drawDefinition
     });
   } else if (drawDefinition) {
     processDrawDefinition({ drawDefinition });
-    drawDefinition.tieFormat = tieFormat;
+    drawDefinition.tieFormat = copyTieFormat(tieFormat);
     modifiedCount += 1;
   } else {
     return { error: MISSING_DRAW_DEFINITION };
   }
-  return { ...SUCCESS, modifiedCount, modifiedStructuresCount, tieFormat };
+  return {
+    modifiedStructuresCount,
+    modifiedMatchUpsCount,
+    addedMatchUpsCount,
+    modifiedCount,
+    ...SUCCESS,
+    tieFormat
+  };
   function processDrawDefinition({ drawDefinition: drawDefinition2 }) {
     const structures = drawDefinition2.structures || [];
     const modifiedStructureIds = [];
@@ -29745,9 +29862,10 @@ function updateTieFormat({
       const modifiedCount2 = processStructure({
         inheritedTieFormat,
         structure: structure2
-      })?.modifiedCount;
+      })?.modifiedMatchUpsCount;
       if (modifiedCount2) {
-        modifiedStructuresCount += modifiedCount2;
+        modifiedStructuresCount += 1;
+        modifiedMatchUpsCount += modifiedCount2;
         const structureId = structure2.structureId;
         modifiedStructureIds.push(structureId);
       }
@@ -29760,32 +29878,49 @@ function updateTieFormat({
     return modifiedStructureIds.length;
   }
   function processStructure({ inheritedTieFormat, structure: structure2 }) {
-    let modifiedCount2 = 0;
+    let modifiedMatchUpsCount2 = 0;
     const structureMatchUps = getAllStructureMatchUps({
       matchUpFilters: { matchUpTypes: [TEAM$2] },
       structure: structure2
     })?.matchUps || [];
     for (const matchUp2 of structureMatchUps) {
+      const validToUpdate = validUpdate({ matchUp: matchUp2, updateInProgressMatchUps });
       let modified = false;
       const tieMatchUpsMap = instanceCount(
         matchUp2.tieMatchUps?.map(({ collectionId }) => collectionId)
       );
-      if (!mapsCheck(collectionMap, tieMatchUpsMap)) {
-        if (inheritedTieFormat) {
-          matchUp2.tieFormat = inheritedTieFormat;
-          modified = true;
+      const check = checkStructureMatchUpCounts({
+        from: tieMatchUpsMap,
+        to: collectionMap
+      });
+      if (!check.equivalent) {
+        const { changes, changesArePossible } = getMatchUpChangesArePossible({
+          matchUp: matchUp2,
+          check
+        });
+        if (changesArePossible && !matchUp2.tieFormat) {
+          makeChanges({ changes, matchUp: matchUp2, tieFormat, uuids });
+        } else if (inheritedTieFormat) {
+          const different = !matchUp2.tieFormat || compareTieFormats({
+            ancestor: inheritedTieFormat,
+            descendant: matchUp2.tieFormat
+          }).different;
+          if (different) {
+            matchUp2.tieFormat = inheritedTieFormat;
+            modified = true;
+          }
         } else {
           return decorateResult({
             result: { error: MISSING_TIE_FORMAT },
             stack
           });
         }
-      } else if (matchUp2.tieFormat && matchingCollections(matchUp2) && validUpdate({ matchUp: matchUp2, updateInProgressMatchUps })) {
+      } else if (matchUp2.tieFormat && matchingCollections(matchUp2) && validToUpdate) {
         matchUp2.tieFormat = copyTieFormat(tieFormat);
         modified = true;
       }
       if (modified) {
-        modifiedCount2 += 1;
+        modifiedMatchUpsCount2 += 1;
         modifyMatchUpNotice({
           tournamentId: tournamentRecord?.tournamentId,
           drawDefinition,
@@ -29795,8 +29930,80 @@ function updateTieFormat({
         });
       }
     }
-    return { modifiedCount: modifiedCount2 };
+    return { modifiedMatchUpsCount: modifiedMatchUpsCount2 };
   }
+  function makeChanges({ uuids: uuids2, matchUp: matchUp2, tieFormat: tieFormat2, changes }) {
+    matchUp2.tieFormat = copyTieFormat(tieFormat2);
+    const matchUpIdsRemoved = [];
+    const matchUpsAdded = [];
+    changes.forEach((change) => {
+      if (change.countChange > 0) {
+        const collectionPositionOffset = Math.max(
+          0,
+          ...matchUp2.tieMatchUps.filter(
+            (tieMatchUp) => tieMatchUp.collectionId === change.collectionId
+          ).map(extractAttributes("collectionPosition"))
+        );
+        const collectionDefinition = tieFormat2.collectionDefinitions.find(
+          (def) => def.collectionId === change.collectionId
+        );
+        const newMatchUps = generateCollectionMatchUps({
+          matchUpsLimit: change.countChange,
+          collectionPositionOffset,
+          collectionDefinition,
+          uuids: uuids2
+        });
+        matchUpsAdded.push(...makeDeepCopy(newMatchUps, false, true));
+        addedMatchUpsCount += matchUpsAdded.length;
+        matchUp2.tieMatchUps.push(...newMatchUps);
+      } else {
+        const tieMatchUpIdsToRemove = change.toBePlayedTieMatchUpIds.slice(
+          0,
+          Math.abs(change.countChange)
+        );
+        console.log("remove", tieMatchUpIdsToRemove.length);
+        matchUpIdsRemoved.push(...tieMatchUpIdsToRemove);
+        matchUp2.tieMatchUps = matchUp2.tieMatchUps.filter(
+          ({ matchUpId }) => !tieMatchUpIdsToRemove.includes(matchUpId)
+        );
+      }
+    });
+    matchUpsAdded.length && addMatchUpsNotice({
+      matchUps: matchUpsAdded,
+      drawDefinition,
+      tournamentId,
+      eventId
+    });
+    matchUpIdsRemoved.length && deleteMatchUpsNotice({
+      matchUpIds: matchUpIdsRemoved,
+      action: "updateTieFormat",
+      drawDefinition,
+      tournamentId,
+      eventId
+    });
+    return { matchUpIdsRemoved, matchUpsAdded };
+  }
+}
+function getMatchUpChangesArePossible({ check, matchUp }) {
+  let cannotChangeReaon = "";
+  const changes = [];
+  const changesArePossible = check.matchUpsCountChanges.every(
+    ({ collectionId, countChange }) => {
+      const toBePlayedTieMatchUpIds = matchUp.tieMatchUps.filter(
+        (tieMatchUp) => tieMatchUp.collectionId === collectionId && tieMatchUp.matchUpStatus === TO_BE_PLAYED
+      ).map(extractAttributes("matchUpId"));
+      const possibleToChange = toBePlayedTieMatchUpIds.length + countChange >= 0 || countChange > 0;
+      if (!possibleToChange && countChange < 0)
+        cannotChangeReaon = "Insufficient TO_BE_PLAYED matchUps";
+      changes.push({
+        toBePlayedTieMatchUpIds,
+        collectionId,
+        countChange
+      });
+      return possibleToChange;
+    }
+  );
+  return { changesArePossible, changes, cannotChangeReaon };
 }
 
 function modifyCollectionDefinition$1({
@@ -29859,7 +30066,7 @@ function modifyCollectionDefinition$1({
     scoreValue,
     setValue
   };
-  if (!Object.values(valueAssignments).filter(Boolean).length && !collectionOrder && !collectionName && !matchUpCount && !matchUpFormat)
+  if (!Object.values(valueAssignments).filter(Boolean).length && !collectionOrder && !collectionName && !matchUpFormat && !matchUpCount && !matchUpType)
     return decorateResult({ result: { error: MISSING_VALUE }, stack });
   if (Object.values(valueAssignments).filter(Boolean).length > 1)
     return decorateResult({
@@ -29886,11 +30093,16 @@ function modifyCollectionDefinition$1({
     (collectionDefinition) => collectionDefinition.collectionId === collectionId
   );
   if (!sourceCollectionDefinition)
-    return decorateResult({ result: { error: NOT_FOUND }, stack });
+    return decorateResult({
+      info: "source collectionDefinition",
+      result: { error: NOT_FOUND },
+      context: { collectionId },
+      stack
+    });
   const value = collectionValue ?? matchUpValue ?? scoreValue ?? setValue;
   if (collectionValueProfiles) {
-    const result2 = validateCollectionValueProfile({
-      matchUpCount: matchUpCount || sourceCollectionDefinition?.matchUpCount,
+    const result2 = validateCollectionValueProfiles({
+      matchUpCount: matchUpCount ?? sourceCollectionDefinition?.matchUpCount,
       collectionValueProfiles
     });
     if (result2.errors) {
@@ -29966,11 +30178,8 @@ function modifyCollectionDefinition$1({
     modifications.push({ collectionId, matchUpFormat });
   }
   if (isConvertableInteger(matchUpCount) && sourceCollectionDefinition.matchUpCount !== matchUpCount) {
-    return decorateResult({
-      result: { error: NOT_IMPLEMENTED },
-      context: { matchUpCount },
-      stack
-    });
+    targetCollectionDefinition.matchUpCount = matchUpCount;
+    modifications.push({ collectionId, matchUpCount });
   }
   if (matchUpType && sourceCollectionDefinition.matchUpType !== matchUpType) {
     return decorateResult({
@@ -29987,8 +30196,8 @@ function modifyCollectionDefinition$1({
     targetCollectionDefinition.gender = gender;
     modifications.push({ collectionId, gender });
   }
-  const prunedTieFormat = definedAttributes(tieFormat);
-  result = validateTieFormat({ tieFormat: prunedTieFormat });
+  const modifiedTieFormat = definedAttributes(tieFormat);
+  result = validateTieFormat({ tieFormat: modifiedTieFormat });
   if (result.error) {
     return decorateResult({ result, stack });
   }
@@ -29997,16 +30206,16 @@ function modifyCollectionDefinition$1({
   }
   const changedTieFormatName = existingTieFormat?.tieFormatName !== tieFormatName;
   if (changedTieFormatName) {
-    prunedTieFormat.tieFormatName = tieFormatName;
+    modifiedTieFormat.tieFormatName = tieFormatName;
     modifications.push({ tieFormatName });
   } else if (modifications.length) {
-    delete prunedTieFormat.tieFormatName;
+    delete modifiedTieFormat.tieFormatName;
     modifications.push(
       "tieFormatName removed: modifications without new tieFormatName"
     );
   }
   result = updateTieFormat({
-    tieFormat: prunedTieFormat,
+    tieFormat: modifiedTieFormat,
     updateInProgressMatchUps,
     tournamentRecord,
     drawDefinition,
@@ -30299,17 +30508,17 @@ function removeCollectionDefinition$1({
     matchUps = getAllStructureMatchUps({
       matchUpFilters: { matchUpTypes: [TEAM$2] },
       structure
-    })?.matchUps || [];
+    })?.matchUps ?? [];
   } else if (drawDefinition) {
     matchUps = allDrawMatchUps$1({
       matchUpFilters: { matchUpTypes: [TEAM$2] },
       drawDefinition
-    })?.matchUps || [];
+    })?.matchUps ?? [];
   } else if (event) {
     matchUps = allEventMatchUps({
       matchUpFilters: { matchUpTypes: [TEAM$2] },
       drawDefinition
-    })?.matchUps || [];
+    })?.matchUps ?? [];
   }
   const targetMatchUps = (matchUps || []).filter((matchUp2) => {
     const collectionMatchUps = matchUp2.tieMatchUps?.filter(
@@ -30435,41 +30644,6 @@ function removeCollectionDefinition(params) {
   return resolveTournamentRecord({ ...params, method: removeCollectionDefinition$1 });
 }
 
-function generateTieMatchUps({
-  tieFormat,
-  isMock,
-  uuids
-}) {
-  const { collectionDefinitions } = tieFormat || {};
-  const tieMatchUps = (collectionDefinitions || []).map(
-    (collectionDefinition) => generateCollectionMatchUps({ collectionDefinition, uuids, isMock })
-  ).filter(Boolean).flat();
-  return { tieMatchUps };
-}
-function generateCollectionMatchUps({
-  collectionDefinition,
-  matchUpsLimit,
-  // internal use allows generation of missing matchUps on "reset"
-  isMock,
-  uuids
-}) {
-  const { matchUpCount, matchUpType, collectionId, processCodes } = collectionDefinition || {};
-  const numberToGenerate = matchUpsLimit || matchUpCount || 0;
-  return generateRange(0, numberToGenerate).map((index) => {
-    const collectionPosition = index + 1;
-    return {
-      sides: [{ sideNumber: 1 }, { sideNumber: 2 }],
-      matchUpId: uuids?.pop() || UUID(),
-      matchUpStatus: MatchUpStatusEnum.ToBePlayed,
-      collectionPosition,
-      collectionId,
-      processCodes,
-      matchUpType,
-      isMock
-    };
-  });
-}
-
 function addCollectionDefinition$1({
   updateInProgressMatchUps = true,
   collectionDefinition,
@@ -30485,6 +30659,7 @@ function addCollectionDefinition$1({
   uuids,
   event
 }) {
+  const stack = "addCollectionDefinition";
   const appliedPolicies = getAppliedPolicies({
     tournamentRecord,
     drawDefinition,
@@ -30498,10 +30673,10 @@ function addCollectionDefinition$1({
     checkGender,
     event
   });
-  if (!valid)
-    return { error: INVALID_VALUES, errors };
-  const stack = "addCollectionDefinition";
-  let result = !matchUp ? getTieFormat$1({
+  if (!valid) {
+    return decorateResult({ result: { error: INVALID_VALUES, errors }, stack });
+  }
+  let result = !matchUp?.tieFormat ? getTieFormat$1({
     drawDefinition,
     structureId,
     matchUpId,
@@ -30509,14 +30684,15 @@ function addCollectionDefinition$1({
     event
   }) : void 0;
   if (result?.error)
-    return { error: result.error };
+    return decorateResult({ result: { error: result.error }, stack });
   const structure = result?.structure;
   matchUp = matchUp ?? result?.matchUp;
-  const existingTieFormat = result?.tieFormat;
+  const existingTieFormat = matchUp?.tieFormat ?? result?.tieFormat;
   const tieFormat = copyTieFormat(existingTieFormat);
   result = validateTieFormat({ tieFormat });
-  if (result?.error)
-    return { error: result.error };
+  if (result?.error) {
+    return decorateResult({ result: { error: result.error }, stack });
+  }
   if (!collectionDefinition.collectionId) {
     collectionDefinition.collectionId = UUID();
   } else {
@@ -30549,8 +30725,9 @@ function addCollectionDefinition$1({
   let targetMatchUps = [];
   const prunedTieFormat = definedAttributes(tieFormat);
   result = validateTieFormat({ tieFormat: prunedTieFormat });
-  if (result?.error)
-    return { error: result.error };
+  if (result?.error) {
+    return decorateResult({ result: { error: result.error }, stack });
+  }
   if (eventId && event) {
     event.tieFormat = prunedTieFormat;
     for (const drawDefinition2 of event.drawDefinitions ?? []) {
@@ -30631,7 +30808,7 @@ function addCollectionDefinition$1({
         structure: structure2,
         uuids
       });
-      modifiedStructureIds.push(structureId);
+      modifiedStructureIds.push(structure2.structureId);
       addedMatchUps.push(...result2.newMatchUps);
       targetMatchUps.push(...result2.targetMatchUps);
     }
@@ -30725,146 +30902,6 @@ function addCollectionDefinition(params) {
   return resolveTournamentRecord({ ...params, method: addCollectionDefinition$1 });
 }
 
-function publicFindMatchUp(params) {
-  Object.assign(params, { inContext: true });
-  const { matchUp, error } = findMatchUp(params);
-  return { matchUp: makeDeepCopy(matchUp, true, true), error };
-}
-function findMatchUp({
-  participantsProfile,
-  afterRecoveryTimes,
-  tournamentRecord,
-  contextContent,
-  contextProfile,
-  drawDefinition,
-  matchUpId,
-  inContext,
-  eventId,
-  drawId,
-  event
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (typeof matchUpId !== "string")
-    return { error: MISSING_MATCHUP_ID };
-  if (!drawDefinition || !event) {
-    const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps || [];
-    const inContextMatchUp = matchUps.find(
-      (matchUp2) => matchUp2.matchUpId === matchUpId
-    );
-    if (!inContextMatchUp)
-      return { error: MATCHUP_NOT_FOUND };
-    ({ eventId, drawId } = inContextMatchUp);
-    ({ event, drawDefinition } = findEvent({
-      tournamentRecord,
-      eventId,
-      drawId
-    }));
-  }
-  if (!drawDefinition)
-    return { error: DRAW_DEFINITION_NOT_FOUND };
-  if (contextProfile && !contextContent)
-    contextContent = getContextContent({ tournamentRecord, contextProfile });
-  const additionalContext = {
-    surfaceCategory: event?.surfaceCategory || tournamentRecord.surfaceCategory,
-    indoorOutDoor: event?.indoorOutdoor || tournamentRecord.indoorOutdoor,
-    endDate: event?.endDate || tournamentRecord.endDate,
-    tournamentId: tournamentRecord.tournamentId,
-    eventId: eventId || event?.eventId,
-    drawId
-  };
-  const { participants: tournamentParticipants = [] } = hydrateParticipants({
-    participantsProfile,
-    tournamentRecord,
-    contextProfile,
-    inContext
-  });
-  const { matchUp, structure } = findMatchUp$1({
-    context: inContext ? additionalContext : void 0,
-    tournamentParticipants,
-    afterRecoveryTimes,
-    contextContent,
-    drawDefinition,
-    contextProfile,
-    matchUpId,
-    inContext,
-    event
-  });
-  return { matchUp, structure, drawDefinition };
-}
-
-function getTieFormat({
-  tournamentRecord,
-  // passed in automatically by tournamentEngine
-  drawDefinition,
-  // passed in automatically by tournamentEngine when drawId provided
-  structureId,
-  // optional - if only the default matchUpFormat for a structure is required
-  matchUpId,
-  // id of matchUp for which the scoped matchUpFormat(s) are desired
-  structure,
-  // optional optimization - when structure already known
-  eventId,
-  // optional - if only the default matchUpFormat for an event is required
-  drawId,
-  // avoid brute force search for matchUp
-  event
-  // passed in automatically by tournamentEngine when drawId or eventId provided
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!drawId && !event && !structureId && !matchUpId)
-    return decorateResult({
-      result: { error: MISSING_VALUE },
-      stack: "getTieFormat"
-    });
-  if (eventId && !event) {
-    event = tournamentRecord.events?.find((event2) => event2.eventId === eventId);
-  }
-  const matchUpResult = findMatchUp({
-    tournamentRecord,
-    drawDefinition,
-    matchUpId,
-    drawId,
-    event
-  });
-  if (matchUpId && matchUpResult?.error) {
-    return matchUpResult;
-  } else if (!drawDefinition && matchUpResult?.drawDefinition) {
-    drawDefinition = matchUpResult?.drawDefinition;
-  }
-  structure = structure ?? matchUpResult?.structure;
-  if (!structure && structureId && !matchUpId) {
-    if (!drawDefinition)
-      return { error: MISSING_DRAW_ID };
-    const structureResult = findStructure({ drawDefinition, structureId });
-    if (structureResult.error)
-      return structureResult;
-    structure = structureResult.structure;
-  }
-  const structureDefaultTieFormat = (structure?.tieFormat || structure?.tieFormatId) && resolveTieFormat({ structure, drawDefinition, event })?.tieFormat;
-  const drawDefaultTieFormat = (drawDefinition?.tieFormat || drawDefinition?.tieFormatId) && resolveTieFormat({
-    drawDefinition,
-    event
-  })?.tieFormat;
-  const eventDefaultTieFormat = resolveTieFormat({ event })?.tieFormat;
-  const tieFormat = resolveTieFormat({
-    matchUp: matchUpResult?.matchUp,
-    drawDefinition,
-    structure,
-    event
-  })?.tieFormat;
-  return {
-    ...SUCCESS,
-    matchUp: matchUpResult?.matchUp,
-    structureDefaultTieFormat,
-    eventDefaultTieFormat,
-    drawDefaultTieFormat,
-    tieFormat,
-    structure
-  };
-}
-
 function updateTargetTeamMatchUps({
   updateInProgressMatchUps,
   tournamentRecord,
@@ -31010,8 +31047,7 @@ function removeCollectionGroup$1({
   if (isNaN(collectionGroupNumber))
     return { error: INVALID_VALUES };
   const stack = "removeCollectionGroup";
-  let result = !matchUp ? getTieFormat({
-    tournamentRecord,
+  let result = !matchUp ? getTieFormat$1({
     drawDefinition,
     structureId,
     matchUpId,
@@ -31120,10 +31156,8 @@ function addCollectionGroup$1({
     const { collectionId, collectionGroupNumber: collectionGroupNumber2 } = collectionDefinition;
     if (collectionGroupNumber2 && collectionIds.includes(collectionId))
       return decorateResult({
-        result: {
-          error: INVALID_VALUES,
-          info: "collectionIds cannot be part of other collectionGroups"
-        },
+        info: "collectionIds cannot be part of other collectionGroups",
+        result: { error: INVALID_VALUES },
         stack
       });
   }
@@ -31178,9 +31212,14 @@ function modifyTieFormat$1({
   uuids,
   event
 }) {
-  const stack = "updateTieFormat";
-  if (!validateTieFormat(modifiedTieFormat))
-    return { error: INVALID_TIE_FORMAT };
+  const stack = "modifyTieFormat";
+  if (!validateTieFormat({ tieFormat: modifiedTieFormat }).valid) {
+    return decorateResult({
+      result: { error: INVALID_TIE_FORMAT },
+      info: "falied validation",
+      stack
+    });
+  }
   const result = getTieFormat$1({
     drawDefinition,
     structureId,
@@ -31192,8 +31231,23 @@ function modifyTieFormat$1({
     return decorateResult({ result, stack });
   const { matchUp, tieFormat: existingTieFormat } = result;
   const tieFormat = copyTieFormat(existingTieFormat);
-  if (!compareTieFormats({ ancestor: tieFormat, descendant: modifiedTieFormat })?.different) {
-    return { ...SUCCESS };
+  const comparison = compareTieFormats({
+    descendant: modifiedTieFormat,
+    ancestor: tieFormat
+  });
+  if (comparison.invalid) {
+    return decorateResult({
+      context: { invalid: comparison.invalid },
+      result: { error: INVALID_TIE_FORMAT },
+      stack
+    });
+  }
+  if (!comparison?.different) {
+    return decorateResult({
+      result: { ...SUCCESS },
+      info: "Nothing to do",
+      stack
+    });
   }
   const existingCollectionIds = tieFormat.collectionDefinitions.map(
     ({ collectionId }) => collectionId
@@ -31207,13 +31261,18 @@ function modifyTieFormat$1({
   const addedCollectionDefinitions = modifiedTieFormat.collectionDefinitions.filter(
     ({ collectionId }) => !existingCollectionIds.includes(collectionId)
   );
+  const addedCollectionIds = addedCollectionDefinitions.map(extractAttributes("collectionId"));
   const modifications = [];
   let processedTieFormat;
+  const tieFormatName = modifiedTieFormat.tieFormatName;
   for (const collectionDefinition of modifiedTieFormat.collectionDefinitions) {
+    if (addedCollectionIds.includes(collectionDefinition.collectionId))
+      continue;
     const result2 = modifyCollectionDefinition$1({
       updateInProgressMatchUps,
       ...collectionDefinition,
       tournamentRecord,
+      tieFormatName,
       drawDefinition,
       structureId,
       matchUpId,
@@ -31227,7 +31286,6 @@ function modifyTieFormat$1({
     if (result2.tieFormat)
       processedTieFormat = result2.tieFormat;
   }
-  const tieFormatName = modifiedTieFormat.tieFormatName;
   for (const collectionDefinition of addedCollectionDefinitions) {
     const result2 = addCollectionDefinition$1({
       updateInProgressMatchUps,
@@ -31270,7 +31328,7 @@ function modifyTieFormat$1({
   if (changedTieFormatName) {
     processedTieFormat.tieFormatName = tieFormatName;
     modifications.push({ tieFormatName });
-  } else if (modifications.length) {
+  } else if (modifications.length || addedCollectionIds.length || removedCollectionIds.length) {
     delete processedTieFormat.tieFormatName;
     modifications.push(
       "tieFormatName removed: modifications without new tieFormatName"
@@ -31279,13 +31337,85 @@ function modifyTieFormat$1({
   processedTieFormat.collectionDefinitions = processedTieFormat.collectionDefinitions.sort(
     (a, b) => numericSortValue(a.collectionOrder) - numericSortValue(b.collectionOrder)
   ).map((def, i) => ({ ...def, collectionOrder: i + 1 }));
-  return { ...SUCCESS, processedTieFormat, modifications };
+  return {
+    processedTieFormat: copyTieFormat(processedTieFormat),
+    modifications,
+    ...SUCCESS
+  };
 }
 
 function modifyTieFormat(params) {
   return resolveTournamentRecord({ ...params, method: modifyTieFormat$1 });
 }
 
+function publicFindMatchUp(params) {
+  Object.assign(params, { inContext: true });
+  const { matchUp, error } = findMatchUp(params);
+  return { matchUp: makeDeepCopy(matchUp, true, true), error };
+}
+function findMatchUp({
+  participantsProfile,
+  afterRecoveryTimes,
+  tournamentRecord,
+  contextContent,
+  contextProfile,
+  drawDefinition,
+  matchUpId,
+  inContext,
+  eventId,
+  drawId,
+  event
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (typeof matchUpId !== "string")
+    return { error: MISSING_MATCHUP_ID };
+  if (!drawDefinition || !event) {
+    const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps ?? [];
+    const inContextMatchUp = matchUps.find(
+      (matchUp2) => matchUp2.matchUpId === matchUpId
+    );
+    if (!inContextMatchUp)
+      return { error: MATCHUP_NOT_FOUND };
+    ({ eventId, drawId } = inContextMatchUp);
+    ({ event, drawDefinition } = findEvent({
+      tournamentRecord,
+      eventId,
+      drawId
+    }));
+  }
+  if (!drawDefinition)
+    return { error: DRAW_DEFINITION_NOT_FOUND };
+  if (contextProfile && !contextContent)
+    contextContent = getContextContent({ tournamentRecord, contextProfile });
+  const additionalContext = {
+    surfaceCategory: event?.surfaceCategory ?? tournamentRecord.surfaceCategory,
+    indoorOutDoor: event?.indoorOutdoor ?? tournamentRecord.indoorOutdoor,
+    endDate: event?.endDate ?? tournamentRecord.endDate,
+    tournamentId: tournamentRecord.tournamentId,
+    eventId: eventId ?? event?.eventId,
+    drawId
+  };
+  const { participants: tournamentParticipants = [] } = hydrateParticipants({
+    participantsProfile,
+    tournamentRecord,
+    contextProfile,
+    inContext
+  });
+  const { matchUp, structure } = findMatchUp$1({
+    context: inContext ? additionalContext : void 0,
+    tournamentParticipants,
+    afterRecoveryTimes,
+    contextContent,
+    drawDefinition,
+    contextProfile,
+    matchUpId,
+    inContext,
+    event
+  });
+  return { matchUp, structure, drawDefinition };
+}
+
 function resetTieFormat$1({
   tournamentRecord,
   drawDefinition,
@@ -42689,11 +42819,7 @@ function positionByes({
 }
 
 function positionQualifiers(params) {
-  let { structure, structureId } = params;
-  if (!structure)
-    ({ structure } = findStructure(params));
-  if (!structureId)
-    ({ structureId } = structure);
+  const structure = params.structure ?? findStructure(params).structure;
   const stack = "positionQualifiers";
   const qualifierDrawPositions = [];
   if (structure.stage === CONSOLATION) {
@@ -43337,7 +43463,7 @@ function generateAndPopulatePlayoffStructures(params) {
     drawDefinition
   });
   if (!structure)
-    return decorateResult({ result: { error: STRUCTURE_NOT_FOUND } });
+    return decorateResult({ result: { error: STRUCTURE_NOT_FOUND }, stack });
   if (structure.structureType === CONTAINER || structure.structures) {
     return generateAndPopulateRRplayoffStructures({
       sourceStructureId: structure.structureId,
@@ -44151,11 +44277,11 @@ function attachStructures$1({
   links = [],
   event
 }) {
+  const stack = "attachStructures";
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
   if (!Array.isArray(structures) || !Array.isArray(links))
-    return decorateResult({ result: { error: INVALID_VALUES } });
-  const stack = "attachStructures";
+    return decorateResult({ result: { error: INVALID_VALUES }, stack });
   const linkHash = (link) => [
     link.source.structureId,
     link.source.roundNumber || link.source.finishingPositions?.join("|"),
@@ -45058,7 +45184,9 @@ function positionParticipantAction(params) {
     };
     addPositionActionTelemetry({ drawDefinition, positionAction });
     return decorateResult({
-      result: { ...SUCCESS, context: { removedParticipantId: removedParticipantId2 }, stack }
+      context: { removedParticipantId: removedParticipantId2 },
+      result: { ...SUCCESS },
+      stack
     });
   }
 }
@@ -45826,8 +45954,8 @@ function addEventEntries(params) {
   const removedEntries = [];
   if (extensions && (!Array.isArray(extensions) || !extensions.every(isValidExtension)) || extension && !isValidExtension({ extension })) {
     return decorateResult({
-      result: { error: INVALID_VALUES },
       context: definedAttributes({ extension, extensions }),
+      result: { error: INVALID_VALUES },
       info: "Invalid extension(s)",
       stack
     });
@@ -45932,8 +46060,8 @@ function addEventEntries(params) {
   const invalidParticipantIds = validParticipantIds.length !== participantIds.length;
   if (invalidParticipantIds)
     return decorateResult({
-      result: { error: INVALID_PARTICIPANT_IDS },
       context: { misMatchedGender, gender: event.gender },
+      result: { error: INVALID_PARTICIPANT_IDS },
       stack
     });
   if (autoEntryPositions) {
@@ -46891,10 +47019,6 @@ function removeDelegatedOutcome$1({ drawDefinition, event, matchUpId }) {
   });
 }
 
-function stringSort(a, b) {
-  return (a || "").localeCompare(b || "");
-}
-
 function generateCandidate({
   maxIterations = 4e3,
   // cap the processing intensity of the candidate generator
@@ -47492,19 +47616,17 @@ function setOrderOfFinish$1({
   const stack = "setOrderOfFinish";
   if (!Array.isArray(finishingOrder))
     return decorateResult({
-      result: {
-        error: INVALID_VALUES
-      },
       info: mustBeAnArray("finishingOrder"),
+      result: { error: INVALID_VALUES },
       stack
     });
   const { completedMatchUps, matchUpsMap } = getDrawMatchUps({
     inContext: true,
     drawDefinition
   });
-  const matchUpIds = completedMatchUps?.map(getMatchUpId) || [];
+  const matchUpIds = completedMatchUps?.map(getMatchUpId) ?? [];
   const targetMatchUpIds = finishingOrder.map(getMatchUpId);
-  const { matchUpTypes, roundNumbers, structureIds, matchUpTieIds } = (completedMatchUps || []).filter(({ matchUpId }) => targetMatchUpIds.includes(matchUpId)).reduce(
+  const { matchUpTypes, roundNumbers, structureIds, matchUpTieIds } = (completedMatchUps ?? []).filter(({ matchUpId }) => targetMatchUpIds.includes(matchUpId)).reduce(
     (aggregator, matchUp) => {
       const { matchUpTieId, matchUpType, roundNumber, structureId } = matchUp;
       if (!aggregator.matchUpTypes.includes(matchUpType))
@@ -47526,10 +47648,8 @@ function setOrderOfFinish$1({
   );
   if (matchUpTypes.length > 1 || matchUpTieIds.length > 1 || roundNumbers.length > 1 || structureIds.length > 1) {
     return decorateResult({
-      result: {
-        error: INVALID_VALUES
-      },
       info: "matchUpType, structureId and roundNumber must be equivalent",
+      result: { error: INVALID_VALUES },
       stack
     });
   }
@@ -47558,7 +47678,7 @@ function setOrderOfFinish$1({
   const otherCohortMatchUps = completedMatchUps?.filter(
     (matchUp) => matchUp.structureId === structureIds[0] && matchUp.roundNumber === roundNumbers[0] && matchUp.matchUpType === matchUpTypes[0] && matchUp.matchUpTieId === matchUpTieIds[0] && !targetedMatchUpIds.includes(matchUp.matchUpId)
   );
-  for (const matchUp of otherCohortMatchUps || []) {
+  for (const matchUp of otherCohortMatchUps ?? []) {
     const { orderOfFinish } = matchUp || {};
     if (orderOfFinish) {
       if (!isConvertableInteger(orderOfFinish))
@@ -47572,10 +47692,8 @@ function setOrderOfFinish$1({
   }
   if (uniqueValues(orderOfFinishValues).length !== orderOfFinishValues.length || Math.max(...orderOfFinishValues) > orderOfFinishValues.length) {
     return decorateResult({
-      result: {
-        error: INVALID_VALUES
-      },
       info: "Values not unique or greater than expected number of values",
+      result: { error: INVALID_VALUES },
       stack
     });
   }
@@ -50208,10 +50326,8 @@ function addIndividualParticipantIds({
     return decorateResult({ result: { error: PARTICIPANT_NOT_FOUND }, stack });
   if (groupingParticipant?.participantType && ![TEAM, GROUP].includes(groupingParticipant.participantType)) {
     return decorateResult({
-      result: {
-        error: INVALID_PARTICIPANT_TYPE
-      },
       context: { participantType: groupingParticipant.participantType },
+      result: { error: INVALID_PARTICIPANT_TYPE },
       stack
     });
   }
@@ -52241,7 +52357,7 @@ function assignTieMatchUpParticipantId(params) {
   const tieMatchUpSide = inContextTieMatchUp?.sides?.find(
     (side) => side.sideNumber === sideNumber
   );
-  const lineUp = dualMatchUpSide?.lineUp || getTeamLineUp({
+  const lineUp = dualMatchUpSide?.lineUp ?? getTeamLineUp({
     participantId: teamParticipantId,
     drawDefinition
   })?.lineUp;
@@ -54791,8 +54907,8 @@ function deleteDrawDefinitions({
   const auditTrail = [];
   if (!event?.drawDefinitions)
     return decorateResult({
-      result: { ...SUCCESS },
       info: "event has no drawDefinition",
+      result: { ...SUCCESS },
       stack
     });
   const eventDrawIds = event.drawDefinitions.map(({ drawId: drawId2 }) => drawId2);
@@ -54801,8 +54917,8 @@ function deleteDrawDefinitions({
   drawIds = drawIds.filter((drawId2) => eventDrawIds.includes(drawId2));
   if (!drawIds.length)
     return decorateResult({
-      result: { ...SUCCESS },
       info: "nothing to do; no matching drawIds in event.",
+      result: { ...SUCCESS },
       stack
     });
   const flightProfile = makeDeepCopy(
@@ -57656,6 +57772,7 @@ function addVoluntaryConsolationStructure(params) {
 }
 
 function prepareStage(params) {
+  const stack = "prepareStage";
   let { seedsCount } = params;
   const preparedStructureIds = params.preparedStructureIds || [];
   const {
@@ -57711,7 +57828,7 @@ function prepareStage(params) {
     ({ structureId: structureId2 }) => !preparedStructureIds.includes(structureId2)
   );
   if (!structure)
-    return decorateResult({ result: { error: STRUCTURE_NOT_FOUND } });
+    return decorateResult({ result: { error: STRUCTURE_NOT_FOUND }, stack });
   const structureId = structure?.structureId;
   const seedBlockInfo = structure ? getValidSeedBlocks({
     provisionalPositioning,
@@ -57834,7 +57951,7 @@ function prepareStage(params) {
     positionAssignments = result?.positionAssignments;
     positioningReport = result?.positioningReport;
     if (result.error) {
-      return decorateResult({ result, stack: "prepareStage" });
+      return decorateResult({ result, stack });
     }
   }
   return {
@@ -57980,10 +58097,8 @@ function generateDrawDefinition(params) {
   if (policyDefinitions) {
     if (typeof policyDefinitions !== "object") {
       return decorateResult({
-        result: {
-          info: "policyDefinitions must be an object",
-          error: INVALID_VALUES
-        },
+        info: "policyDefinitions must be an object",
+        result: { error: INVALID_VALUES },
         stack
       });
     } else {
@@ -58212,8 +58327,9 @@ function generateDrawDefinition(params) {
     for (const roundTargetProfile of params.qualifyingProfiles) {
       if (!Array.isArray(roundTargetProfile.structureProfiles))
         return decorateResult({
+          info: mustBeAnArray("structureProfiles"),
           result: { error: MISSING_VALUE },
-          info: mustBeAnArray("structureProfiles")
+          stack
         });
       roundTarget = roundTargetProfile.roundTarget || roundTarget;
       const sortedStructureProfiles = roundTargetProfile.structureProfiles?.sort(sequenceSort) || [];
@@ -58444,12 +58560,12 @@ function modifyEvent({
   const enteredParticipantIds = event?.entries?.filter(({ entryStatus }) => {
     const status = entryStatus;
     return [...STRUCTURE_SELECTED_STATUSES, ALTERNATE].includes(status);
-  }).map(({ participantId }) => participantId) || [];
+  }).map(({ participantId }) => participantId) ?? [];
   const enteredParticipants = enteredParticipantIds ? getParticipants$1({
     participantFilters: { participantIds: enteredParticipantIds },
     withIndividualParticipants: true,
     tournamentRecord
-  }).participants || [] : [];
+  }).participants ?? [] : [];
   const genderAccumulator = [];
   const enteredParticipantTypes = enteredParticipants.reduce(
     (types, participant) => {
@@ -58460,7 +58576,7 @@ function modifyEvent({
     []
   );
   const enteredParticipantGenders = unique(genderAccumulator);
-  const validGender = !enteredParticipantGenders.length || [MIXED, ANY].includes(eventUpdates.gender || "") || enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender;
+  const validGender = !enteredParticipantGenders.length || [MIXED, ANY].includes(eventUpdates.gender ?? "") || enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender;
   if (eventUpdates.gender && !validGender)
     return decorateResult({
       context: { gender: eventUpdates.gender },
@@ -58471,14 +58587,14 @@ function modifyEvent({
     SINGLES,
     TEAM$1
   ];
-  const validEventType = validEventTypes.includes(eventUpdates.eventType || "");
+  const validEventType = validEventTypes.includes(eventUpdates.eventType ?? "");
   if (eventUpdates.eventType && !validEventType)
     return decorateResult({
       context: { participantType: eventUpdates.eventType },
       result: { error: INVALID_VALUES }
     });
   if (eventUpdates.eventType)
-    event.eventType === eventUpdates.eventType;
+    event.eventType = eventUpdates.eventType;
   if (eventUpdates.eventName)
     event.eventName = eventUpdates.eventName;
   if (eventUpdates.gender)
@@ -59052,6 +59168,78 @@ function getParticipantSignInStatus({
   return timeItem && timeItem.itemValue === SIGNED_IN && SIGNED_IN;
 }
 
+function getTieFormat({
+  tournamentRecord,
+  // passed in automatically by tournamentEngine
+  drawDefinition,
+  // passed in automatically by tournamentEngine when drawId provided
+  structureId,
+  // optional - if only the default matchUpFormat for a structure is required
+  matchUpId,
+  // id of matchUp for which the scoped matchUpFormat(s) are desired
+  structure,
+  // optional optimization - when structure already known
+  eventId,
+  // optional - if only the default matchUpFormat for an event is required
+  drawId,
+  // avoid brute force search for matchUp
+  event
+  // passed in automatically by tournamentEngine when drawId or eventId provided
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!drawId && !event && !structureId && !matchUpId)
+    return decorateResult({
+      result: { error: MISSING_VALUE },
+      stack: "getTieFormat"
+    });
+  if (eventId && !event) {
+    event = tournamentRecord.events?.find((event2) => event2.eventId === eventId);
+  }
+  const matchUpResult = publicFindMatchUp({
+    tournamentRecord,
+    drawDefinition,
+    matchUpId,
+    drawId,
+    event
+  });
+  if (matchUpId && matchUpResult?.error) {
+    return matchUpResult;
+  } else if (!drawDefinition && matchUpResult?.drawDefinition) {
+    drawDefinition = matchUpResult?.drawDefinition;
+  }
+  structure = structure ?? matchUpResult?.structure;
+  if (!structure && structureId && !matchUpId) {
+    if (!drawDefinition)
+      return { error: MISSING_DRAW_ID };
+    const structureResult = findStructure({ drawDefinition, structureId });
+    if (structureResult.error)
+      return structureResult;
+    structure = structureResult.structure;
+  }
+  const structureDefaultTieFormat = (structure?.tieFormat || structure?.tieFormatId) && resolveTieFormat({ structure, drawDefinition, event })?.tieFormat;
+  const drawDefaultTieFormat = (drawDefinition?.tieFormat || drawDefinition?.tieFormatId) && resolveTieFormat({
+    drawDefinition,
+    event
+  })?.tieFormat;
+  const eventDefaultTieFormat = resolveTieFormat({ event })?.tieFormat;
+  const tieFormat = resolveTieFormat({
+    matchUp: matchUpResult?.matchUp,
+    drawDefinition,
+    structure,
+    event
+  })?.tieFormat;
+  return {
+    ...SUCCESS,
+    matchUp: matchUpResult?.matchUp,
+    structureDefaultTieFormat: copyTieFormat(structureDefaultTieFormat),
+    eventDefaultTieFormat: copyTieFormat(eventDefaultTieFormat),
+    drawDefaultTieFormat: copyTieFormat(drawDefaultTieFormat),
+    tieFormat: copyTieFormat(tieFormat),
+    structure
+  };
+}
+
 function getEventProperties({ tournamentRecord, event }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };