@kromatv/sdk 0.1.39-canary.3579809

package/types/ui/src/components/organisms/perf-hud/perf-hud.d.ts

@@ -0,0 +1,5 @@
+declare function PerfHud({ enabled, artworkScale, }: Readonly<{
+    enabled: boolean;
+    artworkScale?: number;
+}>): import("react").JSX.Element | null;
+export { PerfHud };

package/types/ui/src/components/organisms/player/hooks/use-drag-track.d.ts

@@ -0,0 +1,22 @@
+import type { LayoutChangeEvent, View } from 'react-native';
+interface DragTrack {
+    /** Put on the track view, alongside `onLayout`. */
+    ref: React.RefObject<View | null>;
+    onLayout: (e: LayoutChangeEvent) => void;
+    /** Re-read the on-screen box. Call as a gesture begins: it is the last moment
+     *  before the number matters, and the stage may have been resized since. */
+    measure: () => void;
+    /** The track's width in canvas units, as state, for anything that renders. */
+    width: number;
+    /** A pointer's `locationX`, relative to the track, as an offset in canvas
+     *  units. Null until the track has been measured. */
+    offsetOf: (locationX: number) => number | null;
+}
+/**
+ * Every layer inside the track should be `pointerEvents: 'none'`, so the track is
+ * always the event's target and `locationX` is relative to the track itself
+ * rather than to whichever fill happened to be under the finger.
+ */
+declare function useDragTrack(): DragTrack;
+export type { DragTrack };
+export { useDragTrack };

package/types/ui/src/components/organisms/player/hooks/use-grid-focus.d.ts

@@ -0,0 +1,19 @@
+import type { RemoteKey } from '#ui/lib/remote-keys';
+export interface GridFocusOptions {
+    count: number;
+    cols: number;
+    initial?: number;
+    onActivate?: (index: number) => void;
+    onBack?: () => void;
+    onExit?: (edge: 'top' | 'bottom') => void;
+}
+export interface GridFocus {
+    index: number;
+    setIndex: (i: number) => void;
+    onKey: (key: RemoteKey) => boolean;
+    hover: (i: number) => () => void;
+    /** Bumps on every D-pad move but not on hover: scrolling the focused card into
+     *  view on hover would shift the layout under the cursor. */
+    keyNonce: number;
+}
+export declare function useGridFocus(opts: GridFocusOptions): GridFocus;

package/types/ui/src/components/organisms/player/hooks/use-idle-cursor.d.ts

@@ -0,0 +1,7 @@
+/** The player root's element id, which the idle-cursor rule hooks onto. */
+export declare const PLAYER_ROOT_ID = "kroma-player";
+/**
+ * Takes the pointer away while the chrome is away, and gives it back with it -
+ * what YouTube's `ytp-autohide` does. A no-op on a target with no document.
+ */
+export declare function useIdleCursor(hidden: boolean): void;

package/types/ui/src/components/organisms/player/hooks/use-list-focus.d.ts

@@ -0,0 +1,40 @@
+import type { RemoteKey } from '#ui/lib/remote-keys';
+/**
+ * Reusable 1-D focus for a list of controls, driving BOTH the D-pad and the
+ * mouse from one index. Every selection panel (Quality, Audio, Speed, Subtitles)
+ * and every "value row" surface (subtitle appearance, the AI-gen wizard) uses
+ * it, so the focus-ring behaviour is identical everywhere.
+ *
+ * - vertical   : ▲▼ move the row, ◀▶ call `onHorizontal` (value rows) or `onExit`.
+ * - horizontal : ◀▶ move, ▲▼ call `onExit`.
+ * `onKey` returns whether the key was consumed.
+ */
+export interface ListFocusOptions {
+    count: number;
+    orientation?: 'vertical' | 'horizontal';
+    initial?: number;
+    /** OK/Enter on the focused index. */
+    onActivate?: (index: number) => void;
+    /** Back / Escape (dismiss the surface). */
+    onBack?: () => void;
+    /** Moving off an edge: `before` = ▲/◀ past the first, `after` = ▼/▶ past the last. */
+    onExit?: (edge: 'before' | 'after') => void;
+    /** Cross-axis nudge (▲▼ list → ◀▶ adjusts the focused row's value). */
+    onHorizontal?: (index: number, dir: -1 | 1) => void;
+    /** A control ABOVE the list - the panel's Back button - reached by ▲ from the
+     *  first row, and run by OK there. Without it that button is pointer-only and
+     *  a remote cannot reach it at all. While it holds the focus, `index` is -1,
+     *  which is what the panel renders it lit from.
+     *
+     *  A list inside a <SettingsPanel> sub-view inherits this from the panel (see
+     *  lib/panel-header) and does not pass it. */
+    header?: () => void;
+}
+export interface ListFocus {
+    index: number;
+    setIndex: (i: number) => void;
+    onKey: (key: RemoteKey) => boolean;
+    /** Hover handler for row `i` (mouse moves focus, per §15). */
+    hover: (i: number) => () => void;
+}
+export declare function useListFocus(opts: ListFocusOptions): ListFocus;

package/types/ui/src/components/organisms/player/hooks/use-player-credits.d.ts

@@ -0,0 +1,22 @@
+import type { PlayerMarker } from '../media-types';
+export interface CreditsState {
+    show: boolean;
+    secondsLeft: number;
+    total: number;
+    cancel: () => void;
+}
+/**
+ * Credits-aware next-episode autoplay (§11). Shows the card once playback enters
+ * the `credits` marker (or the last {@link CREDITS_TAIL}s when unmarked), runs a
+ * fixed 5s countdown that advances at 0, and also advances on the real end. The
+ * countdown is frozen during a scrub, so seeking near the end never teleports.
+ */
+export declare function usePlayerCredits(opts: {
+    markers?: readonly PlayerMarker[];
+    dur: number;
+    cur: number;
+    seeking: boolean;
+    endedNonce: number;
+    hasNext: boolean;
+    onAdvance: () => void;
+}): CreditsState;

package/types/ui/src/components/organisms/player/hooks/use-player-ending.d.ts

@@ -0,0 +1,37 @@
+import type { PostPlayFocus, PostPlayItem } from '#ui/components/organisms/player/parts/post-play';
+import type { UpNextItem } from '#ui/components/organisms/player/parts/up-next-sheet';
+import type { PlayerController } from '#ui/components/organisms/player/types';
+import type { RemoteKey } from '#ui/lib/remote-keys';
+import type { PlayerMarker } from '../media-types';
+import { type CreditsState } from './use-player-credits';
+export interface PlayerEnding {
+    credits: CreditsState;
+    creditsFocus: 'play' | 'cancel';
+    onCreditsKey: (key: RemoteKey) => boolean;
+    /** Whether the end screen has the stage, which it only ever takes with a film
+     *  to offer on it. */
+    over: boolean;
+    postPlayFocus: PostPlayFocus;
+    onPostPlayKey: (key: RemoteKey) => void;
+    playOffer: () => void;
+    goHome: () => void;
+}
+/**
+ * Everything the player does as a film runs out (§10, §11), which is two
+ * mutually exclusive things: with an episode queued the credits card counts
+ * down to it, and with none the end raises the post-play screen or leaves.
+ * Both hang off the same `endedNonce`, which is why they are one hook.
+ */
+export declare function usePlayerEnding(opts: {
+    controller: PlayerController;
+    markers?: readonly PlayerMarker[];
+    postPlay?: PostPlayItem | null;
+    onPlayNext?: () => void;
+    onPlayItem?: (item: UpNextItem) => void;
+    onGoHome?: () => void;
+    /** Leave the player: the post-play's fallback home, and where an end with
+     *  nothing to offer goes. */
+    onLeave: () => void;
+    /** Called before the end screen rises, so it never covers an open panel. */
+    onClearOverlay: () => void;
+}): PlayerEnding;

package/types/ui/src/components/organisms/player/hooks/use-player-nav.d.ts

@@ -0,0 +1,69 @@
+import type { SeekPress } from '#ui/components/organisms/player/hooks/use-seek-nudge';
+import type { ControlId, Overlay, Zone } from '#ui/components/organisms/player/lib/nav';
+import type { PlayerCloseReason } from '#ui/components/organisms/player/types';
+import type { RemoteKey } from '#ui/lib/remote-keys';
+/** Actions the top-level machine invokes; the shell wires them to the controller. */
+export interface PlayerNavActions {
+    togglePlay(): void;
+    /** Directional seek, -1 = back / +1 = forward, from the progress zone or the
+     *  rewind/forward transport buttons. */
+    seekNudge(dir: -1 | 1, press: SeekPress): void;
+    onNext(): void;
+    hasNext: boolean;
+    sheetHasItems: boolean;
+    /** Volume ±5 % (§4b) when the volume control is focused. */
+    volumeNudge(dir: -1 | 1): void;
+    toggleMute(): void;
+    togglePip(): void;
+    toggleFullscreen(): void;
+    /** Hand this film to a TV. Only reachable when `flags.cast` is on, which the
+     *  host sets while a receiver is live. */
+    onCast?(): void;
+    /** The resumed-at prompt while it is up. Absent once it has gone, which is
+     *  also what takes its stop out of the chain. */
+    resume?: {
+        onStartOver(): void;
+        onFocus(): void;
+    };
+    /** Leave the player, told why: OK on the back button, Back at the top level,
+     *  or the Stop media key. */
+    onExit(reason: PlayerCloseReason): void;
+}
+export interface PlayerNav {
+    revealed: boolean;
+    zone: Zone;
+    overlay: Overlay;
+    controls: readonly ControlId[];
+    /** The focused control id, or null when the progress zone / a panel is active. */
+    focusedControl: ControlId | null;
+    /** Route a logical key. The shell calls this after giving any open panel first
+     *  refusal. */
+    handleKey(key: RemoteKey): void;
+    walkChrome(backwards: boolean): void;
+    /** Reveal the chrome + (re)arm the auto-hide timer (pointer move / any key). */
+    poke(): void;
+    /** Re-arm the auto-hide timer WITHOUT revealing the chrome. Used by immersive
+     *  media shortcuts so repeated arrow presses don't flash the UI. */
+    rearmHide(): void;
+    openOverlay(o: Exclude<Overlay, null>): void;
+    closeOverlay(): void;
+    /** Run a control's action (shared by mouse click and D-pad OK). */
+    activate(id: ControlId): void;
+    /** Mouse focus helpers (hover moves focus, §15). */
+    focusControl(id: ControlId): void;
+    focusProgress(): void;
+    /** Leave the player, told why, without going through the key chain. */
+    exit(reason: PlayerCloseReason): void;
+}
+/**
+ * The unified navigation state machine (§3): three-zone D-pad + pointer focus,
+ * feature-flag-aware control stops, "▲ from the progress bar hides the UI", and
+ * the auto-hiding chrome. It owns zone/overlay/focus; panels manage their own
+ * internal focus (see useListFocus / useGridFocus) and the shell routes keys to
+ * the open panel first.
+ *
+ * `controls` must be exactly the row as drawn (see ../lib/metrics
+ * `chromeMetrics`): the machine steps through only the controls on screen, so a
+ * shed control never keeps a focus stop nobody can see.
+ */
+export declare function usePlayerNav(playing: boolean, actions: PlayerNavActions, controls: readonly ControlId[]): PlayerNav;

package/types/ui/src/components/organisms/player/hooks/use-player-outro.d.ts

@@ -0,0 +1,14 @@
+/**
+ * What happens when a film reaches its end with nothing queued behind it (§10).
+ * A next episode is the credits countdown's business (see usePlayerCredits);
+ * this covers everything else, so the player never parks on a dead frame: it
+ * offers the next film to watch, and with none to offer it leaves.
+ */
+export declare function usePlayerOutro(opts: {
+    endedNonce: number;
+    hasNext: boolean;
+    /** Whether there is a film to offer. False leaves instead. */
+    canOffer: boolean;
+    onOffer: () => void;
+    onLeave: () => void;
+}): void;

package/types/ui/src/components/organisms/player/hooks/use-player-root.d.ts

@@ -0,0 +1,72 @@
+import { type ReactNode } from 'react';
+import { type LayoutChangeEvent } from 'react-native';
+import { type ControlId, type PanelHandle } from '../lib/nav';
+import { type UpNextData, type UpNextItem } from '../parts/up-next-sheet';
+import type { SubtitleGenBundle } from '../parts/settings-panel/settings/gen';
+import type { StageFlash } from '../parts/stage-flash';
+import type { PlayerController, PlayerFlags, PlayerCloseDetails } from '../types';
+interface UsePlayerRootArgs {
+    controller: PlayerController;
+    flags: PlayerFlags;
+    onCast?: () => void;
+    onClose: (details: PlayerCloseDetails) => void;
+    children?: ReactNode;
+}
+declare function usePlayerRoot({ controller, flags, onCast, onClose, children, }: Readonly<UsePlayerRootArgs>): {
+    c: PlayerController;
+    slots: import("../player-parts").PlayerSlots;
+    upNext: UpNextData;
+    nextTitle: import("..").CreditsCardItem | null;
+    onPlayNext: (() => void) | undefined;
+    postPlay: import("..").PostPlayItem | null;
+    appearance: import("..").SubtitleAppearance;
+    onAppearanceChange: (next: Partial<import("..").SubtitleAppearance>) => void;
+    subtitleGen: SubtitleGenBundle;
+    onReport: ((category: import("..").PlayerReportCategory) => Promise<void>) | undefined;
+    rawChapters: import("..").Chapter[] | undefined;
+    tileAt: (sec: number) => import("../../../..").StoryboardTile | null;
+    stageSize: {
+        width: number;
+        height: number;
+    };
+    onStageLayout: (e: LayoutChangeEvent) => void;
+    statsOn: boolean;
+    setStatsOn: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    panelRef: import("react").RefObject<PanelHandle | null>;
+    locked: boolean;
+    closeFromChrome: () => void;
+    notice: import("./use-resume-notice").ResumeNotice;
+    startOver: () => void;
+    intro: {
+        active: boolean;
+        onSkip: () => void;
+    } | undefined;
+    metrics: import("../lib/metrics").ChromeMetrics;
+    flash: StageFlash | null;
+    nav: import("./use-player-nav").PlayerNav;
+    credits: import("./use-player-credits").CreditsState;
+    ending: import("./use-player-ending").PlayerEnding;
+    input: {
+        onPointerMove: (e: {
+            nativeEvent?: {
+                pointerType?: string;
+            };
+        }) => void;
+        onStagePress: () => void;
+        onStageLongPress: () => void;
+    };
+    settingsShrink: boolean;
+    settings: import("../lib/panel-slide").PanelSlide;
+    initialView: "audio" | "menu" | "subtitles";
+    panel: import("../lib/metrics").PanelGeometry;
+    onTransportLayout: (e: LayoutChangeEvent) => void;
+    bottomInset: number;
+    introLift: number;
+    sheetOpen: boolean;
+    peekVisible: boolean;
+    chromeShown: boolean;
+    openSheet: () => void;
+    runOverflow: (id: ControlId) => void;
+    playUpNextItem: (item: UpNextItem) => void | undefined;
+};
+export { usePlayerRoot };

package/types/ui/src/components/organisms/player/hooks/use-resume-notice.d.ts

@@ -0,0 +1,20 @@
+export declare const RESUME_WINDOW = 6;
+export interface ResumeNotice {
+    shown: boolean;
+    /** Whole seconds before the prompt leaves on its own, null once it stopped counting. */
+    secondsLeft: number | null;
+    total: number;
+    dismiss: () => void;
+    holdOpen: () => void;
+}
+/**
+ * `at` is the second playback opened on; pass none where nothing was resumed. The
+ * window opens on the first moving picture rather than on the first frame asked
+ * for, so a slow stream does not spend it behind a spinner.
+ */
+export declare function useResumeNotice(opts: {
+    at?: number;
+    cur: number;
+    playing: boolean;
+    waiting: boolean;
+}): ResumeNotice;

package/types/ui/src/components/organisms/player/hooks/use-seek-nudge.d.ts

@@ -0,0 +1,24 @@
+import type { PlayerController } from '#ui/components/organisms/player/types';
+/** The seek in progress, for the stage to show: how far the presses so far have
+ *  moved the cursor from where the film was, signed against it. */
+export interface SeekBurst {
+    dir: -1 | 1;
+    deltaSec: number;
+}
+/**
+ * `tap` is exactly one step whatever came before it. `hold` is a press from
+ * something that auto-repeats, so a run of them close together becomes a scrub.
+ */
+export type SeekPress = 'tap' | 'hold';
+export interface SeekNudge {
+    /** The `seekNudge(dir, press)` the nav machine calls for ◀ / ▶ on the progress
+     *  bar, the rewind / forward transport buttons and the keyboard's arrows. */
+    nudge(dir: -1 | 1, press: SeekPress): void;
+    /** Live from the first press until the coalesced seek fires, null after. */
+    burst: SeekBurst | null;
+}
+/**
+ * A directional seek that ramps while a key is held: a tap moves exactly 10 s,
+ * a run of taps adds up, and one real seek fires once the presses stop.
+ */
+export declare function useSeekNudge(controller: PlayerController): SeekNudge;

package/types/ui/src/components/organisms/player/hooks/use-volume-flash.d.ts

@@ -0,0 +1,8 @@
+import type { StageFlash } from '#ui/components/organisms/player/parts/stage-flash';
+export interface VolumeFlash {
+    flash: StageFlash | null;
+    /** Show `level` over the picture, and keep showing it while keys keep coming. */
+    show(level: number): void;
+}
+/** The volume echo a keyboard or remote step leaves on the stage. */
+export declare function useVolumeFlash(): VolumeFlash;

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

@@ -0,0 +1,26 @@
+export { PLAYER_ROOT_ID } from './hooks/use-idle-cursor';
+export { RESUME_WINDOW, type ResumeNotice, useResumeNotice } from './hooks/use-resume-notice';
+export { AUDIO_FILTER_KEY, audioFilterLabels, storedAudioFilter, useAudioFilter, } from './lib/audio-filter';
+export { currentChapter, currentChapterIndex, normalizeChapters } from './lib/chapters';
+export { endsAtClock, pct } from './lib/fmt';
+export { buildLeanStats, type LeanStatsInput, type LeanStatsVideoHandle } from './lib/lean-stats';
+export { type SeekBarPaint, seekBar } from './lib/style';
+export { DEFAULT_SUB_APPEARANCE, migrateAppearance, SUB_COLORS, SUB_EDGES, SUB_FONTS, type SubEdge, type SubFont, type SubSize, type SubtitleAppearance, subtitleStyle, subtitleWindowStyle, useSubtitleAppearance, withOpacity, } from './lib/subtitle-appearance';
+export type { PlayerAudioTrack, PlayerMarker, PlayerReportCategory, PlayerStatsItem, PlayerSubCapabilities, PlayerSubtitleGeneration, PlayerVideoTrack, } from './media-types';
+export type { CreditsCardItem } from './parts/credits-card';
+export { BACK_10_ICON, FWD_10_ICON } from './parts/icons';
+export { POST_PLAY_ART_W, type PostPlayItem } from './parts/post-play';
+export { ResumePrompt, type ResumePromptProps } from './parts/resume-prompt';
+export type { SubtitleGenBundle, SubtitleGenRequest } from './parts/settings-panel/settings/gen';
+export { PICTURE_ID as PLAYER_PICTURE_ID, STAGE_ID as PLAYER_STAGE_ID } from './parts/stage/stage';
+export { StatsPanel } from './parts/stats-panel';
+export { SUBTITLE_LAYER_ID as PLAYER_SUBTITLE_ID } from './parts/subtitle-renderer/subtitle-renderer';
+export type { SurfaceRadius } from './parts/surface-radius';
+export { SurfaceRadiusProvider, useSurfaceRadius } from './parts/surface-radius';
+export { UP_NEXT_ART_W } from './parts/up-next-card';
+export type { UpNextData, UpNextItem } from './parts/up-next-sheet';
+export type { PlayerRootProps } from './player-root';
+export { Player } from './player';
+export type { PlayerActionsProps, PlayerMediaProps, PlayerPanelProps } from './player-parts';
+export type { AudioFilterMode, Chapter, PlaneRect, PlayerCloseDetails, PlayerCloseReason, PlayerController, PlayerFlags, PlayerMeter, PlayerQuality, PlayerStats, PlayerSub, PlayerSurface, } from './types';
+export { TV_FLAGS, WEB_FLAGS } from './types';

package/types/ui/src/components/organisms/player/lib/audio-filter.d.ts

@@ -0,0 +1,22 @@
+import type { MessageKey, Translate } from '@kromatv/i18n';
+import { type RefObject } from 'react';
+import type { AudioFilterMode } from '#ui/components/organisms/player/types';
+import { type DeviceStore } from '#ui/lib/device-store';
+export declare const AUDIO_FILTER_KEY: Record<AudioFilterMode, MessageKey>;
+export declare function audioFilterLabels(t: Translate): Record<AudioFilterMode, string>;
+/** Synchronous, so a native engine can apply the remembered mode at
+ * construction, before React state has hydrated. `off` without storage/DOM. */
+export declare function storedAudioFilter(store?: DeviceStore | null): AudioFilterMode;
+/** Audio graph lifetime matches the player controller that owns its video ref. */
+export declare function createAudioFilterOwner(): {
+    wire: (el: HTMLMediaElement, mode: AudioFilterMode, boost: number) => void;
+    retain: () => () => void;
+};
+/** `remountKey` must change whenever the parent remounts the <video>, so the
+ * graph re-attaches to the fresh element. `boost` is the gain past the
+ * element's own ceiling (1 = none), the web's volume above 100%. */
+export declare function useAudioFilter(videoRef: RefObject<HTMLVideoElement | null>, remountKey: string, boost?: number): {
+    mode: AudioFilterMode;
+    setMode: (m: AudioFilterMode) => void;
+    supported: boolean;
+};

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

@@ -0,0 +1,16 @@
+import type { Chapter } from '#ui/components/organisms/player/types';
+/**
+ * The chapter model behind the progress bar (§1). Real chapter data passes
+ * through normalized; with none, the bar degrades to a single continuous
+ * segment. Intro/credits markers are drawn as ticks independent of chapters.
+ */
+/**
+ * Sort, clamp and gap-fill raw chapter data into a clean, contiguous list.
+ * Returns `[]` when there is nothing meaningful to segment (0/1 chapters), so
+ * the bar renders as a plain progress bar.
+ */
+export declare function normalizeChapters(raw: readonly Chapter[] | null | undefined, durMs: number): Chapter[];
+/** Index of the chapter containing `posMs`, or -1 when there are no chapters. */
+export declare function currentChapterIndex(chapters: readonly Chapter[], posMs: number): number;
+/** Convenience: the chapter object at `posMs`, or null. */
+export declare function currentChapter(chapters: readonly Chapter[], posMs: number): Chapter | null;

package/types/ui/src/components/organisms/player/lib/chart-geometry.d.ts

@@ -0,0 +1,46 @@
+export declare const CHART_WINDOW = 80;
+export interface ChartBox {
+    /** Drawable width. `x = width` is the newest sample. */
+    width: number;
+    height: number;
+    /** Vertical inset, so a 2px stroke never clips against the extremes. */
+    padY: number;
+    /** Samples across the full width. Defaults to CHART_WINDOW. */
+    window?: number;
+}
+export interface Extent {
+    min: number;
+    max: number;
+}
+/**
+ * The value range every series in one chart shares, so two series (e.g.
+ * bandwidth and bitrate) can be read against each other without inventing a
+ * crossover that isn't in the data. `reference` widens the range so a floor
+ * line is never drawn outside the box; a flat series gets a symmetric ±1
+ * instead of dividing by zero.
+ */
+export declare function extentOf(series: readonly (readonly number[])[], reference?: number): Extent;
+/** Sample index → x. Right-anchored: the newest sample sits at `box.width`. */
+export declare function xAt(index: number, count: number, box: ChartBox): number;
+/** Value → y. Larger values sit higher, which is why this inverts. */
+export declare function yAt(value: number, extent: Extent, box: ChartBox): number;
+/** Quantise to 0.1px: finer precision is invisible at this size, and the shorter
+ * `d` string is what actually crosses into the renderer on every tick. */
+export declare function px(n: number): number;
+/**
+ * `d` for one open trace. Empty when there is not yet enough to draw a line -
+ * a single sample is a dot's worth of information and reads as a glitch.
+ */
+export declare function seriesPath(data: readonly number[], extent: Extent, box: ChartBox): string;
+/**
+ * `d` for the closed band between two traces: the headroom between the
+ * bandwidth a connection is delivering and the bitrate it's asking for. Drawn
+ * filled so a closing gap (an impending stall) reads at a glance.
+ */
+export declare function bandPath(upper: readonly number[], lower: readonly number[], extent: Extent, box: ChartBox): string;
+/** Where the newest sample landed, for the "now" end dot. Null when there is
+ * nothing drawn to anchor it to. */
+export declare function endPoint(data: readonly number[], extent: Extent, box: ChartBox): {
+    x: number;
+    y: number;
+} | null;

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

@@ -0,0 +1,21 @@
+/** Player-chrome formatting helpers shared by web + TV. */
+import { clamp01 } from '#ui/components/atoms/progress';
+/**
+ * Wall-clock time the current playback will finish, given the remaining
+ * milliseconds (§1, "fin à 22h38"). Localized: 24h `22h38` for fr, `10:38 PM`
+ * for en. Empty string when the runtime is unknown.
+ */
+export declare function endsAtClock(remainingMs: number | null | undefined, locale?: string): string;
+/** The kit's one clamp (the progress atom's), re-exported for the chrome. */
+export { clamp01 };
+/** Percentage (0–100) of `value` within `total`, clamped and safe when total=0. */
+export declare function pct(value: number, total: number): number;
+/** Slider position [0,1] → level [0,max]. The rail is linear in the level a
+ *  viewer reads (50% sits halfway to 100%); the platform applies the loudness
+ *  curve when it drives the audio (see the web's useVolumeBoost). `max` is the
+ *  controller's `volumeMax`, 1 without a boost. */
+export declare function sliderToVolume(position: number, max?: number): number;
+/** Level [0,max] → slider position [0,1] (inverse of {@link sliderToVolume}). */
+export declare function volumeToSlider(volume: number, max?: number): number;
+/** One 5% step of level, clamped to [0,max]. */
+export declare function volumeStep(volume: number, dir: -1 | 1, max?: number): number;

package/types/ui/src/components/organisms/player/lib/lean-stats.d.ts

@@ -0,0 +1,34 @@
+import type { Translate } from '@kromatv/i18n';
+import type { PlayerStats } from '#ui/components/organisms/player/types';
+import type { PlayerAudioTrack, PlayerStatsItem } from '../media-types';
+/** Typed structurally so React Native surfaces can satisfy it with no DOM lib. */
+export interface LeanStatsVideoHandle {
+    videoWidth: number;
+    videoHeight: number;
+    getVideoPlaybackQuality?: () => {
+        droppedVideoFrames: number;
+        totalVideoFrames: number;
+    };
+}
+export interface LeanStatsInput {
+    item: PlayerStatsItem;
+    cur: number;
+    dur: number;
+    bufEnd: number | null;
+    audioTracks: PlayerAudioTrack[];
+    audioIndex: number;
+    /** Null for native planes (AVPlay / mpv / exo / AVPlayer). */
+    video: LeanStatsVideoHandle | null;
+    /** The forward buffer a healthy stream keeps on THIS player, which is what
+     *  the meter is read against. Defaults to ten seconds; a player whose cache
+     *  window is a second and a half by design reads permanently critical against
+     *  a single constant. */
+    bufferTarget?: number;
+    mode: string;
+    t: Translate;
+    extra?: NonNullable<PlayerStats['extra']>;
+    meters?: NonNullable<PlayerStats['meters']>;
+}
+/** Dropped frames appear only when an in-page <video> is present; the buffer is
+ * a live meter rather than a row, because its history is the diagnostic. */
+export declare function buildLeanStats(s: LeanStatsInput): PlayerStats;

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

@@ -0,0 +1,40 @@
+import type { ControlId } from './nav';
+export declare const CONTROL_SIZE: Record<ControlId, number>;
+export declare const VOLUME_RAIL = 96;
+export declare const TRANSPORT_GAP = 20;
+export declare const CLUSTER_GAP = 14;
+export declare const GUTTER = 34;
+export declare const TRANSPORT_HEIGHT = 164;
+export declare const ROW_GAP = 24;
+export declare const isTransport: (id: ControlId) => boolean;
+export declare const MIN_SCALE = 0.78;
+export interface ChromeMetrics {
+    scale: number;
+    controls: ControlId[];
+    rail: boolean;
+    overflow: ControlId[];
+    clusterWidth: number;
+}
+/**
+ * How the control row fits `stageWidth`: draw it as large as the stage allows,
+ * and where that would take a circle below the touch-target floor, shed a
+ * control and ask again. The row never wraps onto a second line. The returned
+ * `controls` is both what is drawn and what the nav machine steps through, so
+ * nothing focusable is ever off screen.
+ */
+export declare function chromeMetrics(row: readonly ControlId[], stageWidth: number): ChromeMetrics;
+export declare function px(scale: number, size: number): number;
+export type Px = (size: number) => number;
+export declare const scaler: (scale: number) => Px;
+export declare const PANEL_FRACTION = 0.44;
+export declare const PANEL_MAX = 720;
+export declare const PANEL_MIN = 420;
+export declare const CARD_MARGIN = 64;
+export declare const MIN_CARD_SCALE = 0.2;
+export interface PanelGeometry {
+    width: number;
+    covers: boolean;
+}
+/** Where the settings panel sits on this stage, and whether the video still has
+ * somewhere to shrink to beside it. */
+export declare function panelGeometry(stageWidth: number): PanelGeometry;

package/types/ui/src/components/organisms/player/lib/nav-keys.d.ts

@@ -0,0 +1,22 @@
+import type { Dispatch, SetStateAction } from 'react';
+import type { PlayerNavActions } from '#ui/components/organisms/player/hooks/use-player-nav';
+import type { RemoteKey } from '#ui/lib/remote-keys';
+import type { ControlId, Overlay, Zone } from './nav';
+interface DpadContext {
+    a: PlayerNavActions;
+    zone: Zone;
+    focused: ControlId | undefined;
+    controlsLen: number;
+    setZone: Dispatch<SetStateAction<Zone>>;
+    setControlIndex: Dispatch<SetStateAction<number>>;
+    setRevealed: Dispatch<SetStateAction<boolean>>;
+    clearHide: () => void;
+    openOverlay: (o: Exclude<Overlay, null>) => void;
+    activate: (id: ControlId) => void;
+}
+/** The keys {@link handleMediaKey} answers: a transport press drives the film
+ *  itself, so it acts wherever the player is rather than waiting for the chrome. */
+declare const TRANSPORT_KEYS: ReadonlySet<RemoteKey>;
+declare function handleMediaKey(key: RemoteKey, a: PlayerNavActions): boolean;
+declare function handleDpadKey(key: RemoteKey, ctx: DpadContext): void;
+export { handleDpadKey, handleMediaKey, TRANSPORT_KEYS };