tods-competition-factory 1.7.12 → 1.7.14

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.12";
+  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 }) {
@@ -29569,6 +29618,7 @@ function getTieFormat$1({
   // optional - if an eventId is present only return tieFormat for event
   event
 }) {
+  const stack = "getTieFormat";
   let tieFormat;
   structureId = structure?.structureId ?? structureId;
   matchUpId = matchUp?.matchUpId ?? matchUpId;
@@ -29584,6 +29634,9 @@ function getTieFormat$1({
       });
       if (result.error)
         return result;
+      if (result.matchUp?.matchUpType !== TEAM_MATCHUP) {
+        return decorateResult({ result: { error: INVALID_MATCHUP }, stack });
+      }
       if (!structure)
         structure = result.structure;
       if (!matchUp)
@@ -29617,8 +29670,13 @@ function getTieFormat$1({
     tieFormat = getObjectTieFormat(drawDefinition) || getObjectTieFormat(event);
   }
   if (!tieFormat)
-    return decorateResult({ result: { error: MISSING_TIE_FORMAT } });
-  return { ...SUCCESS, tieFormat, matchUp, structure };
+    return decorateResult({ result: { error: MISSING_TIE_FORMAT }, stack });
+  return {
+    ...SUCCESS,
+    structure,
+    tieFormat,
+    matchUp
+  };
 }
 
 function tieFormatTelemetry({ drawDefinition, auditData }) {
@@ -29633,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,
@@ -29649,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) => {
@@ -29666,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;
@@ -29674,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) {
@@ -29683,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({
@@ -29693,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 = [];
@@ -29741,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);
       }
@@ -29756,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,
@@ -29791,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({
@@ -29800,9 +30026,9 @@ function modifyCollectionDefinition$1({
   tournamentRecord,
   collectionOrder,
   collectionName,
+  tieFormatName,
   drawDefinition,
   matchUpFormat,
-  tieFormatName,
   matchUpCount,
   collectionId,
   matchUpType,
@@ -29819,19 +30045,35 @@ function modifyCollectionDefinition$1({
   scoreValue,
   setValue
 }) {
+  const stack = "modifyCollectionDefinition";
   if (matchUpFormat && !isValid(matchUpFormat)) {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { matchUpFormat },
+      stack
+    });
   }
   if (collectionName && typeof collectionName !== "string") {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { collectionName },
+      stack
+    });
   }
   if (gender && !Object.values(genderConstants).includes(gender)) {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { gender },
+      stack
+    });
   }
   if (category && typeof category !== "object") {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { category },
+      stack
+    });
   }
-  const stack = "modifyCollectionDefinition";
   const valueAssignments = {
     collectionValueProfiles,
     collectionValue,
@@ -29839,14 +30081,12 @@ 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({
-      result: {
-        info: "Only one value assignment allowed per collectionDefinition",
-        error: INVALID_VALUES
-      },
+      info: "Only one value assignment allowed per collectionDefinition",
+      result: { error: INVALID_VALUES },
       stack
     });
   let result = getTieFormat$1({
@@ -29856,81 +30096,141 @@ function modifyCollectionDefinition$1({
     eventId,
     event
   });
-  if (result.error)
+  if (result.error) {
     return decorateResult({ result, stack });
+  }
   const { matchUp, structure, tieFormat: existingTieFormat } = result;
   const tieFormat = copyTieFormat(existingTieFormat);
-  const collectionDefinition = tieFormat.collectionDefinitions.find(
-    (collectionDefinition2) => collectionDefinition2.collectionId === collectionId
+  const sourceCollectionDefinition = existingTieFormat?.collectionDefinitions.find(
+    (collectionDefinition) => collectionDefinition.collectionId === collectionId
   );
-  if (!collectionDefinition)
-    return decorateResult({ result: { error: NOT_FOUND }, stack });
-  const value = collectionValue || matchUpValue || scoreValue || setValue;
-  if (value || collectionValueProfiles) {
-    if (value) {
-      if (!isConvertableInteger(value))
-        return decorateResult({ result: { error: INVALID_VALUES, value } });
-    } else if (collectionValueProfiles) {
-      const result2 = validateCollectionValueProfile({
-        matchUpCount: collectionDefinition.matchUpCount,
-        collectionValueProfiles
-      });
-      if (result2.errors) {
-        return decorateResult({
-          result: { error: INVALID_VALUES, info: result2.errors },
-          stack
-        });
-      }
+  const targetCollectionDefinition = tieFormat?.collectionDefinitions.find(
+    (collectionDefinition) => collectionDefinition.collectionId === collectionId
+  );
+  if (!sourceCollectionDefinition)
+    return decorateResult({
+      info: "source collectionDefinition",
+      result: { error: NOT_FOUND },
+      context: { collectionId },
+      stack
+    });
+  const value = collectionValue ?? matchUpValue ?? scoreValue ?? setValue;
+  if (collectionValueProfiles) {
+    const result2 = validateCollectionValueProfiles({
+      matchUpCount: matchUpCount ?? sourceCollectionDefinition?.matchUpCount,
+      collectionValueProfiles
+    });
+    if (result2.errors) {
+      return decorateResult({
+        result: { error: INVALID_VALUES },
+        info: result2.errors,
+        stack
+      });
     }
-    collectionDefinition.collectionValue = void 0;
-    collectionDefinition.matchUpValue = void 0;
-    collectionDefinition.scoreValue = void 0;
-    collectionDefinition.setValue = void 0;
-    Object.assign(collectionDefinition, valueAssignments);
+  } else if (value && !isConvertableInteger(value)) {
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      info: "value is not an integer",
+      context: { value },
+      stack
+    });
   }
-  if ((scoreValue || setValue) && collectionDefinition.collectionGroupNumber) {
-    const targetCollectionGroupNumber = collectionDefinition.collectionGroupNumber;
+  const equivalentValueProfiles = (a, b) => intersection(Object.keys(a), Object.keys(b)).length === Object.keys(a).length && intersection(Object.values(a), Object.values(b)).length === Object.values(a).length;
+  const valueProfileModified = collectionValueProfiles && (!sourceCollectionDefinition.collectionValueProfiles || !equivalentValueProfiles(
+    sourceCollectionDefinition.collectionValueProfiles,
+    collectionValueProfiles
+  ));
+  const valueModified = isConvertableInteger(collectionValue) && sourceCollectionDefinition.collectionValue !== collectionValue || isConvertableInteger(matchUpValue) && sourceCollectionDefinition.matchUpValue !== matchUpValue || isConvertableInteger(scoreValue) && sourceCollectionDefinition.scoreValue !== scoreValue || isConvertableInteger(setValue) && sourceCollectionDefinition.setValue !== setValue || valueProfileModified;
+  const modifications = [];
+  if (valueModified) {
+    targetCollectionDefinition.collectionValueProfiles = void 0;
+    targetCollectionDefinition.collectionValue = void 0;
+    targetCollectionDefinition.matchUpValue = void 0;
+    targetCollectionDefinition.scoreValue = void 0;
+    targetCollectionDefinition.setValue = void 0;
+    Object.assign(targetCollectionDefinition, valueAssignments);
+    modifications.push({
+      collectionId,
+      ...definedAttributes(valueAssignments)
+    });
+  }
+  if ((isConvertableInteger(scoreValue) || isConvertableInteger(setValue)) && targetCollectionDefinition.collectionGroupNumber) {
+    const targetCollectionGroupNumber = targetCollectionDefinition.collectionGroupNumber;
     tieFormat.collectionDefinitions = tieFormat.collectionDefinitions.map(
-      (collectionDefinition2) => {
-        const { collectionGroupNumber, ...rest } = collectionDefinition2;
+      (collectionDefinition) => {
+        const { collectionGroupNumber, ...rest } = collectionDefinition;
         if (collectionGroupNumber === targetCollectionGroupNumber) {
           return rest;
         } else {
-          return collectionDefinition2;
+          return collectionDefinition;
         }
       }
     );
     tieFormat.collectionGroups = tieFormat.collectionGroups.filter(
       ({ groupNumber }) => groupNumber !== targetCollectionGroupNumber
     );
+    modifications.push({
+      collectionId,
+      change: "collectionGroupNumber removed"
+    });
   }
   const { aggregateValue, valueGoal } = calculateWinCriteria(tieFormat);
-  tieFormat.winCriteria = definedAttributes({ aggregateValue, valueGoal });
-  const originalValueGoal = existingTieFormat?.winCriteria.valueGoal;
-  const wasAggregateValue = existingTieFormat?.winCriteria.aggregateValue;
-  if (originalValueGoal && originalValueGoal !== valueGoal || aggregateValue && !wasAggregateValue) {
-    delete tieFormat.tieFormatName;
-  }
-  if (tieFormatName)
-    tieFormat.tieFormatName = tieFormatName;
-  if (collectionOrder)
-    collectionDefinition.collectionOrder = collectionOrder;
-  if (collectionName)
-    collectionDefinition.collectionName = collectionName;
-  if (matchUpFormat)
-    collectionDefinition.matchUpFormat = matchUpFormat;
-  if (matchUpType)
-    collectionDefinition.matchUpType = matchUpType;
-  if (category)
-    collectionDefinition.category = category;
-  if (gender)
-    collectionDefinition.gender = gender;
-  const prunedTieFormat = definedAttributes(tieFormat);
-  result = validateTieFormat({ tieFormat: prunedTieFormat });
-  if (result.error)
+  const winCriteria = definedAttributes({ aggregateValue, valueGoal });
+  if (winCriteria.aggregateValue !== existingTieFormat?.winCriteria.aggregateValue || winCriteria.valueGoal !== existingTieFormat?.winCriteria.valueGoal) {
+    tieFormat.winCriteria = winCriteria;
+    modifications.push({ collectionId, winCriteria });
+  }
+  if (isConvertableInteger(collectionOrder) && sourceCollectionDefinition.collectionOrder !== collectionOrder) {
+    targetCollectionDefinition.collectionOrder = collectionOrder;
+    modifications.push({ collectionId, collectionOrder });
+  }
+  if (collectionName && sourceCollectionDefinition.collectionName !== collectionName) {
+    targetCollectionDefinition.collectionName = collectionName;
+    modifications.push({ collectionId, collectionName });
+  }
+  if (matchUpFormat && sourceCollectionDefinition.matchUpFormat !== matchUpFormat) {
+    targetCollectionDefinition.matchUpFormat = matchUpFormat;
+    modifications.push({ collectionId, matchUpFormat });
+  }
+  if (isConvertableInteger(matchUpCount) && sourceCollectionDefinition.matchUpCount !== matchUpCount) {
+    targetCollectionDefinition.matchUpCount = matchUpCount;
+    modifications.push({ collectionId, matchUpCount });
+  }
+  if (matchUpType && sourceCollectionDefinition.matchUpType !== matchUpType) {
+    return decorateResult({
+      result: { error: NOT_IMPLEMENTED },
+      context: { matchUpType },
+      stack
+    });
+  }
+  if (category && sourceCollectionDefinition.category !== category) {
+    targetCollectionDefinition.category = category;
+    modifications.push({ collectionId, category });
+  }
+  if (gender && sourceCollectionDefinition.gender !== gender) {
+    targetCollectionDefinition.gender = gender;
+    modifications.push({ collectionId, gender });
+  }
+  const modifiedTieFormat = definedAttributes(tieFormat);
+  result = validateTieFormat({ tieFormat: modifiedTieFormat });
+  if (result.error) {
     return decorateResult({ result, stack });
+  }
+  if (!modifications.length) {
+    return decorateResult({ result: { ...SUCCESS, modifications } });
+  }
+  const changedTieFormatName = existingTieFormat?.tieFormatName !== tieFormatName;
+  if (changedTieFormatName) {
+    modifiedTieFormat.tieFormatName = tieFormatName;
+    modifications.push({ tieFormatName });
+  } else if (modifications.length) {
+    delete modifiedTieFormat.tieFormatName;
+    modifications.push(
+      "tieFormatName removed: modifications without new tieFormatName"
+    );
+  }
   result = updateTieFormat({
-    tieFormat: prunedTieFormat,
+    tieFormat: modifiedTieFormat,
     updateInProgressMatchUps,
     tournamentRecord,
     drawDefinition,
@@ -29943,8 +30243,8 @@ function modifyCollectionDefinition$1({
     const { appliedPolicies } = getAppliedPolicies({ tournamentRecord });
     if (appliedPolicies?.audit?.[TIE_FORMAT_MODIFICATIONS]) {
       const auditData = definedAttributes({
+        collectionDefinition: targetCollectionDefinition,
         drawId: drawDefinition?.drawId,
-        collectionDefinition,
         action: stack,
         structureId,
         matchUpId,
@@ -29953,7 +30253,7 @@ function modifyCollectionDefinition$1({
       tieFormatTelemetry({ drawDefinition, auditData });
     }
   }
-  return decorateResult({ result, stack });
+  return decorateResult({ result: { ...result, modifications }, stack });
 }
 
 function resolveTournamentRecord(params) {
@@ -30223,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(
@@ -30359,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,
@@ -30448,10 +30713,10 @@ function addCollectionDefinition$1({
       ({ collectionId }) => collectionId
     );
     if (collectionIds.includes(collectionDefinition.collectionId))
-      return {
-        collectionId: collectionDefinition.collectionId,
-        error: DUPLICATE_VALUE
-      };
+      return decorateResult({
+        context: { collectionId: collectionDefinition.collectionId },
+        result: { error: DUPLICATE_VALUE }
+      });
   }
   tieFormat.collectionDefinitions.push(collectionDefinition);
   tieFormat.collectionDefinitions.sort((a, b) => (a.collectionOrder || 0) - (b.collectionOrder || 0)).forEach(
@@ -30524,7 +30789,10 @@ function addCollectionDefinition$1({
     });
   } else if (matchUpId && matchUp) {
     if (!validUpdate({ matchUp, updateInProgressMatchUps }))
-      return { error: CANNOT_MODIFY_TIEFORMAT };
+      return decorateResult({
+        result: { error: CANNOT_MODIFY_TIEFORMAT },
+        stack
+      });
     matchUp.tieFormat = prunedTieFormat;
     const newMatchUps = generateCollectionMatchUps({
       collectionDefinition,
@@ -30552,7 +30820,7 @@ function addCollectionDefinition$1({
         structure: structure2,
         uuids
       });
-      modifiedStructureIds.push(structureId);
+      modifiedStructureIds.push(structure2.structureId);
       addedMatchUps.push(...result2.newMatchUps);
       targetMatchUps.push(...result2.targetMatchUps);
     }
@@ -30579,10 +30847,10 @@ function addCollectionDefinition$1({
     tieFormatTelemetry({ drawDefinition, auditData });
   }
   return {
-    ...SUCCESS,
     tieFormat: prunedTieFormat,
     targetMatchUps,
-    addedMatchUps
+    addedMatchUps,
+    ...SUCCESS
   };
 }
 function updateStructureMatchUps({
@@ -30646,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,
@@ -30931,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,
@@ -31100,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,
@@ -31113,40 +31245,51 @@ function modifyTieFormat$1({
     return decorateResult({ result, stack });
   const { matchUp, tieFormat: existingTieFormat } = result;
   const tieFormat = copyTieFormat(existingTieFormat);
+  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
   );
-  const modifiedCollectionDefinitions = [];
-  const addedCollectionDefinitions = [];
-  const updatedCollectionIds = [];
-  modifiedTieFormat.collectionDefinitions.forEach((def) => {
-    updatedCollectionIds.push(def.collectionId);
-    if (modifiedTieFormat && existingCollectionIds.includes(def.collectionId)) {
-      compareTieFormats({
-        descendant: modifiedTieFormat,
-        ancestor: tieFormat
-      })?.different && modifiedCollectionDefinitions.push(def);
-    } else {
-      addedCollectionDefinitions.push(def);
-    }
-  });
+  const updatedCollectionIds = modifiedTieFormat.collectionDefinitions.map(
+    ({ collectionId }) => collectionId
+  );
   const removedCollectionIds = existingCollectionIds.filter(
     (collectionId) => !updatedCollectionIds.includes(collectionId)
   );
-  const tieFormatName = modifiedTieFormat.tieFormatName;
+  const addedCollectionDefinitions = modifiedTieFormat.collectionDefinitions.filter(
+    ({ collectionId }) => !existingCollectionIds.includes(collectionId)
+  );
+  const addedCollectionIds = addedCollectionDefinitions.map(extractAttributes("collectionId"));
+  const modifications = [];
   let processedTieFormat;
-  for (const collectionDefinition of modifiedCollectionDefinitions) {
+  const tieFormatName = modifiedTieFormat.tieFormatName;
+  for (const collectionDefinition of modifiedTieFormat.collectionDefinitions) {
+    if (addedCollectionIds.includes(collectionDefinition.collectionId))
+      continue;
     const result2 = modifyCollectionDefinition$1({
       updateInProgressMatchUps,
       ...collectionDefinition,
       tournamentRecord,
-      drawDefinition,
       tieFormatName,
+      drawDefinition,
       structureId,
       matchUpId,
       eventId,
       event
     });
+    if (result2.modifications)
+      modifications.push(...result2.modifications);
     if (result2.error)
       return decorateResult({ result: result2, stack });
     if (result2.tieFormat)
@@ -31190,16 +31333,98 @@ function modifyTieFormat$1({
     if (result2.tieFormat)
       processedTieFormat = result2.tieFormat;
   }
+  const changedTieFormatName = existingTieFormat?.tieFormatName !== tieFormatName;
+  if (changedTieFormatName) {
+    processedTieFormat.tieFormatName = tieFormatName;
+    modifications.push({ tieFormatName });
+  } else if (modifications.length || addedCollectionIds.length || removedCollectionIds.length) {
+    delete processedTieFormat.tieFormatName;
+    modifications.push(
+      "tieFormatName removed: modifications without new tieFormatName"
+    );
+  }
   processedTieFormat.collectionDefinitions = processedTieFormat.collectionDefinitions.sort(
     (a, b) => numericSortValue(a.collectionOrder) - numericSortValue(b.collectionOrder)
   ).map((def, i) => ({ ...def, collectionOrder: i + 1 }));
-  return { ...SUCCESS, processedTieFormat };
+  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,
@@ -46805,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
@@ -58966,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 };