@kromatv/sdk 0.1.40-canary.0

package/types/ui/src/components/organisms/player/parts/settings-panel/settings/speed-panel.d.ts

@@ -0,0 +1,10 @@
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+export declare const RATES: readonly [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2];
+interface SpeedPanelProps {
+    rate: number;
+    onSelect: (rate: number) => void;
+    onBack: () => void;
+}
+/** Playback-speed picker (§5). `1` reads as "Normal"; others as "1.25×". */
+export declare const SpeedPanel: import("react").ForwardRefExoticComponent<SpeedPanelProps & import("react").RefAttributes<PanelHandle>>;
+export {};

package/types/ui/src/components/organisms/player/parts/settings-panel/settings/sub-view.d.ts

@@ -0,0 +1,16 @@
+import type { ReportCategory } from '@kroma/client/reports';
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import type { SubtitleAppearance } from '#ui/components/organisms/player/lib/subtitle-appearance';
+import type { PlayerController } from '#ui/components/organisms/player/types';
+import type { View } from './entries';
+import type { SubtitleGenBundle } from './gen';
+export interface SubViewProps {
+    view: View;
+    controller: PlayerController;
+    appearance: SubtitleAppearance;
+    onAppearanceChange: (p: Partial<SubtitleAppearance>) => void;
+    subtitleGen: SubtitleGenBundle;
+    onReport?: (category: ReportCategory) => Promise<void>;
+    onBack: () => void;
+}
+export declare const SubView: import("react").ForwardRefExoticComponent<SubViewProps & import("react").RefAttributes<PanelHandle>>;

package/types/ui/src/components/organisms/player/parts/settings-panel/settings/subtitle-appearance-panel.d.ts

@@ -0,0 +1,14 @@
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import { type SubtitleAppearance } from '#ui/components/organisms/player/lib/subtitle-appearance';
+interface SubtitleAppearancePanelProps {
+    appearance: SubtitleAppearance;
+    onAppearanceChange: (patch: Partial<SubtitleAppearance>) => void;
+    onBack: () => void;
+}
+/**
+ * A live preview above value rows for CEA-708's three layers: the text, the box
+ * behind it, and the window the block sits in. ▲▼ move between rows, ◀▶ change
+ * the focused row's value.
+ */
+export declare const SubtitleAppearancePanel: import("react").ForwardRefExoticComponent<SubtitleAppearancePanelProps & import("react").RefAttributes<PanelHandle>>;
+export {};

package/types/ui/src/components/organisms/player/parts/settings-panel/settings/subtitle-appearance-parts.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+export declare function AppearanceRow({ index, label, focused, onFocus, onNudge, children, }: Readonly<{
+    index: number;
+    label: string;
+    focused: boolean;
+    onFocus: (index: number) => void;
+    onNudge: (index: number, dir: -1 | 1) => void;
+    children: ReactNode;
+}>): import("react").JSX.Element;
+export declare function Choice({ label }: Readonly<{
+    label: string;
+}>): import("react").JSX.Element;
+export declare function Seg<V extends string>({ value, options, onPick, }: Readonly<{
+    value: V;
+    options: {
+        v: V;
+        label: string;
+    }[];
+    onPick: (v: V) => void;
+}>): import("react").JSX.Element;
+export declare function Swatches({ value, onPick, }: Readonly<{
+    value: string;
+    onPick: (color: string) => void;
+}>): import("react").JSX.Element;
+export declare function Meter({ value }: Readonly<{
+    value: number;
+}>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/settings-panel/settings/subtitles-panel.d.ts

@@ -0,0 +1,18 @@
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import type { PlayerSub } from '#ui/components/organisms/player/types';
+import type { SubtitleGenBundle } from './gen';
+interface SubtitlesPanelProps {
+    subs: PlayerSub[];
+    current: number | null;
+    onSelect: (index: number | null) => void;
+    gen: SubtitleGenBundle;
+    onBack: () => void;
+}
+/**
+ * Subtitle picker (§5): an "Off" row, the embedded / downloaded tracks (AI tracks
+ * carry a violet "IA" badge + a delete control), the live generation rows, and a
+ * "create missing" row (leading sparkle) that opens the {@link GenerateWizard}
+ * inline. Selecting a track returns to the menu; the wizard captures the D-pad.
+ */
+export declare const SubtitlesPanel: import("react").ForwardRefExoticComponent<SubtitlesPanelProps & import("react").RefAttributes<PanelHandle>>;
+export {};

package/types/ui/src/components/organisms/player/parts/settings-panel/settings/title-bar.d.ts

@@ -0,0 +1,9 @@
+export declare function TitleBar({ title, back, backFocused, onClose, px, }: Readonly<{
+    title: string;
+    /** Absent in the menu, which has nothing above it. */
+    back?: () => void;
+    backFocused: boolean;
+    /** Absent unless the panel covers the stage. */
+    onClose?: () => void;
+    px: (n: number) => number;
+}>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/settings-panel/settings/wizard-parts.d.ts

@@ -0,0 +1,8 @@
+export declare function CycleField({ label, value, focused, onFocus, onDec, onInc, }: Readonly<{
+    label: string;
+    value: string;
+    focused: boolean;
+    onFocus: () => void;
+    onDec: () => void;
+    onInc: () => void;
+}>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/settings-panel/settings-panel.d.ts

@@ -0,0 +1,40 @@
+import type { ReportCategory } from '@kroma/client/reports';
+import type { ControlId, PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import type { SubtitleAppearance } from '#ui/components/organisms/player/lib/subtitle-appearance';
+import type { PlayerController } from '#ui/components/organisms/player/types';
+import { type View } from './settings/entries';
+import type { SubtitleGenBundle } from './settings/gen';
+interface SettingsPanelProps {
+    controller: PlayerController;
+    /** Controls the transport row had no room for (see ../lib/metrics). The panel
+     *  grows a row for each, so a narrow window moves them here instead of losing
+     *  them. Empty on any stage wide enough for the whole row. */
+    overflow?: readonly ControlId[];
+    /** Run one of those controls. The player closes the panel first: pip, cast
+     *  and the next episode all change what is on screen behind it. */
+    onControl?: (id: ControlId) => void;
+    appearance: SubtitleAppearance;
+    onAppearanceChange: (p: Partial<SubtitleAppearance>) => void;
+    statsOn: boolean;
+    onToggleStats: () => void;
+    subtitleGen: SubtitleGenBundle;
+    /** Report a problem with what is playing. The menu grows the row only when the
+     *  host provides this, so a surface with its own reporting flow (or none) is
+     *  unaffected. */
+    onReport?: (category: ReportCategory) => Promise<void>;
+    /** The panel's width in px, from `panelGeometry` - the whole stage once a 44%
+     *  panel would be too narrow to read. */
+    width?: number;
+    /** The panel covers the stage, so there is no scrim left to tap. */
+    covers?: boolean;
+    /** The chrome's scale (see ../lib/metrics). 1 on a television stage. */
+    scale?: number;
+    /** Open straight into a sub-view (the Audio / Subtitles cluster quick-access). */
+    initialView?: View;
+    /** False while the panel is leaving: it stays mounted for the exit, and the
+     *  picture expands from under it rather than from under nothing. */
+    shown?: boolean;
+    onClose: () => void;
+}
+export declare const SettingsPanel: import("react").ForwardRefExoticComponent<SettingsPanelProps & import("react").RefAttributes<PanelHandle>>;
+export {};

package/types/ui/src/components/organisms/player/parts/skip-intro-button/index.d.ts

@@ -0,0 +1 @@
+export * from './skip-intro-button';

package/types/ui/src/components/organisms/player/parts/skip-intro-button/skip-intro-button.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Skip-intro pill (§13): a bottom-right "Passer l'intro" button shown only
+ * during the detected intro window. Focus is state-driven (`focused` is ALWAYS
+ * passed, see ../lib/virtual-focus.ts): on focus the variant swaps from scrim to
+ * primary, giving the design's "amber when focused" without a bespoke control.
+ * Sits above the bottom chrome via `lift`, so the two never overlap.
+ */
+export interface SkipIntroButtonProps {
+    visible: boolean;
+    focused: boolean;
+    /** The chrome's scale (see ../lib/metrics). 1 on a television stage. */
+    scale?: number;
+    /**
+     * How high the pill sits above the bottom edge, in real pixels (already
+     * scaled). Passed in because what it must clear isn't constant: the transport
+     * resizes with the stage, and the up-next peek lifts it 150px further. A
+     * fixed value drew the pill through the seek bar in the other case.
+     */
+    lift: number;
+    onSkip: () => void;
+}
+export declare function SkipIntroButton({ visible, focused, scale, lift, onSkip, }: Readonly<SkipIntroButtonProps>): import("react").JSX.Element | null;

package/types/ui/src/components/organisms/player/parts/stage/index.d.ts

@@ -0,0 +1 @@
+export * from './stage';

package/types/ui/src/components/organisms/player/parts/stage/stage-overlay.d.ts

@@ -0,0 +1,13 @@
+interface StageOverlayProps {
+    /** Already-localized, and the reason the picture is not coming. Wins over
+     *  `waiting`: a title that has died is not still loading. */
+    error?: string | null;
+    /** The line under {@link error}, where there is something to do about it. */
+    hint?: string | null;
+    waiting?: boolean;
+}
+/** What covers the picture while there is none: the failure across the stage,
+ *  or the spinner. Nothing when the film is playing. */
+declare function StageOverlay({ error, hint, waiting }: Readonly<StageOverlayProps>): import("react").JSX.Element | null;
+export type { StageOverlayProps };
+export { StageOverlay };

package/types/ui/src/components/organisms/player/parts/stage/stage.d.ts

@@ -0,0 +1,30 @@
+import { type ReactNode } from 'react';
+import type { SubtitleAppearance } from '../../lib/subtitle-appearance';
+import type { PlayerController } from '../../types';
+interface StageProps {
+    controller: PlayerController;
+    /** The stage's measured size. Only ever read as a ratio, so the unit the
+     *  shell reports it in does not matter. */
+    stageSize: {
+        width: number;
+        height: number;
+    };
+    /** The picture is on the settings card. WHICH hold that takes is read off the
+     *  surface here (../../lib/surface-shrink), not decided by the caller. */
+    settingsShrink: boolean;
+    appearance: SubtitleAppearance;
+    raised: boolean;
+    locked: boolean;
+    onPress: () => void;
+    onLongPress: () => void;
+    children?: ReactNode;
+}
+declare function Stage({ controller: c, stageSize, settingsShrink, appearance, raised, locked, onPress, onLongPress, children, }: Readonly<StageProps>): import("react").JSX.Element;
+/** The picture box's DOM id: what web CSS sizes an in-page `<video>` through,
+ * and what a shell measures to place a native plane behind the page. */
+export declare const STAGE_ID = "kroma-player-stage";
+/** The picture's own box inside the stage: the card when the settings shrink
+ * it, the whole stage otherwise. What a shell that cuts a native plane into the
+ * page measures, since the plane has to sit exactly where the picture is. */
+export declare const PICTURE_ID = "kroma-player-picture";
+export { Stage };

package/types/ui/src/components/organisms/player/parts/stats-panel/index.d.ts

@@ -0,0 +1 @@
+export * from './stats-panel';

package/types/ui/src/components/organisms/player/parts/stats-panel/stats-chart.d.ts

@@ -0,0 +1,16 @@
+import type { PlayerMeter } from '#ui/components/organisms/player/types';
+export interface StatsChartProps {
+    /** Meters sharing this chart's axis, in draw order. */
+    meters: readonly PlayerMeter[];
+    /** Rolling sample history per meter key, oldest first. */
+    history: ReadonlyMap<string, number[]>;
+    /** Plot width. The panel gives the chart band its full inner width. */
+    width: number;
+    /** Palette offset, so slot assignment is stable across charts: the second
+     *  chart's first series is the palette's next colour, not its first. */
+    slot: number;
+}
+export declare function StatsChart({ meters, history, width, slot }: Readonly<StatsChartProps>): import("react").JSX.Element;
+/** Exported for the panel, which sizes its chart band to match. */
+export declare const STATS_CHART_HEIGHT = 44;
+export type { Extent } from '#ui/components/organisms/player/lib/chart-geometry';

package/types/ui/src/components/organisms/player/parts/stats-panel/stats-panel.d.ts

@@ -0,0 +1,14 @@
+import type { PlayerController } from '#ui/components/organisms/player/types';
+/**
+ * Discreet top-left "stats for nerds" overlay: what the stream actually is,
+ * versus what was asked for. Read-only, so it carries no D-pad focus beyond the
+ * close X.
+ */
+export declare function StatsPanel({ controller, onClose, top, left, width, maxHeight, }: Readonly<{
+    controller: Pick<PlayerController, 'getStats'>;
+    onClose: () => void;
+    top?: number;
+    left?: number;
+    width?: number;
+    maxHeight?: number;
+}>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/storyboard-thumb/index.d.ts

@@ -0,0 +1 @@
+export * from './storyboard-thumb';

package/types/ui/src/components/organisms/player/parts/storyboard-thumb/storyboard-thumb.d.ts

@@ -0,0 +1,4 @@
+import type { StoryboardTile } from '#ui/services/storyboard';
+export declare function StoryboardThumb({ tile }: Readonly<{
+    tile: StoryboardTile;
+}>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/subtitle-renderer/index.d.ts

@@ -0,0 +1 @@
+export * from './subtitle-renderer';

package/types/ui/src/components/organisms/player/parts/subtitle-renderer/subtitle-renderer.d.ts

@@ -0,0 +1,32 @@
+import { type SubtitleAppearance } from '#ui/components/organisms/player/lib/subtitle-appearance';
+import type { PlayerSub } from '#ui/components/organisms/player/types';
+interface SubtitleRendererProps {
+    /** Absolute playback position in seconds. */
+    positionSec: number;
+    playing: boolean;
+    /** Bumped on every seek so the renderer can re-sync its cue search. */
+    seekNonce?: number;
+    subtitles: PlayerSub[];
+    activeIndex: number | null;
+    appearance: SubtitleAppearance;
+    /** When true the controls are visible, so lift the caption above them. */
+    raised: boolean;
+    /** The active track's WebVTT could not be fetched, or held zero cues. The
+     *  HOST decides what that means (mark the picker row unavailable, fall back
+     *  to off) - a renderer that swallows the failure leaves a settings row that
+     *  silently does nothing, which reads as a broken app. */
+    onTrackFailed?: (index: number) => void;
+}
+/**
+ * One position-driven subtitle renderer for web AND TV. It fetches the active
+ * track's WebVTT itself (cross-origin `<track>` cues never load when the app and
+ * media server differ in origin), caches the parsed cues per url, and renders the
+ * cue that contains the current position. The position is interpolated locally
+ * while playing so coarse engine clocks (AVPlay/timeupdate) stay in sync.
+ */
+export declare function SubtitleRenderer({ positionSec, playing, seekNonce, subtitles, activeIndex, appearance, raised, onTrackFailed, }: Readonly<SubtitleRendererProps>): import("react").JSX.Element | null;
+/** The cue band's DOM id, present only while a cue is on screen. A shell drawing
+ * the picture on a plane behind the page measures it to keep the band out of the
+ * plane's way. */
+export declare const SUBTITLE_LAYER_ID = "kroma-player-subtitles";
+export {};

package/types/ui/src/components/organisms/player/parts/surface-radius.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from 'react';
+import type { Animated } from 'react-native';
+export type SurfaceRadius = number | Animated.AnimatedInterpolation<number>;
+export declare function SurfaceRadiusProvider({ radius, children, }: Readonly<{
+    radius: SurfaceRadius;
+    children: ReactNode;
+}>): import("react").JSX.Element;
+/** The radius the surface should round itself to; 0 when fullscreen. */
+export declare function useSurfaceRadius(): SurfaceRadius;

package/types/ui/src/components/organisms/player/parts/top-bar/index.d.ts

@@ -0,0 +1 @@
+export * from './top-bar';

package/types/ui/src/components/organisms/player/parts/top-bar/top-bar.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+/**
+ * Player top chrome (§ top chrome): a gradient bar holding the round back
+ * button, the title + subtitle, and an optional warning pill on the right (a
+ * transcode / unsupported-codec notice, say). Rendered over the video, so the
+ * bar itself is click-through and only the back button captures the pointer.
+ */
+export interface TopBarProps {
+    title: string;
+    subtitle?: string;
+    /** Pre-translated warning message, or null to hide the pill. */
+    warn?: string | null;
+    onBack: () => void;
+    /** Whether the nav machine currently rests on the back button. */
+    backFocused?: boolean;
+    /** Host-supplied controls for the right edge (the web's "play on TV"). The
+     * TV passes none: it is the screen things are cast TO. */
+    actions?: ReactNode;
+    /** The chrome's scale (see ../lib/metrics). 1 on a television stage. */
+    scale?: number;
+}
+/** Memoized: its props never change on a playback tick, so the bar skips the
+ * ~4 Hz timeupdate re-renders of the surrounding chrome. */
+export declare const TopBar: import("react").MemoExoticComponent<({ title, subtitle, warn, onBack, backFocused, actions, scale, }: Readonly<TopBarProps>) => import("react").JSX.Element>;

package/types/ui/src/components/organisms/player/parts/transport/index.d.ts

@@ -0,0 +1 @@
+export * from './transport';

package/types/ui/src/components/organisms/player/parts/transport/transport.d.ts

@@ -0,0 +1,19 @@
+import type { LayoutChangeEvent } from 'react-native';
+import type { StoryboardTile } from '#ui/services/storyboard';
+import type { usePlayerNav } from '../../hooks/use-player-nav';
+import { type ChromeMetrics } from '../../lib/metrics';
+import type { Chapter, PlayerController } from '../../types';
+interface TransportProps {
+    controller: PlayerController;
+    chapters?: Chapter[];
+    tileAt: (sec: number) => StoryboardTile | null;
+    metrics: ChromeMetrics;
+    nav: ReturnType<typeof usePlayerNav>;
+    chromeShown: boolean;
+    /** The padding the up-next peek claims under the controls, in real pixels: it
+     *  is the sheet's own height and is never scaled. */
+    bottomInset: number;
+    onLayout: (event: LayoutChangeEvent) => void;
+}
+declare function Transport({ controller: c, chapters: rawChapters, tileAt, metrics, nav, chromeShown, bottomInset, onLayout, }: Readonly<TransportProps>): import("react").JSX.Element;
+export { Transport };

package/types/ui/src/components/organisms/player/parts/up-next-card/index.d.ts

@@ -0,0 +1 @@
+export * from './up-next-card';

package/types/ui/src/components/organisms/player/parts/up-next-card/up-next-card.d.ts

@@ -0,0 +1,37 @@
+import { type DimensionValue } from 'react-native';
+export interface UpNextItem {
+    id: string;
+    title: string;
+    subtitle?: string;
+    posterUrl?: string | null;
+    categoryLabel?: string;
+}
+export interface UpNextCardProps {
+    item: UpNextItem;
+    /** Handed the card's `item`, so one handler serves the whole sheet rather
+     *  than a closure per card. */
+    onActivate: (item: UpNextItem) => void;
+    /** The first card of an opening sheet takes the focus. */
+    autoFocus?: boolean;
+    /** False for the parked PEEK, which is a picture of the sheet rather than the
+     *  sheet: its cards must not be reachable while the remote drives the chrome. */
+    interactive?: boolean;
+    width?: DimensionValue;
+}
+export declare const UP_NEXT_COLUMNS = 3;
+export declare const UP_NEXT_GAP = 26;
+/** The width a card is actually DRAWN at, three across a 1920 stage once the
+ * sheet's padding and gaps are taken out - and so the width its artwork should
+ * be requested at. The hooks used to ask for no width at all, which serves the
+ * original: three full-size stills arrive and the rest of the sheet is still
+ * downloading, which on a television looks exactly like art that never loads. */
+export declare const UP_NEXT_ART_W: number;
+/**
+ * One card of the up-next sheet: a still with its caption on it.
+ *
+ * The card is a <Focusable>, so the ring, the lift over its neighbours and the
+ * scroll that brings it into view are the kit's, the same ones every tile in the
+ * product uses - the sheet used to run its own index, its own ring and its own
+ * scrolling, and each of the three drifted from the kit in its own way.
+ */
+export declare function UpNextCard({ item, onActivate, autoFocus, interactive, width, }: Readonly<UpNextCardProps>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/up-next-sheet/index.d.ts

@@ -0,0 +1 @@
+export * from './up-next-sheet';

package/types/ui/src/components/organisms/player/parts/up-next-sheet/slide.d.ts

@@ -0,0 +1,5 @@
+import { type StyleProp, type ViewStyle } from 'react-native';
+/** The sheet's transform: home when `open`, parked `by` pixels down the screen
+ * when not. The result belongs on an `Animated.View`: it carries an
+ * `Animated.Value`. */
+export declare function useSheetSlide(open: boolean, by: number): StyleProp<ViewStyle>;

package/types/ui/src/components/organisms/player/parts/up-next-sheet/slide.web.d.ts

@@ -0,0 +1,5 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+/** The sheet's transform: home when `open`, parked `by` pixels down the screen
+ * when not. Plain styles, so it rides on the `Animated.View` the native half
+ * needs. */
+export declare function useSheetSlide(open: boolean, by: number): StyleProp<ViewStyle>;

package/types/ui/src/components/organisms/player/parts/up-next-sheet/up-next-sheet.d.ts

@@ -0,0 +1,17 @@
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import { type UpNextItem } from '#ui/components/organisms/player/parts/up-next-card';
+export type { UpNextItem };
+export interface UpNextData {
+    nextEpisodes: UpNextItem[];
+    recommendations: UpNextItem[];
+}
+export interface UpNextSheetProps {
+    data: UpNextData;
+    open: boolean;
+    revealed: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    onPlay: (item: UpNextItem) => void;
+}
+export declare const PEEK_HEIGHT = 150;
+export declare const UpNextSheet: import("react").NamedExoticComponent<UpNextSheetProps & import("react").RefAttributes<PanelHandle>>;

package/types/ui/src/components/organisms/player/player-chrome-state.d.ts

@@ -0,0 +1,11 @@
+import type { usePlayerNav } from './hooks/use-player-nav';
+import type { UpNextData } from './parts/up-next-sheet';
+declare function initialSettingsView(overlay: string | null): 'audio' | 'subtitles' | 'menu';
+declare function deriveChrome(nav: ReturnType<typeof usePlayerNav>, upNext: UpNextData, panelCovers: boolean, over?: boolean): {
+    settingsOpen: boolean;
+    sheetOpen: boolean;
+    settingsShrink: boolean;
+    peekVisible: boolean;
+    chromeShown: boolean;
+};
+export { deriveChrome, initialSettingsView };

package/types/ui/src/components/organisms/player/player-input.d.ts

@@ -0,0 +1,16 @@
+import type { RemoteKey } from '@kroma/core';
+import type { Dispatch, SetStateAction } from 'react';
+import type { usePlayerNav } from './hooks/use-player-nav';
+import type { PlayerController, PlayerFlags } from './types';
+declare function handleCreditsKey(key: RemoteKey, focus: 'play' | 'cancel', setFocus: Dispatch<SetStateAction<'play' | 'cancel'>>, onPlay: () => void, onCancel: () => void): boolean;
+declare function handlePostPlayKey(key: RemoteKey, focus: 'play' | 'home', setFocus: Dispatch<SetStateAction<'play' | 'home'>>, onPlay: () => void, onHome: () => void): void;
+declare function playerInputHandlers(nav: ReturnType<typeof usePlayerNav>, c: PlayerController, flags: PlayerFlags, locked: boolean): {
+    onPointerMove: (e: {
+        nativeEvent?: {
+            pointerType?: string;
+        };
+    }) => void;
+    onStagePress: () => void;
+    onStageLongPress: () => void;
+};
+export { handleCreditsKey, handlePostPlayKey, playerInputHandlers };

package/types/ui/src/components/organisms/player/player-parts.d.ts

@@ -0,0 +1,34 @@
+import { type ReactNode } from 'react';
+declare const PlayerSlotContext: import("react").Context<boolean>;
+interface PlayerMediaProps {
+    /** The surface the controller drives: an in-page `<video>`, or the placeholder
+     *  a native plane draws behind. It rounds ITSELF (see `useSurfaceRadius`); a
+     *  rounded parent does not clip a hardware video layer. */
+    children: ReactNode;
+}
+/** The picture, under the whole chrome. */
+declare function Media({ children }: Readonly<PlayerMediaProps>): import("react").JSX.Element;
+interface PlayerActionsProps {
+    children: ReactNode;
+}
+/** The host's own controls, at the end of the top bar beside the warning pill
+ *  (the web's "play on TV"). A television passes none: it is the screen a film
+ *  is cast TO. */
+declare function Actions({ children }: Readonly<PlayerActionsProps>): import("react").JSX.Element;
+interface PlayerPanelProps {
+    children: ReactNode;
+}
+/** A region that takes the stage over: the "an admin stopped this" notice. While
+ *  one is mounted the chrome is locked: the picture stops taking presses, the
+ *  buffering spinner stays down, and only Back / OK get through, both meaning
+ *  leave. */
+declare function Panel({ children }: Readonly<PlayerPanelProps>): import("react").JSX.Element;
+interface PlayerSlots {
+    media: ReactNode;
+    actions: ReactNode;
+    panel: ReactNode;
+    rest: ReactNode[];
+}
+declare function sortSlots(children: ReactNode): PlayerSlots;
+export type { PlayerActionsProps, PlayerMediaProps, PlayerPanelProps };
+export { Actions, Media, Panel, PlayerSlotContext, sortSlots };

package/types/ui/src/components/organisms/player/player.d.ts

@@ -0,0 +1,63 @@
+import type { Marker } from '@kroma/client/media';
+import type { ReportCategory } from '@kroma/client/reports';
+import { type ReactNode } from 'react';
+import type { View } from 'react-native';
+import type { StoryboardTile } from '#ui/services/storyboard';
+import type { SubtitleAppearance } from './lib/subtitle-appearance';
+import { type CreditsCardItem } from './parts/credits-card';
+import { type PostPlayItem } from './parts/post-play';
+import type { SubtitleGenBundle } from './parts/settings-panel/settings/gen';
+import { type UpNextData, type UpNextItem } from './parts/up-next-sheet';
+import { Actions, Media, Panel } from './player-parts';
+import type { Chapter, PlayerCloseDetails, PlayerController, PlayerFlags } from './types';
+export interface PlayerRootProps {
+    controller: PlayerController;
+    flags: PlayerFlags;
+    title: string;
+    subtitle?: string;
+    /** Pre-translated warning, drawn as a pill in the top bar; null to hide it. */
+    warn?: string | null;
+    chapters?: Chapter[];
+    markers?: readonly Marker[];
+    tileAt: (sec: number) => StoryboardTile | null;
+    appearance: SubtitleAppearance;
+    onAppearanceChange: (next: Partial<SubtitleAppearance>) => void;
+    subtitleGen: SubtitleGenBundle;
+    upNext: UpNextData;
+    onReport?: (category: ReportCategory) => Promise<void>;
+    onPlayItem?: (item: UpNextItem) => void;
+    /** Given one, the chrome grows a "next" control and plays the credits card. */
+    onPlayNext?: () => void;
+    nextTitle?: CreditsCardItem | null;
+    /** The film offered when this one ends with no next episode queued. Given
+     *  one, the end raises the full-screen post-play; with none the player
+     *  leaves instead of parking on a dead frame. */
+    postPlay?: PostPlayItem | null;
+    /** Where the post-play's second action goes. Falls back to {@link onClose}. */
+    onGoHome?: () => void;
+    /** Whether the film is inside its detected intro window. The skip pill is only
+     *  offered while this is true AND `onSkipIntro` is given. */
+    introActive?: boolean;
+    onSkipIntro?: () => void;
+    onCast?: () => void;
+    onClose: (details: PlayerCloseDetails) => void;
+    ref?: React.Ref<View>;
+    /** A <Player.Media>, then any of <Player.Actions> and <Player.Panel>. Only a
+     *  DIRECT child takes its slot; anything else is drawn over the chrome, in the
+     *  order it was written. */
+    children?: ReactNode;
+}
+/**
+ * The unified player chrome (§14): one component for web + TV. The platform
+ * provides a {@link PlayerController} and feature flags; nothing here talks to an
+ * engine directly. It owns the stage, so give it the whole screen and exactly
+ * one `<Player.Media>`.
+ */
+declare function Root({ controller: c, flags, title, subtitle, warn, chapters: rawChapters, markers, tileAt, appearance, onAppearanceChange, subtitleGen, upNext, onReport, onPlayItem, onPlayNext, nextTitle, postPlay, onGoHome, introActive, onSkipIntro, onCast, onClose, ref, children, }: Readonly<PlayerRootProps>): import("react").JSX.Element;
+declare const Player: {
+    Root: typeof Root;
+    Media: typeof Media;
+    Actions: typeof Actions;
+    Panel: typeof Panel;
+};
+export { Player };