courthive-components 6.0.1 → 6.1.0

package/dist/components/schedule-page/domain/utils.d.ts

@@ -1,5 +1,25 @@
-import { CatalogMatchUpItem, MatchUpSide } from '../types';
+import { CatalogMatchUpItem, MatchUpSide, ScheduleCellSide } from '../types';
 export declare function deepClone<T>(obj: T): T;
 export declare function matchUpLabel(item: CatalogMatchUpItem): string;
 export declare function participantLabel(side?: MatchUpSide): string;
+/**
+ * Everything a catalog item can be found by, as one lower-cased line.
+ *
+ * `sides[].participantName` alone left doubles players unfindable by their own
+ * name: the factory composes a PAIR's `participantName` from family names only
+ * (`Phoebus/Smith`), so a search for "Aiden Phoebus" matched his singles matchUps
+ * and silently skipped every doubles matchUp he was in. `individualParticipants`
+ * carries the given+family names that the pair name drops, so both are pushed.
+ */
+/**
+ * "Aiden Phoebus / Ravi Smith" — a doubles side's members, spelled out in full.
+ *
+ * Empty for a singles side and for an un-hydrated pair, which is the caller's cue to
+ * set no tooltip at all rather than an empty one.
+ *
+ * Pure and here rather than inline in the renderer so it can be tested without a DOM:
+ * the ecosystem's DOM layer is Playwright/Storybook, and `test-storybook` cannot
+ * currently run in this repo (612/612 suites fail in the runner, measured 2026-09-27).
+ */
+export declare function memberNamesLabel(side?: MatchUpSide | ScheduleCellSide): string;
 export declare function matchUpSearchKey(item: CatalogMatchUpItem): string;

package/dist/components/schedule-page/index.d.ts

@@ -9,7 +9,7 @@ export { SchedulePageControl } from './controller/schedulePageControl';
 export { SchedulePageStore } from './engine/schedulePageStore';
 export { filterMatchUpCatalog, groupMatchUpCatalog, computeBaseRoundByEvent, isCompletedStatus } from './domain/matchUpCatalogProjections';
 export { buildScheduleIssueIndex } from './domain/scheduleIssues';
-export { matchUpLabel, participantLabel, matchUpSearchKey, deepClone } from './domain/utils';
+export { matchUpLabel, participantLabel, matchUpSearchKey, memberNamesLabel, deepClone } from './domain/utils';
 export { computeActiveStrip, computeActiveStripCell, computeActiveStripDropTarget, computeReschedulePlacements } from './domain/activeStrip';
 export type { ActiveStripCell, ActiveStripCellState, ActiveStripCourtColumn, ActiveStripDropCandidate, ActiveStripDropTarget, ActiveStripGrid, ActiveStripGridMatchUp, ActiveStripStatusOptions, RescheduleCandidate, ReschedulePlacement } from './domain/activeStrip';
 export { buildScheduleDateStrip } from './ui/dateStrip';

package/dist/components/schedule-page/types.d.ts

@@ -9,6 +9,19 @@ export interface MatchUpSide {
     participantId?: string;
     seedNumber?: number;
     ranking?: number;
+    /**
+     * Hydrated members of a pair or team, present on `inContext` matchUps.
+     *
+     * Load-bearing for search, not for layout. A PAIR participant's own
+     * `participantName` is composed by the factory from FAMILY NAMES ALONE
+     * (`Phoebus/Smith`), so a doubles side carries no given name anywhere — and a
+     * consumer searching for "Aiden Phoebus" could not match the one cell he is
+     * actually in. These are the names that make him findable.
+     */
+    individualParticipants?: {
+        participantId?: string;
+        participantName?: string;
+    }[];
 }
 export interface CatalogMatchUpItem {
     matchUpId: string;
@@ -238,6 +251,19 @@ export interface ScheduleCellSide {
     teamName?: string;
     /** True if this side is a BYE (no participant) */
     bye?: boolean;
+    /**
+     * Hydrated members of a pair or team, present on `inContext` matchUps.
+     *
+     * Load-bearing for search, not for layout. A PAIR participant's own
+     * `participantName` is composed by the factory from FAMILY NAMES ALONE
+     * (`Phoebus/Smith`), so a doubles side carries no given name anywhere — and a
+     * consumer searching for "Aiden Phoebus" could not match the one cell he is
+     * actually in. These are the names that make him findable.
+     */
+    individualParticipants?: {
+        participantId?: string;
+        participantName?: string;
+    }[];
 }
 /**
  * Flat data shape the cell renderer consumes — mapped from factory matchUp objects.

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

@@ -41,6 +41,21 @@ export type SmartComplementResult = {
  * Get the format for a specific set index
  * Uses finalSetFormat for deciding set if available
  */
+/**
+ * The `MatchUpConfig` for a TODS matchUpFormat string.
+ *
+ * Hoisted because it takes TWO sources to assemble and `dynamicSetsApproach` already had its own copy
+ * (`getMatchUpConfig`, line ~134): `bestOf` comes from `parseMatchUpFormat`, which resolves an
+ * `exactly:N` format down to a set count, while `exactly`, `setFormat` and `finalSetFormat` come
+ * straight off `matchUpFormatCode.parse`. A region building its own would be a second copy of a
+ * derivation whose two halves must agree, which is the shape every other divergence in this module
+ * family started as.
+ *
+ * Never parse a matchUpFormat with a regex — the factory owns that grammar, and an unparseable format
+ * falls back to SET3 rather than throwing, because a dialog that will not open is worse than one that
+ * opens on the wrong best-of.
+ */
+export declare function matchUpConfigFor(matchUpFormat?: string): MatchUpConfig;
 export declare function getSetFormatForIndex(setIndex: number, config: MatchUpConfig): SetFormat | undefined;
 /**
  * Check if a set is tiebreak-only (e.g., TB10)

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

@@ -24,27 +24,64 @@
 export declare const NEITHER_SIDE = "NEITHER";
 /** Shown when an irregular ending has been chosen but the winner question is unanswered. */
 export declare const WINNER_REQUIRED_ERROR = "Select a winner";
-/** The statuses whose selection opens the winner question at all. */
+/**
+ * Every irregular ending a set-entry approach offers, in display order.
+ *
+ * ── Why ten, when this list held six ──
+ *
+ * It held six because those are exactly the keys the factory's scoring policy can refine with
+ * `matchUpStatusCodes`, the reasoning being that a status with no code group cannot carry a reason.
+ * That is true but it was the wrong list to derive a VOCABULARY from, and the cost was measurable:
+ * `freeScoreApproach` has always parsed ten, so four statuses were typeable in one approach and
+ * unreachable in the other three. Rotating between approaches could therefore show an ending that
+ * could not be re-selected. The four additions (SUSPENDED, IN_PROGRESS, AWAITING_RESULT,
+ * DEAD_RUBBER) simply carry no reason, which is the designed quiet state, not a defect.
+ *
+ * Two things checked while widening, recorded because neither is visible from here:
+ *
+ * - `WITHDRAWN` is NOT a factory matchUpStatus (`matchUpStatusConstants.WITHDRAWN` will not even
+ *   compile), yet the USTA policy keys a seventh `matchUpStatusCodes` group with it, from
+ *   `entryStatusConstants`. This comment previously called that "a code group no status can reach"
+ *   and a factory problem. Both halves were wrong, and this is settled, twice over:
+ *
+ *   CA, 2026-09-27: "WITHDRAWN is a statusCode on a WALKOVER... WALKOVER (withdrawn injured or
+ *   withdrawn ill)" — a withdrawal is expressed AS a walkover, and the WALKOVER group already ships
+ *   that expression as `W5` / "Wo/Withdrawn". CA, 2026-09-19: the WALKOVER group records "a match
+ *   that did not happen because someone withdrew", a RESULT; the WITHDRAWN group records "the
+ *   withdrawal itself", an ENTRY action belonging to the entries UI. Same reasons, two events, two
+ *   surfaces — which is why the groups are label-for-label parallel and must NOT be merged.
+ *   `statusCodes.test.ts` holds that, including the measurement that refutes merging them.
+ * - The ten partition PERFECTLY onto the factory's own classification: three directing, seven
+ *   non-directing, with nothing in both and nothing in neither. The `endingPartition` test asserts
+ *   this rather than trusting it.
+ *
+ * Ordered so the three that name a winner come first, then the three an operator reaches for most
+ * often mid-tournament, then the remainder.
+ */
+export declare const SELECTABLE_ENDINGS: string[];
+/**
+ * The statuses whose selection opens the winner question at all.
+ *
+ * DERIVED from the factory's `directingMatchUpStatuses` rather than hand-listed, because "does a
+ * winner advance out of this status" is the factory's question to answer and it already answers it.
+ * Hand-adding a status to two sets is precisely where a mistake hides, and the eleventh ending
+ * should classify itself rather than wait for someone to remember both places.
+ */
 export declare const WINNER_REQUIRING_STATUSES: Set<string>;
 /**
  * Endings that resolve nobody: the match did not produce a result, so there is no winner to name
- * and no winner question to answer. The factory classifies these as non-directing
- * (`nonDirectingMatchUpStatuses`) — nothing advances out of them.
+ * and no winner question to answer. Nothing advances out of them.
  *
  * These are NOT a smaller version of the winner-requiring endings. Asking "who won an abandoned
  * match" is not a question with a missing answer; it is not a question. So unlike a walkover with
  * no winner selection, one of these is valid the moment it is chosen.
- */
-export declare const NON_DIRECTING_ENDINGS: Set<string>;
-/**
- * Every irregular ending a set-entry approach offers, in display order.
  *
- * These six are exactly the keys the factory's scoring policy can refine with `matchUpStatusCodes`
- * (ABANDONED, CANCELLED, DEFAULTED, INCOMPLETE, RETIRED, WALKOVER), which is why the list is this
- * list: a status with no code group cannot carry a reason, and a code group with no status cannot
- * be reached. Ordered so the three an operator reaches for most sit first.
+ * Also derived, and the complement of `WINNER_REQUIRING_STATUSES` over `SELECTABLE_ENDINGS` — but
+ * computed independently from `nonDirectingMatchUpStatuses` rather than as `!winnerRequiring`, so
+ * that a status the factory somehow classifies as NEITHER shows up as a test failure instead of
+ * being silently swept in here.
  */
-export declare const SELECTABLE_ENDINGS: string[];
+export declare const NON_DIRECTING_ENDINGS: Set<string>;
 /** Whether choosing this ending obliges the operator to answer the winner question. */
 export declare function requiresWinner(selectedOutcome: string | undefined): boolean;
 /**
@@ -57,12 +94,52 @@ export declare function requiresWinner(selectedOutcome: string | undefined): boo
  * score is real. The same goes for `RETIRED` — a retirement keeps whatever was played, and needs no
  * completed set to be a valid result.
  *
- * `CANCELLED` and `DEAD_RUBBER` are deliberately NOT here even though this repo's `validateScore`
- * strips scores for them. They are unreachable from the set-entry approaches today (only freeScore
- * parses them) and the factory does not blank scores for them, so adding them here would be a
- * guess. Revisit when the status list widens — see Mentat SCORING_MODAL_STATUS_CODES.md M2.
+ * ── CANCELLED and DEAD_RUBBER are here now, and that is a CLIENT policy ──
+ *
+ * They were held out on the stated grounds that they were "unreachable from the set-entry approaches
+ * (only freeScore parses them)", with a note to revisit when the vocabulary widened. Two corrections
+ * to that, found on widening it:
+ *
+ * 1. CANCELLED was never unreachable — it has been in `SELECTABLE_ENDINGS` all along and renders as
+ *    a radio in both Dynamic Sets and Dial Pad. Only DEAD_RUBBER was genuinely out of reach.
+ * 2. The rule was not absent, it was TRIPLICATED, and the three copies disagreed:
+ *
+ *        NO_SCORE_STATUSES          WALKOVER  DOUBLE_WALKOVER
+ *        validateScore              WALKOVER  CANCELLED  DEAD_RUBBER
+ *        freeScore display          WALKOVER  CANCELLED  DEAD_RUBBER
+ *
+ *    No copy held all four, and the two that agreed with each other both omitted DOUBLE_WALKOVER.
+ *    This set is now the single one, and CA settled its contents (2026-09-27): selecting Cancelled
+ *    or Dead Rubber clears any partial score present.
+ *
+ * Note what that means and does not mean. The FACTORY blanks scores for `{WALKOVER,
+ * DOUBLE_WALKOVER}` only (`modifyMatchUpScore.ts:236`, verified) — `removeScore` is its separate
+ * lever for anything else. So nothing server-side enforces the clearing of CANCELLED or DEAD_RUBBER;
+ * the client simply never submits a score for them, which reaches the same place. Do not "correct"
+ * this set toward the factory's: it is deliberately wider, and the widening is the policy.
+ *
+ * Still NOT here, and each for a reason worth keeping: `DEFAULTED` / `DOUBLE_DEFAULT`, because a
+ * player can default part-way through a match that was genuinely played; `RETIRED`, which keeps
+ * whatever was played; and ABANDONED / INCOMPLETE / SUSPENDED, where the partial score is the entire
+ * content of the result — "6-4 3-2, suspended" says when it was suspended.
  */
 export declare const NO_SCORE_STATUSES: Set<string>;
+/**
+ * Endings a typed score legitimately survives alongside.
+ *
+ * The Dial Pad clears the selected ending when a digit is typed — the operator is starting over —
+ * and must not do that for an ending whose whole meaning includes a partial score. It decided this
+ * by asking `NON_DIRECTING_ENDINGS`, which is a DIFFERENT question: "does anyone advance" is not
+ * "is there a score". The two happened to coincide across the old six. They do not across the ten:
+ * DEAD_RUBBER and CANCELLED are non-directing yet carry no score, so the old gate would have
+ * preserved an ending that had just discarded the digits being typed.
+ *
+ * So it is stated as its own predicate over both axes, and the `endingPartition` test pins the case
+ * that made the difference.
+ */
+export declare const SCORE_PRESERVING_ENDINGS: Set<string>;
+/** Whether a typed score should be kept when this ending is selected. */
+export declare function coexistsWithScore(selectedOutcome: string | undefined): boolean;
 /**
  * Whether this ending means "no score exists", so score validation must be skipped rather than run
  * and then overridden.
@@ -139,3 +216,66 @@ export declare function resolveIrregularEnding(params: {
  *   `error: 'At least one set is required'` was the symptom of exactly that missing check.
  */
 export declare function applyIrregularEndingToValidation(validation: any, selectedOutcome: string | undefined, winnerSelection: WinnerSelection): IrregularEndingResolution;
+/**
+ * What the controls should show for a matchUp that already carries a result.
+ *
+ * The documented INVERSE of `resolveIrregularEnding`. That function was hoisted here because three
+ * approaches each carried their own copy of the forward rule and disagreed; the inverse was left
+ * behind in each of them and diverged the same way. Measured before this existed:
+ *
+ *   - `dynamicSetsApproach` restored all six endings and both double exits;
+ *   - `dialPadApproach` restored only RETIRED / WALKOVER / DEFAULTED, so a saved ABANDONED,
+ *     CANCELLED or INCOMPLETE re-opened reading as COMPLETED — and re-submitting silently replaced
+ *     a non-directing status;
+ *   - `freeScoreApproach` used a third mechanism entirely;
+ *   - `inlineScoringApproach` discarded the saved result by construction.
+ *
+ * Round-tripping is the property that matters, and it is the one a test can hold: for every status
+ * in `SELECTABLE_ENDINGS`, `resolveIrregularEnding(hydrateIrregularEnding(m))` must return the
+ * status `m` was saved with.
+ *
+ * ── What each branch means ──
+ *
+ * A **double exit** is stored as its own status and carries no `winningSide`, so it inverts to the
+ * base ending plus an explicit `NEITHER_SIDE` — the tri-state's third value, recovered rather than
+ * guessed. A **non-directing** ending (ABANDONED, CANCELLED, INCOMPLETE) resolves nobody, so its
+ * winner is `undefined` and must stay that way; reading a stray `winningSide` back onto one would
+ * re-introduce the fail-open shape this module exists to prevent. Anything else — COMPLETED,
+ * TO_BE_PLAYED, IN_PROGRESS, a status this vocabulary does not offer, or no matchUp at all —
+ * inverts to COMPLETED with no winner, which is the inert state the controls open in.
+ *
+ * Deliberately NOT inferred: a `winningSide` present on a status that requires one is trusted, but a
+ * MISSING one is returned as `undefined` rather than defaulted. An unanswered winner is the
+ * fail-closed state (`WINNER_REQUIRED_ERROR`), and it must survive a save/reopen cycle as unanswered.
+ */
+export declare function hydrateIrregularEnding(matchUp?: {
+    matchUpStatus?: string;
+    winningSide?: number;
+}): {
+    selectedOutcome: string;
+    winnerSelection: WinnerSelection;
+};
+/**
+ * Display labels for every selectable ending, with locale overrides applied.
+ *
+ * Shared because it was not: Dynamic Sets and Dial Pad each kept their own map covering only the
+ * statuses they offered, and Dynamic Sets read it as `ENDING_LABELS[value]` with NO fallback — so
+ * widening `SELECTABLE_ENDINGS` without this would have rendered four radios labelled `undefined`.
+ * One map means an eleventh ending is either labelled or caught by `everySelectableEndingIsLabelled`.
+ *
+ * The fallback is the raw status rather than a blank, so an unlabelled ending is visibly wrong in the
+ * UI rather than invisibly missing.
+ */
+export type EndingLabelOverrides = {
+    retired?: string;
+    walkover?: string;
+    defaulted?: string;
+    inProgress?: string;
+    awaitingResult?: string;
+    suspended?: string;
+    abandoned?: string;
+    cancelled?: string;
+    incomplete?: string;
+    deadRubber?: string;
+};
+export declare function endingLabels(labels?: EndingLabelOverrides): Record<string, string>;

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

@@ -0,0 +1,25 @@
+import { ScoreOutcome } from '../types';
+/** The fields a projection may replace. Everything else on the matchUp is carried through as-is. */
+type ProjectableMatchUp = {
+    score?: any;
+    matchUpStatus?: string;
+    winningSide?: number;
+    [key: string]: any;
+};
+/**
+ * The matchUp the next approach should hydrate from.
+ *
+ * Returns the original when there is nothing in progress to carry — the ordinary case on first open,
+ * where the saved matchUp IS the truth.
+ *
+ * ── `winningSide` takes no fallback, and that is the whole care of this function ──
+ *
+ * It is read from the outcome and never from the saved matchUp. If the operator has cleared the
+ * score, the outcome carries no winner, and falling back to the stored one would put back a winner
+ * they had just removed — an unanswered question read as a particular answer, which is the fail-open
+ * shape (Mentat architectural standard A3) that `irregularEnding.ts` exists to prevent, one field
+ * over. `score` and `matchUpStatus` DO fall back, because an outcome that asserts neither is not
+ * claiming the match has no score or no status; it is simply not speaking about them.
+ */
+export declare function projectOutcomeOntoMatchUp<T extends ProjectableMatchUp>(matchUp: T, outcome?: ScoreOutcome | null): T;
+export {};

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

@@ -0,0 +1,130 @@
+import { IrregularEndingResolution } from './irregularEnding';
+/** Which side a per-side ending was recorded against. */
+export type SideNumber = 1 | 2;
+/**
+ * Everything the card holds that is not the score itself.
+ *
+ * The score lives in the score region (per-set inputs, a text field, or a keypad) and is passed in
+ * when resolving, because all three regions already own it and the card must not become a second
+ * place it can be edited.
+ */
+export type ScoreEntryState = {
+    /**
+     * The side that ended early, and how. `sideNumber` is the side the ending HAPPENED TO — the one
+     * that retired or failed to appear — not the winner. The winner is derived from it.
+     */
+    sideEnding?: {
+        sideNumber: SideNumber;
+        status: string;
+    };
+    /**
+     * "…did not appear either — no one advances." The checkbox on the affected row that turns a side
+     * ending into a double exit.
+     *
+     * A separate flag rather than a third value on `sideEnding`, because it is a different assertion:
+     * the operator has said something about the OTHER side. Collapsing them is how the old tri-state
+     * came to treat "unanswered" and "neither" as the same thing.
+     */
+    bothSidesOut?: boolean;
+    /** The match-level ending. One of the seven; mutually exclusive with `sideEnding`. */
+    matchEnding?: string;
+    /** The policy reason code chosen for whichever ending is selected. */
+    reasonCode?: string;
+};
+/** What the card resolves to, plus the two things the UI needs that a resolution alone does not say. */
+export type ScoreEntryResolution = IrregularEndingResolution & {
+    /** True when the selected ending means a typed score must be discarded rather than submitted. */
+    clearsScore: boolean;
+    /** True when an ending is selected at all, so the score region can render itself inert. */
+    hasEnding: boolean;
+};
+/** The empty card: no ending chosen, which is a reachable state and not a null one. */
+export declare const emptyScoreEntryState: ScoreEntryState;
+/**
+ * Record (or un-record) a per-side ending.
+ *
+ * Every control in the card is a TOGGLE, so choosing the ending already selected on that same side
+ * clears it. This is what gives the card a reachable empty state; a radio group has none, which is
+ * GOV.UK's standing objection to pre-selected radios — a user cannot get back to "nothing chosen"
+ * without reloading the page.
+ *
+ * Choosing a side ending clears any match-level ending, and vice versa. They answer the same
+ * question — how did this match end — so allowing both would let the card hold two answers and
+ * submit whichever the resolver happened to read first.
+ *
+ * `bothSidesOut` and `reasonCode` are dropped on any change of ending, because both are qualifiers
+ * OF an ending: a reason code chosen for a retirement is not a reason for a walkover, and the codes
+ * come from different policy groups. Carrying either across would submit a qualifier the operator
+ * never chose for the ending it ends up attached to.
+ */
+export declare function chooseSideEnding(state: ScoreEntryState, sideNumber: SideNumber, status: string): ScoreEntryState;
+/**
+ * Record (or un-record) a match-level ending. A toggle, on the same reasoning as above.
+ */
+export declare function chooseMatchEnding(state: ScoreEntryState, status: string): ScoreEntryState;
+/**
+ * Toggle "the other side did not appear either".
+ *
+ * Refused when there is no side ending to qualify, and refused when the ending has no double form:
+ * RETIRED is the case — the factory has no double-retirement status, and two players who both fail
+ * to finish are a double default or a double walkover depending on why, which is the operator's
+ * distinction to make and not one this module can infer. Returning the state unchanged rather than
+ * setting a flag that cannot resolve keeps the card from offering a checkbox whose answer is dropped.
+ */
+export declare function toggleBothSidesOut(state: ScoreEntryState): ScoreEntryState;
+/** Whether the card should offer the "did not appear either" checkbox at all. */
+export declare function offersBothSidesOut(state: ScoreEntryState): boolean;
+/** Choose (or clear) a reason code for the selected ending. A toggle, like everything else. */
+export declare function chooseReasonCode(state: ScoreEntryState, code: string | undefined): ScoreEntryState;
+/**
+ * The status whose policy code group the reason chips should come from.
+ *
+ * `undefined` when no ending is selected, because there is nothing to give a reason for.
+ */
+export declare function reasonCodeStatus(state: ScoreEntryState): string | undefined;
+/**
+ * Resolve the card into a submittable outcome.
+ *
+ * ── The one piece of derivation that lives here ──
+ *
+ * A per-side ending is recorded against the side it HAPPENED TO, and the winner is the other side.
+ * That inversion is the whole reason the separate winner question can be deleted, so it is stated
+ * once, here, and asserted on its own:
+ *
+ *     sideEnding.sideNumber === 1  →  winnerSelection 2
+ *
+ * Everything past that point is `resolveIrregularEnding`'s answer, unmodified — including the
+ * fail-closed states. Note in particular that a side ending with `bothSidesOut` on an ending with no
+ * double form cannot occur, because `toggleBothSidesOut` refuses to set it; if it somehow does, the
+ * resolver's own guard returns `isValid: false` rather than inventing a status.
+ */
+export declare function resolveScoreEntry(state: ScoreEntryState): ScoreEntryResolution;
+/**
+ * A resolution for an ending the SCORE REGION reported rather than the operator selected.
+ *
+ * Free Score parses endings out of typed text — "6-4 ret" is a retirement — and that must keep
+ * working, because typing the whole result is the entire reason that approach exists. But the card now
+ * owns endings through its own controls, so two sources can speak at once and the precedence has to be
+ * stated rather than emergent:
+ *
+ *   **An explicitly selected ending always wins.** A region-reported one is used only when the
+ *   operator has selected nothing.
+ *
+ * That direction and not the other, because a click is an unambiguous instruction and parsed text is
+ * an inference. An operator who types "ret", then clicks Suspended, means Suspended; clearing the
+ * click falls back to what they typed, which is still on screen in front of them.
+ *
+ * Resolution goes through `resolveIrregularEnding` like everything else, so a parsed ending and a
+ * clicked one cannot disagree about what they mean — only about which one applies.
+ */
+export declare function resolveReportedEnding(matchUpStatus?: string, winningSide?: number): ScoreEntryResolution;
+/**
+ * Which endings the card offers on a player row, and which in the match-level group.
+ *
+ * Derived from the same two sets the approaches use, in `SELECTABLE_ENDINGS` order, so the card
+ * cannot offer an ending the vocabulary does not hold or drop one it does. The split is not a layout
+ * choice: it is `WINNER_REQUIRING_STATUSES` and `NON_DIRECTING_ENDINGS`, which come from the
+ * factory's `directingMatchUpStatuses` / `nonDirectingMatchUpStatuses`.
+ */
+export declare function sideEndingOptions(): string[];
+export declare function matchEndingOptions(): string[];

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

@@ -0,0 +1,28 @@
+import { ScoreEntryResolution } from './scoreEntryState';
+export type ResultTone = 'good' | 'warn' | 'neutral';
+export type ResultBand = {
+    tone: ResultTone;
+    /** The main sentence. Always present — a band with no headline would be a band with no purpose. */
+    headline: string;
+    /** The quieter right-hand note: what happens next, or what was recorded. */
+    detail?: string;
+};
+export type SummaryParams = {
+    resolution: ScoreEntryResolution;
+    /** Side 1's name first. */
+    sideNames: [string, string];
+    /** The score as it currently stands, already formatted (e.g. `'6-4 2-1'`). */
+    scoreString?: string;
+    /** Whether that score is a finished result — the score region's judgement, not this module's. */
+    scoreComplete?: boolean;
+    /** The winner a complete score implies, when no ending overrides it. */
+    scoreWinningSide?: 1 | 2;
+    /** Display labels for endings, so a locale can supply them. Defaults to English. */
+    labels?: Record<string, string>;
+    /** The chosen reason code's display form, e.g. `'Wo [inj]'`. */
+    reasonDisplay?: string;
+    /** What the winner advances to, e.g. `'the quarter-final'`. Omitted when unknown. */
+    advancesTo?: string;
+};
+/** The band for the current state of the card. */
+export declare function scoreEntrySummary(params: SummaryParams): ResultBand;

package/dist/components/scoring/regions/dialPadRegion.d.ts

@@ -0,0 +1,12 @@
+import { ScoreRegion } from '../scoreEntryCard';
+import { SetScore } from '../types';
+export type DialPadRegionParams = {
+    matchUpFormat?: string;
+    /** Sets already recorded, e.g. from a saved matchUp. */
+    sets?: SetScore[];
+    onChange?: () => void;
+};
+export type DialPadRegion = ScoreRegion & {
+    getSets: () => SetScore[];
+};
+export declare function createDialPadRegion(params: DialPadRegionParams): DialPadRegion;

package/dist/components/scoring/regions/dynamicSetsRegion.d.ts

@@ -0,0 +1,19 @@
+import { ScoreRegion } from '../scoreEntryCard';
+import { SetScore } from '../types';
+export type DynamicSetsRegionParams = {
+    matchUpFormat?: string;
+    /** Sets already recorded, e.g. from a saved matchUp. */
+    sets?: SetScore[];
+    /** Whether smart complements starts enabled. Defaults to on. */
+    smartComplements?: boolean;
+    smartComplementsLabel?: string;
+    /** Called after a change affecting only the score. Wire to the card's `refresh`. */
+    onChange?: () => void;
+    /** Called when the COLUMNS change. Wire to the card's `rerender`. */
+    onStructureChange?: () => void;
+};
+export type DynamicSetsRegion = ScoreRegion & {
+    getSets: () => SetScore[];
+    smartComplementsEnabled: () => boolean;
+};
+export declare function createDynamicSetsRegion(params: DynamicSetsRegionParams): DynamicSetsRegion;

package/dist/components/scoring/regions/freeScoreRegion.d.ts

@@ -0,0 +1,18 @@
+import { ScoreRegion } from '../scoreEntryCard';
+import { SetScore } from '../types';
+export type FreeScoreRegionParams = {
+    matchUpFormat?: string;
+    /** The score to open with, already formatted (e.g. `'6-4 6-3'`). */
+    initialText?: string;
+    /** Label above the field. */
+    label?: string;
+    /** Called after any change. Wire to the card's `refresh`. */
+    onChange?: () => void;
+};
+export type FreeScoreRegion = ScoreRegion & {
+    /** What is currently in the field. */
+    getText: () => string;
+    /** The sets the parse produced, for submission. */
+    getSets: () => SetScore[];
+};
+export declare function createFreeScoreRegion(params: FreeScoreRegionParams): FreeScoreRegion;

package/dist/components/scoring/regions/scoreReadout.d.ts

@@ -0,0 +1,11 @@
+import { SideNumber } from '../logic/scoreEntryState';
+import { SetScore } from '../types';
+/** The track width for the readout column, matching the artboards. */
+export declare const READOUT_COLUMN_WIDTH = "200px";
+export type ScoreReadouts = {
+    /** The cell for a side's row. Registers it, so later `update` calls reach it. */
+    cell: (sideNumber: SideNumber, sets: SetScore[]) => HTMLElement;
+    /** Rewrite every registered readout from the current sets. */
+    update: (sets: SetScore[]) => void;
+};
+export declare function createScoreReadouts(): ScoreReadouts;

package/dist/components/scoring/regions/setColumns.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Labels for the score columns.
+ *
+ * Shared by every region that renders per-set columns, so the Dial Pad and Dynamic Sets cannot end up
+ * heading the same column differently.
+ */
+/**
+ * The column heading for a set: `1st`, `2nd`, `3rd`, `4th`, `5th`.
+ *
+ * CA, 2026-09-27, replacing `SET 1` / `SET 2` / `SET 3`. Shorter matters here for a reason beyond
+ * taste: the heading sits above a 62px column, and `SET 1` is wide enough that shrinking the column
+ * on a narrow viewport would either clip it or force the 44px input below its minimum target.
+ *
+ * The teens are handled even though a match will never have eleven sets, because an ordinal function
+ * that is wrong for 11 is simply a wrong ordinal function, and the next caller will not check.
+ */
+export declare function ordinalSetLabel(setNumber: number): string;