hevy-shared 1.0.962 → 1.0.964

package/built/hevyTrainer.js

@@ -0,0 +1,676 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrioritySortedExercises = exports.isEquipmentCompatible = exports.normalizeExerciseCategory = exports.getTrainerRestTimerSeconds = exports.getTrainerRepRange = exports.getTrainerSetCount = exports.programSplits = exports.frequencyMap = exports.routineNames = exports.defaultDurationPerFrequency = exports.hevyTrainerExerciseCategories = exports.granularEquipmentsToTrainerEquipments = exports.trainerEquipmentToGranularEquipments = exports.granularEquipmentDefaults = exports.trainerGymTypes = exports.workoutDurationOptions = void 0;
+exports.pickExerciseForPrescription = pickExerciseForPrescription;
+exports.generateProgram = generateProgram;
+const _1 = require(".");
+exports.workoutDurationOptions = [40, 60, 80];
+exports.trainerGymTypes = [
+    'home_gym',
+    'garage_gym',
+    'commercial_gym',
+    'full_gym',
+];
+exports.granularEquipmentDefaults = {
+    home_gym: ['dumbbell', 'pullup_bar', 'adjustable_bench'],
+    garage_gym: [
+        'dumbbell',
+        'kettlebell',
+        'barbell',
+        'plate',
+        'pullup_bar',
+        'dip_bar',
+        'squat_rack',
+        'adjustable_bench',
+        'spinning',
+    ],
+    commercial_gym: [
+        'dumbbell',
+        'barbell',
+        'plate',
+        'ez_bar',
+        'pullup_bar',
+        'dip_bar',
+        'squat_rack',
+        'adjustable_bench',
+        'single_cable_machine',
+        'lat_pulldown_cable',
+        'leg_press_machine',
+        'smith_machine',
+        'stack_machines',
+        'treadmill',
+        'elliptical_trainer',
+        'spinning',
+    ],
+    // All equipment is available in a full gym
+    full_gym: [
+        'barbell',
+        'dumbbell',
+        'kettlebell',
+        'plate',
+        'medicine_ball',
+        'ez_bar',
+        'landmine',
+        'trap_bar',
+        'pullup_bar',
+        'dip_bar',
+        'squat_rack',
+        'flat_bench',
+        'adjustable_bench',
+        'dual_cable_machine',
+        'single_cable_machine',
+        'lat_pulldown_cable',
+        'leg_press_machine',
+        'smith_machine',
+        't_bar',
+        'plate_machines',
+        'stack_machines',
+        'treadmill',
+        'elliptical_trainer',
+        'rowing_machine',
+        'spinning',
+        'stair_machine',
+        'air_bike',
+        'suspension_band',
+        'resistance_band',
+        'battle_rope',
+        'rings',
+        'jump_rope',
+    ],
+};
+const trainerEquipmentToGranularEquipmentsMap = {
+    barbell: [
+        'adjustable_bench',
+        'barbell',
+        'ez_bar',
+        'flat_bench',
+        'landmine',
+        'plate',
+        'squat_rack',
+        't_bar',
+    ],
+    dumbbell: ['adjustable_bench', 'dumbbell', 'flat_bench'],
+    machine: [
+        'adjustable_bench',
+        'dip_bar',
+        'dual_cable_machine',
+        'flat_bench',
+        'lat_pulldown_cable',
+        'leg_press_machine',
+        'plate',
+        'plate_machines',
+        'pullup_bar',
+        'single_cable_machine',
+        'smith_machine',
+        'stack_machines',
+    ],
+};
+const trainerEquipmentToGranularEquipments = (equipments) => {
+    const granularEquipments = [];
+    equipments.forEach((equipment) => {
+        granularEquipments.push(...trainerEquipmentToGranularEquipmentsMap[equipment]);
+    });
+    return Array.from(new Set(granularEquipments));
+};
+exports.trainerEquipmentToGranularEquipments = trainerEquipmentToGranularEquipments;
+const MACHINE_SPECIFIC_GRANULAR_EQUIPMENTS = [
+    'smith_machine',
+    'leg_press_machine',
+    'dual_cable_machine',
+    'single_cable_machine',
+    'lat_pulldown_cable',
+    'plate_machines',
+    'stack_machines',
+    'dip_bar',
+    'pullup_bar',
+];
+/**
+ * Converts granular equipment values back to the old HevyTrainerProgramEquipment
+ * types for backwards compatibility with old mobile clients.
+ */
+const granularEquipmentsToTrainerEquipments = (granularEquipments) => {
+    const result = [];
+    if (granularEquipments.includes('barbell')) {
+        result.push('barbell');
+    }
+    if (granularEquipments.includes('dumbbell')) {
+        result.push('dumbbell');
+    }
+    if (granularEquipments.some((eq) => MACHINE_SPECIFIC_GRANULAR_EQUIPMENTS.includes(eq))) {
+        result.push('machine');
+    }
+    return result;
+};
+exports.granularEquipmentsToTrainerEquipments = granularEquipmentsToTrainerEquipments;
+exports.hevyTrainerExerciseCategories = ['compound', 'isolation'];
+// These are the values that Philip decided for the default duration per frequency
+exports.defaultDurationPerFrequency = {
+    1: 80,
+    2: 60,
+    3: 60,
+    4: 60,
+    5: 40,
+    6: 40,
+};
+exports.routineNames = [
+    // Full body 1x
+    'full_body_1',
+    // Full body 2x
+    'full_body_2_a',
+    'full_body_2_b',
+    // Full body 3x
+    'full_body_3_a',
+    'full_body_3_b',
+    'full_body_3_c',
+    // Upper body x4 per week
+    'upper_1_a',
+    'lower_1_a',
+    'upper_1_b',
+    'lower_1_b',
+    // Push Pull Legs Upper Lower 5x per week
+    'push_1',
+    'pull_1',
+    'legs_1',
+    'upper_2',
+    'lower_2',
+    // Push Pull Legs x6 per week
+    'push_2_a',
+    'pull_2_a',
+    'legs_2_a',
+    'push_2_b',
+    'pull_2_b',
+    'legs_2_b',
+];
+exports.frequencyMap = {
+    1: 'one_day',
+    2: 'two_days',
+    3: 'three_days',
+    4: 'four_days',
+    5: 'five_days',
+    6: 'six_days',
+};
+exports.programSplits = {
+    1: ['full_body_1'],
+    2: ['full_body_2_a', 'full_body_2_b'],
+    3: ['full_body_3_a', 'full_body_3_b', 'full_body_3_c'],
+    4: ['upper_1_a', 'lower_1_a', 'upper_1_b', 'lower_1_b'],
+    5: ['push_1', 'pull_1', 'legs_1', 'upper_2', 'lower_2'],
+    6: ['push_2_a', 'pull_2_a', 'legs_2_a', 'push_2_b', 'pull_2_b', 'legs_2_b'],
+};
+const getTrainerSetCount = (trainerAlgorithmSettings, goal, frequency) => {
+    return trainerAlgorithmSettings.sets[exports.frequencyMap[frequency]][goal];
+};
+exports.getTrainerSetCount = getTrainerSetCount;
+const getTrainerRepRange = (trainerAlgorithmSettings, goal, exerciseCategory) => {
+    return trainerAlgorithmSettings.rep_ranges[goal][exerciseCategory];
+};
+exports.getTrainerRepRange = getTrainerRepRange;
+const getTrainerRestTimerSeconds = (trainerAlgorithmSettings, goal, length, exerciseCategory) => {
+    return trainerAlgorithmSettings.rest_timers[goal][length][exerciseCategory];
+};
+exports.getTrainerRestTimerSeconds = getTrainerRestTimerSeconds;
+/**
+ * Normalizes the exercise category to a HevyTrainerExerciseCategory
+ * - Treat custom exercises and exercises with no category as `compound`
+ * - Treat `assistance-compound` as `compound`
+ * - Treat `isolation` as `isolation`
+ * @param exercise - The exercise to normalize the category for
+ * @returns The normalized exercise category
+ */
+const normalizeExerciseCategory = (exercise) => {
+    return exercise.is_custom
+        ? 'compound'
+        : exercise.category === 'isolation'
+            ? 'isolation'
+            : 'compound';
+};
+exports.normalizeExerciseCategory = normalizeExerciseCategory;
+/**
+ * Returns true if the focus muscle group extra exercise is allowed for a given template
+ */
+const isFocusMuscleExtraExerciseAllowed = (templateName, focusMuscle) => {
+    const isFullBodyTemplate = templateName.startsWith('full_body');
+    // Full body templates allow all muscle groups
+    if (isFullBodyTemplate) {
+        return true;
+    }
+    const isLegsTemplate = templateName.startsWith('legs');
+    const isUpperTemplate = templateName.startsWith('upper');
+    const isLowerTemplate = templateName.startsWith('lower');
+    const isPushTemplate = templateName.startsWith('push');
+    const isPullTemplate = templateName.startsWith('pull');
+    switch (focusMuscle) {
+        case 'core':
+            // Core exercises are allowed for all templates
+            return true;
+        case 'chest':
+        case 'shoulders':
+            return isUpperTemplate || isPushTemplate;
+        case 'arms':
+            return isUpperTemplate || isPullTemplate || isPushTemplate;
+        case 'legs':
+            return isLowerTemplate || isLegsTemplate;
+        case 'back':
+            return isUpperTemplate || isPullTemplate;
+        default:
+            (0, _1.exhaustiveTypeCheck)(focusMuscle);
+            return false;
+    }
+};
+/**
+ * Checks if an exercise is compatible with the user's selected granular equipments
+ *
+ * - If the exercise has no granular equipments, it is compatible no matter what the user has selected
+ * - Otherwise, the exercise is only allowed if the user has all the granular equipments
+ */
+const isEquipmentCompatible = (exercise, userSelectedGranularEquipments) => {
+    if (!exercise.granular_equipments ||
+        exercise.granular_equipments.length === 0) {
+        return true;
+    }
+    const allowedEquipments = [...userSelectedGranularEquipments];
+    // Special case: adjustable bench can substitute for flat bench
+    if (userSelectedGranularEquipments.includes('adjustable_bench')) {
+        allowedEquipments.push('flat_bench');
+    }
+    // Special case: dual cable machine can substitute for single cable machine
+    if (userSelectedGranularEquipments.includes('dual_cable_machine')) {
+        allowedEquipments.push('single_cable_machine');
+    }
+    return exercise.granular_equipments.every((granularEquipment) => allowedEquipments.includes(granularEquipment));
+};
+exports.isEquipmentCompatible = isEquipmentCompatible;
+const MAX_BARBELL_EXERCISES_FOR_ONCE_PER_WEEK = 3;
+/**
+ * - If frequency is 1 and the candidate exercise is a barbell exercise
+ * - Then allow at most `MAX_BARBELL_EXERCISES_FOR_ONCE_PER_WEEK` barbell exercises
+ * - 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 isCandidateBarbell = exercise.equipment_category === 'barbell';
+    const isOncePerWeek = frequency === 1;
+    if (!isCandidateBarbell || !isOncePerWeek)
+        return true;
+    const isAtOrOverLimit = routineBarbellExerciseCount >= MAX_BARBELL_EXERCISES_FOR_ONCE_PER_WEEK;
+    if (!isAtOrOverLimit)
+        return true;
+    const barbellSubstitutes = [
+        'dumbbell',
+        'dual_cable_machine',
+        'single_cable_machine',
+        'smith_machine',
+        'plate_machines',
+        'stack_machines',
+    ];
+    const hasAnySubstitute = barbellSubstitutes.some((substitute) => userEquipments.includes(substitute));
+    // If the user has substitutes, enforce the cap; otherwise allow barbell to avoid dead-ends.
+    return !hasAnySubstitute;
+};
+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)) ||
+        ((_c = context.excludedExerciseIds) === null || _c === void 0 ? void 0 : _c.has(exercise.id)) ||
+        false);
+};
+const isolationExerciseAlternatives = {
+    /**
+     * - B74A95BB (Kneeling Push Up)
+     * - 392887AA (Push Up)
+     * - 39C99849 (Incline Push Ups)
+     * - 982734D4 (Plate Press)
+     */
+    chest: ['B74A95BB', '392887AA', '39C99849', '982734D4'],
+    /**
+     * - 6575F52D (Diamond Push Up)
+     * - CD6DC8E5 (Bench Dip)
+     */
+    triceps: ['6575F52D', 'CD6DC8E5'],
+    /**
+     * - 32HKJ34K (Walking Lunge)
+     * - A733CC5B (Walking Lunge (Dumbbell))
+     * - 9694DA61 (Squat (Bodyweight))
+     */
+    quadriceps: ['32HKJ34K', 'A733CC5B', '9694DA61'],
+    /**
+     * - F6948F17 (Frog Pumps (Dumbbell))
+     * - 487B3755 (Single Leg Hip Thrust)
+     * - CDA23948 (Glute Bridge)
+     */
+    hamstrings: ['F6948F17', '487B3755', 'CDA23948'],
+    glutes: [],
+    lats: [],
+    lower_back: [],
+    upper_back: [],
+    shoulders: [],
+    biceps: [],
+    adductors: [],
+    abductors: [],
+    calves: [],
+    forearms: [],
+    abdominals: [],
+    other: [],
+    cardio: [],
+    traps: [],
+    neck: [],
+    full_body: [],
+};
+/**
+ * Sorts exercises by priority for each muscle group based on the provided priorities
+ * and adds any remaining exercises from the store that weren't in the priorities.
+ *
+ * @param exercisePriorities - Object mapping muscle groups to arrays of exercise IDs in priority order
+ * @param exerciseStore - Array of all available exercises
+ * @returns Object mapping muscle groups to arrays of exercises sorted by priority
+ */
+const getPrioritySortedExercises = (exercisePriorities, exerciseStore) => {
+    // Have a map of muscle group to exercises sorted by exercise priority
+    const sortedExercises = Object.entries(exercisePriorities).reduce((acc, [muscleGroup, exercises]) => {
+        const foundExercises = exercises
+            .map((exercise) => exerciseStore.find((e) => e.id === exercise))
+            .filter((exercise) => exercise !== undefined);
+        // Debug: Log missing exercise IDs
+        const missingIds = exercises.filter((id) => !exerciseStore.some((e) => e.id === id));
+        if (missingIds.length > 0) {
+            console.log(`Missing the following exercises with IDs in the store for muscle group ${muscleGroup}:`, missingIds);
+        }
+        acc[muscleGroup] = foundExercises;
+        return acc;
+    }, {});
+    // Then add remaining exercises to the map
+    Object.keys(sortedExercises).forEach((muscleGroup) => {
+        const remainingExercises = exerciseStore
+            .filter((e) => e.muscle_group === muscleGroup &&
+            !sortedExercises[muscleGroup].includes(e))
+            .sort((a, b) => b.priority - a.priority);
+        sortedExercises[muscleGroup].push(...remainingExercises);
+    });
+    return sortedExercises;
+};
+exports.getPrioritySortedExercises = getPrioritySortedExercises;
+const getMuscleGroup = ({ muscleGroupPrescription, programFocusMuscleExerciseCount, focusMuscle, routineName, }) => {
+    if (muscleGroupPrescription === 'focus_muscle') {
+        // 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(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 routine
+        // we skip this extra exercise for the focus muscle in the program
+        return undefined;
+    }
+    return muscleGroupPrescription;
+};
+/**
+ * Checks if an exercise matches the given criteria for selection
+ */
+const isExerciseMatch = (exercise, criteria) => {
+    var _a, _b, _c, _d;
+    const categoryMatch = criteria.exerciseCategory === 'all' ||
+        exercise.category === criteria.exerciseCategory ||
+        (exercise.category === 'assistance-compound' &&
+            criteria.exerciseCategory === 'compound');
+    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);
+    return (categoryMatch && levelMatch && goalMatch && equipmentMatch && barbellLimitOk);
+};
+/**
+ * Checks if an exercise is a valid alternative isolation exercise
+ */
+const isAlternativeIsolationExerciseMatch = (exercise, criteria) => {
+    var _a, _b;
+    const isIsolationCategory = criteria.exerciseCategory === 'isolation';
+    const isAlternativeExercise = isolationExerciseAlternatives[criteria.muscleGroup].includes(exercise.id);
+    const equipmentMatch = (0, exports.isEquipmentCompatible)(exercise, criteria.equipments);
+    const levelMatch = (_b = (_a = exercise.level) === null || _a === void 0 ? void 0 : _a.includes(criteria.level)) !== null && _b !== void 0 ? _b : false;
+    return (isIsolationCategory && isAlternativeExercise && equipmentMatch && levelMatch);
+};
+/**
+ * Finds an exercise that matches the criteria and is not already used
+ */
+const findMatchingExercise = (exercises, criteria, context) => {
+    return exercises.find((exercise) => {
+        const matchesCriteria = isExerciseMatch(exercise, criteria);
+        const isNotUsed = !isExerciseUsed(exercise, context);
+        return matchesCriteria && isNotUsed;
+    });
+};
+/**
+ * Finds an alternative isolation exercise that matches the criteria
+ */
+const findAlternativeIsolationExercise = (exercises, criteria, context) => {
+    return exercises.find((exercise) => {
+        const matchesCriteria = isAlternativeIsolationExerciseMatch(exercise, criteria);
+        const isNotUsed = !isExerciseUsed(exercise, context);
+        return matchesCriteria && isNotUsed;
+    });
+};
+const pickExerciseForPrescriptionWithTrace = (params) => {
+    const { sortedExercises, handPickedExercises, criteria, context } = params;
+    const trace = { entries: [] };
+    const exercises = handPickedExercises
+        ? [...handPickedExercises, ...sortedExercises[criteria.muscleGroup]]
+        : sortedExercises[criteria.muscleGroup];
+    const programContext = {
+        programUsedExerciseIds: context.programUsedExerciseIds,
+        excludedExerciseIds: context.excludedExerciseIds,
+    };
+    const routineContext = {
+        routineUsedExerciseIds: context.routineUsedExerciseIds,
+        excludedExerciseIds: context.excludedExerciseIds,
+    };
+    // Pass 1
+    let exercise = findMatchingExercise(exercises, criteria, programContext);
+    trace.entries.push({
+        pass: 1,
+        label: 'exact match; not used 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: 1 }) };
+    // Pass 2
+    exercise = findMatchingExercise(exercises, criteria, routineContext);
+    trace.entries.push({
+        pass: 2,
+        label: 'exact match; 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: 2 }) };
+    // Pass 3
+    exercise = findAlternativeIsolationExercise(exercises, criteria, programContext);
+    trace.entries.push({
+        pass: 3,
+        label: 'handpicked alternative isolation; not used 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: 3 }) };
+    // Pass 4
+    exercise = findAlternativeIsolationExercise(exercises, criteria, routineContext);
+    trace.entries.push({
+        pass: 4,
+        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' }), routineContext);
+    trace.entries.push({
+        pass: 5,
+        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,
+    });
+    if (exercise)
+        return { exercise, trace: Object.assign(Object.assign({}, trace), { selectedPass: 5 }) };
+    // Pass 6
+    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);
+    trace.entries.push({
+        pass: 6,
+        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,
+    });
+    return exercise
+        ? { exercise, trace: Object.assign(Object.assign({}, trace), { selectedPass: 6 }) }
+        : { exercise: undefined, trace };
+};
+function pickExerciseForPrescription(params) {
+    if (params.withTrace) {
+        return pickExerciseForPrescriptionWithTrace(params);
+    }
+    return pickExerciseForPrescriptionWithTrace(params).exercise;
+}
+function generateProgram(params) {
+    var _a, _b;
+    const { trainerAlgorithmSettings, frequency, goal, level, equipments, workoutDurationMinutes, restTimerLength, exerciseStore, focusMuscle, excludedExerciseIds, debugExerciseSelectionTrace, } = params;
+    const exerciseSelectionTraces = [];
+    const routines = exports.programSplits[frequency];
+    const program = {
+        name: frequency,
+        routines: [],
+    };
+    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];
+            const muscleGroup = getMuscleGroup({
+                muscleGroupPrescription: exercisePrescription.muscle_group,
+                programFocusMuscleExerciseCount,
+                focusMuscle,
+                routineName: routine,
+            });
+            // If the muscle group is not found, skip the exercise
+            if (!muscleGroup) {
+                continue;
+            }
+            // If the exercise does not meet the min workout duration limit, skip the exercise
+            const execiseDoesNotMeetMinWorkoutDurationLimit = exercisePrescription.min_workout_duration_limit
+                ? exercisePrescription.min_workout_duration_limit >
+                    workoutDurationMinutes
+                : false;
+            if (execiseDoesNotMeetMinWorkoutDurationLimit) {
+                continue;
+            }
+            const criteria = {
+                frequency,
+                exerciseCategory: exercisePrescription.category,
+                equipments,
+                muscleGroup,
+                routineBarbellExerciseCount,
+                level,
+                goal,
+            };
+            let exercise;
+            if (debugExerciseSelectionTrace) {
+                const selection = pickExerciseForPrescription({
+                    sortedExercises,
+                    criteria,
+                    context: {
+                        programUsedExerciseIds,
+                        routineUsedExerciseIds,
+                        excludedExerciseIds,
+                    },
+                    withTrace: true,
+                });
+                exercise = selection.exercise;
+                exerciseSelectionTraces.push({
+                    routine,
+                    prescriptionIndex,
+                    prescription: exercisePrescription,
+                    resolvedMuscleGroup: muscleGroup,
+                    criteria,
+                    selectedExerciseId: (_a = selection.exercise) === null || _a === void 0 ? void 0 : _a.id,
+                    trace: selection.trace,
+                });
+            }
+            else {
+                exercise = pickExerciseForPrescription({
+                    sortedExercises,
+                    criteria,
+                    context: {
+                        programUsedExerciseIds,
+                        routineUsedExerciseIds,
+                        excludedExerciseIds,
+                    },
+                });
+            }
+            if (!!exercise) {
+                programUsedExerciseIds.add(exercise.id);
+                routineUsedExerciseIds.add(exercise.id);
+                if (exercise.equipment_category === 'barbell')
+                    routineBarbellExerciseCount++;
+                if (exercisePrescription.muscle_group === 'focus_muscle')
+                    programFocusMuscleExerciseCount++;
+                const repRange = (0, exports.getTrainerRepRange)(trainerAlgorithmSettings, goal, exercisePrescription.category);
+                routineExercises.push({
+                    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 {
+                // Collect error instead of throwing
+                allErrors.push({
+                    type: 'exercise_not_found',
+                    prescription: exercisePrescription,
+                    muscleGroup,
+                    context: {
+                        goal,
+                        level,
+                        equipments,
+                        focusMuscle,
+                    },
+                });
+            }
+        }
+        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,
+            errors: allErrors,
+            partialProgram: program,
+        };
+        return debugExerciseSelectionTrace
+            ? Object.assign(Object.assign({}, result), { exerciseSelectionTraces }) : result;
+    }
+    const result = {
+        success: true,
+        program,
+    };
+    return debugExerciseSelectionTrace
+        ? Object.assign(Object.assign({}, result), { exerciseSelectionTraces }) : result;
+}