@titan-design/react-ui 0.4.0 → 0.5.0

package/dist/pages-MO0JCySL.d.mts

@@ -0,0 +1,791 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ViewProps } from 'react-native';
+import { c as MesoStatusCardProps } from './MesoStatusCard-CQk71hSi.mjs';
+
+type PRType = 'e1rm' | 'weight' | 'reps' | 'volume' | 'velocity';
+interface PrBadgeProps extends ViewProps {
+    /** PR type determines auto-generated label */
+    type?: PRType;
+    /** Display label (e.g., "PR e1RM", "PR 5RM"). Auto-generated from type if omitted. */
+    label?: string;
+    /** Show only the star icon, no text label */
+    compact?: boolean;
+    /** Trigger pop animation on mount */
+    animate?: boolean;
+    className?: string;
+}
+declare function PrBadge({ type, label: labelProp, compact, animate, className, ...props }: PrBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Spec statuses: completed | current | upcoming | deload.
+ * `next` and `missed` are additive extras supported by this implementation.
+ */
+type WorkoutPillStatus = 'completed' | 'current' | 'upcoming' | 'deload' | 'next' | 'missed';
+interface WorkoutPillProps extends ViewProps {
+    name: string;
+    status: WorkoutPillStatus;
+    /** Force pulsing animation. Defaults to pulsing only on `current` status. */
+    pulse?: boolean;
+    onPress?: () => void;
+    highlighted?: boolean;
+    className?: string;
+}
+declare function WorkoutPill({ name, status, pulse, onPress, highlighted, className, ...props }: WorkoutPillProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Structural velocity-zone band accepted from an upstream analytics source
+ * (e.g. workout-analytics' `VelocityZones.bands`).
+ *
+ * Deliberately a plain structural shape — titan never imports the analytics
+ * package (same policy as TempoBar's presentational phase key). Any object with
+ * this shape can be passed, so `zones={waVelocityZones.bands}` works directly.
+ * Bands are ordered slow → fast, contiguous, and cover `[0, ∞)` with the top
+ * band's `max === null`. Bands carry NO color — color is a UI concern resolved
+ * here via {@link zoneIdToScaleToken}.
+ */
+interface VelocityZoneBandProp {
+    /** Stable zone identity (e.g. WA's `VelocityZoneId`). Drives color mapping. */
+    id: string;
+    /** Human-readable label shown in the summary row. */
+    label: string;
+    /** Inclusive lower bound (m/s mean concentric velocity). */
+    min: number;
+    /** Exclusive upper bound (m/s); `null` marks the open top band. */
+    max: number | null;
+}
+interface VelocityStripProps extends ViewProps {
+    /**
+     * Per-rep MEAN concentric velocity (m/s), one entry per rep (brain WA-D02).
+     * Drives both bar height and — in the default path — zone color. Callers must
+     * feed mean (not peak) concentric velocity so bar color, height, and the
+     * summary label all describe one metric.
+     */
+    velocities: number[];
+    /**
+     * Optional velocity-zone bands (shape-compatible with WA's
+     * `VelocityZones.bands`). When provided, bar color and the summary zone label
+     * come from these bands via {@link zoneIdToScaleToken}. When omitted, the
+     * built-in default scale (≥1.0 / ≥0.75 / ≥0.5) is used — identical to prior
+     * releases. Colors NEVER come from the bands themselves.
+     */
+    zones?: readonly VelocityZoneBandProp[];
+    /**
+     * Live mode: index of the most-recently-completed rep. That bar animates in
+     * with a "pop"; if it is also the current set peak (a new best), it "bounces"
+     * instead. Only the latest bar animates. Honors `prefers-reduced-motion`.
+     * Full variant only.
+     */
+    liveRepIndex?: number;
+    expanded?: boolean;
+    onToggle?: () => void;
+    onRepPress?: (index: number, velocity: number) => void;
+    variant?: 'full' | 'mini';
+    showInfo?: boolean;
+    className?: string;
+}
+declare function getVelocityZoneColor(velocity: number): string;
+declare function getVelocityZoneName(velocity: number): string;
+/**
+ * Velocity loss for a set, as a whole percentage. Uses the running-best rep as
+ * the reference (matching WA-02.05 / brain WA-D01): `(vBest − vLast) / vBest`,
+ * clamped to ≥ 0 so a set that ends on its best rep reports 0 loss.
+ */
+declare function calculateVelocityLoss(velocities: number[]): number;
+/** Arithmetic mean of the per-rep mean-concentric velocities. */
+declare function calculateMeanVelocity(velocities: number[]): number;
+declare function VelocityStrip({ velocities, zones, liveRepIndex, expanded, onToggle, onRepPress, variant, showInfo, className, ...props }: VelocityStripProps): react_jsx_runtime.JSX.Element;
+
+type SetRowMode = 'active' | 'completed' | 'history';
+interface SetRowProps {
+    mode: SetRowMode;
+    setNumber: number;
+    previous?: {
+        reps: number;
+        weight: number;
+    } | null;
+    reps: number | null;
+    weight: number | null;
+    rpe?: number | null;
+    unit: 'lbs' | 'kg';
+    /** Per-rep MEAN concentric velocities (m/s). */
+    velocities?: number[];
+    /** Optional velocity-zone bands (WA `VelocityZones.bands`); default scale when absent. */
+    velocityZones?: readonly VelocityZoneBandProp[];
+    /** Live mode: index of the newest rep bar to animate (pop / new-peak bounce). */
+    velocityLiveRepIndex?: number;
+    velocityExpanded?: boolean;
+    onVelocityToggle?: () => void;
+    setType?: string;
+    prBadges?: Array<{
+        type: PRType;
+        label: string;
+    }>;
+    isNextSet?: boolean;
+    targets?: {
+        reps: number;
+        weight: number;
+    };
+}
+declare function SetRow({ mode, setNumber, previous, reps, weight, rpe, unit, velocities, velocityZones, velocityLiveRepIndex, velocityExpanded, onVelocityToggle, setType, prBadges, isNextSet, targets, }: SetRowProps): react_jsx_runtime.JSX.Element;
+
+type ExerciseCardState = 'collapsed' | 'expanded' | 'upcoming';
+interface ExerciseCardProps {
+    name: string;
+    state: ExerciseCardState;
+    onToggle: () => void;
+    onNavigateDetail?: () => void;
+    summary?: {
+        sets: number;
+        reps: number | string;
+        weight: number;
+        unit: 'lbs' | 'kg';
+    };
+    e1rm?: {
+        value: number;
+        unit: 'lbs' | 'kg';
+    };
+    isPR?: boolean;
+    setVelocities?: number[][];
+    /** Optional velocity-zone bands shared across this exercise's sets (WA bands). */
+    velocityZones?: readonly VelocityZoneBandProp[];
+    totalPlannedSets?: number;
+    sets?: SetRowProps[];
+    tempo?: [number, number, number, number];
+    prescription?: string;
+    previousBest?: string;
+    supersetPosition?: 'first' | 'last' | 'middle' | null;
+    supersetColor?: string;
+}
+declare function ExerciseCard(props: ExerciseCardProps): react_jsx_runtime.JSX.Element;
+
+type MesoStatus = 'completed' | 'current' | 'upcoming';
+interface Meso {
+    id: string;
+    name: string;
+    weekCount: number;
+    status: MesoStatus;
+    /**
+     * 1-based week index of progress within a `current` meso.
+     * Drives the solid fill width. Ignored for non-current mesos.
+     */
+    currentWeek?: number;
+}
+interface MesoProgressBarProps extends ViewProps {
+    mesos: Meso[];
+    activeMesoId: string | null;
+    onMesoPress: (mesoId: string) => void;
+    className?: string;
+}
+/**
+ * Segmented horizontal bar of mesocycles. Each segment is tappable and its
+ * flex width is proportional to the meso's `weekCount`. The active segment is
+ * highlighted with a 2px brand border to stay in sync with MesoCard selection.
+ *
+ * @example
+ * <MesoProgressBar
+ *   mesos={[
+ *     { id: 'm1', name: 'Accumulation', weekCount: 4, status: 'completed' },
+ *     { id: 'm2', name: 'Intensification', weekCount: 3, status: 'current', currentWeek: 2 },
+ *     { id: 'm3', name: 'Peak', weekCount: 2, status: 'upcoming' },
+ *   ]}
+ *   activeMesoId="m2"
+ *   onMesoPress={(id) => console.log(id)}
+ * />
+ */
+declare function MesoProgressBar({ mesos, activeMesoId, onMesoPress, className, ...props }: MesoProgressBarProps): react_jsx_runtime.JSX.Element;
+
+interface WeekRowWorkout {
+    name: string;
+    status: WorkoutPillStatus;
+    onPress?: () => void;
+}
+interface WeekRowProps extends ViewProps {
+    /** Week index within the mesocycle (1-based) */
+    weekNumber: number;
+    /** Total weeks in the mesocycle */
+    totalWeeks: number;
+    /** Workouts scheduled for this week */
+    workouts: WeekRowWorkout[];
+    /** Planned intensity for the week, 0-1 */
+    intensityLevel: number;
+    /** Optional MRV/overexertion threshold, 0-1 */
+    intensityThreshold?: number;
+    /** Highlights this row as the active week */
+    isCurrent?: boolean;
+    /** Renders this row as a deload week (purple tint, deload pills) */
+    isDeload?: boolean;
+    className?: string;
+}
+/**
+ * A single week within a mesocycle, showing the week number, its workout pills,
+ * and a right-aligned vertical intensity indicator.
+ *
+ * @example
+ * <WeekRow
+ *   weekNumber={1}
+ *   totalWeeks={4}
+ *   workouts={[
+ *     { name: 'Upper', status: 'completed' },
+ *     { name: 'Lower', status: 'current' },
+ *   ]}
+ *   intensityLevel={0.55}
+ *   intensityThreshold={0.8}
+ *   isCurrent
+ * />
+ */
+declare function WeekRow({ weekNumber, totalWeeks, workouts, intensityLevel, intensityThreshold, isCurrent, isDeload, className, ...props }: WeekRowProps): react_jsx_runtime.JSX.Element;
+
+type WorkoutStatus = 'completed' | 'today' | 'upcoming';
+/** Spec volume-status vocabulary; mapped to MuscleGroupChip's VolumeStatus internally. */
+type WorkoutMuscleVolumeStatus = 'under' | 'maintenance' | 'productive' | 'over';
+interface WorkoutMuscleGroup {
+    /** Muscle group identifier (free-form to match plan data). */
+    group: string;
+    /** Display label, may be abbreviated. */
+    label: string;
+    /** Volume status relative to landmarks. */
+    volumeStatus?: WorkoutMuscleVolumeStatus;
+}
+interface WorkoutCardProps extends ViewProps {
+    name: string;
+    date: string;
+    /** e.g. "45 min" */
+    duration?: string;
+    status: WorkoutStatus;
+    muscleGroups: WorkoutMuscleGroup[];
+    totalSets: number;
+    /** Total lbs/kg moved across the workout. */
+    totalVolume?: number;
+    unit: 'lbs' | 'kg';
+    exercises?: ExerciseCardProps[];
+    expanded?: boolean;
+    onToggle?: () => void;
+    className?: string;
+}
+/**
+ * A workout within a week: name, date, duration, muscle-group pills, and a
+ * stats summary. When expandable it renders contained ExerciseCards on expand.
+ * Status drives a colored left border, today adds a brand tint, and upcoming
+ * is dimmed.
+ *
+ * @example
+ * <WorkoutCard
+ *   name="Upper A"
+ *   date="Mon, Jun 23"
+ *   duration="45 min"
+ *   status="today"
+ *   muscleGroups={[{ group: 'chest', label: 'Chest', volumeStatus: 'productive' }]}
+ *   totalSets={18}
+ *   totalVolume={12450}
+ *   unit="lbs"
+ *   expanded
+ *   onToggle={() => {}}
+ *   exercises={exercises}
+ * />
+ */
+declare function WorkoutCard({ name, date, duration, status, muscleGroups, totalSets, totalVolume, unit, exercises, expanded, onToggle, className, ...props }: WorkoutCardProps): react_jsx_runtime.JSX.Element;
+
+interface MesoVolumeHeatmapEntry {
+    /** Muscle group identifier (free-form to match plan data). */
+    group: string;
+    /** Planned volume intensity for the group, 0-100. */
+    percentage: number;
+}
+interface MesoCardProps extends ViewProps {
+    /** Mesocycle name, e.g. "Accumulation". */
+    name: string;
+    /** Training goal, e.g. "Hypertrophy", "Strength", "Peaking". */
+    goal: string;
+    /** Training split, e.g. "Upper/Lower", "Push/Pull/Legs". */
+    split: string;
+    /** Week range label, e.g. "Weeks 1-4". */
+    weekRange: string;
+    /** Current week within the mesocycle (1-based). */
+    currentWeek?: number;
+    /** Total weeks in the mesocycle. */
+    totalWeeks: number;
+    /** Weeks rendered as a WeekRow list when expanded. */
+    weeks: WeekRowProps[];
+    /** Whether the card is expanded to reveal the week list. */
+    expanded?: boolean;
+    /** Toggles expansion; makes the header a button when provided. */
+    onToggle?: () => void;
+    /** Whether this meso is highlighted in the MesoProgressBar. */
+    highlighted?: boolean;
+    /** Volume heatmap data per muscle group for the meso. */
+    volumeHeatmap?: MesoVolumeHeatmapEntry[];
+    className?: string;
+}
+/**
+ * A mesocycle card with name, goal, split, week range, an optional volume
+ * heatmap strip, and an expandable WeekRow list. Highlighting animates the
+ * border toward brand-primary with a subtle glow to stay in sync with the
+ * MesoProgressBar.
+ *
+ * @example
+ * <MesoCard
+ *   name="Accumulation"
+ *   goal="Hypertrophy"
+ *   split="Upper/Lower"
+ *   weekRange="Weeks 1-4"
+ *   currentWeek={2}
+ *   totalWeeks={4}
+ *   weeks={weeks}
+ *   volumeHeatmap={[{ group: 'chest', percentage: 80 }]}
+ *   expanded
+ *   onToggle={() => {}}
+ *   highlighted
+ * />
+ */
+declare function MesoCard({ name, goal, split, weekRange, currentWeek, totalWeeks, weeks, expanded, onToggle, highlighted, volumeHeatmap, className, ...props }: MesoCardProps): react_jsx_runtime.JSX.Element;
+
+interface StrengthTrendDataPoint {
+    /** ISO date string for the session. */
+    date: string;
+    /** Estimated one-rep max in the chart's unit. */
+    e1rm: number;
+    /** Marks a personal-record session (rendered with a star). */
+    isPR?: boolean;
+    /** Optional human label shown in the tooltip instead of the raw date. */
+    sessionLabel?: string;
+}
+interface StrengthTrendChartMesoBoundary {
+    /** ISO date where the mesocycle boundary falls. */
+    date: string;
+    /** Short label, e.g. "Hypertrophy". */
+    label: string;
+}
+interface StrengthTrendChartProps extends ViewProps {
+    /** Actual e1RM data points, chronological. */
+    data: StrengthTrendDataPoint[];
+    /** Projected/planned e1RM trajectory, drawn as a dashed line. */
+    projection?: StrengthTrendDataPoint[];
+    /** Chart plot width in pixels. */
+    width: number;
+    /** Chart plot height in pixels (120-160 for the compact variant). */
+    height: number;
+    /** Mesocycle boundary markers (vertical guides + labels). */
+    mesoBoundaries?: StrengthTrendChartMesoBoundary[];
+    /** Called when an actual data point is tapped. */
+    onPointPress?: (point: StrengthTrendDataPoint) => void;
+    /** Unit for display and labels. */
+    unit: 'lbs' | 'kg';
+    /** Animate the left-to-right line draw on mount (default true). */
+    animateOnMount?: boolean;
+    className?: string;
+}
+/**
+ * Estimated-1RM line chart over time with an optional dashed plan-projection
+ * line and PR star markers. Rendered entirely with absolutely-positioned
+ * Views (no SVG), following the Sparkline approach. Tapping an actual point
+ * opens a tooltip and fires `onPointPress`. A trend pill below the chart
+ * summarizes the percentage change for the current mesocycle.
+ *
+ * @example
+ * <StrengthTrendChart
+ *   data={[{ date: '2026-01-01', e1rm: 225 }, { date: '2026-02-01', e1rm: 245, isPR: true }]}
+ *   projection={[{ date: '2026-02-01', e1rm: 245 }, { date: '2026-03-01', e1rm: 260 }]}
+ *   width={320}
+ *   height={150}
+ *   unit="lbs"
+ * />
+ */
+declare function StrengthTrendChart({ data, projection, width, height, mesoBoundaries, onPointPress, unit, animateOnMount, className, ...props }: StrengthTrendChartProps): react_jsx_runtime.JSX.Element;
+
+type WorkoutDotStatus = 'within' | 'above' | 'below';
+interface CapacityBandDataPoint {
+    /** ISO-ish date string (e.g. "2026-06-01"). */
+    date: string;
+    /** Lower bound of the capacity band (MEV equivalent). */
+    bandLow: number;
+    /** Upper bound of the capacity band (MRV equivalent). */
+    bandHigh: number;
+}
+interface WorkoutDot {
+    date: string;
+    /** Actual session load score. */
+    load: number;
+    /** Position of the session relative to the band. */
+    status: WorkoutDotStatus;
+}
+interface CapacityBandProjection {
+    /** Band shape over the next days if training continues (rises). */
+    withTraining: CapacityBandDataPoint[];
+    /** Band shape over the next days if resting (drops). */
+    withRest: CapacityBandDataPoint[];
+}
+interface CapacityBandChartProps extends ViewProps {
+    /** Capacity band shape over time. */
+    band: CapacityBandDataPoint[];
+    /** Workout sessions plotted as dots. */
+    workouts: WorkoutDot[];
+    /** Optional forward projection (next few days). */
+    projection?: CapacityBandProjection;
+    /** Chart width in px. */
+    width: number;
+    /** Chart height in px. */
+    height: number;
+    /** Called when a workout dot is tapped. */
+    onWorkoutPress?: (workout: WorkoutDot) => void;
+    className?: string;
+}
+/**
+ * Gentler-Streak-inspired fatigue visualization. Renders a shaded capacity
+ * band (between a rolling MEV/MRV estimate), workout sessions as colored dots
+ * positioned by load, and an optional dashed forward projection that diverges
+ * for "keep training" (rises) versus "rest" (drops). View-based, no SVG:
+ * the band fill is a run of vertical columns and the edges/projection are
+ * rotated line Views (same technique as Sparkline).
+ *
+ * @example
+ * <CapacityBandChart
+ *   band={band}
+ *   workouts={workouts}
+ *   projection={{ withTraining, withRest }}
+ *   width={320}
+ *   height={180}
+ *   onWorkoutPress={(w) => openSession(w)}
+ * />
+ */
+declare function CapacityBandChart({ band, workouts, projection, width, height, onWorkoutPress, className, ...props }: CapacityBandChartProps): react_jsx_runtime.JSX.Element;
+
+/** A single workout within a planned week, plus its exercise breakdown. */
+interface PlanWorkout {
+    /** Stable identifier used for drill-down selection. */
+    id: string;
+    name: string;
+    date: string;
+    duration?: string;
+    status: WorkoutStatus;
+    muscleGroups: WorkoutMuscleGroup[];
+    totalSets: number;
+    totalVolume?: number;
+    unit: 'lbs' | 'kg';
+    /** Exercises revealed when the workout is opened. */
+    exercises: ExerciseCardProps[];
+}
+/** A training week inside a mesocycle. */
+interface PlanWeek {
+    /** 1-based week index within the mesocycle. */
+    weekNumber: number;
+    /** Planned intensity for the week, 0-1. */
+    intensityLevel: number;
+    /** Optional MRV/overexertion threshold, 0-1. */
+    intensityThreshold?: number;
+    isDeload?: boolean;
+    isCurrent?: boolean;
+    workouts: PlanWorkout[];
+}
+/** A mesocycle: the top level of the drill-down. */
+interface PlanMeso {
+    id: string;
+    name: string;
+    goal: string;
+    split: string;
+    weekRange: string;
+    weekCount: number;
+    currentWeek?: number;
+    status: MesoStatus;
+    volumeHeatmap?: MesoVolumeHeatmapEntry[];
+    weeks: PlanWeek[];
+}
+/** Current depth of the meso -> week -> workout drill-down. */
+type ProgramNavLevel = 'meso' | 'week' | 'workout';
+/** The navigation cursor within the active mesocycle. */
+interface ProgramSelection {
+    weekNumber: number | null;
+    workoutId: string | null;
+}
+/** One tappable step in the breadcrumb trail. */
+interface ProgramBreadcrumb {
+    key: string;
+    label: string;
+    level: ProgramNavLevel;
+}
+interface ProgramPlanningPageProps extends ViewProps {
+    /** Page heading. */
+    title?: string;
+    /** Mesocycles that make up the program. */
+    mesos: PlanMeso[];
+    className?: string;
+}
+/** Derive the current drill-down level from the selection cursor (pure). */
+declare function deriveNavLevel(selection: ProgramSelection): ProgramNavLevel;
+/** Project the mesocycles onto MesoProgressBar segment data (pure). */
+declare function toProgressBarMesos(mesos: PlanMeso[]): Meso[];
+/** Look up a meso by id, or null. */
+declare function findMeso(mesos: PlanMeso[], id: string | null): PlanMeso | null;
+/** Look up a week within a meso, or null. */
+declare function findWeek(meso: PlanMeso | null, weekNumber: number | null): PlanWeek | null;
+/** Look up a workout within a week, or null. */
+declare function findWorkout(week: PlanWeek | null, workoutId: string | null): PlanWorkout | null;
+/** Build the breadcrumb trail for the active drill path (pure). */
+declare function buildBreadcrumbs(meso: PlanMeso, weekNumber: number | null, workout: PlanWorkout | null): ProgramBreadcrumb[];
+/**
+ * ProgramPlanningPage — a meso -> week -> workout drill-down over an entire
+ * training program. A `MesoProgressBar` pins the mesocycle timeline to the top;
+ * the body swaps between three levels: expandable `MesoCard`s (with inline
+ * `WeekRow`s), a week's `WorkoutCard` list, and a single opened `WorkoutCard`
+ * with inline `ExerciseCard` expansion. A breadcrumb trail tracks and rewinds
+ * the drill path. Selection is page-level state; children keep their own styles.
+ *
+ * @example
+ * <ProgramPlanningPage mesos={mesos} />
+ */
+declare function ProgramPlanningPage({ title, mesos, className, ...props }: ProgramPlanningPageProps): react_jsx_runtime.JSX.Element;
+
+/** Which tab of the exercise detail view is showing. */
+type ExerciseDetailTab = 'progress' | 'history' | 'advanced';
+/** Tabs in display order. */
+declare const EXERCISE_DETAIL_TABS: Array<{
+    key: ExerciseDetailTab;
+    label: string;
+}>;
+/** Identity + headline stats for the exercise being inspected. */
+interface ExerciseDetailHeader {
+    /** Exercise name, e.g. "Barbell Bench Press". */
+    name: string;
+    /** Context line, e.g. "Chest · Barbell". */
+    subtitle: string;
+    /** Unit used across the page. */
+    unit: 'lbs' | 'kg';
+    /** Current estimated one-rep max, shown as a header pill. */
+    currentE1rm?: number;
+}
+/**
+ * A single expandable entry — one progression week or one logged session.
+ * Projected onto an `ExerciseCard`, so it collapses to a summary and expands
+ * to its `SetRow` breakdown.
+ */
+interface ExerciseDetailEntry {
+    /** Stable id for inline-expansion selection. */
+    id: string;
+    /** Row title, e.g. "Week 3" or "Mon, Jun 16". */
+    title: string;
+    /** Collapsed summary (sets × reps @ weight). */
+    summary?: ExerciseCardProps['summary'];
+    /** Estimated one-rep max badge. */
+    e1rm?: ExerciseCardProps['e1rm'];
+    /** Flags a personal-record entry. */
+    isPR?: boolean;
+    /** Prescribed tempo, revealed when expanded. */
+    tempo?: ExerciseCardProps['tempo'];
+    /** Per-set breakdown revealed when expanded. */
+    sets: SetRowProps[];
+}
+/** Strength-trend inputs for the Progress tab chart. */
+interface ExerciseTrend {
+    /** Measured e1RM data points, chronological. */
+    data: StrengthTrendDataPoint[];
+    /** Planned/projected trajectory (dashed line). */
+    projection?: StrengthTrendDataPoint[];
+    /** Mesocycle boundary guides. */
+    mesoBoundaries?: StrengthTrendChartMesoBoundary[];
+}
+/** One set's velocity trace for the Advanced tab breakdown. */
+interface ExerciseVbtSet {
+    /** Row label, e.g. "Set 1". */
+    label: string;
+    /** Per-rep mean concentric velocities (m/s). */
+    velocities: number[];
+}
+/** Velocity-based-training inputs for the Advanced tab. */
+interface ExerciseVbt {
+    /** Capacity band shape over time. */
+    band: CapacityBandDataPoint[];
+    /** Sessions plotted against the band. */
+    workouts: WorkoutDot[];
+    /** Optional forward band projection. */
+    projection?: CapacityBandProjection;
+    /** Per-set velocity traces for the most recent session. */
+    sets: ExerciseVbtSet[];
+    /** Optional velocity-zone bands for this exercise (WA `VelocityZones.bands`). */
+    zones?: readonly VelocityZoneBandProp[];
+}
+/** Page-level roll-up of the logged sessions. */
+interface ExerciseDetailStats {
+    /** Number of logged sessions. */
+    sessions: number;
+    /** Best estimated one-rep max seen, or null if none recorded. */
+    bestE1rm: number | null;
+    /** Count of PR entries. */
+    prCount: number;
+}
+/** Aggregate velocity readout for the Advanced tab. */
+interface VbtSummary {
+    /** Mean concentric velocity across every logged rep. */
+    meanVelocity: number;
+    /** Worst within-set velocity loss (%), i.e. the most-fatigued set. */
+    velocityLoss: number;
+}
+interface ExerciseDetailPageProps extends ViewProps {
+    /** Exercise identity + headline stats. */
+    exercise: ExerciseDetailHeader;
+    /** Mesocycle context banner (Progress tab). */
+    meso: MesoStatusCardProps;
+    /** Strength trend inputs (Progress tab). */
+    trend: ExerciseTrend;
+    /** Week-by-week progression entries (Progress tab). */
+    progression: ExerciseDetailEntry[];
+    /** All logged sessions (History tab). */
+    history: ExerciseDetailEntry[];
+    /** Velocity-based-training inputs (Advanced tab). */
+    vbt: ExerciseVbt;
+    className?: string;
+}
+/** Roll up logged sessions into the page summary (pure, testable). */
+declare function deriveExerciseStats(entries: ExerciseDetailEntry[]): ExerciseDetailStats;
+/** Project an entry onto ExerciseCard props, wiring inline expansion (pure). */
+declare function toExerciseCardProps(entry: ExerciseDetailEntry, expanded: boolean, onToggle: () => void): ExerciseCardProps;
+/** Aggregate per-set velocity traces into the Advanced readout (pure). */
+declare function summarizeVbt(sets: ExerciseVbtSet[]): VbtSummary;
+/**
+ * ExerciseDetailPage — a tabbed per-exercise view. A shared header (name,
+ * context line, current e1RM pill) sits above a Progress / History / Advanced
+ * tab bar. Progress composes the `MesoStatusCard` context banner, a stats
+ * strip, a `StrengthTrendChart`, and a week-by-week progression list with
+ * inline `ExerciseCard` expansion. History lists every logged session with the
+ * same inline expansion. Advanced surfaces VBT data via a `CapacityBandChart`,
+ * a velocity summary, and a per-set `VelocityStrip` breakdown. Tab and
+ * per-list expansion are page-level state; children keep their own styles.
+ *
+ * @example
+ * <ExerciseDetailPage
+ *   exercise={exercise}
+ *   meso={meso}
+ *   trend={trend}
+ *   progression={progression}
+ *   history={history}
+ *   vbt={vbt}
+ * />
+ */
+declare function ExerciseDetailPage({ exercise, meso, trend, progression, history, vbt, className, ...props }: ExerciseDetailPageProps): react_jsx_runtime.JSX.Element;
+
+/** Where an exercise sits in the during-workout flow. */
+type ActiveExerciseStatus = 'completed' | 'active' | 'upcoming';
+/**
+ * One exercise in the running workout. Projected onto an `ExerciseCard`, whose
+ * visual state is driven by `status` and the page's zoom focus: completed and
+ * active exercises collapse/expand, upcoming ones stay dimmed.
+ */
+interface ActiveWorkoutExercise {
+    /** Stable id for zoom-focus selection. */
+    id: string;
+    /** Exercise name, e.g. "Barbell Bench Press". */
+    name: string;
+    /** Position in the workout flow. */
+    status: ActiveExerciseStatus;
+    /** Unit used for this exercise's loads. */
+    unit: 'lbs' | 'kg';
+    /** Total sets prescribed for this exercise. */
+    totalPlannedSets: number;
+    /** Collapsed summary (sets × reps @ weight) for a completed exercise. */
+    summary?: ExerciseCardProps['summary'];
+    /** Estimated one-rep max badge. */
+    e1rm?: ExerciseCardProps['e1rm'];
+    /** Flags a personal-record exercise. */
+    isPR?: boolean;
+    /** Prescribed tempo, revealed when expanded. */
+    tempo?: ExerciseCardProps['tempo'];
+    /** Per-rep velocities for each logged set (drives collapsed strips + set count). */
+    setVelocities?: number[][];
+    /** Per-set breakdown revealed when expanded. */
+    sets?: SetRowProps[];
+    /** One-line prescription for an upcoming exercise. */
+    prescription?: string;
+    /** Previous-best hint for an upcoming exercise. */
+    previousBest?: string;
+    /** Groups consecutive exercises under a shared `SupersetWrapper`. */
+    supersetId?: string;
+}
+/** A superset grouping consecutive exercises that share its id. */
+interface ActiveWorkoutSuperset {
+    /** Matches `ActiveWorkoutExercise.supersetId`. */
+    id: string;
+    /** Corner badge label, e.g. "SS1". */
+    label: string;
+    /** Accent color for the wrapper rail + label. */
+    color?: string;
+}
+/** Live-set inputs shown in the bottom `InputBar`. */
+interface ActiveWorkoutInput {
+    /** Current reps field value. */
+    reps: string;
+    /** Current weight field value. */
+    weight: string;
+}
+/** Rest-timer inputs shown in the bottom `RestTimer`. */
+interface ActiveWorkoutRest {
+    /** Prescribed rest length, seconds. */
+    totalSeconds: number;
+    /** Elapsed rest, milliseconds. */
+    elapsedMs: number;
+    /** Next-set hint, e.g. "Set 3 · 8 × 195 lbs". */
+    nextSetInfo?: string;
+}
+/** Derived, page-level roll-up of workout progress. */
+interface WorkoutProgress {
+    /** Number of exercises marked completed. */
+    completedExercises: number;
+    /** Total exercises in the workout. */
+    totalExercises: number;
+    /** Sets logged so far across all exercises. */
+    completedSets: number;
+    /** Total sets prescribed across all exercises. */
+    totalSets: number;
+    /** Fraction of prescribed sets logged, 0-1. */
+    fraction: number;
+}
+/** An ordered render group: a lone exercise or a superset of exercises. */
+type WorkoutGroup = {
+    type: 'single';
+    exercise: ActiveWorkoutExercise;
+} | {
+    type: 'superset';
+    superset: ActiveWorkoutSuperset;
+    exercises: ActiveWorkoutExercise[];
+};
+interface ActiveWorkoutPageProps extends ViewProps {
+    /** Workout name shown in the header. */
+    title?: string;
+    /** Context line under the title, e.g. "Push Day A · Week 6". */
+    subtitle?: string;
+    /** Exercises in flow order. */
+    exercises: ActiveWorkoutExercise[];
+    /** Superset groupings referenced by `exercise.supersetId`. */
+    supersets?: ActiveWorkoutSuperset[];
+    /** Seed reps/weight for the live `InputBar`. */
+    input?: ActiveWorkoutInput;
+    /** Rest-timer state; when resting, the timer replaces the input bar. */
+    rest?: ActiveWorkoutRest;
+    /** Start the page in the resting state (timer showing). */
+    initialResting?: boolean;
+    className?: string;
+}
+/** Count the sets logged for an exercise (pure). */
+declare function countCompletedSets(exercise: ActiveWorkoutExercise): number;
+/** Roll up the exercises into the header progress readout (pure, testable). */
+declare function deriveWorkoutProgress(exercises: ActiveWorkoutExercise[]): WorkoutProgress;
+/** The active exercise anchors the bottom bar; find it, or null (pure). */
+declare function findActiveExercise(exercises: ActiveWorkoutExercise[]): ActiveWorkoutExercise | null;
+/** Map an exercise's status + focus onto an `ExerciseCard` visual state (pure). */
+declare function statusToCardState(status: ActiveExerciseStatus, focused: boolean): ExerciseCardState;
+/** Project an exercise onto ExerciseCard props, wiring zoom focus (pure). */
+declare function toActiveCardProps(exercise: ActiveWorkoutExercise, focused: boolean, onToggle: () => void, supersetPosition?: ExerciseCardProps['supersetPosition'], supersetColor?: string): ExerciseCardProps;
+/** Fold consecutive same-superset exercises into render groups (pure). */
+declare function groupExercises(exercises: ActiveWorkoutExercise[], supersets: ActiveWorkoutSuperset[]): WorkoutGroup[];
+/**
+ * ActiveWorkoutPage — the during-workout screen, built as a zoom hierarchy over
+ * `ExerciseCard`s. A header progress bar rolls up completed sets; the flow list
+ * dims upcoming exercises, collapses finished ones to their velocity strips, and
+ * expands exactly one focused exercise to its `SetRow` breakdown. Consecutive
+ * superset exercises stitch together inside a `SupersetWrapper`. A pinned bottom
+ * bar toggles between the live `InputBar` (log the next set) and the `RestTimer`.
+ * Focus and rest are page-level state; children keep their own styles.
+ *
+ * @example
+ * <ActiveWorkoutPage title="Push Day A" exercises={exercises} />
+ */
+declare function ActiveWorkoutPage({ title, subtitle, exercises, supersets, input, rest, initialResting, className, ...props }: ActiveWorkoutPageProps): react_jsx_runtime.JSX.Element;
+
+export { type WorkoutCardProps as $, type ActiveExerciseStatus as A, type PlanWorkout as B, CapacityBandChart as C, PrBadge as D, ExerciseCard as E, type PrBadgeProps as F, type ProgramBreadcrumb as G, type ProgramNavLevel as H, type ProgramPlanningPageProps as I, type ProgramSelection as J, type SetRowMode as K, type SetRowProps as L, type Meso as M, StrengthTrendChart as N, type StrengthTrendChartMesoBoundary as O, type PRType as P, type StrengthTrendChartProps as Q, type StrengthTrendDataPoint as R, SetRow as S, VelocityStrip as T, type VelocityStripProps as U, type VbtSummary as V, type VelocityZoneBandProp as W, WeekRow as X, type WeekRowProps as Y, type WeekRowWorkout as Z, WorkoutCard as _, type ActiveWorkoutExercise as a, type WorkoutDot as a0, type WorkoutDotStatus as a1, type WorkoutGroup as a2, type WorkoutMuscleGroup as a3, type WorkoutMuscleVolumeStatus as a4, WorkoutPill as a5, type WorkoutPillProps as a6, type WorkoutPillStatus as a7, type WorkoutProgress as a8, type WorkoutStatus as a9, calculateMeanVelocity as aa, calculateVelocityLoss as ab, getVelocityZoneColor as ac, getVelocityZoneName as ad, ActiveWorkoutPage as ae, EXERCISE_DETAIL_TABS as af, ExerciseDetailPage as ag, ProgramPlanningPage as ah, buildBreadcrumbs as ai, countCompletedSets as aj, deriveExerciseStats as ak, deriveNavLevel as al, deriveWorkoutProgress as am, findActiveExercise as an, findMeso as ao, findWeek as ap, findWorkout as aq, groupExercises as ar, statusToCardState as as, summarizeVbt as at, toActiveCardProps as au, toExerciseCardProps as av, toProgressBarMesos as aw, type ActiveWorkoutInput as b, type ActiveWorkoutPageProps as c, type ActiveWorkoutRest as d, type ActiveWorkoutSuperset as e, type CapacityBandChartProps as f, type CapacityBandDataPoint as g, type CapacityBandProjection as h, type ExerciseCardProps as i, type ExerciseCardState as j, type ExerciseDetailEntry as k, type ExerciseDetailHeader as l, type ExerciseDetailPageProps as m, type ExerciseDetailStats as n, type ExerciseDetailTab as o, type ExerciseTrend as p, type ExerciseVbt as q, type ExerciseVbtSet as r, MesoCard as s, type MesoCardProps as t, MesoProgressBar as u, type MesoProgressBarProps as v, type MesoStatus as w, type MesoVolumeHeatmapEntry as x, type PlanMeso as y, type PlanWeek as z };