courthive-components 6.2.1 → 6.3.0

package/dist/components/matchUpFormat/matchUpFormat.d.ts

@@ -54,9 +54,11 @@ interface MatchUpFormatConfig {
         text: string;
     }>;
 }
-export declare function getMatchUpFormatModal({ existingMatchUpFormat, callback, config, modalConfig }?: {
+export declare function getMatchUpFormatModal({ existingMatchUpFormat, callback, onClose, config, modalConfig }?: {
     existingMatchUpFormat?: string;
     callback?: (format: string) => void;
+    /** Called however the modal closes — Select, Cancel, or anything else that closes it. */
+    onClose?: () => void;
     config?: MatchUpFormatConfig;
     modalConfig?: any;
 }): {

package/dist/components/scoring/logic/dynamicSetsLogic.d.ts

@@ -69,10 +69,25 @@ export declare function isSetTiebreakOnly(format?: SetFormat): boolean;
  */
 export declare function isSetTimed(format?: SetFormat): boolean;
 /**
- * Calculate the maximum allowed score for a regular set game score
- * based on the opponent's score and set rules
+ * The highest game (or tiebreak-point) score one side may enter, given the opponent's.
  *
- * For timed sets, returns Infinity (no maximum) since scores don't need relationships
+ * ── Delegated to the factory ──
+ *
+ * `scoreGovernor.getMaxSetScore` answers for a games set from the format alone: the tiebreak games,
+ * `tiebreakAt` above or below `setTo`, a declared `winBy`. It answers `undefined` where the format has no
+ * ceiling — a timed set, an advantage set past the tiebreak-less `setTo`, or a tiebreak-only set, whose
+ * points are not games — and each of those is handled here by the factory's own tiebreak complement or
+ * by the set's margin, not by recomputing tennis.
+ *
+ * The hand-rolled body this replaced read a tiebreak-only set as a six-game set: `SET1-S:TB10` with no
+ * opponent score was capped at **7** — a match tiebreak to ten that could not be entered (measured
+ * 2026-10-08, live in the shipping dialog). It now caps at the complement of the opponent's points: 10,
+ * then 12 against 10, and `NoAD` ends it at the target.
+ *
+ * One convention of the calling dialog is kept: an opponent score of 0 means "not entered yet" and allows
+ * the format's ceiling. Where the opponent's games already hold the set, the answer is the factory's
+ * ceiling (CA, 2026-10-08: "follow the factory") — 7 under `S:6/TB7`, 5 under `S:5/TB9@4` — and the old
+ * "extended play" read of 9, a tiebreak set running on like an advantage set, is gone.
  */
 export declare function getMaxAllowedScore(setIndex: number, side: 1 | 2, currentScores: {
     side1: number;

package/dist/components/scoring/logic/engineOutcome.d.ts

@@ -0,0 +1,28 @@
+import { SetScore } from '../types';
+/** What the card reports on Submit, with the sets the dialog adds. */
+export type ReportedOutcome = {
+    matchUpStatus?: string;
+    winningSide?: number;
+    reasonCode?: string;
+    score?: string;
+    cleared?: boolean;
+    sets?: SetScore[];
+};
+/** The outcome in the shape `tournamentEngine.setMatchUpStatus({ drawId, matchUpId, outcome })` reads. */
+export type EngineOutcome = {
+    matchUpStatus?: string;
+    winningSide?: number;
+    matchUpFormat?: string;
+    matchUpStatusCodes?: string[];
+    score: {
+        sets: SetScore[];
+    };
+};
+export declare function toEngineOutcome(outcome: ReportedOutcome, matchUpFormat?: string): EngineOutcome;
+/**
+ * The positional array the engine reads a reason from.
+ *
+ * A single exit: the side that did NOT win, at its index. A double exit: both. An ending that resolves
+ * nobody: index 0, since there is no side — the engine files that one as `matchUpStatusCode`.
+ */
+export declare function positionalCodes({ reasonCode, matchUpStatus, winningSide }: ReportedOutcome): string[] | undefined;

package/dist/components/scoring/scoreEntryCard.d.ts

@@ -156,10 +156,14 @@ export type ScoreEntryCardParams = {
     initialState?: ScoreEntryState;
     onClear?: () => void;
     onSubmit?: (outcome: ScoreEntryOutcome) => void;
-    onClose?: () => void;
 };
 export type ScoreEntryCard = {
     element: HTMLElement;
+    /**
+     * Close an open menu (the approach switcher's or Other's) and report whether one was open. The dialog's
+     * Escape calls it first, wherever focus is, so one Escape closes the menu and a second one cancels.
+     */
+    closeMenus: () => boolean;
     /** Re-render the band and the submit gate. Call when the score region's value changes. */
     refresh: () => void;
     /** Rebuild everything, including the region's cells. Call when the region's COLUMNS change. */

package/dist/components/scoring/scoreEntryDialog.d.ts

@@ -1,16 +1,24 @@
+import { EngineOutcome } from './logic/engineOutcome';
 import { SetScore } from './types';
 import { ScoreEntryCard, ScoreEntryCardParams, ScoreEntryOutcome } from './scoreEntryCard';
 /** The three entry approaches. The key is what `onSelectApproach` reports and what a host persists. */
 export type ScoreEntryApproach = 'dynamicSets' | 'freeScore' | 'dialPad';
-export type ScoreEntryDialogParams = Omit<ScoreEntryCardParams, 'region' | 'approachLabel' | 'approaches' | 'onSelectApproach' | 'onSwitchApproach' | 'onEditFormat' | 'onClose' | 'onSubmit'> & {
+export type ScoreEntryDialogParams = Omit<ScoreEntryCardParams, 'region' | 'approachLabel' | 'approaches' | 'onSelectApproach' | 'onSwitchApproach' | 'onEditFormat' | 'onSubmit'> & {
     /**
      * Called with the outcome, then the dialog closes.
      *
      * `sets` is added to what the card reports, because the dialog knows its regions carry them and a
      * host saving to the factory needs the structured sets rather than only the formatted string.
+     *
+     * `outcome` is the same result in the shape the factory reads — hand it to
+     * `tournamentEngine.setMatchUpStatus({ drawId, matchUpId, outcome })` as is (pass a copy if you keep
+     * what you sent: the engine writes its derived score strings into it). The score as `score.sets`, a
+     * chosen reason as positional `matchUpStatusCodes`, a clear as the empty-sets outcome that actually
+     * clears, and a format changed through the chip as `matchUpFormat`. See `logic/engineOutcome.ts`.
      */
     onSubmit?: (outcome: ScoreEntryOutcome & {
         sets: SetScore[];
+        outcome: EngineOutcome;
     }) => void;
     /** Which approach opens. Defaults to Dynamic Sets. */
     approach?: ScoreEntryApproach;
@@ -77,6 +85,8 @@ export type ScoreEntryDialogParams = Omit<ScoreEntryCardParams, 'region' | 'appr
     openFormatPicker?: (params: {
         existingMatchUpFormat: string;
         callback: (matchUpFormat: string) => void;
+        /** Called however the picker closes; the dialog is inert until then. */
+        onClose?: () => void;
     }) => void;
 };
 export type ScoreEntryDialog = {

package/dist/components/topology-builder/types.d.ts

@@ -6,6 +6,8 @@ export interface TopologyNode {
     structureType: string;
     drawSize: number;
     qualifyingPositions?: number;
+    /** QUALIFYING nodes: seeds to place in the structure (0 = unseeded). */
+    seedsCount?: number;
     matchUpFormat?: string;
     structureOptions?: any;
     position: {