tods-competition-factory 1.8.25 → 1.8.27

package/dist/index.mjs

@@ -1298,18 +1298,21 @@ function cycleMutationStatus$1() {
   return status;
 }
 function addNotice$1({ topic, payload, key }) {
-  syncGlobalState.modified = true;
   if (typeof topic !== "string" || typeof payload !== "object") {
     return;
   }
-  if (syncGlobalState.disableNotifications || !syncGlobalState.subscriptions[topic])
+  if (!syncGlobalState.disableNotifications)
+    syncGlobalState.modified = true;
+  if (syncGlobalState.disableNotifications || !syncGlobalState.subscriptions[topic]) {
     return;
+  }
   if (key) {
     syncGlobalState.notices = syncGlobalState.notices.filter(
       (notice) => !(notice.topic === topic && notice.key === key)
     );
   }
   syncGlobalState.notices.push({ topic, payload, key });
+  return { ...SUCCESS };
 }
 function getNotices$1({ topic }) {
   const notices = syncGlobalState.notices.filter((notice) => notice.topic === topic).map((notice) => notice.payload);
@@ -1424,6 +1427,13 @@ function getDevContext(contextCriteria) {
     ) && globalState.devContext;
   }
 }
+function setGlobalLog(loggingFx) {
+  if (typeof loggingFx === "function") {
+    globalState.globalLog = loggingFx;
+  } else {
+    delete globalState.globalLog;
+  }
+}
 function setDevContext(value) {
   globalState.devContext = value;
 }
@@ -1526,6 +1536,13 @@ function handleCaughtError({
     err
   });
 }
+function globalLog$1(engine, log) {
+  if (globalState.globalLog) {
+    return globalState.globalLog(engine, log);
+  } else {
+    console.log(engine, log);
+  }
+}
 
 const validDateString = /^[\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1])$/;
 const validTimeString = /^((0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)([.,][0-9]{3})?$/;
@@ -2387,7 +2404,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.25";
+  return "1.8.27";
 }
 
 function getObjectTieFormat(obj) {
@@ -2450,260 +2467,6 @@ function resolveTieFormat({
   };
 }
 
-const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
-const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
-function getCategoryAgeDetails(params) {
-  const category = params.category;
-  if (typeof category !== "object")
-    return { error: INVALID_CATEGORY };
-  let { ageCategoryCode, ageMaxDate, ageMinDate, ageMax, ageMin } = category;
-  const categoryName = category.categoryName;
-  let combinedAge;
-  if (!typeMatch(
-    [ageCategoryCode, ageMaxDate, ageMinDate, categoryName],
-    "string"
-  ) || !allNumeric(
-    [ageMax, ageMin]
-  ))
-    return { error: INVALID_CATEGORY };
-  const consideredDate = params.consideredDate ?? extractDate((/* @__PURE__ */ new Date()).toLocaleDateString("sv"));
-  if (!isValidDateString(consideredDate))
-    return { error: INVALID_DATE };
-  const [consideredYear] = consideredDate.split("-").slice(0, 3).map((n) => parseInt(n));
-  const previousDayDate = dateStringDaysChange(consideredDate, -1);
-  const [previousDayMonth, previousDay] = previousDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
-  const previousMonthDay = `${zeroPad(previousDayMonth)}-${zeroPad(
-    previousDay
-  )}`;
-  const nextDayDate = dateStringDaysChange(consideredDate, 1);
-  const [nextDayMonth, nextDay] = nextDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
-  const nextMonthDay = `${zeroPad(nextDayMonth)}-${zeroPad(nextDay)}`;
-  let calculatedAgeMaxDate = ageMin && dateStringDaysChange(consideredDate, -1 * 365 * ageMin);
-  let calculatedAgeMinDate = ageMax && dateStringDaysChange(consideredDate, -1 * 365 * ageMax);
-  const errors = [];
-  const addError = (errorString) => !errors.includes(errorString) && errors.push(errorString);
-  ageCategoryCode = ageCategoryCode ?? categoryName;
-  const prePost = /^([UO]?)(\d{1,2})([UO]?)$/;
-  const extractCombined = /^C(\d{1,2})-(\d{1,2})$/;
-  const isBetween = ageCategoryCode?.includes("-");
-  const isCombined = isBetween && ageCategoryCode?.match(extractCombined);
-  const isCoded = ageCategoryCode?.match(prePost);
-  const constructedDate = (y, df) => `${y}-${df}`;
-  const uPre = (ageInt) => {
-    const ageMinYear = consideredYear - ageInt;
-    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
-    if (category.ageMinDate && category.ageMinDate !== newMinDate)
-      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
-    ageMinDate = newMinDate;
-    if (ageCategoryCode) {
-      if (category.ageMax && category.ageMax !== ageInt - 1) {
-        addError(`Invalid submitted ageMax: ${ageMax}`);
-        calculatedAgeMinDate = void 0;
-      }
-      ageMax = ageInt - 1;
-    }
-  };
-  const uPost = (ageInt) => {
-    const ageMinYear = consideredYear - ageInt - 1;
-    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
-    if (category.ageMin && category.ageMin > ageInt) {
-      addError(`Invalid submitted ageMin: ${ageMin}`);
-    }
-    if (category.ageMax && category.ageMax > ageInt) {
-      addError(`Invalid submitted ageMax: ${ageMax}`);
-    }
-    if (category.ageMinDate && category.ageMinDate !== newMinDate)
-      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
-    ageMinDate = newMinDate;
-    if (ageCategoryCode) {
-      if (category.ageMax && category.ageMax !== ageInt) {
-        addError(`Invalid submitted ageMax: ${ageMax}`);
-        calculatedAgeMaxDate = void 0;
-      }
-      ageMax = ageInt;
-    }
-  };
-  const oPre = (ageInt) => {
-    const ageMaxYear = consideredYear - ageInt;
-    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
-    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
-      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
-    ageMaxDate = newMaxDate;
-    if (ageCategoryCode) {
-      if (category.ageMin && category.ageMin !== ageInt + 1) {
-        addError(`Invalid submitted ageMin: ${ageMin}`);
-        calculatedAgeMaxDate = void 0;
-      }
-      ageMin = ageInt + 1;
-    }
-  };
-  const oPost = (ageInt) => {
-    const ageMaxYear = consideredYear - ageInt - 1;
-    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
-    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
-      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
-    ageMaxDate = newMaxDate;
-    if (ageCategoryCode) {
-      if (category.ageMin && category.ageMin !== ageInt) {
-        addError(`Invalid submitted ageMin: ${ageMin}`);
-        calculatedAgeMaxDate = void 0;
-      }
-      ageMin = ageInt;
-    }
-  };
-  const processCode = (code) => {
-    const [pre, age, post] = (code.match(prePost) || []).slice(1);
-    const ageInt = parseInt(age);
-    if (pre === "U") {
-      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
-        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
-      }
-      uPre(ageInt);
-    } else if (pre === "O") {
-      oPre(ageInt);
-    }
-    if (post === "U") {
-      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
-        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
-      }
-      uPost(ageInt);
-    } else if (post === "O") {
-      oPost(ageInt);
-    }
-    ageMaxDate = ageMaxDate ?? calculatedAgeMaxDate;
-    ageMinDate = ageMinDate ?? calculatedAgeMinDate;
-  };
-  if (isCombined) {
-    ageMaxDate = void 0;
-    ageMinDate = void 0;
-    ageMax = void 0;
-    ageMin = void 0;
-    if (category.ageMin) {
-      const ageMaxYear = consideredYear - category.ageMin;
-      ageMaxDate = constructedDate(ageMaxYear, previousMonthDay);
-    }
-    if (category.ageMax) {
-      const ageMinYear = consideredYear - category.ageMax - 1;
-      ageMinDate = constructedDate(ageMinYear, nextMonthDay);
-    }
-    const [lowAge, highAge] = (ageCategoryCode?.match(extractCombined) ?? []).slice(1).map((n) => parseInt(n));
-    if (lowAge <= highAge) {
-      ageMin = lowAge;
-      ageMax = highAge;
-      combinedAge = true;
-    } else {
-      addError(`Invalid combined age range ${ageCategoryCode}`);
-    }
-  } else if (isBetween) {
-    ageCategoryCode?.split("-").forEach(processCode);
-  } else if (isCoded) {
-    processCode(ageCategoryCode);
-  } else {
-    if (ageMin)
-      oPre(ageMin);
-    if (ageMax)
-      uPost(ageMax);
-  }
-  if (ageMax && category.ageMin && category.ageMin > ageMax) {
-    addError(`Invalid submitted ageMin: ${category.ageMin}`);
-    ageMin = void 0;
-  }
-  const result = definedAttributes({
-    consideredDate,
-    combinedAge,
-    ageMaxDate,
-    ageMinDate,
-    ageMax,
-    ageMin
-  });
-  if (errors.length)
-    result.errors = errors;
-  return result;
-}
-
-function decorateResult({
-  context,
-  result,
-  stack,
-  info
-}) {
-  if (result && !Array.isArray(result?.stack))
-    result.stack = [];
-  if (result && Array.isArray(result?.stack) && typeof stack === "string") {
-    result.stack.push(stack);
-  }
-  if (result && info) {
-    result.info = info;
-  }
-  if (result && typeof context === "object" && Object.keys(context).length) {
-    Object.assign(result, definedAttributes(context));
-  }
-  if (result && !result?.error && !result?.success) {
-    Object.assign(result, { ...SUCCESS });
-  }
-  return result ?? { success: true };
-}
-
-function validateCategory({ category }) {
-  if (!isObject(category))
-    return { error: INVALID_VALUES };
-  const categoryDetails = getCategoryAgeDetails({ category });
-  if (categoryDetails.error)
-    return { error: categoryDetails };
-  const { ratingMax, ratingMin } = category;
-  if (ratingMax && !isNumeric(ratingMax))
-    return decorateResult({
-      result: { error: INVALID_VALUES },
-      context: { ratingMax }
-    });
-  if (ratingMin && !isNumeric(ratingMin))
-    return decorateResult({
-      result: { error: INVALID_VALUES },
-      context: { ratingMin }
-    });
-  return { ...categoryDetails };
-}
-
-function categoryCanContain({
-  childCategory,
-  withDetails,
-  category
-}) {
-  const categoryDetails = validateCategory({ category });
-  const childCategoryDetails = validateCategory({
-    category: childCategory
-  });
-  const invalidAgeMin = childCategoryDetails.ageMin && (categoryDetails.ageMin && childCategoryDetails.ageMin < categoryDetails.ageMin || categoryDetails.ageMax && childCategoryDetails.ageMin > categoryDetails.ageMax);
-  const invalidAgeMax = childCategoryDetails.ageMax && (categoryDetails.ageMax && childCategoryDetails.ageMax > categoryDetails.ageMax || categoryDetails.ageMin && childCategoryDetails.ageMax < categoryDetails.ageMin);
-  const invalidAgeMinDate = childCategoryDetails.ageMinDate && categoryDetails.ageMaxDate && new Date(childCategoryDetails.ageMinDate) > new Date(categoryDetails.ageMaxDate);
-  const invalidAgeMaxDate = childCategoryDetails.ageMaxDate && categoryDetails.ageMinDate && new Date(childCategoryDetails.ageMaxDate) < new Date(categoryDetails.ageMinDate);
-  const ratingComparison = category.ratingType && childCategory.ratingType && category.ratingType === childCategory.ratingType;
-  const invalidRatingRange = ratingComparison && (category.ratingMin && childCategory.ratingMin && childCategory.ratingMin < category.ratingMin || category.ratingMax && childCategory.ratingMax && childCategory.ratingMax > category.ratingMax || category.ratingMin && childCategory.ratingMax && childCategory.ratingMax < category.ratingMin || category.ratingMax && childCategory.ratingMin && childCategory.ratingMin > category.ratingMax);
-  const invalidBallType = category.ballType && childCategory.ballType && category.ballType !== childCategory.ballType;
-  const valid = !invalidRatingRange && !invalidAgeMinDate && !invalidAgeMaxDate && !invalidBallType && !invalidAgeMax && !invalidAgeMin;
-  const ignoreFalse = true;
-  const result = definedAttributes(
-    {
-      invalidRatingRange,
-      invalidAgeMinDate,
-      invalidAgeMaxDate,
-      invalidBallType,
-      invalidAgeMax,
-      invalidAgeMin,
-      valid
-    },
-    ignoreFalse
-  );
-  if (withDetails) {
-    Object.assign(result, { categoryDetails, childCategoryDetails });
-  }
-  return result;
-}
-
-function mustBeAnArray(value) {
-  return `${value} must be an array`;
-}
-
 var DrawTypeEnum = /* @__PURE__ */ ((DrawTypeEnum2) => {
   DrawTypeEnum2["AdHoc"] = "AD_HOC";
   DrawTypeEnum2["Compass"] = "COMPASS";
@@ -2818,6 +2581,296 @@ var ParticipantTypeEnum = /* @__PURE__ */ ((ParticipantTypeEnum2) => {
   return ParticipantTypeEnum2;
 })(ParticipantTypeEnum || {});
 
+function decorateResult({
+  context,
+  result,
+  stack,
+  info
+}) {
+  if (result && !Array.isArray(result?.stack))
+    result.stack = [];
+  if (result && Array.isArray(result?.stack) && typeof stack === "string") {
+    result.stack.push(stack);
+  }
+  if (result && info) {
+    result.info = info;
+  }
+  if (result && typeof context === "object" && Object.keys(context).length) {
+    Object.assign(result, definedAttributes(context));
+  }
+  if (result && !result?.error && !result?.success) {
+    Object.assign(result, { ...SUCCESS });
+  }
+  return result ?? { success: true };
+}
+
+const ANY = "ANY";
+const MALE = "MALE";
+const MIXED = "MIXED";
+const OTHER$3 = "OTHER";
+const FEMALE = "FEMALE";
+const genderConstants = {
+  ANY,
+  MALE,
+  FEMALE,
+  MIXED,
+  OTHER: OTHER$3
+};
+
+function genderValidityCheck({
+  referenceGender,
+  matchUpType,
+  gender
+}) {
+  const stack = "genderValidityCheck";
+  if (referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && [GenderEnum.Male, GenderEnum.Female].includes(gender)) {
+    const valid = gender === referenceGender;
+    return valid ? { valid: true } : decorateResult({
+      result: { valid: false, error: INVALID_GENDER },
+      context: { gender },
+      stack
+    });
+  }
+  if (matchUpType === TypeEnum.Singles && referenceGender === MIXED)
+    return decorateResult({
+      info: "matchUpType SINGLES is invalid for gender MIXED",
+      result: { error: INVALID_GENDER, valid: false },
+      stack
+    });
+  return { valid: true };
+}
+
+const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
+const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
+function getCategoryAgeDetails(params) {
+  const category = params.category;
+  if (typeof category !== "object")
+    return { error: INVALID_CATEGORY };
+  let { ageCategoryCode, ageMaxDate, ageMinDate, ageMax, ageMin } = category;
+  const categoryName = category.categoryName;
+  let combinedAge;
+  if (!typeMatch(
+    [ageCategoryCode, ageMaxDate, ageMinDate, categoryName],
+    "string"
+  ) || !allNumeric(
+    [ageMax, ageMin]
+  ))
+    return { error: INVALID_CATEGORY };
+  const consideredDate = params.consideredDate ?? extractDate((/* @__PURE__ */ new Date()).toLocaleDateString("sv"));
+  if (!isValidDateString(consideredDate))
+    return { error: INVALID_DATE };
+  const [consideredYear] = consideredDate.split("-").slice(0, 3).map((n) => parseInt(n));
+  const previousDayDate = dateStringDaysChange(consideredDate, -1);
+  const [previousDayMonth, previousDay] = previousDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
+  const previousMonthDay = `${zeroPad(previousDayMonth)}-${zeroPad(
+    previousDay
+  )}`;
+  const nextDayDate = dateStringDaysChange(consideredDate, 1);
+  const [nextDayMonth, nextDay] = nextDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
+  const nextMonthDay = `${zeroPad(nextDayMonth)}-${zeroPad(nextDay)}`;
+  let calculatedAgeMaxDate = ageMin && dateStringDaysChange(consideredDate, -1 * 365 * ageMin);
+  let calculatedAgeMinDate = ageMax && dateStringDaysChange(consideredDate, -1 * 365 * ageMax);
+  const errors = [];
+  const addError = (errorString) => !errors.includes(errorString) && errors.push(errorString);
+  ageCategoryCode = ageCategoryCode ?? categoryName;
+  const prePost = /^([UO]?)(\d{1,2})([UO]?)$/;
+  const extractCombined = /^C(\d{1,2})-(\d{1,2})$/;
+  const isBetween = ageCategoryCode?.includes("-");
+  const isCombined = isBetween && ageCategoryCode?.match(extractCombined);
+  const isCoded = ageCategoryCode?.match(prePost);
+  const constructedDate = (y, df) => `${y}-${df}`;
+  const uPre = (ageInt) => {
+    const ageMinYear = consideredYear - ageInt;
+    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
+    if (category.ageMinDate && category.ageMinDate !== newMinDate)
+      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
+    ageMinDate = newMinDate;
+    if (ageCategoryCode) {
+      if (category.ageMax && category.ageMax !== ageInt - 1) {
+        addError(`Invalid submitted ageMax: ${ageMax}`);
+        calculatedAgeMinDate = void 0;
+      }
+      ageMax = ageInt - 1;
+    }
+  };
+  const uPost = (ageInt) => {
+    const ageMinYear = consideredYear - ageInt - 1;
+    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
+    if (category.ageMin && category.ageMin > ageInt) {
+      addError(`Invalid submitted ageMin: ${ageMin}`);
+    }
+    if (category.ageMax && category.ageMax > ageInt) {
+      addError(`Invalid submitted ageMax: ${ageMax}`);
+    }
+    if (category.ageMinDate && category.ageMinDate !== newMinDate)
+      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
+    ageMinDate = newMinDate;
+    if (ageCategoryCode) {
+      if (category.ageMax && category.ageMax !== ageInt) {
+        addError(`Invalid submitted ageMax: ${ageMax}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMax = ageInt;
+    }
+  };
+  const oPre = (ageInt) => {
+    const ageMaxYear = consideredYear - ageInt;
+    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
+      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
+    ageMaxDate = newMaxDate;
+    if (ageCategoryCode) {
+      if (category.ageMin && category.ageMin !== ageInt + 1) {
+        addError(`Invalid submitted ageMin: ${ageMin}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMin = ageInt + 1;
+    }
+  };
+  const oPost = (ageInt) => {
+    const ageMaxYear = consideredYear - ageInt - 1;
+    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
+      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
+    ageMaxDate = newMaxDate;
+    if (ageCategoryCode) {
+      if (category.ageMin && category.ageMin !== ageInt) {
+        addError(`Invalid submitted ageMin: ${ageMin}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMin = ageInt;
+    }
+  };
+  const processCode = (code) => {
+    const [pre, age, post] = (code.match(prePost) || []).slice(1);
+    const ageInt = parseInt(age);
+    if (pre === "U") {
+      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
+        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
+      }
+      uPre(ageInt);
+    } else if (pre === "O") {
+      oPre(ageInt);
+    }
+    if (post === "U") {
+      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
+        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
+      }
+      uPost(ageInt);
+    } else if (post === "O") {
+      oPost(ageInt);
+    }
+    ageMaxDate = ageMaxDate ?? calculatedAgeMaxDate;
+    ageMinDate = ageMinDate ?? calculatedAgeMinDate;
+  };
+  if (isCombined) {
+    ageMaxDate = void 0;
+    ageMinDate = void 0;
+    ageMax = void 0;
+    ageMin = void 0;
+    if (category.ageMin) {
+      const ageMaxYear = consideredYear - category.ageMin;
+      ageMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    }
+    if (category.ageMax) {
+      const ageMinYear = consideredYear - category.ageMax - 1;
+      ageMinDate = constructedDate(ageMinYear, nextMonthDay);
+    }
+    const [lowAge, highAge] = (ageCategoryCode?.match(extractCombined) ?? []).slice(1).map((n) => parseInt(n));
+    if (lowAge <= highAge) {
+      ageMin = lowAge;
+      ageMax = highAge;
+      combinedAge = true;
+    } else {
+      addError(`Invalid combined age range ${ageCategoryCode}`);
+    }
+  } else if (isBetween) {
+    ageCategoryCode?.split("-").forEach(processCode);
+  } else if (isCoded) {
+    processCode(ageCategoryCode);
+  } else {
+    if (ageMin)
+      oPre(ageMin);
+    if (ageMax)
+      uPost(ageMax);
+  }
+  if (ageMax && category.ageMin && category.ageMin > ageMax) {
+    addError(`Invalid submitted ageMin: ${category.ageMin}`);
+    ageMin = void 0;
+  }
+  const result = definedAttributes({
+    consideredDate,
+    combinedAge,
+    ageMaxDate,
+    ageMinDate,
+    ageMax,
+    ageMin
+  });
+  if (errors.length)
+    result.errors = errors;
+  return result;
+}
+
+function validateCategory({ category }) {
+  if (!isObject(category))
+    return { error: INVALID_VALUES };
+  const categoryDetails = getCategoryAgeDetails({ category });
+  if (categoryDetails.error)
+    return { error: categoryDetails };
+  const { ratingMax, ratingMin } = category;
+  if (ratingMax && !isNumeric(ratingMax))
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { ratingMax }
+    });
+  if (ratingMin && !isNumeric(ratingMin))
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { ratingMin }
+    });
+  return { ...categoryDetails };
+}
+
+function categoryCanContain({
+  childCategory,
+  withDetails,
+  category
+}) {
+  const categoryDetails = validateCategory({ category });
+  const childCategoryDetails = validateCategory({
+    category: childCategory
+  });
+  const invalidAgeMin = childCategoryDetails.ageMin && (categoryDetails.ageMin && childCategoryDetails.ageMin < categoryDetails.ageMin || categoryDetails.ageMax && childCategoryDetails.ageMin > categoryDetails.ageMax);
+  const invalidAgeMax = childCategoryDetails.ageMax && (categoryDetails.ageMax && childCategoryDetails.ageMax > categoryDetails.ageMax || categoryDetails.ageMin && childCategoryDetails.ageMax < categoryDetails.ageMin);
+  const invalidAgeMinDate = childCategoryDetails.ageMinDate && categoryDetails.ageMaxDate && new Date(childCategoryDetails.ageMinDate) > new Date(categoryDetails.ageMaxDate);
+  const invalidAgeMaxDate = childCategoryDetails.ageMaxDate && categoryDetails.ageMinDate && new Date(childCategoryDetails.ageMaxDate) < new Date(categoryDetails.ageMinDate);
+  const ratingComparison = category.ratingType && childCategory.ratingType && category.ratingType === childCategory.ratingType;
+  const invalidRatingRange = ratingComparison && (category.ratingMin && childCategory.ratingMin && childCategory.ratingMin < category.ratingMin || category.ratingMax && childCategory.ratingMax && childCategory.ratingMax > category.ratingMax || category.ratingMin && childCategory.ratingMax && childCategory.ratingMax < category.ratingMin || category.ratingMax && childCategory.ratingMin && childCategory.ratingMin > category.ratingMax);
+  const invalidBallType = category.ballType && childCategory.ballType && category.ballType !== childCategory.ballType;
+  const valid = !invalidRatingRange && !invalidAgeMinDate && !invalidAgeMaxDate && !invalidBallType && !invalidAgeMax && !invalidAgeMin;
+  const ignoreFalse = true;
+  const result = definedAttributes(
+    {
+      invalidRatingRange,
+      invalidAgeMinDate,
+      invalidAgeMaxDate,
+      invalidBallType,
+      invalidAgeMax,
+      invalidAgeMin,
+      valid
+    },
+    ignoreFalse
+  );
+  if (withDetails) {
+    Object.assign(result, { categoryDetails, childCategoryDetails });
+  }
+  return result;
+}
+
+function mustBeAnArray(value) {
+  return `${value} must be an array`;
+}
+
 function validateTieFormat(params) {
   const checkCategory = !!(params?.enforceCategory !== false && params?.category);
   const checkGender = !!(params?.enforceGender !== false && params?.gender);
@@ -2973,13 +3026,19 @@ function validateCollectionDefinition({
   if (matchUpFormat && !matchUpFormatCode.isValid(matchUpFormat)) {
     errors.push(`Invalid matchUpFormat: ${matchUpFormat}`);
   }
-  if (checkGender && referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && referenceGender !== gender) {
-    errors.push(`Invalid gender: ${gender}`);
-    return decorateResult({
-      result: { error: INVALID_GENDER, errors },
-      context: { referenceGender, gender },
-      stack
+  if (checkGender) {
+    const result = genderValidityCheck({
+      referenceGender,
+      matchUpType,
+      gender
     });
+    if (result.error) {
+      return decorateResult({
+        context: { referenceGender, gender },
+        result,
+        stack
+      });
+    }
   }
   if (checkCategory && referenceCategory && category) {
     const result = categoryCanContain({
@@ -5707,7 +5766,7 @@ const PUBLIC = "PUBLIC";
 const STATUS$1 = "STATUS";
 const MODIFICATION = "MODIFICATION";
 const RETRIEVAL = "RETRIEVAL";
-const OTHER$3 = "other";
+const OTHER$2 = "other";
 const timeItemConstants = {
   MUTUALLY_EXCLUSIVE_TIME_MODIFIERS,
   AFTER_REST,
@@ -5726,7 +5785,7 @@ const timeItemConstants = {
   MODIFICATION,
   NEXT_AVAILABLE,
   NOT_BEFORE,
-  OTHER: OTHER$3,
+  OTHER: OTHER$2,
   PENALTY: PENALTY$1,
   PUBLIC,
   PUBLISH,
@@ -6451,41 +6510,6 @@ function getMatchUpType(params) {
   return { matchUpType };
 }
 
-function modifyEntryProfile({
-  drawDefinition,
-  attributes
-}) {
-  let { extension } = findDrawDefinitionExtension({
-    name: ENTRY_PROFILE,
-    drawDefinition
-  });
-  const entryProfile = extension?.value || {};
-  attributes.forEach((attribute) => {
-    Object.keys(attribute).forEach((key) => {
-      if (!entryProfile[key]) {
-        entryProfile[key] = attribute[key];
-      } else {
-        Object.assign(entryProfile[key], attribute[key]);
-      }
-    });
-  });
-  extension = {
-    name: ENTRY_PROFILE,
-    value: entryProfile
-  };
-  addDrawDefinitionExtension({ drawDefinition, extension });
-  return { entryProfile };
-}
-
-function getEntryProfile({ drawDefinition }) {
-  const { extension } = findDrawDefinitionExtension({
-    name: ENTRY_PROFILE,
-    drawDefinition
-  });
-  const entryProfile = extension?.value || {};
-  return { entryProfile };
-}
-
 const MAIN = "MAIN";
 const QUALIFYING = "QUALIFYING";
 const CONSOLATION = "CONSOLATION";
@@ -6535,6 +6559,7 @@ const WINNER = "WINNER";
 const LOSER = "LOSER";
 const FIRST_MATCHUP = "FIRST_MATCHUP";
 const AD_HOC = "AD_HOC";
+const FLEX_ROUNDS = "AD_HOC";
 const FEED_IN$1 = "FEED_IN";
 const COMPASS = "COMPASS";
 const OLYMPIC = "OLYMPIC";
@@ -6626,6 +6651,7 @@ const drawDefinitionConstants = {
   LOSER,
   AD_HOC,
   FEED_IN: FEED_IN$1,
+  FLEX_ROUNDS,
   COMPASS,
   PLAY_OFF,
   OLYMPIC,
@@ -6751,6 +6777,118 @@ function getDrawStructures({
   }
 }
 
+function getAllPositionedParticipantIds({
+  drawDefinition
+}) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  const stagePositionedParticipantIds = {};
+  const allPositionedParticipantIds = (drawDefinition.structures || []).map((structure) => {
+    const stage = structure.stage;
+    if (!stagePositionedParticipantIds[stage])
+      stagePositionedParticipantIds[stage] = [];
+    const { positionAssignments } = getPositionAssignments$1({ structure });
+    const particiapntIds = positionAssignments?.map(extractAttributes("participantId")).filter(Boolean) ?? [];
+    stagePositionedParticipantIds[stage].push(...particiapntIds);
+    return particiapntIds;
+  }).flat();
+  return { allPositionedParticipantIds, stagePositionedParticipantIds };
+}
+function getPositionAssignments$1({
+  drawDefinition,
+  structureId,
+  structure
+}) {
+  let error, positionAssignments = [];
+  if (!structure) {
+    if (!drawDefinition) {
+      return { positionAssignments, error: MISSING_DRAW_DEFINITION };
+    }
+    ({ structure, error } = findStructure({ drawDefinition, structureId }));
+    if (error)
+      return { positionAssignments, error };
+  }
+  if (structure.structures) {
+    positionAssignments = [].concat(
+      ...structure.structures.map((structure2) => {
+        return getPositionAssignments$1({ structure: structure2 }).positionAssignments;
+      })
+    );
+  } else if (structure.positionAssignments) {
+    positionAssignments = structure.positionAssignments;
+  } else {
+    error = MISSING_POSITION_ASSIGNMENTS;
+  }
+  return { positionAssignments, error };
+}
+function structureAssignedDrawPositions({
+  drawDefinition,
+  structureId,
+  structure
+}) {
+  const positionAssignments = getPositionAssignments$1({
+    drawDefinition,
+    structureId,
+    structure
+  })?.positionAssignments || [];
+  const assignedPositions = positionAssignments?.filter((assignment) => {
+    return assignment.participantId ?? assignment.bye ?? assignment.qualifier;
+  });
+  const allPositionsAssigned = positionAssignments && positionAssignments?.length === assignedPositions?.length;
+  const unassignedPositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && !assignment.bye && !assignment.qualifier;
+  });
+  const byePositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && assignment.bye;
+  });
+  const qualifierPositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && assignment.qualifier;
+  });
+  return {
+    allPositionsAssigned,
+    positionAssignments,
+    unassignedPositions,
+    assignedPositions,
+    qualifierPositions,
+    byePositions
+  };
+}
+
+function modifyEntryProfile({
+  drawDefinition,
+  attributes
+}) {
+  let { extension } = findDrawDefinitionExtension({
+    name: ENTRY_PROFILE,
+    drawDefinition
+  });
+  const entryProfile = extension?.value || {};
+  attributes.forEach((attribute) => {
+    Object.keys(attribute).forEach((key) => {
+      if (!entryProfile[key]) {
+        entryProfile[key] = attribute[key];
+      } else {
+        Object.assign(entryProfile[key], attribute[key]);
+      }
+    });
+  });
+  extension = {
+    name: ENTRY_PROFILE,
+    value: entryProfile
+  };
+  addDrawDefinitionExtension({ drawDefinition, extension });
+  return { entryProfile };
+}
+
+function getEntryProfile({ drawDefinition }) {
+  const { extension } = findDrawDefinitionExtension({
+    name: ENTRY_PROFILE,
+    drawDefinition
+  });
+  const entryProfile = extension?.value || {};
+  return { entryProfile };
+}
+
 const ALTERNATE = EntryStatusEnum.Alternate;
 const CONFIRMED = EntryStatusEnum.Confirmed;
 const DIRECT_ACCEPTANCE = EntryStatusEnum.DirectAcceptance;
@@ -6992,6 +7130,7 @@ function getStageWildcardEntriesCount({ stage, drawDefinition }) {
 
 function getStructureSeedAssignments({
   provisionalPositioning,
+  returnAllProxies,
   drawDefinition,
   structureId,
   structure
@@ -7000,6 +7139,9 @@ function getStructureSeedAssignments({
   if (!structure) {
     ({ structure, error } = findStructure({ drawDefinition, structureId }));
   }
+  const positionAssignments = getPositionAssignments$1({
+    structure
+  }).positionAssignments;
   if (error || !structure)
     return { seedAssignments: [], error: STRUCTURE_NOT_FOUND };
   if (!structureId)
@@ -7013,18 +7155,22 @@ function getStructureSeedAssignments({
     structureId,
     stage
   });
-  const seedProxies = entries ? entries.filter((entry) => entry.placementGroup === 1).sort((a, b) => {
+  const proxiedEntries = entries ? entries.filter((entry) => entry.placementGroup === 1).sort((a, b) => {
     return a.GEMscore < b.GEMscore && 1 || a.GEMscore > b.GEMscore && -1 || 0;
   }).map((entry, index) => {
     const seedNumber = index + 1;
     return {
       participantId: entry.participantId,
       seedValue: seedNumber,
-      seedNumber,
-      seedProxy: true
+      seedProxy: true,
       // flag so that proxy seeding information doesn't get used externally
+      seedNumber
     };
   }) : [];
+  const seedProxies = proxiedEntries?.slice(
+    0,
+    returnAllProxies ? proxiedEntries.length : positionAssignments.length / 2
+  );
   if (seedProxies.length) {
     seedAssignments = seedProxies;
   } else if (structure.seedAssignments) {
@@ -7033,7 +7179,13 @@ function getStructureSeedAssignments({
     error = MISSING_SEED_ASSIGNMENTS;
   }
   const seedLimit = structure.seedLimit || structure?.positionAssignments?.length;
-  return { seedAssignments, seedLimit, stage, stageSequence, error };
+  return {
+    seedAssignments,
+    stageSequence,
+    seedLimit,
+    stage,
+    error
+  };
 }
 
 function getExitProfiles({ drawDefinition }) {
@@ -7312,83 +7464,6 @@ function getSourceDrawPositionRanges({
   return { sourceDrawPositionRanges };
 }
 
-function getAllPositionedParticipantIds({
-  drawDefinition
-}) {
-  if (!drawDefinition)
-    return { error: MISSING_DRAW_DEFINITION };
-  const stagePositionedParticipantIds = {};
-  const allPositionedParticipantIds = (drawDefinition.structures || []).map((structure) => {
-    const stage = structure.stage;
-    if (!stagePositionedParticipantIds[stage])
-      stagePositionedParticipantIds[stage] = [];
-    const { positionAssignments } = getPositionAssignments$1({ structure });
-    const particiapntIds = positionAssignments?.map(extractAttributes("participantId")).filter(Boolean) ?? [];
-    stagePositionedParticipantIds[stage].push(...particiapntIds);
-    return particiapntIds;
-  }).flat();
-  return { allPositionedParticipantIds, stagePositionedParticipantIds };
-}
-function getPositionAssignments$1({
-  drawDefinition,
-  structureId,
-  structure
-}) {
-  let error, positionAssignments = [];
-  if (!structure) {
-    if (!drawDefinition) {
-      return { positionAssignments, error: MISSING_DRAW_DEFINITION };
-    }
-    ({ structure, error } = findStructure({ drawDefinition, structureId }));
-    if (error)
-      return { positionAssignments, error };
-  }
-  if (structure.structures) {
-    positionAssignments = [].concat(
-      ...structure.structures.map((structure2) => {
-        return getPositionAssignments$1({ structure: structure2 }).positionAssignments;
-      })
-    );
-  } else if (structure.positionAssignments) {
-    positionAssignments = structure.positionAssignments;
-  } else {
-    error = MISSING_POSITION_ASSIGNMENTS;
-  }
-  return { positionAssignments, error };
-}
-function structureAssignedDrawPositions({
-  drawDefinition,
-  structureId,
-  structure
-}) {
-  const positionAssignments = getPositionAssignments$1({
-    drawDefinition,
-    structureId,
-    structure
-  })?.positionAssignments || [];
-  const assignedPositions = positionAssignments?.filter((assignment) => {
-    return assignment.participantId ?? assignment.bye ?? assignment.qualifier;
-  });
-  const allPositionsAssigned = positionAssignments && positionAssignments?.length === assignedPositions?.length;
-  const unassignedPositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && !assignment.bye && !assignment.qualifier;
-  });
-  const byePositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && assignment.bye;
-  });
-  const qualifierPositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && assignment.qualifier;
-  });
-  return {
-    allPositionsAssigned,
-    positionAssignments,
-    unassignedPositions,
-    assignedPositions,
-    qualifierPositions,
-    byePositions
-  };
-}
-
 function getOrderedDrawPositions({
   drawPositions,
   roundProfile,
@@ -7952,19 +8027,6 @@ function getSeeding({ seedAssignments, participantId }) {
   );
 }
 
-const ANY = "ANY";
-const MALE = "MALE";
-const MIXED = "MIXED";
-const OTHER$2 = "OTHER";
-const FEMALE = "FEMALE";
-const genderConstants = {
-  ANY,
-  MALE,
-  FEMALE,
-  MIXED,
-  OTHER: OTHER$2
-};
-
 function getAllStructureMatchUps({
   scheduleVisibilityFilters,
   tournamentAppliedPolicies,
@@ -20865,10 +20927,11 @@ function updateMatchUpStatusCodes({
     );
     matchUp.matchUpStatusCodes = (matchUp.matchUpStatusCodes ?? []).map(
       (code) => {
-        if (code.sideNumber === sourceSideNumber) {
-          return { ...code, previousMatchUpStatus: sourceMatchUpStatus };
+        const value = isString(code) || !isNaN(code) ? { code } : code;
+        if (value.sideNumber === sourceSideNumber) {
+          return { ...value, previousMatchUpStatus: sourceMatchUpStatus };
         }
-        return code;
+        return value;
       }
     );
   }
@@ -23758,6 +23821,7 @@ function getSeedingThresholds({
 
 function getValidSeedBlocks({
   provisionalPositioning,
+  returnAllProxies,
   appliedPolicies,
   drawDefinition,
   allPositions,
@@ -23773,6 +23837,7 @@ function getValidSeedBlocks({
   });
   const { seedAssignments } = getStructureSeedAssignments({
     provisionalPositioning,
+    returnAllProxies,
     drawDefinition,
     structure
   });
@@ -24007,6 +24072,7 @@ function getNextSeedBlock(params) {
   } = params;
   const { structure } = findStructure({ drawDefinition, structureId });
   const { seedAssignments } = getStructureSeedAssignments({
+    returnAllProxies: params.returnAllProxies,
     provisionalPositioning,
     drawDefinition,
     structure
@@ -24018,6 +24084,7 @@ function getNextSeedBlock(params) {
   const assignedDrawPositions = positionsWithParticipants?.map((assignment) => assignment.drawPosition).filter(Boolean);
   const { appliedPolicies } = getAppliedPolicies({ drawDefinition });
   const validSeedBlocks = seedBlockInfo?.validSeedBlocks || structure && getValidSeedBlocks({
+    returnAllProxies: params.returnAllProxies,
     provisionalPositioning,
     appliedPolicies,
     drawDefinition,
@@ -38129,7 +38196,7 @@ function engineLogging({ result, methodName, elapsed, params, engine }) {
     log.result = result;
   }
   if (Object.keys(log).length > 1)
-    console.log(engine, log);
+    globalLog$1(engine, log);
   if (result && devContext.makeDeepCopy)
     result.deepCopyIterations = getDeepCopyIterations();
 }
@@ -40972,6 +41039,48 @@ function generateDrawTypeAndModifyDrawDefinition$1(params) {
   };
 }
 
+function processAccessors({
+  significantCharacters,
+  accessors = [],
+  value
+}) {
+  const extractedValues = [];
+  const accessor = accessors[0];
+  if (value?.[accessor]) {
+    const remainingKeys = accessors.slice(1);
+    if (Array.isArray(value[accessor])) {
+      const values = value[accessor];
+      values.forEach((nestedValue) => {
+        const result = processAccessors({
+          accessors: remainingKeys,
+          significantCharacters,
+          value: nestedValue
+        });
+        extractedValues.push(...result);
+      });
+    } else {
+      value = value[accessor];
+      if (remainingKeys.length) {
+        const result = processAccessors({
+          accessors: remainingKeys,
+          significantCharacters,
+          value
+        });
+        extractedValues.push(...result);
+      } else {
+        checkValue({ value });
+      }
+    }
+  }
+  function checkValue({ value: value2 }) {
+    if (value2 && ["string", "number"].includes(typeof value2)) {
+      const extractedValue = significantCharacters ? value2.slice(0, significantCharacters) : value2;
+      extractedValues.push(extractedValue);
+    }
+  }
+  return extractedValues;
+}
+
 function getAttributeGroupings({
   targetParticipantIds,
   policyAttributes,
@@ -41023,8 +41132,14 @@ function extractAttributeValues({
   policyAttributes.forEach((policyAttribute) => {
     const { directive, groupings, key, significantCharacters } = policyAttribute || {};
     if (key) {
-      const keys = key.split(".");
-      processKeys({ value: participant, keys, significantCharacters });
+      const accessors = key.split(".");
+      extractedValues.push(
+        ...processAccessors({
+          significantCharacters,
+          value: participant,
+          accessors
+        })
+      );
     } else if (directive) {
       const includeIds = policyAttribute?.includeIds;
       const collectionIds = (idCollections?.[directive] || []).filter(
@@ -41053,32 +41168,6 @@ function extractAttributeValues({
   });
   const values = unique(extractedValues);
   return { values };
-  function processKeys({ value, keys = [], significantCharacters }) {
-    for (const [index, key] of keys.entries()) {
-      if (value?.[key]) {
-        if (Array.isArray(value[key])) {
-          const values2 = value[key];
-          const remainingKeys = keys.slice(index);
-          values2.forEach(
-            (nestedValue) => processKeys({
-              value: nestedValue,
-              keys: remainingKeys,
-              significantCharacters
-            })
-          );
-        } else {
-          value = value[key];
-          checkValue({ value, index });
-        }
-      }
-    }
-    function checkValue({ value: value2, index }) {
-      if (value2 && index === keys.length - 1 && ["string", "number"].includes(typeof value2)) {
-        const extractedValue = significantCharacters ? value2.slice(0, significantCharacters) : value2;
-        extractedValues.push(extractedValue);
-      }
-    }
-  }
 }
 
 function getPositionedParticipants({
@@ -41574,8 +41663,7 @@ function randomUnseededSeparation({
   structureId,
   avoidance,
   drawSize,
-  entries,
-  // entries for the specific stage of drawDefinition
+  // entries, // entries for the specific stage of drawDefinition
   event
 }) {
   if (!avoidance) {
@@ -41613,10 +41701,11 @@ function randomUnseededSeparation({
   const isRoundRobin = structure?.structureType === CONTAINER;
   const params = isRoundRobin ? { structure, matchUps, allDrawPositions, roundsToSeparate } : { matchUps, allDrawPositions, roundsToSeparate };
   const { drawPositionGroups, drawPositionChunks } = isRoundRobin ? roundRobinParticipantGroups(params) : eliminationParticipantGroups(params);
-  const idCollections = {};
-  idCollections.groupParticipants = participants.filter((participant) => participant.participantType === GROUP).map((participant) => participant.participantId);
-  idCollections.teamParticipants = participants.filter((participant) => participant.participantType === TEAM).map((participant) => participant.participantId);
-  idCollections.pairParticipants = participants.filter((participant) => participant.participantType === PAIR).map((participant) => participant.participantId);
+  const idCollections = {
+    groupParticipants: participants.filter((participant) => participant.participantType === GROUP).map((participant) => participant.participantId),
+    teamParticipants: participants.filter((participant) => participant.participantType === TEAM).map((participant) => participant.participantId),
+    pairParticipants: participants.filter((participant) => participant.participantType === PAIR).map((participant) => participant.participantId)
+  };
   const allGroups = getAttributeGroupings({
     targetParticipantIds: unseededParticipantIds,
     policyAttributes,
@@ -41677,8 +41766,8 @@ function randomUnseededSeparation({
         policyAttributes,
         idCollections,
         allGroups,
-        drawSize,
-        entries
+        drawSize
+        // entries,
       })
     );
     const candidates = noPairPriorityCandidates.concat(...pairedPriorityCandidates).filter((candidate2) => !candidate2.errors?.length);
@@ -41825,7 +41914,7 @@ function positionUnseededParticipants({
     drawDefinition,
     event
   });
-  let { avoidance } = appliedPolicies ?? {};
+  let avoidance = (appliedPolicies ?? {})[POLICY_TYPE_AVOIDANCE];
   if (structure.stage === PLAY_OFF) {
     const groupings = entries.reduce((groupings2, entry) => {
       if (!groupings2[entry.groupingValue])
@@ -42048,11 +42137,11 @@ function getSeedOrderByePositions({
   const strictSeedOrderByePositions = getOrderedByePositions({
     orderedSeedDrawPositions: orderedSortedFirstRoundSeededDrawPositions,
     relevantMatchUps
-  }).slice(0, positionedSeeds.length);
+  }).slice(0, byesToPlace);
   const blockSeedOrderByePositions = getOrderedByePositions({
     orderedSeedDrawPositions: blockSortedRandomDrawPositions,
     relevantMatchUps
-  }).slice(0, positionedSeeds.length);
+  }).slice(0, byesToPlace);
   return {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
@@ -42734,7 +42823,6 @@ function automatedPositioning$1({
       event
     }) : void 0;
     if (result2?.error) {
-      console.log("positionByes", { result: result2 });
       return handleErrorCondition(result2);
     }
     unseededByePositions = result2?.unseededByePositions;
@@ -42857,6 +42945,7 @@ function automatedPlayoffPositioning(params) {
   );
   const structurePositionAssignments = [];
   const participants = tournamentRecord?.participants;
+  const positioningReports = [];
   if (playoffStructures) {
     for (const structure of playoffStructures) {
       const { structureId: playoffStructureId } = structure;
@@ -42878,9 +42967,11 @@ function automatedPlayoffPositioning(params) {
           structureId: playoffStructureId
         });
       }
+      if (result.positioningReport)
+        positioningReports.push(result.positioningReport);
     }
   }
-  return { ...SUCCESS, structurePositionAssignments };
+  return { ...SUCCESS, structurePositionAssignments, positioningReports };
 }
 
 function generateAndPopulateRRplayoffStructures(params) {
@@ -43543,9 +43634,15 @@ function getStructureGroups({
 }
 
 function generateQualifyingStructure$1(params) {
-  if (!params.drawDefinition)
-    return { error: MISSING_DRAW_DEFINITION };
   const stack = "generateQualifyingStructure";
+  if (!params.drawDefinition)
+    return decorateResult({
+      result: { error: MISSING_DRAW_DEFINITION },
+      stack
+    });
+  if (params.drawSize && !isConvertableInteger(params.drawSize) || params.participantsCount && !isConvertableInteger(params.participantsCount) || params.qualifyingPositions && !isConvertableInteger(params.qualifyingPositions)) {
+    return decorateResult({ result: { error: INVALID_VALUES }, stack });
+  }
   let drawSize = params.drawSize ?? coerceEven(params.participantsCount);
   const {
     qualifyingRoundNumber,
@@ -43563,13 +43660,22 @@ function generateQualifyingStructure$1(params) {
     isMock,
     uuids
   } = params;
+  if (!params.drawSize)
+    return decorateResult({
+      result: { error: MISSING_DRAW_SIZE },
+      context: { drawSize },
+      stack
+    });
+  if (qualifyingPositions && qualifyingPositions >= params.drawSize)
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { drawSize, qualifyingPositions },
+      stack
+    });
   let roundLimit, roundsCount, structure, matchUps;
   let qualifiersCount = 0;
   let finishingPositions;
   const stageSequence = 1;
-  if (!isConvertableInteger(drawSize)) {
-    return decorateResult({ result: { error: MISSING_DRAW_SIZE }, stack });
-  }
   const { structureProfiles } = getStructureGroups({ drawDefinition });
   const structureProfile = structureProfiles[targetStructureId];
   if (!structureProfile) {
@@ -47929,6 +48035,7 @@ function getValidAssignmentActions({
   if (!ignoreSeedPositions) {
     const result = getNextSeedBlock({
       provisionalPositioning,
+      returnAllProxies: true,
       randomize: true,
       drawDefinition,
       structureId,
@@ -48454,6 +48561,7 @@ function positionActions$1(params) {
       action: SEED_VALUE
     }) && isAvailableAction({ policyActions, action: SEED_VALUE }) && isValidSeedPosition({ drawDefinition, structureId, drawPosition }) && validToAssignSeed) {
       const { seedAssignments } = getStructureSeedAssignments({
+        returnAllProxies: true,
         drawDefinition,
         structure
       });
@@ -48480,6 +48588,7 @@ function positionActions$1(params) {
       action: REMOVE_SEED
     }) && isAvailableAction({ policyActions, action: REMOVE_SEED }) && isValidSeedPosition({ drawDefinition, structureId, drawPosition }) && validToAssignSeed) {
       const { seedAssignments } = getStructureSeedAssignments({
+        returnAllProxies: true,
         drawDefinition,
         structure
       });
@@ -54675,7 +54784,7 @@ function getEntryStatusReports({
   }).matchUps ?? [];
   const nonTeamEnteredParticipantIds = nonTeamMatchUps.flatMap(
     ({ sides, matchUpType }) => sides?.flatMap(
-      (side) => matchUpType === DOUBLES_MATCHUP ? side.participant?.individualParticipantIds : side.participant?.participantId || side.participantId
+      (side) => matchUpType === DOUBLES_MATCHUP ? side?.participant?.individualParticipantIds : side?.participant?.participantId || side.participantId
     ).filter(Boolean)
   ).filter(Boolean);
   const withDrawnParticipantIds = [];
@@ -54805,13 +54914,14 @@ function getEntryStatusReports({
   const individualParticipants = Object.values(participantMap ?? {}).filter(
     ({ participant: { participantType, participantRole } }) => participantType === INDIVIDUAL && participantRole === COMPETITOR
   );
-  const nonParticipatingParticipants = individualParticipants.filter(
+  const nonParticipatingParticipantIds = individualParticipants.filter(
     ({ participant }) => !nonTeamEnteredParticipantIds.includes(participant.participantId)
   ).map(({ participant }) => participant.participantId);
   const tournamentEntryReport = {
-    nonParticipatingEntriesCount: nonParticipatingParticipants.length,
+    nonParticipatingEntriesCount: nonParticipatingParticipantIds.length,
     individualParticipantsCount: individualParticipants.length,
     eventsCount: Object.values(eventReports).length,
+    nonParticipatingParticipantIds,
     drawDefinitionsCount,
     tournamentId
   };
@@ -62729,11 +62839,11 @@ function anonymizeTournamentRecord({
       if ([MALE, FEMALE].includes(gender)) {
         counts[gender] += 1;
       } else {
-        counts[OTHER$2] += 1;
+        counts[OTHER$3] += 1;
       }
       return counts;
     },
-    { [MALE]: 0, [FEMALE]: 0, [OTHER$2]: 0 }
+    { [MALE]: 0, [FEMALE]: 0, [OTHER$3]: 0 }
   );
   const genderedPersons = Object.assign(
     {},
@@ -62749,7 +62859,7 @@ function anonymizeTournamentRecord({
       })?.persons || []
     }))
   );
-  const genderedIndices = { [MALE]: 0, [FEMALE]: 0, [OTHER$2]: 0 };
+  const genderedIndices = { [MALE]: 0, [FEMALE]: 0, [OTHER$3]: 0 };
   const individualParticipantsCount = individualParticipants.length;
   const addressComponents = individualParticipants.reduce(
     (components, participant) => {
@@ -62783,7 +62893,7 @@ function anonymizeTournamentRecord({
   const addressValues = { cities, states, postalCodes };
   individualParticipants.forEach((individualParticipant, participantIndex) => {
     const person = individualParticipant?.person;
-    const gender = person?.sex || OTHER$2;
+    const gender = person?.sex || OTHER$3;
     const birthYear = extractDate(person?.birthDate)?.split("-")[0];
     const genderedIndex = genderedIndices[gender];
     const generatedPerson = genderedPersons[gender][genderedIndex];
@@ -63338,7 +63448,7 @@ function processTieFormat({
   let maxDoublesCount = 0, maxSinglesCount = 0;
   let singlesMatchUpTotal = 0, doublesMatchUpTotal = 0;
   const categories = {};
-  const genders = { [MALE]: 0, [FEMALE]: 0, [MIXED]: 0, [OTHER$2]: 0, [ANY]: 0 };
+  const genders = { [MALE]: 0, [FEMALE]: 0, [MIXED]: 0, [OTHER$3]: 0, [ANY]: 0 };
   tieFormat = typeof tieFormat === "object" ? tieFormat : tieFormatDefaults({ namedFormat: tieFormatName });
   tieFormat?.collectionDefinitions?.filter(Boolean).forEach((collectionDefinition) => {
     const { category, collectionId, matchUpType, matchUpCount, gender } = collectionDefinition;
@@ -63390,7 +63500,7 @@ function getParticipantsCount({
   const gendersCount = {
     [FEMALE]: 0,
     [MIXED]: 0,
-    [OTHER$2]: 0,
+    [OTHER$3]: 0,
     [MALE]: 0,
     [ANY]: 0
   };
@@ -65049,6 +65159,7 @@ const utilities = {
   findExtension: findExtension$2,
   flattenJSON,
   garman,
+  genderValidityCheck,
   generateHashCode,
   generateRange,
   generateScoreString,
@@ -65089,5 +65200,5 @@ const utilities = {
   visualizeScheduledMatchUps
 };
 
-export { EntryStatusEnum, competitionEngine, competitionEngineAsync, deleteNotices, drawDefinitionConstants, drawEngine, drawEngineAsync, entryStatusConstants, errorConditionConstants, eventConstants, factoryConstants, fixtures, flightConstants, genderConstants, getNotices, keyValueConstants, matchUpActionConstants, matchUpEngine, matchUpEngineAsync, matchUpFormatCode, matchUpStatusConstants, matchUpTypes, mocksEngine, participantConstants, participantRoles, participantTypes, penaltyConstants, policyConstants, positionActionConstants, resultConstants, scaleConstants, scaleEngine, scaleEngineAsync, scoreGovernor, setDeepCopy, setDevContext, setStateProvider, setSubscriptions, surfaceConstants, timeItemConstants, tournamentEngine, tournamentEngineAsync, utilities, venueConstants, factoryVersion as version };
+export { EntryStatusEnum, competitionEngine, competitionEngineAsync, deleteNotices, drawDefinitionConstants, drawEngine, drawEngineAsync, entryStatusConstants, errorConditionConstants, eventConstants, factoryConstants, fixtures, flightConstants, genderConstants, getNotices, keyValueConstants, matchUpActionConstants, matchUpEngine, matchUpEngineAsync, matchUpFormatCode, matchUpStatusConstants, matchUpTypes, mocksEngine, participantConstants, participantRoles, participantTypes, penaltyConstants, policyConstants, positionActionConstants, resultConstants, scaleConstants, scaleEngine, scaleEngineAsync, scoreGovernor, setDeepCopy, setDevContext, setGlobalLog, setStateProvider, setSubscriptions, surfaceConstants, timeItemConstants, tournamentEngine, tournamentEngineAsync, utilities, venueConstants, factoryVersion as version };
 //# sourceMappingURL=index.mjs.map