@kromatv/sdk 0.1.39-canary.3579809

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

@@ -0,0 +1,13 @@
+import { type Ref } from 'react';
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import type { AudioFilterMode } from '#ui/components/organisms/player/types';
+interface AudioFilterPanelProps {
+    value: AudioFilterMode;
+    onSelect: (mode: AudioFilterMode) => void;
+    onBack: () => void;
+    ref?: Ref<PanelHandle>;
+}
+/** Volume-normalizer picker (§7): Off / Standard / Night, with a hint. Only
+ * mounted when the controller reports `audioFilterSupported`. */
+export declare function AudioFilterPanel({ value, onSelect, onBack, ref, }: Readonly<AudioFilterPanelProps>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+import { type Ref } from 'react';
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import type { PlayerAudioTrack } from '../../../media-types';
+interface AudioPanelProps {
+    tracks: PlayerAudioTrack[];
+    current: number;
+    onSelect: (index: number) => void;
+    onBack: () => void;
+    ref?: Ref<PanelHandle>;
+}
+/** Audio-track picker (§5). */
+export declare function AudioPanel({ tracks, current, onSelect, onBack, ref }: Readonly<AudioPanelProps>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+import type { ControlId } from '#ui/components/organisms/player/lib/nav';
+import type { PlayerController } from '#ui/components/organisms/player/types';
+import type { useT } from '#ui/services/i18n';
+type T = ReturnType<typeof useT>;
+/** The sub-views the menu can open. `menu` is the list itself; the toggles
+ *  (statistics) act in place and never become a view. */
+export type View = 'menu' | 'quality' | 'engine' | 'audio' | 'audioFilter' | 'subtitles' | 'appearance' | 'speed' | 'report';
+/** One main-menu row: a sub-view to open, a switch to flip, or a control the
+ *  transport row could not fit. */
+export interface Entry {
+    id: View | 'stats' | ControlId;
+    icon: ReactNode;
+    label: string;
+    value?: ReactNode;
+    toggle?: boolean;
+    on?: boolean;
+    activate: () => void;
+}
+/** The controls the transport row had no room for. Volume is a toggle because
+ *  that is what activating it does (mute), not a sub-view. */
+export declare function movedEntries(t: T, ids: readonly ControlId[], at: Readonly<{
+    muted: boolean;
+    onControl?: (id: ControlId) => void;
+}>): Entry[];
+/** Every setting the panel offers, in the order it is read. */
+export declare function menuEntries(t: T, c: PlayerController, at: Readonly<{
+    statsOn: boolean;
+    onToggleStats: () => void;
+    canReport: boolean;
+    go: (view: View) => void;
+}>): Entry[];
+/** The panel's title: the menu's own, or the row that opened the sub-view. */
+export declare function panelTitle(view: View, entries: readonly Entry[], t: T): string;
+export {};

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

@@ -0,0 +1,24 @@
+import type { PlayerSubCapabilities, PlayerSubtitleGeneration } from '#ui/components/organisms/player/media-types';
+/** The request {@link GenerateWizard} emits; the platform adapter maps it to its own
+ * `subtitles.generate` call, so the shared chrome never imports an API client. */
+export interface SubtitleGenRequest {
+    mode: 'transcribe' | 'translate';
+    /** Spoken language to transcribe (transcribe mode). */
+    lang?: string;
+    /** Source subtitle track index (translate mode). */
+    sourceIndex?: number;
+    /** Whisper model tier (transcribe mode). */
+    quality?: 'fast' | 'balanced' | 'accurate';
+}
+/** Everything the Subtitles panel needs to drive generation, kept prop-driven so
+ * `@kromatv/ui` stays engine- and client-agnostic. */
+export interface SubtitleGenBundle {
+    canCreate: boolean;
+    caps: PlayerSubCapabilities | null;
+    /** Running and recently-finished generations. */
+    pending: PlayerSubtitleGeneration[];
+    onCancel: (id: string) => void;
+    onDelete: (subId: string) => void;
+    onStart: (req: SubtitleGenRequest) => void;
+}
+export type { PlayerSub } from '#ui/components/organisms/player/types';

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

@@ -0,0 +1,20 @@
+import { type Ref } from 'react';
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import type { PlayerSubCapabilities } from '#ui/components/organisms/player/media-types';
+import type { PlayerSub } from '#ui/components/organisms/player/types';
+import type { SubtitleGenRequest } from './gen';
+interface GenerateWizardProps {
+    caps: PlayerSubCapabilities | null;
+    sources: PlayerSub[];
+    onStart: (req: SubtitleGenRequest) => void;
+    onClose: () => void;
+    ref?: Ref<PanelHandle>;
+}
+/**
+ * The on-device subtitle-generation form (§5), prop-driven so @kromatv/ui stays
+ * client-agnostic. Mode tabs pick transcribe (Whisper) / translate (LLM); ▲▼ move
+ * between cycle fields, ◀▶ change the focused field, OK on the last row emits a
+ * {@link SubtitleGenRequest} and closes. Modes are gated by `caps`.
+ */
+export declare function GenerateWizard({ caps, sources, onStart, onClose, ref, }: Readonly<GenerateWizardProps>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import type { Entry } from './entries';
+export declare function MenuList({ entries, moved, focused, onFocus, px, }: Readonly<{
+    entries: readonly Entry[];
+    moved: number;
+    focused: number;
+    onFocus: (index: number) => () => void;
+    /** The chrome's scaler (see ../../lib/metrics). */
+    px: (n: number) => number;
+}>): import("react").JSX.Element;

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

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import { type ViewStyle } from 'react-native';
+export declare function MenuRow({ icon, label, value, toggle, on, focused, style, onActivate, onFocus, }: Readonly<{
+    icon: ReactNode;
+    label: string;
+    value?: ReactNode;
+    toggle?: boolean;
+    on?: boolean;
+    focused: boolean;
+    /** Placement only (the menu uses it to open a gap between two groups of
+     *  rows). The row's own look stays here. */
+    style?: ViewStyle;
+    onActivate: () => void;
+    onFocus: () => void;
+}>): import("react").JSX.Element;

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

@@ -0,0 +1,99 @@
+/**
+ * Shared style atoms for the settings sub-panels.
+ *
+ * Focus is state-driven: a row picks its `*On` / `*Off` style from a boolean,
+ * never from CSS `:hover` or `:focus`.
+ *
+ * The `On` styles carry the lift as well as the ring, the same step <Focusable>
+ * takes: the ring stands off the row and the row below it, drawn later, would
+ * otherwise paint over that side of it.
+ *
+ * One live set rather than a constant per name: `styles()` re-resolves against
+ * the active theme, so the focus ring and the inks follow a swap. A bag of
+ * module constants would keep the palette of module-load time.
+ */
+import type { ViewStyle } from 'react-native';
+export declare const panel: import("../../../../../../core/styles").Styles<{
+    readonly panelList: {
+        readonly gap: 10;
+    };
+    readonly selectRow: {
+        readonly w: '100%';
+        readonly row: true;
+        readonly align: 'center';
+        readonly radius: 'xl';
+        readonly px: 22;
+        readonly py: 18;
+        readonly gap: 16;
+    };
+    readonly selectLabel: {
+        readonly text: "labelTv";
+        readonly color: "text";
+    };
+    readonly selectSub: {
+        readonly text: "metaTv";
+        readonly mt: 2;
+        readonly color: "text/50";
+    };
+    readonly menuRow: {
+        readonly w: '100%';
+        readonly row: true;
+        readonly align: 'center';
+        readonly radius: 'xl';
+        readonly px: 22;
+        readonly py: 18;
+        readonly gap: 18;
+    };
+    readonly menuLabel: {
+        readonly text: "strongTv";
+        readonly color: "text";
+    };
+    readonly menuValue: {
+        readonly text: "metaTv";
+        readonly mt: 2;
+        readonly color: "text/50";
+    };
+    readonly valueRow: {
+        readonly radius: "xl";
+        readonly px: 22;
+        readonly py: 16;
+    };
+    readonly valueRowOn: {
+        readonly bg: "tint/8";
+        readonly ring: "focusLift";
+        readonly z: 1;
+    };
+    readonly valueLabel: {
+        readonly text: "sectionTv";
+        readonly color: "text";
+    };
+    readonly panelHint: {
+        readonly mt: 12;
+        readonly mx: 2;
+        readonly text: "captionTv";
+        readonly color: "text/50";
+    };
+    readonly panelEmpty: {
+        readonly px: 2;
+        readonly py: 4;
+        readonly text: "captionTv";
+        readonly color: "textDim";
+    };
+    readonly rowOn: {
+        readonly bg: "tint/10";
+        readonly ring: "focusLift";
+        readonly z: 1;
+    };
+    readonly rowOff: {
+        readonly bg: "transparent";
+    };
+    readonly pill: {
+        readonly radius: "sm";
+        readonly py: 9;
+        readonly bg: "tint/6";
+    };
+    readonly pillLabel: {
+        readonly text: "footnoteTv";
+    };
+}>;
+export declare const rowStyle: (base: ViewStyle, on: ViewStyle, focused: boolean) => ViewStyle[];

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

@@ -0,0 +1,18 @@
+import { type Ref } from 'react';
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import type { PlayerQuality } from '#ui/components/organisms/player/types';
+interface QualityPanelProps {
+    qualities: PlayerQuality[];
+    current: string;
+    onSelect: (id: string) => void;
+    /** Return to the settings menu (Back, or after a pick). */
+    onBack: () => void;
+    ref?: Ref<PanelHandle>;
+}
+/**
+ * Quality picker (§5). The server is remux-only, so this reflects the honest
+ * source ("Auto · <source>") rather than a fake ladder. Picking a quality selects
+ * it and returns to the menu.
+ */
+export declare function QualityPanel({ qualities, current, onSelect, onBack, ref, }: Readonly<QualityPanelProps>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { type Ref } from 'react';
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import type { PlayerReportCategory } from '../../../media-types';
+interface ReportPanelProps {
+    onReport: (category: PlayerReportCategory) => Promise<void>;
+    onBack: () => void;
+    ref?: Ref<PanelHandle>;
+}
+export declare function ReportPanel({ onReport, onBack, ref }: Readonly<ReportPanelProps>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+/**
+ * One row of a settings sub-list (Quality / Audio / Subtitles / Speed / audio
+ * filter): a label, an optional sub-line, an accent check when it is the current
+ * value, and an optional trailing control.
+ *
+ * Focus is the `focused` PROP, not CSS state: the panel's list navigation owns
+ * which row is current, and a pointer entering a row moves that selection
+ * exactly as the D-pad would (§15).
+ */
+export declare function SelectRow({ index, label, sub, selected, focused, onActivate, onFocus, leading, trailing, }: Readonly<{
+    index: number;
+    label: ReactNode;
+    sub?: ReactNode;
+    selected?: boolean;
+    focused: boolean;
+    onActivate: (index: number) => void;
+    onFocus: (index: number) => void;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+}>): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { type Ref } from 'react';
+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;
+    ref?: Ref<PanelHandle>;
+}
+/** Playback-speed picker (§5). `1` reads as "Normal"; others as "1.25×". */
+export declare function SpeedPanel({ rate, onSelect, onBack, ref }: Readonly<SpeedPanelProps>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+import type { Ref } from 'react';
+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 { PlayerReportCategory } from '../../../media-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: PlayerReportCategory) => Promise<void>;
+    onBack: () => void;
+    ref?: Ref<PanelHandle>;
+}
+export declare function SubView({ view, controller: c, appearance, onAppearanceChange, subtitleGen, onReport, onBack, ref, }: Readonly<SubViewProps>): import("react").JSX.Element | null;

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

@@ -0,0 +1,16 @@
+import { type Ref } from 'react';
+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;
+    ref?: Ref<PanelHandle>;
+}
+/**
+ * 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 function SubtitleAppearancePanel({ appearance, onAppearanceChange, onBack, ref, }: Readonly<SubtitleAppearancePanelProps>): import("react").JSX.Element;
+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,20 @@
+import { type Ref } from 'react';
+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;
+    ref?: Ref<PanelHandle>;
+}
+/**
+ * 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 function SubtitlesPanel({ subs, current, onSelect, gen, onBack, ref, }: Readonly<SubtitlesPanelProps>): import("react").JSX.Element;
+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,42 @@
+import { type Ref } from 'react';
+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 { PlayerReportCategory } from '../../media-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: PlayerReportCategory) => 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;
+    ref?: Ref<PanelHandle>;
+}
+export declare function SettingsPanel({ controller, appearance, onAppearanceChange, statsOn, onToggleStats, subtitleGen, onReport, overflow, onControl, width, covers, scale, initialView, shown, onClose, ref, }: Readonly<SettingsPanelProps>): import("react").JSX.Element;
+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,15 @@
+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 the spinner tells assistive tech it waits on; plain loading without it. */
+    reason?: 'loading' | 'buffering';
+}
+/** 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, reason }: 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/stage-flash/index.d.ts

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

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

@@ -0,0 +1,27 @@
+/** What a keyboard or remote shortcut just did to the film, for the stage to
+ *  echo: a seek burst adding up as the presses land, or the level a volume key
+ *  set. `null` once nothing is being shown. */
+export type StageFlash = {
+    kind: 'seek';
+    dir: -1 | 1;
+    deltaSec: number;
+} | {
+    kind: 'volume';
+    level: number;
+};
+export interface StageFlashProps {
+    flash: StageFlash | null;
+    /** 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): clear of the transport while the chrome is up, close to the edge
+     *  once it has gone. The same number the skip-intro pill takes. */
+    lift: number;
+}
+/**
+ * A transient pill low on the picture, just above the seek bar it describes:
+ * the seek so far with its direction, or the volume a key just set. It keeps
+ * out of the frame's middle, and draws the last flash while fading out so a
+ * run of taps reads as one label counting up.
+ */
+export declare function StageFlashView({ flash, scale, lift }: Readonly<StageFlashProps>): import("react").JSX.Element | null;

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';