hevy-shared 1.0.960 → 1.0.962

package/built/hevyTrainer.js

@@ -1,676 +0,0 @@
-"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;
-}