tods-competition-factory 1.7.2 → 1.7.4

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.2";
+  return "1.7.4";
 }
 
 function getObjectTieFormat(obj) {
@@ -4404,6 +4404,7 @@ function getMatchUpFormatAverageTimes({
   });
 }
 
+const DYNAMIC = "DYNAMIC";
 const RANKING$1 = "RANKING";
 const RATING$2 = "RATING";
 const SCALE$1 = "SCALE";
@@ -6183,7 +6184,7 @@ function getRoundMatchUps$1({
     roundProfile[roundNumber].finishingRound = finishingRoundMap[roundNumber]?.finishingRound;
     roundProfile[roundNumber].roundName = finishingRoundMap[roundNumber]?.roundName;
     roundProfile[roundNumber].abbreviatedRoundName = finishingRoundMap[roundNumber]?.abbreviatedRoundName;
-    roundProfile[roundNumber].finishingPositionRange = roundMatchUps[roundNumber][0].finishingPositionRange;
+    roundProfile[roundNumber].finishingPositionRange = roundMatchUps[roundNumber]?.[0]?.finishingPositionRange;
     if (roundNumber === 1 || !roundProfile[roundNumber - 1]) {
       const orderedDrawPositions = currentRoundDrawPositions.sort(numericSort);
       const pairedDrawPositions = chunkArray(orderedDrawPositions, 2);
@@ -13381,21 +13382,27 @@ const ratingConstants = {
 const ratingsParameters = {
   [ELO]: { range: [0, 3e3], decimalsCount: 0, defaultInitialization: 1500 },
   [NTRP]: {
-    range: [1, 7],
-    decimalsCount: 1,
-    defaultInitialization: 3,
-    accessor: "dntrpRatingHundredths",
     accessors: ["ntrpRating", "dntrpRatingHundredths"],
-    attributes: { ustaRatingType: "" }
+    attributes: { ustaRatingType: "" },
+    accessor: "dntrpRatingHundredths",
+    defaultInitialization: 3,
+    decimalsCount: 1,
+    range: [1, 7]
   },
-  [UTR]: { range: [1, 16], decimalsCount: 2, defaultInitialization: 6 },
-  [WTN]: {
-    range: [40, 1],
+  [UTR]: {
+    defaultInitialization: 6,
+    accessors: ["utrRating"],
+    accessor: "utrRating",
     decimalsCount: 2,
+    range: [1, 16]
+  },
+  [WTN]: {
+    attributes: { confidence: { generator: true, range: [60, 100] } },
+    accessors: ["wtnRating", "confidence"],
     defaultInitialization: 23,
     accessor: "wtnRating",
-    accessors: ["wtnRating"],
-    attributes: { confidence: { generator: true, range: [60, 100] } }
+    decimalsCount: 2,
+    range: [40, 1]
   }
 };
 
@@ -28916,9 +28923,9 @@ function getParticipantEntries(params) {
               if (!participation)
                 return;
               if (!finishingPositionRange)
-                finishingPositionRange = participation.finishingPositionRange;
-              if (diff(finishingPositionRange) > diff(participation.finishingPositionRange))
-                finishingPositionRange = participation.finishingPositionRange;
+                finishingPositionRange = participation?.finishingPositionRange;
+              if (diff(finishingPositionRange) > diff(participation?.finishingPositionRange))
+                finishingPositionRange = participation?.finishingPositionRange;
               const notQualifying = participation.stage !== QUALIFYING;
               if (notQualifying)
                 nonQualifyingOrder += 1;
@@ -28929,8 +28936,10 @@ function getParticipantEntries(params) {
                 flightNumber
               });
             }).filter(Boolean);
-            participantAggregator.draws[drawId].finishingPositionRange = finishingPositionRange;
-            participantAggregator.draws[drawId].structureParticipation = orderedParticipation;
+            if (participantAggregator.draws[drawId]) {
+              participantAggregator.draws[drawId].finishingPositionRange = finishingPositionRange;
+              participantAggregator.draws[drawId].structureParticipation = orderedParticipation;
+            }
           }
         }
       }
@@ -39654,6 +39663,7 @@ function generateCurtisConsolation(params) {
     finishingPositionOffset,
     structureName = MAIN,
     stageSequence = 1,
+    structureNameMap,
     staggeredEntry,
     stage = MAIN,
     matchUpType,
@@ -39687,8 +39697,9 @@ function generateCurtisConsolation(params) {
     const consolationItems = feedRoundOffsets.map((roundOffset, index) => {
       const stageSequence2 = index + 1;
       const { consolationStructure } = consolationFeedStructure({
-        structureId: uuids?.pop(),
         idPrefix: idPrefix && `${idPrefix}-c${index}`,
+        structureId: uuids?.pop(),
+        structureNameMap,
         stageSequence: stageSequence2,
         roundOffset,
         matchUpType,
@@ -39717,9 +39728,9 @@ function generateCurtisConsolation(params) {
         isMock
       });
       const playoffStructure = structureTemplate({
+        structureName: structureNameMap?.[PLAY_OFF] || PLAY_OFF,
         structureId: uuids?.pop(),
         matchUps: playoffMatchUps,
-        structureName: PLAY_OFF,
         stageSequence: 2,
         stage: PLAY_OFF,
         matchUpType
@@ -39744,6 +39755,7 @@ function generateCurtisConsolation(params) {
 }
 function consolationFeedStructure({
   stageSequence = 1,
+  structureNameMap,
   roundOffset = 0,
   matchUpType,
   structureId,
@@ -39764,7 +39776,8 @@ function consolationFeedStructure({
     isMock,
     uuids
   });
-  const structureName = `${CONSOLATION} ${index + 1}`;
+  const defaultName = `${CONSOLATION} ${index + 1}`;
+  const structureName = structureNameMap?.[defaultName] || defaultName;
   const consolationStructure = structureTemplate({
     matchUps: consolationMatchUps,
     stage: CONSOLATION,
@@ -40049,6 +40062,7 @@ function processPlayoffGroups({
     }
     const params = {
       structureId: playoffGroup.structureId ?? uuids?.pop(),
+      structureNameMap: playoffGroup.structureNameMap,
       structureName: playoffGroup.structureName,
       idPrefix: idPrefix && `${idPrefix}-po`,
       appliedPolicies: policyDefinitions,
@@ -44332,21 +44346,30 @@ function generateAdHocMatchUps$1({
     structureId = drawDefinition.structures?.[0]?.structureId;
   if (typeof structureId !== "string")
     return { error: MISSING_STRUCTURE_ID };
-  if (newRound && !matchUpsCount) {
+  const structure = drawDefinition.structures?.find(
+    (structure2) => structure2.structureId === structureId
+  );
+  if (!structure)
+    return { error: STRUCTURE_NOT_FOUND };
+  if (!matchUpsCount) {
     const selectedEntries = drawDefinition?.entries?.filter((entry) => {
       const entryStatus = entry.entryStatus;
       return STRUCTURE_SELECTED_STATUSES.includes(entryStatus);
     }) ?? [];
-    matchUpsCount = Math.floor(selectedEntries?.length / 2) || 1;
+    const roundMatchUpsCount = Math.floor(selectedEntries?.length / 2) || 1;
+    if (newRound) {
+      matchUpsCount = roundMatchUpsCount;
+    } else {
+      const maxRemaining = roundMatchUpsCount - (structure.matchUps?.length || 0);
+      if (maxRemaining > 0)
+        matchUpsCount = maxRemaining;
+    }
   }
   if (participantIdPairings && !Array.isArray(participantIdPairings) || matchUpsCount && !isConvertableInteger(matchUpsCount) || matchUpIds && !Array.isArray(matchUpIds) || !participantIdPairings && !matchUpsCount) {
     return { error: INVALID_VALUES, info: "matchUpsCount or pairings error" };
   }
-  const structure = drawDefinition?.structures?.find(
-    (structure2) => structure2.structureId === structureId
-  );
   let structureHasRoundPositions;
-  const existingMatchUps = structure?.matchUps;
+  const existingMatchUps = structure.matchUps ?? [];
   const lastRoundNumber = existingMatchUps?.reduce(
     (roundNumber2, matchUp) => {
       if (matchUp.roundPosition)
@@ -44355,12 +44378,12 @@ function generateAdHocMatchUps$1({
     },
     0
   );
-  if (structure?.structures || structureHasRoundPositions || structure?.finishingPosition === ROUND_OUTCOME) {
+  if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
     return { error: INVALID_STRUCTURE };
   }
   if (roundNumber && roundNumber - 1 > (lastRoundNumber || 0))
     return { error: INVALID_VALUES, info: "roundNumber error" };
-  const nextRoundNumber = roundNumber ?? (newRound ? (lastRoundNumber ?? 0) + 1 : lastRoundNumber ?? 1);
+  const nextRoundNumber = roundNumber ?? (newRound && (lastRoundNumber ?? 0) + 1 || lastRoundNumber || 1);
   participantIdPairings = participantIdPairings ?? generateRange(0, matchUpsCount).map(() => ({
     participantIds: [void 0, void 0]
   }));
@@ -46701,60 +46724,93 @@ function removeDelegatedOutcome$1({ drawDefinition, event, matchUpId }) {
 }
 
 function generateCandidate({
-  maxIterations = 5e3,
+  maxIterations = 4e3,
   // cap the processing intensity of the candidate generator
   valueSortedPairings,
   // pairings sorted by value from low to high
   pairingValues,
+  valueObjects,
   deltaObjects
 }) {
-  const rankedMatchUpValues = Object.assign(
+  const pairingValueMap = Object.assign(
     {},
     ...valueSortedPairings.map((rm) => ({ [rm.pairing]: rm.value }))
   );
-  let candidate = roundCandidate({
-    rankedMatchUpValues,
+  const actors = Object.keys(pairingValues);
+  let proposedCandidates = [];
+  const initialProposal = roundCandidate({
+    actorsCount: actors.length,
     valueSortedPairings,
-    deltaObjects
+    pairingValueMap,
+    deltaObjects,
+    valueObjects
   });
-  let deltaCandidate = candidate;
-  const actors = Object.keys(pairingValues);
+  const candidateHashes = [candidateHash(initialProposal)];
+  proposedCandidates.push(initialProposal);
+  let lowCandidateValue = initialProposal.value;
+  let deltaCandidate = initialProposal;
   let candidatesCount = 0;
-  let iterations;
+  let iterations = 0;
   let opponentCount = actors.length;
+  let calculatedIterations;
   do {
     opponentCount -= 1;
-    iterations = actors.length * opponentCount * valueSortedPairings.length / 2;
-  } while (iterations > maxIterations && opponentCount > 2);
+    calculatedIterations = actors.length * pairingValues[actors[0]].length;
+  } while (calculatedIterations > maxIterations && opponentCount > 5);
   const stipulatedPairs = [];
   actors.forEach((actor) => {
     const participantIdPairings = pairingValues[actor];
     participantIdPairings.slice(0, opponentCount).forEach((pairing) => {
+      iterations += 1;
       const stipulatedPair = pairingHash(actor, pairing.opponent);
       if (!stipulatedPairs.includes(stipulatedPair)) {
         const proposed = roundCandidate({
           // each roundCandidate starts with stipulated pairings
           stipulated: [[actor, pairing.opponent]],
-          rankedMatchUpValues,
+          actorsCount: actors.length,
           valueSortedPairings,
-          deltaObjects
+          pairingValueMap,
+          deltaObjects,
+          valueObjects
         });
-        if (proposed.maxDelta < deltaCandidate.maxDelta)
-          deltaCandidate = proposed;
-        if (proposed.value < candidate.value)
-          candidate = proposed;
-        stipulatedPairs.push(stipulatedPair);
-        candidatesCount += 1;
+        if (!candidateHashes.includes(candidateHash(proposed))) {
+          candidateHashes.push(candidateHash(proposed));
+          proposedCandidates.push(proposed);
+          const { maxDelta, value } = proposed;
+          if (maxDelta < deltaCandidate.maxDelta)
+            deltaCandidate = proposed;
+          if (value < lowCandidateValue || value === lowCandidateValue && Math.round(Math.random())) {
+            lowCandidateValue = value;
+          }
+          stipulatedPairs.push(stipulatedPair);
+          candidatesCount += 1;
+        }
       }
     });
+    proposedCandidates = proposedCandidates.filter(
+      (proposed) => Math.abs(proposed.value - lowCandidateValue) < 5
+    );
   });
-  return { candidate, deltaCandidate, candidatesCount, iterations };
+  proposedCandidates.sort((a, b) => a.maxDiff - b.maxDiff);
+  const candidate = randomPop(proposedCandidates);
+  return {
+    candidatesCount,
+    deltaCandidate,
+    maxIterations,
+    iterations,
+    candidate
+  };
+}
+function candidateHash(candidate) {
+  return candidate.participantIdPairings.map(({ participantIds }) => participantIds.sort().join("|")).sort().join("/");
 }
 function roundCandidate({
-  rankedMatchUpValues,
   valueSortedPairings,
   stipulated = [],
-  deltaObjects
+  pairingValueMap,
+  deltaObjects,
+  valueObjects,
+  actorsCount
 }) {
   const roundPlayers = [].concat(...stipulated);
   const participantIdPairings = [];
@@ -46762,11 +46818,17 @@ function roundCandidate({
   stipulated.filter(Boolean).forEach((participantIds) => {
     const [p1, p2] = participantIds;
     const pairing = pairingHash(p1, p2);
-    const value = rankedMatchUpValues[pairing];
+    const value = pairingValueMap[pairing];
     participantIdPairings.push({ participantIds, value });
-    candidateValue += rankedMatchUpValues[pairing];
+    candidateValue += pairingValueMap[pairing];
   });
-  valueSortedPairings.forEach((rankedPairing) => {
+  const consideredPairings = chunkArray(valueSortedPairings, actorsCount).map(
+    (pairings) => shuffleArray(pairings).map((pairing) => ({
+      ...pairing,
+      value: pairing.value + Math.random() * Math.round(Math.random())
+    }))
+  ).flat();
+  consideredPairings.forEach((rankedPairing) => {
     const participantIds = rankedPairing.pairing.split("|");
     const opponentExists = participantIds.reduce(
       (p, c) => roundPlayers.includes(c) || p,
@@ -46786,15 +46848,154 @@ function roundCandidate({
     const delta = deltaObjects[hash];
     return delta > p ? delta : p;
   }, 0);
-  return { value: candidateValue, participantIdPairings, maxDelta };
+  const maxDiff = participantIdPairings.reduce((p, c) => {
+    const [p1, p2] = c.participantIds;
+    const hash = pairingHash(p1, p2);
+    const diff = valueObjects[hash];
+    return diff > p ? diff : p;
+  }, 0);
+  return { value: candidateValue, participantIdPairings, maxDelta, maxDiff };
 }
 function pairingHash(id1, id2) {
   return [id1, id2].sort().join("|");
 }
 
-const ENCOUNTER_VALUE = 50;
-const SAME_TEAM_VALUE = 60;
+function getPairingsData({ participantIds }) {
+  const possiblePairings = {};
+  const uniquePairings = [];
+  participantIds.forEach((participantId) => {
+    possiblePairings[participantId] = participantIds.filter(
+      (id) => id !== participantId
+    );
+    possiblePairings[participantId].forEach((id) => {
+      const pairing = pairingHash(id, participantId);
+      if (!uniquePairings.includes(pairing))
+        uniquePairings.push(pairing);
+    });
+  });
+  const deltaObjects = Object.assign(
+    {},
+    ...uniquePairings.map((pairing) => ({ [pairing]: 0 }))
+  );
+  return { uniquePairings, possiblePairings, deltaObjects };
+}
+
+function getEncounters({ matchUps }) {
+  const encounters = [];
+  for (const matchUp of matchUps) {
+    const participantIds = matchUp.sides.map(
+      extractAttributes("participantId")
+    );
+    if (participantIds.length === 2) {
+      const [p1, p2] = participantIds;
+      const pairing = pairingHash(p1, p2);
+      if (!encounters.includes(pairing))
+        encounters.push(pairing);
+    }
+  }
+  return { encounters };
+}
+
+function getParticipantPairingValues({
+  possiblePairings,
+  valueObjects
+}) {
+  const pairingValues = {};
+  for (const participantId of Object.keys(possiblePairings)) {
+    const participantValues = possiblePairings[participantId].map(
+      (opponent) => pairingValue(participantId, opponent)
+    );
+    pairingValues[participantId] = participantValues.sort(
+      (a, b) => a.value - b.value
+    );
+  }
+  function pairingValue(participantId, opponent) {
+    const key = pairingHash(participantId, opponent);
+    return { opponent, value: valueObjects[key] };
+  }
+  return { pairingValues };
+}
+
 const DEFAULT_RATING = 0;
+function getSideRatings({
+  tournamentParticipants,
+  adHocRatings,
+  eventType,
+  scaleName,
+  pairing
+}) {
+  const defaultRating = ratingsParameters[scaleName]?.defaultInitialization ?? DEFAULT_RATING;
+  return pairing.split("|").map((participantId) => {
+    if (eventType === DOUBLES) {
+      const individualParticipantIds = tournamentParticipants?.find(
+        (participant) => participant.participantId === participantId
+      )?.individualParticipantIds;
+      return !individualParticipantIds ? defaultRating * 2 : individualParticipantIds?.map(
+        (participantId2) => adHocRatings[participantId2] || defaultRating
+      );
+    } else {
+      return adHocRatings[participantId] || defaultRating;
+    }
+  });
+}
+
+function getPairings({
+  tournamentParticipants,
+  adHocRatings = {},
+  possiblePairings,
+  // participant keyed; provides array of possible opponents
+  uniquePairings,
+  // hashes of all possible participantId pairings
+  maxIterations,
+  deltaObjects,
+  // difference in rating between paired participants
+  valueObjects,
+  // calculated value of a pairing of participants, used for sorting pairings
+  eventType,
+  scaleName,
+  salted
+}) {
+  uniquePairings.forEach((pairing) => {
+    const ratings = getSideRatings({
+      tournamentParticipants,
+      adHocRatings,
+      scaleName,
+      eventType,
+      pairing
+    });
+    const salting = typeof salted === "number" && salted || 0.5;
+    const salt = salted && (Math.round(Math.random()) ? salting : salting * -1) || 0;
+    const ratingsDifference = Math.abs(ratings[0] - ratings[1]) + salt;
+    const pairingDelta = Math.abs(ratings[0] - ratings[1]);
+    deltaObjects[pairing] = pairingDelta;
+    if (!valueObjects[pairing])
+      valueObjects[pairing] = 0;
+    valueObjects[pairing] += ratingsDifference ? Math.pow(ratingsDifference, 2) : 0;
+  });
+  const valueSortedPairings = uniquePairings.map((pairing) => ({ pairing, value: valueObjects[pairing] })).sort((a, b) => a.value - b.value);
+  const { pairingValues } = getParticipantPairingValues({
+    possiblePairings,
+    valueObjects
+  });
+  const { candidate, candidatesCount, deltaCandidate, iterations } = generateCandidate({
+    valueSortedPairings,
+    maxIterations,
+    pairingValues,
+    deltaObjects,
+    valueObjects
+  });
+  const { participantIdPairings } = candidate;
+  return {
+    participantIdPairings,
+    candidatesCount,
+    deltaCandidate,
+    iterations,
+    candidate
+  };
+}
+
+const ENCOUNTER_VALUE = 100;
+const SAME_TEAM_VALUE = 100;
 const MAX_ITERATIONS = 5e3;
 function generateDrawMaticRound({
   maxIterations = MAX_ITERATIONS,
@@ -46806,9 +47007,11 @@ function generateDrawMaticRound({
   drawDefinition,
   adHocRatings,
   structureId,
+  salted = 0.5,
   matchUpIds,
   eventType,
-  structure
+  structure,
+  scaleName
 }) {
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
@@ -46857,7 +47060,9 @@ function generateDrawMaticRound({
     deltaObjects,
     valueObjects,
     eventType,
-    structure
+    scaleName,
+    structure,
+    salted
   };
   const { candidatesCount, participantIdPairings, iterations } = getPairings(params);
   if (!candidatesCount)
@@ -46885,118 +47090,11 @@ function generateDrawMaticRound({
     matchUps
   };
 }
-function getSideRatings({
-  tournamentParticipants,
-  adHocRatings,
-  eventType,
-  pairing
-}) {
-  return pairing.split("|").map((participantId) => {
-    if (eventType === DOUBLES) {
-      const individualParticipantIds = tournamentParticipants?.find(
-        (participant) => participant.participantId === participantId
-      )?.individualParticipantIds;
-      return !individualParticipantIds ? DEFAULT_RATING * 2 : individualParticipantIds?.map(
-        (participantId2) => adHocRatings[participantId2 || DEFAULT_RATING]
-      );
-    } else {
-      return adHocRatings[participantId] || DEFAULT_RATING;
-    }
-  });
-}
-function getPairings({
-  tournamentParticipants,
-  adHocRatings = {},
-  possiblePairings,
-  // participant keyed; provides array of possible opponents
-  uniquePairings,
-  // hashes of all possible participantId pairings
-  maxIterations,
-  deltaObjects,
-  // difference in rating between paired participants
-  valueObjects,
-  // calculated value of a pairing of participants, used for sorting pairings
-  eventType
-}) {
-  uniquePairings.forEach((pairing) => {
-    const ratings = getSideRatings({
-      tournamentParticipants,
-      adHocRatings,
-      eventType,
-      pairing
-    });
-    const ratingsDifference = Math.abs(ratings[0] - ratings[1]) + 1;
-    deltaObjects[pairing] = Math.abs(ratings[0] - ratings[1]);
-    if (!valueObjects[pairing])
-      valueObjects[pairing] = 0;
-    valueObjects[pairing] += Math.pow(ratingsDifference, 2);
-  });
-  const valueSortedPairings = uniquePairings.map((pairing) => ({ pairing, value: valueObjects[pairing] })).sort((a, b) => a.value - b.value);
-  const { pairingValues } = getParticipantPairingValues({
-    possiblePairings,
-    valueObjects
-  });
-  const { candidate, candidatesCount, iterations } = generateCandidate({
-    valueSortedPairings,
-    maxIterations,
-    pairingValues,
-    deltaObjects
-  });
-  const { participantIdPairings } = candidate;
-  return { candidatesCount, participantIdPairings, iterations };
-}
-function getPairingsData({ participantIds }) {
-  const possiblePairings = {};
-  const uniquePairings = [];
-  participantIds.forEach((participantId) => {
-    possiblePairings[participantId] = participantIds.filter(
-      (id) => id !== participantId
-    );
-    possiblePairings[participantId].forEach((id) => {
-      const pairing = pairingHash(id, participantId);
-      if (!uniquePairings.includes(pairing))
-        uniquePairings.push(pairing);
-    });
-  });
-  const deltaObjects = Object.assign(
-    {},
-    ...uniquePairings.map((pairing) => ({ [pairing]: 0 }))
-  );
-  return { uniquePairings, possiblePairings, deltaObjects };
-}
-function getEncounters({ matchUps }) {
-  const encounters = [];
-  for (const matchUp of matchUps) {
-    const participantIds = matchUp.sides.map(getParticipantId);
-    if (participantIds.length === 2) {
-      const [p1, p2] = participantIds;
-      const pairing = pairingHash(p1, p2);
-      if (!encounters.includes(pairing))
-        encounters.push(pairing);
-    }
-  }
-  return { encounters };
-}
-function getParticipantPairingValues({ possiblePairings, valueObjects }) {
-  const pairingValues = {};
-  for (const participantId of Object.keys(possiblePairings)) {
-    const participantValues = possiblePairings[participantId].map(
-      (opponent) => pairingValue(participantId, opponent)
-    );
-    pairingValues[participantId] = participantValues.sort(
-      (a, b) => a.value - b.value
-    );
-  }
-  function pairingValue(participantId, opponent) {
-    const key = pairingHash(participantId, opponent);
-    return { opponent, value: valueObjects[key] };
-  }
-  return { pairingValues };
-}
 
 function drawMatic$1({
   tournamentParticipants,
   restrictEntryStatus,
+  adHocRatings = {},
   tournamentRecord,
   generateMatchUps,
   addToStructure,
@@ -47051,12 +47149,16 @@ function drawMatic$1({
   if (!structureIsAdHoc)
     return { error: INVALID_DRAW_DEFINITION };
   tournamentParticipants = tournamentParticipants ?? tournamentRecord.participants ?? [];
-  const adHocRatings = {};
   for (const participantId of participantIds ?? []) {
     const participant = tournamentParticipants?.find(
       (participant2) => participant2.participantId === participantId
     );
-    let scaleValue = getScaleValue({ eventType, participant });
+    let scaleValue = getScaleValue({
+      scaleName: `${scaleName}.${DYNAMIC}`,
+      scaleAccessor,
+      participant,
+      eventType
+    });
     if (!scaleValue && scaleName) {
       scaleValue = getScaleValue({
         scaleAccessor,
@@ -47065,7 +47167,7 @@ function drawMatic$1({
         eventType
       });
     }
-    if (scaleValue)
+    if (scaleValue && !adHocRatings[participantId])
       adHocRatings[participantId] = scaleValue;
   }
   return generateDrawMaticRound({
@@ -47083,14 +47185,15 @@ function drawMatic$1({
   });
 }
 function getScaleValue({
-  eventType = TypeEnum.Singles,
-  scaleName = "dynamic",
+  scaleType = RATING$2,
   scaleAccessor,
-  participant
+  participant,
+  scaleName,
+  eventType
 }) {
   const scaleAttributes = {
     eventType: eventType || TypeEnum.Singles,
-    scaleType: RATING$2,
+    scaleType,
     scaleName
   };
   const result = participant && participantScaleItem({
@@ -59464,11 +59567,15 @@ function calculateNewRatings(params) {
     targetRange: consideredRange
   });
   const updatedWinnerRating = invertedScale ? ratingRange[0] - convertedUpdatedWinnerRating : convertedUpdatedWinnerRating;
-  let newWinnerRating = parseFloat(updatedWinnerRating).toFixed(decimalPlaces);
+  let newWinnerRating = parseFloat(
+    parseFloat(updatedWinnerRating).toFixed(decimalPlaces)
+  );
   const updatedLoserRating = invertedScale ? ratingRange[0] - convertedUpdatedLoserRating : convertedUpdatedLoserRating;
-  let newLoserRating = parseFloat(updatedLoserRating).toFixed(decimalPlaces);
+  let newLoserRating = parseFloat(
+    parseFloat(updatedLoserRating).toFixed(decimalPlaces)
+  );
   const percentageDifference = Math.max(...ratingRange) ? Math.abs(winnerRating - loserRating) / Math.max(...ratingRange) : 0;
-  if (convertedUpdatedWinnerRating > convertedUpdatedLoserRating && percentageDifference > eloConfig.diffThreshold || parseFloat(newWinnerRating) < 0 || parseFloat(newLoserRating) < 0) {
+  if (convertedUpdatedWinnerRating > convertedUpdatedLoserRating && percentageDifference > eloConfig.diffThreshold || newWinnerRating < 0 || newLoserRating < 0) {
     newWinnerRating = winnerRating;
     newLoserRating = loserRating;
   }
@@ -59486,7 +59593,8 @@ const aggregateSets = (sets) => {
   ) || [0, 0];
 };
 
-function processMatchUps({
+function generateDynamicRatings({
+  removePriorValues = true,
   tournamentRecord,
   ratingType = ELO,
   considerGames,
@@ -59517,7 +59625,7 @@ function processMatchUps({
       scaleName: ratingType,
       scaleType: RATING$2
     };
-    const dynamicScaleName = `${ratingType}.DYNAMIC`;
+    const dynamicScaleName = `${ratingType}.${DYNAMIC}`;
     const dynamicScaleAttributes = {
       scaleName: dynamicScaleName,
       eventType: matchUpType,
@@ -59553,9 +59661,9 @@ function processMatchUps({
         return participantId && {
           [participantId]: dynamicScaleItem ?? scaleItem ?? {
             scaleName: outputScaleName,
-            scaleType: RATING$2,
             eventType: matchUpType,
             scaleDate: endDate,
+            scaleType: RATING$2,
             scaleValue
           }
         };
@@ -59584,27 +59692,35 @@ function processMatchUps({
           loserRating,
           ratingType
         });
-        const newWinnerScaleValue = accessor ? { ...winnerScaleValue, [accessor]: newWinnerRating } : newWinnerRating;
-        const newLoserScaleValue = accessor ? { ...loserScaleValue, [accessor]: newLoserRating } : newLoserRating;
+        const newWinnerScaleValue = accessor ? {
+          ...winnerScaleValue,
+          [accessor]: newWinnerRating
+        } : newWinnerRating;
+        const newLoserScaleValue = accessor ? {
+          ...loserScaleValue,
+          [accessor]: newLoserRating
+        } : newLoserRating;
         scaleItemMap[winnerParticipantId].scaleValue = newWinnerScaleValue;
         scaleItemMap[loserParticipantId].scaleValue = newLoserScaleValue;
         let result = setParticipantScaleItem({
+          participantId: winnerParticipantId,
+          removePriorValues,
+          tournamentRecord,
           scaleItem: {
             ...scaleItemMap[winnerParticipantId],
             scaleName: outputScaleName
-          },
-          participantId: winnerParticipantId,
-          tournamentRecord
+          }
         });
         if (result.error)
           return result;
         result = setParticipantScaleItem({
+          participantId: loserParticipantId,
+          removePriorValues,
+          tournamentRecord,
           scaleItem: {
             ...scaleItemMap[loserParticipantId],
             scaleName: outputScaleName
-          },
-          participantId: loserParticipantId,
-          tournamentRecord
+          }
         });
         if (result.error)
           return result;
@@ -59618,7 +59734,7 @@ function processMatchUps({
 
 const governor = {
   calculateNewRatings,
-  processMatchUps
+  generateDynamicRatings
 };
 
 const scaleEngine = (() => {