tods-competition-factory 1.9.1 → 1.9.3

package/dist/index.mjs

@@ -1360,7 +1360,6 @@ function handleCaughtError$1({
 const globalState = {
   tournamentFactoryVersion: "0.0.0",
   timers: { default: { elapsedTime: 0 } },
-  iterators: { makeDeepCopy: 0 },
   deepCopyAttributes: {
     stringify: [],
     ignore: [],
@@ -1437,12 +1436,6 @@ function setGlobalLog(loggingFx) {
 function setDevContext(value) {
   globalState.devContext = value;
 }
-function setDeepCopyIterations(value) {
-  globalState.iterators.makeDeepCopy = value;
-}
-function getDeepCopyIterations() {
-  return globalState.iterators.makeDeepCopy;
-}
 function disableNotifications() {
   _globalStateProvider.disableNotifications();
 }
@@ -1538,7 +1531,13 @@ function handleCaughtError({
 }
 function globalLog$1(engine, log) {
   if (globalState.globalLog) {
-    return globalState.globalLog(engine, log);
+    try {
+      globalState.globalLog(engine, log);
+    } catch (error) {
+      console.log("globalLog error", error);
+      console.log(engine, log);
+      setGlobalLog();
+    }
   } else {
     console.log(engine, log);
   }
@@ -1869,13 +1868,6 @@ function makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtens
   if (!deepCopy?.enabled && !internalUse || typeof sourceObject !== "object" || typeof sourceObject === "function" || sourceObject === null || typeof deepCopy?.threshold === "number" && iteration >= deepCopy.threshold) {
     return sourceObject;
   }
-  const devContext = getDevContext({ makeDeepCopy: true });
-  if (devContext) {
-    setDeepCopyIterations(iteration);
-    if (typeof devContext === "object" && (iteration > (devContext.iterationThreshold || 15) || devContext.firstIteration && iteration === 0) && devContext.log && (!devContext.notInternalUse || devContext.notInternalUse && !internalUse)) {
-      console.log({ devContext, iteration, internalUse }, sourceObject);
-    }
-  }
   const targetObject = Array.isArray(sourceObject) ? [] : {};
   const sourceObjectKeys = Object.keys(sourceObject).filter(
     (key) => !internalUse || !ignore || Array.isArray(ignore) && !ignore.includes(key) || typeof ignore === "function" && !ignore(key)
@@ -2422,7 +2414,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.9.1";
+  return "1.9.3";
 }
 
 function getObjectTieFormat(obj) {
@@ -10336,11 +10328,10 @@ function modifyMatchUpScore({
   }
   if (Array.isArray(defaultedProcessCodes) && inContextMatchUp && !inContextMatchUp.sides?.every(({ participantId }) => participantId)) {
     if (matchUpStatus === DEFAULTED) {
-      if (matchUp.processCodes) {
-        matchUp.processCodes.push(...defaultedProcessCodes);
-      } else {
-        matchUp.processCodes = defaultedProcessCodes;
-      }
+      matchUp.processCodes = unique([
+        ...matchUp.processCodes ?? [],
+        ...defaultedProcessCodes
+      ]);
     } else {
       for (const processCode of defaultedProcessCodes || []) {
         const codeIndex = processCode && matchUp?.processCodes?.lastIndexOf(processCode);
@@ -15131,44 +15122,37 @@ const positionActionConstants = {
   SEED_VALUE
 };
 
-const POLICY_POSITION_ACTIONS_DEFAULT = {
+const POLICY_POSITION_ACTIONS_UNRESTRICTED = {
   [POLICY_TYPE_POSITION_ACTIONS]: {
-    policyName: "positionActionsDefault",
+    policyName: "positionActionsUnrestricted",
+    // positionActions will be selectively enabled for structures matching { stages: [], stageSequences: [], structureTypes: [] }
+    // enabledStructures: [] => all structures are enabled
+    enabledStructures: [],
+    // enables entries in other flights to be accessed as alternates
+    otherFlightEntries: true,
+    // enables entries with multiple qualifying roundTargets to be placed in any round
+    disableRoundRestrictions: true,
+    // enable specific actions even when there are active positions
+    activePositionOverrides: [SEED_VALUE, REMOVE_SEED]
+  }
+};
+
+const POLICY_POSITION_ACTIONS_NO_MOVEMENT = {
+  [POLICY_TYPE_POSITION_ACTIONS]: {
+    policyName: "positionActionsNoMovement",
     // positionActions will be selectively enabled for structures matching { stages: [], stageSequences: [] }
     // enabledStructures: [] => all structures are enabled
     enabledStructures: [
-      {
-        stages: [QUALIFYING, MAIN],
-        // stages to which this policy applies
-        stageSequences: [1],
-        // stageSequences to which this policy applies
-        enabledActions: [],
-        // enabledActions: [] => all actions are enabled
-        disabledActions: []
-        // disabledActions: [] => no actions are disabled
-      },
       {
         stages: [],
         // stages: [] => applies to all stages
         stageSequences: [],
         // stageSequences: [] => applies to all stageSequences
-        enabledActions: [
-          ADD_NICKNAME,
-          ADD_PENALTY,
-          QUALIFYING_PARTICIPANT,
-          SEED_VALUE
-        ],
+        enabledActions: [SEED_VALUE, ADD_NICKNAME, ADD_PENALTY],
         disabledActions: []
         // disabledActions: [] => no actions are disabled
       }
-    ],
-    // positionActions will be completely disabled for any structures matching { stages: [], stageSequences: [] }
-    // disabledStructures: [] => no structures are disabled
-    disbledStructures: [],
-    // enables entries in other flights to be accessed as alternates
-    otherFlightEntries: false,
-    // enable specific actions even when there are active positions
-    activePositionOverrides: []
+    ]
   }
 };
 
@@ -15181,115 +15165,44 @@ const POLICY_POSITION_ACTIONS_DISABLED = {
   }
 };
 
-const POLICY_POSITION_ACTIONS_NO_MOVEMENT = {
+const POLICY_POSITION_ACTIONS_DEFAULT = {
   [POLICY_TYPE_POSITION_ACTIONS]: {
-    policyName: "positionActionsNoMovement",
+    policyName: "positionActionsDefault",
     // positionActions will be selectively enabled for structures matching { stages: [], stageSequences: [] }
     // enabledStructures: [] => all structures are enabled
     enabledStructures: [
+      {
+        stages: [QUALIFYING, MAIN],
+        // stages to which this policy applies
+        stageSequences: [1],
+        // stageSequences to which this policy applies
+        enabledActions: [],
+        // enabledActions: [] => all actions are enabled
+        disabledActions: []
+        // disabledActions: [] => no actions are disabled
+      },
       {
         stages: [],
         // 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
       }
-    ]
-  }
-};
-
-const POLICY_POSITION_ACTIONS_UNRESTRICTED = {
-  [POLICY_TYPE_POSITION_ACTIONS]: {
-    policyName: "positionActionsUnrestricted",
-    // positionActions will be selectively enabled for structures matching { stages: [], stageSequences: [], structureTypes: [] }
-    // enabledStructures: [] => all structures are enabled
-    enabledStructures: [],
+    ],
+    // positionActions will be completely disabled for any structures matching { stages: [], stageSequences: [] }
+    // disabledStructures: [] => no structures are disabled
+    disbledStructures: [],
     // enables entries in other flights to be accessed as alternates
-    otherFlightEntries: true,
-    // enables entries with multiple qualifying roundTargets to be placed in any round
-    disableRoundRestrictions: true,
+    otherFlightEntries: false,
     // enable specific actions even when there are active positions
-    activePositionOverrides: [SEED_VALUE, REMOVE_SEED]
-  }
-};
-
-const POLICY_PRIVACY_DEFAULT = {
-  [POLICY_TYPE_PARTICIPANT]: {
-    policyName: "Participant Privacy Policy",
-    participant: {
-      contacts: false,
-      individualParticipants: {
-        onlineResources: false,
-        participantName: true,
-        participantOtherName: true,
-        participantId: true,
-        participantRole: true,
-        participantStatus: true,
-        penalties: false,
-        representing: true,
-        participantRoleResponsibilities: false,
-        participantType: true,
-        person: {
-          addresses: false,
-          biographicalInformation: false,
-          birthDate: false,
-          contacts: false,
-          nationalityCode: true,
-          nativeFamilyName: false,
-          nativeGivenName: false,
-          onlineResources: false,
-          otherNames: true,
-          parentOrganisationId: false,
-          passportFamilyName: false,
-          passportGivenName: false,
-          personId: false,
-          personOtherIds: false,
-          previousNames: false,
-          sex: false,
-          standardFamilyName: true,
-          standardGivenName: true,
-          status: false,
-          tennisId: false,
-          wheelchair: true
-        }
-      },
-      individualParticipantIds: true,
-      onlineResources: false,
-      participantName: true,
-      participantOtherName: true,
-      participantId: true,
-      participantRole: true,
-      participantStatus: true,
-      penalties: false,
-      representing: true,
-      participantRoleResponsibilities: false,
-      participantType: true,
-      person: {
-        addresses: false,
-        biographicalInformation: false,
-        birthDate: false,
-        contacts: false,
-        nationalityCode: true,
-        nativeFamilyName: false,
-        nativeGivenName: false,
-        onlineResources: false,
-        otherNames: true,
-        parentOrganisationId: false,
-        passportFamilyName: false,
-        passportGivenName: false,
-        personId: false,
-        personOtherIds: false,
-        previousNames: false,
-        sex: false,
-        standardFamilyName: true,
-        standardGivenName: true,
-        status: false,
-        tennisId: false,
-        wheelchair: true
-      }
-    }
+    activePositionOverrides: []
   }
 };
 
@@ -15488,6 +15401,107 @@ const POLICY_SCHEDULING_DEFAULT = {
   }
 };
 
+const POLICY_PRIVACY_DEFAULT = {
+  [POLICY_TYPE_PARTICIPANT]: {
+    policyName: "Participant Privacy Policy",
+    participant: {
+      contacts: false,
+      individualParticipants: {
+        onlineResources: false,
+        participantName: true,
+        participantOtherName: true,
+        participantId: true,
+        participantRole: true,
+        participantStatus: true,
+        penalties: false,
+        representing: true,
+        participantRoleResponsibilities: false,
+        participantType: true,
+        person: {
+          addresses: false,
+          biographicalInformation: false,
+          birthDate: false,
+          contacts: false,
+          nationalityCode: true,
+          nativeFamilyName: false,
+          nativeGivenName: false,
+          onlineResources: false,
+          otherNames: true,
+          parentOrganisationId: false,
+          passportFamilyName: false,
+          passportGivenName: false,
+          personId: false,
+          personOtherIds: false,
+          previousNames: false,
+          sex: false,
+          standardFamilyName: true,
+          standardGivenName: true,
+          status: false,
+          tennisId: false,
+          wheelchair: true
+        }
+      },
+      individualParticipantIds: true,
+      onlineResources: false,
+      participantName: true,
+      participantOtherName: true,
+      participantId: true,
+      participantRole: true,
+      participantStatus: true,
+      penalties: false,
+      representing: true,
+      participantRoleResponsibilities: false,
+      participantType: true,
+      person: {
+        addresses: false,
+        biographicalInformation: false,
+        birthDate: false,
+        contacts: false,
+        nationalityCode: true,
+        nativeFamilyName: false,
+        nativeGivenName: false,
+        onlineResources: false,
+        otherNames: true,
+        parentOrganisationId: false,
+        passportFamilyName: false,
+        passportGivenName: false,
+        personId: false,
+        personOtherIds: false,
+        previousNames: false,
+        sex: false,
+        standardFamilyName: true,
+        standardGivenName: true,
+        status: false,
+        tennisId: false,
+        wheelchair: true
+      }
+    }
+  }
+};
+
+const POLICY_SCORING_DEFAULT = {
+  [POLICY_TYPE_SCORING]: {
+    defaultMatchUpFormat: FORMAT_STANDARD,
+    allowDeletionWithScoresPresent: {
+      drawDefinitions: false,
+      structures: false
+    },
+    requireAllPositionsAssigned: false,
+    processCodes: {
+      incompleteAssignmentsOnDefault: ["RANKING.IGNORE"]
+    },
+    stage: {
+      [MAIN]: {
+        stageSequence: {
+          1: {
+            requireAllPositionsAssigned: true
+          }
+        }
+      }
+    }
+  }
+};
+
 const POLICY_SCORING_USTA = {
   [POLICY_TYPE_SCORING]: {
     requireAllPositionsAssigned: false,
@@ -15584,66 +15598,43 @@ const POLICY_SCORING_USTA = {
   }
 };
 
-const POLICY_SCORING_DEFAULT = {
-  [POLICY_TYPE_SCORING]: {
-    defaultMatchUpFormat: FORMAT_STANDARD,
-    allowDeletionWithScoresPresent: {
-      drawDefinitions: false,
-      structures: false
-    },
-    requireAllPositionsAssigned: false,
-    processCodes: {
-      incompleteAssignmentsOnDefault: ["RANKING.IGNORE"]
-    },
-    stage: {
-      [MAIN]: {
-        stageSequence: {
-          1: {
-            requireAllPositionsAssigned: true
-          }
-        }
-      }
-    }
-  }
-};
-
-const POLICY_SEEDING_ITF = {
+const POLICY_SEEDING_DEFAULT = {
   [POLICY_TYPE_SEEDING]: {
-    seedingProfile: { positioning: CLUSTER },
     validSeedPositions: { ignore: true },
     duplicateSeedNumbers: true,
     drawSizeProgression: true,
-    policyName: "ITF SEEDING",
+    seedingProfile: {
+      drawTypes: {
+        [ROUND_ROBIN_WITH_PLAYOFF]: { positioning: WATERFALL },
+        [ROUND_ROBIN]: { positioning: WATERFALL }
+      },
+      positioning: SEPARATE
+    },
+    policyName: "USTA SEEDING",
     seedsCountThresholds: [
       { drawSize: 4, minimumParticipantCount: 3, seedsCount: 2 },
       { drawSize: 16, minimumParticipantCount: 12, seedsCount: 4 },
       { drawSize: 32, minimumParticipantCount: 24, seedsCount: 8 },
       { drawSize: 64, minimumParticipantCount: 48, seedsCount: 16 },
-      { drawSize: 128, minimumParticipantCount: 97, seedsCount: 32 },
+      { drawSize: 128, minimumParticipantCount: 96, seedsCount: 32 },
       { drawSize: 256, minimumParticipantCount: 192, seedsCount: 64 }
     ]
   }
 };
 
-const POLICY_SEEDING_USTA = {
+const POLICY_SEEDING_ITF = {
   [POLICY_TYPE_SEEDING]: {
+    seedingProfile: { positioning: CLUSTER },
     validSeedPositions: { ignore: true },
     duplicateSeedNumbers: true,
     drawSizeProgression: true,
-    seedingProfile: {
-      drawTypes: {
-        [ROUND_ROBIN_WITH_PLAYOFF]: { positioning: WATERFALL },
-        [ROUND_ROBIN]: { positioning: WATERFALL }
-      },
-      positioning: SEPARATE
-    },
-    policyName: "USTA SEEDING",
+    policyName: "ITF SEEDING",
     seedsCountThresholds: [
       { drawSize: 4, minimumParticipantCount: 3, seedsCount: 2 },
       { drawSize: 16, minimumParticipantCount: 12, seedsCount: 4 },
       { drawSize: 32, minimumParticipantCount: 24, seedsCount: 8 },
       { drawSize: 64, minimumParticipantCount: 48, seedsCount: 16 },
-      { drawSize: 128, minimumParticipantCount: 96, seedsCount: 32 },
+      { drawSize: 128, minimumParticipantCount: 97, seedsCount: 32 },
       { drawSize: 256, minimumParticipantCount: 192, seedsCount: 64 }
     ]
   }
@@ -15661,7 +15652,7 @@ const policies = {
   POLICY_SCORING_DEFAULT,
   POLICY_SCORING_USTA,
   POLICY_SEEDING_ITF,
-  POLICY_SEEDING_USTA
+  POLICY_SEEDING_DEFAULT
 };
 
 const fixtures = {
@@ -26538,6 +26529,34 @@ function updateFactoryExtension({ tournamentRecord, value }) {
   addExtension$1({ element: tournamentRecord, extension: updatedExtension });
 }
 
+function engineLogging({
+  methodName,
+  elapsed,
+  engine,
+  params,
+  result
+}) {
+  const devContext = getDevContext();
+  if (typeof devContext !== "object")
+    return;
+  const log = { method: methodName };
+  const logError = result?.error && (devContext.errors === true || Array.isArray(devContext.errors) && devContext.errors.includes(methodName));
+  const specifiedMethodParams = Array.isArray(devContext.params) && devContext.params?.includes(methodName);
+  const logParams = devContext.params && !Array.isArray(devContext.params) || specifiedMethodParams;
+  const exclude = Array.isArray(devContext.exclude) && devContext.exclude.includes(methodName);
+  if (!exclude && ![void 0, false].includes(devContext.perf) && (isNaN(devContext.perf) || elapsed > devContext.perf)) {
+    log.elapsed = elapsed;
+  }
+  if (!exclude && (logError || logParams)) {
+    log.params = params;
+  }
+  if (!exclude && (logError || devContext.result && !Array.isArray(devContext.result) && (!Array.isArray(devContext.params) || specifiedMethodParams) || Array.isArray(devContext.result) && devContext.result?.includes(methodName))) {
+    log.result = result;
+  }
+  if (Object.keys(log).length > 1)
+    globalLog$1(engine, log);
+}
+
 function notifySubscribers(params) {
   const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
   const { topics } = getTopics();
@@ -40664,27 +40683,6 @@ function setState$4(records, deepCopyOption = true) {
   return setTournamentRecords(deepCopyOption ? makeDeepCopy(records) : records);
 }
 
-function engineLogging({ result, methodName, elapsed, params, engine }) {
-  const devContext = getDevContext();
-  const log = { method: methodName };
-  const logError = result?.error && (devContext.errors === true || Array.isArray(devContext.errors) && devContext.errors.includes(methodName));
-  const specifiedMethodParams = Array.isArray(devContext.params) && devContext.params?.includes(methodName);
-  const logParams = devContext.params && !Array.isArray(devContext.params) || specifiedMethodParams;
-  const exclude = Array.isArray(devContext.exclude) && devContext.exclude.includes(methodName);
-  if (!exclude && ![void 0, false].includes(devContext.perf) && (isNaN(devContext.perf) || elapsed > devContext.perf))
-    log.elapsed = elapsed;
-  if (!exclude && (logError || logParams)) {
-    log.params = params;
-  }
-  if (!exclude && (logError || devContext.result && !Array.isArray(devContext.result) && (!Array.isArray(devContext.params) || specifiedMethodParams) || Array.isArray(devContext.result) && devContext.result?.includes(methodName))) {
-    log.result = result;
-  }
-  if (Object.keys(log).length > 1)
-    globalLog$1(engine, log);
-  if (result && devContext.makeDeepCopy)
-    result.deepCopyIterations = getDeepCopyIterations();
-}
-
 const competitionEngine = function() {
   const engine = {
     getState: (params) => getState$3({
@@ -40816,6 +40814,7 @@ const competitionEngine = function() {
       return { error: INVALID_VALUES };
     const tournamentRecords = getTournamentRecords();
     const activeTournamentId = getTournamentId();
+    const start = Date.now();
     const snapshot = rollbackOnError && makeDeepCopy(tournamentRecords, false, true);
     let timeStamp;
     const results = [];
@@ -40825,10 +40824,8 @@ const competitionEngine = function() {
       const { method: methodName, params } = directive;
       if (!engine[methodName]) {
         const result3 = { error: METHOD_NOT_FOUND, methodName };
-        const devContext = getDevContext();
-        if (devContext.result && !Array.isArray(devContext.result) || Array.isArray(devContext.result) && devContext.result?.includes(methodName)) {
-          console.log("ce:", result3);
-        }
+        const elapsed = Date.now() - start;
+        engineLogging({ result: result3, methodName, elapsed, params, engine: "ce:" });
         return result3;
       }
       const result2 = executeFunction(
@@ -43879,11 +43876,14 @@ function randomUnseededSeparation({
     idCollections,
     participants
   });
+  if (allGroups.error) {
+    return decorateResult({ result: allGroups, stack });
+  }
   const participantIdGroups = Object.assign(
     {},
     ...unseededParticipantIds.map((participantId) => {
       const groups = Object.keys(allGroups).filter(
-        (key) => allGroups[key].includes(participantId)
+        (key) => (allGroups[key] ?? []).includes(participantId)
       );
       return { [participantId]: groups };
     })
@@ -44081,7 +44081,7 @@ function positionUnseededParticipants({
     drawDefinition,
     event
   });
-  let avoidance = (appliedPolicies ?? {})[POLICY_TYPE_AVOIDANCE];
+  let avoidance = appliedPolicies?.[POLICY_TYPE_AVOIDANCE];
   if (structure.stage === PLAY_OFF) {
     const groupings = entries.reduce((groupings2, entry) => {
       if (!groupings2[entry.groupingValue])
@@ -49476,8 +49476,8 @@ const matchUpGovernor = {
 };
 
 function attachPolicies({
-  drawDefinition,
-  policyDefinitions
+  policyDefinitions,
+  drawDefinition
 }) {
   if (!drawDefinition) {
     return { error: MISSING_DRAW_DEFINITION };
@@ -56513,11 +56513,12 @@ function replaceTieMatchUpParticipantId(params) {
   }
   if (substitution || side.substitutions?.length === 1) {
     if (substitution) {
-      const processCodes = tieMatchUp?.processCodes ?? [];
-      if (substitutionProcessCodes)
-        processCodes.push(...substitutionProcessCodes);
-      if (tieMatchUp)
-        tieMatchUp.processCodes = processCodes;
+      if (substitutionProcessCodes && tieMatchUp) {
+        tieMatchUp.processCodes = unique([
+          ...tieMatchUp?.processCodes ?? [],
+          ...substitutionProcessCodes
+        ]);
+      }
     } else {
       for (const substitutionProcessCode of substitutionProcessCodes || []) {
         const codeIndex = tieMatchUp?.processCodes?.lastIndexOf(
@@ -59925,13 +59926,15 @@ function generateDrawDefinition(params) {
   if (params.seedingProfile) {
     if (!policyDefinitions[POLICY_TYPE_SEEDING]) {
       policyDefinitions[POLICY_TYPE_SEEDING] = {
-        ...POLICY_SEEDING_USTA[POLICY_TYPE_SEEDING]
+        ...POLICY_SEEDING_DEFAULT[POLICY_TYPE_SEEDING]
       };
     }
     policyDefinitions[POLICY_TYPE_SEEDING].seedingProfile = seedingProfile;
   }
   const { participants, participantMap } = getParticipants$1({
     withIndividualParticipants: true,
+    convertExtensions: true,
+    internalUse: true,
     tournamentRecord
   });
   const enforceGender = params.enforceGender ?? policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender;
@@ -60042,6 +60045,10 @@ function generateDrawDefinition(params) {
         drawDefinition.matchUpType = matchUpType;
     }
   }
+  const policiesToAttach = {
+    [POLICY_TYPE_AVOIDANCE]: appliedPolicies[POLICY_TYPE_AVOIDANCE],
+    ...POLICY_SEEDING_DEFAULT
+  };
   if (policyDefinitions) {
     if (typeof policyDefinitions !== "object") {
       return decorateResult({
@@ -60050,7 +60057,6 @@ function generateDrawDefinition(params) {
         stack
       });
     } else {
-      const policiesToAttach = {};
       for (const key of Object.keys(policyDefinitions)) {
         if (JSON.stringify(appliedPolicies?.[key]) !== JSON.stringify(policyDefinitions[key])) {
           policiesToAttach[key] = policyDefinitions[key];
@@ -60061,10 +60067,11 @@ function generateDrawDefinition(params) {
         Object.assign(appliedPolicies, policiesToAttach);
       }
     }
+  } else if (policiesToAttach.avoidance) {
+    attachPolicies({ drawDefinition, policyDefinitions: policiesToAttach });
   }
   if (!appliedPolicies[POLICY_TYPE_SEEDING] && !policyDefinitions[POLICY_TYPE_SEEDING]) {
-    attachPolicies({ drawDefinition, policyDefinitions: POLICY_SEEDING_USTA });
-    Object.assign(appliedPolicies, POLICY_SEEDING_USTA);
+    Object.assign(appliedPolicies, POLICY_SEEDING_DEFAULT);
   }
   let structureId = existingDrawDefinition?.structures?.find(
     (structure) => structure.stage === MAIN && structure.stageSequence === 1
@@ -61671,6 +61678,7 @@ const tournamentEngine = (() => {
   function executionQueue(directives, rollbackOnError) {
     if (!Array.isArray(directives))
       return { error: INVALID_VALUES };
+    const start = Date.now();
     const tournamentId = getTournamentId();
     const tournamentRecord = getTournamentRecord(tournamentId);
     const snapshot = rollbackOnError && makeDeepCopy(tournamentRecord, false, true);
@@ -61681,10 +61689,8 @@ const tournamentEngine = (() => {
       const { method: methodName, params } = directive;
       if (!engine[methodName]) {
         const result3 = { error: METHOD_NOT_FOUND, methodName };
-        const devContext = getDevContext();
-        if (devContext.result && !Array.isArray(devContext.result) || Array.isArray(devContext.result) && devContext.result?.includes(methodName)) {
-          console.log("te:", result3);
-        }
+        const elapsed = Date.now() - start;
+        engineLogging({ result: result3, methodName, elapsed, params, engine: "te:" });
         return result3;
       }
       const result2 = executeFunction(