hevy-shared 1.0.994 → 1.0.996

package/built/hevyTrainer.d.ts

@@ -1,6 +1,6 @@
-import { WeeklyTrainingFrequency, TrainingGoal, TrainingLevel, SimplifiedMuscleGroup, MuscleGroup, LibraryExercise, ExerciseCategory, GranularEquipment, HevyTrainerProgramEquipment, RestTimerLength, CardioPreference, StrictRepRange } from '.';
+import { WeeklyTrainingFrequency, TrainingGoal, TrainingLevel, SimplifiedMuscleGroup, MuscleGroup, LibraryExercise, ExerciseCategory, GranularEquipment, HevyTrainerProgramEquipment, RestTimerLength, CardioPreference } from '.';
 export type HevyTrainerExerciseCategory = typeof hevyTrainerExerciseCategories[number];
-export type TrainerWorkoutTemplateName = typeof workoutTemplateNames[number];
+export type HevyTrainerRoutineName = typeof routineNames[number];
 export declare const workoutDurationOptions: readonly [40, 60, 80];
 export type WorkoutDurationMinutes = typeof workoutDurationOptions[number];
 export declare const trainerGymTypes: readonly ["home_gym", "garage_gym", "commercial_gym", "full_gym"];
@@ -16,12 +16,12 @@ export declare const trainerEquipmentToGranularEquipments: (equipments: HevyTrai
 export declare const granularEquipmentsToTrainerEquipments: (granularEquipments: GranularEquipment[]) => HevyTrainerProgramEquipment[];
 export declare const hevyTrainerExerciseCategories: readonly ["compound", "isolation"];
 export declare const defaultDurationPerFrequency: Record<WeeklyTrainingFrequency, WorkoutDurationMinutes>;
-export declare const workoutTemplateNames: readonly ["full_body_1", "full_body_2_a", "full_body_2_b", "full_body_3_a", "full_body_3_b", "full_body_3_c", "upper_1_a", "lower_1_a", "upper_1_b", "lower_1_b", "push_1", "pull_1", "legs_1", "upper_2", "lower_2", "push_2_a", "pull_2_a", "legs_2_a", "push_2_b", "pull_2_b", "legs_2_b"];
+export declare const routineNames: readonly ["full_body_1", "full_body_2_a", "full_body_2_b", "full_body_3_a", "full_body_3_b", "full_body_3_c", "upper_1_a", "lower_1_a", "upper_1_b", "lower_1_b", "push_1", "pull_1", "legs_1", "upper_2", "lower_2", "push_2_a", "pull_2_a", "legs_2_a", "push_2_b", "pull_2_b", "legs_2_b"];
 export type exerciseId = string;
 export interface ExerciseSelectionCriteria {
     exerciseCategory: HevyTrainerExerciseCategory | 'all';
     equipments: GranularEquipment[];
-    workoutBarbellExerciseCount: number;
+    routineBarbellExerciseCount: number;
     level: TrainingLevel;
     goal: TrainingGoal;
     muscleGroup: MuscleGroup;
@@ -29,7 +29,7 @@ export interface ExerciseSelectionCriteria {
 }
 export interface ExerciseSelectionContext {
     programUsedExerciseIds?: Set<string>;
-    workoutUsedExerciseIds?: Set<string>;
+    routineUsedExerciseIds?: Set<string>;
     excludedExerciseIds?: Set<string>;
 }
 export interface ExerciseSelectionParams<T extends HevyTrainerLibraryExercise> {
@@ -69,7 +69,7 @@ export interface ProgramGenerationParams<T extends HevyTrainerLibraryExercise> {
 }
 export interface TemplateExerciseSelectionTraceRecord {
     traceKind: 'template';
-    workoutTemplate: TrainerWorkoutTemplateName;
+    routine: HevyTrainerRoutineName;
     prescriptionIndex: number;
     prescription: ExercisePrescription;
     resolvedMuscleGroup: MuscleGroup;
@@ -79,7 +79,7 @@ export interface TemplateExerciseSelectionTraceRecord {
 }
 export interface CardioExerciseSelectionTraceRecord {
     traceKind: 'cardio';
-    workoutTemplate: TrainerWorkoutTemplateName;
+    routine: HevyTrainerRoutineName;
     prescriptionIndex: number;
     selectedExerciseId?: string;
     equipments: GranularEquipment[];
@@ -87,24 +87,24 @@ export interface CardioExerciseSelectionTraceRecord {
     trace: ExerciseSelectionTrace;
 }
 export type ProgramExerciseSelectionTraceRecord = TemplateExerciseSelectionTraceRecord | CardioExerciseSelectionTraceRecord;
-export type TrainerProgramAttemptWithTraces<T> = TrainerProgramAttempt<T> & {
+export type TrainerProgramAttemptWithTraces = TrainerProgramAttempt & {
     exerciseSelectionTraces: ProgramExerciseSelectionTraceRecord[];
 };
 export type FrequencyString = 'one_day' | 'two_days' | 'three_days' | 'four_days' | 'five_days' | 'six_days';
 export declare const frequencyMap: Record<WeeklyTrainingFrequency, FrequencyString>;
-export declare const programSplits: Record<WeeklyTrainingFrequency, TrainerWorkoutTemplateName[]>;
+export declare const programSplits: Record<WeeklyTrainingFrequency, HevyTrainerRoutineName[]>;
 export type SetsPerGoal = {
     [key in TrainingGoal]: number;
 };
 export type SetsPerFrequency = {
     [key in FrequencyString]: SetsPerGoal;
 };
-export interface AlgorithmRepRange {
+export interface RepRange {
     rep_range_start: number;
     rep_range_end: number;
 }
 export type RepRangesPerCategory = {
-    [key in HevyTrainerExerciseCategory]: AlgorithmRepRange;
+    [key in HevyTrainerExerciseCategory]: RepRange;
 };
 export type RepRanges = {
     [key in TrainingGoal]: RepRangesPerCategory;
@@ -138,7 +138,7 @@ export interface WorkoutTemplate {
     notes?: string;
 }
 export type Templates = {
-    [key in TrainerWorkoutTemplateName]: WorkoutTemplate;
+    [key in HevyTrainerRoutineName]: WorkoutTemplate;
 };
 export interface BackofficeTrainerPreset {
     id?: number;
@@ -157,38 +157,39 @@ export interface TrainerAlgorithmSettings {
     exercise_notes: ExerciseNotes;
     exercise_replacements: ExerciseReplacements;
 }
-export interface TrainerProgramResistanceExercise<T> {
+/** Resistance prescriptions from templates (sets, reps, rest, notes). */
+export interface TrainerProgramResistanceExercise {
     kind: 'resistance';
-    exercise_template: T;
-    set_count: number;
-    warmup_set_count: number;
-    rep_range: StrictRepRange;
-    rest_seconds: number;
+    exerciseTemplate: HevyTrainerLibraryExercise;
+    muscleGroup: MuscleGroup | 'focus_muscle';
+    category: HevyTrainerExerciseCategory;
+    sets: number;
+    warmupSetCount?: number;
+    repRangeStart: number;
+    repRangeEnd: number;
+    restTimerSeconds: number;
+    notes?: string;
 }
-export interface TrainerProgramCardioExercise<T> {
+/** Optional cardio attachment — no prescription semantics beyond exercise choice. */
+export interface TrainerProgramCardioExercise {
     kind: 'cardio';
-    exercise_template: T;
-    set_count: 1;
-    duration_seconds: number;
+    exerciseTemplate: HevyTrainerLibraryExercise;
+    durationSeconds: number;
 }
-export interface TrainerProgramOtherExercise<T> {
-    kind: 'other';
-    exercise_template: T;
-    set_count: number;
-}
-export type TrainerProgramExercise<T> = TrainerProgramResistanceExercise<T> | TrainerProgramCardioExercise<T> | TrainerProgramOtherExercise<T>;
-export declare const isTrainerProgramResistanceExercise: <T>(exercise: TrainerProgramExercise<T>) => exercise is TrainerProgramResistanceExercise<T>;
-export declare const isTrainerProgramCardioExercise: <T>(exercise: TrainerProgramExercise<T>) => exercise is TrainerProgramCardioExercise<T>;
-export declare const isTrainerProgramOtherExercise: <T>(exercise: TrainerProgramExercise<T>) => exercise is TrainerProgramOtherExercise<T>;
-export interface TrainerProgramWorkoutTemplate<T> {
-    name: TrainerWorkoutTemplateName;
-    exercises: TrainerProgramExercise<T>[];
+export type TrainerProgramExercise = TrainerProgramResistanceExercise | TrainerProgramCardioExercise;
+export declare const isTrainerProgramResistanceExercise: (exercise: TrainerProgramExercise) => exercise is TrainerProgramResistanceExercise;
+export declare const isTrainerProgramCardioExercise: (exercise: TrainerProgramExercise) => exercise is TrainerProgramCardioExercise;
+export interface TrainerProgramRoutine {
+    name: HevyTrainerRoutineName;
+    exercises: TrainerProgramExercise[];
+    notes?: string;
 }
-export interface GeneratedTrainerProgram<T> {
-    workoutTemplates: TrainerProgramWorkoutTemplate<T>[];
+export interface TrainerProgram {
+    name: WeeklyTrainingFrequency;
+    routines: TrainerProgramRoutine[];
 }
 export declare const getTrainerSetCount: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, frequency: WeeklyTrainingFrequency) => number;
-export declare const getTrainerRepRange: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, exerciseCategory: HevyTrainerExerciseCategory) => AlgorithmRepRange;
+export declare const getTrainerRepRange: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, exerciseCategory: HevyTrainerExerciseCategory) => RepRange;
 export declare const getTrainerRestTimerSeconds: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, length: RestTimerLength, exerciseCategory: HevyTrainerExerciseCategory) => number;
 /**
  * Normalizes the exercise category to a HevyTrainerExerciseCategory
@@ -242,16 +243,25 @@ export interface ExercisePrescriptionError {
         focusMuscle?: SimplifiedMuscleGroup;
     };
 }
-export interface TrainerProgramResult<T> {
+export interface TrainerProgramExerciseResult {
+    success: true;
+    exercise: TrainerProgramExercise;
+}
+export interface TrainerProgramExerciseError {
+    success: false;
+    error: ExercisePrescriptionError;
+}
+export type TrainerProgramExerciseAttempt = TrainerProgramExerciseResult | TrainerProgramExerciseError;
+export interface TrainerProgramResult {
     success: true;
-    program: GeneratedTrainerProgram<T>;
+    program: TrainerProgram;
 }
-export interface TrainerProgramError<T> {
+export interface TrainerProgramError {
     success: false;
     errors: ExercisePrescriptionError[];
-    partialProgram: GeneratedTrainerProgram<T>;
+    partialProgram: TrainerProgram;
 }
-export type TrainerProgramAttempt<T> = TrainerProgramResult<T> | TrainerProgramError<T>;
+export type TrainerProgramAttempt = TrainerProgramResult | TrainerProgramError;
 /**
  * Generates a complete training program based on the provided parameters
  * - debugExerciseSelectionTrace: true -> includes exercise selection trace breadcrumbs in the result for debugging.
@@ -259,6 +269,6 @@ export type TrainerProgramAttempt<T> = TrainerProgramResult<T> | TrainerProgramE
  */
 export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T> & {
     debugExerciseSelectionTrace: true;
-}): TrainerProgramAttemptWithTraces<T>;
-export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T>): TrainerProgramAttempt<T>;
+}): TrainerProgramAttemptWithTraces;
+export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T>): TrainerProgramAttempt;
 export {};

package/built/hevyTrainer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TRAINER_CARDIO_ATTACHMENT_DURATION_SECONDS = exports.getPrioritySortedExercises = exports.isEquipmentCompatible = exports.normalizeExerciseCategory = exports.getTrainerRestTimerSeconds = exports.getTrainerRepRange = exports.getTrainerSetCount = exports.isTrainerProgramOtherExercise = exports.isTrainerProgramCardioExercise = exports.isTrainerProgramResistanceExercise = exports.programSplits = exports.frequencyMap = exports.workoutTemplateNames = exports.defaultDurationPerFrequency = exports.hevyTrainerExerciseCategories = exports.granularEquipmentsToTrainerEquipments = exports.trainerEquipmentToGranularEquipments = exports.granularEquipmentDefaults = exports.trainerGymTypes = exports.workoutDurationOptions = void 0;
+exports.DEFAULT_TRAINER_CARDIO_ATTACHMENT_DURATION_SECONDS = exports.getPrioritySortedExercises = exports.isEquipmentCompatible = exports.normalizeExerciseCategory = exports.getTrainerRestTimerSeconds = exports.getTrainerRepRange = exports.getTrainerSetCount = exports.isTrainerProgramCardioExercise = exports.isTrainerProgramResistanceExercise = exports.programSplits = exports.frequencyMap = exports.routineNames = exports.defaultDurationPerFrequency = exports.hevyTrainerExerciseCategories = exports.granularEquipmentsToTrainerEquipments = exports.trainerEquipmentToGranularEquipments = exports.granularEquipmentDefaults = exports.trainerGymTypes = exports.workoutDurationOptions = void 0;
 exports.pickTrainerExercise = pickTrainerExercise;
 exports.generateProgram = generateProgram;
 const _1 = require(".");
@@ -152,7 +152,7 @@ exports.defaultDurationPerFrequency = {
     5: 40,
     6: 40,
 };
-exports.workoutTemplateNames = [
+exports.routineNames = [
     // Full body 1x
     'full_body_1',
     // Full body 2x
@@ -201,8 +201,6 @@ const isTrainerProgramResistanceExercise = (exercise) => exercise.kind === 'resi
 exports.isTrainerProgramResistanceExercise = isTrainerProgramResistanceExercise;
 const isTrainerProgramCardioExercise = (exercise) => exercise.kind === 'cardio';
 exports.isTrainerProgramCardioExercise = isTrainerProgramCardioExercise;
-const isTrainerProgramOtherExercise = (exercise) => exercise.kind === 'other';
-exports.isTrainerProgramOtherExercise = isTrainerProgramOtherExercise;
 const getTrainerSetCount = (trainerAlgorithmSettings, goal, frequency) => {
     return trainerAlgorithmSettings.sets[exports.frequencyMap[frequency]][goal];
 };
@@ -293,12 +291,12 @@ const MAX_BARBELL_EXERCISES_FOR_ONCE_PER_WEEK = 3;
  * - Only enforce the cap when the user has at least one "barbell substitute" equipment available
  *   (otherwise we allow barbell exercises to avoid running out of viable options)
  */
-const isBarbellExerciseAllowed = (exercise, workoutBarbellExerciseCount, userEquipments, frequency) => {
+const isBarbellExerciseAllowed = (exercise, routineBarbellExerciseCount, userEquipments, frequency) => {
     const isCandidateBarbell = exercise.equipment_category === 'barbell';
     const isOncePerWeek = frequency === 1;
     if (!isCandidateBarbell || !isOncePerWeek)
         return true;
-    const isAtOrOverLimit = workoutBarbellExerciseCount >= MAX_BARBELL_EXERCISES_FOR_ONCE_PER_WEEK;
+    const isAtOrOverLimit = routineBarbellExerciseCount >= MAX_BARBELL_EXERCISES_FOR_ONCE_PER_WEEK;
     if (!isAtOrOverLimit)
         return true;
     const barbellSubstitutes = [
@@ -316,7 +314,7 @@ const isBarbellExerciseAllowed = (exercise, workoutBarbellExerciseCount, userEqu
 const isExerciseUsed = (exercise, context) => {
     var _a, _b, _c;
     return (((_a = context.programUsedExerciseIds) === null || _a === void 0 ? void 0 : _a.has(exercise.id)) ||
-        ((_b = context.workoutUsedExerciseIds) === null || _b === void 0 ? void 0 : _b.has(exercise.id)) ||
+        ((_b = context.routineUsedExerciseIds) === null || _b === void 0 ? void 0 : _b.has(exercise.id)) ||
         ((_c = context.excludedExerciseIds) === null || _c === void 0 ? void 0 : _c.has(exercise.id)) ||
         false);
 };
@@ -395,16 +393,16 @@ const getPrioritySortedExercises = (exercisePriorities, exerciseStore) => {
     return sortedExercises;
 };
 exports.getPrioritySortedExercises = getPrioritySortedExercises;
-const getMuscleGroup = ({ muscleGroupPrescription, programFocusMuscleExerciseCount, focusMuscle, workoutTemplateName, }) => {
+const getMuscleGroup = ({ muscleGroupPrescription, programFocusMuscleExerciseCount, focusMuscle, routineName, }) => {
     if (muscleGroupPrescription === 'focus_muscle') {
-        // If the user has selected a focus muscle and it is allowed for the workout template,
+        // If the user has selected a focus muscle and it is allowed for the routine,
         // we return the focus muscle extra exercise
         if (!!focusMuscle &&
-            isFocusMuscleExtraExerciseAllowed(workoutTemplateName, focusMuscle)) {
+            isFocusMuscleExtraExerciseAllowed(routineName, focusMuscle)) {
             const n = _1.simplifiedMuscleGroupToMuscleGroups[focusMuscle].length;
             return _1.simplifiedMuscleGroupToMuscleGroups[focusMuscle][programFocusMuscleExerciseCount % n];
         }
-        // If the user has not selected a focus muscle or it is not allowed for the workout template
+        // If the user has not selected a focus muscle or it is not allowed for the routine
         // we skip this extra exercise for the focus muscle in the program
         return undefined;
     }
@@ -422,7 +420,7 @@ const isExerciseMatch = (exercise, criteria) => {
     const levelMatch = (_b = (_a = exercise.level) === null || _a === void 0 ? void 0 : _a.includes(criteria.level)) !== null && _b !== void 0 ? _b : false;
     const goalMatch = (_d = (_c = exercise.goal) === null || _c === void 0 ? void 0 : _c.includes(criteria.goal)) !== null && _d !== void 0 ? _d : false;
     const equipmentMatch = (0, exports.isEquipmentCompatible)(exercise, criteria.equipments);
-    const barbellLimitOk = isBarbellExerciseAllowed(exercise, criteria.workoutBarbellExerciseCount, criteria.equipments, criteria.frequency);
+    const barbellLimitOk = isBarbellExerciseAllowed(exercise, criteria.routineBarbellExerciseCount, criteria.equipments, criteria.frequency);
     return (categoryMatch && levelMatch && goalMatch && equipmentMatch && barbellLimitOk);
 };
 /**
@@ -467,8 +465,8 @@ const pickTrainerExerciseWithTrace = (params) => {
         programUsedExerciseIds: context.programUsedExerciseIds,
         excludedExerciseIds: context.excludedExerciseIds,
     };
-    const workoutContext = {
-        workoutUsedExerciseIds: context.workoutUsedExerciseIds,
+    const routineContext = {
+        routineUsedExerciseIds: context.routineUsedExerciseIds,
         excludedExerciseIds: context.excludedExerciseIds,
     };
     // Pass 1
@@ -482,10 +480,10 @@ const pickTrainerExerciseWithTrace = (params) => {
     if (exercise)
         return { exercise, trace: Object.assign(Object.assign({}, trace), { selectedPass: 1 }) };
     // Pass 2
-    exercise = findMatchingExercise(exercises, criteria, workoutContext);
+    exercise = findMatchingExercise(exercises, criteria, routineContext);
     trace.entries.push({
         pass: 2,
-        label: 'exact match; not used in the same workout (reuse allowed in program)',
+        label: 'exact match; not used in routine (reuse allowed in program)',
         candidatePoolSize: exercises.length,
         selectedExerciseId: exercise === null || exercise === void 0 ? void 0 : exercise.id,
     });
@@ -502,20 +500,20 @@ const pickTrainerExerciseWithTrace = (params) => {
     if (exercise)
         return { exercise, trace: Object.assign(Object.assign({}, trace), { selectedPass: 3 }) };
     // Pass 4
-    exercise = findAlternativeIsolationExercise(exercises, criteria, workoutContext);
+    exercise = findAlternativeIsolationExercise(exercises, criteria, routineContext);
     trace.entries.push({
         pass: 4,
-        label: 'handpicked alternative isolation; not used in the same workout (reuse allowed in program)',
+        label: 'handpicked alternative isolation; not used in routine (reuse allowed in program)',
         candidatePoolSize: exercises.length,
         selectedExerciseId: exercise === null || exercise === void 0 ? void 0 : exercise.id,
     });
     if (exercise)
         return { exercise, trace: Object.assign(Object.assign({}, trace), { selectedPass: 4 }) };
     // Pass 5
-    exercise = findMatchingExercise(exercises, Object.assign(Object.assign({}, criteria), { exerciseCategory: 'all' }), workoutContext);
+    exercise = findMatchingExercise(exercises, Object.assign(Object.assign({}, criteria), { exerciseCategory: 'all' }), routineContext);
     trace.entries.push({
         pass: 5,
-        label: 'match regardless of isolation or compound; not used in the same workout (reuse allowed in program)',
+        label: 'match regardless of isolation or compound; not used in routine (reuse allowed in program)',
         candidatePoolSize: exercises.length,
         selectedExerciseId: exercise === null || exercise === void 0 ? void 0 : exercise.id,
     });
@@ -525,10 +523,10 @@ const pickTrainerExerciseWithTrace = (params) => {
     const secondaryMuscleExercises = Object.values(sortedExercises)
         .flat()
         .filter((e) => e.other_muscles.includes(criteria.muscleGroup));
-    exercise = findMatchingExercise(secondaryMuscleExercises, Object.assign(Object.assign({}, criteria), { exerciseCategory: 'all' }), workoutContext);
+    exercise = findMatchingExercise(secondaryMuscleExercises, Object.assign(Object.assign({}, criteria), { exerciseCategory: 'all' }), routineContext);
     trace.entries.push({
         pass: 6,
-        label: 'secondary muscle match; regardless of isolation or compound; not used in the same workout (reuse allowed in program)',
+        label: 'secondary muscle match; regardless of isolation or compound; not used in routine (reuse allowed in program)',
         candidatePoolSize: secondaryMuscleExercises.length,
         selectedExerciseId: exercise === null || exercise === void 0 ? void 0 : exercise.id,
     });
@@ -544,11 +542,11 @@ function pickTrainerExercise(params) {
 }
 const CARDIO_TRACE_INDEX_BEFORE_TEMPLATE = -1;
 exports.DEFAULT_TRAINER_CARDIO_ATTACHMENT_DURATION_SECONDS = 600;
-/** Inserts optional cardio before or after template exercises for one workout template. */
-const attachOptionalCardioToWorkoutTemplate = ({ cardioPreference, sortedExercises, criteria, debugExerciseSelectionTrace, exerciseSelectionTraces, workoutTemplate, templatePrescriptionCount, workoutExercises, }) => {
+/** Inserts optional cardio before or after template exercises for one routine. */
+const attachOptionalCardioToRoutine = ({ cardioPreference, sortedExercises, criteria, debugExerciseSelectionTrace, exerciseSelectionTraces, routine, templatePrescriptionCount, routineExercises, }) => {
     if (cardioPreference === 'no-cardio')
         return;
-    // Cardio is reusable across workout templates, so program/workoutTemplate used-id contexts are
+    // Cardio is reusable across routines, so program/routine used-id contexts are
     // intentionally omitted — only the global excluded set applies.
     const selectionParams = {
         sortedExercises,
@@ -559,7 +557,7 @@ const attachOptionalCardioToWorkoutTemplate = ({ cardioPreference, sortedExercis
             equipments: criteria.equipments,
             muscleGroup: 'cardio',
             exerciseCategory: 'all',
-            workoutBarbellExerciseCount: 0,
+            routineBarbellExerciseCount: 0,
         },
         context: { excludedExerciseIds: criteria.excludedExerciseIds },
     };
@@ -569,18 +567,17 @@ const attachOptionalCardioToWorkoutTemplate = ({ cardioPreference, sortedExercis
         return;
     const slot = {
         kind: 'cardio',
-        exercise_template: cardioExercise,
-        duration_seconds: exports.DEFAULT_TRAINER_CARDIO_ATTACHMENT_DURATION_SECONDS,
-        set_count: 1,
+        exerciseTemplate: cardioExercise,
+        durationSeconds: exports.DEFAULT_TRAINER_CARDIO_ATTACHMENT_DURATION_SECONDS,
     };
     if (cardioPreference === 'workout-start')
-        workoutExercises.unshift(slot);
+        routineExercises.unshift(slot);
     else
-        workoutExercises.push(slot);
+        routineExercises.push(slot);
     if (debugExerciseSelectionTrace) {
         exerciseSelectionTraces.push({
             traceKind: 'cardio',
-            workoutTemplate,
+            routine,
             prescriptionIndex: cardioPreference === 'workout-start'
                 ? CARDIO_TRACE_INDEX_BEFORE_TEMPLATE
                 : templatePrescriptionCount,
@@ -595,27 +592,28 @@ function generateProgram(params) {
     var _a, _b;
     const { trainerAlgorithmSettings, frequency, goal, level, equipments, workoutDurationMinutes, restTimerLength, exerciseStore, focusMuscle, excludedExerciseIds, debugExerciseSelectionTrace, cardioPreference, } = params;
     const exerciseSelectionTraces = [];
-    const workoutTemplates = exports.programSplits[frequency];
+    const routines = exports.programSplits[frequency];
     const program = {
-        workoutTemplates: [],
+        name: frequency,
+        routines: [],
     };
     // TODO: Rename sortedExercises to sortedExercisesByMuscleGroup or something similar
     const sortedExercises = (0, exports.getPrioritySortedExercises)(trainerAlgorithmSettings.exercise_priorities, exerciseStore);
     const programUsedExerciseIds = new Set();
     let programFocusMuscleExerciseCount = 0;
     const allErrors = [];
-    for (const workout of workoutTemplates) {
-        const workoutTemplate = trainerAlgorithmSettings.templates[workout];
-        let workoutBarbellExerciseCount = 0;
-        const workoutUsedExerciseIds = new Set();
-        const workoutExercises = [];
-        for (let prescriptionIndex = 0; prescriptionIndex < workoutTemplate.exercises.length; prescriptionIndex++) {
-            const exercisePrescription = workoutTemplate.exercises[prescriptionIndex];
+    for (const routine of routines) {
+        const routineTemplate = trainerAlgorithmSettings.templates[routine];
+        let routineBarbellExerciseCount = 0;
+        const routineUsedExerciseIds = new Set();
+        const routineExercises = [];
+        for (let prescriptionIndex = 0; prescriptionIndex < routineTemplate.exercises.length; prescriptionIndex++) {
+            const exercisePrescription = routineTemplate.exercises[prescriptionIndex];
             const muscleGroup = getMuscleGroup({
                 muscleGroupPrescription: exercisePrescription.muscle_group,
                 programFocusMuscleExerciseCount,
                 focusMuscle,
-                workoutTemplateName: workout,
+                routineName: routine,
             });
             // If the muscle group is not found, skip the exercise
             if (!muscleGroup) {
@@ -634,7 +632,7 @@ function generateProgram(params) {
                 exerciseCategory: exercisePrescription.category,
                 equipments,
                 muscleGroup,
-                workoutBarbellExerciseCount,
+                routineBarbellExerciseCount,
                 level,
                 goal,
             };
@@ -645,7 +643,7 @@ function generateProgram(params) {
                     criteria,
                     context: {
                         programUsedExerciseIds,
-                        workoutUsedExerciseIds,
+                        routineUsedExerciseIds,
                         excludedExerciseIds,
                     },
                     withTrace: true,
@@ -653,7 +651,7 @@ function generateProgram(params) {
                 exercise = selection.exercise;
                 exerciseSelectionTraces.push({
                     traceKind: 'template',
-                    workoutTemplate: workout,
+                    routine,
                     prescriptionIndex,
                     prescription: exercisePrescription,
                     resolvedMuscleGroup: muscleGroup,
@@ -668,29 +666,30 @@ function generateProgram(params) {
                     criteria,
                     context: {
                         programUsedExerciseIds,
-                        workoutUsedExerciseIds,
+                        routineUsedExerciseIds,
                         excludedExerciseIds,
                     },
                 });
             }
             if (!!exercise) {
                 programUsedExerciseIds.add(exercise.id);
-                workoutUsedExerciseIds.add(exercise.id);
+                routineUsedExerciseIds.add(exercise.id);
                 if (exercise.equipment_category === 'barbell')
-                    workoutBarbellExerciseCount++;
+                    routineBarbellExerciseCount++;
                 if (exercisePrescription.muscle_group === 'focus_muscle')
                     programFocusMuscleExerciseCount++;
                 const repRange = (0, exports.getTrainerRepRange)(trainerAlgorithmSettings, goal, exercisePrescription.category);
-                workoutExercises.push({
+                routineExercises.push({
                     kind: 'resistance',
-                    exercise_template: exercise,
-                    set_count: (0, exports.getTrainerSetCount)(trainerAlgorithmSettings, goal, frequency),
-                    warmup_set_count: (_b = exercisePrescription.warmup_set_count) !== null && _b !== void 0 ? _b : 0,
-                    rep_range: {
-                        start: repRange.rep_range_start,
-                        end: repRange.rep_range_end,
-                    },
-                    rest_seconds: (0, exports.getTrainerRestTimerSeconds)(trainerAlgorithmSettings, goal, restTimerLength, exercisePrescription.category),
+                    exerciseTemplate: exercise,
+                    muscleGroup: exercisePrescription.muscle_group,
+                    category: exercisePrescription.category,
+                    sets: (0, exports.getTrainerSetCount)(trainerAlgorithmSettings, goal, frequency),
+                    repRangeStart: repRange.rep_range_start,
+                    repRangeEnd: repRange.rep_range_end,
+                    restTimerSeconds: (0, exports.getTrainerRestTimerSeconds)(trainerAlgorithmSettings, goal, restTimerLength, exercisePrescription.category),
+                    warmupSetCount: exercisePrescription.warmup_set_count,
+                    notes: (_b = trainerAlgorithmSettings.exercise_notes[exercise.id]) !== null && _b !== void 0 ? _b : '',
                 });
             }
             else {
@@ -708,21 +707,23 @@ function generateProgram(params) {
                 });
             }
         }
-        attachOptionalCardioToWorkoutTemplate({
+        attachOptionalCardioToRoutine({
             cardioPreference,
             sortedExercises,
             criteria: { equipments, level, goal, frequency, excludedExerciseIds },
             debugExerciseSelectionTrace,
             exerciseSelectionTraces,
-            workoutTemplate: workout,
-            templatePrescriptionCount: workoutTemplate.exercises.length,
-            workoutExercises,
+            routine,
+            templatePrescriptionCount: routineTemplate.exercises.length,
+            routineExercises,
         });
-        program.workoutTemplates.push({
-            name: workout,
-            exercises: workoutExercises,
+        program.routines.push({
+            name: routine,
+            notes: routineTemplate.notes,
+            exercises: routineExercises,
         });
     }
+    // Return result based on whether there were errors
     if (allErrors.length > 0) {
         const result = {
             success: false,

package/built/index.d.ts

@@ -1,5 +1,5 @@
 import { InstructionsLanguage } from './exerciseLocaleUtils';
-import { TrainerWorkoutTemplateName, WorkoutDurationMinutes } from './hevyTrainer';
+import { WorkoutDurationMinutes } from './hevyTrainer';
 import { postEmailBackofficeSchema } from './schemas';
 import { Language } from './translations';
 import { Lookup } from './typeUtils';
@@ -289,6 +289,7 @@ export interface BackofficeExistingUserResponse {
     last_workout_at: string;
     coach_client_status?: 'coached-active-plan' | 'coached-inactive-plan';
     coach_status?: 'coach-active-plan' | 'coach-inactive-plan';
+    coach_username?: string;
     notes: string | null;
     is_banned: boolean;
     metadata: UserMetadataResponse | null;
@@ -299,7 +300,7 @@ export interface BackofficeExistingUserResponse {
     public_api_key: string | null;
     limited_discovery: boolean;
     coach_trial_expire_date?: string;
-    hevy_trainer_program: TrainerProgramV3 | null;
+    hevy_trainer_program: HevyTrainerProgram | null;
 }
 export interface BackofficeDeletedUserResponse {
     state: 'deleted-account';
@@ -744,10 +745,6 @@ export interface RepRange {
     start: number | null;
     end: number | null;
 }
-export interface StrictRepRange extends RepRange {
-    start: number;
-    end: number;
-}
 export interface WorkoutExerciseSet {
     /**
      * id can be a string or a number because we used
@@ -891,7 +888,6 @@ export interface Workout {
     biometrics?: WorkoutBiometrics;
     is_biometrics_public: boolean;
     trainer_program_id: string | undefined;
-    trainer_workout_template_id: string | undefined;
 }
 export interface CustomExerciseImage {
     type: 'image';
@@ -971,7 +967,6 @@ export interface PostWorkoutRequestWorkout {
     biometrics?: WorkoutBiometrics;
     is_biometrics_public: boolean;
     trainer_program_id: string | undefined;
-    trainer_workout_template_id: string | undefined;
 }
 export type WorkoutDataImporterReport = {
     state: 'idle';
@@ -1099,14 +1094,12 @@ export interface Routine extends BaseRoutine {
     username: string;
     coach_id: null;
 }
-/** @deprecated Use TrainerProgramWorkoutTemplate instead */
 export interface HevyTrainerRoutine extends Routine {
     hevy_trainer_program_id: string;
     program_id: null;
     coach_force_rpe_enabled: false;
     folder_id: null;
 }
-/** @deprecated Use TrainerProgramWorkoutTemplate instead */
 export declare const isHevyTrainerRoutine: (routine: BaseRoutine) => routine is HevyTrainerRoutine;
 export type CoachsShallowLibraryRoutine = Omit<BaseRoutine, 'exercises' | 'profile_pic' | 'hevy_trainer_program_id' | 'username'>;
 export interface CoachesRoutine extends BaseRoutine {
@@ -1275,91 +1268,6 @@ export interface GetTeamInviteResponse {
 export interface OutstandingInvitesForCoachTeamResponse {
     invites: CoachTeamInvite[];
 }
-export interface TrainerWorkoutTemplateResistanceExercise {
-    kind: 'resistance';
-    id: string;
-    exercise_template_id: string;
-    index: number;
-    set_count: number;
-    warmup_set_count: number;
-    rep_range: StrictRepRange;
-    rest_seconds: number;
-}
-export interface TrainerWorkoutTemplateCardioExercise {
-    kind: 'cardio';
-    id: string;
-    exercise_template_id: string;
-    index: number;
-    set_count: 1;
-    duration_seconds: number;
-}
-export interface TrainerWorkoutTemplateOtherExercise {
-    kind: 'other';
-    id: string;
-    exercise_template_id: string;
-    index: number;
-    set_count: number;
-}
-export type TrainerWorkoutTemplateExercise = TrainerWorkoutTemplateResistanceExercise | TrainerWorkoutTemplateCardioExercise | TrainerWorkoutTemplateOtherExercise;
-export interface TrainerWorkoutTemplate {
-    id: string;
-    hevy_trainer_program_id: string;
-    index: number;
-    name: TrainerWorkoutTemplateName;
-    exercises: TrainerWorkoutTemplateExercise[];
-}
-export interface TrainerProgramV3 {
-    id: string;
-    schema_version: 'v3';
-    created_at: string;
-    updated_at: string;
-    level: TrainingLevel;
-    goal: TrainingGoal;
-    equipments: GranularEquipment[];
-    weekly_frequency: WeeklyTrainingFrequency;
-    templates: TrainerWorkoutTemplate[];
-    focus_muscle?: SimplifiedMuscleGroup;
-    next_workout_index: number;
-    workout_duration_minutes: WorkoutDurationMinutes;
-    rest_timer_length: RestTimerLength;
-    cardio_preference: CardioPreference;
-}
-export interface TrainerWorkoutTemplateUpdate extends Pick<TrainerWorkoutTemplate, 'name' | 'index'> {
-    exercises: Omit<TrainerWorkoutTemplateExercise, 'id'>[];
-}
-export interface PostTrainerProgramV3RequestBody {
-    program: {
-        version: 3;
-        title: string;
-        level: TrainingLevel;
-        goal: TrainingGoal;
-        equipments: GranularEquipment[];
-        weekly_frequency: WeeklyTrainingFrequency;
-        focus_muscle?: SimplifiedMuscleGroup;
-        next_workout_index?: number;
-        workout_duration_minutes: WorkoutDurationMinutes;
-        rest_timer_length: RestTimerLength;
-        cardio_preference: CardioPreference;
-        templates: TrainerWorkoutTemplateUpdate[];
-    };
-}
-export interface UpdateTrainerProgramV3RequestBody {
-    program: {
-        version: 3;
-        programId: string;
-        level: TrainingLevel;
-        goal: TrainingGoal;
-        equipments: GranularEquipment[];
-        weekly_frequency: WeeklyTrainingFrequency;
-        focus_muscle?: SimplifiedMuscleGroup;
-        next_workout_index?: number;
-        workout_duration_minutes: WorkoutDurationMinutes;
-        rest_timer_length: RestTimerLength;
-        cardio_preference: CardioPreference;
-        templates: TrainerWorkoutTemplateUpdate[];
-    };
-}
-/** @deprecated Use TrainerProgramV3 instead */
 export interface HevyTrainerProgram {
     id: string;
     created_at: string;
@@ -1376,7 +1284,6 @@ export interface HevyTrainerProgram {
     rest_timer_length: RestTimerLength;
     cardio_preference: CardioPreference;
 }
-/** @deprecated Use PostTrainerProgramV3RequestBody instead */
 export interface PostHevyTrainerProgramRequestBody {
     program: {
         version: 1;
@@ -1393,7 +1300,6 @@ export interface PostHevyTrainerProgramRequestBody {
         cardio_preference: CardioPreference;
     };
 }
-/** @deprecated Use UpdateTrainerProgramV3RequestBody instead */
 export interface UpdateHevyTrainerProgramRequestBody {
     program: {
         version: 1;
@@ -1416,7 +1322,7 @@ export interface UpdateHevyTrainerProgramRequestBody {
         }[];
     };
 }
-/** @deprecated Use TrainerProgramV3 instead */
+/** @deprecated Use HevyTrainerProgram instead */
 export interface HevyTrainerProgramOld {
     id: string;
     created_at: string;
@@ -1431,7 +1337,7 @@ export interface HevyTrainerProgramOld {
     next_workout_index: number;
     workout_duration_minutes?: WorkoutDurationMinutes;
 }
-/** @deprecated Use PostTrainerProgramV3RequestBody instead */
+/** @deprecated Use PostHevyTrainerProgramRequestBody instead */
 export interface PostHevyTrainerProgramOldRequestBody {
     program: {
         title: string;
@@ -1445,7 +1351,7 @@ export interface PostHevyTrainerProgramOldRequestBody {
         workout_duration_minutes?: WorkoutDurationMinutes;
     };
 }
-/** @deprecated Use UpdateTrainerProgramV3RequestBody instead */
+/** @deprecated Use UpdateHevyTrainerProgramRequestBody instead */
 export interface UpdateHevyTrainerProgramOldRequestBody {
     program: {
         programId: string;

package/built/index.js

@@ -324,7 +324,6 @@ const isWorkoutBiometrics = (x) => {
     return caloriesAreValid && heartSamplesAreValid;
 };
 exports.isWorkoutBiometrics = isWorkoutBiometrics;
-/** @deprecated Use TrainerProgramWorkoutTemplate instead */
 const isHevyTrainerRoutine = (routine) => routine.hevy_trainer_program_id !== null;
 exports.isHevyTrainerRoutine = isHevyTrainerRoutine;
 exports.measurementsList = [

package/built/normalizedWorkoutUtils.d.ts

@@ -36,7 +36,6 @@ export interface NormalizedWorkout {
     clientId: string;
     biometrics?: WorkoutBiometrics;
     trainerProgramId: string | undefined;
-    trainerWorkoutTemplateId?: string;
 }
 export interface NormalizedSet {
     index: number;

package/built/tests/hevyTrainer.test.js

@@ -236,7 +236,7 @@ const makeSettings = (overrides = {}) => {
         };
         return acc;
     }, {});
-    const templates = hevyTrainer_1.workoutTemplateNames.reduce((acc, name) => {
+    const templates = hevyTrainer_1.routineNames.reduce((acc, name) => {
         acc[name] = { exercises: [] };
         return acc;
     }, {});
@@ -372,7 +372,7 @@ describe('getPrioritySortedExercises', () => {
         expect(result.quadriceps.map((e) => e.id)).toEqual(['leg-ex']);
     });
 });
-const baseCriteria = (overrides = {}) => (Object.assign({ exerciseCategory: 'compound', equipments: [], workoutBarbellExerciseCount: 0, level: 'beginner', goal: 'strength', muscleGroup: 'chest', frequency: 3 }, overrides));
+const baseCriteria = (overrides = {}) => (Object.assign({ exerciseCategory: 'compound', equipments: [], routineBarbellExerciseCount: 0, level: 'beginner', goal: 'strength', muscleGroup: 'chest', frequency: 3 }, overrides));
 /** Produces a `sortedExercises` record where only `chest` is populated. */
 const chestOnlySorted = (exercises) => {
     const empty = __1.muscleGroups.reduce((acc, mg) => {
@@ -394,7 +394,7 @@ describe('pickTrainerExercise', () => {
         });
         expect(result === null || result === void 0 ? void 0 : result.id).toBe('fresh');
     });
-    it('pass 2: falls back to exercises not used in the current workout when all are used in the program', () => {
+    it('pass 2: falls back to exercises not used in the current routine when all are used in the program', () => {
         const onlyExercise = makeExercise({ id: 'only' });
         const result = (0, hevyTrainer_1.pickTrainerExercise)({
             sortedExercises: chestOnlySorted([onlyExercise]),
@@ -402,8 +402,8 @@ describe('pickTrainerExercise', () => {
             context: {
                 // Marked as used in the whole program already.
                 programUsedExerciseIds: new Set(['only']),
-                // But not used in this workout, so pass 2 should succeed.
-                workoutUsedExerciseIds: new Set(),
+                // But not used in this routine, so pass 2 should succeed.
+                routineUsedExerciseIds: new Set(),
             },
         });
         expect(result === null || result === void 0 ? void 0 : result.id).toBe('only');
@@ -506,7 +506,7 @@ describe('pickTrainerExercise', () => {
                 sortedExercises: chestOnlySorted([ex]),
                 criteria: baseCriteria({
                     frequency: 3,
-                    workoutBarbellExerciseCount: 10,
+                    routineBarbellExerciseCount: 10,
                     equipments: ['dumbbell'],
                 }),
                 context: {},
@@ -519,7 +519,7 @@ describe('pickTrainerExercise', () => {
                 sortedExercises: chestOnlySorted([ex]),
                 criteria: baseCriteria({
                     frequency: 1,
-                    workoutBarbellExerciseCount: 2,
+                    routineBarbellExerciseCount: 2,
                     equipments: ['dumbbell'],
                 }),
                 context: {},
@@ -532,7 +532,7 @@ describe('pickTrainerExercise', () => {
                 sortedExercises: chestOnlySorted([ex]),
                 criteria: baseCriteria({
                     frequency: 1,
-                    workoutBarbellExerciseCount: 3,
+                    routineBarbellExerciseCount: 3,
                     // Dumbbell is listed as a barbell substitute, so the cap applies.
                     equipments: ['dumbbell'],
                 }),
@@ -546,7 +546,7 @@ describe('pickTrainerExercise', () => {
                 sortedExercises: chestOnlySorted([ex]),
                 criteria: baseCriteria({
                     frequency: 1,
-                    workoutBarbellExerciseCount: 5,
+                    routineBarbellExerciseCount: 5,
                     // No substitutes → avoid dead-ends by allowing the barbell.
                     equipments: [],
                 }),
@@ -587,7 +587,7 @@ describe('pickTrainerExercise', () => {
 describe('generateProgram', () => {
     const buildSettingsForChestProgram = () => {
         const settings = makeSettings();
-        // Put a single chest compound prescription into the 1-day full body workout.
+        // Put a single chest compound prescription into the 1-day full body routine.
         settings.templates.full_body_1 = {
             exercises: [
                 { muscle_group: 'chest', category: 'compound', warmup_set_count: 2 },
@@ -596,7 +596,7 @@ describe('generateProgram', () => {
         };
         return settings;
     };
-    it('produces one workout per programSplit and populates exercise fields from the settings', () => {
+    it('produces one routine per programSplit and populates exercise fields from the settings', () => {
         const settings = buildSettingsForChestProgram();
         const chestExercise = makeExercise({ id: 'bench', muscle_group: 'chest' });
         const result = (0, hevyTrainer_1.generateProgram)({
@@ -613,19 +613,27 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.workoutTemplates).toHaveLength(hevyTrainer_1.programSplits[1].length);
-        const [workoutTemplate] = result.program.workoutTemplates;
-        expect(workoutTemplate.name).toBe('full_body_1');
-        expect(workoutTemplate.exercises).toHaveLength(1);
-        const [exercise] = workoutTemplate.exercises;
-        if (!(0, hevyTrainer_1.isTrainerProgramResistanceExercise)(exercise))
-            return;
+        expect(result.program.name).toBe(1);
+        expect(result.program.routines).toHaveLength(hevyTrainer_1.programSplits[1].length);
+        const [routine] = result.program.routines;
+        expect(routine.name).toBe('full_body_1');
+        expect(routine.notes).toBe('Hit the chest hard.');
+        expect(routine.exercises).toHaveLength(1);
+        const [exercise] = routine.exercises;
         expect(exercise.kind).toBe('resistance');
-        expect(exercise.exercise_template.id).toBe('bench');
-        expect(exercise.warmup_set_count).toBe(2);
-        expect(exercise.set_count).toBe(1);
-        expect(exercise.rep_range).toEqual({ start: 1, end: 5 });
-        expect(exercise.rest_seconds).toBe(60);
+        if (exercise.kind !== 'resistance')
+            return;
+        expect(exercise.exerciseTemplate.id).toBe('bench');
+        expect(exercise.category).toBe('compound');
+        expect(exercise.muscleGroup).toBe('chest');
+        expect(exercise.warmupSetCount).toBe(2);
+        // strength + one_day -> 1 (see `makeSettings`)
+        expect(exercise.sets).toBe(1);
+        // strength + compound -> 1..5
+        expect(exercise.repRangeStart).toBe(1);
+        expect(exercise.repRangeEnd).toBe(5);
+        // strength + medium + compound -> 60
+        expect(exercise.restTimerSeconds).toBe(60);
     });
     it('returns a partial program and errors when no matching exercise can be found', () => {
         const settings = buildSettingsForChestProgram();
@@ -648,14 +656,14 @@ describe('generateProgram', () => {
             type: 'exercise_not_found',
             muscleGroup: 'chest',
         });
-        // The workout template structure still exists in the partial program, just without
+        // The routine structure still exists in the partial program, just without
         // any resolved exercises.
-        expect(result.partialProgram.workoutTemplates).toHaveLength(1);
-        expect(result.partialProgram.workoutTemplates[0].exercises).toEqual([]);
+        expect(result.partialProgram.routines).toHaveLength(1);
+        expect(result.partialProgram.routines[0].exercises).toEqual([]);
     });
     describe('min_workout_duration_limit filtering', () => {
         /**
-         * Runs a 1-day workout program containing a single chest compound prescription
+         * Runs a 1-day program containing a single chest compound prescription
          * with the provided `min_workout_duration_limit` against the provided
          * `workoutDurationMinutes`, and returns whether the prescription was
          * placed.
@@ -682,8 +690,9 @@ describe('generateProgram', () => {
                 exerciseStore: [makeExercise({ id: 'bench' })],
                 cardioPreference: 'no-cardio',
             });
-            const workoutTemplate = (result.success ? result.program : result.partialProgram).workoutTemplates[0];
-            return workoutTemplate.exercises.length === 1;
+            const routine = (result.success ? result.program : result.partialProgram)
+                .routines[0];
+            return routine.exercises.length === 1;
         };
         it('skips prescriptions whose limit is strictly greater than the selected duration', () => {
             expect(runDurationProbe({ limit: 80, workoutDurationMinutes: 40 })).toBe(false);
@@ -755,11 +764,11 @@ describe('generateProgram', () => {
                 return;
             // Only the 40- and 60-minute prescriptions survive; the 80-minute one
             // is filtered out. Order is preserved.
-            const placed = result.program.workoutTemplates[0].exercises;
+            const placed = result.program.routines[0].exercises;
             expect(placed.every((e) => e.kind === 'resistance')).toBe(true);
             expect(placed
                 .filter(hevyTrainer_1.isTrainerProgramResistanceExercise)
-                .map((e) => e.warmup_set_count)).toEqual([1, 2]);
+                .map((e) => e.warmupSetCount)).toEqual([1, 2]);
         });
     });
     it('skips focus_muscle prescriptions when no focusMuscle is provided', () => {
@@ -783,7 +792,7 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.workoutTemplates[0].exercises).toEqual([]);
+        expect(result.program.routines[0].exercises).toEqual([]);
     });
     it('routes focus_muscle prescriptions to the requested SimplifiedMuscleGroup', () => {
         const settings = makeSettings();
@@ -810,11 +819,12 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        const [exercise] = result.program.workoutTemplates[0].exercises;
+        const [exercise] = result.program.routines[0].exercises;
         expect(exercise.kind).toBe('resistance');
         if (exercise.kind !== 'resistance')
             return;
-        expect(exercise.exercise_template.id).toBe('biceps-curl');
+        expect(exercise.exerciseTemplate.id).toBe('biceps-curl');
+        expect(exercise.muscleGroup).toBe('focus_muscle');
     });
     it('excludes exercises listed in `excludedExerciseIds`', () => {
         const settings = buildSettingsForChestProgram();
@@ -835,7 +845,7 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.workoutTemplates[0].exercises[0].exercise_template.id).toBe('alt');
+        expect(result.program.routines[0].exercises[0].exerciseTemplate.id).toBe('alt');
     });
     it('attaches exercise selection traces when debugExerciseSelectionTrace is true', () => {
         const settings = buildSettingsForChestProgram();
@@ -856,7 +866,7 @@ describe('generateProgram', () => {
         expect(result.exerciseSelectionTraces).toHaveLength(1);
         const [trace] = result.exerciseSelectionTraces;
         expect(trace.traceKind).toBe('template');
-        expect(trace.workoutTemplate).toBe('full_body_1');
+        expect(trace.routine).toBe('full_body_1');
         expect(trace.selectedExerciseId).toBe('bench');
         expect(trace.trace.selectedPass).toBe(1);
     });
@@ -928,7 +938,7 @@ describe('generateProgram', () => {
         expect(cardioTrace.equipments).toEqual([]);
         expect(cardioTrace.level).toBe('beginner');
     });
-    it('uses the same prioritized cardio exercise on every workout (not blocked by program reuse)', () => {
+    it('uses the same prioritized cardio exercise on every routine (not blocked by program reuse)', () => {
         const settings = makeSettings();
         settings.templates.full_body_2_a = {
             exercises: [{ muscle_group: 'chest', category: 'compound' }],
@@ -961,13 +971,13 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.workoutTemplates[0].exercises[0]).toMatchObject({
+        expect(result.program.routines[0].exercises[0]).toMatchObject({
             kind: 'cardio',
-            exercise_template: { id: 'run' },
+            exerciseTemplate: { id: 'run' },
         });
-        expect(result.program.workoutTemplates[1].exercises[0]).toMatchObject({
+        expect(result.program.routines[1].exercises[0]).toMatchObject({
             kind: 'cardio',
-            exercise_template: { id: 'run' },
+            exerciseTemplate: { id: 'run' },
         });
     });
     it('skips cardio exercises that need equipment the user does not have', () => {
@@ -1006,9 +1016,9 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.workoutTemplates[0].exercises[0]).toMatchObject({
+        expect(result.program.routines[0].exercises[0]).toMatchObject({
             kind: 'cardio',
-            exercise_template: { id: 'body-run' },
+            exerciseTemplate: { id: 'body-run' },
         });
     });
     it('skips globally excluded cardio and uses the next priority exercise', () => {
@@ -1047,12 +1057,12 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.workoutTemplates[0].exercises[0]).toMatchObject({
+        expect(result.program.routines[0].exercises[0]).toMatchObject({
             kind: 'cardio',
-            exercise_template: { id: 'run-b' },
+            exerciseTemplate: { id: 'run-b' },
         });
     });
-    it('keeps global trace order aligned with workout generation (no cross-workout unshift)', () => {
+    it('keeps global trace order aligned with routine generation (no cross-routine unshift)', () => {
         const settings = makeSettings();
         settings.templates.full_body_2_a = {
             exercises: [{ muscle_group: 'chest', category: 'compound' }],
@@ -1086,15 +1096,15 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        const idxA = result.exerciseSelectionTraces.findIndex((t) => t.workoutTemplate === 'full_body_2_a');
-        const idxB = result.exerciseSelectionTraces.findIndex((t) => t.workoutTemplate === 'full_body_2_b');
+        const idxA = result.exerciseSelectionTraces.findIndex((t) => t.routine === 'full_body_2_a');
+        const idxB = result.exerciseSelectionTraces.findIndex((t) => t.routine === 'full_body_2_b');
         expect(idxA).toBeGreaterThanOrEqual(0);
         expect(idxB).toBeGreaterThan(idxA);
     });
     describe('barbell cap at frequency === 1 (end-to-end)', () => {
         it('drops the 4th+ barbell prescription when the user has a substitute', () => {
             const settings = makeSettings();
-            // 4 identical barbell compound prescriptions in the 1-day workout.
+            // 4 identical barbell compound prescriptions in the 1-day routine.
             settings.templates.full_body_1 = {
                 exercises: Array.from({ length: 4 }, () => ({
                     muscle_group: 'chest',
@@ -1123,7 +1133,7 @@ describe('generateProgram', () => {
             expect(result.success).toBe(false);
             if (result.success)
                 return;
-            expect(result.partialProgram.workoutTemplates[0].exercises).toHaveLength(3);
+            expect(result.partialProgram.routines[0].exercises).toHaveLength(3);
             expect(result.errors).toHaveLength(1);
         });
         it('allows 4+ barbell prescriptions at frequency 1 when no substitute is present', () => {
@@ -1154,19 +1164,19 @@ describe('generateProgram', () => {
             expect(result.success).toBe(true);
             if (!result.success)
                 return;
-            expect(result.program.workoutTemplates[0].exercises).toHaveLength(4);
+            expect(result.program.routines[0].exercises).toHaveLength(4);
         });
     });
     describe('focus_muscle cycling', () => {
         it('cycles through simplifiedMuscleGroupToMuscleGroups as focus_muscle prescriptions are placed', () => {
             // Use a 2-day split so we can place 4 focus_muscle exercises across two
-            // workouts and confirm the counter survives between workouts.
+            // routines and confirm the counter survives between routines.
             const settings = makeSettings();
             const focusPrescription = {
                 muscle_group: 'focus_muscle',
                 category: 'isolation',
             };
-            // full_body workouts allow any focus muscle. Place 2 per workout so the
+            // full_body routines allow any focus muscle. Place 2 per routine so the
             // combined count across the program is 4.
             settings.templates.full_body_2_a = {
                 exercises: [focusPrescription, focusPrescription],
@@ -1236,7 +1246,7 @@ describe('generateProgram', () => {
             settings.templates.upper_2 = { exercises: [focusPrescription] };
             settings.templates.lower_2 = { exercises: [focusPrescription] };
             // `legs` cycles through ['quadriceps', 'hamstrings', 'calves', 'glutes',
-            // 'abductors', 'adductors']. The first two allowed workouts (legs_1 and
+            // 'abductors', 'adductors']. The first two allowed routines (legs_1 and
             // lower_2) should land on quadriceps and hamstrings respectively.
             const exercises = [
                 makeExercise({
@@ -1269,7 +1279,10 @@ describe('generateProgram', () => {
             // Only legs_1 and lower_2 run the focus_muscle prescription. Both
             // succeed and should have selected quadriceps then hamstrings in order.
             expect(result.exerciseSelectionTraces).toHaveLength(2);
-            expect(result.exerciseSelectionTraces.map((t) => t.workoutTemplate)).toEqual(['legs_1', 'lower_2']);
+            expect(result.exerciseSelectionTraces.map((t) => t.routine)).toEqual([
+                'legs_1',
+                'lower_2',
+            ]);
             expect(result.exerciseSelectionTraces
                 .filter((t) => t.traceKind === 'template')
                 .map((t) => t.resolvedMuscleGroup)).toEqual(['quadriceps', 'hamstrings']);
@@ -1277,14 +1290,14 @@ describe('generateProgram', () => {
     });
     describe('isFocusMuscleExtraExerciseAllowed template compatibility', () => {
         /**
-         * Runs a single-workout template program that places one focus_muscle
+         * Runs a single-routine program that places one focus_muscle
          * prescription into the requested template and returns whether the
          * prescription produced an exercise or was skipped.
          */
-        const runFocusMuscleProbe = (workoutTemplateName, focusMuscle, frequency, candidateExercise) => {
+        const runFocusMuscleProbe = (routineName, focusMuscle, frequency, candidateExercise) => {
             var _a;
             const settings = makeSettings();
-            settings.templates[workoutTemplateName] = {
+            settings.templates[routineName] = {
                 exercises: [{ muscle_group: 'focus_muscle', category: 'isolation' }],
             };
             const result = (0, hevyTrainer_1.generateProgram)({
@@ -1300,13 +1313,13 @@ describe('generateProgram', () => {
                 debugExerciseSelectionTrace: true,
                 cardioPreference: 'no-cardio',
             });
-            // Find the workout template we targeted (it may not be first in the split).
-            const workoutTemplate = (result.success ? result.program : result.partialProgram).workoutTemplates.find((w) => w.name === workoutTemplateName);
+            // Find the routine we targeted (it may not be first in the split).
+            const routine = (result.success ? result.program : result.partialProgram).routines.find((r) => r.name === routineName);
             return {
-                placed: ((_a = workoutTemplate === null || workoutTemplate === void 0 ? void 0 : workoutTemplate.exercises.length) !== null && _a !== void 0 ? _a : 0) > 0,
+                placed: ((_a = routine === null || routine === void 0 ? void 0 : routine.exercises.length) !== null && _a !== void 0 ? _a : 0) > 0,
             };
         };
-        it('allows every focus muscle on full_body workouts', () => {
+        it('allows every focus muscle on full_body routines', () => {
             const muscles = ['chest', 'shoulders', 'arms', 'legs', 'back'];
             muscles.forEach((focusMuscle) => {
                 // Use a muscle that's in the simplified group: biceps for arms, chest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hevy-shared",
-  "version": "1.0.994",
+  "version": "1.0.996",
   "description": "",
   "main": "built/index.js",
   "types": "built/index.d.ts",