tods-competition-factory 0.201.2 → 0.202.0

package/dist/tods-competition-factory.development.cjs.js

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.201.2';
+  return '0.202.0';
 }
 
 function decorateResult({
@@ -258,9 +258,10 @@ function decorateResult({
   context,
   info
 }) {
-  if (stack && result.error) {
-    if (!result.error.stack) result.error.stack = [];
-    result.error.stack.push(stack);
+  if (!result.stack) result.stack = [];
+
+  if (stack) {
+    result.stack.push(stack);
   }
 
   if (info && result.error) {
@@ -303,7 +304,7 @@ function isConvertableInteger(n) {
   return Number.isSafeInteger(typeof n === 'string' ? +n : n);
 } // produces an approximated normal distribution between 0 and max
 
-function weightedRandom(max = 1, weight, round = true) {
+function weightedRandom(max = 1, weight = 3, round = true) {
   let num = 0;
 
   for (let i = 0; i < weight; i++) {
@@ -4027,7 +4028,7 @@ function getHighTiebreakValue({
   lowValue = 0,
   NoAD = false,
   tiebreakTo
-}) {
+} = {}) {
   const winBy = NoAD ? 1 : 2;
 
   if (lowValue + 1 >= tiebreakTo) {
@@ -5562,7 +5563,7 @@ function findCategoryTiming({
 function findMatchupFormatAverageTimes({
   matchUpAverageTimes,
   matchUpFormat
-}) {
+} = {}) {
   // first find all matchUpAverageTime definitions which include matchUpFormats...
   // ... that either exactly match or start with the target matchUpFormat.
   const codeMatches = (matchUpAverageTimes === null || matchUpAverageTimes === void 0 ? void 0 : matchUpAverageTimes.map(({
@@ -5586,7 +5587,7 @@ function findMatchupFormatRecoveryTimes({
   matchUpRecoveryTimes,
   averageMinutes,
   matchUpFormat
-}) {
+} = {}) {
   var _matchUpRecoveryTimes;
 
   return matchUpRecoveryTimes === null || matchUpRecoveryTimes === void 0 ? void 0 : (_matchUpRecoveryTimes = matchUpRecoveryTimes.find(({
@@ -7102,7 +7103,7 @@ function getRoundMatchUps$1({
 
 function getMatchUpType({
   matchUp = {}
-}) {
+} = {}) {
   var _matchUp$sides;
 
   let matchUpType = matchUp.matchUpType;
@@ -7465,7 +7466,7 @@ function isValidExtension(extension) {
 function addExtension$1({
   element,
   extension
-}) {
+} = {}) {
   if (!element) return {
     error: MISSING_VALUE
   };
@@ -7496,7 +7497,7 @@ function addExtension$1({
 function removeExtension$1({
   element,
   name
-}) {
+} = {}) {
   if (!element) return {
     error: MISSING_VALUE
   };
@@ -8703,6 +8704,7 @@ function filterMatchUps(params) {
     roundNumbers,
     matchUpIds,
     // only applies to inContext matchUps and only when processContext boolean is true
+    stageSequences,
     scheduledDates,
     scheduledDate,
     processContext,
@@ -8718,6 +8720,7 @@ function filterMatchUps(params) {
   } = params;
   const targetMatchUpStatuses = Array.isArray(matchUpStatuses) ? matchUpStatuses.filter(Boolean) : [];
   const targetStages = Array.isArray(stages) ? stages.filter(Boolean) : [];
+  const targetStageSequences = Array.isArray(stageSequences) ? stageSequences.filter(Boolean) : [];
   const targetCollectionIds = Array.isArray(collectionIds) ? collectionIds.filter(Boolean) : [];
   const targetRoundNumbers = Array.isArray(roundNumbers) ? roundNumbers.filter(Boolean) : [];
   const targetRoundPositions = Array.isArray(roundPositions) ? roundPositions.filter(Boolean) : [];
@@ -8758,6 +8761,10 @@ function filterMatchUps(params) {
       return false;
     }
 
+    if (targetStageSequences.length && !targetStageSequences.includes(matchUp.stageSequence)) {
+      return false;
+    }
+
     if (targetCollectionIds.length && !targetCollectionIds.includes(matchUp.collectionId)) {
       return false;
     }
@@ -11946,8 +11953,8 @@ function getStructureLinks({
  */
 
 function positionTargets({
-  useTargetMatchUpIds = false,
   inContextDrawMatchUps = [],
+  useTargetMatchUpIds,
   inContextMatchUp,
   drawDefinition,
   matchUpId
@@ -11992,15 +11999,16 @@ function targetByRoundOutcome({
   structure,
   matchUp
 }) {
+  var _winnerTargetLink$tar, _loserTargetLink$targ;
+
   const {
-    links: {
-      source
-    }
+    links
   } = getRoundLinks({
     roundNumber: matchUp.roundNumber,
     structureId: structure.structureId,
     drawDefinition
   });
+  const source = links === null || links === void 0 ? void 0 : links.source;
   const winnerTargetLink = getTargetLink({
     source,
     linkType: WINNER
@@ -12013,86 +12021,75 @@ function targetByRoundOutcome({
     winnerMatchUpId,
     loserMatchUpId
   } = matchUp;
+  const winnerFeedProfile = winnerTargetLink === null || winnerTargetLink === void 0 ? void 0 : (_winnerTargetLink$tar = winnerTargetLink.target) === null || _winnerTargetLink$tar === void 0 ? void 0 : _winnerTargetLink$tar.feedProfile;
+  const loserFeedProfile = loserTargetLink === null || loserTargetLink === void 0 ? void 0 : (_loserTargetLink$targ = loserTargetLink.target) === null || _loserTargetLink$targ === void 0 ? void 0 : _loserTargetLink$targ.feedProfile;
   let loserMatchUp, loserTargetDrawPosition, loserMatchUpDrawPositionIndex;
   let winnerMatchUp, winnerTargetDrawPosition, winnerMatchUpDrawPositionIndex;
   let structureMatchUps;
 
-  if (useTargetMatchUpIds) {
-    winnerMatchUp = winnerMatchUpId && inContextDrawMatchUps.find(({
+  if (useTargetMatchUpIds && (winnerMatchUpId || loserMatchUpId)) {
+    winnerMatchUp = winnerMatchUpId && winnerFeedProfile !== DRAW && inContextDrawMatchUps.find(({
       matchUpId
     }) => matchUpId === winnerMatchUpId);
-    loserMatchUp = loserMatchUpId && inContextDrawMatchUps.find(({
+    loserMatchUp = loserMatchUpId && loserFeedProfile !== DRAW && inContextDrawMatchUps.find(({
       matchUpId
     }) => matchUpId === loserMatchUpId);
-  }
 
-  const useBruteForce = winnerTargetLink && !winnerMatchUp || loserTargetLink && !loserMatchUp;
-
-  if (useBruteForce) {
-    if (getDevContext({
-      qualifying: true
-    })) {
-      console.log({
-        useBruteForce
-      });
+    if (winnerMatchUp || loserMatchUp) {
+      return {
+        matchUp,
+        targetLinks: {
+          loserTargetLink,
+          winnerTargetLink
+        },
+        targetMatchUps: {
+          loserMatchUp,
+          winnerMatchUp
+        }
+      };
     }
+  }
 
-    const {
-      roundPosition: sourceRoundPosition
-    } = matchUp;
-    structureMatchUps = structureMatchUps || inContextDrawMatchUps.filter(matchUp => matchUp.structureId === structure.structureId);
-    const sourceRoundMatchUpCount = structureMatchUps.reduce((count, currentMatchUp) => {
-      return currentMatchUp.roundNumber === matchUp.roundNumber && !currentMatchUp.matchUpTieId // exclude tieMatchUps
-      ? count + 1 : count;
-    }, 0);
-
-    if (loserTargetLink) {
-      ({
-        matchUp: loserMatchUp,
-        matchUpDrawPositionIndex: loserMatchUpDrawPositionIndex,
-        targetDrawPosition: loserTargetDrawPosition
-      } = getTargetMatchUp({
-        targetLink: loserTargetLink,
-        sourceRoundMatchUpCount,
-        inContextDrawMatchUps,
-        sourceRoundPosition,
-        drawDefinition
-      }));
-    }
+  const {
+    roundPosition: sourceRoundPosition
+  } = matchUp;
+  structureMatchUps = structureMatchUps || inContextDrawMatchUps.filter(matchUp => matchUp.structureId === structure.structureId);
+  const sourceRoundMatchUpCount = structureMatchUps.reduce((count, currentMatchUp) => {
+    return currentMatchUp.roundNumber === matchUp.roundNumber && !currentMatchUp.matchUpTieId // exclude tieMatchUps
+    ? count + 1 : count;
+  }, 0);
 
-    if (winnerTargetLink) {
-      ({
-        matchUp: winnerMatchUp,
-        matchUpDrawPositionIndex: winnerMatchUpDrawPositionIndex,
-        targetDrawPosition: winnerTargetDrawPosition
-      } = getTargetMatchUp({
-        drawDefinition,
-        inContextDrawMatchUps,
-        sourceRoundPosition,
-        sourceRoundMatchUpCount,
-        targetLink: winnerTargetLink
-      }));
-    }
+  if (loserTargetLink && !loserMatchUp && loserFeedProfile !== DRAW) {
+    ({
+      matchUp: loserMatchUp,
+      matchUpDrawPositionIndex: loserMatchUpDrawPositionIndex,
+      targetDrawPosition: loserTargetDrawPosition
+    } = getTargetMatchUp({
+      targetLink: loserTargetLink,
+      sourceRoundMatchUpCount,
+      inContextDrawMatchUps,
+      sourceRoundPosition,
+      drawDefinition
+    }));
+  }
 
-    if (getDevContext({
-      qualifying: true
-    })) {
-      console.log(sourceRoundPosition, sourceRoundMatchUpCount, winnerTargetLink, winnerMatchUp);
-    }
+  if (winnerTargetLink && !winnerMatchUp && winnerFeedProfile !== DRAW) {
+    ({
+      matchUp: winnerMatchUp,
+      matchUpDrawPositionIndex: winnerMatchUpDrawPositionIndex,
+      targetDrawPosition: winnerTargetDrawPosition
+    } = getTargetMatchUp({
+      drawDefinition,
+      inContextDrawMatchUps,
+      sourceRoundPosition,
+      sourceRoundMatchUpCount,
+      targetLink: winnerTargetLink
+    }));
   }
 
   if (!winnerMatchUp) {
     // if there is no winnerTargetLink then find targetMatchUp in next round
     structureMatchUps = structureMatchUps || inContextDrawMatchUps.filter(matchUp => matchUp.structureId === structure.structureId);
-
-    if (getDevContext({
-      qualifying: true
-    })) {
-      console.log('no winner matcnUp', {
-        structureMatchUps
-      });
-    }
-
     ({
       matchUp: winnerMatchUp
     } = nextRoundMatchUp({
@@ -12368,7 +12365,7 @@ function getNextToBePlayedMatchUp({
 
 function getUpcomingInfo({
   upcomingMatchUp
-}) {
+} = {}) {
   if (!upcomingMatchUp) return;
   return (({
     matchUpId,
@@ -14813,7 +14810,7 @@ const POLICY_POSITION_ACTIONS_DEFAULT = {
       // stages: [] => applies to all stages
       stageSequences: [],
       // stageSequences: [] => applies to all stageSequences
-      enabledActions: [SEED_VALUE, ADD_NICKNAME, ADD_PENALTY],
+      enabledActions: [ADD_NICKNAME, ADD_PENALTY, QUALIFYING_PARTICIPANT, SEED_VALUE],
       disabledActions: [] // disabledActions: [] => no actions are disabled
 
     }],
@@ -15436,7 +15433,7 @@ function getMatchUpFormatMap({
 }
 const baseAttributeKeys = ['collectionId', 'collectionPosition', 'drawPositions', 'extensions', 'finishingPositionRange', 'finishingRound', 'isMock', 'matchUpId', 'matchUpStatus', 'matchUpStatusCodes', 'orderOfFinish', 'processCodes', 'roundNumber', 'tieFormat', 'tieMatchUps', 'roundPosition', 'score', 'sides', // can be removed only if drawPositions is present and is not a TEAM matchUp
 'winnerMatchUpId', 'loserMatchUpId', 'matchUpDuration', 'winningSide'];
-function removeExtraneousAttributes(matchUps, matchUpFormatMap) {
+function removeExtraneousAttributes(matchUps, matchUpFormatMap = {}) {
   for (const matchUp of matchUps) {
     const {
       structureId,
@@ -17737,7 +17734,7 @@ function tournamentRelevantSchedulingIds({
   tournamentRecord = {},
   tournamentMap = {},
   requireCourts
-}) {
+} = {}) {
   const drawIds = [];
   const eventIds = [];
   const structureIds = [];
@@ -17805,7 +17802,7 @@ function tournamentRelevantSchedulingIds({
 }
 function getAllRelevantSchedulingIds({
   tournamentRecords = {}
-}) {
+} = {}) {
   const records = tournamentRecords && Object.values(tournamentRecords) || [];
   const tournamentsMap = {};
   const {
@@ -19245,10 +19242,17 @@ function removeDrawPosition({
     }
   }
 
-  if (winnerMatchUp && winnerMatchUp.structureId !== targetData.matchUp.structureId) {
-    console.log('linked structure winnerMatchUp removal', {
-      winnerTargetLink,
-      winnerMatchUpDrawPositionIndex
+  if (winnerMatchUp && winnerMatchUp.structureId !== targetData.matchUp.structureId && // does not apply to traversals that are based on QUALIFYING
+  winnerTargetLink.target.feedProfile !== DRAW) {
+    const {
+      structure
+    } = findStructure({
+      drawDefinition,
+      structureId: targetData.matchUp.structureId
+    });
+    if (structure.structureType !== QUALIFYING) console.log('linked structure winnerMatchUp removal', {
+      winnerMatchUpDrawPositionIndex,
+      winnerTargetLink
     });
   }
 }
@@ -20246,7 +20250,7 @@ function assignDrawPositionBye$1({
     structureId
   });
   const currentAssignment = positionAssignments.find(assignment => assignment.drawPosition === drawPosition);
-  if (currentAssignment.bye) return { ...SUCCESS
+  if (currentAssignment !== null && currentAssignment !== void 0 && currentAssignment.bye) return { ...SUCCESS
   }; // ################### Check error conditions ######################
 
   const drawPositionIsActive = activeDrawPositions === null || activeDrawPositions === void 0 ? void 0 : activeDrawPositions.includes(drawPosition);
@@ -22380,6 +22384,7 @@ function assignSeed({
   seedValue,
   eventId
 }) {
+  const stack = 'assignSeed';
   const {
     structure
   } = findStructure({
@@ -22402,11 +22407,15 @@ function assignSeed({
     drawDefinition,
     participantId
   });
-  if (participantId && !validParticipantId) return {
-    error: INVALID_PARTICIPANT_ID,
-    method: 'assignSeed',
-    participantId
-  };
+  if (participantId && !validParticipantId) return decorateResult({
+    result: {
+      error: INVALID_PARTICIPANT_ID
+    },
+    context: {
+      participantId
+    },
+    stack
+  });
   const relevantAssignment = positionAssignments.find(assignment => assignment.participantId === participantId);
   const assignedDrawPosition = relevantAssignment === null || relevantAssignment === void 0 ? void 0 : relevantAssignment.drawPosition;
 
@@ -22417,9 +22426,16 @@ function assignSeed({
       structureId,
       seedNumber
     });
-    if (!positionIsValid) return {
-      error: INVALID_DRAW_POSITION_FOR_SEEDING
-    };
+    if (!positionIsValid) return decorateResult({
+      result: {
+        error: INVALID_DRAW_POSITION_FOR_SEEDING
+      },
+      context: {
+        assignedDrawPosition
+      },
+      info: 'invalid seed position',
+      stack
+    });
   }
 
   if (!seedNumbers.includes(seedNumber)) {
@@ -22457,9 +22473,12 @@ function assignSeed({
     };
   }
 
-  return {
-    error: INVALID_SEED_NUMBER
-  };
+  return decorateResult({
+    result: {
+      error: INVALID_SEED_NUMBER
+    },
+    stack
+  });
 }
 
 function getTargetMatchUps({
@@ -22556,6 +22575,7 @@ function assignDrawPosition$1({
   structureId,
   event
 }) {
+  const stack = 'assignDrawPosition';
   if (!participantId && !isQualifierPosition) return {
     error: MISSING_PARTICIPANT_ID
   };
@@ -22574,23 +22594,27 @@ function assignDrawPosition$1({
     }));
   }
 
-  const {
-    structure,
-    error
-  } = findStructure({
+  const result = findStructure({
     drawDefinition,
     structureId
   });
-  if (error) return {
-    error
-  }; // there are no drawPositions assigned for ADHOC structures
+  if (result.error) return decorateResult({
+    result,
+    stack
+  });
+  const {
+    structure
+  } = result; // there are no drawPositions assigned for ADHOC structures
 
   if (isAdHoc({
     drawDefinition,
     structure
-  })) return {
-    error: INVALID_MATCHUP
-  };
+  })) return decorateResult({
+    result: {
+      error: INVALID_MATCHUP
+    },
+    stack
+  });
   const {
     seedAssignments
   } = getStructureSeedAssignments({
@@ -22607,9 +22631,15 @@ function assignDrawPosition$1({
       drawPosition,
       structureId
     });
-    if (!isValidDrawPosition) return {
-      error: INVALID_DRAW_POSITION_FOR_SEEDING
-    };
+    if (!isValidDrawPosition) return decorateResult({
+      result: {
+        error: INVALID_DRAW_POSITION_FOR_SEEDING
+      },
+      context: {
+        drawPosition
+      },
+      stack
+    });
   }
 
   const {
@@ -22618,15 +22648,27 @@ function assignDrawPosition$1({
     structure
   });
   const positionAssignment = positionAssignments.find(assignment => assignment.drawPosition === drawPosition);
-  if (!positionAssignment) return {
-    error: INVALID_DRAW_POSITION
-  };
+  if (!positionAssignment) return decorateResult({
+    result: {
+      error: INVALID_DRAW_POSITION
+    },
+    context: {
+      drawPosition
+    },
+    stack
+  });
   const participantAlreadyAssigned = positionAssignments.map(getParticipantId).includes(participantId);
 
   if (participantAlreadyAssigned) {
-    return {
-      error: EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT
-    };
+    return decorateResult({
+      result: {
+        error: EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT
+      },
+      context: {
+        drawPosition
+      },
+      stack
+    });
   }
 
   const {
@@ -22644,7 +22686,10 @@ function assignDrawPosition$1({
       matchUpsMap,
       event
     });
-    if (result.error) return result;
+    if (result.error) return decorateResult({
+      result,
+      stack
+    });
   }
 
   if (containsParticipant && positionAssignment.participantId !== participantId) {
@@ -22657,9 +22702,12 @@ function assignDrawPosition$1({
     const drawPositionIsActive = activeDrawPositions.includes(drawPosition);
 
     if (drawPositionIsActive) {
-      return {
-        error: DRAW_POSITION_ACTIVE
-      };
+      return decorateResult({
+        result: {
+          error: DRAW_POSITION_ACTIVE
+        },
+        stack
+      });
     } // cleanup side[].lineUps of previous participantId in TEAM matchUps
 
 
@@ -22831,7 +22879,13 @@ function addDrawPositionToMatchUps({
       drawPosition,
       matchUpsMap
     });
-    if (result.error) return result;
+    if (result.error) return decorateResult({
+      stack: 'assignDrawPositionToMatchUps',
+      context: {
+        drawPosition
+      },
+      result
+    });
   }
 }
 
@@ -23018,6 +23072,7 @@ function directLoser(params) {
     matchUpsMap,
     event
   } = params;
+  const stack = 'directLoser';
   const loserLinkCondition = loserTargetLink.linkCondition;
   const targetMatchUpDrawPositions = loserMatchUp.drawPositions || [];
   const fedDrawPositionFMLC = loserLinkCondition === FIRST_MATCHUP && loserMatchUp.roundNumber === 2 && Math.min(...targetMatchUpDrawPositions.filter(Boolean));
@@ -23074,7 +23129,8 @@ function directLoser(params) {
   const loserAlreadyDirected = targetMatchUpPositionAssignments.some(assignment => assignment.participantId === loserParticipantId);
 
   if (loserAlreadyDirected) {
-    return SUCCESS;
+    return { ...SUCCESS
+    };
   }
 
   const unfilledTargetMatchUpDrawPositions = targetMatchUpPositionAssignments.filter(assignment => {
@@ -23088,10 +23144,16 @@ function directLoser(params) {
 
   if (fedDrawPositionFMLC) {
     const result = loserLinkFedFMLC();
-    if (result.error) return result;
+    if (result.error) return decorateResult({
+      result,
+      stack
+    });
   } else if (isFirstRoundValidDrawPosition) {
     const result = asssignLoserDrawPosition();
-    if (result.error) return result;
+    if (result.error) return decorateResult({
+      result,
+      stack
+    });
   } else if (isFeedRound) {
     // if target.roundNumber > 1 then it is a feed round and should always take the lower drawPosition
     const fedDrawPosition = unfilledTargetMatchUpDrawPositions.sort(numericSort)[0];
@@ -23105,11 +23167,20 @@ function directLoser(params) {
       drawDefinition,
       matchUpsMap
     });
-    if (result.error) return result;
+    if (result.error) return decorateResult({
+      result,
+      stack
+    });
   } else {
-    return {
-      error: INVALID_DRAW_POSITION
-    };
+    return decorateResult({
+      result: {
+        error: INVALID_DRAW_POSITION
+      },
+      context: {
+        loserDrawPosition
+      },
+      stack
+    });
   }
 
   if (structure !== null && structure !== void 0 && structure.seedAssignments && structure.structureId !== targetStructureId) {
@@ -23177,24 +23248,36 @@ function directLoser(params) {
   };
 
   function loserLinkFedFMLC() {
+    const stack = 'loserLinkFedFMLC';
+
     if (validForConsolation) {
-      return asssignLoserDrawPosition();
+      return decorateResult({
+        result: asssignLoserDrawPosition(),
+        stack
+      });
     } else {
-      return assignWinnerPositionBye();
+      return decorateResult({
+        result: assignWinnerPositionBye(),
+        stack
+      });
     }
   }
 
   function assignWinnerPositionBye() {
-    return assignDrawPositionBye$1({
+    const result = assignDrawPositionBye$1({
       drawPosition: winnerBackdrawPosition,
       structureId: targetStructureId,
       tournamentRecord,
       drawDefinition
     });
+    return decorateResult({
+      result,
+      stack: 'assignWinnerPositionBye'
+    });
   }
 
   function asssignLoserDrawPosition() {
-    return assignDrawPosition$1({
+    const result = assignDrawPosition$1({
       drawPosition: targetMatchUpDrawPosition,
       participantId: loserParticipantId,
       structureId: targetStructureId,
@@ -23204,6 +23287,10 @@ function directLoser(params) {
       drawDefinition,
       matchUpsMap
     });
+    return decorateResult({
+      result,
+      stack: 'assignLoserDrawPosition'
+    });
   }
 }
 
@@ -23227,6 +23314,7 @@ function directParticipants(params) {
     event,
     score
   } = params;
+  const stack = 'directParticipants';
   const isCollectionMatchUp = Boolean(matchUp.collectionId);
   const isAdHocMatchUp = isAdHoc({
     drawDefinition,
@@ -23338,7 +23426,10 @@ function directParticipants(params) {
         dualMatchUp,
         event
       });
-      if (result.error) return result;
+      if (result.error) return decorateResult({
+        result,
+        stack
+      });
     }
   } else {
     return {
@@ -23368,6 +23459,7 @@ function drawPositionsAssignedParticipantIds({
 }
 
 function attemptToSetWinningSide(params) {
+  const stack = 'attemptToSetWinningSide';
   const {
     drawDefinition,
     winningSide,
@@ -23401,7 +23493,10 @@ function attemptToSetWinningSide(params) {
   }
 
   const result = directParticipants(params);
-  if (result.error) return result;
+  if (result.error) return decorateResult({
+    result,
+    stack
+  });
   return { ...SUCCESS,
     connectedStructures
   };
@@ -23582,7 +23677,7 @@ function noDownstreamDependencies(params) {
 
   const removeDirected = ({
     removeScore
-  }) => {
+  } = {}) => {
     let connectedStructures;
     const {
       structure,
@@ -23619,7 +23714,7 @@ function noDownstreamDependencies(params) {
     return scoreModification(params);
   }
 
-  return winningSide && attemptToSetWinningSide(params) || scoreWithNoWinningSide && removeDirected({
+  const result = winningSide && attemptToSetWinningSide(params) || scoreWithNoWinningSide && removeDirected({
     removeScore
   }) || statusNotTBP && attemptToSetMatchUpStatus(params) || removeWinningSide && removeDirected({
     removeScore
@@ -23627,6 +23722,10 @@ function noDownstreamDependencies(params) {
     removeScore: true
   }) || console.log('unknown condition') && { ...SUCCESS
   };
+  return decorateResult({
+    result,
+    stack: 'noDownStreamDependencies'
+  });
 }
 
 function scoreModification(params) {
@@ -23667,6 +23766,7 @@ function scoreModification(params) {
 function isActiveDownstream(params) {
   var _targetData$matchUp, _winnerMatchUp$drawPo;
 
+  // relevantLink is passed in iterative calls (see below)
   const {
     inContextDrawMatchUps,
     targetData,
@@ -23682,11 +23782,6 @@ function isActiveDownstream(params) {
     },
     targetLinks
   } = targetData;
-  if (getDevContext({
-    qualifying: true
-  })) console.log({
-    targetData
-  });
   const loserMatchUpWalkover = [WALKOVER$2].includes(loserMatchUp === null || loserMatchUp === void 0 ? void 0 : loserMatchUp.matchUpStatus);
   const winnerDrawPositionsCount = (winnerMatchUp === null || winnerMatchUp === void 0 ? void 0 : (_winnerMatchUp$drawPo = winnerMatchUp.drawPositions) === null || _winnerMatchUp$drawPo === void 0 ? void 0 : _winnerMatchUp$drawPo.filter(Boolean).length) || 0;
 
@@ -23844,7 +23939,8 @@ function swapWinnerLoser(params) {
 function setMatchUpStatus$2(params) {
   var _inContextMatchUp$dra, _matchUp$sides;
 
-  // always clear score if DOUBLE_WALKOVER or WALKOVER
+  const stack = 'setMatchUpStatus'; // always clear score if DOUBLE_WALKOVER or WALKOVER
+
   if ([WALKOVER$2, DOUBLE_WALKOVER].includes(params.matchUpStatus)) params.score = undefined; // matchUpStatus in params is the new status
   // winningSide in params is new winningSide
 
@@ -23892,13 +23988,17 @@ function setMatchUpStatus$2(params) {
     winnerMatchUpId,
     loserMatchUpId
   }) => winnerMatchUpId || loserMatchUpId);
-  if (!hasGoesTo) ({
-    inContextDrawMatchUps
-  } = addGoesTo({
-    inContextDrawMatchUps,
-    drawDefinition,
-    matchUpsMap
-  })); // Find target matchUp ------------------------------------------------------
+
+  if (!hasGoesTo) {
+    ({
+      inContextDrawMatchUps
+    } = addGoesTo({
+      inContextDrawMatchUps,
+      drawDefinition,
+      matchUpsMap
+    }));
+  } // Find target matchUp ------------------------------------------------------
+
 
   const matchUp = matchUpsMap.drawMatchUps.find(matchUp => matchUp.matchUpId === matchUpId);
   const inContextMatchUp = inContextDrawMatchUps.find(matchUp => matchUp.matchUpId === matchUpId);
@@ -23929,9 +24029,6 @@ function setMatchUpStatus$2(params) {
   const targetData = positionTargets({
     matchUpId: matchUpTieId || matchUpId,
     // get targets for TEAM matchUp if tieMatchUp
-    useTargetMatchUpIds: getDevContext({
-      useTargetMatchUpIds: true
-    }),
     inContextDrawMatchUps,
     drawDefinition
   });
@@ -24068,7 +24165,10 @@ function setMatchUpStatus$2(params) {
   const result = !activeDownstream && noDownstreamDependencies(params) || matchUpWinner && winningSideWithDownstreamDependencies(params) || directingMatchUpStatus && applyMatchUpValues(params) || {
     error: NO_VALID_ACTIONS
   };
-  return result;
+  return decorateResult({
+    result,
+    stack
+  });
 }
 
 function winningSideWithDownstreamDependencies(params) {
@@ -24670,7 +24770,7 @@ function deletionMessage({
 function validTimePeriod({
   startTime,
   endTime
-}) {
+} = {}) {
   if (!timeValidation.test(startTime) || !timeValidation.test(endTime)) return false;
   const [startHour, startMinute] = startTime.split(':');
   const [endHour, endMinute] = endTime.split(':');
@@ -40504,7 +40604,7 @@ function getAssignedParticipantIds({
 
 function refreshEntryPositions({
   entries = []
-}) {
+} = {}) {
   const stagedEntries = entries.filter(Boolean).reduce((stages, entry) => {
     const {
       entryStage,
@@ -45066,7 +45166,7 @@ function newDrawDefinition({
   drawId = UUID(),
   matchUpType,
   drawType
-}) {
+} = {}) {
   const drawDefinition = definitionTemplate();
   return Object.assign(drawDefinition, {
     drawId,
@@ -45388,7 +45488,7 @@ function getState$1({
   convertExtensions,
   removeExtensions,
   tournamentId
-}) {
+} = {}) {
   if (typeof tournamentId !== 'string') return {};
   const tournamentRecord = getTournamentRecord(tournamentId);
   return {
@@ -46251,7 +46351,7 @@ function getState({
   convertExtensions,
   removeExtensions,
   tournamentId
-}) {
+} = {}) {
   if (typeof tournamentId !== 'string') return {};
   const tournamentRecord = getTournamentRecord(tournamentId);
   return {
@@ -56846,7 +56946,7 @@ function generatePersons({
   count = 1,
   category,
   sex
-}) {
+} = {}) {
   if (isNaN(count)) return {
     error: INVALID_VALUES
   };
@@ -57027,7 +57127,7 @@ var namesData = [
 function nameMocks({
   nameRoot = 'TEAM',
   count = 1
-}) {
+} = {}) {
   const shuffledTeamNames = shuffleArray(namesData);
   const names = shuffledTeamNames.slice(0, count);
 
@@ -57401,7 +57501,7 @@ var citiesData = [
 function cityMocks({
   count = 1,
   participantsCount = 32
-}) {
+} = {}) {
   const shuffledCities = shuffleArray(citiesData);
   const candidateCities = shuffledCities.slice(0, count); // the following ensures that all of the generated items are used at least once
 
@@ -57413,7 +57513,7 @@ function cityMocks({
 function stateMocks({
   count = 1,
   participantsCount = 32
-}) {
+} = {}) {
   const shuffledStates = shuffleArray(statesData);
   const candidateStates = shuffledStates.slice(0, count).map(state => Object.keys(state)).flat(); // the following ensures that all of the generated items are used at least once
 
@@ -57425,7 +57525,7 @@ function stateMocks({
 function postalCodeMocks({
   count = 1,
   participantsCount = 32
-}) {
+} = {}) {
   const candidatePostalCodes = generateRange(0, count).map(() => generateRange(0, 5).map(() => randomInt(0, 9)).join('')); // the following ensures that all of the generated items are used at least once
 
   const postalCodes = generateRange(0, participantsCount).map(i => i < count ? candidatePostalCodes[i] : randomMember(candidatePostalCodes));
@@ -57457,7 +57557,7 @@ function anonymizeTournamentRecord({
 
       return element === null || element === void 0 ? void 0 : (_element$extensions = element.extensions) === null || _element$extensions === void 0 ? void 0 : _element$extensions.filter(extension => extensionsToKeep.includes(extension.name));
     } else {
-      return element.extensions;
+      return element === null || element === void 0 ? void 0 : element.extensions;
     }
   }; // create mapping from original element IDs to newly generated UUIDs
 
@@ -57709,7 +57809,7 @@ function anonymizeTournamentRecord({
     delete generatedPerson.lastName;
     generatedPerson.extensions = filterExtensions(person);
     individualParticipant.person = generatedPerson;
-    idMap[person.personId] = generatedPerson.personId;
+    idMap[person === null || person === void 0 ? void 0 : person.personId] = generatedPerson.personId;
   });
   const pairParticipants = (tournamentRecord.participants || []).filter(({
     participantType
@@ -60540,13 +60640,7 @@ function generateTournamentRecord({
     let drawIndex = 0;
 
     for (const drawProfile of drawProfiles) {
-      const {
-        drawId,
-        eventId,
-        event,
-        error,
-        uniqueParticipantIds
-      } = generateEventWithDraw({
+      let result = generateEventWithDraw({
         allUniqueParticipantIds,
         matchUpStatusProfile,
         participantsProfile,
@@ -60562,10 +60656,14 @@ function generateTournamentRecord({
         goesTo,
         uuids
       });
-      if (error) return {
-        error
-      };
-      const result = addEvent({
+      if (result.error) return result;
+      const {
+        drawId,
+        eventId,
+        event,
+        uniqueParticipantIds
+      } = result;
+      result = addEvent({
         suppressNotifications: false,
         tournamentRecord,
         event