tods-competition-factory 7.26.0 → 7.28.0

package/dist/esm/acquire/findStructure.mjs

@@ -2,9 +2,9 @@ import { checkRequiredParameters } from '../helpers/parameters/checkRequiredPara
 import { firstClassOrExtension } from './firstClassOrExtension.mjs';
 import { structureSort } from '../functions/sorters/structureSort.mjs';
 import { structuresOf } from './structureMembers.mjs';
-import { STRUCTURE_NOT_FOUND, MISSING_DRAW_DEFINITION, MISSING_STRUCTURES } from '../constants/errorConditionConstants.mjs';
+import { MISSING_DRAW_DEFINITION, MISSING_STRUCTURES, STRUCTURE_NOT_FOUND } from '../constants/errorConditionConstants.mjs';
 import { STRUCTURE_ID, DRAW_DEFINITION } from '../constants/attributeConstants.mjs';
-import { ITEM, validStages } from '../constants/drawDefinitionConstants.mjs';
+import { validStages, ITEM } from '../constants/drawDefinitionConstants.mjs';
 import { ROUND_TARGET } from '../constants/extensionConstants.mjs';
 
 function findStructure(params) {

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

@@ -0,0 +1,8 @@
+import { competitionEngineAsync as competitionEngineAsync$1 } from '../../../tests/engines/asyncEngine/index.mjs';
+import { asyncEngine as asyncEngine$1 } from './index.mjs';
+
+const asyncEngine = asyncEngine$1;
+const competitionEngineAsync = competitionEngineAsync$1;
+const tournamentEngineAsync = competitionEngineAsync;
+
+export { asyncEngine, competitionEngineAsync, tournamentEngineAsync };

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

@@ -11,7 +11,7 @@ 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, getOutcomePipeline, getSaveDrawDeletions, getAuditAuthorityServer, setTournamentId, setDeepCopy, getTournamentId, removeTournamentRecord, setDevContext, setSchemaWriteMode, setOutcomePipeline, setSaveDrawDeletions, setAuditAuthorityServer } from '../../../global/state/globalState.mjs';
+import { setTournamentRecords, getDevContext, setSchemaWriteMode, getSchemaWriteMode, setOutcomePipeline, getOutcomePipeline, setSaveDrawDeletions, getSaveDrawDeletions, setAuditAuthorityServer, getAuditAuthorityServer, setTournamentId, setDeepCopy, getTournamentId, removeTournamentRecord, setDevContext } from '../../../global/state/globalState.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';
 
 function engineStart(engine, engineInvoke) {

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

@@ -1,6 +1,6 @@
 import { getRecordLinkedTournamentIds } from '../../../acquire/getRecordLinkedTournamentIds.mjs';
 import { makeDeepCopy } from '../../../tools/makeDeepCopy.mjs';
-import { getTournamentId, getTournamentRecord, setTournamentRecord as setTournamentRecord$1, setTournamentId, setTournamentRecords, getTournamentRecords } from '../../../global/state/globalState.mjs';
+import { getTournamentId, getTournamentRecord, getTournamentRecords, setTournamentRecord as setTournamentRecord$1, setTournamentId, setTournamentRecords } from '../../../global/state/globalState.mjs';
 import { INVALID_OBJECT, INVALID_VALUES, INVALID_RECORDS } from '../../../constants/errorConditionConstants.mjs';
 
 function getState({ convertExtensions, removeExtensions }) {

package/dist/esm/assemblies/engines/scoring/v2/actions.mjs

@@ -30,6 +30,8 @@ const CALCULATED_POINT_FIELDS = new Set([
     'gamesToSet',
     'isBreakpoint',
     'serveSide',
+    'phase',
+    'periodNumber',
 ]);
 function refusal(message) {
     return { code: INVALID_VALUES.code, message };

package/dist/esm/assemblies/engines/scoring/v2/decide.mjs

@@ -22,6 +22,8 @@ function units(set) {
     return [set.side1TiebreakScore ?? set.side1Score, set.side2TiebreakScore ?? set.side2Score];
 }
 function decideAggregate(match, sets) {
+    if (match.overtime)
+        return decideOvertime(match, sets);
     const counted = sets.slice(0, match.n);
     if (counted.length < match.n || !counted.every(isClosed))
         return IN_PLAY;
@@ -39,6 +41,38 @@ function decideAggregate(match, sets) {
         return IN_PLAY;
     return { complete: true, winningSide: decider.winningSide };
 }
+function decideOvertime(match, sets) {
+    const regulation = sets.slice(0, match.n);
+    if (regulation.length < match.n || !regulation.every(isClosed))
+        return IN_PLAY;
+    let total = sumUnits(regulation);
+    if (total[0] !== total[1])
+        return moreOf(total);
+    const overtime = match.overtime;
+    const periods = sets.slice(match.n, overtime.count === 'unlimited' ? undefined : match.n + overtime.count);
+    for (const period of periods) {
+        const [a, b] = units(period);
+        total = [total[0] + a, total[1] + b];
+        if (!isClosed(period))
+            return overtime.suddenDeath && total[0] !== total[1] ? moreOf(total) : IN_PLAY;
+        if (!overtime.exactly && total[0] !== total[1])
+            return moreOf(total);
+    }
+    if (overtime.count === 'unlimited' || periods.length < overtime.count)
+        return IN_PLAY;
+    if (total[0] !== total[1])
+        return moreOf(total);
+    if (!match.final)
+        return { complete: true };
+    const decider = sets[match.n + overtime.count];
+    return decider && isClosed(decider) ? { complete: true, winningSide: decider.winningSide } : IN_PLAY;
+}
+function sumUnits(sets) {
+    return sets.reduce((sum, set) => {
+        const [a, b] = units(set);
+        return [sum[0] + a, sum[1] + b];
+    }, [0, 0]);
+}
 function decidePastClose(match, sets) {
     if (sets.length < match.n || !sets.every(isClosed))
         return IN_PLAY;

package/dist/esm/assemblies/engines/scoring/v2/engine.mjs

@@ -1,17 +1,18 @@
-import { calculateMatchStatistics } from '../../../../query/scoring/statistics/standalone.mjs';
+import { overtimeLayout, scoringPeriod, segmentClosed } from '../../../../helpers/matchUpFormatCode/overtimeContext.mjs';
+import { initialState, createContext, step, positionOf, INVALID_FORMAT, serverOf } from './reduce.mjs';
 import { DEFAULT_MATCHUP_FORMAT, takesInput, finalGoverns } from './format.mjs';
+import { readChallenge, readServer, readPoint, CALCULATED_POINT_FIELDS } from './actions.mjs';
+import { replayLegacy, LEGACY_REFUSED_INPUT, LEGACY_IGNORED_INPUT } from './legacy.mjs';
+import { calculateMatchStatistics } from '../../../../query/scoring/statistics/standalone.mjs';
 import { toStatObjects } from '../../../../query/scoring/statistics/toStatObjects.mjs';
-import { initialState, createContext, step, positionOf, INVALID_FORMAT, serverOf } from './reduce.mjs';
 import { createMatchUp } from '../../../../mutate/scoring/createMatchUp.mjs';
 import { getScoreboard } from '../../../../query/scoring/getScoreboard.mjs';
 import { parse } from '../../../../helpers/matchUpFormatCode/parse.mjs';
 import { getEpisodes } from '../../../../query/scoring/getEpisodes.mjs';
-import { readChallenge, readServer, readPoint, CALCULATED_POINT_FIELDS } from './actions.mjs';
-import { replayLegacy, LEGACY_REFUSED_INPUT, LEGACY_IGNORED_INPUT } from './legacy.mjs';
 import { scoreOf, ruleInPlay } from './score.mjs';
 import { materialize } from './record.mjs';
-import { setsWon } from './decide.mjs';
 import { nowIso } from '../../../../tools/clock.mjs';
+import { setsWon } from './decide.mjs';
 import { initialLineUpsOf, substitutionError, substituted, substitutionViolations, copyLineUps, hasLineUps } from './lineUps.mjs';
 import { COMPLETED } from '../../../../constants/matchUpStatusValues.mjs';
 
@@ -63,14 +64,16 @@ class ScoringEngine {
             isDoubles: options.isDoubles || false,
         });
         this.entries = [];
+        if (this.context().match?.overtime)
+            this.write([]);
     }
     context() {
         const context = createContext({
             matchUpFormat: this.matchUpFormat,
             competitionFormat: this.competitionFormat,
             pointMultipliers: this.pointMultipliers,
-        });
-        if (!this.pastClose || !context.match)
+        }, { allowOvertime: true });
+        if (!this.pastClose || !context.match || context.match.overtime)
             return context;
         return { ...context, match: { ...context.match, pastClose: true } };
     }
@@ -104,7 +107,7 @@ class ScoringEngine {
             const before = state;
             const result = step(context, state, unindexed);
             let next = result.state;
-            if (!result.outcome.recorded) {
+            if (!result.outcome.recorded && !context.match?.overtime) {
                 const v1 = replayLegacy(context, state, unindexed, result.outcome);
                 legacy.add(v1?.shape ?? ('refused' in result.outcome ? LEGACY_REFUSED_INPUT : LEGACY_IGNORED_INPUT));
                 if (v1)
@@ -379,6 +382,10 @@ class ScoringEngine {
     }
     patchPoint(pointIndex, fields) {
         const points = [...(this.record.history?.points ?? [])];
+        if (this.context().match?.overtime) {
+            const { phase: _phase, periodNumber: _period, ...metadata } = fields;
+            fields = metadata;
+        }
         points[pointIndex] = { ...points[pointIndex], ...fields };
         this.record = { ...this.record, history: { ...this.record.history, points } };
     }
@@ -434,17 +441,25 @@ class ScoringEngine {
         this.legacyShapes = new Set();
         this.stale = false;
         this.initialServer = undefined;
+        if (this.context().match?.overtime)
+            this.write([]);
         this.eventHandlers?.onReset?.(this.eventContext());
     }
     setState(matchUp) {
         const loaded = copy(matchUp);
+        const overtime = !!parse(loaded.matchUpFormat)?.overtimeFormat;
+        const overtimeTimeline = overtime ? readOvertimeTimeline(loaded) : undefined;
         this.record = loaded;
         this.matchUpFormat = loaded.matchUpFormat;
         this.redoStack = [];
-        this.entries = loaded.history?.entries ? [...loaded.history.entries] : undefined;
+        this.entries = overtimeTimeline ?? (loaded.history?.entries ? [...loaded.history.entries] : undefined);
         this.lineUps = lineUpsOf(loaded);
         this.initialLineUps = initialLineUpsOf(this.lineUps, this.entries, loaded.history?.substitutions);
         this.initialServer = loaded.history?.initialServer;
+        if (overtime) {
+            this.rebuild();
+            return;
+        }
         this.prepare();
         this.legacyShapes = new Set();
         this.stale = true;
@@ -571,6 +586,14 @@ class ScoringEngine {
             return undefined;
         const closed = this.state.sets.filter((set) => set.winningSide || set.segmentComplete);
         const setNumber = Math.min(positionOf(match, this.state).set.setNumber, Math.max(closed.length + 1, 1));
+        const layout = overtimeLayout(structure);
+        if (layout) {
+            const current = this.state.matchUpStatus === COMPLETED ? (this.state.sets.at(-1)?.setNumber ?? 1) : setNumber;
+            const period = scoringPeriod(layout, current);
+            if (period?.phase === 'OVERTIME')
+                return structure.overtimeFormat?.setFormat;
+            return period?.phase === 'DECIDER' ? structure.finalSetFormat : structure.setFormat;
+        }
         const final = finalGoverns(match, setNumber, setsWon(this.state.sets.slice(0, setNumber - 1)));
         return final && structure.finalSetFormat ? structure.finalSetFormat : structure.setFormat;
     }
@@ -653,6 +676,46 @@ class ScoringEngine {
         return this.competitionFormat?.playerRules;
     }
 }
+function readOvertimeTimeline(record) {
+    const context = createContext({ matchUpFormat: record.matchUpFormat }, { allowOvertime: true });
+    if (!context.match?.overtime)
+        throw new Error('Unsupported overtime format');
+    if (record.history?.entries?.length)
+        return [...record.history.entries];
+    if (record.history?.points?.length)
+        throw new Error('Overtime point records require a scoring timeline');
+    const sets = record.score.sets;
+    const last = sets.at(-1);
+    if (!last)
+        return [];
+    const open = record.matchUpStatus !== COMPLETED && !segmentClosed(last);
+    const entry = {
+        type: 'setInitialScore',
+        timestamp: record.endTime ?? record.createdAt ?? nowIso(),
+        data: {
+            sets: open ? sets.slice(0, -1) : sets,
+            ...(open ? openOvertimeBaseline(last) : {}),
+            matchUpStatus: record.matchUpStatus,
+            ...(record.winningSide === undefined ? {} : { winningSide: record.winningSide }),
+        },
+    };
+    const result = step(context, initialState(), { ...entry });
+    if (!result.outcome.recorded)
+        refusedWith(result.outcome);
+    return [entry];
+}
+function openOvertimeBaseline(set) {
+    if (set.isTiebreakOnly) {
+        return {
+            currentSetScore: { side1Score: 0, side2Score: 0 },
+            currentGameScore: {
+                side1Points: set.side1GameScores?.at(-1) ?? set.side1TiebreakScore ?? set.side1Score ?? 0,
+                side2Points: set.side2GameScores?.at(-1) ?? set.side2TiebreakScore ?? set.side2Score ?? 0,
+            },
+        };
+    }
+    return { currentSetScore: { side1Score: set.side1Score ?? 0, side2Score: set.side2Score ?? 0 } };
+}
 function lineUpsAfter(initial, entries) {
     if (!initial)
         return undefined;

package/dist/esm/assemblies/engines/scoring/v2/format.mjs

@@ -1,3 +1,4 @@
+import { overtimeFinalNumber, overtimeGoverns } from './overtime.mjs';
 import { parse } from '../../../../helpers/matchUpFormatCode/parse.mjs';
 
 const DEFAULT_MATCHUP_FORMAT = 'SET3-S:6/TB7';
@@ -47,17 +48,20 @@ function segmentRule(setFormat, gameFormat, context) {
     const at = Number(setFormat.tiebreakAt ?? setTo);
     return { kind: 'standard', setTo, winBy: 2, tiebreak: { at, race: raceRule(setFormat.tiebreakFormat) }, game };
 }
-function resolveFormat(code) {
+function resolveFormat(code, options = {}) {
     if (!code)
         return undefined;
     const parsed = parse(code);
-    if (!parsed?.setFormat)
+    if (!parsed?.setFormat || (parsed.overtimeFormat && !options.allowOvertime))
         return undefined;
     const exactly = parsed.exactly;
     const n = exactly ?? parsed.bestOf ?? 1;
     const context = { tennisFamily: !parsed.matchRoot && !parsed.aggregate && !parsed.simplified };
     const ordinary = segmentRule(parsed.setFormat, parsed.gameFormat, context);
     const final = parsed.finalSetFormat ? segmentRule(parsed.finalSetFormat, parsed.gameFormat, context) : undefined;
+    const overtime = parsed.overtimeFormat;
+    if (overtime && !supportsOvertime(parsed, n, ordinary, final))
+        return undefined;
     return {
         code,
         mode: exactly ? 'exactly' : 'bestOf',
@@ -66,12 +70,34 @@ function resolveFormat(code) {
         setsToWin: Math.floor(n / 2) + 1,
         ordinary,
         ...(final ? { final } : {}),
+        ...(overtime
+            ? {
+                overtime: {
+                    count: overtime.count,
+                    exactly: !!overtime.exactly,
+                    suddenDeath: !!overtime.suddenDeath,
+                    rule: segmentRule(overtime.setFormat, parsed.gameFormat, context),
+                },
+            }
+            : {}),
     };
 }
+function supportsOvertime(parsed, n, ordinary, final) {
+    const overtime = parsed.overtimeFormat;
+    if (parsed.matchUpConstraint || ordinary.kind !== 'timed' || ordinary.tiebreak)
+        return false;
+    if (!overtime.setFormat.timed || overtime.setFormat.tiebreakFormat)
+        return false;
+    if (final && final.kind !== 'tiebreakOnly' && (final.kind !== 'timed' || final.tiebreak))
+        return false;
+    return overtime.count === 'unlimited' || Number.isSafeInteger(n + overtime.count + (final ? 1 : 0));
+}
 function configuredFormat(config) {
     return config.matchUpFormat ?? config.competitionFormat?.matchUpFormat ?? DEFAULT_MATCHUP_FORMAT;
 }
 function finalGoverns(match, setNumber, setsWon) {
+    if (match.overtime)
+        return setNumber === overtimeFinalNumber(match);
     if (match.mode === 'exactly')
         return setNumber === (match.aggregate ? match.n + 1 : match.n);
     if (setNumber === match.n)
@@ -82,6 +108,8 @@ function finalGoverns(match, setNumber, setsWon) {
     return setsWon[0] === oneFromWinning && setsWon[1] === oneFromWinning;
 }
 function ruleForSet(match, setNumber, setsWon) {
+    if (match.overtime && overtimeGoverns(match, setNumber))
+        return match.overtime.rule;
     return match.final && finalGoverns(match, setNumber, setsWon) ? match.final : match.ordinary;
 }
 function takesInput(rule, input) {

package/dist/esm/assemblies/engines/scoring/v2/overtime.mjs

@@ -0,0 +1,30 @@
+import { scoringPeriod } from '../../../../helpers/matchUpFormatCode/overtimeContext.mjs';
+
+function overtimeGoverns(match, setNumber) {
+    const overtime = match.overtime;
+    return !!overtime && setNumber > match.n && (overtime.count === 'unlimited' || setNumber <= match.n + overtime.count);
+}
+function overtimeFinalNumber(match) {
+    const overtime = match.overtime;
+    return overtime && overtime.count !== 'unlimited' && match.final ? match.n + overtime.count + 1 : undefined;
+}
+function lastPlayableSet(match) {
+    if (match.overtime) {
+        if (match.overtime.count === 'unlimited')
+            return undefined;
+        return match.n + match.overtime.count + (match.final ? 1 : 0);
+    }
+    return match.n + (match.mode === 'exactly' && match.aggregate && match.final ? 1 : 0);
+}
+function overtimeTotalError(match, setNumber, totals) {
+    return match.overtime?.suddenDeath && overtimeGoverns(match, setNumber) && totals[0] > 0 && totals[1] > 0
+        ? 'a sudden-death overtime total cannot have scoring by both sides'
+        : undefined;
+}
+function periodForSet(match, setNumber) {
+    return match.overtime
+        ? scoringPeriod({ regulationCount: match.n, overtimeCount: match.overtime.count, finalDecider: !!match.final }, setNumber)
+        : undefined;
+}
+
+export { lastPlayableSet, overtimeFinalNumber, overtimeGoverns, overtimeTotalError, periodForSet };

package/dist/esm/assemblies/engines/scoring/v2/record.mjs

@@ -1,4 +1,6 @@
 import { hasLineUps, substituted, activePlayersOf } from './lineUps.mjs';
+import { overtimeScoreContext } from '../../../../helpers/matchUpFormatCode/overtimeContext.mjs';
+import { parse } from '../../../../helpers/matchUpFormatCode/parse.mjs';
 import { isClosed } from './decide.mjs';
 import { COMPLETED } from '../../../../constants/matchUpStatusValues.mjs';
 import { POINT, SUBSTITUTION } from './actions.mjs';
@@ -59,6 +61,10 @@ function materialize({ base, state, entries, completedBy, lineUps, timeline, ini
         score: { sets: recordedSets(state) },
         sides: (identity.sides ?? []).map((side) => lineUps.current?.[side.sideNumber] ? { ...side, lineUp: lineUps.current[side.sideNumber] } : side),
     };
+    const format = parse(base.matchUpFormat);
+    const overtime = format && overtimeScoreContext(format, recorded.score.sets, state.matchUpStatus);
+    if (overtime)
+        recorded.score.overtime = overtime;
     if (previous || entries.length || points.length || initialServer !== undefined)
         recorded.history = history;
     return recorded;

package/dist/esm/assemblies/engines/scoring/v2/reduce.mjs

@@ -1,14 +1,15 @@
 import { INITIAL_SERVICE, nextServer, corrected, serveSide, afterPoint, serviceCode } from './service.mjs';
+import { lastPlayableSet, overtimeTotalError, periodForSet, overtimeGoverns } from './overtime.mjs';
 import { resolveFormat, configuredFormat, ruleForSet, takesInput } from './format.mjs';
-import { pointsTo, isBreakpoint } from './view.mjs';
 import { setsWon, isClosed, decideMatch } from './decide.mjs';
-import { openSet, atTimeIn, segmentEnd, segmentTotal, segmentGame, pointsAreUnits, segmentPoint, decidedInPlay } from './segments/segment.mjs';
+import { pointsTo, isBreakpoint } from './view.mjs';
 import { NEEDS_A_FORMAT, refusal, ANNOTATION, SUBSTITUTION, CHALLENGE, readChallenge, SET_SERVER, readServer, END_SEGMENT, SET_INITIAL_SCORE, SET, GAME, POINT, readEndSegment, readSetTotal, readGame, readPoint, pointFacts } from './actions.mjs';
+import { openSet, atTimeIn, segmentEnd, segmentTotal, segmentGame, pointsAreUnits, segmentPoint, decidedInPlay } from './segments/segment.mjs';
 import { TO_BE_PLAYED, COMPLETED, IN_PROGRESS } from '../../../../constants/matchUpStatusValues.mjs';
 
-function createContext(config) {
+function createContext(config, options = {}) {
     return {
-        match: resolveFormat(configuredFormat(config)),
+        match: resolveFormat(configuredFormat(config), options),
         multipliers: config.pointMultipliers ?? config.competitionFormat?.pointMultipliers ?? [],
         rules: { winnerServes: config.competitionFormat?.serverRule === 'WINNER_SERVES' },
     };
@@ -48,20 +49,27 @@ function target(match, state) {
         return { set: last, rule, game: state.game, index: state.sets.length - 1, atTime: atTimeIn(rule, last) };
     }
     const setNumber = state.sets.length + 1;
-    const decider = match.mode === 'exactly' && match.aggregate && match.final ? 1 : 0;
-    if (setNumber > match.n + decider && !match.pastClose)
+    const limit = lastPlayableSet(match);
+    if (limit !== undefined && setNumber > limit && !match.pastClose)
         return undefined;
     const rule = ruleForSet(match, setNumber, setsWon(state.sets));
     return { set: openSet(rule, setNumber), rule, index: state.sets.length, atTime: false };
 }
 function scored(match, state, at, result, scoring = true) {
-    const sets = [...state.sets.slice(0, at.index), result.set];
+    const labeled = { ...result.set, ...periodForSet(match, at.set.setNumber) };
+    const sets = [...state.sets.slice(0, at.index), labeled];
     const decision = decideMatch(match, sets);
+    const suddenDeathWin = match.overtime?.suddenDeath &&
+        overtimeGoverns(match, at.set.setNumber) &&
+        decision.complete &&
+        decision.winningSide;
+    if (suddenDeathWin)
+        sets[at.index] = { ...labeled, segmentComplete: true, winningSide: decision.winningSide };
     const { winningSide: _previous, game: _game, ...rest } = state;
     return {
         ...rest,
         sets,
-        ...(result.game ? { game: result.game } : {}),
+        ...(result.game && !suddenDeathWin ? { game: result.game } : {}),
         matchUpStatus: decision.complete ? COMPLETED : IN_PROGRESS,
         ...(decision.winningSide ? { winningSide: decision.winningSide } : {}),
         scoringEntries: state.scoringEntries + (scoring ? 1 : 0),
@@ -115,6 +123,7 @@ function point(context, match, state, entry) {
     const index = state.points.length;
     const materialized = {
         ...pointFacts(entry.data),
+        ...periodForSet(match, at.set.setNumber),
         winner,
         winningSide: (winner + 1),
         ...(server === undefined ? {} : { server, serverSideNumber: (server + 1) }),
@@ -156,6 +165,9 @@ function set(match, state, entry) {
     const at = aimed(match, state);
     if (typeof at === 'string')
         return ignored(state, at);
+    const overtimeError = overtimeTotalError(match, at.set.setNumber, facts.total.totals);
+    if (overtimeError)
+        return refused(state, refusal(overtimeError));
     const result = segmentTotal(at.rule, at.set.setNumber, facts.total);
     if ('refused' in result)
         return refused(state, refusal(result.refused));
@@ -202,9 +214,14 @@ function baselineSets(match, given) {
     const sets = [];
     let atTime = false;
     for (const [i, data] of given.entries()) {
+        if (match.overtime && decideMatch(match, sets).complete)
+            return { refused: 'an overtime baseline includes a segment after the match was decided' };
         const facts = readSetTotal(data);
         if (facts.refused)
             return { refused: facts.refused.message };
+        const overtimeError = overtimeTotalError(match, i + 1, facts.total.totals);
+        if (overtimeError)
+            return { refused: overtimeError };
         const rule = ruleForSet(match, i + 1, setsWon(sets));
         const judged = segmentTotal(rule, i + 1, facts.total);
         if ('refused' in judged)
@@ -214,7 +231,7 @@ function baselineSets(match, given) {
             return { refused: `Set ${i + 1} is not finished and is not the last set` };
         if (atTimeSet)
             atTime = true;
-        sets.push(judged.set);
+        sets.push({ ...judged.set, ...periodForSet(match, i + 1) });
     }
     return { sets, atTime };
 }
@@ -245,15 +262,45 @@ function baselineInPlay(match, sets, data) {
     if (given && raceInPlay)
         return { refused: raceNamedTwice(setNumber) };
     const base = open && !raceInPlay ? last : openSet(rule, setNumber);
-    const inPlay = { ...base, side1Score: base.side1Score + games[0], side2Score: base.side2Score + games[1] };
+    const checked = overtimeBaselineSet(match, rule, {
+        ...base,
+        side1Score: base.side1Score + games[0],
+        side2Score: base.side2Score + games[1],
+        ...periodForSet(match, setNumber),
+    }, given, !!currentSetScore);
+    if ('refused' in checked)
+        return checked;
+    const inPlay = checked;
     if (decidedInPlay(rule, [inPlay.side1Score, inPlay.side2Score]))
         return { refused: 'the set in play is already won' };
     if (rule.kind === 'combined')
         return { sets: [...closed, inPlay] };
-    const points = given ?? (raceInPlay ? [last.side1Score, last.side2Score] : [0, 0]);
+    const points = baselinePoints(match, rule, inPlay, raceInPlay ? last : undefined, given);
     const withGame = { ...inPlay, side1GameScores: [points[0]], side2GameScores: [points[1]] };
     return { sets: [...closed, withGame], game: { score: points, pointsPlayed: points[0] + points[1] } };
 }
+function baselinePoints(match, rule, inPlay, race, given) {
+    if (given)
+        return given;
+    if (match.overtime && rule.kind === 'timed')
+        return [inPlay.side1Score, inPlay.side2Score];
+    return race ? [race.side1Score, race.side2Score] : [0, 0];
+}
+function overtimeBaselineSet(match, rule, set, given, setGiven) {
+    if (!match.overtime)
+        return set;
+    let inPlay = set;
+    if (rule.kind === 'timed' && given) {
+        if (setGiven && (given[0] !== set.side1Score || given[1] !== set.side2Score))
+            return { refused: 'timed overtime baseline games and points name the same totals and must agree' };
+        inPlay = { ...set, side1Score: given[0], side2Score: given[1] };
+    }
+    if (match.overtime.suddenDeath &&
+        overtimeGoverns(match, set.setNumber) &&
+        [inPlay.side1Score, inPlay.side2Score, ...(given ?? [])].some((score) => score > 0))
+        return { refused: 'a sudden-death overtime with a nonzero score is already decided, not in play' };
+    return inPlay;
+}
 const raceNamedTwice = (setNumber) => `Set ${setNumber} is a tiebreak-only set in play, and a currentGameScore names its points again`;
 function combinedInPlay(match, sets, open) {
     const closed = open ? sets.slice(0, -1) : sets;
@@ -341,5 +388,19 @@ function apply(context, state, entry, live) {
             return scoreless(state);
     }
 }
+function reduce(config, timeline, options = {}) {
+    const context = createContext(config, options);
+    const outcomes = [];
+    const legacy = [];
+    let state = initialState();
+    for (const [index, entry] of timeline.entries()) {
+        const result = step(context, state, entry);
+        outcomes.push(result.outcome);
+        if (!result.outcome.recorded)
+            legacy.push(index);
+        state = result.state;
+    }
+    return { state, outcomes, legacy };
+}
 
-export { INVALID_FORMAT, createContext, initialState, positionOf, raceNamedTwice, serverOf, step };
+export { INVALID_FORMAT, createContext, initialState, positionOf, raceNamedTwice, reduce, serverOf, step };

package/dist/esm/assemblies/engines/scoring/v2/score.mjs

@@ -1,6 +1,8 @@
-import { positionOf, serverOf } from './reduce.mjs';
+import { overtimeScoreContext, overtimeScoreString } from '../../../../helpers/matchUpFormatCode/overtimeContext.mjs';
+import { parse } from '../../../../helpers/matchUpFormatCode/parse.mjs';
 import { combinedClosed } from './segments/combined.mjs';
 import { inTiebreak } from './segments/standard.mjs';
+import { positionOf, serverOf } from './reduce.mjs';
 import { atTimeIn } from './segments/segment.mjs';
 import { isClosed } from './decide.mjs';
 import { pointsTo } from './view.mjs';
@@ -110,9 +112,12 @@ function inPlay(context, state) {
 }
 function scoreOf(context, state, sets) {
     const { games, points, pointDisplay } = inPlay(context, state);
+    const format = context.match?.overtime && parse(context.match.code);
+    const overtime = format && overtimeScoreContext(format, sets, state.matchUpStatus);
     return {
         sets,
-        scoreString: scoreString(sets),
+        scoreString: overtime ? overtimeScoreString(overtime) : scoreString(sets),
+        ...(overtime ? { overtime } : {}),
         games,
         points,
         pointDisplay,

package/dist/esm/assemblies/engines/scoring/v2/view.mjs

@@ -1,5 +1,6 @@
 import { playRacePoint, playGamePoint, NEW_GAME } from './segments/game.mjs';
 import { inTiebreak, standardSetWinner } from './segments/standard.mjs';
+import { overtimeGoverns } from './overtime.mjs';
 import { ruleForSet } from './format.mjs';
 import { setsWon } from './decide.mjs';
 
@@ -108,6 +109,8 @@ function counted(rule) {
     return rule.kind === 'standard' || rule.kind === 'tiebreakOnly';
 }
 function pointsTo(state, position) {
+    if (position.match.overtime?.suddenDeath && overtimeGoverns(position.match, position.set.setNumber))
+        return { pointsToGame: [1, 1], pointsToSet: [1, 1], pointsToMatch: [1, 1], gamesToSet: [1, 1] };
     const { rule, set, game } = position;
     if (!counted(rule))
         return undefined;

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

@@ -35,7 +35,7 @@ function generateDrawMaticRound(params) {
     let sourceRatingType;
     const { competitionPolicy } = getCompetitionPolicy({ tournamentRecord, drawDefinition, event });
     const { competitionState } = competitionPolicy
-        ? getCompetitionState({ drawDefinition })
+        ? getCompetitionState({ drawDefinition, competitionPolicy })
         : { competitionState: undefined };
     const useCompetitionRatings = competitionPolicy && competitionState && competitionPolicy.pairingPolicy.ratingSource === 'DYNAMIC_FORM';
     if (useCompetitionRatings) {

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/adHoc/swiss/generateSwissRound.mjs

@@ -47,7 +47,7 @@ function generateSwissRound(params) {
     }
     const { competitionPolicy } = getCompetitionPolicy({ tournamentRecord, drawDefinition, event });
     const { competitionState } = competitionPolicy
-        ? getCompetitionState({ drawDefinition })
+        ? getCompetitionState({ drawDefinition, competitionPolicy })
         : { competitionState: undefined };
     let adHocRatings;
     if (competitionPolicy && competitionState && competitionPolicy.pairingPolicy.ratingSource === 'DYNAMIC_FORM') {

package/dist/esm/assemblies/generators/drawDefinitions/drawTypes/generateVoluntaryConsolation.mjs

@@ -35,7 +35,7 @@ function generateVoluntaryConsolation(params) {
         return { error: INVALID_DRAW_SIZE };
     let { tieFormat, matchUpType } = params;
     if (tieFormat) {
-        const result = validateTieFormat({ tieFormat });
+        const result = validateTieFormat({ tieFormat, enforceValues: true });
         if (result.error)
             return result;
     }

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

@@ -22,7 +22,7 @@ import { addGoesTo } from '../../../query/matchUps/addGoesTo.mjs';
 import { generateTieMatchUps } from './tieMatchUps.mjs';
 import { makeDeepCopy } from '../../../tools/makeDeepCopy.mjs';
 import { ensureInt } from '../../../tools/ensureInt.mjs';
-import { INVALID_VALUES, MISSING_DRAW_DEFINITION, STRUCTURE_NOT_FOUND } from '../../../constants/errorConditionConstants.mjs';
+import { MISSING_DRAW_DEFINITION, INVALID_VALUES, STRUCTURE_NOT_FOUND } from '../../../constants/errorConditionConstants.mjs';
 import { TOP_DOWN, LOSER, CONTAINER, PLAY_OFF } from '../../../constants/drawDefinitionConstants.mjs';
 import { BYE } from '../../../constants/matchUpStatusValues.mjs';
 import { SUCCESS } from '../../../constants/resultConstants.mjs';