tods-competition-factory 7.4.0 → 7.6.0

package/README.md

@@ -142,7 +142,7 @@ Full documentation with interactive examples: **[courthive.github.io/competition
 
 ## Testing
 
-**13,700+ tests** covering draw generation and exit propagation, scheduling, scoring, participants and entries, team competition, publishing and embargo, ranking points and ratings, officiating and sanctioning.
+**15,000+ tests** covering draw generation and exit propagation, scheduling, scoring, participants and entries, team competition, publishing and embargo, ranking points and ratings, officiating and sanctioning.
 
 Beyond conventional unit and integration tests, the suite includes relational property suites (do/undo, idempotence, monotonicity), agreement oracles, and an at-scale randomized sweep with delta-debugging for exit propagation — added because full branch coverage of a propagation guard proved compatible with hundreds of wrong answers.
 

package/dist/esm/acquire/findDrawMatchUp.mjs

@@ -1,3 +1,4 @@
+import { getMatchUpsMap, getMappedStructureMatchUps } from '../query/matchUps/getMatchUpsMap.mjs';
 import { checkRequiredParameters } from '../helpers/parameters/checkRequiredParameters.mjs';
 import { getAllStructureMatchUps } from '../query/matchUps/getAllStructureMatchUps.mjs';
 import { getContextContent } from '../query/hierarchical/getContextContent.mjs';
@@ -10,11 +11,15 @@ function findDrawMatchUp(params) {
     const paramsCheck = checkRequiredParameters(params, [{ [DRAW_DEFINITION]: true, [MATCHUP_ID]: true }]);
     if (paramsCheck.error)
         return paramsCheck;
-    const { tournamentParticipants, participantsProfile, afterRecoveryTimes, contextProfile, drawDefinition, matchUpsMap, matchUpId, inContext, context, event, } = params;
+    const { tournamentParticipants, participantsProfile, afterRecoveryTimes, contextProfile, drawDefinition, matchUpId, inContext, context, event, } = params;
     const { structures = [] } = getDrawStructures({ drawDefinition });
     const contextContent = params.contextContent ?? (contextProfile && getContextContent({ contextProfile, drawDefinition }));
+    const matchUpsMap = params.matchUpsMap ?? getMatchUpsMap({ drawDefinition });
     for (const structure of structures) {
+        if (!structureHoldsMatchUp({ structureId: structure.structureId, matchUpsMap, matchUpId }))
+            continue;
         const { matchUps } = getAllStructureMatchUps({
+            hydrateMatchUpId: inContext ? matchUpId : undefined,
             tournamentParticipants,
             participantsProfile,
             afterRecoveryTimes,
@@ -33,5 +38,9 @@ function findDrawMatchUp(params) {
     }
     return { error: MATCHUP_NOT_FOUND };
 }
+function structureHoldsMatchUp({ matchUpsMap, structureId, matchUpId, }) {
+    return getMappedStructureMatchUps({ matchUpsMap, structureId }).some((matchUp) => matchUp.matchUpId === matchUpId ||
+        matchUp.tieMatchUps?.some((tieMatchUp) => tieMatchUp.matchUpId === matchUpId));
+}
 
 export { findDrawMatchUp };

package/dist/esm/assemblies/engines/async/asyncEngineInvoke.mjs

@@ -1,12 +1,13 @@
 import { getMutationStatus } from '../parts/getMutationStatus.mjs';
 import { logMethodNotFound } from '../parts/logMethodNotFound.mjs';
-import { getTournamentRecords, deleteNotices } from '../../../global/state/globalState.mjs';
+import { getTournamentRecords, deleteNotices, getInvokeObserver } from '../../../global/state/globalState.mjs';
 import { executeFunction } from '../parts/executeMethod.mjs';
 import { notifySubscribersAsync } from '../../../global/state/notifySubscribers.mjs';
 import { setState } from '../parts/stateMethods.mjs';
 import { isObject, isFunction, isString } from '../../../tools/objects.mjs';
 import { getMethods } from '../../../global/state/syncGlobalState.mjs';
 import { makeDeepCopy } from '../../../tools/makeDeepCopy.mjs';
+import { nowMs } from '../../../tools/clock.mjs';
 import { INVALID_VALUES, METHOD_NOT_FOUND } from '../../../constants/errorConditionConstants.mjs';
 
 async function asyncEngineInvoke(engine, args) {
@@ -32,7 +33,7 @@ async function asyncEngineInvoke(engine, args) {
     const result = (await executeFunction(engine, method, params, methodName, 'async')) ?? {};
     if (result?.error && snapshot)
         setState(snapshot);
-    const timeStamp = Date.now();
+    const timeStamp = nowMs();
     const mutationStatus = getMutationStatus({ timeStamp });
     const notify = result?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
     if (notify)
@@ -43,6 +44,7 @@ async function asyncEngineInvoke(engine, args) {
         });
     if (notify || !result?.success || params?.doNotNotify)
         deleteNotices();
+    getInvokeObserver()?.({ phase: 'after', methodName, engineType: 'async', params, result });
     return result;
 }
 

package/dist/esm/assemblies/engines/async/asyncExecutionQueue.mjs

@@ -1,10 +1,11 @@
-import { getMethods, getTournamentRecords, deleteNotices } from '../../../global/state/globalState.mjs';
+import { getMethods, getTournamentRecords, deleteNotices, getInvokeObserver } from '../../../global/state/globalState.mjs';
 import { getMutationStatus } from '../parts/getMutationStatus.mjs';
 import { logMethodNotFound } from '../parts/logMethodNotFound.mjs';
 import { executeFunction } from '../parts/executeMethod.mjs';
 import { notifySubscribersAsync } from '../../../global/state/notifySubscribers.mjs';
 import { setState } from '../parts/stateMethods.mjs';
 import { makeDeepCopy } from '../../../tools/makeDeepCopy.mjs';
+import { nowMs } from '../../../tools/clock.mjs';
 import { INVALID_VALUES } from '../../../constants/errorConditionConstants.mjs';
 
 async function asyncExecutionQueue(engine, directives, rollbackOnError) {
@@ -30,6 +31,7 @@ async function asyncExecutionQueue(engine, directives, rollbackOnError) {
             }
         }
         const result = executeFunction(engine, methods[methodName], params, methodName, 'async');
+        getInvokeObserver()?.({ phase: 'after', methodName, engineType: 'async', params, result });
         if (result?.error) {
             if (snapshot)
                 setState(snapshot);
@@ -37,7 +39,7 @@ async function asyncExecutionQueue(engine, directives, rollbackOnError) {
         }
         results.push({ ...result, methodName });
     }
-    const timeStamp = Date.now();
+    const timeStamp = nowMs();
     const mutationStatus = getMutationStatus({ timeStamp });
     await notifySubscribersAsync({ directives, mutationStatus, timeStamp });
     deleteNotices();

package/dist/esm/assemblies/engines/parts/checkMutationLock.mjs

@@ -2,6 +2,7 @@ import { methodScopeMap } from '../../../constants/mutationLockScopeMap.mjs';
 import { addExtension } from '../../../mutate/extensions/addExtension.mjs';
 import { findExtension } from '../../../acquire/findExtension.mjs';
 import { findVenue } from '../../../query/venues/findVenue.mjs';
+import { nowIso } from '../../../tools/clock.mjs';
 import { MUTATION_LOCKED } from '../../../constants/errorConditionConstants.mjs';
 import { MUTATION_LOCKS } from '../../../constants/extensionConstants.mjs';
 
@@ -15,7 +16,7 @@ function checkMutationLock(methodName, params, tournamentRecord) {
     if (!scope)
         return undefined;
     const lockToken = params.lockToken;
-    const now = new Date().toISOString();
+    const now = nowIso();
     const elements = [];
     if (params.drawDefinition) {
         elements.push({ element: params.drawDefinition, label: `draw:${params.drawDefinition.drawId}` });

package/dist/esm/assemblies/engines/parts/engineStart.mjs

@@ -8,9 +8,11 @@ import { createTournamentRecord } from '../../generators/tournamentRecords/creat
 import { methodImporter } from './methodImporter.mjs';
 import { processResult } from './processResult.mjs';
 import { factoryVersion } from '../../../functions/global/factoryVersion.mjs';
+import { setRandomSource } from '../../../tools/prng.mjs';
 import { getTournament, getState, setTournamentRecord, setState, removeUnlinkedTournamentRecords } from './stateMethods.mjs';
-import { setTournamentRecords, getDevContext, getSchemaWriteMode, getSaveDrawDeletions, getAuditAuthorityServer, setTournamentId, setDeepCopy, getTournamentId, removeTournamentRecord, setDevContext, setSchemaWriteMode, setSaveDrawDeletions, setAuditAuthorityServer } from '../../../global/state/globalState.mjs';
+import { setTournamentRecords, getDevContext, getSchemaWriteMode, getOutcomePipeline, getSaveDrawDeletions, getAuditAuthorityServer, setTournamentId, setDeepCopy, getTournamentId, removeTournamentRecord, setDevContext, setSchemaWriteMode, setOutcomePipeline, setSaveDrawDeletions, setAuditAuthorityServer } from '../../../global/state/globalState.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';
+import { setClock } from '../../../tools/clock.mjs';
 
 function engineStart(engine, engineInvoke) {
     engine.importMethods = (methods, collections, depth, global) => methodImporter(engine, engineInvoke, methods, collections, depth, global);
@@ -34,6 +36,11 @@ function engineStart(engine, engineInvoke) {
         return processResult(engine, result);
     };
     engine.getSchemaWriteMode = () => getSchemaWriteMode();
+    engine.outcomePipeline = (mode) => {
+        const result = setOutcomePipeline(mode);
+        return processResult(engine, result);
+    };
+    engine.getOutcomePipeline = () => getOutcomePipeline();
     engine.saveDrawDeletions = (flag) => {
         const result = setSaveDrawDeletions(flag);
         return processResult(engine, result);
@@ -44,6 +51,14 @@ function engineStart(engine, engineInvoke) {
         return processResult(engine, result);
     };
     engine.getAuditAuthorityServer = () => getAuditAuthorityServer();
+    engine.setRandomSource = (source) => {
+        const result = setRandomSource(source);
+        return processResult(engine, result);
+    };
+    engine.setClock = (clock) => {
+        const result = setClock(clock);
+        return processResult(engine, result);
+    };
     engine.newTournamentRecord = (params = {}) => {
         const result = createTournamentRecord(params);
         const tournamentId = result.tournamentId;

package/dist/esm/assemblies/engines/parts/executeMethod.mjs

@@ -2,7 +2,7 @@ import { engineLogging } from '../../../global/state/engineLogging.mjs';
 import { checkMutationLock } from './checkMutationLock.mjs';
 import { paramsMiddleware } from './paramsMiddleware.mjs';
 import { makeDeepCopy } from '../../../tools/makeDeepCopy.mjs';
-import { getTournamentId, getTournamentRecord, getTournamentRecords, getDevContext, handleCaughtError } from '../../../global/state/globalState.mjs';
+import { getTournamentId, getTournamentRecord, getTournamentRecords, getDevContext, handleCaughtError, getInvokeObserver } from '../../../global/state/globalState.mjs';
 
 function executeFunction(engine, method, params, methodName, engineType, options) {
     delete engine.success;
@@ -17,22 +17,20 @@ function executeFunction(engine, method, params, methodName, engineType, options
     }) ||
         getTournamentRecords();
     const paramsToLog = params ? makeDeepCopy(params, undefined, true) : undefined;
+    getInvokeObserver()?.({ phase: 'before', methodName, engineType, params: paramsToLog });
+    const result = resolve({ method, params, methodName, tournamentRecords, tournamentRecord });
+    const elapsed = Date.now() - start;
+    engineLogging({ result, methodName, elapsed, params: paramsToLog, engineType, dryRun: options?.dryRun });
+    return result;
+}
+function resolve({ method, params, methodName, tournamentRecords, tournamentRecord }) {
     const augmentedParams = params ? paramsMiddleware(tournamentRecords, params) : undefined;
     if (augmentedParams?.error)
         return augmentedParams;
     const lockError = checkMutationLock(methodName, augmentedParams, tournamentRecord);
     if (lockError)
         return lockError;
-    const result = invoke({
-        params: augmentedParams,
-        tournamentRecords,
-        tournamentRecord,
-        methodName,
-        method,
-    });
-    const elapsed = Date.now() - start;
-    engineLogging({ result, methodName, elapsed, params: paramsToLog, engineType, dryRun: options?.dryRun });
-    return result;
+    return invoke({ params: augmentedParams, tournamentRecords, tournamentRecord, methodName, method });
 }
 function invoke({ tournamentRecords, tournamentRecord, params, methodName, method }) {
     if (getDevContext()) {

package/dist/esm/assemblies/engines/scoring/ScoringEngine.mjs

@@ -1,3 +1,4 @@
+import { openSetNumber, finalSetGoverns } from '../../../helpers/matchUpFormatCode/aggregateDecider.mjs';
 import { calculateMatchStatistics } from '../../../query/scoring/statistics/standalone.mjs';
 import { toStatObjects } from '../../../query/scoring/statistics/toStatObjects.mjs';
 import { resolveSetType } from '../../../tools/scoring/scoringUtilities.mjs';
@@ -8,7 +9,9 @@ import { getEpisodes } from '../../../query/scoring/getEpisodes.mjs';
 import { isComplete } from '../../../query/scoring/isComplete.mjs';
 import { getWinner } from '../../../query/scoring/getWinner.mjs';
 import { getScore } from '../../../query/scoring/getScore.mjs';
+import { nowIso } from '../../../tools/clock.mjs';
 import { addPoint, deriveServer, deriveServerBase, checkStandardSetWon, checkAndFinalizeMatch } from '../../../mutate/scoring/addPoint.mjs';
+import { COMPLETED, TO_BE_PLAYED, IN_PROGRESS } from '../../../constants/matchUpStatusValues.mjs';
 
 class ScoringEngine {
     constructor(options = {}) {
@@ -49,7 +52,7 @@ class ScoringEngine {
         const pointIndex = this.state.history?.points.length || 0;
         const prevTotalGames = this.state.score.sets.reduce((sum, s) => sum + (s.side1Score || 0) + (s.side2Score || 0), 0);
         const prevCompletedSets = this.state.score.sets.filter((s) => s.winningSide !== undefined).length;
-        const prevComplete = this.state.matchUpStatus === 'COMPLETED';
+        const prevComplete = this.state.matchUpStatus === COMPLETED;
         const activePlayersSnapshot = this.hasLineUp() ? this.getActivePlayers() : undefined;
         this.state = addPoint(this.state, options, {
             pointMultipliers: this.pointMultipliers,
@@ -81,7 +84,7 @@ class ScoringEngine {
                 result: options.result,
                 penaltyType: options.penaltyType,
             },
-            timestamp: options.timestamp || new Date().toISOString(),
+            timestamp: options.timestamp || nowIso(),
             pointIndex,
         });
         this.redoStack = [];
@@ -98,7 +101,7 @@ class ScoringEngine {
                 const setWinner = completedSet?.winningSide === 1 ? 0 : 1;
                 this.eventHandlers.onSetComplete?.({ ...ctx, setWinner });
             }
-            if (!prevComplete && this.state.matchUpStatus === 'COMPLETED') {
+            if (!prevComplete && this.state.matchUpStatus === COMPLETED) {
                 const matchWinner = this.state.winningSide === 1 ? 0 : 1;
                 this.eventHandlers.onMatchComplete?.({ ...ctx, matchWinner });
             }
@@ -111,7 +114,7 @@ class ScoringEngine {
         this.state.history.entries.push({
             type: 'set',
             data: { ...options, winningSide },
-            timestamp: options.timestamp || new Date().toISOString(),
+            timestamp: options.timestamp || nowIso(),
         });
         this.redoStack = [];
     }
@@ -121,7 +124,7 @@ class ScoringEngine {
         this.state.history.entries.push({
             type: 'game',
             data: options,
-            timestamp: options.timestamp || new Date().toISOString(),
+            timestamp: options.timestamp || nowIso(),
         });
         this.redoStack = [];
     }
@@ -132,7 +135,7 @@ class ScoringEngine {
         this.state.history.entries.push({
             type: 'endSegment',
             data: { setNumber: currentSetIndex + 1, ...options },
-            timestamp: options?.timestamp || new Date().toISOString(),
+            timestamp: options?.timestamp || nowIso(),
         });
     }
     setInitialScore(options) {
@@ -143,10 +146,10 @@ class ScoringEngine {
         this.state.history.entries.push({
             type: 'setInitialScore',
             data: options,
-            timestamp: new Date().toISOString(),
+            timestamp: nowIso(),
         });
-        if (this.state.matchUpStatus === 'TO_BE_PLAYED') {
-            this.state.matchUpStatus = 'IN_PROGRESS';
+        if (this.state.matchUpStatus === TO_BE_PLAYED) {
+            this.state.matchUpStatus = IN_PROGRESS;
         }
     }
     undo(count = 1) {
@@ -257,7 +260,7 @@ class ScoringEngine {
             if (set.winningSide === 2)
                 setsWon[1]++;
         });
-        const setType = resolveSetType(this.cachedFormatStructure, setsWon);
+        const setType = resolveSetType(this.cachedFormatStructure, setsWon, openSetNumber(this.state.score.sets));
         return deriveServer(this.state, this.cachedFormatStructure, setType);
     }
     setServer(side, options) {
@@ -270,7 +273,7 @@ class ScoringEngine {
             if (set.winningSide === 2)
                 setsWon[1]++;
         });
-        const setType = resolveSetType(this.cachedFormatStructure, setsWon);
+        const setType = resolveSetType(this.cachedFormatStructure, setsWon, openSetNumber(this.state.score.sets));
         const baseServer = deriveServerBase(this.state, this.cachedFormatStructure, setType);
         this.state.serverFlip = side !== baseServer;
         if (options?.recordEntry === false)
@@ -279,7 +282,7 @@ class ScoringEngine {
         this.state.history.entries.push({
             type: 'setServer',
             data: { side },
-            timestamp: new Date().toISOString(),
+            timestamp: nowIso(),
         });
         this.redoStack = [];
     }
@@ -375,7 +378,7 @@ class ScoringEngine {
         this.state.history.entries.push({
             type: 'substitution',
             data: subEvent,
-            timestamp: options.timestamp || new Date().toISOString(),
+            timestamp: options.timestamp || nowIso(),
         });
         this.redoStack = [];
     }
@@ -568,8 +571,8 @@ class ScoringEngine {
         if (side2TiebreakScore !== undefined)
             newSet.side2TiebreakScore = side2TiebreakScore;
         this.state.score.sets.push(newSet);
-        if (this.state.matchUpStatus === 'TO_BE_PLAYED') {
-            this.state.matchUpStatus = 'IN_PROGRESS';
+        if (this.state.matchUpStatus === TO_BE_PLAYED) {
+            this.state.matchUpStatus = IN_PROGRESS;
         }
         if (winningSide !== undefined) {
             this.checkMatchCompletion();
@@ -602,8 +605,8 @@ class ScoringEngine {
             currentSet.side1TiebreakScore = tiebreakScore[0];
             currentSet.side2TiebreakScore = tiebreakScore[1];
         }
-        if (this.state.matchUpStatus === 'TO_BE_PLAYED') {
-            this.state.matchUpStatus = 'IN_PROGRESS';
+        if (this.state.matchUpStatus === TO_BE_PLAYED) {
+            this.state.matchUpStatus = IN_PROGRESS;
         }
         this.checkSetCompletion(currentSet);
         if (currentSet.winningSide !== undefined) {
@@ -652,7 +655,8 @@ class ScoringEngine {
             if (set.winningSide === 2)
                 setsWon[1]++;
         });
-        const isDecidingSet = setsWon[0] === setsToWin - 1 && setsWon[1] === setsToWin - 1;
+        const setNumber = currentSet.setNumber ?? this.state.score.sets.indexOf(currentSet) + 1;
+        const isDecidingSet = finalSetGoverns(formatStructure, setNumber, setsWon[0] === setsToWin - 1 && setsWon[1] === setsToWin - 1);
         const activeSetFormat = isDecidingSet && formatStructure.finalSetFormat ? formatStructure.finalSetFormat : formatStructure.setFormat;
         if (!activeSetFormat)
             return;
@@ -729,8 +733,8 @@ class ScoringEngine {
         }
         if (this.initialScore) {
             this.applyInitialScore(newState, this.initialScore);
-            if (newState.matchUpStatus === 'TO_BE_PLAYED') {
-                newState.matchUpStatus = 'IN_PROGRESS';
+            if (newState.matchUpStatus === TO_BE_PLAYED) {
+                newState.matchUpStatus = IN_PROGRESS;
             }
         }
         newState.history = { points: [], entries: [...entries] };
@@ -744,7 +748,7 @@ class ScoringEngine {
             if (set.winningSide === 2)
                 setsWon[1]++;
         });
-        const setType = resolveSetType(this.cachedFormatStructure, setsWon);
+        const setType = resolveSetType(this.cachedFormatStructure, setsWon, openSetNumber(this.state.score.sets));
         const baseServer = deriveServerBase(this.state, this.cachedFormatStructure, setType);
         this.state.serverFlip = data.side !== baseServer;
     }
@@ -757,8 +761,8 @@ class ScoringEngine {
         });
         if (this.initialScore) {
             this.applyInitialScore(newState, this.initialScore);
-            if (newState.matchUpStatus === 'TO_BE_PLAYED') {
-                newState.matchUpStatus = 'IN_PROGRESS';
+            if (newState.matchUpStatus === TO_BE_PLAYED) {
+                newState.matchUpStatus = IN_PROGRESS;
             }
         }
         for (const point of currentPoints) {
@@ -791,7 +795,8 @@ class ScoringEngine {
             }
             if (setData.winningSide === undefined) {
                 const fs = this.cachedFormatStructure;
-                const setFormat = fs?.finalSetFormat && i === (fs.bestOf ?? fs.exactly ?? 3) - 1 ? fs.finalSetFormat : fs?.setFormat;
+                const isFinalSet = finalSetGoverns(fs, i + 1, i === (fs?.bestOf ?? fs?.exactly ?? 3) - 1);
+                const setFormat = fs?.finalSetFormat && isFinalSet ? fs.finalSetFormat : fs?.setFormat;
                 const setTo = setFormat?.setTo;
                 if (setTo && (setData.side1Score >= setTo || setData.side2Score >= setTo)) {
                     if (setData.side1Score > setData.side2Score)

package/dist/esm/assemblies/engines/sync/engineInvoke.mjs

@@ -1,6 +1,6 @@
 import { getMutationStatus } from '../parts/getMutationStatus.mjs';
 import { logMethodNotFound } from '../parts/logMethodNotFound.mjs';
-import { getTournamentRecords, deleteNotices } from '../../../global/state/globalState.mjs';
+import { getTournamentRecords, deleteNotices, getInvokeObserver } from '../../../global/state/globalState.mjs';
 import { executeFunction } from '../parts/executeMethod.mjs';
 import { notifySubscribers } from '../../../global/state/notifySubscribers.mjs';
 import { setState } from '../parts/stateMethods.mjs';
@@ -9,6 +9,7 @@ import { getMethods } from '../../../global/state/syncGlobalState.mjs';
 import { makeDeepCopy } from '../../../tools/makeDeepCopy.mjs';
 import { createSeededRandom } from '../../../tools/prng.mjs';
 import { INVALID_VALUES, METHOD_NOT_FOUND } from '../../../constants/errorConditionConstants.mjs';
+import { nowMs } from '../../../tools/clock.mjs';
 
 function engineInvoke(engine, args) {
     if (!isObject(args))
@@ -37,7 +38,7 @@ function engineInvoke(engine, args) {
     const result = executeFunction(engine, method, params, methodName, 'sync') ?? {};
     if (result?.error && snapshot)
         setState(snapshot);
-    const timeStamp = Date.now();
+    const timeStamp = nowMs();
     const mutationStatus = getMutationStatus({ timeStamp });
     const notify = result?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
     if (notify)
@@ -48,6 +49,7 @@ function engineInvoke(engine, args) {
         });
     if (notify || !result?.success || params?.doNotNotify)
         deleteNotices();
+    getInvokeObserver()?.({ phase: 'after', methodName, engineType: 'sync', params, result });
     return result;
 }
 

package/dist/esm/assemblies/engines/sync/executionQueue.mjs

@@ -1,4 +1,4 @@
-import { getMethods, getTournamentRecords, deleteNotices } from '../../../global/state/globalState.mjs';
+import { getMethods, getTournamentRecords, deleteNotices, getInvokeObserver } from '../../../global/state/globalState.mjs';
 import { getMutationStatus } from '../parts/getMutationStatus.mjs';
 import { logMethodNotFound } from '../parts/logMethodNotFound.mjs';
 import { executeFunction } from '../parts/executeMethod.mjs';
@@ -7,6 +7,7 @@ import { setState } from '../parts/stateMethods.mjs';
 import { makeDeepCopy } from '../../../tools/makeDeepCopy.mjs';
 import { createSeededRandom } from '../../../tools/prng.mjs';
 import { INVALID_VALUES } from '../../../constants/errorConditionConstants.mjs';
+import { nowMs } from '../../../tools/clock.mjs';
 
 function executionQueue(engine, directives, rollbackOnError) {
     if (!Array.isArray(directives))
@@ -37,6 +38,7 @@ function executionQueue(engine, directives, rollbackOnError) {
             }
         }
         const result = executeFunction(engine, methods[methodName], params, methodName, 'sync');
+        getInvokeObserver()?.({ phase: 'after', methodName, engineType: 'sync', params, result });
         if (result?.error) {
             if (snapshot)
                 setState(snapshot);
@@ -44,7 +46,7 @@ function executionQueue(engine, directives, rollbackOnError) {
         }
         results.push({ ...result, methodName });
     }
-    const timeStamp = Date.now();
+    const timeStamp = nowMs();
     const mutationStatus = getMutationStatus({ timeStamp });
     notifySubscribers({ directives, mutationStatus, timeStamp });
     deleteNotices();

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/adHoc/drawMatic/generateCandidate.mjs

@@ -1,8 +1,9 @@
 import { randomPop, chunkArray, shuffleArray } from '../../../../../../tools/arrays.mjs';
 import { stringSort } from '../../../../../../functions/sorters/stringSort.mjs';
+import { randomSource } from '../../../../../../tools/prng.mjs';
 
 function generateCandidate({ maxIterations = 4000, valueSortedPairings, individualIdsMap, pairingValues, valueObjects, deltaObjects, random, }) {
-    const rng = random ?? Math.random;
+    const rng = random ?? randomSource();
     const pairingValueMap = Object.assign({}, ...valueSortedPairings.map((rm) => ({ [rm.pairing]: rm.value })));
     const actors = Object.keys(pairingValues);
     let proposedCandidates = [];
@@ -89,7 +90,7 @@ function candidateHash(candidate) {
         .join('/');
 }
 function roundCandidate({ valueSortedPairings, stipulated = [], individualIdsMap, pairingValueMap, deltaObjects, valueObjects, actorsCount, random, }) {
-    const rng = random ?? Math.random;
+    const rng = random ?? randomSource();
     const occupants = (participantId) => {
         const individualIds = individualIdsMap?.[participantId];
         return individualIds?.length ? individualIds : [participantId];

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/adHoc/drawMatic/getPairings.mjs

@@ -1,6 +1,7 @@
 import { getParticipantPairingValues } from './getParticipantPairingValues.mjs';
 import { generateCandidate } from './generateCandidate.mjs';
 import { getSideRatings } from './getSideRatings.mjs';
+import { randomSource } from '../../../../../../tools/prng.mjs';
 
 function getPairings(params) {
     const { tournamentParticipants, adHocRatings = {}, possiblePairings, individualIdsMap, uniquePairings, maxIterations, minimizeDelta, deltaObjects, valueObjects, eventType, scaleName, salted, } = params;
@@ -13,7 +14,7 @@ function getPairings(params) {
             pairing,
         });
         const salting = (typeof salted === 'number' && salted) || 0.5;
-        const rng = params.random ?? Math.random;
+        const rng = params.random ?? randomSource();
         const salt = (salted && (Math.round(rng()) ? salting : salting * -1)) || 0;
         const ratingsDifference = Math.abs(ratings[0] - ratings[1]) + salt;
         const pairingDelta = Math.abs(ratings[0] - ratings[1]);

package/dist/esm/assemblies/generators/drawDefinitions/generateSeedingScaleItems.mjs

@@ -1,12 +1,13 @@
 import { MISSING_VALUE } from '../../../constants/errorConditionConstants.mjs';
 import { SEEDING } from '../../../constants/scaleConstants.mjs';
+import { nowIso } from '../../../tools/clock.mjs';
 
 function generateSeedingScaleItems({ scaleAttributes, scaledEntries, stageEntries, seedsCount, scaleName, }) {
     if (!scaleAttributes)
         return { error: MISSING_VALUE, info: 'missing scaleAttributes' };
     const seededEntries = Object.assign({}, ...(scaledEntries ?? []).slice(0, seedsCount).map(({ participantId }, index) => ({ [participantId]: index + 1 })));
     scaleName = scaleName || scaleAttributes.scaleName;
-    const scaleDate = new Date().toISOString();
+    const scaleDate = nowIso();
     const scaleItemsWithParticipantIds = stageEntries.map(({ participantId }) => {
         const scaleItem = {
             scaleValue: seededEntries[participantId],

package/dist/esm/assemblies/generators/drawDefinitions/getDrawFormat.mjs

@@ -5,6 +5,7 @@ import { TEAM } from '../../../constants/eventConstants.mjs';
 import { MAIN } from '../../../constants/drawDefinitionConstants.mjs';
 import { FORMAT_STANDARD } from '../../../fixtures/scoring/matchUpFormats/index.mjs';
 import '../../../helpers/keyValueScore/constants.mjs';
+import '../../../validators/isMatchUpStatus.mjs';
 
 function getDrawFormat(params) {
     const { existingDrawDefinition, hydrateCollections, enforceGender, tieFormatName, tieFormatId, matchUpType, eventType, isMock, event, } = params;

package/dist/esm/assemblies/generators/drawDefinitions/validateAndDeriveDrawValues.mjs

@@ -15,7 +15,10 @@ import '../../../query/formatWizard/suggestFormatPlans.mjs';
 import '../../../types/tournamentTypes.mjs';
 import { isAdHocType } from '../../../query/drawDefinition/isAdHocType.mjs';
 import '../../../query/matchUp/isScheduleLocked.mjs';
+import '../../../mutate/matchUps/schedule/byeScheduling.mjs';
 import '../../../query/matchUp/predictMatchUpCompetitiveBands.mjs';
+import '../../../mutate/matchUps/matchUpStatus/sideStatusCodes.mjs';
+import '../../../validators/isMatchUpStatus.mjs';
 import '../../../functions/sorters/roundSort.mjs';
 import '../../../query/drawDefinition/predictDrawCompetitiveBands.mjs';
 import { getDrawTypeCoercion } from './getDrawTypeCoercion.mjs';

package/dist/esm/assemblies/generators/matchUps/generateScoreString.mjs

@@ -1,3 +1,4 @@
+import { finalSetGoverns } from '../../../helpers/matchUpFormatCode/aggregateDecider.mjs';
 import { parse } from '../../../helpers/matchUpFormatCode/parse.mjs';
 import { isNumeric } from '../../../tools/math.mjs';
 import { MISSING_VALUE } from '../../../constants/errorConditionConstants.mjs';
@@ -23,7 +24,7 @@ function generateScoreString(params) {
         return `${outcomeString} ${setScores}`;
     return `${setScores} ${outcomeString}`;
     function setString(currentSet) {
-        const isFinalSet = bestOf && currentSet.setNumber === bestOf;
+        const isFinalSet = finalSetGoverns(parsedFormat, currentSet.setNumber, !!bestOf && currentSet.setNumber === bestOf);
         const format = isFinalSet && finalSetFormat ? finalSetFormat : setFormat;
         const hasGameScores = (set) => isNumeric(set?.side1Score) || isNumeric(set?.side2Score);
         const hasTiebreakScores = (set) => isNumeric(set?.side1TiebreakScore) || isNumeric(set?.side2TiebreakScore);

package/dist/esm/assemblies/generators/matchUps/matchUpScore.mjs

@@ -1,10 +1,13 @@
+import { withPointsInTiebreakFields, formatForSet } from '../../../query/matchUp/tiebreakSetShape.mjs';
 import { generateScoreString } from './generateScoreString.mjs';
+import { parse } from '../../../helpers/matchUpFormatCode/parse.mjs';
 
 function matchUpScore(params) {
     const { matchUpFormat, matchUpStatus, winningSide, score, setTBlast } = params;
     if (!score)
         return { sets: [] };
-    const sets = score.sets ?? [];
+    const parsedFormat = score.sets?.length && matchUpFormat ? parse(matchUpFormat) : undefined;
+    const sets = (score.sets ?? []).map((set) => withPointsInTiebreakFields(set, formatForSet(parsedFormat, set?.setNumber)));
     let scoreStringSide1 = generateScoreString({
         winnerFirst: false,
         matchUpFormat,

package/dist/esm/assemblies/generators/mocks/applyScenarioProfile.mjs

@@ -2,6 +2,7 @@ import { addMatchUpScheduledDate } from '../../../mutate/matchUps/schedule/sched
 import { addMatchUpScheduledTime } from '../../../mutate/matchUps/schedule/scheduledTime.mjs';
 import { scheduleProfileGrid } from '../../../mutate/matchUps/schedule/scheduleProfileGrid.mjs';
 import { decorateResult } from '../../../functions/global/decorateResult.mjs';
+import { now } from '../../../tools/clock.mjs';
 import { extractDate } from '../../../tools/plainDate.mjs';
 import { allTournamentMatchUps } from '../../../query/matchUps/getAllTournamentMatchUps.mjs';
 import { INVALID_VALUES, INVALID_DATE } from '../../../constants/errorConditionConstants.mjs';
@@ -32,7 +33,7 @@ function applyScenarioProfile({ tournamentRecord, scenarioProfile }) {
     const { anchor = 'NOW', minutesBeforeAnchor = 0, assignCourts } = scenarioProfile;
     if (typeof minutesBeforeAnchor !== 'number' || !isFinite(minutesBeforeAnchor))
         return { error: INVALID_VALUES };
-    const anchorDate = anchor === 'NOW' ? new Date() : new Date(anchor);
+    const anchorDate = anchor === 'NOW' ? now() : new Date(anchor);
     if (isNaN(anchorDate.getTime()))
         return { error: INVALID_VALUES };
     const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps ?? [];

package/dist/esm/assemblies/generators/mocks/generateOutcome.mjs

@@ -1,3 +1,4 @@
+import { finalSetGoverns, aggregateDeciderSetNumber } from '../../../helpers/matchUpFormatCode/aggregateDecider.mjs';
 import { getSetComplement, getTiebreakComplement } from '../../../query/matchUp/getComplement.mjs';
 import { matchUpScore } from '../matchUps/matchUpScore.mjs';
 import { isValidMatchUpFormat } from '../../../validators/isValidMatchUpFormat.mjs';
@@ -157,7 +158,7 @@ function generateScoredOutcome({ pointsPerMinute, matchUpFormat, matchUpStatus,
     let weightedWinningSide;
     const setsToGenerate = generateRange(1, (exactly ?? bestOf) + 1);
     for (const setNumber of setsToGenerate) {
-        const isFinalSet = setNumber === (exactly ?? bestOf);
+        const isFinalSet = finalSetGoverns(parsedFormat, setNumber, setNumber === (exactly ?? bestOf));
         const { set, incomplete, winningSideNumber } = generateSet({
             setFormat: (isFinalSet && finalSetFormat) || setFormat,
             incomplete: incompleteAt === setNumber,
@@ -176,6 +177,22 @@ function generateScoredOutcome({ pointsPerMinute, matchUpFormat, matchUpStatus,
         if (analysis.calculatedWinningSide && !parsedFormat?.aggregate)
             break;
     }
+    const deciderSetNumber = aggregateDeciderSetNumber(parsedFormat);
+    if (deciderSetNumber && finalSetFormat && !weightedWinningSide && aggregateIsLevel(sets)) {
+        const { set } = generateSet({
+            weightedRange: winningSide ? [winningSide - 1] : weightedRange,
+            setFormat: finalSetFormat,
+            setNumber: deciderSetNumber,
+            incomplete: false,
+            pointsPerMinute,
+            matchUpStatus,
+            random,
+        });
+        if (winningSide && set.winningSide !== winningSide)
+            swapSides(set);
+        sets.push(set);
+        weightedWinningSide = set.winningSide;
+    }
     const matchUpWinningSide = determineMatchUpWinningSide({
         weightedWinningSide,
         matchUpFormat,
@@ -196,6 +213,15 @@ function generateScoredOutcome({ pointsPerMinute, matchUpFormat, matchUpStatus,
     };
     return { outcome };
 }
+function swapSides(set) {
+    [set.side1Score, set.side2Score] = [set.side2Score, set.side1Score];
+    [set.side1TiebreakScore, set.side2TiebreakScore] = [set.side2TiebreakScore, set.side1TiebreakScore];
+    set.winningSide = set.winningSide === 1 ? 2 : 1;
+}
+function aggregateIsLevel(sets) {
+    const total = (side) => sets.reduce((sum, set) => sum + (set[`side${side}Score`] ?? 0), 0);
+    return sets.length > 0 && total(1) === total(2);
+}
 function determineMatchUpWinningSide({ weightedWinningSide, matchUpFormat, parsedFormat, winningSide, random, sets }) {
     if (weightedWinningSide) {
         return winningSide || weightedWinningSide;