hevy-shared 1.0.1047 → 1.0.1049

package/built/geography.d.ts

@@ -0,0 +1 @@
+export declare const distanceMBetween: (lat1: number, lon1: number, lat2: number, lon2: number) => number;

package/built/geography.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distanceMBetween = void 0;
+const haversineDistance = (lat1, lon1, lat2, lon2) => {
+    const R = 6371;
+    const dLat = ((lat2 - lat1) * Math.PI) / 180;
+    const dLon = ((lon2 - lon1) * Math.PI) / 180;
+    const a = Math.sin(dLat / 2) ** 2 +
+        Math.cos((lat1 * Math.PI) / 180) *
+            Math.cos((lat2 * Math.PI) / 180) *
+            Math.sin(dLon / 2) ** 2;
+    return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+};
+const distanceMBetween = (lat1, lon1, lat2, lon2) => Math.round(haversineDistance(lat1, lon1, lat2, lon2) * 1000);
+exports.distanceMBetween = distanceMBetween;

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[];
@@ -92,19 +92,19 @@ export type TrainerProgramAttemptWithTraces = TrainerProgramAttempt & {
 };
 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;
@@ -135,10 +135,11 @@ 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 HevyTrainerRoutineName]: WorkoutTemplate;
+    [key in TrainerWorkoutTemplateName]: WorkoutTemplate;
 };
 export interface BackofficeTrainerPreset {
     id?: number;
@@ -157,39 +158,38 @@ export interface TrainerAlgorithmSettings {
     exercise_notes: ExerciseNotes;
     exercise_replacements: ExerciseReplacements;
 }
-/** Resistance prescriptions from templates (sets, reps, rest, notes). */
 export interface TrainerProgramResistanceExercise {
     kind: 'resistance';
-    exerciseTemplate: HevyTrainerLibraryExercise;
-    muscleGroup: MuscleGroup | 'focus_muscle';
-    category: HevyTrainerExerciseCategory;
-    sets: number;
-    warmupSetCount?: number;
-    repRangeStart: number;
-    repRangeEnd: number;
-    restTimerSeconds: number;
-    notes?: string;
+    exercise_template: HevyTrainerLibraryExercise;
+    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 {
     kind: 'cardio';
-    exerciseTemplate: HevyTrainerLibraryExercise;
-    durationSeconds: number;
+    exercise_template: HevyTrainerLibraryExercise;
+    set_count: 1;
+    duration_seconds: number;
 }
-export type TrainerProgramExercise = TrainerProgramResistanceExercise | TrainerProgramCardioExercise;
+export interface TrainerProgramOtherExercise {
+    kind: 'other';
+    exercise_template: HevyTrainerLibraryExercise;
+    set_count: number;
+}
+export type TrainerProgramExercise = TrainerProgramResistanceExercise | TrainerProgramCardioExercise | TrainerProgramOtherExercise;
 export declare const isTrainerProgramResistanceExercise: (exercise: TrainerProgramExercise) => exercise is TrainerProgramResistanceExercise;
 export declare const isTrainerProgramCardioExercise: (exercise: TrainerProgramExercise) => exercise is TrainerProgramCardioExercise;
-export interface TrainerProgramRoutine {
-    name: HevyTrainerRoutineName;
+export declare const isTrainerProgramOtherExercise: (exercise: TrainerProgramExercise) => exercise is TrainerProgramOtherExercise;
+export interface TrainerProgramWorkoutTemplate {
+    name: TrainerWorkoutTemplateName;
     exercises: TrainerProgramExercise[];
-    notes?: string;
 }
-export interface TrainerProgram {
-    name: WeeklyTrainingFrequency;
-    routines: TrainerProgramRoutine[];
+export interface GeneratedTrainerProgram {
+    workoutTemplates: TrainerProgramWorkoutTemplate[];
 }
 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,23 +243,14 @@ 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 {
     success: true;
-    program: TrainerProgram;
+    program: GeneratedTrainerProgram;
 }
 export interface TrainerProgramError {
     success: false;
     errors: ExercisePrescriptionError[];
-    partialProgram: TrainerProgram;
+    partialProgram: GeneratedTrainerProgram;
 }
 export type TrainerProgramAttempt = TrainerProgramResult | TrainerProgramError;
 /**

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,