courthive-components 6.1.0 → 6.2.1

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

@@ -11,7 +11,7 @@ export declare const MATCH_ROOTS: readonly ["SET", "HAL", "QTR", "PER", "INN", "
 export declare const MATCH_ROOT_LABELS: Record<string, string>;
 /**
  * Returns valid bestOf options for a given match root.
- * SET root: [1,3,5] (standard tennis)
+ * SET root: [1,3,5,7,9] — odd counts; the factory parses any best-of count (#5136)
  * Other roots: [1..12] (wide range for cross-sport)
  */
 export declare function getBestOfOptionsForRoot(matchRoot?: string): number[];

package/dist/components/scoring/approaches/dialPadLogic.d.ts

@@ -10,3 +10,8 @@ export type FormatOptions = {
  * Example: "6464" with matchUpFormat 'SET3-S:6/TB7' becomes "6-4 6-4"
  */
 export declare function formatScoreString(digits: string, options: FormatOptions): string;
+/**
+ * The number of sets a format names. `matchUpFormatCode.parse` puts `bestOf` and `exactly` at the top level
+ * of the parsed format, never inside `setFormat`.
+ */
+export declare function setCountOf(parsedFormat: any): number;

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

@@ -0,0 +1,24 @@
+import { SideNumber } from './logic/scoreEntryState';
+/**
+ * The LOWER participant's row — where entry begins, in every approach.
+ *
+ * CA, 2026-09-28: *"the dynamic sets when launched should always initially give focus to the lower
+ * row; that way e.g. 3 is lower row and shift+3 is upper row, which feels natural ... each subsequent
+ * entry column should start on the bottom cell."*
+ *
+ * Named rather than written as a bare `2` at each site: it is one decision, and the shifted case is
+ * derived from it (`otherSide`) so the two can never be set independently and disagree.
+ */
+export declare const ENTRY_SIDE: SideNumber;
+/** The side a SHIFTED keystroke writes to — the upper row, by construction. */
+export declare const SHIFTED_SIDE: SideNumber;
+export declare function otherSide(sideNumber: SideNumber): SideNumber;
+/**
+ * The digit a key press means, or `undefined` for anything that is not a digit key.
+ *
+ * Both the number row and the numpad, because an operator entering scores at speed uses whichever is
+ * under their hand.
+ */
+export declare function digitFromCode(code: string): number | undefined;
+/** Whether a key event carries a modifier that means it belongs to the browser or the OS. */
+export declare function hasCommandModifier(event: KeyboardEvent): boolean;

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

@@ -1,17 +1,37 @@
 import { SetScore } from '../types';
 /**
  * Set format information returned by matchUpFormatCode.parse()
+ *
+ * ── `NoAD`, and why the casing is load-bearing ──
+ *
+ * This type is a hand-written MIRROR of what `matchUpFormatCode.parse` emits, and it named the
+ * no-advantage flag `noAd` while the factory emits **`NoAD`**. Measured 2026-09-28:
+ * `parse('SET1-S:TB10NOAD').setFormat.tiebreakSet` is `{ tiebreakTo: 10, NoAD: true }`, so every read
+ * of `.noAd` in this module answered `undefined` for every format — and the TYPE is what made those
+ * reads look correct.
+ *
+ * Nothing threw and nothing logged; no-advantage scoring was simply ignored. Two measured
+ * consequences, both live in the shipping dialog: a low of 6 in a `TB7NOAD` completed to **8** instead
+ * of 7, and a low of 5 in `S:6NOAD` completed to **7** instead of 6 — a 7-5 in a format where first to
+ * six wins.
+ *
+ * Every OTHER reader of this flag in the package had it right — `freeScore.ts`, `matchUpFormat.ts`,
+ * `matchUpFormatLogic.ts` and the format picker all read `.NoAD`. This one type was the outlier, which
+ * is the shape the architectural standards call mock divergence: a hand-written mirror that renames a
+ * field and then certifies the rename.
  */
 export type SetFormat = {
     setTo?: number;
     tiebreakAt?: number;
+    /** No-advantage on the SET — with no tiebreak, the set ends at `setTo` without a two-game margin. */
+    NoAD?: boolean;
     tiebreakFormat?: {
         tiebreakTo?: number;
-        noAd?: boolean;
+        NoAD?: boolean;
     };
     tiebreakSet?: {
         tiebreakTo?: number;
-        noAd?: boolean;
+        NoAD?: boolean;
     };
     timed?: boolean;
     minutes?: number;
@@ -25,6 +45,7 @@ export type SetFormat = {
 export type MatchUpConfig = {
     bestOf: number;
     exactly?: number;
+    aggregate?: boolean;
     setFormat?: SetFormat;
     finalSetFormat?: SetFormat;
 };
@@ -37,24 +58,6 @@ export type SmartComplementResult = {
     shouldApply: boolean;
     reason?: string;
 };
-/**
- * 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;
 /**
@@ -95,12 +98,12 @@ export declare function getSetWinner(setIndex: number, scores: {
 /**
  * Determine if match is complete based on sets won
  */
-export declare function isMatchComplete(sets: SetScore[], bestOf: number, exactly?: number): boolean;
+export declare function isMatchComplete(sets: SetScore[], config: MatchUpConfig): boolean;
 /**
  * Get the match winner based on sets won
  * Returns undefined if match is not complete
  */
-export declare function getMatchWinner(sets: SetScore[], bestOf: number, exactly?: number): 1 | 2 | undefined;
+export declare function getMatchWinner(sets: SetScore[], config: MatchUpConfig): 1 | 2 | undefined;
 /**
  * Calculate the complement score for smart complement entry
  * Returns null if no predictable complement exists

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

@@ -0,0 +1,175 @@
+import { hydrateScoreEntryState, ScoreEntryState, SideNumber } from './scoreEntryState';
+import { MatchUpConfig } from './dynamicSetsLogic';
+import { SetScore } from '../types';
+/** The three ways of typing a score. The dialog's own union of the same three names is re-pointed here in S5. */
+export type ScoreEntryApproach = 'dynamicSets' | 'freeScore' | 'dialPad';
+/**
+ * One set as ENTERED, cell by cell. Any cell may be empty, which is how a half-entered set is kept.
+ *
+ * `side1` / `side2` are the set's principal score — games, or the POINTS of a tiebreak-only set, exactly
+ * as the regions' cells hold them. `tiebreak1` / `tiebreak2` are the points that decided an ordinary set
+ * that went to a tiebreak.
+ */
+export type SetEntry = {
+    side1?: number;
+    side2?: number;
+    tiebreak1?: number;
+    tiebreak2?: number;
+};
+/** Which cell of which set an intent is aimed at. A tiebreak-only set has no `tiebreak` cells. */
+export type CellRef = {
+    setIndex: number;
+    side: SideNumber;
+    kind: 'games' | 'tiebreak';
+};
+export type ScoreEntryModel = {
+    matchUpFormat: string;
+    approach: ScoreEntryApproach;
+    /** Exactly the set count the format plays, every entry possibly empty. */
+    sets: readonly SetEntry[];
+    /** The existing pure ending engine, folded in unchanged. */
+    ending: ScoreEntryState;
+};
+/** The ways an ending is chosen, one per transition in `scoreEntryState.ts`. */
+export type EndingIntent = {
+    kind: 'side';
+    sideNumber: SideNumber;
+    status: string;
+} | {
+    kind: 'match';
+    status: string;
+} | {
+    kind: 'bothSidesOut';
+} | {
+    kind: 'reasonCode';
+    code: string | undefined;
+};
+export type CreateScoreEntryModelParams = {
+    matchUpFormat?: string;
+    approach?: ScoreEntryApproach;
+    /** A saved score to open with, in factory shape. */
+    sets?: SetScore[];
+    /** A saved matchUp whose outcome hydrates the ending — see `hydrateScoreEntryState`. */
+    matchUp?: Parameters<typeof hydrateScoreEntryState>[0];
+};
+/** What a model with no format opens under. The same fallback `freeScoreRegion` and `matchUpConfigFor` use. */
+export declare const DEFAULT_MATCH_UP_FORMAT = "SET3-S:6/TB7";
+export declare function createScoreEntryModel(params?: CreateScoreEntryModelParams): ScoreEntryModel;
+export type TypeDigitIntent = {
+    cell: CellRef;
+    digit: number;
+    /**
+     * Derive the OTHER side from what was typed, where the format makes that a single answer.
+     *
+     * For a games cell this is the smart complement — a `4` typed into an EMPTY cell writes `6` opposite,
+     * over whatever the other cell held: the inference is about the pair. Whether to offer it again for
+     * the same set is the caller's policy. For an ordinary tiebreak it derives the
+     * winner's points from the loser's, and fires only from the games LOSER's cell, because a winner's 7
+     * could have beaten anything. For a tiebreak-only set it derives the other side from the one typed —
+     * CA's rule for the Dial Pad, which always asks; Dynamic Sets asks while its Smart toggle is on.
+     */
+    complement?: boolean;
+};
+/**
+ * Append a digit to a cell, as a keystroke does.
+ *
+ * Refused — the same model comes back — when the digit could not become a legal score: past the
+ * ceiling for a games cell, or past two digits where no ceiling exists. Refusal is what lets a keypad
+ * move on to the next cell rather than the model guessing.
+ *
+ * The ceiling is `getMaxSetScore`'s, given the OPPONENT's games where they are in: 7 in a set to six,
+ * tightened to 6 for a side facing 3 — 7 is reachable only through a tiebreak at six-all — and left at
+ * 7 for a side facing 5, since 7-5 needs no tiebreak. That last answer is `#5043(factory)`, merged
+ * 2026-09-30; this module is written to the fixed factory, and a `7` typed against a `5` is pinned.
+ */
+export declare function typeDigit(model: ScoreEntryModel, intent: TypeDigitIntent): ScoreEntryModel;
+/**
+ * Write a whole value into a cell, as setting an input's value does. `undefined` empties it.
+ *
+ * Nothing is clamped or derived: the value recorded is the value given, and whether it is legal is
+ * `error`'s question. A keystroke goes through `typeDigit`, which is where the derivations live.
+ */
+export declare function setCell(model: ScoreEntryModel, cell: CellRef, value: number | undefined): ScoreEntryModel;
+export declare function clearCell(model: ScoreEntryModel, cell: CellRef): ScoreEntryModel;
+/**
+ * Empty every set and keep the ending: what a score-clearing ending does to the cells.
+ *
+ * CA, 2026-09-30: *"when I enter set score(s) and then select (Walkover) the set score(s) should
+ * clear."* The card calls this when the chosen ending carries no score, having first read `scoreString`
+ * for the band. Final, like `[Clear]`: un-choosing the walkover does not bring the score back, because a
+ * remembered score that silently reappears on an approach switch was the worse bug.
+ */
+export declare function clearScore(model: ScoreEntryModel): ScoreEntryModel;
+/** Empty every set and un-choose the ending: the card's `[Clear]`. Format and approach stay. */
+export declare function clearAll(model: ScoreEntryModel): ScoreEntryModel;
+/**
+ * Choose (or un-choose) an ending, delegating to `scoreEntryState.ts` — every control there is a
+ * toggle, and that is preserved.
+ *
+ * The SETS are left exactly as they are, even for an ending that carries no score. The card today
+ * clears the region on a walkover and keeps the string aside for the band; here the selectors suppress
+ * the score while such an ending is chosen (`scoreString` answers nothing, `discardedScore` names what
+ * was typed) and it comes back if the ending is un-chosen. Keeping the keystrokes is the point of the
+ * model; whether the card should ALSO clear explicitly is S5's decision, and `clearAll` is there for it.
+ */
+export declare function chooseEnding(model: ScoreEntryModel, intent: EndingIntent): ScoreEntryModel;
+/**
+ * Move to another format, keeping what the new format has not invalidated.
+ *
+ * `retainScoreForFormat` decides, given both formats: a set whose position keeps the same rule survives
+ * finished or not, a set whose rule changed must stand as a complete legal set, and everything after the
+ * first casualty goes with it. It keeps a PREFIX, so the entries are cut to its length rather than
+ * rebuilt from its output — the operator's cells survive untouched. The array is then resized to the
+ * new format's set count.
+ */
+export declare function changeFormat(model: ScoreEntryModel, matchUpFormat: string): ScoreEntryModel;
+/** Change how the score is typed. A no-op on the score itself: the sets are the sets whichever region shows them. */
+export declare function switchApproach(model: ScoreEntryModel, approach: ScoreEntryApproach): ScoreEntryModel;
+/**
+ * The index of the set that decides the match, or `undefined` while nothing does.
+ *
+ * Asked of the factory prefix by prefix, so that a decision reached at set 2 is found even when a stale
+ * set 3 would make the whole array read as undecided — measured: `analyzeMatchUp` on `6-2 6-2 6-3` with
+ * three winning sides answers NO winner, because three is not `setsToWin`.
+ */
+export declare function decidingIndex(sets: readonly SetEntry[], config: MatchUpConfig): number | undefined;
+/** The sets with BOTH principal cells in, as the factory reads them, positioned by `setNumber`. */
+export declare function enteredFactorySets(sets: readonly SetEntry[], config: MatchUpConfig): SetScore[];
+/**
+ * One entry in the factory's shape.
+ *
+ * `buildSetScore` derives the winning side and the tiebreak pair from the loser's points, which is the
+ * contract this module keeps: the lower of two tiebreak cells is the loser's. A cell that is empty stays
+ * empty in the output — it is not read as 0, which is what let a half-entered set claim `6-0`.
+ *
+ * A tiebreak-only set is built here rather than by `buildSetScore`. When this was written that function's
+ * winner rule was a hand-rolled "both sides above zero and unequal" (a `3-1` won, a `10-0` not); it asks
+ * the factory now too, and this path simply never left. The set's winner is `analyzeSet`'s, given the
+ * points AS points — `getSetWinner` would hand them over as games, which a tiebreak-only format has no
+ * rule for.
+ */
+export declare function toFactorySet(entry: SetEntry, index: number, config: MatchUpConfig): SetScore;
+/**
+ * Replace every set from a factory-shaped array: the Free Score boundary, where TEXT becomes sets.
+ *
+ * Free Score keeps the text as the field's own value while it is being typed — a half-typed `6-4 re` is
+ * nothing the model can represent — and commits here at the points where the text parses to sets. The
+ * same seeding and the same invariants as opening a saved score: a set past the decider is trimmed.
+ * The same model comes back when nothing changed, so a keystroke inside a word is not a transition.
+ */
+export declare function replaceSets(model: ScoreEntryModel, sets: SetScore[]): ScoreEntryModel;
+export declare function readCell(entry: SetEntry, cell: CellRef): number | undefined;
+/** The side that lost the set on games, or `undefined` while the games are level or not both in. */
+export declare function gamesLoser(entry: SetEntry): SideNumber | undefined;
+/** Whether both principal cells are in — the regions' `bothEntered`. */
+export declare function isEntered(entry: SetEntry): boolean;
+/** Whether the set holds anything at all, in any cell. */
+export declare function isEmptyEntry(entry: SetEntry): boolean;
+/**
+ * How many sets the format can hold: every set of an `exactly` format, otherwise the best-of. An
+ * aggregate format with a final tiebreak holds one more, its sudden-death decider, which is set N + 1
+ * and never one of the N (factory #5166; CA, 2026-10-04). It opens only on a level total.
+ */
+export declare function setCountOf(config: MatchUpConfig): number;
+/** The set number of an aggregate format's final-tiebreak decider, or `undefined` when it has none. */
+export declare function deciderSetNumberOf(config: MatchUpConfig): number | undefined;

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

@@ -0,0 +1,88 @@
+import { ScoreEntryResolution, SideNumber } from './scoreEntryState';
+import { ScoreEntryModel } from './scoreEntryModel';
+import { SetScore } from '../types';
+/** One visible column: a set's principal cells, or the tiebreak cells beside a set that went to one. */
+export type ScoreSlot = {
+    kind: 'games' | 'tiebreak';
+    setIndex: number;
+};
+export type ColumnOptions = {
+    /**
+     * A set the operator has clicked back into, whose tiebreak column stays open though its points are
+     * known. Presentation, held by the region — passed in rather than kept in the model.
+     */
+    editingSet?: number;
+};
+/** The ending, resolved. The one place `resolveScoreEntry` is asked about a model. */
+export declare function resolveEnding(model: ScoreEntryModel): ScoreEntryResolution;
+/** Sets with BOTH principal cells in, in factory shape, positioned by `setNumber`. A partial set is not here. */
+export declare function enteredSets(model: ScoreEntryModel): SetScore[];
+/** The entered sets that are SETTLED — see `isSettled`. A `4-2` is entered; it is not completed. */
+export declare function completedSets(model: ScoreEntryModel): SetScore[];
+/** Whether ANYTHING has been typed, complete or not — a single digit counts. */
+export declare function hasEntry(model: ScoreEntryModel): boolean;
+/** The score as it stands, in the factory's own line — or nothing while an ending has set it aside. */
+export declare function scoreString(model: ScoreEntryModel): string | undefined;
+/** What a score-clearing ending set aside, so the band can name it. Nothing unless one is chosen. */
+export declare function discardedScore(model: ScoreEntryModel): string | undefined;
+/**
+ * Whether the score is a FINISHED result: the factory names a winner, the last set is settled, and
+ * nothing is wrong with what came before it. An ending that discards the score makes this false,
+ * because there is no result to be finished.
+ */
+export declare function isComplete(model: ScoreEntryModel): boolean;
+/** The winner: the ending's when it names one, otherwise the finished score's. */
+export declare function winningSide(model: ScoreEntryModel): SideNumber | undefined;
+/** The ending's status when one is chosen; `COMPLETED` for a finished score; nothing otherwise. */
+export declare function matchUpStatus(model: ScoreEntryModel): string | undefined;
+/**
+ * The first thing wrong with the score, in words, or `undefined`.
+ *
+ * Three checks, in order:
+ *
+ *   1. a tiebreak that contradicts who won the set, with the participant NAMED — the factory refuses it
+ *      too, but "side 1" is not a message an operator can act on;
+ *   2. the FACTORY's judgement of each entered set (`validateSetScore` with `allowIncomplete`), which
+ *      forgives unfinished games but knows `3-7` cannot be. A set whose tiebreak points are still owed
+ *      is skipped, because the card is asking for them and an error at that moment would answer its
+ *      own question;
+ *   3. invariant 10A: a set before the last entered one that is empty or unfinished.
+ *
+ * Silent while a score-clearing ending is chosen: nothing typed will be submitted.
+ */
+export type ErrorOptions = {
+    /** Names for the two sides, so a message can say who rather than "side 1". */
+    sideNames?: [string, string];
+};
+export declare function error(model: ScoreEntryModel, options?: ErrorOptions): string | undefined;
+/**
+ * The visible columns, left to right.
+ *
+ * Every set that holds anything is shown, whatever came before it — this is the rule that ends the
+ * ghost set: a cleared set 1 beside a typed set 2 shows BOTH, one empty and one full, so the operator
+ * sees the score the model has. Then one empty set opens after the last holding one, and only when
+ * everything before it is settled and the match is not decided; a timed format plays every bolt, so
+ * for it the only question is whether one is left. A tiebreak column sits beside a set whose games call
+ * for points it does not yet have, or that the operator has reopened.
+ */
+export declare function columns(model: ScoreEntryModel, options?: ColumnOptions): ScoreSlot[];
+/**
+ * Whether a set is finished: both principal cells in, no tiebreak points owed, and the factory accepts
+ * it as a COMPLETE legal set. A `7-6` whose points are unknown is not settled, so the next set does not
+ * open under it.
+ *
+ * ── Strict `validateSetScore`, and not `analyzeSet`'s winning side ──
+ *
+ * Measured 2026-09-30, before `#5049(factory)`: `analyzeSet` named a winner for a `3-1` in a match
+ * tiebreak to ten, and for a `10-9` — any lead read as a win. Both answers are fixed in 7.4.0, and
+ * `dynamicSetsLogic` now asks the factory too. Strict validation stays the rule here all the same: it is
+ * the same answer `error` reports, so "settled" and "no error" cannot come apart.
+ *
+ * A timed set is the exception: any pair of scores ends it, a tie included, so both cells in is the
+ * whole test — strict validation refuses a `0-0` bolt, which is unusual but not impossible.
+ */
+export declare function isSettled(model: ScoreEntryModel, index: number): boolean;
+/** Whether the set's games call for a tiebreak whose points the operator has not supplied yet. */
+export declare function tiebreakOutstanding(model: ScoreEntryModel, index: number): boolean;
+/** The value in one cell. Exported for regions, which render cells from the model and never read them back. */
+export declare function cellValue(model: ScoreEntryModel, setIndex: number, side: SideNumber, kind: ScoreSlot['kind']): number | undefined;

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

@@ -81,6 +81,39 @@ export declare function chooseReasonCode(state: ScoreEntryState, code: string |
  *
  * `undefined` when no ending is selected, because there is nothing to give a reason for.
  */
+/**
+ * The card's state for a matchUp that ALREADY has an outcome.
+ *
+ * Without this the dialog opened blank on a scored matchUp: no recorded ending, no reason code. The
+ * shipping modal hydrates, so swapping the card in without this would lose the display of every outcome
+ * already entered — CA, 2026-09-28: *"we need to be able to open existing outcomes!"*
+ *
+ * ── The one inversion, again ──
+ *
+ * A stored matchUp names the WINNER. This card records the side the ending HAPPENED TO, and derives the
+ * winner from it. So hydration runs that mapping backwards: the exiting side is the one that did not
+ * win. `hydrateIrregularEnding` is reused for the status itself rather than re-deriving it, so the
+ * reverse lookup from `DOUBLE_WALKOVER` to the `WALKOVER` an operator actually clicks lives in exactly
+ * one place.
+ *
+ * Three cases and a refusal:
+ *
+ *   - a DOUBLE exit — both sides out, so no side is distinguished. `sideNumber: 1` is arbitrary and only
+ *     decides nothing: `bothSidesOut` makes the resolution `NEITHER_SIDE`, and the card draws the pill on
+ *     both rows regardless.
+ *   - an ending that resolves NOBODY — recorded at match level, because there is no side to attach it to.
+ *   - a single exit — recorded against `3 - winningSide`.
+ *   - a winner-requiring status with NO winning side is a corrupt record, and is refused: it returns the
+ *     empty state rather than inventing a placement. `hydrateIrregularEnding` makes the same choice for
+ *     an unmapped double exit, and for the same reason — a guess here silently advances a participant.
+ */
+export declare function hydrateScoreEntryState(matchUp?: {
+    matchUpStatus?: string;
+    winningSide?: number;
+    sideStatusCodes?: Record<number, string>;
+    matchUpStatusCode?: string;
+    matchUpStatusCodes?: unknown[];
+}): ScoreEntryState;
 export declare function reasonCodeStatus(state: ScoreEntryState): string | undefined;
 /**
  * Resolve the card into a submittable outcome.

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

@@ -0,0 +1,8 @@
+import { CreateScoreEntryModelParams, ScoreEntryModel } from './scoreEntryModel';
+export type ScoreEntryStore = {
+    /** The model as it stands. Never mutated; read it again after any transition. */
+    get: () => ScoreEntryModel;
+    /** Replace the model. The caller says what must be redrawn. */
+    set: (next: ScoreEntryModel) => void;
+};
+export declare function createScoreEntryStore(params?: CreateScoreEntryModelParams): ScoreEntryStore;

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

@@ -42,6 +42,40 @@ export declare function groupKeyForStatus(matchUpStatus: string | undefined): st
  *
  * Returns `undefined` for a provenance element, which carries no code at all.
  */
+/**
+ * The reason code a matchUp actually recorded, for the control that has to re-display it.
+ *
+ * ── Why not `matchUpStatusCodes[0]` ──
+ *
+ * `matchUpStatusCodes` is POSITIONAL BY SIDE, so a reason belonging to side 2 sits at index 1 and
+ * index 0 is an empty string that `normalizeStatusCode` turns into `undefined`. The picker then opens
+ * empty, the operator's reason is missing from the control meant to show it, and re-saving loses it.
+ *
+ * Measured against published **7.1.0**, because the exposure is narrower than it first looks: a code
+ * submitted by this dialog is stored EXACTLY as submitted, so `['W1']` round-trips through index 0 and
+ * reads correctly today. The index-1 case arrives by PROPAGATION — a reason carried into a connected
+ * structure is placed at the arriving side's index — and factory #5016 both fixes that carry and gives
+ * the fact a home that states what it attributes to.
+ *
+ * ── The order, and why each step is needed ──
+ *
+ * 1. `sideStatusCodes[sideNumber]` — the side's own, once the factory writes it.
+ * 2. `matchUpStatusCode` — the MATCH's, for an ending that resolves nobody (ABANDONED, CANCELLED,
+ *    INCOMPLETE). There is no side to ask.
+ * 3. `matchUpStatusCodes[0]` — records written before either field existed. Not optional: the peer
+ *    range still admits a factory major that has neither, so dropping it would read nothing at all
+ *    from every record stored to date.
+ *
+ * The fields are mirrored onto this package's own `MatchUp` rather than imported from the factory, for
+ * the reason `types.ts` already records: they do not exist in the older major the peer range admits.
+ */
+export declare function recordedStatusCode(matchUp?: {
+    matchUpStatus?: string;
+    winningSide?: number;
+    sideStatusCodes?: Record<number, string>;
+    matchUpStatusCode?: string;
+    matchUpStatusCodes?: unknown[];
+}): string | undefined;
 export declare function normalizeStatusCode(entry: unknown): string | undefined;
 /**
  * The codes a policy offers for this status, or an empty list when it offers none.

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

@@ -0,0 +1,14 @@
+import { SetFormat } from './dynamicSetsLogic';
+import { SideNumber } from './scoreEntryState';
+/** The points a tiebreak-only set is played to, or `undefined` if this set is not one. */
+export declare function tiebreakOnlyTarget(setFormat?: SetFormat): number | undefined;
+/**
+ * Both sides' points, from the LOWER score and the side it was entered on.
+ *
+ * `undefined` when the set carries no target to complete against, or when the factory declines — never
+ * a guess. The caller leaves what was typed alone in that case rather than inventing the other half.
+ */
+export declare function completeTiebreakOnly(lowValue: number, lowSide: SideNumber, setFormat?: SetFormat): {
+    side1: number;
+    side2: number;
+} | undefined;

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

@@ -1,12 +1,17 @@
+import { ScoreEntryStore } from '../logic/scoreEntryStore';
 import { ScoreRegion } from '../scoreEntryCard';
 import { SetScore } from '../types';
 export type DialPadRegionParams = {
+    /** The model the card holds. Omit it and the region makes its own from the params below. */
+    store?: ScoreEntryStore;
     matchUpFormat?: string;
-    /** Sets already recorded, e.g. from a saved matchUp. */
+    /** Sets already recorded, e.g. from a saved matchUp. Read only when no `store` is given. */
     sets?: SetScore[];
     onChange?: () => void;
 };
 export type DialPadRegion = ScoreRegion & {
+    store: ScoreEntryStore;
+    /** The entered sets, for a host or a test reading the region directly. The card reads the model. */
     getSets: () => SetScore[];
 };
 export declare function createDialPadRegion(params: DialPadRegionParams): DialPadRegion;

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

@@ -1,7 +1,12 @@
 import { ScoreRegion } from '../scoreEntryCard';
+import { ScoreEntryStore } from '../logic/scoreEntryStore';
 import { SetScore } from '../types';
 export type DynamicSetsRegionParams = {
+    /** The model the card holds. Omit it and the region makes its own from the params below. */
+    store?: ScoreEntryStore;
     matchUpFormat?: string;
+    /** Participant names, so an integrity message can say who rather than "side 1". */
+    sideNames?: [string, string];
     /** Sets already recorded, e.g. from a saved matchUp. */
     sets?: SetScore[];
     /** Whether smart complements starts enabled. Defaults to on. */
@@ -13,7 +18,11 @@ export type DynamicSetsRegionParams = {
     onStructureChange?: () => void;
 };
 export type DynamicSetsRegion = ScoreRegion & {
+    store: ScoreEntryStore;
+    /** The entered sets, for a host or a test reading the region directly. The card reads the model. */
     getSets: () => SetScore[];
+    /** The model's integrity message, named with this region's `sideNames`. The card computes its own. */
+    error: () => string | undefined;
     smartComplementsEnabled: () => boolean;
 };
 export declare function createDynamicSetsRegion(params: DynamicSetsRegionParams): DynamicSetsRegion;

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

@@ -1,8 +1,11 @@
+import { ScoreEntryStore } from '../logic/scoreEntryStore';
 import { ScoreRegion } from '../scoreEntryCard';
 import { SetScore } from '../types';
 export type FreeScoreRegionParams = {
+    /** The model the card holds. Omit it and the region makes its own from the params below. */
+    store?: ScoreEntryStore;
     matchUpFormat?: string;
-    /** The score to open with, already formatted (e.g. `'6-4 6-3'`). */
+    /** The score to open with, already formatted (e.g. `'6-4 6-3'`). With a `store`, the model's own line is used. */
     initialText?: string;
     /** Label above the field. */
     label?: string;
@@ -10,9 +13,12 @@ export type FreeScoreRegionParams = {
     onChange?: () => void;
 };
 export type FreeScoreRegion = ScoreRegion & {
+    store: ScoreEntryStore;
     /** What is currently in the field. */
     getText: () => string;
-    /** The sets the parse produced, for submission. */
+    /** The entered sets, for a host or a test reading the region directly. The card reads the model. */
     getSets: () => SetScore[];
+    /** Text in the field counts as entry the model cannot see; required here. */
+    hasEntry: () => boolean;
 };
 export declare function createFreeScoreRegion(params: FreeScoreRegionParams): FreeScoreRegion;

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

@@ -0,0 +1,2 @@
+import { SetScore } from '../types';
+export declare function scoreLine(sets: SetScore[], matchUpFormat?: string): string | undefined;