@ethlete/bracket 1.0.0-next.1 → 1.0.0-next.2

package/fesm2022/ethlete-bracket.mjs

@@ -1,5 +1,3 @@
-// codes 3400-3499 (3400 was LAYOUT_MODE_UNSUPPORTED, retired when layouts became explicit values -
-// an unsupported layout×mode combination no longer exists as a factory)
 const BRACKET_ERROR_CODES = {
     /** The source has no rounds/matches to render. */
     SOURCE_EMPTY: 3401,
@@ -27,6 +25,8 @@ const BRACKET_ERROR_CODES = {
     MISSING_MATCH_NORMALIZER: 3412,
     /** No registered {@link BracketLayout} matches the source's tournament `mode`. */
     LAYOUT_NOT_REGISTERED: 3413,
+    /** A cell the bracket draws has no card - neither an input, the layout, nor the config names one. */
+    CARD_NOT_REGISTERED: 3414,
 };
 
 class BracketRuntimeError extends Error {
@@ -101,6 +101,11 @@ const SWISS_BRACKET_ROUND_TYPE = {
 const GROUP_BRACKET_ROUND_TYPE = {
     GROUP: 'group',
 };
+const TERMINAL_ROUND_SORT_PRIORITY = {
+    [COMMON_BRACKET_ROUND_TYPE.FINAL]: 1,
+    [DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL]: 2,
+    [COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE]: 3,
+};
 const createRoundsMapBase = (source, options) => {
     const map = new BracketMap();
     const shouldSplitRoundsInTwo = options.layout === BRACKET_DATA_LAYOUT.MIRRORED;
@@ -112,12 +117,7 @@ const createRoundsMapBase = (source, options) => {
     // of one that has no side. Tracked per bracket half, because the two converge separately.
     const foldClosed = { upper: false, lower: false };
     const splitRoundsRest = [];
-    const terminalRoundSortPriority = {
-        [COMMON_BRACKET_ROUND_TYPE.FINAL]: 1,
-        [DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL]: 2,
-        [COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE]: 3,
-    };
-    const orderedRounds = [...source.rounds].sort((a, b) => (terminalRoundSortPriority[a.type] ?? 0) - (terminalRoundSortPriority[b.type] ?? 0));
+    const orderedRounds = [...source.rounds].sort((a, b) => (TERMINAL_ROUND_SORT_PRIORITY[a.type] ?? 0) - (TERMINAL_ROUND_SORT_PRIORITY[b.type] ?? 0));
     for (const [roundIndex, round] of orderedRounds.entries()) {
         const isUpperBracket = round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET;
         const isLowerBracket = round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET;
@@ -213,9 +213,14 @@ const createRoundsMapBase = (source, options) => {
     return map;
 };
 
-const createNewMatchParticipantBase = (source, participantId, match, rounds, matchRoundId, participants) => {
+const createNewMatchParticipantBase = (source, participantId, match, rounds, matchRoundId, participants, sourceMatchesById) => {
     if (!participantId)
         return null;
+    const findSourceMatch = (matchId) => matchId === undefined
+        ? undefined
+        : sourceMatchesById
+            ? sourceMatchesById.get(matchId)
+            : source.matches.find((m) => m.id === matchId);
     const participantBase = participants.getOrThrow(participantId);
     const roundBase = rounds.getOrThrow(matchRoundId);
     const matchIndex = participantBase.matchIds.indexOf(match.id);
@@ -230,7 +235,7 @@ const createNewMatchParticipantBase = (source, participantId, match, rounds, mat
     let tiesTilNow = isTie ? 1 : 0;
     for (let i = 0; i < matchIndex; i++) {
         const previousMatchId = participantBase.matchIds[i];
-        const previousMatch = source.matches.find((m) => m.id === previousMatchId);
+        const previousMatch = findSourceMatch(previousMatchId);
         const myPreviousMatchSide = previousMatch?.home === participantId ? 'home' : previousMatch?.away === participantId ? 'away' : null;
         if (!previousMatch || !myPreviousMatchSide)
             continue;
@@ -250,9 +255,7 @@ const createNewMatchParticipantBase = (source, participantId, match, rounds, mat
     const hasElimination = source.mode === TOURNAMENT_MODE.SINGLE_ELIMINATION ||
         source.mode === TOURNAMENT_MODE.DOUBLE_ELIMINATION ||
         source.mode === TOURNAMENT_MODE.SWISS_WITH_ELIMINATION;
-    // Means the current match is loss and it's the last match of the participant
     let isEliminated = false;
-    // Always true for single elimination, never for e.g. groups, depends on the round for double elimination, depends on the loss count for swiss with elimination
     let isEliminationMatch = false;
     if (hasElimination) {
         switch (source.mode) {
@@ -278,7 +281,7 @@ const createNewMatchParticipantBase = (source, participantId, match, rounds, mat
                         break;
                     const previousMatchIndex = currentMatchIndex - 1;
                     const previousMatchId = participantBase.matchIds[previousMatchIndex];
-                    const previousMatch = source.matches.find((m) => m.id === previousMatchId);
+                    const previousMatch = findSourceMatch(previousMatchId);
                     if (!previousMatch)
                         throw new BracketRuntimeError(BRACKET_ERROR_CODES.MATCH_RELATION_INVALID, `Previous match with id ${previousMatchId} not found`);
                     const previousRound = rounds.getOrThrow(previousMatch.roundId);
@@ -311,6 +314,7 @@ const createNewMatchParticipantBase = (source, participantId, match, rounds, mat
 
 const createMatchesMapBase = (source, rounds, participants) => {
     const map = new BracketMap();
+    const sourceMatchesById = new Map(source.matches.map((match) => [match.id, match]));
     for (const match of source.matches) {
         const genericRound = rounds.get(match.roundId);
         const splitRound = rounds.get(`${match.roundId}--half-1`);
@@ -336,8 +340,8 @@ const createMatchesMapBase = (source, rounds, participants) => {
                     : -1;
         if (indexInRound === -1)
             throw new BracketRuntimeError(BRACKET_ERROR_CODES.MATCH_RELATION_INVALID, `Match with id ${match.id} not found in round with id ${roundToUse.id}`);
-        const home = createNewMatchParticipantBase(source, match.home, match, rounds, roundToUse.id, participants);
-        const away = createNewMatchParticipantBase(source, match.away, match, rounds, roundToUse.id, participants);
+        const home = createNewMatchParticipantBase(source, match.home, match, rounds, roundToUse.id, participants, sourceMatchesById);
+        const away = createNewMatchParticipantBase(source, match.away, match, rounds, roundToUse.id, participants, sourceMatchesById);
         const winner = match.winner === 'home' ? home : match.winner === 'away' ? away : null;
         const matchBase = {
             home,
@@ -365,24 +369,27 @@ const createParticipantsMapBase = (source) => {
         .map((m) => [m.home, m.away])
         .flat()
         .filter((p) => !!p);
+    const matchIdsByParticipant = new Map();
+    for (const match of source.matches) {
+        for (const participantId of new Set([match.home, match.away])) {
+            if (!participantId)
+                continue;
+            const matchIds = matchIdsByParticipant.get(participantId) ?? [];
+            matchIds.push(match.id);
+            matchIdsByParticipant.set(participantId, matchIds);
+        }
+    }
     for (const [index, participantId] of participantIds.entries()) {
         const participantBase = {
             id: participantId,
             shortId: `p${index}`,
-            matchIds: source.matches
-                .filter((m) => m.home === participantId || m.away === participantId)
-                .map((m) => m.id),
+            matchIds: matchIdsByParticipant.get(participantId) ?? [],
         };
         map.set(participantId, participantBase);
     }
     return map;
 };
 
-const TERMINAL_ROUND_SORT_PRIORITY = {
-    final: 1,
-    'reverse-final': 2,
-    'third-place': 3,
-};
 const sortSourceMatchesByRoundOrder = (source) => {
     const orderedRoundIds = [...source.rounds]
         .sort((a, b) => (TERMINAL_ROUND_SORT_PRIORITY[a.type] ?? 0) - (TERMINAL_ROUND_SORT_PRIORITY[b.type] ?? 0))
@@ -391,7 +398,26 @@ const sortSourceMatchesByRoundOrder = (source) => {
     const sortedMatches = [...source.matches].sort((a, b) => (roundIndexMap.get(a.roundId) ?? 0) - (roundIndexMap.get(b.roundId) ?? 0));
     return { ...source, matches: sortedMatches };
 };
+const assertUniqueIds = (options) => {
+    const seen = new Set();
+    for (const id of options.ids) {
+        if (seen.has(id)) {
+            throw new BracketRuntimeError(options.code, `${options.kind} with id ${id} exists more than once in the source.`);
+        }
+        seen.add(id);
+    }
+};
 const createBracketBase = (source, options) => {
+    assertUniqueIds({
+        ids: source.rounds.map((round) => round.id),
+        code: BRACKET_ERROR_CODES.DUPLICATE_ROUND,
+        kind: 'Round',
+    });
+    assertUniqueIds({
+        ids: source.matches.map((match) => match.id),
+        code: BRACKET_ERROR_CODES.DUPLICATE_MATCH,
+        kind: 'Match',
+    });
     const normalizedSource = sortSourceMatchesByRoundOrder(source);
     const participants = createParticipantsMapBase(normalizedSource);
     const rounds = createRoundsMapBase(normalizedSource, options);
@@ -421,34 +447,29 @@ const path = (d, options) => {
 
 const curvePath = (from, to, direction, options) => {
     const inverted = options.inverted ?? false;
-    // Inline/block coordinates depending on direction and inversion
     const fromInline = inverted ? from.inline.start : from.inline.end;
     const toInline = inverted ? to.inline.end : to.inline.start;
     const fromBlock = from.block.center;
     const toBlock = to.block.center;
-    // Both bends have to fit inside the block distance between the two cards, or the line turns past its
-    // target and comes back. Scaling them down instead - to nothing, for two cards on the same row - is
-    // also what keeps the six commands below identical for every connector: a CSS `d` transition
-    // interpolates only between two paths of the same shape.
+    // Both bends have to fit inside the block and the inline distance between the two cards, or the line
+    // turns past its target and comes back. Scaling them down instead - to nothing, for two cards on the
+    // same row - is also what keeps the six commands below identical for every connector: a CSS `d`
+    // transition interpolates only between two paths of the same shape.
     const requestedCurve = options.lineStartingCurveAmount + options.lineEndingCurveAmount;
-    const blockDistance = Math.abs(toBlock - fromBlock);
-    const curveScale = requestedCurve > blockDistance ? blockDistance / requestedCurve : 1;
+    const totalInline = Math.abs(toInline - fromInline);
+    const room = Math.min(Math.abs(toBlock - fromBlock), totalInline);
+    const curveScale = requestedCurve > room ? room / requestedCurve : 1;
     const startCurve = options.lineStartingCurveAmount * curveScale;
     const endCurve = options.lineEndingCurveAmount * curveScale;
-    const totalInline = Math.abs(toInline - fromInline);
     const straightLength = (totalInline - startCurve - endCurve) / 2;
-    // Calculate key points for the path
     const straightEnd = inverted ? fromInline - straightLength : fromInline + straightLength;
     const straightStart = inverted ? toInline + straightLength : toInline - straightLength;
-    // First curve (from start)
     const firstCurveEndX = inverted ? straightEnd - startCurve : straightEnd + startCurve;
     const firstCurveEndY = direction === 'down' ? fromBlock + startCurve : fromBlock - startCurve;
-    // Second curve (to end)
     const secondCurveStartY = direction === 'down' ? toBlock - endCurve : toBlock + endCurve;
     const secondCurveEndX = straightStart;
     const secondCurveEndY = toBlock;
     const secondCurveBezierX = inverted ? straightStart + endCurve : straightStart - endCurve;
-    // SVG path string
     const d = [
         `M ${fromInline} ${fromBlock}`,
         `H ${straightEnd}`,
@@ -460,20 +481,14 @@ const curvePath = (from, to, direction, options) => {
     return path(d, options.path);
 };
 
-const createBracketElementPart = (config) => {
-    const { elementPartHeight } = config;
-    const newElementPart = {
-        dimensions: {
-            width: 0,
-            height: elementPartHeight,
-            top: 0,
-            left: 0,
-        },
-    };
-    return {
-        elementPart: newElementPart,
-    };
-};
+const createBracketElementPart = (config) => ({
+    dimensions: {
+        width: 0,
+        height: config.elementPartHeight,
+        top: 0,
+        left: 0,
+    },
+});
 
 const createBracketElement = (config) => {
     const { type, area, elementHeight, partHeights } = config;
@@ -532,18 +547,10 @@ const createBracketElement = (config) => {
                 throw new BracketRuntimeError(BRACKET_ERROR_CODES.GRID_INVALID, `Unknown element type: ${type}`);
         }
     })();
-    const pushPart = (...newParts) => {
-        parts.push(...newParts);
-    };
     for (const partHeight of partHeights) {
-        const { elementPart } = createBracketElementPart({
-            elementPartHeight: partHeight,
-        });
-        pushPart(elementPart);
+        parts.push(createBracketElementPart({ elementPartHeight: partHeight }));
     }
-    return {
-        element: newElement,
-    };
+    return newElement;
 };
 
 const finalizeBracketGrid = (grid) => {
@@ -625,8 +632,7 @@ const finalizeBracketGrid = (grid) => {
 
 const createBracketGrid = (config) => {
     const masterColumns = [];
-    const spannedWidthCache = new Map();
-    const spanStartLeftCache = new Map();
+    const contentWidths = new WeakMap();
     const newGrid = {
         dimensions: { width: 0, height: 0, top: 0, left: 0 },
         masterColumns,
@@ -642,7 +648,9 @@ const createBracketGrid = (config) => {
             const { padding } = masterColumn;
             masterColumn.dimensions.left = currentMasterColumnLeft;
             masterColumn.dimensions.top = 0;
-            masterColumn.dimensions.width += padding.left + padding.right;
+            const contentWidth = contentWidths.get(masterColumn) ?? masterColumn.dimensions.width;
+            contentWidths.set(masterColumn, contentWidth);
+            masterColumn.dimensions.width = contentWidth + padding.left + padding.right;
             const sections = masterColumn.sections;
             let runningTop = 0;
             const firstElement = sections[0]?.subColumns[0]?.elements[0];
@@ -660,10 +668,10 @@ const createBracketGrid = (config) => {
                 section.dimensions.left = masterColumn.dimensions.left;
                 section.dimensions.top = runningTop;
                 runningTop += sectionPaddingTop;
-                const contentWidth = masterColumn.dimensions.width - sectionPadding.left - sectionPadding.right;
+                const sectionContentWidth = masterColumn.dimensions.width - sectionPadding.left - sectionPadding.right;
                 const subColumns = section.subColumns;
                 const totalSubColumns = subColumns.length;
-                const subColumnWidth = contentWidth / totalSubColumns;
+                const subColumnWidth = sectionContentWidth / totalSubColumns;
                 let currentSubColumnLeft = masterColumn.dimensions.left + sectionPadding.left;
                 let maxSectionHeight = 0;
                 for (const subColumn of subColumns) {
@@ -726,8 +734,7 @@ const createBracketGrid = (config) => {
                         const isStartPosition = mcIdx === span.masterColumnStart && secIdx === span.sectionStart && scIdx === span.subColumnStart;
                         const spanKey = `${span.masterColumnStart}-${span.masterColumnEnd}-${span.sectionStart}-${span.sectionEnd}-${span.subColumnStart}-${span.subColumnEnd}`;
                         if (isStartPosition && !spanDimensions.has(spanKey)) {
-                            const totalSpannedWidth = calculateSpannedWidth(span, masterCols);
-                            const spanStartLeft = calculateSpanStartLeft(span, masterCols);
+                            const { left: spanStartLeft, width: totalSpannedWidth } = calculateSpanExtent(span, masterCols);
                             const width = config.spanElementWidth;
                             // Winner bracket rounds span two lower bracket columns. Left-align them within that
                             // span (factor 0) instead of centering (factor 0.5) so each winner round n sits above
@@ -742,75 +749,18 @@ const createBracketGrid = (config) => {
                         if (storedDimensions) {
                             element.dimensions.width = storedDimensions.width;
                             element.dimensions.left = storedDimensions.left;
-                            element.isHidden = !isStartPosition;
                         }
                     }
                 }
             }
         }
     };
-    const calculateSpannedWidth = (span, masterColumns) => {
-        const key = `${span.masterColumnStart}-${span.masterColumnEnd}-${span.sectionStart}-${span.sectionEnd}-${span.subColumnStart}-${span.subColumnEnd}`;
-        const cachedWidth = spannedWidthCache.get(key);
-        if (cachedWidth !== undefined)
-            return cachedWidth;
-        if (span.masterColumnStart === span.masterColumnEnd) {
-            const masterColumn = masterColumns[span.masterColumnStart];
-            if (masterColumn) {
-                const section = masterColumn.sections[span.sectionStart];
-                if (section) {
-                    const subColumnWidth = section.dimensions.width / section.subColumns.length;
-                    const totalWidth = subColumnWidth * (span.subColumnEnd - span.subColumnStart + 1);
-                    spannedWidthCache.set(key, totalWidth);
-                    return totalWidth;
-                }
-            }
-            spannedWidthCache.set(key, 0);
-            return 0;
-        }
-        let totalWidth = 0;
-        for (let mcIdx = span.masterColumnStart; mcIdx <= span.masterColumnEnd; mcIdx++) {
-            const masterColumn = masterColumns[mcIdx];
-            if (!masterColumn)
-                continue;
-            if (mcIdx === span.masterColumnStart) {
-                const section = masterColumn.sections[span.sectionStart];
-                if (section) {
-                    const subColumnWidth = section.dimensions.width / section.subColumns.length;
-                    totalWidth += subColumnWidth * (section.subColumns.length - span.subColumnStart);
-                }
-            }
-            else if (mcIdx === span.masterColumnEnd) {
-                const section = masterColumn.sections[span.sectionEnd];
-                if (section) {
-                    const subColumnWidth = section.dimensions.width / section.subColumns.length;
-                    totalWidth += subColumnWidth * (span.subColumnEnd + 1);
-                }
-            }
-            else {
-                totalWidth += masterColumn.dimensions.width;
-            }
-        }
-        spannedWidthCache.set(key, totalWidth);
-        return totalWidth;
-    };
-    const calculateSpanStartLeft = (span, masterColumns) => {
-        const key = `${span.masterColumnStart}-${span.sectionStart}-${span.subColumnStart}`;
-        const cachedLeft = spanStartLeftCache.get(key);
-        if (cachedLeft !== undefined)
-            return cachedLeft;
-        const startMasterColumn = masterColumns[span.masterColumnStart];
-        if (!startMasterColumn) {
-            spanStartLeftCache.set(key, 0);
-            return 0;
-        }
-        let startLeft = startMasterColumn.dimensions.left;
-        const section = startMasterColumn.sections[span.sectionStart];
-        if (section) {
-            startLeft += (section.dimensions.width / section.subColumns.length) * span.subColumnStart;
-        }
-        spanStartLeftCache.set(key, startLeft);
-        return startLeft;
+    const calculateSpanExtent = (span, masterColumns) => {
+        const start = masterColumns[span.masterColumnStart]?.sections[span.sectionStart]?.subColumns[span.subColumnStart];
+        const end = masterColumns[span.masterColumnEnd]?.sections[span.sectionEnd]?.subColumns[span.subColumnEnd];
+        if (!start || !end)
+            return { left: start?.dimensions.left ?? 0, width: 0 };
+        return { left: start.dimensions.left, width: end.dimensions.left + end.dimensions.width - start.dimensions.left };
     };
     const setupElementSpans = () => {
         const masterCols = newGrid.masterColumns;
@@ -957,11 +907,16 @@ const createBracketContinueMasterColumn = (config) => {
         throw new BracketRuntimeError(BRACKET_ERROR_CODES.GRID_INVALID, 'No last master column found in existing master columns');
     }
     // Dimensions are not calculated yet at this point, but all part heights are static, so the
-    // total column height is the sum of the tallest sub column of every section.
-    const totalHeight = lastMasterColumn.sections.reduce((height, section) => {
+    // total column height is the sum of the tallest sub column of every section plus its padding - the
+    // same sum `calculateDimensions` makes, which skips the top padding of a leading header section.
+    const firstSectionIsHeader = lastMasterColumn.sections[0]?.subColumns[0]?.elements[0]?.type === 'header';
+    let totalHeight = 0;
+    for (const [sectionIndex, section] of lastMasterColumn.sections.entries()) {
+        const padding = section.padding ?? lastMasterColumn.padding;
+        const paddingTop = sectionIndex === 0 && firstSectionIsHeader ? 0 : padding.top;
         const sectionHeight = Math.max(0, ...section.subColumns.map((subColumn) => subColumn.elements.reduce((subColumnHeight, element) => subColumnHeight + element.parts.reduce((sum, part) => sum + part.dimensions.height, 0), 0)));
-        return height + sectionHeight;
-    }, 0);
+        totalHeight += paddingTop + sectionHeight + padding.bottom;
+    }
     const { masterColumn, pushSection } = createBracketMasterColumn({
         columnWidth,
         padding: {
@@ -981,7 +936,7 @@ const createBracketContinueMasterColumn = (config) => {
         },
     });
     if (headerOffset > 0) {
-        const { element: headerGapElement } = createBracketElement({
+        const headerGapElement = createBracketElement({
             area: '.',
             type: 'colGap',
             elementHeight: headerOffset,
@@ -990,7 +945,7 @@ const createBracketContinueMasterColumn = (config) => {
         pushElement(headerGapElement);
     }
     const containerHeight = Math.max(elementHeight, totalHeight - headerOffset);
-    const { element: continueElement } = createBracketElement({
+    const continueElement = createBracketElement({
         area: 'continue',
         type: 'continue',
         elementHeight,
@@ -1087,7 +1042,6 @@ const drawMan = (dimensions) => {
                 .filter((id) => !!id)
                 .join(' ');
             const currentPos = makePos(el.dimensions);
-            // No lines for the third place match
             if (el.round.type === COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE)
                 continue;
             if (continuePos && isBracketContinueMatch(el.match)) {
@@ -1100,8 +1054,7 @@ const drawMan = (dimensions) => {
             // Crossing the middle of a fold. Every other line here is drawn by the match it flows *into*, but a
             // round in the middle of a mirrored bracket is fed from both sides and its relation names only one
             // of them - so the round on the way back draws its own line. Deliberately outside the switch below:
-            // which relation a match has says nothing about which side of a fold it sits on, and keying this to
-            // `two-to-one` is why a folded lower bracket used to lose the line into its centre round.
+            // which relation a match has says nothing about which side of a fold it sits on.
             if (el.round.mirrorRoundType === BRACKET_ROUND_MIRROR_TYPE.RIGHT && 'nextMatch' in el.match.relation) {
                 const { nextMatch, nextRound } = el.match.relation;
                 if (nextRound.mirrorRoundType === null) {
@@ -1118,6 +1071,7 @@ const drawMan = (dimensions) => {
                 }
             }
             switch (el.match.relation.type) {
+                case 'none':
                 case 'nothing-to-one': {
                     continue;
                 }
@@ -1125,8 +1079,8 @@ const drawMan = (dimensions) => {
                 case 'one-to-one': {
                     const prev = dimensions.bracketGrid.matchElementMap.getOrThrow(el.match.relation.previousMatch.id);
                     const prevPos = makePos(prev.dimensions);
-                    // The winner of the match it comes from, like every other connector - this used to carry both of
-                    // the *current* match's participants, which lit the line for whoever arrived from somewhere else.
+                    // The winner of the match it comes from, like every other connector, or the journey highlight
+                    // lights the line for whoever arrived from somewhere else.
                     pushEdge(straightPath(prevPos, currentPos, {
                         path: {
                             ...dimensions.path,
@@ -1160,7 +1114,6 @@ const drawMan = (dimensions) => {
                         }));
                     }
                     else {
-                        // draw two lines that merge into one in the middle
                         pushEdge(mergePath(prevUpperPos, currentPos, 'down', {
                             ...curveOptions,
                             path: {
@@ -1265,7 +1218,6 @@ const factorialCache = /* @__PURE__ */ new Map();
 const getAvailableSwissGroupsForRound = (roundNumber, totalMatchesInRound) => {
     const advanceWins = SWISS_ADVANCE_WINS;
     const eliminateLosses = SWISS_ELIMINATE_LOSSES;
-    // Cache factorial calculations
     const getFactorial = (n) => {
         if (n <= 1)
             return 1;
@@ -1276,11 +1228,9 @@ const getAvailableSwissGroupsForRound = (roundNumber, totalMatchesInRound) => {
         factorialCache.set(n, result);
         return result;
     };
-    // Pre-calculate roundFactorial
     const roundFactorial = getFactorial(roundNumber);
     let totalCombinations = 0;
     const validGroups = [];
-    // Single loop to gather valid groups and total combinations
     for (let wins = roundNumber; wins >= 0; wins--) {
         const losses = roundNumber - wins;
         const remainingGames = advanceWins + eliminateLosses - (wins + losses) - 1;
@@ -1292,7 +1242,6 @@ const getAvailableSwissGroupsForRound = (roundNumber, totalMatchesInRound) => {
         totalCombinations += combinations;
         validGroups.push({ wins, losses, combinations });
     }
-    // Create final groups with calculated proportions
     return validGroups.map(({ wins, losses, combinations }) => ({
         id: `${wins}-${losses}`,
         name: `${wins}-${losses}`,
@@ -1388,9 +1337,8 @@ const collectSwissRoundGeometries = (bracketGrid) => {
         if (!group || !round)
             continue;
         const [wins, losses] = group.id.split('-').map(Number);
-        if (wins === undefined || losses === undefined || isNaN(wins) || isNaN(losses)) {
-            throw new BracketRuntimeError(BRACKET_ERROR_CODES.SWISS_GROUPING_FAILED, `Unable to parse wins and losses from Swiss group id: ${group.id}`);
-        }
+        if (wins === undefined || losses === undefined || isNaN(wins) || isNaN(losses))
+            continue;
         const matchesTop = Math.min(...matchElements.map((element) => element.dimensions.top));
         const matchesBottom = Math.max(...matchElements.map((element) => element.dimensions.top + element.dimensions.height));
         const winnerShortIds = [];
@@ -1536,42 +1484,20 @@ const drawSwissMan = (dimensions) => {
 };
 
 const calculateUpperLowerRatio = (upperRoundsCount, lowerRoundsCount) => {
-    // In double elimination, after the first aligned column,
-    // we need to distribute the remaining upper rounds across the remaining lower rounds
-    const remainingUpperRounds = upperRoundsCount - 1; // Subtract the first round
-    const remainingLowerRounds = lowerRoundsCount - 1; // Subtract the first round
-    if (remainingUpperRounds === 0) {
-        return 1; // Edge case: only one upper round
-    }
+    const remainingUpperRounds = upperRoundsCount - 1;
+    const remainingLowerRounds = lowerRoundsCount - 1;
+    if (remainingUpperRounds === 0)
+        return 1;
     return remainingLowerRounds / remainingUpperRounds;
 };
-const calculateColumnSplitFactor = (upperToLowerRatio) => {
-    // The split factor determines how many sub-columns each match column will have
-    // For example, if the ratio is 1.5, we split each match column
-    // into 2 sub-columns so that matches can be centered correctly
-    if (upperToLowerRatio === 1.5) {
-        return 2; // Split into 2 sub-columns for 1.5 ratio
-    }
-    if (upperToLowerRatio === 2) {
-        return 1; // Split into 1 sub-columns for 2 ratio
-    }
-    return 1;
-};
+const calculateColumnSplitFactor = (upperToLowerRatio) => (upperToLowerRatio === 1.5 ? 2 : 1);
 const calculateLowerRoundIndex = (subColumnIndex, splitFactor) => Math.floor(subColumnIndex / splitFactor);
 // eslint-disable-next-line max-params -- index math over positional grid coordinates
 const calculateUpperRoundIndex = (subColumnIndex, upperToLowerRatio, splitFactor) => {
-    // Calculate which complete column we're in
     const completeColumnIndex = Math.floor(subColumnIndex / splitFactor);
-    // For the first complete column (index 0), always use the first upper round (index 0)
-    if (completeColumnIndex === 0) {
+    if (completeColumnIndex === 0)
         return 0;
-    }
-    // For subsequent columns, map based on the ratio
-    // We subtract 1 because the first column is handled separately
-    const adjustedColumnIndex = completeColumnIndex - 1;
-    // Calculate which upper round this column should use
-    // We add 1 because we start from the second upper round (index 1)
-    return Math.floor(adjustedColumnIndex / upperToLowerRatio) + 1;
+    return Math.floor((completeColumnIndex - 1) / upperToLowerRatio) + 1;
 };
 
 const createRoundBracketSubColumnRelativeToFirstRound = (config) => {
@@ -1588,7 +1514,6 @@ const createRoundBracketSubColumnRelativeToFirstRound = (config) => {
         ? Math.max(options.roundHeaderGap, options.finalRoundHeaderGap ?? 0)
         : options.roundHeaderGap;
     const elementsToCreate = [];
-    // Only include a header row if headers exist
     if (options.roundHeaderHeight > 0) {
         elementsToCreate.push({
             type: 'header',
@@ -1605,7 +1530,6 @@ const createRoundBracketSubColumnRelativeToFirstRound = (config) => {
             elementHeight: roundHeaderGap,
         });
     }
-    // Add match elements to create
     for (const [matchIndex, match] of matches.entries()) {
         const isLastMatch = matchIndex === matches.length - 1;
         // One row per match this one is fed by. A fractional factor has no whole feeder row to align to,
@@ -1649,16 +1573,14 @@ const createRoundBracketSubColumnRelativeToFirstRound = (config) => {
             elementHeight: config.bottomPadding,
         });
     }
-    // Create all elements at once
     for (const elementData of elementsToCreate) {
-        const { element } = createBracketElement(elementData);
+        const element = createBracketElement(elementData);
         pushElement(element);
     }
     return subColumn;
 };
 
 const heightOfElement = (element) => element.parts.reduce((total, part) => total + part.dimensions.height, 0);
-/** Read off the built rows rather than re-derived, so the two stay in step. */
 const cardGeometry = (subColumn) => {
     let height = 0;
     let cardTop = null;
@@ -1721,6 +1643,7 @@ const createBracketGapMasterColumn = (config) => {
     for (const section of lastMasterColumn.sections) {
         const { masterColumnSection, pushSubColumn } = createBracketMasterColumnSection({
             type: 'gap',
+            padding: section.padding && { ...section.padding, left: 0, right: 0 },
         });
         const lastSubColumn = section.subColumns[section.subColumns.length - 1];
         if (!lastSubColumn) {
@@ -1780,7 +1703,7 @@ const createBracketGapMasterColumn = (config) => {
                     partHeights,
                 };
             })();
-            pushElement(createBracketElement(elementToCreate).element);
+            pushElement(createBracketElement(elementToCreate));
         }
         pushSubColumn(subColumn);
         pushSection(masterColumnSection);
@@ -1798,8 +1721,8 @@ const resolveBracketGridRowSpan = (bracket, options) => {
 const createDoubleEliminationGrid = (bracketData, options, components) => {
     const resolvedOptions = resolveBracketGridRowSpan(bracketData, options);
     const grid = createBracketGrid({ spanElementWidth: resolvedOptions.columnWidth });
-    const presentUpperBracketRounds = Array.from(bracketData.roundsByType.getOrThrow(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET).values());
-    const lowerBracketRounds = Array.from(bracketData.roundsByType.getOrThrow(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET).values());
+    const presentUpperBracketRounds = Array.from(bracketData.roundsByType.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.UPPER_BRACKET)?.values() ?? []);
+    const lowerBracketRounds = Array.from(bracketData.roundsByType.get(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET)?.values() ?? []);
     // A complete winner bracket has (lowerRounds / 2) + 1 rounds. If fewer are present, the winner
     // bracket starts later than round 1 - e.g. a small double elimination where lower-round 1 is
     // seeded directly from a group phase and has no winner round feeding it. Pad the front of the
@@ -1844,7 +1767,7 @@ const createDoubleEliminationGrid = (bracketData, options, components) => {
             firstUpperRound.matchCount * options.matchHeight +
             Math.max(0, firstUpperRound.matchCount - 1) * options.rowGap;
         const { subColumn, pushElement } = createBracketSubColumn({ span: config.span });
-        const { element } = createBracketElement({
+        const element = createBracketElement({
             area: '.',
             type: 'colGap',
             elementHeight: emptyUpperHeight,
@@ -1858,7 +1781,7 @@ const createDoubleEliminationGrid = (bracketData, options, components) => {
         const { subColumn, pushElement } = createBracketSubColumn({
             span: { isStart: true, isEnd: true },
         });
-        const { element } = createBracketElement({
+        const element = createBracketElement({
             area: '.',
             type: 'roundGap',
             elementHeight: options.rowRoundGap,
@@ -1908,17 +1831,14 @@ const createDoubleEliminationGrid = (bracketData, options, components) => {
             }
             // May be null for a leading winner slot that does not exist (front-truncated winner bracket).
             const upperRound = upperBracketRounds[currentUpperRoundIndex];
-            // For upper bracket spans - check if this round is different from the previous occurrence
             const isUpperSpanStart = isFirstSubColumnInMasterColumn
                 ? lowerRoundIndex === 0 || lastRoundLastSubColumnUpperIndex !== currentUpperRoundIndex
                 : previousUpperRoundIndex !== currentUpperRoundIndex;
-            // For upper bracket spans - check if this round will be different in the next occurrence
             const isUpperSpanEnd = isLastSubColumnInMasterColumn
                 ? isLastLowerRound ||
                     calculateUpperRoundIndex((lowerRoundIndex + 1) * columnSplitFactor, upperToLowerRatio, columnSplitFactor) !==
                         currentUpperRoundIndex
                 : nextUpperRoundIndex !== currentUpperRoundIndex;
-            // For lower bracket spans - similar logic
             const isLowerSpanStart = isFirstSubColumnInMasterColumn
                 ? lowerRoundIndex === 0 || lastRoundLastSubColumnLowerIndex !== currentLowerRoundIndex
                 : previousLowerRoundIndex !== currentLowerRoundIndex;
@@ -2008,7 +1928,7 @@ const createDoubleEliminationGrid = (bracketData, options, components) => {
             elementHeight: options.rowRoundGap,
             partHeights: [options.rowRoundGap],
         });
-        upperLowerGapSubColumn.pushElement(upperLowerGapElement.element);
+        upperLowerGapSubColumn.pushElement(upperLowerGapElement);
         pushUpperLowerSubColumn(upperLowerGapSubColumn.subColumn);
         if (thirdPlaceRound) {
             const lowerSubColumn = createRoundBracketSubColumnRelativeToFirstRound({
@@ -2047,7 +1967,7 @@ const createDoubleEliminationGrid = (bracketData, options, components) => {
                     elementHeight: element.dimensions.height,
                     partHeights: element.parts.map((p) => p.dimensions.height),
                 });
-                lowerSubColumn.pushElement(el.element);
+                lowerSubColumn.pushElement(el);
             }
             pushLowerSubColumn(lowerSubColumn.subColumn);
         }
@@ -2087,35 +2007,22 @@ const createDoubleEliminationGrid = (bracketData, options, components) => {
     };
 };
 
-/**
- * Where a round that never folded sits in its block's centre chain. A bracket's own rounds go first, by
- * depth; the rounds that decide the tournament follow in the order they are played.
- */
 const CENTRE_CHAIN_ORDER = {
     [COMMON_BRACKET_ROUND_TYPE.FINAL]: 1,
     [DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL]: 2,
     [COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE]: 3,
 };
-/** The card drawn for a round's matches - the deciding one is the taller `finalMatch`. */
 const isFinalMatchRound = (round, hasReverseFinal) => hasReverseFinal
     ? round.type === DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL
     : round.type === COMMON_BRACKET_ROUND_TYPE.FINAL;
-/**
- * A chain round takes exactly the room its cards need. Every other column reserves the same height for
- * every round (`createRoundBracketSubColumnRelativeToFirstRound`), which the chain cannot do - it stacks
- * several rounds in one column.
- */
 const chainRoundHeight = (config) => {
     const { round, options, hasReverseFinal } = config;
     const cardHeight = isFinalMatchRound(round, hasReverseFinal) ? options.finalMatchHeight : options.matchHeight;
     return round.matchCount * cardHeight + Math.max(0, round.matchCount - 1) * options.rowGap;
 };
-/**
- * Splits one bracket's rounds into the fold's three parts and works out the heights that keep the two
- * blocks aligned. `null` when the bracket has no rounds at all.
- */
 const createStackedBlock = (config) => {
-    const { rounds, options, hasReverseFinal } = config;
+    const { rounds, hasReverseFinal } = config;
+    const options = resolveBracketGridRowSpan({ rounds }, config.options);
     const halves = rounds.filter((round) => !!round.mirrorRoundType);
     const left = halves
         .filter((round) => round.mirrorRoundType === BRACKET_ROUND_MIRROR_TYPE.LEFT)
@@ -2136,7 +2043,10 @@ const createStackedBlock = (config) => {
     const firstRound = leftSlots[0] ?? chain[0];
     if (!firstRound)
         return null;
-    const content = firstRound.matchCount * options.matchHeight + Math.max(0, firstRound.matchCount - 1) * options.rowGap;
+    const rows = options.rowSpanMatchCount ?? firstRound.matchCount;
+    const rowsHeight = (count) => count * options.matchHeight + Math.max(0, count - 1) * options.rowGap;
+    const content = rowsHeight(rows);
+    const columnContent = (round) => rowsHeight(Math.max(rows, round.matchCount));
     let chainHeight = 0;
     for (const [index, round] of chain.entries()) {
         chainHeight += (index ? options.rowRoundGap : 0) + chainRoundHeight({ round, options, hasReverseFinal });
@@ -2147,15 +2057,17 @@ const createStackedBlock = (config) => {
     // there grows the block rather than sliding up: an anchor a few px off centre turns every one of those
     // connectors into a diagonal, in a drawing where nothing else is.
     const spacerTop = Math.max(0, (content - anchorHeight) / 2);
+    const body = Math.max(spacerTop + chainHeight, ...[...leftSlots, ...right].map(columnContent));
     return {
         firstRound,
         left: leftSlots,
         right,
         chain,
-        content,
-        bottomPadding: Math.max(0, spacerTop + chainHeight - content),
+        options,
+        body,
+        columnContent,
         spacerTop,
-        spacerBottom: Math.max(0, content - spacerTop - chainHeight),
+        spacerBottom: Math.max(0, body - spacerTop - chainHeight),
     };
 };
 /**
@@ -2166,8 +2078,7 @@ const createStackedBlock = (config) => {
  * @internal
  */
 const createStackedDoubleEliminationGrid = (bracketData, options, components) => {
-    const resolvedOptions = resolveBracketGridRowSpan(bracketData, options);
-    const grid = createBracketGrid({ spanElementWidth: resolvedOptions.columnWidth });
+    const grid = createBracketGrid({ spanElementWidth: options.columnWidth });
     const roundsOfType = (type) => Array.from(bracketData.roundsByType.get(type)?.values() ?? []);
     const hasReverseFinal = !!roundsOfType(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL).length;
     const winners = createStackedBlock({
@@ -2176,7 +2087,7 @@ const createStackedDoubleEliminationGrid = (bracketData, options, components) =>
             ...roundsOfType(COMMON_BRACKET_ROUND_TYPE.FINAL),
             ...roundsOfType(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.REVERSE_FINAL),
         ],
-        options: resolvedOptions,
+        options,
         hasReverseFinal,
     });
     const losers = createStackedBlock({
@@ -2184,7 +2095,7 @@ const createStackedDoubleEliminationGrid = (bracketData, options, components) =>
             ...roundsOfType(DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE.LOWER_BRACKET),
             ...roundsOfType(COMMON_BRACKET_ROUND_TYPE.THIRD_PLACE),
         ],
-        options: resolvedOptions,
+        options,
         hasReverseFinal,
     });
     if (!winners || !losers) {
@@ -2192,12 +2103,9 @@ const createStackedDoubleEliminationGrid = (bracketData, options, components) =>
     }
     const blocks = [winners, losers];
     const headerBlock = options.roundHeaderHeight > 0 ? options.roundHeaderHeight + options.roundHeaderGap : 0;
-    const blockHeight = (block) => headerBlock + block.content + block.bottomPadding;
-    // Both blocks put their centre in the same master column, so the chains - and the grand final's line
-    // down to the losers champion - run up one strip rather than two.
+    const blockHeight = (block) => headerBlock + block.body;
     const centreIndex = Math.max(...blocks.map((block) => block.left.length));
     const columnCount = centreIndex + 1 + Math.max(...blocks.map((block) => block.right.length));
-    /** A column this block does not reach into, holding the height its rounds would have taken. */
     const createPlaceholderSubColumn = (block) => {
         const { subColumn, pushElement } = createBracketSubColumn({
             span: { isStart: true, isEnd: true },
@@ -2208,7 +2116,7 @@ const createStackedDoubleEliminationGrid = (bracketData, options, components) =>
             type: 'colGap',
             elementHeight: height,
             partHeights: [height],
-        }).element);
+        }));
         return subColumn;
     };
     const createChainSubColumn = (block) => {
@@ -2286,11 +2194,10 @@ const createStackedDoubleEliminationGrid = (bracketData, options, components) =>
             });
         }
         for (const elementData of elementsToCreate) {
-            pushElement(createBracketElement(elementData).element);
+            pushElement(createBracketElement(elementData));
         }
         return subColumn;
     };
-    /** What this block draws in the column at `columnIndex`, centred on the shared middle column. */
     const createBlockSubColumn = (block, columnIndex) => {
         const slotIndex = columnIndex - (centreIndex - block.left.length);
         if (slotIndex === block.left.length)
@@ -2303,14 +2210,13 @@ const createStackedDoubleEliminationGrid = (bracketData, options, components) =>
         return createRoundBracketSubColumnRelativeToFirstRound({
             firstRound: block.firstRound,
             round,
-            options: resolvedOptions,
+            options: block.options,
             hasReverseFinal,
-            bottomPadding: block.bottomPadding,
+            bottomPadding: block.body - block.columnContent(round),
             span: { isStart: true, isEnd: true },
             components,
         });
     };
-    /** The band the print reference leaves empty: the two blocks are independent, so nothing crosses it. */
     const createBandSubColumn = () => {
         const { subColumn, pushElement } = createBracketSubColumn({
             span: { isStart: true, isEnd: true },
@@ -2320,7 +2226,7 @@ const createStackedDoubleEliminationGrid = (bracketData, options, components) =>
             type: 'roundGap',
             elementHeight: options.rowRoundGap,
             partHeights: [options.rowRoundGap],
-        }).element);
+        }));
         return subColumn;
     };
     for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
@@ -2343,7 +2249,6 @@ const createStackedDoubleEliminationGrid = (bracketData, options, components) =>
             }));
         }
     }
-    // No spans: a stacked block draws one round per column, so nothing reaches across its neighbours.
     grid.calculateDimensions();
     const finalizedGrid = finalizeBracketGrid(grid);
     return {
@@ -2451,32 +2356,45 @@ const createSingleEliminationGrid = (bracketData, options, components) => {
 
 const FALLBACK_MATCH_RELATION_POSITION = -1;
 const generateMatchPosition = (match, factor) => Math.ceil(match.position * factor);
+const generatePreviousRoundMatchPositions = (relation, match) => {
+    const feederFactor = relation.currentRound.matchCount / relation.previousRound.matchCount;
+    const feederPositions = [];
+    for (const feeder of relation.previousRound.matches.values()) {
+        if (generateMatchPosition(feeder, feederFactor) === match.position)
+            feederPositions.push(feeder.position);
+    }
+    const first = feederPositions[0];
+    const last = feederPositions[feederPositions.length - 1];
+    if (first !== undefined && last !== undefined) {
+        return { previousUpperRoundMatchPosition: first, previousLowerRoundMatchPosition: last };
+    }
+    const double = relation.previousRoundMatchFactor === 2 ? 1 : 0;
+    return {
+        previousUpperRoundMatchPosition: (generateMatchPosition(match, relation.previousRoundMatchFactor) -
+            double),
+        previousLowerRoundMatchPosition: generateMatchPosition(match, relation.previousRoundMatchFactor),
+    };
+};
 const generateMatchRelationPositions = (relation, match) => {
     switch (relation.type) {
+        case 'none':
+            return null;
         case 'nothing-to-one':
             return {
                 nextRoundMatchPosition: generateMatchPosition(match, relation.nextRoundMatchFactor),
                 previousUpperRoundMatchPosition: FALLBACK_MATCH_RELATION_POSITION,
                 previousLowerRoundMatchPosition: FALLBACK_MATCH_RELATION_POSITION,
             };
-        case 'one-to-nothing': {
-            const double = relation.previousRoundMatchFactor === 2 ? 1 : 0;
+        case 'one-to-nothing':
             return {
                 nextRoundMatchPosition: FALLBACK_MATCH_RELATION_POSITION,
-                previousUpperRoundMatchPosition: (generateMatchPosition(match, relation.previousRoundMatchFactor) -
-                    double),
-                previousLowerRoundMatchPosition: generateMatchPosition(match, relation.previousRoundMatchFactor),
+                ...generatePreviousRoundMatchPositions(relation, match),
             };
-        }
-        case 'one-to-one': {
-            const double = relation.previousRoundMatchFactor === 2 ? 1 : 0;
+        case 'one-to-one':
             return {
                 nextRoundMatchPosition: generateMatchPosition(match, relation.nextRoundMatchFactor),
-                previousUpperRoundMatchPosition: (generateMatchPosition(match, relation.previousRoundMatchFactor) -
-                    double),
-                previousLowerRoundMatchPosition: generateMatchPosition(match, relation.previousRoundMatchFactor),
+                ...generatePreviousRoundMatchPositions(relation, match),
             };
-        }
         case 'two-to-one':
             return {
                 nextRoundMatchPosition: generateMatchPosition(match, relation.nextRoundMatchFactor),
@@ -2620,7 +2538,7 @@ const createTwoToNothingRelation$1 = (params) => {
 };
 const generateMatchRelationsNew = (bracketData, options = {}) => {
     const sourceMatches = options.source?.matches ?? [];
-    const hasDeclaredGraph = options.previousMatchIds !== undefined || sourceMatches.some((match) => defaultPreviousMatchIds(match).length > 0);
+    const hasDeclaredGraph = options.previousMatchIds !== undefined || sourceMatches.some((match) => matchOutcomeSlots(match).length > 0);
     if (hasDeclaredGraph) {
         return generateDeclaredMatchRelations({
             bracket: bracketData,
@@ -2637,9 +2555,6 @@ const generateMatchRelationsNew = (bracketData, options = {}) => {
     for (const match of bracketData.matches.values()) {
         const relation = match.round.relation;
         const positions = generateMatchRelationPositions(relation, match);
-        // A round without a resolved relation (e.g. a truncated bracket where a round has no
-        // successor/predecessor to wire up) keeps the placeholder relation from createBracket.
-        // Skip it so the match renders without connector lines instead of crashing the whole bracket.
         if (!positions)
             continue;
         const { nextRoundMatchPosition, previousUpperRoundMatchPosition, previousLowerRoundMatchPosition } = positions;
@@ -2694,9 +2609,10 @@ const generateMatchRelationsNew = (bracketData, options = {}) => {
     }
     return matchRelations;
 };
-const defaultPreviousMatchIds = (match) => [match.homeSource, match.awaySource]
-    .filter((slot) => slot?.kind === 'match-outcome' && slot.matchId !== null)
-    .map((slot) => slot?.matchId);
+const matchOutcomeSlots = (match) => [match.homeSource, match.awaySource].filter((slot) => slot?.kind === 'match-outcome' && !!slot.matchId);
+const defaultPreviousMatchIds = (match) => matchOutcomeSlots(match)
+    .filter((slot) => slot.role !== 'loser')
+    .map((slot) => slot.matchId);
 const generateDeclaredMatchRelations = (options) => {
     const { bracket, sourceMatches, previousMatchIds } = options;
     const previousByMatchId = new Map(sourceMatches.map((match) => [match.id, previousMatchIds(match)]));
@@ -2927,43 +2843,28 @@ const handleFinalRound = (params) => {
             firstLowerRound,
         }));
     }
-    if (isAsyncBracket) {
-        const preFinalLowerRound = lowerRounds[lowerRounds.length - 2];
-        const prePreFinalLowerRound = lowerRounds[lowerRounds.length - 3] || null;
-        if (!preFinalLowerRound)
-            throw new BracketRuntimeError(BRACKET_ERROR_CODES.ROUND_RELATION_INVALID, 'preFinalLowerRound is null');
-        relations.push(createOneToOneRelation({
-            currentRound: finalLowerRound,
-            previousRound: preFinalLowerRound,
-            nextRound: currentUpperRound,
-            rootRound: firstLowerRound,
-        }));
-        if (prePreFinalLowerRound) {
-            relations.push(createOneToOneRelation({
-                currentRound: preFinalLowerRound,
-                previousRound: prePreFinalLowerRound,
-                nextRound: finalLowerRound,
-                rootRound: firstLowerRound,
-            }));
-        }
-        else {
-            relations.push(createNothingToOneRelation({
-                currentRound: preFinalLowerRound,
-                nextRound: finalLowerRound,
-            }));
-        }
+    const preFinalLowerRound = lowerRounds[lowerRounds.length - 2] || null;
+    if (!preFinalLowerRound) {
+        relations.push(createNothingToOneRelation({ currentRound: finalLowerRound, nextRound: currentUpperRound }));
+        return;
     }
-    else {
-        const previousLowerRound = lowerRounds[lowerRounds.length - 2] || null;
-        if (!previousLowerRound)
-            throw new BracketRuntimeError(BRACKET_ERROR_CODES.ROUND_RELATION_INVALID, 'previousLowerRound is null');
-        relations.push(createOneToOneRelation({
-            currentRound: finalLowerRound,
-            previousRound: previousLowerRound,
-            nextRound: currentUpperRound,
+    relations.push(createOneToOneRelation({
+        currentRound: finalLowerRound,
+        previousRound: preFinalLowerRound,
+        nextRound: currentUpperRound,
+        rootRound: firstLowerRound,
+    }));
+    if (!isAsyncBracket)
+        return;
+    const prePreFinalLowerRound = lowerRounds[lowerRounds.length - 3] || null;
+    relations.push(prePreFinalLowerRound
+        ? createOneToOneRelation({
+            currentRound: preFinalLowerRound,
+            previousRound: prePreFinalLowerRound,
+            nextRound: finalLowerRound,
             rootRound: firstLowerRound,
-        }));
-    }
+        })
+        : createNothingToOneRelation({ currentRound: preFinalLowerRound, nextRound: finalLowerRound }));
 };
 const handleFirstRound = (params) => {
     const { relations, currentUpperRound, nextUpperRound, lowerRounds, currentUpperRoundIndex } = params;
@@ -3137,11 +3038,9 @@ const createBracket = (source, options) => {
     const rounds = new BracketMap();
     const roundsByType = new BracketMap();
     for (const roundBase of bracketNewBase.rounds.values()) {
-        const newRound = {
-            ...roundBase,
-            matches: new BracketMap(),
-            relation: { type: 'dummy' },
-        };
+        const relation = { type: 'none' };
+        const newRound = { ...roundBase, matches: new BracketMap(), relation };
+        relation.currentRound = newRound;
         rounds.set(roundBase.id, newRound);
         if (!roundsByType.has(roundBase.type)) {
             roundsByType.set(roundBase.type, new BracketMap());
@@ -3164,14 +3063,16 @@ const createBracket = (source, options) => {
         const awayParticipant = matchBase.away
             ? { ...matchBase.away, matches: new BracketMap() }
             : null;
+        const relation = { type: 'none', currentRound: round };
         const newMatch = {
             ...matchBase,
             home: homeParticipant,
             away: awayParticipant,
             winner: null,
             round,
-            relation: { type: 'dummy' },
+            relation,
         };
+        relation.currentMatch = newMatch;
         if (matchBase.winner) {
             const winnerParticipant = homeParticipant?.id === matchBase.winner.id ? homeParticipant : awayParticipant;
             if (!winnerParticipant)
@@ -3278,26 +3179,30 @@ const resolveSlotOccupant = (options) => {
 const resolveSlot = (options) => {
     const { walk, match, side } = options;
     const visitKey = `${match.id}:${side}`;
-    if (walk.visited.has(visitKey)) {
-        walk.cycleHits++;
+    const openDepth = walk.visitDepths.get(visitKey);
+    if (openDepth !== undefined) {
+        walk.shallowestCycleHit = Math.min(walk.shallowestCycleHit, openDepth);
         return null;
     }
     const resolved = walk.resolved.get(visitKey);
     if (resolved !== undefined)
         return resolved;
-    walk.visited.add(visitKey);
-    const cycleHitsBefore = walk.cycleHits;
+    const depth = walk.visitDepths.size;
+    const shallowestCycleHitBefore = walk.shallowestCycleHit;
+    walk.visitDepths.set(visitKey, depth);
+    walk.shallowestCycleHit = Infinity;
     try {
         const result = resolveSlotOccupant({ walk, match, side });
-        // Only a result the visit guard never interfered with is a function of the slot alone. One that
-        // did hit the guard depends on the path that reached it, so caching it would answer a later path
-        // with a cycle's `null`.
-        if (walk.cycleHits === cycleHitsBefore)
+        // A result whose cycle guard only fired on this slot or below it is a function of the slot alone.
+        // One that hit a slot above it depends on the path that reached it, so caching it would answer a
+        // later path with a cycle's `null`.
+        if (walk.shallowestCycleHit >= depth)
             walk.resolved.set(visitKey, result);
         return result;
     }
     finally {
-        walk.visited.delete(visitKey);
+        walk.visitDepths.delete(visitKey);
+        walk.shallowestCycleHit = Math.min(walk.shallowestCycleHit, shallowestCycleHitBefore);
     }
 };
 const createResolveWalk = (options) => ({
@@ -3305,15 +3210,23 @@ const createResolveWalk = (options) => ({
     picks: options.picks,
     realParticipantOutranksPick: options.realParticipantOutranksPick ?? (() => false),
     keepPickWhileFeederSideIsOpen: options.keepPickWhileFeederSideIsOpen ?? false,
-    visited: new Set(),
+    visitDepths: new Map(),
     resolved: new Map(),
-    cycleHits: 0,
+    shallowestCycleHit: Infinity,
 });
-/** Who the viewer's own picks put in a slot, or `null` while their picks do not reach it. */
-const resolveBracketSlot = (options) => {
-    const match = options.bracket.matches.get(options.matchId);
-    return match ? resolveSlot({ walk: createResolveWalk(options), match, side: options.side }) : null;
+/**
+ * @internal A {@link resolveBracketSlot} that shares one memo across its calls. Valid only while the
+ * picks it was created with do not change.
+ */
+const createBracketSlotResolver = (options) => {
+    const walk = createResolveWalk(options);
+    return (matchId, side) => {
+        const match = options.bracket.matches.get(matchId);
+        return match ? resolveSlot({ walk, match, side }) : null;
+    };
 };
+/** Who the viewer's own picks put in a slot, or `null` while their picks do not reach it. */
+const resolveBracketSlot = (options) => createBracketSlotResolver(options)(options.matchId, options.side);
 
 // Grouped by type and depth rather than by round id: a mirrored layout splits one round into two
 // half-rounds to draw either side of the fold, and a pick has to be able to travel across it. Ordered
@@ -3378,16 +3291,14 @@ const migrateBracketPicks = (options) => {
         const travelling = [];
         const strandedHere = new Set();
         const sidesOf = (matchId) => sidesByMatchId.get(matchId) ?? [null, null];
+        const resolve = createBracketSlotResolver({
+            bracket,
+            picks: settled,
+            realParticipantOutranksPick: options.realParticipantOutranksPick,
+            keepPickWhileFeederSideIsOpen: options.keepPickWhileFeederSideIsOpen,
+        });
         for (const match of round) {
-            const resolve = (side) => resolveBracketSlot({
-                bracket,
-                picks: settled,
-                matchId: match.id,
-                side,
-                realParticipantOutranksPick: options.realParticipantOutranksPick,
-                keepPickWhileFeederSideIsOpen: options.keepPickWhileFeederSideIsOpen,
-            });
-            sidesByMatchId.set(match.id, [resolve('home'), resolve('away')]);
+            sidesByMatchId.set(match.id, [resolve(match.id, 'home'), resolve(match.id, 'away')]);
         }
         for (const match of round) {
             const pick = pickAsMade(match.id);
@@ -3522,7 +3433,7 @@ const createSwissGrid = (bracketData, options, components) => {
                     partHeights: [options.roundHeaderGap],
                     elementHeight: options.roundHeaderGap,
                 });
-                headerSubColumn.pushElement(headerElement.element, headerGapElement.element);
+                headerSubColumn.pushElement(headerElement, headerGapElement);
                 headerColumnSection.pushSubColumn(headerSubColumn.subColumn);
                 pushSection(headerColumnSection.masterColumnSection);
             }
@@ -3564,7 +3475,7 @@ const createSwissGrid = (bracketData, options, components) => {
                 }
             }
             for (const elementData of elementsToCreate) {
-                const { element } = createBracketElement(elementData);
+                const element = createBracketElement(elementData);
                 pushElement(element);
             }
             pushSubColumn(subColumn);
@@ -3585,7 +3496,7 @@ const createSwissGrid = (bracketData, options, components) => {
                     elementHeight: rowRoundGap,
                     partHeights: [rowRoundGap],
                 });
-                groupGapSubColumn.pushElement(groupGapElement.element);
+                groupGapSubColumn.pushElement(groupGapElement);
                 groupGapColumnSection.pushSubColumn(groupGapSubColumn.subColumn);
                 pushSection(groupGapColumnSection.masterColumnSection);
             }
@@ -3609,7 +3520,7 @@ const createSwissGrid = (bracketData, options, components) => {
                 elementHeight: fillerHeight,
                 partHeights: [fillerHeight],
             });
-            fillerSubColumn.pushElement(fillerElement.element);
+            fillerSubColumn.pushElement(fillerElement);
             fillerColumnSection.pushSubColumn(fillerSubColumn.subColumn);
             pushSection(fillerColumnSection.masterColumnSection);
         }
@@ -3684,7 +3595,7 @@ const standingPickOutcome = (options) => {
  * The order to show a group table in before anyone moves a row: every stored pick takes the position it was
  * stored on, and the participants without one follow in the order the backend listed them, filling the gaps.
  *
- * A pick the field cannot hold is dropped rather than drawn - a position outside
+ * A pick the field cannot hold is dropped rather than drawn - a position that is not an integer in
  * `1..participantIds.length`, an id that is not in the field, a second pick for a position or for a
  * participant already placed (the lowest position keeps it). The result is therefore always a permutation
  * of `participantIds`.
@@ -3695,7 +3606,8 @@ const standingPickStartOrder = (options) => {
     const byPosition = new Map();
     const placed = new Set();
     for (const pick of [...picks].sort((left, right) => left.position - right.position)) {
-        const holds = pick.position >= 1 &&
+        const holds = Number.isInteger(pick.position) &&
+            pick.position >= 1 &&
             pick.position <= participantIds.length &&
             field.has(pick.participantId) &&
             !placed.has(pick.participantId) &&
@@ -3719,5 +3631,5 @@ const standingPickStartOrder = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BRACKET_DATA_LAYOUT, BRACKET_ERROR_CODES, BRACKET_ROUND_MIRROR_TYPE, BRACKET_SWISS_GROUP_COLOR_TYPE, BracketMap, COMMON_BRACKET_ROUND_TYPE, DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE, GROUP_BRACKET_ROUND_TYPE, SINGLE_ELIMINATION_BRACKET_ROUND_TYPE, STANDING_PICK_OUTCOME, SWISS_ADVANCE_WINS, SWISS_BRACKET_ROUND_TYPE, SWISS_ELIMINATE_LOSSES, TOURNAMENT_MODE, bracketGridNaturalWidth, calculateColumnSplitFactor, calculateLowerRoundIndex, calculateUpperLowerRatio, calculateUpperRoundIndex, createBracket, createBracketBase, createBracketContinueMasterColumn, createBracketElement, createBracketElementPart, createBracketGapMasterColumn, createBracketGrid, createBracketMasterColumn, createBracketMasterColumnSection, createBracketSubColumn, createDoubleEliminationGrid, createFoldedThirdPlaceSection, createMatchesMapBase, createNewMatchParticipantBase, createParticipantsMapBase, createRoundBracketSubColumnRelativeToFirstRound, createRoundsMapBase, createSingleEliminationGrid, createStackedDoubleEliminationGrid, createSwissGrid, curvePath, drawMan, drawSwissMan, finalizeBracketGrid, generateBracketRoundSwissGroupMaps, generateMatchPosition, generateMatchRelationPositions, generateMatchRelationsNew, generateRoundRelationsNew, getAvailableSwissGroupsForRound, getBracketContinueMatches, getSwissGroupColorType, gutterPath, isBracketContinueMatch, isBracketSlotPredictable, linePath, migrateBracketPicks, path, resolveBracketGridRowSpan, resolveBracketLayout, resolveBracketSlot, standingPickOutcome, standingPickStartOrder, verticalPath };
+export { BRACKET_DATA_LAYOUT, BRACKET_ERROR_CODES, BRACKET_ROUND_MIRROR_TYPE, BRACKET_SWISS_GROUP_COLOR_TYPE, BracketMap, COMMON_BRACKET_ROUND_TYPE, DOUBLE_ELIMINATION_BRACKET_ROUND_TYPE, GROUP_BRACKET_ROUND_TYPE, SINGLE_ELIMINATION_BRACKET_ROUND_TYPE, STANDING_PICK_OUTCOME, SWISS_ADVANCE_WINS, SWISS_BRACKET_ROUND_TYPE, SWISS_ELIMINATE_LOSSES, TERMINAL_ROUND_SORT_PRIORITY, TOURNAMENT_MODE, bracketGridNaturalWidth, calculateColumnSplitFactor, calculateLowerRoundIndex, calculateUpperLowerRatio, calculateUpperRoundIndex, createBracket, createBracketBase, createBracketContinueMasterColumn, createBracketElement, createBracketElementPart, createBracketGapMasterColumn, createBracketGrid, createBracketMasterColumn, createBracketMasterColumnSection, createBracketSlotResolver, createBracketSubColumn, createDoubleEliminationGrid, createFoldedThirdPlaceSection, createMatchesMapBase, createNewMatchParticipantBase, createParticipantsMapBase, createRoundBracketSubColumnRelativeToFirstRound, createRoundsMapBase, createSingleEliminationGrid, createStackedDoubleEliminationGrid, createSwissGrid, curvePath, drawMan, drawSwissMan, finalizeBracketGrid, generateBracketRoundSwissGroupMaps, generateMatchPosition, generateMatchRelationPositions, generateMatchRelationsNew, generateRoundRelationsNew, getAvailableSwissGroupsForRound, getBracketContinueMatches, getSwissGroupColorType, gutterPath, isBracketContinueMatch, isBracketSlotPredictable, linePath, migrateBracketPicks, path, resolveBracketGridRowSpan, resolveBracketLayout, resolveBracketSlot, standingPickOutcome, standingPickStartOrder, verticalPath };
 //# sourceMappingURL=ethlete-bracket.mjs.map