hevy-shared 1.0.1018 → 1.0.1020

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;
@@ -135,11 +135,10 @@ export type ExerciseReplacements = {
 };
 export interface WorkoutTemplate {
     exercises: ExercisePrescription[];
-    /** @deprecated Because this is english-only and not translatable so we are not using it currently */
     notes?: string;
 }
 export type Templates = {
-    [key in TrainerWorkoutTemplateName]: WorkoutTemplate;
+    [key in HevyTrainerRoutineName]: WorkoutTemplate;
 };
 export interface BackofficeTrainerPreset {
     id?: number;
@@ -158,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
@@ -243,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.
@@ -260,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,