courthive-components 1.10.1 → 3.0.0

package/dist/components/{temporal-grid/controller/temporalGridControl.d.ts → availability-grid/controller/availabilityGridControl.d.ts}

@@ -1,12 +1,12 @@
-import { temporal, TemporalEngine } from 'tods-competition-factory';
-import { TemporalViewState } from '../engine/viewState';
+import { availability, AvailabilityEngine } from 'tods-competition-factory';
+import { AvailabilityViewState } from '../engine/viewState';
 import { DEFAULT_COLOR_SCHEME, ResourceGroupingMode } from './viewProjections';
 import { BlockPopoverManager } from '../ui/blockPopover';
 import { CourtTimeline } from '../timeline/CourtTimeline';
-type BlockType = temporal.BlockType;
-type CourtRef = temporal.CourtRef;
-type DayId = temporal.DayId;
-export interface TemporalGridControlConfig {
+type BlockType = availability.BlockType;
+type CourtRef = availability.CourtRef;
+type DayId = availability.DayId;
+export interface AvailabilityGridControlConfig {
     /** Container element for the timeline */
     container: HTMLElement;
     /** Initial selected day */
@@ -35,8 +35,30 @@ export interface TemporalGridControlConfig {
     onBlocksChanged?: () => void;
     /** Callback when a day label is double-clicked (for navigating to 1-Day view) */
     onDayNavigate?: (day: string) => void;
+    /**
+     * Callback invoked when an action can't complete because of scheduling
+     * conflicts. The controller never opens a dialog itself — the consumer
+     * wires this hook to its own themed-toast / modal system. When omitted,
+     * conflicts are written to console.warn only (NEVER falls back to a
+     * native browser alert).
+     */
+    onConflict?: (conflicts: any[]) => void;
+    /**
+     * Optional callback rendered as a "Manage Registrations" menu item on
+     * the block popover for PRACTICE blocks. The argument carries the
+     * resolved block descriptor — consumers use it to open their practice-
+     * registration management surface (e.g. a cModal in TMX).
+     */
+    onManageRegistrations?: (args: {
+        blockId: string;
+        courtId: string;
+        venueId: string;
+        date: string;
+        startTime: string;
+        endTime: string;
+    }) => void;
 }
-export declare class TemporalGridControl {
+export declare class AvailabilityGridControl {
     private readonly engine;
     private timeline;
     private readonly config;
@@ -49,7 +71,7 @@ export declare class TemporalGridControl {
     private currentView;
     private selectedCourts;
     private visibleCourts;
-    constructor(engine: TemporalEngine, config: TemporalGridControlConfig);
+    constructor(engine: AvailabilityEngine, config: AvailabilityGridControlConfig);
     private initialize;
     /**
      * Ensure timeline exists. Defers creation to the next macro-task so the
@@ -123,15 +145,20 @@ export declare class TemporalGridControl {
      * toISOString() converts to UTC which shifts the time by the local offset.
      */
     private toLocalISO;
-    /** Show conflict dialog */
+    /**
+     * Surface scheduling conflicts to the consumer. We never open a dialog
+     * here — the consumer's `onConflict` hook routes them to whatever themed
+     * notification system the host app uses (TMX toast, AMS console modal,
+     * etc.). When no hook is wired, conflicts go to console.warn only.
+     */
     private showConflictDialog;
     /** Get timeline instance (for advanced usage) */
     getTimeline(): CourtTimeline | null;
     /** Get engine instance */
-    getEngine(): TemporalEngine;
+    getEngine(): AvailabilityEngine;
     /** Get view state (for external consumers to subscribe to view changes) */
-    getViewState(): TemporalViewState;
+    getViewState(): AvailabilityViewState;
 }
-/** Create a temporal grid controller */
-export declare function createTemporalGridControl(engine: TemporalEngine, config: TemporalGridControlConfig): TemporalGridControl;
+/** Create a availability grid controller */
+export declare function createAvailabilityGridControl(engine: AvailabilityEngine, config: AvailabilityGridControlConfig): AvailabilityGridControl;
 export {};

package/dist/components/{temporal-grid → availability-grid}/controller/viewProjections.d.ts

@@ -1,8 +1,8 @@
-import { temporal } from 'tods-competition-factory';
-type BlockType = temporal.BlockType;
-type CourtMeta = temporal.CourtMeta;
-type CourtRef = temporal.CourtRef;
-type VenueDayTimeline = temporal.VenueDayTimeline;
+import { availability } from 'tods-competition-factory';
+type BlockType = availability.BlockType;
+type CourtMeta = availability.CourtMeta;
+type CourtRef = availability.CourtRef;
+type VenueDayTimeline = availability.VenueDayTimeline;
 /**
  * Timeline Group (represents a court or facility group header)
  */

package/dist/components/{temporal-grid → availability-grid}/engine/viewState.d.ts

@@ -1,6 +1,6 @@
-import { temporal } from 'tods-competition-factory';
-type BlockType = temporal.BlockType;
-type DayId = temporal.DayId;
+import { availability } from 'tods-competition-factory';
+type BlockType = availability.BlockType;
+type DayId = availability.DayId;
 export interface ViewStateSnapshot {
     selectedDay: DayId | null;
     selectedVenue: string | null;
@@ -12,7 +12,7 @@ export interface ViewChangeEvent {
     payload: Partial<ViewStateSnapshot>;
 }
 export type ViewChangeListener = (event: ViewChangeEvent) => void;
-export declare class TemporalViewState {
+export declare class AvailabilityViewState {
     private selectedDay;
     private selectedVenue;
     private selectedCourt;

package/dist/components/{temporal-grid → availability-grid}/index.d.ts

@@ -1,14 +1,14 @@
 /**
- * Temporal Grid - Main Entry Point
+ * Availability Grid - Main Entry Point
  *
- * Engine modules re-exported from tods-competition-factory via `temporal` namespace.
+ * Engine modules re-exported from tods-competition-factory via `availability` namespace.
  * Controller, UI, and view state are local to courthive-components.
  */
-export { TemporalEngine, TemporalEngine as TemporalGridEngine, temporal } from 'tods-competition-factory';
-export { TemporalViewState, type ViewChangeEvent, type ViewChangeListener, type ViewStateSnapshot } from './engine/viewState';
-export { createTemporalGridControl, TemporalGridControl, type TemporalGridControlConfig } from './controller/temporalGridControl';
+export { AvailabilityEngine, AvailabilityEngine as AvailabilityGridEngine, availability } from 'tods-competition-factory';
+export { AvailabilityViewState, type ViewChangeEvent, type ViewChangeListener, type ViewStateSnapshot } from './engine/viewState';
+export { createAvailabilityGridControl, AvailabilityGridControl, type AvailabilityGridControlConfig } from './controller/availabilityGridControl';
 export { buildBlockEvents, buildCapacityVisualization, buildConflictEvents, buildEventsFromTimelines, buildVenueGroups, buildHiddenDates, buildResourcesFromTimelines, buildTimeSlotConfig, buildTimelineWindowConfig, DEFAULT_COLOR_SCHEME, filterEventsByTimeRange, filterResourcesByVenue, generateBlockPatternCSS, isBlockEvent, isConflictEvent, isSegmentEvent, parseBlockEventId, parseResourceId, sortResources, type BlockColorScheme, type CalendarEvent, type CalendarResource, type TimelineGroup, type TimelineItem, type ProjectionConfig, type ResourceGroupingMode } from './controller/viewProjections';
-export { createTemporalGrid, TemporalGrid, type TemporalGridCallbacks, type TemporalGridConfig, type TemporalGridLabels } from './ui/temporalGrid';
+export { createAvailabilityGrid, AvailabilityGrid, type AvailabilityGridCallbacks, type AvailabilityGridConfig, type AvailabilityGridLabels } from './ui/availabilityGrid';
 export { ModernTimePicker, showModernTimePicker, type TimePickerConfig } from './ui/modernTimePicker';
 export { createBlockPopoverManager, type BlockPopoverManager, type BlockPopoverOptions, type EngineBlockPopoverOptions } from './ui/blockPopover';
 export { buildStatsBar, type StatsBarUpdate } from './ui/statsBar';

package/dist/components/{temporal-grid → availability-grid}/timeline/types.d.ts

@@ -1,5 +1,5 @@
-import { temporal } from 'tods-competition-factory';
-type CourtRef = temporal.CourtRef;
+import { availability } from 'tods-competition-factory';
+type CourtRef = availability.CourtRef;
 export interface TimelineGroupData {
     id: string;
     content: string;

package/dist/components/{temporal-grid/ui/temporalGrid.d.ts → availability-grid/ui/availabilityGrid.d.ts}

@@ -1,11 +1,11 @@
-import { TemporalEngine, temporal } from 'tods-competition-factory';
-import { TemporalGridControl, TemporalGridControlConfig } from '../controller/temporalGridControl';
-type DayId = temporal.DayId;
+import { AvailabilityEngine, availability } from 'tods-competition-factory';
+import { AvailabilityGridControl, AvailabilityGridControlConfig } from '../controller/availabilityGridControl';
+type DayId = availability.DayId;
 /**
- * i18n labels for the temporal grid component.
+ * i18n labels for the availability grid component.
  * All fields are optional — English defaults are used when omitted.
  */
-export interface TemporalGridLabels {
+export interface AvailabilityGridLabels {
     view?: string;
     day1?: string;
     days3?: string;
@@ -19,13 +19,13 @@ export interface TemporalGridLabels {
     setDefaultAvailability?: string;
     saveToTournament?: string;
 }
-export interface TemporalGridCallbacks {
+export interface AvailabilityGridCallbacks {
     /**
      * Called when dirty state changes (blocks/availability modified vs initial)
      */
     onDirtyChange?: (isDirty: boolean) => void;
 }
-export interface TemporalGridConfig extends Partial<TemporalGridControlConfig>, TemporalGridCallbacks {
+export interface AvailabilityGridConfig extends Partial<AvailabilityGridControlConfig>, AvailabilityGridCallbacks {
     /**
      * Tournament record (TODS format)
      */
@@ -57,7 +57,7 @@ export interface TemporalGridConfig extends Partial<TemporalGridControlConfig>,
     /**
      * i18n labels
      */
-    labels?: TemporalGridLabels;
+    labels?: AvailabilityGridLabels;
     /**
      * Language code for datepicker localization (e.g. 'en', 'fr', 'de')
      */
@@ -75,7 +75,7 @@ export interface TemporalGridConfig extends Partial<TemporalGridControlConfig>,
      */
     onMutationsApplied?: (mutations: any[]) => void;
 }
-export declare class TemporalGrid {
+export declare class AvailabilityGrid {
     private engine;
     private control;
     private config;
@@ -89,7 +89,7 @@ export declare class TemporalGrid {
     private visibleCourts;
     private initialSnapshot;
     private isDirty;
-    constructor(config: TemporalGridConfig);
+    constructor(config: AvailabilityGridConfig);
     /**
      * Render the component into a container
      */
@@ -128,11 +128,11 @@ export declare class TemporalGrid {
     /**
      * Get the engine instance
      */
-    getEngine(): TemporalEngine;
+    getEngine(): AvailabilityEngine;
     /**
      * Get the controller instance
      */
-    getControl(): TemporalGridControl | null;
+    getControl(): AvailabilityGridControl | null;
     /**
      * Set the selected day
      */
@@ -143,7 +143,7 @@ export declare class TemporalGrid {
     refresh(): void;
 }
 /**
- * Create and render a temporal grid
+ * Create and render a availability grid
  */
-export declare function createTemporalGrid(config: TemporalGridConfig, container: HTMLElement): TemporalGrid;
+export declare function createAvailabilityGrid(config: AvailabilityGridConfig, container: HTMLElement): AvailabilityGrid;
 export {};

package/dist/components/{temporal-grid → availability-grid}/ui/blockPopover.d.ts

@@ -1,4 +1,4 @@
-import { TemporalEngine } from 'tods-competition-factory';
+import { AvailabilityEngine } from 'tods-competition-factory';
 export interface BlockPopoverOptions {
     itemId: string;
     blockTypes: Array<{
@@ -16,9 +16,24 @@ export interface BlockPopoverOptions {
 export interface EngineBlockPopoverOptions {
     itemId: string;
     blockId: string;
-    engine: TemporalEngine;
+    engine: AvailabilityEngine;
     day: string;
     onBlockChanged: () => void;
+    /**
+     * Optional callback rendered as a "Manage Registrations" menu item for
+     * PRACTICE blocks. Provides the resolved block descriptor (courtId, date,
+     * sub-window times) so the consumer can resolve to its bookingId without
+     * a round trip — the factory derives bookingId from `${courtId}-${date}-${startTime}`
+     * when the booking lacks an explicit one.
+     */
+    onManageRegistrations?: (args: {
+        blockId: string;
+        courtId: string;
+        venueId: string;
+        date: string;
+        startTime: string;
+        endTime: string;
+    }) => void;
 }
 export interface BlockPopoverManager {
     show(target: HTMLElement, options: BlockPopoverOptions): void;

package/dist/components/editor/notesEditor.d.ts

@@ -0,0 +1,13 @@
+import { Editor } from '@tiptap/core';
+export interface NotesEditorOptions {
+    initialHtml?: string;
+}
+export interface NotesEditorHandle {
+    toolbar: HTMLElement;
+    editorElement: HTMLElement;
+    editor: Editor | undefined;
+    getHtml(): string;
+    isEmpty(): boolean;
+    destroy(): void;
+}
+export declare function createNotesEditor(options?: NotesEditorOptions): NotesEditorHandle;

package/dist/components/hive-id-login/buildHiveIDLogin.d.ts

@@ -0,0 +1,4 @@
+import { HiveIDAuthenticatedDetail, HiveIDLoginConfig, HiveIDLoginShell } from './types';
+export declare function buildHiveIDLogin(config: HiveIDLoginConfig): HiveIDLoginShell;
+/** Magic-link consume helper for the courthive-public landing route. */
+export declare function completeMagicLink(cfsBaseUrl: string, code: string, fetchImpl?: typeof fetch): Promise<HiveIDAuthenticatedDetail>;

package/dist/components/hive-id-login/hiveIDClient.d.ts

@@ -0,0 +1,14 @@
+import { HiveIDClientError, MagicLinkConsumeRequest, MagicLinkConsumeResponse, MagicLinkRequest, MagicLinkResponse, SignupRequest, SignupResponse, VerifyExistingRequest, VerifyExistingResponse } from './types';
+type FetchLike = typeof fetch;
+export declare function signup(baseUrl: string, body: SignupRequest, fetchImpl?: FetchLike): Promise<SignupResponse>;
+export declare function verifyExisting(baseUrl: string, body: VerifyExistingRequest, fetchImpl?: FetchLike): Promise<VerifyExistingResponse>;
+export declare function requestMagicLink(baseUrl: string, body: MagicLinkRequest, fetchImpl?: FetchLike): Promise<MagicLinkResponse>;
+export declare function consumeMagicLink(baseUrl: string, body: MagicLinkConsumeRequest, fetchImpl?: FetchLike): Promise<MagicLinkConsumeResponse>;
+/**
+ * Helper: returns true when the error is a 409 with the existing-user
+ * redirect shape from CFS (`{ code: 'EXISTING_USER', ... }`). The
+ * component uses this to swap signup mode → verify-existing without
+ * re-typing the email.
+ */
+export declare function isExistingUserConflict(err: unknown): err is HiveIDClientError;
+export {};

package/dist/components/hive-id-login/index.d.ts

@@ -0,0 +1,3 @@
+export { buildHiveIDLogin, completeMagicLink } from './buildHiveIDLogin';
+export { consumeMagicLink, isExistingUserConflict, requestMagicLink, signup, verifyExisting } from './hiveIDClient';
+export type { CachedPersonFields, HiveIDAuthenticatedDetail, HiveIDClientError, HiveIDFederationId, HiveIDLoginConfig, HiveIDLoginShell, HiveIDMode, MagicLinkConsumeRequest, MagicLinkConsumeResponse, MagicLinkRequest, MagicLinkResponse, SignupCandidate, SignupRequest, SignupResolved, SignupResponse, VerifyExistingRequest, VerifyExistingResponse } from './types';

package/dist/components/hive-id-login/styles.d.ts

@@ -0,0 +1,16 @@
+export declare const hilContainerStyle: () => string;
+export declare const hilFormStyle: () => string;
+export declare const hilHeaderStyle: () => string;
+export declare const hilTitleStyle: () => string;
+export declare const hilTabsStyle: () => string;
+export declare const hilTabStyle: () => string;
+export declare const hilTabActiveStyle: () => string;
+export declare const hilFieldStyle: () => string;
+export declare const hilLabelStyle: () => string;
+export declare const hilInputStyle: () => string;
+export declare const hilRowStyle: () => string;
+export declare const hilSubmitStyle: () => string;
+export declare const hilMessageStyle: () => string;
+export declare const hilMessageErrorStyle: () => string;
+export declare const hilMessageSuccessStyle: () => string;
+export declare const hilSwitchModeStyle: () => string;

package/dist/components/hive-id-login/types.d.ts

@@ -0,0 +1,115 @@
+/**
+ * HiveID Login — types.
+ *
+ * Mirrors the response shapes from CFS `/auth/hiveid/*` (PR-G):
+ * - POST /auth/hiveid/signup
+ * - POST /auth/hiveid/verify-existing
+ * - POST /auth/hiveid/magic-link
+ * - POST /auth/hiveid/magic-link/consume
+ */
+export type HiveIDMode = 'signup' | 'login' | 'magic-link';
+export interface CachedPersonFields {
+    standardFamilyName: string | null;
+    standardGivenName: string | null;
+    birthDate: string | null;
+    sex: string | null;
+    nationalityCode: string | null;
+}
+export interface HiveIDFederationId {
+    provider: string;
+    externalId: string;
+}
+export interface HiveIDAuthenticatedDetail {
+    token: string;
+    refreshToken: string;
+    personId: string | null;
+    cached: CachedPersonFields;
+}
+export interface SignupRequest {
+    email: string;
+    firstName: string;
+    lastName: string;
+    federationIds?: HiveIDFederationId[];
+}
+export interface VerifyExistingRequest {
+    email: string;
+    password: string;
+}
+export interface MagicLinkRequest {
+    email: string;
+}
+export interface MagicLinkConsumeRequest {
+    code: string;
+}
+export interface SignupResolved {
+    status: 'created';
+    token: string;
+    refreshToken: string;
+    personId: string;
+    personRevision: number;
+    cached: CachedPersonFields;
+}
+export interface SignupCandidate {
+    status: 'candidate';
+    candidates: {
+        personId: string;
+        confidence: number;
+    }[];
+}
+export type SignupResponse = SignupResolved | SignupCandidate;
+export interface VerifyExistingResponse {
+    status: 'verified';
+    token: string;
+    refreshToken: string;
+    personId: string | null;
+    personRevision: number | null;
+    cached: CachedPersonFields | null;
+}
+export interface MagicLinkResponse {
+    ok: true;
+}
+export interface MagicLinkConsumeResponse {
+    status: 'authenticated';
+    token: string;
+    refreshToken: string;
+    personId: string | null;
+    personRevision: number | null;
+    cached: CachedPersonFields;
+}
+export interface HiveIDLoginConfig {
+    /** Which CFS instance to talk to (no trailing slash). */
+    cfsBaseUrl: string;
+    /** Starting mode. Defaults to 'signup'. The user can toggle inside the component. */
+    mode?: HiveIDMode;
+    /** Pre-fill email — useful when the consumer already knows the user. */
+    defaultEmail?: string;
+    /**
+     * Optional pre-existing federation IDs (e.g. a USTA id known to the
+     * consumer) appended to the signup resolve fragment to bump
+     * strong-match likelihood. Most callers leave this empty.
+     */
+    federationIds?: HiveIDFederationId[];
+    /** Optional fetch implementation (tests stub this). */
+    fetchImpl?: typeof fetch;
+}
+export interface HiveIDLoginShell {
+    /** Root DOM node — append to your container. */
+    root: HTMLElement;
+    /** Programmatically swap modes (signup ⇄ login ⇄ magic-link). */
+    setMode(mode: HiveIDMode): void;
+    /** Current mode. */
+    getMode(): HiveIDMode;
+    /** Convenience: subscribe to the success event without addEventListener. */
+    onAuthenticated(handler: (detail: HiveIDAuthenticatedDetail) => void): () => void;
+}
+export type HiveIDClientError = {
+    kind: 'http';
+    status: number;
+    body: any;
+} | {
+    kind: 'network';
+    cause: Error;
+} | {
+    kind: 'parse';
+    cause: Error;
+};

package/dist/components/interactive-scoring/types.d.ts

@@ -30,6 +30,14 @@ export interface InteractiveScoringShellConfig {
      * IndexedDB. If omitted, the shell starts at 0-0.
      */
     initialMatchUp?: MatchUp;
+    /**
+     * Hook to confirm a reset before the engine clears the matchUp. Return
+     * `true` to proceed, `false` to abort. Consumers wire this to whatever
+     * themed-modal primitive their app uses (e.g. cModal in
+     * courthive-public). When omitted, Reset fires immediately without any
+     * prompt — the shell NEVER falls back to a native browser dialog.
+     */
+    confirmReset?: () => boolean | Promise<boolean>;
 }
 /**
  * Detail payload for the `stateChanged` CustomEvent.

package/dist/components/modal/mockParticipants.d.ts

@@ -54,7 +54,7 @@ export interface MockParticipantsConfig {
  *
  * Features:
  * - Gender selection (Any/Male/Female)
- * - Participant count (8-256)
+ * - Participant count (8-128)
  * - Age range with automatic validation (ageMax >= ageMin)
  * - Number of countries to limit nationality diversity
  * - Optional WTN/UTR ratings

package/dist/components/renderStructure/renderStructureMinimap.d.ts

@@ -0,0 +1,7 @@
+import { MatchUp } from '../../types';
+export interface StructureMinimapOptions {
+    matchUps: MatchUp[];
+    width?: number;
+    quarterCount?: number;
+}
+export declare function buildStructureMinimap({ matchUps, width, quarterCount }: StructureMinimapOptions): HTMLDivElement | null;

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

@@ -13,7 +13,7 @@
  *
  *   - computeActiveStripDropTarget(grid, courtId, dragged)
  *       Picks a row when a matchUp is dropped onto a court's strip cell.
- *       It infers a "temporal floor" from the existing grid:
+ *       It infers a "scheduled floor" from the existing grid:
  *         (a) any row across all courts where the dragged matchUp's
  *             participants already appear — the dragged matchUp must land
  *             below those rows;

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

@@ -1,4 +1,15 @@
 import { CatalogMatchUpItem, CatalogFilters, MatchUpCatalogGroupBy, ScheduledBehavior } from '../types';
 export declare function isCompletedStatus(status?: string): boolean;
 export declare function filterMatchUpCatalog(catalog: CatalogMatchUpItem[], query: string, behavior?: ScheduledBehavior, filters?: CatalogFilters, showCompleted?: boolean): CatalogMatchUpItem[];
+/**
+ * For each event, returns the lowest `roundNumber` among items that are
+ * unscheduled and not completed. Drives the round-emphasis tier on each
+ * catalog card — offset 0 means "this round is what should be scheduled
+ * next within its event," offset >= 1 deemphasizes future rounds.
+ *
+ * Computed against the FULL catalog (not the filtered set) by the catalog
+ * widget's `update()` so a search / filter that narrows the visible items
+ * doesn't shift the priority assignment underneath the operator.
+ */
+export declare function computeBaseRoundByEvent(catalog: CatalogMatchUpItem[]): Map<string, number>;
 export declare function groupMatchUpCatalog(items: CatalogMatchUpItem[], mode: MatchUpCatalogGroupBy): Map<string, CatalogMatchUpItem[]>;

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

@@ -7,7 +7,7 @@ import { SchedulePageControl } from './controller/schedulePageControl';
  */
 export { SchedulePageControl } from './controller/schedulePageControl';
 export { SchedulePageStore } from './engine/schedulePageStore';
-export { filterMatchUpCatalog, groupMatchUpCatalog, isCompletedStatus } from './domain/matchUpCatalogProjections';
+export { filterMatchUpCatalog, groupMatchUpCatalog, computeBaseRoundByEvent, isCompletedStatus } from './domain/matchUpCatalogProjections';
 export { buildScheduleIssueIndex } from './domain/scheduleIssues';
 export { matchUpLabel, participantLabel, matchUpSearchKey, deepClone } from './domain/utils';
 export { computeActiveStrip, computeActiveStripCell, computeActiveStripDropTarget } from './domain/activeStrip';
@@ -20,7 +20,7 @@ export { buildScheduleInspectorPanel } from './ui/inspectorPanel';
 export { buildCourtGridSlot } from './ui/courtGridSlot';
 export { buildSchedulePageLayout } from './ui/schedulePageLayout';
 export { buildActiveStripPanel } from './ui/activeStrip';
-export type { ActiveStripPanel, ActiveStripPanelCallbacks, ActiveStripPanelData, ActiveStripPanelOptions, ActiveStripCourtMeta } from './ui/activeStrip';
+export type { ActiveStripPanel, ActiveStripPanelCallbacks, ActiveStripPanelData, ActiveStripPanelOptions, ActiveStripCourtMeta, ActiveStripCourtBlock } from './ui/activeStrip';
 export { buildScheduleGridCell, mapMatchUpToCellData, DEFAULT_SCHEDULE_CELL_CONFIG } from './ui/scheduleGridCell';
 export { activateScheduleCellTypeAhead } from './ui/scheduleCellTypeAhead';
 export type { ScheduleCellTypeAheadOptions } from './ui/scheduleCellTypeAhead';

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

@@ -17,6 +17,11 @@ export interface CatalogMatchUpItem {
     drawId: string;
     drawName?: string;
     structureId: string;
+    /** Draw stage — MAIN / CONSOLATION / PLAYOFF / QUALIFYING / ROUND_ROBIN /
+     *  etc. Rendered as a chip when present and not MAIN so a Quarterfinal in
+     *  the consolation bracket reads distinctly from a Quarterfinal in the
+     *  main draw of the same event. */
+    stage?: string;
     roundNumber: number;
     roundName?: string;
     matchUpFormat?: string;
@@ -244,5 +249,19 @@ export interface ScheduleCellData {
         bookingType?: string;
         rowCount?: number;
         notes?: string;
+        /**
+         * Participant labels to render below the booking type. Pre-formatted
+         * by the consumer so the cell stays display-only — e.g.
+         * `["Smith / Jones (14:00–14:30)", "Ortiz (14:30–15:00)"]`.
+         *
+         * NOTE: as of 2026-06-01 there is no expected consumer. The Now/Live
+         * strip uses a separate banner path (`ActiveStripCourtBlock.detail`),
+         * and PRACTICE bookings are time-windowed — they don't currently
+         * surface as grid cells, which have fixed row positions, not fixed
+         * times. The field is kept available for future use (e.g. if a
+         * tournament chooses to materialize PRACTICE bookings as cells) but
+         * no production callsite populates it today.
+         */
+        registrations?: string[];
     };
 }

package/dist/components/schedule-page/ui/activeStrip.d.ts

@@ -4,11 +4,34 @@ export interface ActiveStripCourtMeta {
     courtId: string;
     label: string;
 }
+/**
+ * Active availability block surfaced on a court for the current clock time.
+ * When present, the strip renders a labeled banner inside the court's cell
+ * (e.g. "PRACTICE 14:00–16:00") so the TD sees at a glance that the court
+ * has a non-matchUp time reservation in effect.
+ *
+ * The strip itself is data-driven and does NOT poll the clock; consumers
+ * are expected to refresh `ActiveStripPanelData` periodically (e.g. every
+ * 30s) with the blocks active at "now".
+ */
+export interface ActiveStripCourtBlock {
+    /** Block type label, used as the banner intent class (e.g. "PRACTICE", "MAINTENANCE"). */
+    type: string;
+    /** Banner text. Caller controls formatting — e.g. "PRACTICE 14:00–16:00". */
+    label: string;
+    /** Optional short note (block.reason, registrant name from a future practice-registration system, etc.). */
+    detail?: string;
+}
 export interface ActiveStripPanelData {
     /** Court columns, in display order. The strip computes one cell per column. */
     grid: ActiveStripGrid;
     /** Optional display labels per courtId. Falls back to courtId. */
     courts?: ActiveStripCourtMeta[];
+    /**
+     * Optional map of courtId → active availability block. When provided, the
+     * strip renders a colored banner inside the court's active cell.
+     */
+    courtBlocks?: Record<string, ActiveStripCourtBlock>;
     /**
      * CSS grid-template-columns applied to the strip root. When provided, the
      * strip lays out as `display: grid` with a leading spacer occupying the

package/dist/components/schedule-page/ui/matchUpCard.d.ts

@@ -7,5 +7,13 @@ export interface MatchUpCardOptions {
      *  (top-right) and suppress the standard time chip. Used by the schedule
      *  grid's Scheduled tab where the time is the card's primary signal. */
     prominentTime?: boolean;
+    /** Distance from the earliest unscheduled round within this card's event.
+     *  0 = this round is the next-to-schedule (highest emphasis on the title),
+     *  1 = one round behind, ≥ 2 = further out (lowest emphasis). Mapped to
+     *  `spl-card-title--round-current / next / later` classes so consumers can
+     *  re-theme via CSS without touching the JS. Omit to leave the title at
+     *  its default styling (used for non-catalog renders + scheduled / completed
+     *  cards where round priority is meaningless). */
+    roundOffset?: number;
 }
 export declare function buildMatchUpCard(item: CatalogMatchUpItem, callbacks: MatchUpCardCallbacks, options?: MatchUpCardOptions): HTMLElement;

package/dist/components/scheduling-profile/domain/validateProfile.d.ts

@@ -1,11 +1,12 @@
-import { SchedulingProfile, ValidationResult, TemporalAdapter, DependencyAdapter, FlattenedRound } from '../types';
+import { SchedulingProfile, ValidationResult, AvailabilityAdapter, DemandAdapter, DependencyAdapter, FlattenedRound } from '../types';
 export interface ValidateProfileParams {
     profile: SchedulingProfile;
-    temporal?: TemporalAdapter;
+    availability?: AvailabilityAdapter;
+    demand?: DemandAdapter;
     dependencies?: DependencyAdapter;
     venueOrder?: string[];
 }
-export declare function validateProfile({ profile, temporal, dependencies, venueOrder }: ValidateProfileParams): ValidationResult[];
+export declare function validateProfile({ profile, availability, demand, dependencies, venueOrder }: ValidateProfileParams): ValidationResult[];
 export declare function validateRoundPrecedenceLocal({ profile }: {
     profile: SchedulingProfile;
     venueOrder?: string[];

package/dist/components/scheduling-profile/index.d.ts

@@ -20,5 +20,5 @@ export { buildIssuesPanel } from './ui/issuesPanel';
 export { buildRoundCard } from './ui/roundCard';
 export { createCardPopoverManager } from './ui/cardPopover';
 export { buildSchedulingProfileLayout } from './ui/schedulingProfileLayout';
-export type { SchedulingProfile, ScheduleDay, VenueSchedule, RoundProfile, RoundSegment, VenueInfo, CatalogRoundItem, CatalogGroupBy, RoundKey, RoundLocator, DragPayload, CatalogDragPayload, PlannedDragPayload, DropTarget, DropResult, Severity, ValidationCode, FixActionKind, FixAction, ValidationResult, SeverityCounts, IssueIndex, ProfileStoreState, ProfileChangeListener, TemporalAdapter, DemandAdapter, DependencyAdapter, SchedulingProfileConfig, UIPanel, FlattenedRound, PlannedRoundBehavior } from './types';
+export type { SchedulingProfile, ScheduleDay, VenueSchedule, RoundProfile, RoundSegment, VenueInfo, CatalogRoundItem, CatalogGroupBy, RoundKey, RoundLocator, DragPayload, CatalogDragPayload, PlannedDragPayload, DropTarget, DropResult, Severity, ValidationCode, FixActionKind, FixAction, ValidationResult, SeverityCounts, IssueIndex, ProfileStoreState, ProfileChangeListener, AvailabilityAdapter, DemandAdapter, DependencyAdapter, SchedulingProfileConfig, UIPanel, FlattenedRound, PlannedRoundBehavior } from './types';
 export declare function createSchedulingProfile(config: SchedulingProfileConfig, container: HTMLElement): SchedulingProfileControl;