tods-competition-factory 1.7.13 → 1.7.14

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.13";
+  return "1.7.14";
 }
 
 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,7 +2558,7 @@ 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: {
@@ -2695,7 +2696,7 @@ function validateCollectionDefinition({
     errors.push(`collectionValue is not type number: ${collectionValue}`);
   }
   if (collectionValueProfiles) {
-    const result = validateCollectionValueProfile({
+    const result = validateCollectionValueProfiles({
       collectionValueProfiles,
       matchUpCount
     });
@@ -2726,7 +2727,7 @@ function checkTieFormat(tieFormat) {
   }
   return { tieFormat };
 }
-function validateCollectionValueProfile({
+function validateCollectionValueProfiles({
   collectionValueProfiles,
   matchUpCount
 }) {
@@ -16570,6 +16571,10 @@ function proConflicts({
   return { courtIssues, rowIssues };
 }
 
+function stringSort(a, b) {
+  return (a || "").localeCompare(b || "");
+}
+
 function getTieFormatDesc(tieFormat) {
   if (!tieFormat)
     return {};
@@ -16652,7 +16657,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 +16692,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 +16711,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 +16746,7 @@ function getCollectionsValue(definitions) {
     }
     return total;
   }, 0);
-  return { totalValue, totalMatchUps };
+  return { totalValue, totalMatchUps, invalidValues, assignmentValues };
 }
 
 function dehydrateMatchUps({ tournamentRecord }) {
@@ -29622,7 +29671,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 +29691,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 +29753,14 @@ function updateTieFormat({
   tieFormat,
   eventId,
   matchUp,
-  event
+  event,
+  uuids
 }) {
   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 +29774,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 +29782,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,9 +29791,17 @@ 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({
@@ -29697,44 +29809,64 @@ function updateTieFormat({
           info: "matchUp is IN_PROGRESS or COMPLETE"
         });
       }
+    } 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 +29877,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 +29893,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 +29945,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 +30081,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 +30108,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 +30193,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 +30211,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 +30221,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 +30523,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 +30659,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,
@@ -30631,7 +30820,7 @@ function addCollectionDefinition$1({
         structure: structure2,
         uuids
       });
-      modifiedStructureIds.push(structureId);
+      modifiedStructureIds.push(structure2.structureId);
       addedMatchUps.push(...result2.newMatchUps);
       targetMatchUps.push(...result2.targetMatchUps);
     }
@@ -30725,146 +30914,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 +31059,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,
@@ -31179,8 +31227,13 @@ function modifyTieFormat$1({
   event
 }) {
   const stack = "updateTieFormat";
-  if (!validateTieFormat(modifiedTieFormat))
-    return { error: INVALID_TIE_FORMAT };
+  if (!validateTieFormat({ tieFormat: modifiedTieFormat }).valid) {
+    return decorateResult({
+      result: { error: INVALID_TIE_FORMAT },
+      info: "falied validation",
+      stack
+    });
+  }
   const result = getTieFormat$1({
     drawDefinition,
     structureId,
@@ -31192,8 +31245,18 @@ 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 }
+    });
+  }
+  if (!comparison?.different) {
+    return decorateResult({ result: { ...SUCCESS }, info: "Nothing to do" });
   }
   const existingCollectionIds = tieFormat.collectionDefinitions.map(
     ({ collectionId }) => collectionId
@@ -31207,13 +31270,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 +31295,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 +31337,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 +31346,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,
@@ -46891,10 +47030,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
@@ -59052,6 +59187,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 };