@titan-design/react-ui 0.6.0 → 0.8.0

package/dist/{pages-MO0JCySL.d.mts → pages-DCFBqp79.d.mts}

@@ -2,20 +2,6 @@ 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.
@@ -59,8 +45,20 @@ interface VelocityStripProps extends ViewProps {
      * 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.
+     *
+     * Optional: provide exactly one of `velocities` or {@link VelocityStripProps.set}.
+     * When neither is given the strip renders nothing.
      */
-    velocities: number[];
+    velocities?: number[];
+    /**
+     * Optional structured strength-training set descriptor (see {@link VelocitySet}).
+     * When present it supersedes `velocities`: the done-velocity array is derived
+     * from the set (so mean / loss / zone summaries still work) and the strip is
+     * drawn as a typed slot list — grey todo, cyan variable / continue windows and
+     * the wide-gap chunking that distinguishes drop / myo / cluster sets. Provide
+     * exactly one of `velocities` or `set`.
+     */
+    set?: VelocitySet;
     /**
      * Optional velocity-zone bands (shape-compatible with WA's
      * `VelocityZones.bands`). When provided, bar color and the summary zone label
@@ -73,13 +71,45 @@ interface VelocityStripProps extends ViewProps {
      * 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.
+     * Framed `expanded` chart only (interactive tap-to-expand use).
      */
     liveRepIndex?: number;
+    /**
+     * `expanded` variant: whether the chart is OPEN. Default true (the variant shows
+     * its chart). Toggle it (with {@link onToggle}) for the interactive tap-to-expand
+     * collapse↔chart animation; a static open chart (no `onToggle`) does not animate.
+     */
     expanded?: boolean;
     onToggle?: () => void;
     onRepPress?: (index: number, velocity: number) => void;
-    variant?: 'full' | 'mini';
+    /**
+     * `mini` — a flat 3px static strip (set-type aware). `expanded` — the velocity-
+     * HEIGHT bar chart (rounded tops), whose chrome is prop-driven: with
+     * {@link showNumbers} or {@link showInfo} on it's the framed chart (raised surface,
+     * padding, per-bar m/s labels, mean/loss info row, interactive collapse); with both
+     * off it's a bare strip — the active-set "spotlight" of {@link ExerciseCard}. `hero`
+     * — the across-the-room, single-set wall treatment: tall bars, a per-bar m/s value
+     * label, a dashed running-best reference line, and dashed placeholders for the reps
+     * still to come (see {@link targetReps}). Reuses the zone scale and the live-rep pop.
+     */
+    variant?: 'mini' | 'expanded' | 'hero';
+    /** `expanded` / `hero` plot height in px (bars scale to this). Default 60 (`expanded`) / 220 (`hero`). */
+    height?: number;
+    /**
+     * `hero` only: the set's planned rep count. Reps beyond {@link velocities} draw as
+     * dashed placeholder stubs so the wall reads "3 of 8 done" at a glance. Ignored
+     * (and no placeholders drawn) when absent or ≤ the performed-rep count.
+     */
+    targetReps?: number;
+    /**
+     * `expanded` / `hero` bar scaling. `peak` (default) scales to the set's own max
+     * (+15% headroom). `fixed` scales to a fixed velocity ceiling so bar heights read
+     * the same absolute velocity across sets (the spotlight).
+     */
+    scale?: 'peak' | 'fixed';
+    /** `expanded` framed chart: per-bar m/s labels. Default true. */
+    showNumbers?: boolean;
+    /** `expanded` framed chart: the mean/loss info row. Default true. */
     showInfo?: boolean;
     className?: string;
 }
@@ -93,46 +123,232 @@ declare function getVelocityZoneName(velocity: number): string;
 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;
+/**
+ * A structured strength-training set. Supply as {@link VelocityStripProps.set} to
+ * render its set-type encoding; the done-velocity array (used for the mean / loss
+ * / zone summary) is derived from the type's velocity fields.
+ */
+type VelocitySet = 
+/** Fixed reps at a fixed load: done reps colored + a grey todo remainder to `planned`. */
+{
+    type: 'straight';
+    velocities: number[];
+    planned?: number;
+}
+/** Bounded reps: committed slots `0..floor`, then a cyan variable window `floor..max`. */
+ | {
+    type: 'range';
+    velocities: number[];
+    floor: number;
+    max: number;
+}
+/** As-many-reps-as-possible: done reps + a trailing cyan "continue" slot that never closes. */
+ | {
+    type: 'amrap';
+    velocities: number[];
+    target?: number;
+}
+/** Load drops with no rest: each sub-load's reps, split by a WIDE notch gap. */
+ | {
+    type: 'drop';
+    subloads: number[][];
+}
+/** Rest-pause: an activation chunk + mini-clusters split by WIDE gaps; `open` adds a cyan continue. */
+ | {
+    type: 'myo';
+    activation: number[];
+    clusters: number[][];
+    open?: boolean;
+}
+/** Fixed count broken by intra-set rests: reps grouped by `groupSize` with WIDE intra-rest gaps. */
+ | {
+    type: 'cluster';
+    velocities: number[];
+    groupSize: number;
+    planned?: number;
+};
+declare function VelocityStrip({ velocities, set, zones, liveRepIndex, expanded, onToggle, onRepPress, variant, height, targetReps, scale, showNumbers, showInfo, className, ...props }: VelocityStripProps): react_jsx_runtime.JSX.Element | null;
 
-type SetRowMode = 'active' | 'completed' | 'history';
-interface SetRowProps {
-    mode: SetRowMode;
+type SetRowUnit = 'lbs' | 'kg';
+/** A set's lifecycle: logged (`done`), being performed now (`live`), or planned (`todo`). */
+type SetRowState = 'done' | 'live' | 'todo';
+interface SetRowBase {
     setNumber: number;
-    previous?: {
+    unit: SetRowUnit;
+    /** Optional set-type marker (e.g. "DROP", "AMRAP") shown in the SET cell. */
+    setType?: string;
+    /** Optional velocity-zone bands (WA `VelocityZones.bands`); default scale when absent. */
+    velocityZones?: readonly VelocityZoneBandProp[];
+}
+/**
+ * One row of the unified expanded exercise table (SET · REPS · LBS · RPE + a
+ * per-row velocity strip), as a lifecycle discriminated union:
+ * - `done` — a logged set: recorded reps / weight / rpe, a flat `mini` strip.
+ * - `live` — performed right now: shows its TARGET (never "reps-done/target"),
+ *   stands out by brightness, and a compact velocity-HEIGHT spotlight strip.
+ * - `todo` — planned: shows its target, muted, a flat grey `mini` stub strip.
+ *
+ * `done` + `todo` share ONE muted treatment; only `live` is brightened. There is
+ * no PREV column (dropped in the unified design).
+ */
+type SetRowProps = (SetRowBase & {
+    state: 'done';
+    reps: number;
+    weight: number;
+    rpe?: number | null;
+    /** Per-rep MEAN concentric velocities (m/s). */
+    velocities: number[];
+}) | (SetRowBase & {
+    state: 'live';
+    /** The prescribed target shown in the REPS / LBS cells (no live "5/10"). */
+    target: {
         reps: number;
         weight: number;
-    } | null;
-    reps: number | null;
-    weight: number | null;
+    };
+    /** Reps / weight committed so far (available to hosts; the display shows `target`). */
+    reps: number;
+    weight: number;
     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?: {
+    /** Per-rep MEAN concentric velocities logged so far this set. */
+    velocities: number[];
+    /** Newest rep index — reserved; the compact spotlight strip is static. */
+    liveRepIndex?: number;
+}) | (SetRowBase & {
+    state: 'todo';
+    /** The prescribed target shown in the REPS / LBS cells. */
+    target: {
         reps: number;
         weight: number;
     };
+    /** Planned rep count backing the grey stub strip. Default `target.reps`. */
+    planned?: number;
+});
+/**
+ * ONE set row of the unified expanded exercise table. SET · REPS · LBS · RPE over
+ * a per-row {@link VelocityStrip}; `live` stands out by brightness with a compact
+ * velocity-height spotlight, `done`/`todo` are muted with a flat mini strip. Its
+ * column widths mirror {@link SetTableHeader}(`showPrevious={false}`).
+ */
+declare function SetRow(set: SetRowProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * The four canonical rep-intensity zone pins (real titan ramp pins). A rep's mean
+ * velocity ratio maps to one of these; butted together they form a set's bar.
+ */
+declare const SET_STRIP_ZONES: {
+    readonly slow: "#D14343";
+    readonly moderate: "#FF7900";
+    readonly fast: "#F9B415";
+    readonly fastest: "#2ED573";
+};
+/**
+ * The learned "variable / unknown / opportunity" semantic (cyan-900, a real ramp
+ * pin): an unperformed rep in a range's variable zone, and the fading trail of a
+ * myo set whose cluster count isn't yet known.
+ */
+declare const SET_STRIP_VARIABLE_COLOR: "#0B3149";
+/** Map a per-rep mean-velocity ratio to its zone pin (fastest = green, slowest = red). */
+declare function velocityZoneColor(v: number): string;
+/**
+ * One set's data. Flat variants: `done` = every rep performed; `active` = reps-so-far
+ * performed against a planned count (remainder greyed, performed reps pulse); `todo` =
+ * a planned but unstarted set (solid grey bar). Set-type variants:
+ * - `range` — variable rep-range (e.g. 15–20): `max` segments; committed zone
+ *   `0..floor` (done = velocity, todo = grey), variable zone `floor..max` (done =
+ *   velocity, todo = the variable/opportunity cyan). `doneVels` may run past `floor`.
+ * - `drop` — one set, no rest: `subloads` butted internally, split by 2px notches.
+ * - `myo` — done rest-pause: `activation` chunk + `clusters`, split by 3px cluster gaps.
+ * - `myo-upcoming` — planned myo, length unknown: grey activation (`activationLen`) +
+ *   a fading cyan "clusters-to-failure" trail with the right edge left open.
+ */
+type SetStripSet = {
+    status: 'done';
+    velocities: number[];
+} | {
+    status: 'active';
+    velocities: number[];
+    planned: number;
+} | {
+    status: 'todo';
+    planned: number;
+} | {
+    status: 'range';
+    floor: number;
+    max: number;
+    doneVels: number[];
+} | {
+    status: 'drop';
+    subloads: number[][];
+} | {
+    status: 'myo';
+    activation: number[];
+    clusters: number[][];
+} | {
+    status: 'myo-upcoming';
+    activationLen: number;
+    clusterCount?: number;
+};
+interface SetBarProps {
+    /** One set's performance state (done / active / todo). */
+    set: SetStripSet;
+    /** Bar height in px. Default 8. */
+    height?: 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;
+/**
+ * ONE set's multi-coloured bar: the butted per-rep colour segments for a single
+ * set (`done` = velocity-coloured reps · `active` = performed reps pulsing + grey
+ * remainder · `todo` = a solid grey bar), composed over {@link SegmentedBar}.
+ * Fills its flex slot; {@link SetStrip} lays several side by side. Colours are the
+ * real titan ramp pins.
+ */
+declare function SetBar({ set, height }: SetBarProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * The LOCKED 6-kind indicator taxonomy (TD-03.51). One precedence-ranked slot is
+ * ever shown per exercise, resolved by {@link resolveIndicator}. Glyph = the
+ * specific signal; color = the severity tier (danger/warning/success/info, bound
+ * to titan status tokens). Outlined (border + glyph, no fill) so a chip never
+ * collides with the filled velocity strip beside it.
+ */
+type ExerciseIndicatorKind = 'imbalance' | 'overshoot' | 'velocity-loss' | 'missed-reps' | 'pr' | 'info';
+/**
+ * Precedence order (1=highest → last=lowest). A single chip is shown, so when
+ * several signals are true the highest-ranked wins. Alerts outrank `pr`; `info`
+ * is the floor. This ordering is LOCKED — do not reshuffle.
+ */
+declare const INDICATOR_PRECEDENCE: readonly ExerciseIndicatorKind[];
+/**
+ * Given the signals currently true for an exercise, pick the single
+ * highest-precedence kind to surface (or `undefined` when none apply). Order and
+ * duplicates in `candidates` don't matter — {@link INDICATOR_PRECEDENCE} decides.
+ */
+declare function resolveIndicator(candidates: ExerciseIndicatorKind[]): ExerciseIndicatorKind | undefined;
+interface ExerciseIndicatorProps extends Omit<ViewProps, 'children'> {
+    kind: ExerciseIndicatorKind;
+    /** Optional tap handler (surfaces detail — PR history / alert / info). */
+    onPress?: () => void;
+    className?: string;
+}
+/**
+ * A small circular outlined chip for an exercise heading. Presentational and
+ * static (chips are chrome — no pulse); the tap detail (tooltip/sheet) is wired
+ * by the consumer.
+ */
+declare function ExerciseIndicator({ kind, onPress, className, ...props }: ExerciseIndicatorProps): react_jsx_runtime.JSX.Element;
 
-type ExerciseCardState = 'collapsed' | 'expanded' | 'upcoming';
 interface ExerciseCardProps {
     name: string;
-    state: ExerciseCardState;
-    onToggle: () => void;
+    /**
+     * The dimmed, not-yet-reached representation (prescription + previous-best line).
+     * Overrides the expand state — an upcoming card never expands.
+     */
+    upcoming?: boolean;
+    /** Controlled expand state. Omit to run uncontrolled (see {@link defaultExpanded}). */
+    expanded?: boolean;
+    /** Uncontrolled initial expand state. Default false. Ignored when `expanded` is set. */
+    defaultExpanded?: boolean;
+    /** Notified when the user toggles the card between collapsed and expanded. */
+    onExpandedChange?: (expanded: boolean) => void;
     onNavigateDetail?: () => void;
     summary?: {
         sets: number;
@@ -140,23 +356,38 @@ interface ExerciseCardProps {
         weight: number;
         unit: 'lbs' | 'kg';
     };
-    e1rm?: {
-        value: number;
-        unit: 'lbs' | 'kg';
-    };
     isPR?: boolean;
+    /** Collapsed glance: per-set logged velocities (drives the mini strips). */
     setVelocities?: number[][];
     /** Optional velocity-zone bands shared across this exercise's sets (WA bands). */
     velocityZones?: readonly VelocityZoneBandProp[];
+    /** Collapsed glance: total planned sets (placeholder strips fill the remainder). */
     totalPlannedSets?: number;
+    /** Expanded body: the per-set rows (done / live / todo). */
     sets?: SetRowProps[];
     tempo?: [number, number, number, number];
     prescription?: string;
     previousBest?: string;
     supersetPosition?: 'first' | 'last' | 'middle' | null;
     supersetColor?: string;
+    /** Expanded header per-set strip override; derived from `sets` when omitted. */
+    setStates?: SetStripSet[];
+    /** A small PR / issue / info chip in the title line (expanded header). */
+    indicator?: ExerciseIndicatorKind;
+    /** Expanded header strip height in px. Default 8. */
+    stripHeight?: number;
 }
-declare function ExerciseCard(props: ExerciseCardProps): react_jsx_runtime.JSX.Element;
+/**
+ * The data-contract exercise card, in three representations:
+ * - `upcoming` — a dimmed, not-yet-reached row (prescription + previous best).
+ * - collapsed — a glance: name + summary + per-set velocity strips.
+ * - expanded — the unified card: the real {@link ExerciseCardHeading} header over
+ *   the SET · REPS · LBS · RPE body (one {@link SetRow} per set).
+ *
+ * Expand is controlled (`expanded` + `onExpandedChange`) or uncontrolled
+ * (`defaultExpanded`, internal state). `upcoming` overrides expand.
+ */
+declare function ExerciseCard({ upcoming, expanded, defaultExpanded, onExpandedChange, ...rest }: ExerciseCardProps): react_jsx_runtime.JSX.Element;
 
 type MesoStatus = 'completed' | 'current' | 'upcoming';
 interface Meso {
@@ -564,8 +795,11 @@ interface ExerciseDetailEntry {
     title: string;
     /** Collapsed summary (sets × reps @ weight). */
     summary?: ExerciseCardProps['summary'];
-    /** Estimated one-rep max badge. */
-    e1rm?: ExerciseCardProps['e1rm'];
+    /** Estimated one-rep max, feeding the page's best-e1RM stat. */
+    e1rm?: {
+        value: number;
+        unit: 'lbs' | 'kg';
+    };
     /** Flags a personal-record entry. */
     isPR?: boolean;
     /** Prescribed tempo, revealed when expanded. */
@@ -681,8 +915,6 @@ interface ActiveWorkoutExercise {
     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. */
@@ -768,8 +1000,8 @@ declare function countCompletedSets(exercise: ActiveWorkoutExercise): number;
 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;
+/** Whether an exercise renders as the dimmed, not-yet-reached representation (pure). */
+declare function isUpcomingExercise(status: ActiveExerciseStatus): boolean;
 /** 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). */
@@ -788,4 +1020,4 @@ declare function groupExercises(exercises: ActiveWorkoutExercise[], supersets: A
  */
 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 };
+export { VelocityStrip as $, type ActiveExerciseStatus as A, type PlanWeek as B, CapacityBandChart as C, type PlanWorkout as D, type ExerciseIndicatorKind as E, type ProgramBreadcrumb as F, type ProgramNavLevel as G, type ProgramPlanningPageProps as H, INDICATOR_PRECEDENCE as I, type ProgramSelection as J, SET_STRIP_VARIABLE_COLOR as K, SET_STRIP_ZONES as L, type Meso as M, SetBar as N, type SetBarProps as O, type PlanMeso as P, SetRow as Q, type SetRowProps as R, type SetStripSet as S, type SetRowState as T, type SetRowUnit as U, StrengthTrendChart as V, type StrengthTrendChartMesoBoundary as W, type StrengthTrendChartProps as X, type StrengthTrendDataPoint as Y, type VbtSummary as Z, type VelocitySet as _, type ActiveWorkoutExercise as a, type VelocityStripProps as a0, type VelocityZoneBandProp as a1, WeekRow as a2, type WeekRowProps as a3, type WeekRowWorkout as a4, WorkoutCard as a5, type WorkoutCardProps as a6, type WorkoutDot as a7, type WorkoutDotStatus as a8, type WorkoutGroup as a9, groupExercises as aA, isUpcomingExercise as aB, summarizeVbt as aC, toActiveCardProps as aD, toExerciseCardProps as aE, toProgressBarMesos as aF, type WorkoutMuscleGroup as aa, type WorkoutMuscleVolumeStatus as ab, WorkoutPill as ac, type WorkoutPillProps as ad, type WorkoutPillStatus as ae, type WorkoutProgress as af, type WorkoutStatus as ag, calculateMeanVelocity as ah, calculateVelocityLoss as ai, getVelocityZoneColor as aj, getVelocityZoneName as ak, resolveIndicator as al, velocityZoneColor as am, ActiveWorkoutPage as an, EXERCISE_DETAIL_TABS as ao, ExerciseDetailPage as ap, ProgramPlanningPage as aq, buildBreadcrumbs as ar, countCompletedSets as as, deriveExerciseStats as at, deriveNavLevel as au, deriveWorkoutProgress as av, findActiveExercise as aw, findMeso as ax, findWeek as ay, findWorkout as az, 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, ExerciseCard as i, type ExerciseCardProps as j, type ExerciseDetailEntry as k, type ExerciseDetailHeader as l, type ExerciseDetailPageProps as m, type ExerciseDetailStats as n, type ExerciseDetailTab as o, ExerciseIndicator as p, type ExerciseIndicatorProps as q, type ExerciseTrend as r, type ExerciseVbt as s, type ExerciseVbtSet as t, MesoCard as u, type MesoCardProps as v, MesoProgressBar as w, type MesoProgressBarProps as x, type MesoStatus as y, type MesoVolumeHeatmapEntry as z };