courthive-components 6.2.1 → 6.4.2

package/dist/components/inline-scoring/renderInlineMatchUp.d.ts

@@ -1,5 +1,5 @@
-import { InlineScoringManager } from './inlineScoringManager';
 import { Composition, EventHandlers, MatchUp } from '../../types';
+import { InlineScoringManager } from './inlineScoringManager';
 interface RenderInlineMatchUpParams {
     matchUp: MatchUp;
     composition: Composition;

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

@@ -0,0 +1,20 @@
+/**
+ * The picker's two dropdowns: a plain list of choices, and the game-format chooser. Moved out of
+ * matchUpFormat.ts unchanged except that they are given their labels instead of reading module state.
+ */
+export interface DropdownItem {
+    text: string;
+    onClick: () => void;
+}
+export declare function closeCurrentDropdown(): void;
+export declare function createDropdown(e: Event, items: DropdownItem[]): void;
+type GameFormat = {
+    type: 'CONSECUTIVE';
+    count: number;
+    deuceAfter?: number;
+} | {
+    type: 'TRADITIONAL';
+    deuceAfter?: number;
+};
+export declare function createGameFormatDropdown(e: Event, currentGameFormat: GameFormat | undefined, labels: any, onUpdate: (gameFormat?: GameFormat) => void): void;
+export {};

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

@@ -0,0 +1,12 @@
+import { Capabilities, FormatState, ResolvedCapabilities } from './types';
+/** Everything the picker offered before capabilities existed is on unless a consumer turns it off. */
+export declare function resolveCapabilities(capabilities?: Capabilities): ResolvedCapabilities;
+export declare const SET_TYPE_CAPABILITY: {
+    readonly SET: "set";
+    readonly TIEBREAK: "tiebreak";
+    readonly TIMED: "timed";
+    readonly OUTS: "outs";
+    readonly POINTS_TOTAL: "pointsTotal";
+};
+/** The switched-off capabilities this format needs, each named once. Empty means it may be edited. */
+export declare function capabilityReasons(format: FormatState, capabilities: ResolvedCapabilities): string[];

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

@@ -0,0 +1,20 @@
+import { Capabilities, Codec, EditorState, FormatState, SegmentDraft } from './types';
+export declare const DEFAULT_FORMAT = "SET3-S:6/TB7";
+export declare function defaultSegment(): SegmentDraft;
+/** The parsed shape the factory's stringify reads, built from a segment of the state. */
+export declare function segmentToParsed(segment: SegmentDraft): any;
+export declare function formatFromParsed(parsed: any): FormatState;
+export declare function formatToParsed(written: FormatState): any;
+export declare function toCode(format: FormatState, codec: Codec): string;
+/**
+ * The picker's starting state for a code.
+ *
+ * The code is editable only if the state rebuilds it exactly: compared canonically, so a redundant
+ * spelling (`@6` on a set to 6) still counts as representable. Anything else (a set type, a field or
+ * a modifier the state has no place for) makes it read-only, so it is returned untouched rather than
+ * rebuilt without the parts the controls cannot hold. A code that does not parse falls back to the
+ * default format, which is then what Select returns, as the picker always has.
+ */
+export declare function fromCode(code: string, codec: Codec, capabilities?: Capabilities): EditorState;
+/** What Select returns: the original code until something is edited, the rebuilt code after. */
+export declare function selectedCode(state: EditorState, codec: Codec): string;

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

@@ -0,0 +1,16 @@
+import { Capabilities, CombinedPointsConfig, Codec, Edit, EditorState } from './types';
+/** A final set's tiebreak targets outside "Exactly" mode; "Exactly" also offers 1 and 3. */
+export declare const DEFAULT_TIEBREAK_TO_OPTIONS: number[];
+export interface EditContext {
+    codec: Codec;
+    capabilities?: Capabilities;
+    /** The tiebreak targets offered outside "Exactly" mode (the picker's configured options). */
+    tiebreakToOptions?: number[];
+    /** A policy's permitted points totals and tie rules (Phase 3). */
+    combinedPoints?: CombinedPointsConfig;
+}
+/**
+ * The picker's single transition function. Pure: it returns a new state and never touches the one it
+ * was given. A read-only state accepts only a new code (choosing another format replaces it whole).
+ */
+export declare function applyEdit(state: EditorState, edit: Edit, context: EditContext): EditorState;

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

@@ -0,0 +1,29 @@
+import { CombinedPointsConfig, FormatState, SegmentDraft } from './types';
+/**
+ * Points total (`SET1-S:P32`): one rally-scored segment that ends at a combined total.
+ *
+ * The grammar allows it only as a single set of a SET match: no other root, no count but 1, no Exactly,
+ * aggregate, game format, final set, match time limit or match modifiers. Rather than overwrite those
+ * values when points total is chosen, the state keeps them and this overlay locks them, so choosing
+ * another set type brings back what the operator had.
+ */
+export declare const DEFAULT_COMBINED_POINT_TOTALS: number[];
+/** Tie allowed, then win by 1 (the deciding point), 2 or 3 (CA, 2026-10-10). */
+export declare const DEFAULT_TIE_MARGINS: number[];
+export declare const isPointsTotal: (format: FormatState) => boolean;
+/** The format as it is written: a points total locks every match-level value. */
+export declare function effectiveFormat(format: FormatState): FormatState;
+/** A tie is possible only on an even total, so only an even total says what follows one. */
+export declare const tieRuleApplies: (segment: SegmentDraft) => boolean;
+export declare function tieMarginFromParsed(parsedSet: any): number;
+/** The parsed set the factory writes as `P{n}`, `P{n}DP` or `P{n}WB{m}`. Win by 1 is the deciding point. */
+export declare function pointsTotalToParsed(segment: SegmentDraft): any;
+/** The totals offered: the policy's, else the configured list, else the defaults. */
+export declare function offeredTotals(combinedPoints?: CombinedPointsConfig, configured?: number[]): number[];
+/** The tie margins offered: the policy's variants, else all of them. */
+export declare function offeredTieMargins(combinedPoints?: CombinedPointsConfig): number[];
+/**
+ * Entering points total, a total or margin the policy does not permit moves to the first one it does,
+ * so the picker starts on a permitted format. A code opened with other values keeps them.
+ */
+export declare function snapToPermitted(segment: SegmentDraft, combinedPoints?: CombinedPointsConfig): void;

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

@@ -0,0 +1,200 @@
+/**
+ * The format picker as an explicit state machine.
+ *
+ * One `FormatState` holds the whole format; the DOM holds none of it. A code becomes state through
+ * `fromCode`, state becomes a code through `toCode`, every change is an `Edit` applied by `applyEdit`
+ * (where each invariant lives once), and `deriveView` says what every control shows. The modal only
+ * renders the view and dispatches edits.
+ */
+export type SetType = 'SET' | 'TIEBREAK' | 'TIMED' | 'OUTS' | 'POINTS_TOTAL';
+export type CountMode = 'BEST_OF' | 'EXACTLY';
+export type SegmentKey = 'set' | 'finalSet';
+export type GameFormat = {
+    type: 'CONSECUTIVE';
+    count: number;
+    deuceAfter?: number;
+} | {
+    type: 'TRADITIONAL';
+    deuceAfter?: number;
+};
+/**
+ * One segment (the main set or the final set). It keeps a value for every set type's controls, so
+ * switching type and back restores what the operator had rather than resetting to defaults.
+ */
+export interface SegmentDraft {
+    type: SetType;
+    /** Standard set: games to win the set. */
+    setTo: number;
+    /** Standard set: no-advantage games. */
+    noAd: boolean;
+    /** Standard set: whether it ends in a tiebreak. */
+    tiebreak: boolean;
+    /** Standard set with a tiebreak: the game score at which it is played. */
+    tiebreakAt: number;
+    /** Standard set without a tiebreak: the game margin needed to win (2 is the default). */
+    setWinBy: number;
+    /** A set tiebreak or a tiebreak-only set: points to win. */
+    tiebreakTo: number;
+    /** A set tiebreak or a tiebreak-only set: 1 is no-advantage, 2 is win by two. */
+    tiebreakWinBy: number;
+    /** Timed set: minutes. */
+    minutes: number;
+    /** Timed set: scoring basis. Undefined is games, the grammar's default. */
+    based?: string;
+    /**
+     * Timed set: whether it ends in a tiebreak (`T10P/TB1`). Separate from a standard set's `tiebreak`, so
+     * switching a set with a tiebreak to timed does not give the timed set one.
+     */
+    timedTiebreak: boolean;
+    /** Outs set (baseball and similar): outs per side. */
+    outs: number;
+    /** A tiebreak's or a timed set's modifier, e.g. RALLY. */
+    modifier?: string;
+    /** Points total (Americano, `P32`): the rallies played; the score is how they split between the sides. */
+    combinedPointTotal: number;
+    /**
+     * Points total: what follows a tie. 0 keeps the tie as a result (`P32`), 1 plays one deciding point
+     * (`P32DP`), and 2 or more plays on until one side leads by that margin (`P32WB2`). Written only for an
+     * even total, since an odd total cannot tie.
+     */
+    tieMargin: number;
+}
+export interface FormatState {
+    /** SET, HAL, QTR, PER, INN, RND, FRM or MAP. */
+    matchRoot: string;
+    countMode: CountMode;
+    count: number;
+    aggregate: boolean;
+    gameFormat?: GameFormat;
+    set: SegmentDraft;
+    finalSetEnabled: boolean;
+    /** Kept even while disabled, so turning the final set back on restores it. */
+    finalSet: SegmentDraft;
+    /** A match-level time limit in minutes (`-M:T60`), or undefined for none. */
+    maxMinutes?: number;
+    /**
+     * Match modifiers the grammar keeps for forward compatibility (`SET3Z`). The picker has no control for
+     * them; they are carried through unchanged.
+     */
+    matchMods: string[];
+    /**
+     * The code used the standalone timed short form (`T10` for `SET1-S:T10`). Kept while the format can
+     * still be written that way, so an edit that keeps it a single timed set keeps its spelling.
+     */
+    shortForm: boolean;
+}
+/** Each capability can be switched off; a code that needs a switched-off one opens read-only. */
+export interface Capabilities {
+    setTypes?: {
+        set?: boolean;
+        tiebreak?: boolean;
+        timed?: boolean;
+        outs?: boolean;
+        pointsTotal?: boolean;
+    };
+    /** Choosing a match root other than SET. */
+    matchRoots?: boolean;
+    /** "Exactly N" set counts. */
+    exactly?: boolean;
+    aggregate?: boolean;
+    gameFormat?: boolean;
+    finalSet?: boolean;
+    /** A standard or timed set's tiebreak toggle. */
+    setTiebreak?: boolean;
+    /** A match-level time limit (`-M:T60`). */
+    maxMatchTime?: boolean;
+    /** A timed set's scoring basis (games or points). */
+    scoringBasis?: boolean;
+    /** Tiebreak and timed-set modifiers, e.g. RALLY. */
+    modifiers?: boolean;
+    /** The dropdown of predefined formats. */
+    catalog?: boolean;
+}
+export type ResolvedCapabilities = {
+    setTypes: {
+        set: boolean;
+        tiebreak: boolean;
+        timed: boolean;
+        outs: boolean;
+        pointsTotal: boolean;
+    };
+    matchRoots: boolean;
+    exactly: boolean;
+    aggregate: boolean;
+    gameFormat: boolean;
+    finalSet: boolean;
+    setTiebreak: boolean;
+    maxMatchTime: boolean;
+    scoringBasis: boolean;
+    modifiers: boolean;
+    catalog: boolean;
+};
+/** What the picker is working on: the format, the code it opened with, and whether it may be edited. */
+export interface EditorState {
+    format: FormatState;
+    /** The code the picker was opened with or last loaded. Returned unchanged until something is edited. */
+    original: string;
+    /** True once any control has changed the format. */
+    dirty: boolean;
+    /**
+     * Why the format cannot be edited here, or empty when it can. A code the state cannot represent
+     * exactly, or one that needs a switched-off capability, is shown and returned unchanged instead of
+     * being rebuilt from controls that would silently drop part of it.
+     */
+    readOnlyReasons: string[];
+}
+export type SegmentField = 'setTo' | 'noAd' | 'tiebreakAt' | 'setWinBy' | 'tiebreakTo' | 'tiebreakWinBy' | 'minutes' | 'based' | 'modifier' | 'outs' | 'combinedPointTotal' | 'tieMargin';
+export type Edit = {
+    type: 'loadCode';
+    code: string;
+} | {
+    type: 'setCountMode';
+    mode: CountMode;
+} | {
+    type: 'setCount';
+    count: number;
+} | {
+    type: 'setMatchRoot';
+    matchRoot: string;
+} | {
+    type: 'setAggregate';
+    on: boolean;
+} | {
+    type: 'setGameFormat';
+    gameFormat?: GameFormat;
+} | {
+    type: 'setMaxMinutes';
+    minutes?: number;
+} | {
+    type: 'setFinalSet';
+    on: boolean;
+} | {
+    type: 'setSetType';
+    segment: SegmentKey;
+    setType: SetType;
+} | {
+    type: 'setTiebreak';
+    segment: SegmentKey;
+    on: boolean;
+} | {
+    type: 'setSegmentValue';
+    segment: SegmentKey;
+    field: SegmentField;
+    value: any;
+};
+/**
+ * What a points total may be, as a consumer's policy permits it (Phase 3). It narrows what the picker
+ * offers; it enforces nothing, since the engine validates every write.
+ */
+export interface CombinedPointsConfig {
+    permittedPointTotals?: number[];
+    permittedVariants?: {
+        tieResolution: 'ALLOW' | 'DECIDING_POINT' | 'WIN_BY_MARGIN';
+        winningMargin?: number;
+    }[];
+}
+/** The factory's parse and stringify, injected so the machine stays pure and testable. */
+export interface Codec {
+    parse: (code: string) => any;
+    stringify: (parsed: any) => string;
+}

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

@@ -0,0 +1,76 @@
+import { Capabilities, Codec, CombinedPointsConfig, EditorState, GameFormat, SegmentField, SetType } from './types';
+/**
+ * Everything the picker shows, derived from the state. The modal renders this and decides nothing
+ * itself: which controls are visible, what each one reads, and what each dropdown offers.
+ */
+export interface Option {
+    value: any;
+    text: string;
+}
+export interface ControlView {
+    visible: boolean;
+    label: string;
+    options: Option[];
+    /** Shown but not changeable: a value a points total fixes, or the only one a policy permits. */
+    locked?: boolean;
+}
+export interface ToggleView {
+    visible: boolean;
+    checked: boolean;
+}
+export interface SegmentView {
+    what: ControlView & {
+        setType: SetType;
+    };
+    setTo: ControlView;
+    tiebreakTo: ControlView;
+    tiebreakAt: ControlView;
+    /** One button, two meanings: the tiebreak's win-by when there is a tiebreak, the set's otherwise. */
+    winBy: ControlView & {
+        field?: SegmentField;
+    };
+    advantage: ControlView;
+    minutes: ControlView;
+    based: ControlView;
+    modifier: ControlView;
+    outs: ControlView;
+    /** Points total: the rallies played. */
+    pointsTotal: ControlView;
+    /** Points total: tie allowed, or win by 1 (the deciding point), 2 or 3. Hidden for an odd total. */
+    tieRule: ControlView;
+    tiebreakToggle: ToggleView;
+}
+export interface EditorView {
+    code: string;
+    /** The catalog entry matching the code, or 'Custom'. */
+    catalogValue: string;
+    catalogVisible: boolean;
+    readOnly: boolean;
+    descriptor: ControlView;
+    count: ControlView;
+    matchRoot: ControlView;
+    aggregate: ToggleView;
+    gameFormat: ControlView & {
+        gameFormat?: GameFormat;
+    };
+    /** The match-level time limit (`-M:T60`). Its option value 0 means none. */
+    maxTime: ControlView;
+    finalSetToggle: ToggleView;
+    set: SegmentView;
+    finalSet: SegmentView & {
+        visible: boolean;
+    };
+}
+export interface ViewConfig {
+    codec: Codec;
+    capabilities?: Capabilities;
+    labels?: any;
+    options?: any;
+    /** The codes the catalog dropdown offers. */
+    catalogCodes: string[];
+    /** A policy's permitted points totals and tie rules: they narrow what is offered (Phase 3). */
+    combinedPoints?: CombinedPointsConfig;
+}
+export declare const CUSTOM = "Custom";
+export declare function gameFormatText(gameFormat: GameFormat | undefined, labels?: any): string;
+export declare function deriveView(state: EditorState, config: ViewConfig): EditorView;

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

@@ -1,4 +1,5 @@
-interface MatchUpFormatConfig {
+import { Capabilities, CombinedPointsConfig } from './machine/types';
+export interface MatchUpFormatConfig {
     labels?: {
         title?: string;
         setFormatLabel?: string;
@@ -22,6 +23,10 @@ interface MatchUpFormatConfig {
         starPoint?: string;
         games?: string;
         points?: string;
+        /** Shown when a format cannot be edited here and will be returned unchanged. */
+        readOnly?: string;
+        /** The match-level time limit control. */
+        maxTime?: string;
         descriptors?: {
             bestOf?: string;
             exactly?: string;
@@ -48,15 +53,27 @@ interface MatchUpFormatConfig {
         matchRoots?: string[];
         gameFormats?: string[];
         modifiers?: string[];
+        /** Outs per side offered for an outs set. */
+        outs?: number[];
+        /** Minutes offered for the match-level time limit. */
+        maxMinutes?: number[];
+        /** Totals offered for a points total (`SET1-S:P32`). */
+        combinedPointTotals?: number[];
     };
+    /** A policy's permitted points totals and tie rules. Narrows what is offered; the engine still validates. */
+    combinedPoints?: CombinedPointsConfig;
+    /** Switch parts of the picker off. Everything is on unless set to false. */
+    capabilities?: Capabilities;
     preDefinedFormats?: Array<{
         code: string;
         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;
 }): {
@@ -82,4 +99,3 @@ export declare function getMatchUpFormatModal({ existingMatchUpFormat, callback,
         label?: string;
     }) => void;
 };
-export {};

package/dist/components/schedule-page/controller/schedulePageControl.d.ts

@@ -11,6 +11,8 @@ export declare class SchedulePageControl {
     setMatchUpCatalog(catalog: CatalogMatchUpItem[]): void;
     setScheduleDates(dates: ScheduleDate[]): void;
     setIssues(issues: ScheduleIssue[]): void;
+    /** Push several of the above and render once: `control.batch(() => { … })`. */
+    batch(writes: () => void): void;
     setActiveStripVisible(visible: boolean): void;
     toggleActiveStrip(): void;
     get activeStripVisible(): boolean;

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

@@ -18,8 +18,8 @@ export declare function participantLabel(side?: MatchUpSide): string;
  * 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).
+ * the ecosystem's DOM layer is Storybook play functions in a browser (`pnpm test:stories`), and a
+ * pure function needs no browser to be checked.
  */
 export declare function memberNamesLabel(side?: MatchUpSide | ScheduleCellSide): string;
 export declare function matchUpSearchKey(item: CatalogMatchUpItem): string;

package/dist/components/schedule-page/engine/schedulePageStore.d.ts

@@ -3,6 +3,9 @@ export declare class SchedulePageStore {
     private state;
     private readonly listeners;
     private readonly config;
+    /** `batch` nesting, and whether a write inside it is waiting to be announced. */
+    private batchDepth;
+    private emitDeferred;
     constructor(config: SchedulePageConfig);
     getState(): SchedulePageState;
     setMatchUpCatalog(catalog: CatalogMatchUpItem[]): void;
@@ -43,5 +46,11 @@ export declare class SchedulePageStore {
     toggleInspector(): void;
     subscribe(listener: SchedulePageChangeListener): () => void;
     private setState;
+    /**
+     * Run several writes and notify listeners once, after the last. A consumer's refresh pushes the
+     * catalog, the dates and the issues together; written one by one, each push rebuilt every panel.
+     * Nested batches notify when the outermost one ends.
+     */
+    batch(writes: () => void): void;
     private emit;
 }

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,22 @@ export type ScoreEntryCardParams = {
     initialState?: ScoreEntryState;
     onClear?: () => void;
     onSubmit?: (outcome: ScoreEntryOutcome) => void;
-    onClose?: () => void;
+    /**
+     * Whether a recorded outcome may be REMOVED. Only the draw knows whether a later match depends on the
+     * result, so the host reads it from the engine (the factory's `CLEAR_SCORE` matchUp action) rather than
+     * the dialog guessing. `false` disables `[Clear]` on a reopened result and says why in its
+     * tooltip (`labels.clearRefused`), so the dialog never offers a
+     * submission the engine will refuse. Omitted, `[Clear]` behaves as it always has.
+     */
+    clearable?: boolean;
 };
 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/scoring/types.d.ts

@@ -67,6 +67,13 @@ export type ScoringModalParams = {
      * with no governing-body policy attached.
      */
     matchUpStatusCodes?: StatusCodeGroups;
+    /**
+     * Whether a recorded outcome may be REMOVED. Only the draw knows whether a later match depends on the
+     * result, so the host reads it from the engine (the factory's `CLEAR_SCORE` matchUp action) rather than
+     * the dialog guessing. `false` withholds `[Clear]` on a reopened result, so the dialog never offers a
+     * submission the engine will refuse. Omitted, `[Clear]` behaves as it always has.
+     */
+    clearable?: boolean;
 };
 export type ScoreChangeHandler = (outcome: ScoreOutcome) => void;
 export type RenderScoreEntryParams = {

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: {