hevy-shared 1.0.993 → 1.0.994

package/built/hevyTrainer.d.ts

@@ -1,6 +1,6 @@
-import { WeeklyTrainingFrequency, TrainingGoal, TrainingLevel, SimplifiedMuscleGroup, MuscleGroup, LibraryExercise, ExerciseCategory, GranularEquipment, HevyTrainerProgramEquipment, RestTimerLength, CardioPreference } from '.';
+import { WeeklyTrainingFrequency, TrainingGoal, TrainingLevel, SimplifiedMuscleGroup, MuscleGroup, LibraryExercise, ExerciseCategory, GranularEquipment, HevyTrainerProgramEquipment, RestTimerLength, CardioPreference, StrictRepRange } from '.';
 export type HevyTrainerExerciseCategory = typeof hevyTrainerExerciseCategories[number];
-export type HevyTrainerRoutineName = typeof routineNames[number];
+export type TrainerWorkoutTemplateName = typeof workoutTemplateNames[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 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 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 type exerciseId = string;
 export interface ExerciseSelectionCriteria {
     exerciseCategory: HevyTrainerExerciseCategory | 'all';
     equipments: GranularEquipment[];
-    routineBarbellExerciseCount: number;
+    workoutBarbellExerciseCount: number;
     level: TrainingLevel;
     goal: TrainingGoal;
     muscleGroup: MuscleGroup;
@@ -29,7 +29,7 @@ export interface ExerciseSelectionCriteria {
 }
 export interface ExerciseSelectionContext {
     programUsedExerciseIds?: Set<string>;
-    routineUsedExerciseIds?: Set<string>;
+    workoutUsedExerciseIds?: 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';
-    routine: HevyTrainerRoutineName;
+    workoutTemplate: TrainerWorkoutTemplateName;
     prescriptionIndex: number;
     prescription: ExercisePrescription;
     resolvedMuscleGroup: MuscleGroup;
@@ -79,7 +79,7 @@ export interface TemplateExerciseSelectionTraceRecord {
 }
 export interface CardioExerciseSelectionTraceRecord {
     traceKind: 'cardio';
-    routine: HevyTrainerRoutineName;
+    workoutTemplate: TrainerWorkoutTemplateName;
     prescriptionIndex: number;
     selectedExerciseId?: string;
     equipments: GranularEquipment[];
@@ -87,24 +87,24 @@ export interface CardioExerciseSelectionTraceRecord {
     trace: ExerciseSelectionTrace;
 }
 export type ProgramExerciseSelectionTraceRecord = TemplateExerciseSelectionTraceRecord | CardioExerciseSelectionTraceRecord;
-export type TrainerProgramAttemptWithTraces = TrainerProgramAttempt & {
+export type TrainerProgramAttemptWithTraces<T> = TrainerProgramAttempt<T> & {
     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, HevyTrainerRoutineName[]>;
+export declare const programSplits: Record<WeeklyTrainingFrequency, TrainerWorkoutTemplateName[]>;
 export type SetsPerGoal = {
     [key in TrainingGoal]: number;
 };
 export type SetsPerFrequency = {
     [key in FrequencyString]: SetsPerGoal;
 };
-export interface RepRange {
+export interface AlgorithmRepRange {
     rep_range_start: number;
     rep_range_end: number;
 }
 export type RepRangesPerCategory = {
-    [key in HevyTrainerExerciseCategory]: RepRange;
+    [key in HevyTrainerExerciseCategory]: AlgorithmRepRange;
 };
 export type RepRanges = {
     [key in TrainingGoal]: RepRangesPerCategory;
@@ -138,7 +138,7 @@ export interface WorkoutTemplate {
     notes?: string;
 }
 export type Templates = {
-    [key in HevyTrainerRoutineName]: WorkoutTemplate;
+    [key in TrainerWorkoutTemplateName]: WorkoutTemplate;
 };
 export interface BackofficeTrainerPreset {
     id?: number;
@@ -157,39 +157,38 @@ export interface TrainerAlgorithmSettings {
     exercise_notes: ExerciseNotes;
     exercise_replacements: ExerciseReplacements;
 }
-/** Resistance prescriptions from templates (sets, reps, rest, notes). */
-export interface TrainerProgramResistanceExercise {
+export interface TrainerProgramResistanceExercise<T> {
     kind: 'resistance';
-    exerciseTemplate: HevyTrainerLibraryExercise;
-    muscleGroup: MuscleGroup | 'focus_muscle';
-    category: HevyTrainerExerciseCategory;
-    sets: number;
-    warmupSetCount?: number;
-    repRangeStart: number;
-    repRangeEnd: number;
-    restTimerSeconds: number;
-    notes?: string;
+    exercise_template: T;
+    set_count: number;
+    warmup_set_count: number;
+    rep_range: StrictRepRange;
+    rest_seconds: number;
 }
-/** Optional cardio attachment — no prescription semantics beyond exercise choice. */
-export interface TrainerProgramCardioExercise {
+export interface TrainerProgramCardioExercise<T> {
     kind: 'cardio';
-    exerciseTemplate: HevyTrainerLibraryExercise;
-    durationSeconds: number;
+    exercise_template: T;
+    set_count: 1;
+    duration_seconds: number;
 }
-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 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 interface TrainerProgram {
-    name: WeeklyTrainingFrequency;
-    routines: TrainerProgramRoutine[];
+export interface GeneratedTrainerProgram<T> {
+    workoutTemplates: TrainerProgramWorkoutTemplate<T>[];
 }
 export declare const getTrainerSetCount: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, frequency: WeeklyTrainingFrequency) => number;
-export declare const getTrainerRepRange: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, exerciseCategory: HevyTrainerExerciseCategory) => RepRange;
+export declare const getTrainerRepRange: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, exerciseCategory: HevyTrainerExerciseCategory) => AlgorithmRepRange;
 export declare const getTrainerRestTimerSeconds: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, length: RestTimerLength, exerciseCategory: HevyTrainerExerciseCategory) => number;
 /**
  * Normalizes the exercise category to a HevyTrainerExerciseCategory
@@ -243,25 +242,16 @@ export interface ExercisePrescriptionError {
         focusMuscle?: SimplifiedMuscleGroup;
     };
 }
-export interface TrainerProgramExerciseResult {
-    success: true;
-    exercise: TrainerProgramExercise;
-}
-export interface TrainerProgramExerciseError {
-    success: false;
-    error: ExercisePrescriptionError;
-}
-export type TrainerProgramExerciseAttempt = TrainerProgramExerciseResult | TrainerProgramExerciseError;
-export interface TrainerProgramResult {
+export interface TrainerProgramResult<T> {
     success: true;
-    program: TrainerProgram;
+    program: GeneratedTrainerProgram<T>;
 }
-export interface TrainerProgramError {
+export interface TrainerProgramError<T> {
     success: false;
     errors: ExercisePrescriptionError[];
-    partialProgram: TrainerProgram;
+    partialProgram: GeneratedTrainerProgram<T>;
 }
-export type TrainerProgramAttempt = TrainerProgramResult | TrainerProgramError;
+export type TrainerProgramAttempt<T> = TrainerProgramResult<T> | TrainerProgramError<T>;
 /**
  * Generates a complete training program based on the provided parameters
  * - debugExerciseSelectionTrace: true -> includes exercise selection trace breadcrumbs in the result for debugging.
@@ -269,6 +259,6 @@ export type TrainerProgramAttempt = TrainerProgramResult | TrainerProgramError;
  */
 export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T> & {
     debugExerciseSelectionTrace: true;
-}): TrainerProgramAttemptWithTraces;
-export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T>): TrainerProgramAttempt;
+}): TrainerProgramAttemptWithTraces<T>;
+export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T>): TrainerProgramAttempt<T>;
 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.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.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.pickTrainerExercise = pickTrainerExercise;
 exports.generateProgram = generateProgram;
 const _1 = require(".");
@@ -152,7 +152,7 @@ exports.defaultDurationPerFrequency = {
     5: 40,
     6: 40,
 };
-exports.routineNames = [
+exports.workoutTemplateNames = [
     // Full body 1x
     'full_body_1',
     // Full body 2x
@@ -201,6 +201,8 @@ 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];
 };
@@ -291,12 +293,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, routineBarbellExerciseCount, userEquipments, frequency) => {
+const isBarbellExerciseAllowed = (exercise, workoutBarbellExerciseCount, userEquipments, frequency) => {
     const isCandidateBarbell = exercise.equipment_category === 'barbell';
     const isOncePerWeek = frequency === 1;
     if (!isCandidateBarbell || !isOncePerWeek)
         return true;
-    const isAtOrOverLimit = routineBarbellExerciseCount >= MAX_BARBELL_EXERCISES_FOR_ONCE_PER_WEEK;
+    const isAtOrOverLimit = workoutBarbellExerciseCount >= MAX_BARBELL_EXERCISES_FOR_ONCE_PER_WEEK;
     if (!isAtOrOverLimit)
         return true;
     const barbellSubstitutes = [
@@ -314,7 +316,7 @@ const isBarbellExerciseAllowed = (exercise, routineBarbellExerciseCount, 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.routineUsedExerciseIds) === null || _b === void 0 ? void 0 : _b.has(exercise.id)) ||
+        ((_b = context.workoutUsedExerciseIds) === null || _b === void 0 ? void 0 : _b.has(exercise.id)) ||
         ((_c = context.excludedExerciseIds) === null || _c === void 0 ? void 0 : _c.has(exercise.id)) ||
         false);
 };
@@ -393,16 +395,16 @@ const getPrioritySortedExercises = (exercisePriorities, exerciseStore) => {
     return sortedExercises;
 };
 exports.getPrioritySortedExercises = getPrioritySortedExercises;
-const getMuscleGroup = ({ muscleGroupPrescription, programFocusMuscleExerciseCount, focusMuscle, routineName, }) => {
+const getMuscleGroup = ({ muscleGroupPrescription, programFocusMuscleExerciseCount, focusMuscle, workoutTemplateName, }) => {
     if (muscleGroupPrescription === 'focus_muscle') {
-        // If the user has selected a focus muscle and it is allowed for the routine,
+        // If the user has selected a focus muscle and it is allowed for the workout template,
         // we return the focus muscle extra exercise
         if (!!focusMuscle &&
-            isFocusMuscleExtraExerciseAllowed(routineName, focusMuscle)) {
+            isFocusMuscleExtraExerciseAllowed(workoutTemplateName, 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 routine
+        // If the user has not selected a focus muscle or it is not allowed for the workout template
         // we skip this extra exercise for the focus muscle in the program
         return undefined;
     }
@@ -420,7 +422,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.routineBarbellExerciseCount, criteria.equipments, criteria.frequency);
+    const barbellLimitOk = isBarbellExerciseAllowed(exercise, criteria.workoutBarbellExerciseCount, criteria.equipments, criteria.frequency);
     return (categoryMatch && levelMatch && goalMatch && equipmentMatch && barbellLimitOk);
 };
 /**
@@ -465,8 +467,8 @@ const pickTrainerExerciseWithTrace = (params) => {
         programUsedExerciseIds: context.programUsedExerciseIds,
         excludedExerciseIds: context.excludedExerciseIds,
     };
-    const routineContext = {
-        routineUsedExerciseIds: context.routineUsedExerciseIds,
+    const workoutContext = {
+        workoutUsedExerciseIds: context.workoutUsedExerciseIds,
         excludedExerciseIds: context.excludedExerciseIds,
     };
     // Pass 1
@@ -480,10 +482,10 @@ const pickTrainerExerciseWithTrace = (params) => {
     if (exercise)
         return { exercise, trace: Object.assign(Object.assign({}, trace), { selectedPass: 1 }) };
     // Pass 2
-    exercise = findMatchingExercise(exercises, criteria, routineContext);
+    exercise = findMatchingExercise(exercises, criteria, workoutContext);
     trace.entries.push({
         pass: 2,
-        label: 'exact match; not used in routine (reuse allowed in program)',
+        label: 'exact match; not used in the same workout (reuse allowed in program)',
         candidatePoolSize: exercises.length,
         selectedExerciseId: exercise === null || exercise === void 0 ? void 0 : exercise.id,
     });
@@ -500,20 +502,20 @@ const pickTrainerExerciseWithTrace = (params) => {
     if (exercise)
         return { exercise, trace: Object.assign(Object.assign({}, trace), { selectedPass: 3 }) };
     // Pass 4
-    exercise = findAlternativeIsolationExercise(exercises, criteria, routineContext);
+    exercise = findAlternativeIsolationExercise(exercises, criteria, workoutContext);
     trace.entries.push({
         pass: 4,
-        label: 'handpicked alternative isolation; not used in routine (reuse allowed in program)',
+        label: 'handpicked alternative isolation; not used in the same workout (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' }), routineContext);
+    exercise = findMatchingExercise(exercises, Object.assign(Object.assign({}, criteria), { exerciseCategory: 'all' }), workoutContext);
     trace.entries.push({
         pass: 5,
-        label: 'match regardless of isolation or compound; not used in routine (reuse allowed in program)',
+        label: 'match regardless of isolation or compound; not used in the same workout (reuse allowed in program)',
         candidatePoolSize: exercises.length,
         selectedExerciseId: exercise === null || exercise === void 0 ? void 0 : exercise.id,
     });
@@ -523,10 +525,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' }), routineContext);
+    exercise = findMatchingExercise(secondaryMuscleExercises, Object.assign(Object.assign({}, criteria), { exerciseCategory: 'all' }), workoutContext);
     trace.entries.push({
         pass: 6,
-        label: 'secondary muscle match; regardless of isolation or compound; not used in routine (reuse allowed in program)',
+        label: 'secondary muscle match; regardless of isolation or compound; not used in the same workout (reuse allowed in program)',
         candidatePoolSize: secondaryMuscleExercises.length,
         selectedExerciseId: exercise === null || exercise === void 0 ? void 0 : exercise.id,
     });
@@ -542,11 +544,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 routine. */
-const attachOptionalCardioToRoutine = ({ cardioPreference, sortedExercises, criteria, debugExerciseSelectionTrace, exerciseSelectionTraces, routine, templatePrescriptionCount, routineExercises, }) => {
+/** Inserts optional cardio before or after template exercises for one workout template. */
+const attachOptionalCardioToWorkoutTemplate = ({ cardioPreference, sortedExercises, criteria, debugExerciseSelectionTrace, exerciseSelectionTraces, workoutTemplate, templatePrescriptionCount, workoutExercises, }) => {
     if (cardioPreference === 'no-cardio')
         return;
-    // Cardio is reusable across routines, so program/routine used-id contexts are
+    // Cardio is reusable across workout templates, so program/workoutTemplate used-id contexts are
     // intentionally omitted — only the global excluded set applies.
     const selectionParams = {
         sortedExercises,
@@ -557,7 +559,7 @@ const attachOptionalCardioToRoutine = ({ cardioPreference, sortedExercises, crit
             equipments: criteria.equipments,
             muscleGroup: 'cardio',
             exerciseCategory: 'all',
-            routineBarbellExerciseCount: 0,
+            workoutBarbellExerciseCount: 0,
         },
         context: { excludedExerciseIds: criteria.excludedExerciseIds },
     };
@@ -567,17 +569,18 @@ const attachOptionalCardioToRoutine = ({ cardioPreference, sortedExercises, crit
         return;
     const slot = {
         kind: 'cardio',
-        exerciseTemplate: cardioExercise,
-        durationSeconds: exports.DEFAULT_TRAINER_CARDIO_ATTACHMENT_DURATION_SECONDS,
+        exercise_template: cardioExercise,
+        duration_seconds: exports.DEFAULT_TRAINER_CARDIO_ATTACHMENT_DURATION_SECONDS,
+        set_count: 1,
     };
     if (cardioPreference === 'workout-start')
-        routineExercises.unshift(slot);
+        workoutExercises.unshift(slot);
     else
-        routineExercises.push(slot);
+        workoutExercises.push(slot);
     if (debugExerciseSelectionTrace) {
         exerciseSelectionTraces.push({
             traceKind: 'cardio',
-            routine,
+            workoutTemplate,
             prescriptionIndex: cardioPreference === 'workout-start'
                 ? CARDIO_TRACE_INDEX_BEFORE_TEMPLATE
                 : templatePrescriptionCount,
@@ -592,28 +595,27 @@ function generateProgram(params) {
     var _a, _b;
     const { trainerAlgorithmSettings, frequency, goal, level, equipments, workoutDurationMinutes, restTimerLength, exerciseStore, focusMuscle, excludedExerciseIds, debugExerciseSelectionTrace, cardioPreference, } = params;
     const exerciseSelectionTraces = [];
-    const routines = exports.programSplits[frequency];
+    const workoutTemplates = exports.programSplits[frequency];
     const program = {
-        name: frequency,
-        routines: [],
+        workoutTemplates: [],
     };
     // 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 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];
+    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];
             const muscleGroup = getMuscleGroup({
                 muscleGroupPrescription: exercisePrescription.muscle_group,
                 programFocusMuscleExerciseCount,
                 focusMuscle,
-                routineName: routine,
+                workoutTemplateName: workout,
             });
             // If the muscle group is not found, skip the exercise
             if (!muscleGroup) {
@@ -632,7 +634,7 @@ function generateProgram(params) {
                 exerciseCategory: exercisePrescription.category,
                 equipments,
                 muscleGroup,
-                routineBarbellExerciseCount,
+                workoutBarbellExerciseCount,
                 level,
                 goal,
             };
@@ -643,7 +645,7 @@ function generateProgram(params) {
                     criteria,
                     context: {
                         programUsedExerciseIds,
-                        routineUsedExerciseIds,
+                        workoutUsedExerciseIds,
                         excludedExerciseIds,
                     },
                     withTrace: true,
@@ -651,7 +653,7 @@ function generateProgram(params) {
                 exercise = selection.exercise;
                 exerciseSelectionTraces.push({
                     traceKind: 'template',
-                    routine,
+                    workoutTemplate: workout,
                     prescriptionIndex,
                     prescription: exercisePrescription,
                     resolvedMuscleGroup: muscleGroup,
@@ -666,30 +668,29 @@ function generateProgram(params) {
                     criteria,
                     context: {
                         programUsedExerciseIds,
-                        routineUsedExerciseIds,
+                        workoutUsedExerciseIds,
                         excludedExerciseIds,
                     },
                 });
             }
             if (!!exercise) {
                 programUsedExerciseIds.add(exercise.id);
-                routineUsedExerciseIds.add(exercise.id);
+                workoutUsedExerciseIds.add(exercise.id);
                 if (exercise.equipment_category === 'barbell')
-                    routineBarbellExerciseCount++;
+                    workoutBarbellExerciseCount++;
                 if (exercisePrescription.muscle_group === 'focus_muscle')
                     programFocusMuscleExerciseCount++;
                 const repRange = (0, exports.getTrainerRepRange)(trainerAlgorithmSettings, goal, exercisePrescription.category);
-                routineExercises.push({
+                workoutExercises.push({
                     kind: 'resistance',
-                    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 : '',
+                    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),
                 });
             }
             else {
@@ -707,23 +708,21 @@ function generateProgram(params) {
                 });
             }
         }
-        attachOptionalCardioToRoutine({
+        attachOptionalCardioToWorkoutTemplate({
             cardioPreference,
             sortedExercises,
             criteria: { equipments, level, goal, frequency, excludedExerciseIds },
             debugExerciseSelectionTrace,
             exerciseSelectionTraces,
-            routine,
-            templatePrescriptionCount: routineTemplate.exercises.length,
-            routineExercises,
+            workoutTemplate: workout,
+            templatePrescriptionCount: workoutTemplate.exercises.length,
+            workoutExercises,
         });
-        program.routines.push({
-            name: routine,
-            notes: routineTemplate.notes,
-            exercises: routineExercises,
+        program.workoutTemplates.push({
+            name: workout,
+            exercises: workoutExercises,
         });
     }
-    // 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 { WorkoutDurationMinutes } from './hevyTrainer';
+import { TrainerWorkoutTemplateName, WorkoutDurationMinutes } from './hevyTrainer';
 import { postEmailBackofficeSchema } from './schemas';
 import { Language } from './translations';
 import { Lookup } from './typeUtils';
@@ -299,7 +299,7 @@ export interface BackofficeExistingUserResponse {
     public_api_key: string | null;
     limited_discovery: boolean;
     coach_trial_expire_date?: string;
-    hevy_trainer_program: HevyTrainerProgram | null;
+    hevy_trainer_program: TrainerProgramV3 | null;
 }
 export interface BackofficeDeletedUserResponse {
     state: 'deleted-account';
@@ -744,6 +744,10 @@ 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
@@ -887,6 +891,7 @@ 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';
@@ -966,6 +971,7 @@ 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';
@@ -1093,12 +1099,14 @@ 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 {
@@ -1267,6 +1275,91 @@ 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;
@@ -1283,6 +1376,7 @@ export interface HevyTrainerProgram {
     rest_timer_length: RestTimerLength;
     cardio_preference: CardioPreference;
 }
+/** @deprecated Use PostTrainerProgramV3RequestBody instead */
 export interface PostHevyTrainerProgramRequestBody {
     program: {
         version: 1;
@@ -1299,6 +1393,7 @@ export interface PostHevyTrainerProgramRequestBody {
         cardio_preference: CardioPreference;
     };
 }
+/** @deprecated Use UpdateTrainerProgramV3RequestBody instead */
 export interface UpdateHevyTrainerProgramRequestBody {
     program: {
         version: 1;
@@ -1321,7 +1416,7 @@ export interface UpdateHevyTrainerProgramRequestBody {
         }[];
     };
 }
-/** @deprecated Use HevyTrainerProgram instead */
+/** @deprecated Use TrainerProgramV3 instead */
 export interface HevyTrainerProgramOld {
     id: string;
     created_at: string;
@@ -1336,7 +1431,7 @@ export interface HevyTrainerProgramOld {
     next_workout_index: number;
     workout_duration_minutes?: WorkoutDurationMinutes;
 }
-/** @deprecated Use PostHevyTrainerProgramRequestBody instead */
+/** @deprecated Use PostTrainerProgramV3RequestBody instead */
 export interface PostHevyTrainerProgramOldRequestBody {
     program: {
         title: string;
@@ -1350,7 +1445,7 @@ export interface PostHevyTrainerProgramOldRequestBody {
         workout_duration_minutes?: WorkoutDurationMinutes;
     };
 }
-/** @deprecated Use UpdateHevyTrainerProgramRequestBody instead */
+/** @deprecated Use UpdateTrainerProgramV3RequestBody instead */
 export interface UpdateHevyTrainerProgramOldRequestBody {
     program: {
         programId: string;
@@ -1618,12 +1713,6 @@ export interface UserMetadataResponse {
 export interface NetworkInfoRequest {
     networkType: NetworkType;
 }
-export type Gym = {
-    id: string;
-    name: string;
-    address: string;
-    distanceM: number;
-};
 export interface StripePrice {
     product_id: string;
     billing_period: 'month' | 'year' | 'pay-once';

package/built/index.js

@@ -324,6 +324,7 @@ 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,6 +36,7 @@ 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.routineNames.reduce((acc, name) => {
+    const templates = hevyTrainer_1.workoutTemplateNames.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: [], routineBarbellExerciseCount: 0, level: 'beginner', goal: 'strength', muscleGroup: 'chest', frequency: 3 }, overrides));
+const baseCriteria = (overrides = {}) => (Object.assign({ exerciseCategory: 'compound', equipments: [], workoutBarbellExerciseCount: 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 routine when all are used in the program', () => {
+    it('pass 2: falls back to exercises not used in the current workout 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 routine, so pass 2 should succeed.
-                routineUsedExerciseIds: new Set(),
+                // But not used in this workout, so pass 2 should succeed.
+                workoutUsedExerciseIds: 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,
-                    routineBarbellExerciseCount: 10,
+                    workoutBarbellExerciseCount: 10,
                     equipments: ['dumbbell'],
                 }),
                 context: {},
@@ -519,7 +519,7 @@ describe('pickTrainerExercise', () => {
                 sortedExercises: chestOnlySorted([ex]),
                 criteria: baseCriteria({
                     frequency: 1,
-                    routineBarbellExerciseCount: 2,
+                    workoutBarbellExerciseCount: 2,
                     equipments: ['dumbbell'],
                 }),
                 context: {},
@@ -532,7 +532,7 @@ describe('pickTrainerExercise', () => {
                 sortedExercises: chestOnlySorted([ex]),
                 criteria: baseCriteria({
                     frequency: 1,
-                    routineBarbellExerciseCount: 3,
+                    workoutBarbellExerciseCount: 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,
-                    routineBarbellExerciseCount: 5,
+                    workoutBarbellExerciseCount: 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 routine.
+        // Put a single chest compound prescription into the 1-day full body workout.
         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 routine per programSplit and populates exercise fields from the settings', () => {
+    it('produces one workout 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,27 +613,19 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             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');
-        if (exercise.kind !== 'resistance')
+        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(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);
+        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);
     });
     it('returns a partial program and errors when no matching exercise can be found', () => {
         const settings = buildSettingsForChestProgram();
@@ -656,14 +648,14 @@ describe('generateProgram', () => {
             type: 'exercise_not_found',
             muscleGroup: 'chest',
         });
-        // The routine structure still exists in the partial program, just without
+        // The workout template structure still exists in the partial program, just without
         // any resolved exercises.
-        expect(result.partialProgram.routines).toHaveLength(1);
-        expect(result.partialProgram.routines[0].exercises).toEqual([]);
+        expect(result.partialProgram.workoutTemplates).toHaveLength(1);
+        expect(result.partialProgram.workoutTemplates[0].exercises).toEqual([]);
     });
     describe('min_workout_duration_limit filtering', () => {
         /**
-         * Runs a 1-day program containing a single chest compound prescription
+         * Runs a 1-day workout 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.
@@ -690,9 +682,8 @@ describe('generateProgram', () => {
                 exerciseStore: [makeExercise({ id: 'bench' })],
                 cardioPreference: 'no-cardio',
             });
-            const routine = (result.success ? result.program : result.partialProgram)
-                .routines[0];
-            return routine.exercises.length === 1;
+            const workoutTemplate = (result.success ? result.program : result.partialProgram).workoutTemplates[0];
+            return workoutTemplate.exercises.length === 1;
         };
         it('skips prescriptions whose limit is strictly greater than the selected duration', () => {
             expect(runDurationProbe({ limit: 80, workoutDurationMinutes: 40 })).toBe(false);
@@ -764,11 +755,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.routines[0].exercises;
+            const placed = result.program.workoutTemplates[0].exercises;
             expect(placed.every((e) => e.kind === 'resistance')).toBe(true);
             expect(placed
                 .filter(hevyTrainer_1.isTrainerProgramResistanceExercise)
-                .map((e) => e.warmupSetCount)).toEqual([1, 2]);
+                .map((e) => e.warmup_set_count)).toEqual([1, 2]);
         });
     });
     it('skips focus_muscle prescriptions when no focusMuscle is provided', () => {
@@ -792,7 +783,7 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.routines[0].exercises).toEqual([]);
+        expect(result.program.workoutTemplates[0].exercises).toEqual([]);
     });
     it('routes focus_muscle prescriptions to the requested SimplifiedMuscleGroup', () => {
         const settings = makeSettings();
@@ -819,12 +810,11 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        const [exercise] = result.program.routines[0].exercises;
+        const [exercise] = result.program.workoutTemplates[0].exercises;
         expect(exercise.kind).toBe('resistance');
         if (exercise.kind !== 'resistance')
             return;
-        expect(exercise.exerciseTemplate.id).toBe('biceps-curl');
-        expect(exercise.muscleGroup).toBe('focus_muscle');
+        expect(exercise.exercise_template.id).toBe('biceps-curl');
     });
     it('excludes exercises listed in `excludedExerciseIds`', () => {
         const settings = buildSettingsForChestProgram();
@@ -845,7 +835,7 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.routines[0].exercises[0].exerciseTemplate.id).toBe('alt');
+        expect(result.program.workoutTemplates[0].exercises[0].exercise_template.id).toBe('alt');
     });
     it('attaches exercise selection traces when debugExerciseSelectionTrace is true', () => {
         const settings = buildSettingsForChestProgram();
@@ -866,7 +856,7 @@ describe('generateProgram', () => {
         expect(result.exerciseSelectionTraces).toHaveLength(1);
         const [trace] = result.exerciseSelectionTraces;
         expect(trace.traceKind).toBe('template');
-        expect(trace.routine).toBe('full_body_1');
+        expect(trace.workoutTemplate).toBe('full_body_1');
         expect(trace.selectedExerciseId).toBe('bench');
         expect(trace.trace.selectedPass).toBe(1);
     });
@@ -938,7 +928,7 @@ describe('generateProgram', () => {
         expect(cardioTrace.equipments).toEqual([]);
         expect(cardioTrace.level).toBe('beginner');
     });
-    it('uses the same prioritized cardio exercise on every routine (not blocked by program reuse)', () => {
+    it('uses the same prioritized cardio exercise on every workout (not blocked by program reuse)', () => {
         const settings = makeSettings();
         settings.templates.full_body_2_a = {
             exercises: [{ muscle_group: 'chest', category: 'compound' }],
@@ -971,13 +961,13 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.routines[0].exercises[0]).toMatchObject({
+        expect(result.program.workoutTemplates[0].exercises[0]).toMatchObject({
             kind: 'cardio',
-            exerciseTemplate: { id: 'run' },
+            exercise_template: { id: 'run' },
         });
-        expect(result.program.routines[1].exercises[0]).toMatchObject({
+        expect(result.program.workoutTemplates[1].exercises[0]).toMatchObject({
             kind: 'cardio',
-            exerciseTemplate: { id: 'run' },
+            exercise_template: { id: 'run' },
         });
     });
     it('skips cardio exercises that need equipment the user does not have', () => {
@@ -1016,9 +1006,9 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.routines[0].exercises[0]).toMatchObject({
+        expect(result.program.workoutTemplates[0].exercises[0]).toMatchObject({
             kind: 'cardio',
-            exerciseTemplate: { id: 'body-run' },
+            exercise_template: { id: 'body-run' },
         });
     });
     it('skips globally excluded cardio and uses the next priority exercise', () => {
@@ -1057,12 +1047,12 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        expect(result.program.routines[0].exercises[0]).toMatchObject({
+        expect(result.program.workoutTemplates[0].exercises[0]).toMatchObject({
             kind: 'cardio',
-            exerciseTemplate: { id: 'run-b' },
+            exercise_template: { id: 'run-b' },
         });
     });
-    it('keeps global trace order aligned with routine generation (no cross-routine unshift)', () => {
+    it('keeps global trace order aligned with workout generation (no cross-workout unshift)', () => {
         const settings = makeSettings();
         settings.templates.full_body_2_a = {
             exercises: [{ muscle_group: 'chest', category: 'compound' }],
@@ -1096,15 +1086,15 @@ describe('generateProgram', () => {
         expect(result.success).toBe(true);
         if (!result.success)
             return;
-        const idxA = result.exerciseSelectionTraces.findIndex((t) => t.routine === 'full_body_2_a');
-        const idxB = result.exerciseSelectionTraces.findIndex((t) => t.routine === 'full_body_2_b');
+        const idxA = result.exerciseSelectionTraces.findIndex((t) => t.workoutTemplate === 'full_body_2_a');
+        const idxB = result.exerciseSelectionTraces.findIndex((t) => t.workoutTemplate === '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 routine.
+            // 4 identical barbell compound prescriptions in the 1-day workout.
             settings.templates.full_body_1 = {
                 exercises: Array.from({ length: 4 }, () => ({
                     muscle_group: 'chest',
@@ -1133,7 +1123,7 @@ describe('generateProgram', () => {
             expect(result.success).toBe(false);
             if (result.success)
                 return;
-            expect(result.partialProgram.routines[0].exercises).toHaveLength(3);
+            expect(result.partialProgram.workoutTemplates[0].exercises).toHaveLength(3);
             expect(result.errors).toHaveLength(1);
         });
         it('allows 4+ barbell prescriptions at frequency 1 when no substitute is present', () => {
@@ -1164,19 +1154,19 @@ describe('generateProgram', () => {
             expect(result.success).toBe(true);
             if (!result.success)
                 return;
-            expect(result.program.routines[0].exercises).toHaveLength(4);
+            expect(result.program.workoutTemplates[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
-            // routines and confirm the counter survives between routines.
+            // workouts and confirm the counter survives between workouts.
             const settings = makeSettings();
             const focusPrescription = {
                 muscle_group: 'focus_muscle',
                 category: 'isolation',
             };
-            // full_body routines allow any focus muscle. Place 2 per routine so the
+            // full_body workouts allow any focus muscle. Place 2 per workout so the
             // combined count across the program is 4.
             settings.templates.full_body_2_a = {
                 exercises: [focusPrescription, focusPrescription],
@@ -1246,7 +1236,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 routines (legs_1 and
+            // 'abductors', 'adductors']. The first two allowed workouts (legs_1 and
             // lower_2) should land on quadriceps and hamstrings respectively.
             const exercises = [
                 makeExercise({
@@ -1279,10 +1269,7 @@ 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.routine)).toEqual([
-                'legs_1',
-                'lower_2',
-            ]);
+            expect(result.exerciseSelectionTraces.map((t) => t.workoutTemplate)).toEqual(['legs_1', 'lower_2']);
             expect(result.exerciseSelectionTraces
                 .filter((t) => t.traceKind === 'template')
                 .map((t) => t.resolvedMuscleGroup)).toEqual(['quadriceps', 'hamstrings']);
@@ -1290,14 +1277,14 @@ describe('generateProgram', () => {
     });
     describe('isFocusMuscleExtraExerciseAllowed template compatibility', () => {
         /**
-         * Runs a single-routine program that places one focus_muscle
+         * Runs a single-workout template program that places one focus_muscle
          * prescription into the requested template and returns whether the
          * prescription produced an exercise or was skipped.
          */
-        const runFocusMuscleProbe = (routineName, focusMuscle, frequency, candidateExercise) => {
+        const runFocusMuscleProbe = (workoutTemplateName, focusMuscle, frequency, candidateExercise) => {
             var _a;
             const settings = makeSettings();
-            settings.templates[routineName] = {
+            settings.templates[workoutTemplateName] = {
                 exercises: [{ muscle_group: 'focus_muscle', category: 'isolation' }],
             };
             const result = (0, hevyTrainer_1.generateProgram)({
@@ -1313,13 +1300,13 @@ describe('generateProgram', () => {
                 debugExerciseSelectionTrace: true,
                 cardioPreference: 'no-cardio',
             });
-            // 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);
+            // 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);
             return {
-                placed: ((_a = routine === null || routine === void 0 ? void 0 : routine.exercises.length) !== null && _a !== void 0 ? _a : 0) > 0,
+                placed: ((_a = workoutTemplate === null || workoutTemplate === void 0 ? void 0 : workoutTemplate.exercises.length) !== null && _a !== void 0 ? _a : 0) > 0,
             };
         };
-        it('allows every focus muscle on full_body routines', () => {
+        it('allows every focus muscle on full_body workouts', () => {
             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.993",
+  "version": "1.0.994",
   "description": "",
   "main": "built/index.js",
   "types": "built/index.d.ts",