hevy-shared 1.0.974 → 1.0.975

package/built/tests/hevyTrainer.test.js

@@ -0,0 +1,1423 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
+const hevyTrainer_1 = require("../hevyTrainer");
+const sortGranular = (arr) => [...arr].sort();
+describe('trainerEquipmentToGranularEquipments', () => {
+    it('returns empty array when no equipments are provided', () => {
+        expect((0, hevyTrainer_1.trainerEquipmentToGranularEquipments)([])).toEqual([]);
+    });
+    it('returns expected granular equipments for barbell only', () => {
+        const result = (0, hevyTrainer_1.trainerEquipmentToGranularEquipments)(['barbell']);
+        expect(sortGranular(result)).toEqual(sortGranular([
+            'adjustable_bench',
+            'barbell',
+            'ez_bar',
+            'flat_bench',
+            'landmine',
+            'plate',
+            'squat_rack',
+            't_bar',
+        ]));
+    });
+    it('returns expected granular equipments for dumbbell only', () => {
+        const result = (0, hevyTrainer_1.trainerEquipmentToGranularEquipments)(['dumbbell']);
+        expect(sortGranular(result)).toEqual(sortGranular(['adjustable_bench', 'dumbbell', 'flat_bench']));
+    });
+    it('returns expected granular equipments for machine only', () => {
+        const result = (0, hevyTrainer_1.trainerEquipmentToGranularEquipments)(['machine']);
+        expect(sortGranular(result)).toEqual(sortGranular([
+            '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',
+        ]));
+    });
+    it('returns deduped union for multiple equipments', () => {
+        const equipments = ['barbell', 'dumbbell'];
+        const result = (0, hevyTrainer_1.trainerEquipmentToGranularEquipments)(equipments);
+        const barbellOnly = (0, hevyTrainer_1.trainerEquipmentToGranularEquipments)(['barbell']);
+        const dumbbellOnly = (0, hevyTrainer_1.trainerEquipmentToGranularEquipments)(['dumbbell']);
+        const combined = sortGranular(Array.from(new Set([...barbellOnly, ...dumbbellOnly])));
+        expect(sortGranular(result)).toEqual(combined);
+    });
+});
+const createExercise = (granularEquipments) => ({
+    id: 'test-exercise',
+    title: 'Test Exercise',
+    granular_equipments: granularEquipments,
+});
+describe('isEquipmentCompatible', () => {
+    it('returns true when exercise has no granular equipments', () => {
+        const exercise = createExercise(undefined);
+        expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['barbell'])).toBe(true);
+    });
+    it('returns true when exercise has empty granular equipments', () => {
+        const exercise = createExercise([]);
+        expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['barbell'])).toBe(true);
+    });
+    it('returns true when user has all required equipments', () => {
+        const exercise = createExercise(['barbell', 'squat_rack']);
+        expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['barbell', 'squat_rack'])).toBe(true);
+    });
+    it('returns false when user is missing required equipment', () => {
+        const exercise = createExercise(['barbell', 'squat_rack']);
+        expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['barbell'])).toBe(false);
+    });
+    it('returns true when user has more equipment than required', () => {
+        const exercise = createExercise(['barbell']);
+        expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['barbell', 'squat_rack', 'dumbbell'])).toBe(true);
+    });
+    describe('special case: adjustable_bench / flat_bench substitution', () => {
+        it('allows adjustable_bench to substitute for flat_bench when exercise requires flat_bench', () => {
+            const exercise = createExercise(['flat_bench']);
+            expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['adjustable_bench'])).toBe(true);
+        });
+        it('does NOT allow flat_bench to substitute for adjustable_bench when exercise requires adjustable_bench', () => {
+            const exercise = createExercise(['adjustable_bench']);
+            expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['flat_bench'])).toBe(false);
+        });
+    });
+    describe('special case: dual_cable_machine / single_cable_machine substitution', () => {
+        it('allows dual_cable_machine to substitute for single_cable_machine when exercise requires single_cable_machine', () => {
+            const exercise = createExercise(['single_cable_machine']);
+            expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['dual_cable_machine'])).toBe(true);
+        });
+        it('does NOT allow single_cable_machine to substitute for dual_cable_machine when exercise requires dual_cable_machine', () => {
+            const exercise = createExercise(['dual_cable_machine']);
+            expect((0, hevyTrainer_1.isEquipmentCompatible)(exercise, ['single_cable_machine'])).toBe(false);
+        });
+    });
+});
+describe('granularEquipmentsToTrainerEquipments', () => {
+    it('returns empty array when no granular equipments are provided', () => {
+        expect((0, hevyTrainer_1.granularEquipmentsToTrainerEquipments)([])).toEqual([]);
+    });
+    it('returns only "barbell" when a barbell is present', () => {
+        expect((0, hevyTrainer_1.granularEquipmentsToTrainerEquipments)(['barbell'])).toEqual([
+            'barbell',
+        ]);
+    });
+    it('returns only "dumbbell" when a dumbbell is present', () => {
+        expect((0, hevyTrainer_1.granularEquipmentsToTrainerEquipments)(['dumbbell'])).toEqual([
+            'dumbbell',
+        ]);
+    });
+    it('returns "machine" when any machine-specific equipment is present', () => {
+        const machineSpecifics = [
+            'smith_machine',
+            'leg_press_machine',
+            'dual_cable_machine',
+            'single_cable_machine',
+            'lat_pulldown_cable',
+            'plate_machines',
+            'stack_machines',
+            'dip_bar',
+            'pullup_bar',
+        ];
+        machineSpecifics.forEach((eq) => {
+            expect((0, hevyTrainer_1.granularEquipmentsToTrainerEquipments)([eq])).toEqual(['machine']);
+        });
+    });
+    it('returns all three categories when all are present', () => {
+        const result = (0, hevyTrainer_1.granularEquipmentsToTrainerEquipments)([
+            'barbell',
+            'dumbbell',
+            'smith_machine',
+        ]);
+        expect(result).toEqual(['barbell', 'dumbbell', 'machine']);
+    });
+    it('returns empty array for granular equipment that does not map to any category', () => {
+        expect((0, hevyTrainer_1.granularEquipmentsToTrainerEquipments)(['kettlebell'])).toEqual([]);
+        expect((0, hevyTrainer_1.granularEquipmentsToTrainerEquipments)(['jump_rope'])).toEqual([]);
+    });
+    it('does not include "machine" when only non-machine-specific granular equipment is present', () => {
+        // `flat_bench` is granular equipment but is not considered machine-specific.
+        const result = (0, hevyTrainer_1.granularEquipmentsToTrainerEquipments)([
+            'barbell',
+            'flat_bench',
+        ]);
+        expect(result).toEqual(['barbell']);
+    });
+});
+describe('normalizeExerciseCategory', () => {
+    it('returns "compound" for a custom exercise regardless of category', () => {
+        expect((0, hevyTrainer_1.normalizeExerciseCategory)({ is_custom: true, category: 'isolation' })).toBe('compound');
+        expect((0, hevyTrainer_1.normalizeExerciseCategory)({ is_custom: true, category: 'compound' })).toBe('compound');
+        expect((0, hevyTrainer_1.normalizeExerciseCategory)({
+            is_custom: true,
+            category: 'assistance-compound',
+        })).toBe('compound');
+        expect((0, hevyTrainer_1.normalizeExerciseCategory)({ is_custom: true })).toBe('compound');
+    });
+    it('returns "isolation" only when category is explicitly "isolation"', () => {
+        expect((0, hevyTrainer_1.normalizeExerciseCategory)({ is_custom: false, category: 'isolation' })).toBe('isolation');
+    });
+    it('returns "compound" for "compound" or "assistance-compound" categories', () => {
+        expect((0, hevyTrainer_1.normalizeExerciseCategory)({ is_custom: false, category: 'compound' })).toBe('compound');
+        expect((0, hevyTrainer_1.normalizeExerciseCategory)({
+            is_custom: false,
+            category: 'assistance-compound',
+        })).toBe('compound');
+    });
+    it('defaults to "compound" when category is undefined', () => {
+        expect((0, hevyTrainer_1.normalizeExerciseCategory)({ is_custom: false })).toBe('compound');
+    });
+});
+const emptyExercisePriorities = () => __1.muscleGroups.reduce((acc, mg) => {
+    acc[mg] = [];
+    return acc;
+}, {});
+/**
+ * Builds a minimal but fully typed `TrainerAlgorithmSettings` instance.
+ *
+ * All numeric values are distinct so that lookup tests can assert that
+ * `goal`, `frequency`, `rest timer length`, and `category` are routed to the
+ * correct cell of each lookup table.
+ */
+const makeSettings = (overrides = {}) => {
+    const frequencyStrings = Object.values(hevyTrainer_1.frequencyMap);
+    const goals = ['strength', 'build_muscle', 'fat_loss'];
+    const goalOffset = {
+        strength: 0,
+        build_muscle: 100,
+        fat_loss: 200,
+    };
+    const freqOffset = {
+        one_day: 1,
+        two_days: 2,
+        three_days: 3,
+        four_days: 4,
+        five_days: 5,
+        six_days: 6,
+    };
+    const sets = frequencyStrings.reduce((acc, freqKey) => {
+        acc[freqKey] = goals.reduce((gAcc, goal) => {
+            gAcc[goal] = freqOffset[freqKey] + goalOffset[goal];
+            return gAcc;
+        }, {});
+        return acc;
+    }, {});
+    const rep_ranges = goals.reduce((acc, goal) => {
+        acc[goal] = {
+            compound: {
+                rep_range_start: 1 + goalOffset[goal],
+                rep_range_end: 5 + goalOffset[goal],
+            },
+            isolation: {
+                rep_range_start: 8 + goalOffset[goal],
+                rep_range_end: 12 + goalOffset[goal],
+            },
+        };
+        return acc;
+    }, {});
+    const rest_timers = goals.reduce((acc, goal) => {
+        acc[goal] = {
+            short: {
+                compound: 30 + goalOffset[goal],
+                isolation: 15 + goalOffset[goal],
+            },
+            medium: {
+                compound: 60 + goalOffset[goal],
+                isolation: 45 + goalOffset[goal],
+            },
+            long: {
+                compound: 120 + goalOffset[goal],
+                isolation: 90 + goalOffset[goal],
+            },
+        };
+        return acc;
+    }, {});
+    const templates = hevyTrainer_1.routineNames.reduce((acc, name) => {
+        acc[name] = { exercises: [] };
+        return acc;
+    }, {});
+    return Object.assign({ sets,
+        rep_ranges,
+        rest_timers,
+        templates, exercise_priorities: emptyExercisePriorities(), exercise_notes: {}, exercise_replacements: {} }, overrides);
+};
+describe('getTrainerSetCount / getTrainerRepRange / getTrainerRestTimerSeconds', () => {
+    const settings = makeSettings();
+    it('looks up set count by frequency and goal', () => {
+        // strength offset = 0, frequency 1 -> one_day -> 1
+        expect((0, hevyTrainer_1.getTrainerSetCount)(settings, 'strength', 1)).toBe(1);
+        // build_muscle offset = 100, frequency 3 -> three_days -> 103
+        expect((0, hevyTrainer_1.getTrainerSetCount)(settings, 'build_muscle', 3)).toBe(103);
+        // fat_loss offset = 200, frequency 6 -> six_days -> 206
+        expect((0, hevyTrainer_1.getTrainerSetCount)(settings, 'fat_loss', 6)).toBe(206);
+    });
+    it('looks up rep range by goal and exercise category', () => {
+        expect((0, hevyTrainer_1.getTrainerRepRange)(settings, 'strength', 'compound')).toEqual({
+            rep_range_start: 1,
+            rep_range_end: 5,
+        });
+        expect((0, hevyTrainer_1.getTrainerRepRange)(settings, 'strength', 'isolation')).toEqual({
+            rep_range_start: 8,
+            rep_range_end: 12,
+        });
+        expect((0, hevyTrainer_1.getTrainerRepRange)(settings, 'build_muscle', 'compound')).toEqual({
+            rep_range_start: 101,
+            rep_range_end: 105,
+        });
+    });
+    it('looks up rest timer by goal, length, and category', () => {
+        expect((0, hevyTrainer_1.getTrainerRestTimerSeconds)(settings, 'strength', 'short', 'compound')).toBe(30);
+        expect((0, hevyTrainer_1.getTrainerRestTimerSeconds)(settings, 'strength', 'medium', 'isolation')).toBe(45);
+        expect((0, hevyTrainer_1.getTrainerRestTimerSeconds)(settings, 'fat_loss', 'long', 'compound')).toBe(320);
+    });
+});
+describe('workout duration defaults', () => {
+    it('exposes a non-empty set of workout duration options', () => {
+        expect(hevyTrainer_1.workoutDurationOptions.length).toBeGreaterThan(0);
+        hevyTrainer_1.workoutDurationOptions.forEach((duration) => {
+            expect(typeof duration).toBe('number');
+            expect(duration).toBeGreaterThan(0);
+        });
+    });
+    it('defines a default duration for every weekly training frequency', () => {
+        __1.weeklyTrainingFrequencies.forEach((frequency) => {
+            expect(hevyTrainer_1.defaultDurationPerFrequency[frequency]).toBeDefined();
+        });
+    });
+    it('only uses values from workoutDurationOptions as defaults', () => {
+        const allowed = new Set(hevyTrainer_1.workoutDurationOptions);
+        Object.values(hevyTrainer_1.defaultDurationPerFrequency).forEach((duration) => {
+            expect(allowed.has(duration)).toBe(true);
+        });
+    });
+});
+const makeExercise = (overrides = {}) => (Object.assign({ id: 'ex', title: 'Exercise', priority: 0, muscle_group: 'chest', other_muscles: [], exercise_type: 'weight_reps', equipment_category: 'barbell', category: 'compound', level: ['beginner', 'intermediate', 'advanced'], goal: ['strength', 'build_muscle', 'fat_loss'], granular_equipments: undefined }, overrides));
+describe('getPrioritySortedExercises', () => {
+    it('returns an entry for every muscle group, even when none are provided', () => {
+        const result = (0, hevyTrainer_1.getPrioritySortedExercises)(emptyExercisePriorities(), []);
+        __1.muscleGroups.forEach((mg) => {
+            expect(Array.isArray(result[mg])).toBe(true);
+            expect(result[mg]).toEqual([]);
+        });
+    });
+    it('orders exercises by the provided priority list', () => {
+        const a = makeExercise({ id: 'a', muscle_group: 'chest', priority: 1 });
+        const b = makeExercise({ id: 'b', muscle_group: 'chest', priority: 2 });
+        const c = makeExercise({ id: 'c', muscle_group: 'chest', priority: 3 });
+        const priorities = emptyExercisePriorities();
+        priorities.chest = ['c', 'a', 'b'];
+        const result = (0, hevyTrainer_1.getPrioritySortedExercises)(priorities, [a, b, c]);
+        expect(result.chest.map((e) => e.id)).toEqual(['c', 'a', 'b']);
+    });
+    it('appends exercises missing from the priority list, sorted by descending priority', () => {
+        const prioritized = makeExercise({
+            id: 'p',
+            muscle_group: 'chest',
+            priority: 0,
+        });
+        const highPriorityLeftover = makeExercise({
+            id: 'hi',
+            muscle_group: 'chest',
+            priority: 10,
+        });
+        const lowPriorityLeftover = makeExercise({
+            id: 'lo',
+            muscle_group: 'chest',
+            priority: 1,
+        });
+        const priorities = emptyExercisePriorities();
+        priorities.chest = ['p'];
+        const result = (0, hevyTrainer_1.getPrioritySortedExercises)(priorities, [
+            prioritized,
+            lowPriorityLeftover,
+            highPriorityLeftover,
+        ]);
+        expect(result.chest.map((e) => e.id)).toEqual(['p', 'hi', 'lo']);
+    });
+    it('skips priority ids that are missing from the exercise store', () => {
+        const a = makeExercise({ id: 'a', muscle_group: 'chest', priority: 1 });
+        const priorities = emptyExercisePriorities();
+        priorities.chest = ['missing', 'a'];
+        // The implementation `console.log`s missing ids as a debug aid; silence
+        // the output here so it doesn't pollute the jest report. We intentionally
+        // don't assert on the log because it's a debug artifact, not part of the
+        // contract we want to freeze.
+        const logSpy = jest
+            .spyOn(console, 'log')
+            .mockImplementation(() => undefined);
+        const result = (0, hevyTrainer_1.getPrioritySortedExercises)(priorities, [a]);
+        expect(result.chest.map((e) => e.id)).toEqual(['a']);
+        logSpy.mockRestore();
+    });
+    it('only places an exercise under its own muscle_group bucket', () => {
+        const chestExercise = makeExercise({
+            id: 'chest-ex',
+            muscle_group: 'chest',
+            priority: 1,
+        });
+        const legExercise = makeExercise({
+            id: 'leg-ex',
+            muscle_group: 'quadriceps',
+            priority: 1,
+        });
+        const result = (0, hevyTrainer_1.getPrioritySortedExercises)(emptyExercisePriorities(), [
+            chestExercise,
+            legExercise,
+        ]);
+        expect(result.chest.map((e) => e.id)).toEqual(['chest-ex']);
+        expect(result.quadriceps.map((e) => e.id)).toEqual(['leg-ex']);
+    });
+});
+const baseCriteria = (overrides = {}) => (Object.assign({ exerciseCategory: 'compound', equipments: [], routineBarbellExerciseCount: 0, level: 'beginner', goal: 'strength', muscleGroup: 'chest', frequency: 3 }, overrides));
+/** Produces a `sortedExercises` record where only `chest` is populated. */
+const chestOnlySorted = (exercises) => {
+    const empty = __1.muscleGroups.reduce((acc, mg) => {
+        acc[mg] = [];
+        return acc;
+    }, {});
+    return Object.assign(Object.assign({}, empty), { chest: exercises });
+};
+describe('pickExerciseForPrescription', () => {
+    it('pass 1: returns the first matching exercise that is not used in the program', () => {
+        const used = makeExercise({ id: 'used' });
+        const fresh = makeExercise({ id: 'fresh' });
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([used, fresh]),
+            criteria: baseCriteria(),
+            context: {
+                programUsedExerciseIds: new Set(['used']),
+            },
+        });
+        expect(result === null || result === void 0 ? void 0 : result.id).toBe('fresh');
+    });
+    it('pass 2: falls back to exercises not used in the current routine when all are used in the program', () => {
+        const onlyExercise = makeExercise({ id: 'only' });
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([onlyExercise]),
+            criteria: baseCriteria(),
+            context: {
+                // Marked as used in the whole program already.
+                programUsedExerciseIds: new Set(['only']),
+                // But not used in this routine, so pass 2 should succeed.
+                routineUsedExerciseIds: new Set(),
+            },
+        });
+        expect(result === null || result === void 0 ? void 0 : result.id).toBe('only');
+    });
+    it('excludes exercises in `excludedExerciseIds` across all passes', () => {
+        const excluded = makeExercise({ id: 'excluded' });
+        const alternative = makeExercise({ id: 'alt' });
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([excluded, alternative]),
+            criteria: baseCriteria(),
+            context: {
+                excludedExerciseIds: new Set(['excluded']),
+            },
+        });
+        expect(result === null || result === void 0 ? void 0 : result.id).toBe('alt');
+    });
+    it('returns undefined when no exercise satisfies any pass', () => {
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([]),
+            criteria: baseCriteria(),
+            context: {},
+        });
+        expect(result).toBeUndefined();
+    });
+    it('respects the equipment filter (skips exercises that need unavailable equipment)', () => {
+        const needsBarbell = makeExercise({
+            id: 'barbell-ex',
+            granular_equipments: ['barbell'],
+        });
+        const bodyweight = makeExercise({
+            id: 'bw',
+            granular_equipments: [],
+        });
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([needsBarbell, bodyweight]),
+            criteria: baseCriteria({ equipments: [] }),
+            context: {},
+        });
+        expect(result === null || result === void 0 ? void 0 : result.id).toBe('bw');
+    });
+    it('respects the level and goal filters', () => {
+        const wrongLevel = makeExercise({ id: 'wrong', level: ['advanced'] });
+        const wrongGoal = makeExercise({ id: 'wrongGoal', goal: ['fat_loss'] });
+        const rightOne = makeExercise({ id: 'right' });
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([wrongLevel, wrongGoal, rightOne]),
+            criteria: baseCriteria({ level: 'beginner', goal: 'strength' }),
+            context: {},
+        });
+        expect(result === null || result === void 0 ? void 0 : result.id).toBe('right');
+    });
+    it('considers handpicked exercises before sortedExercises', () => {
+        const hand = makeExercise({ id: 'hand' });
+        const sorted = makeExercise({ id: 'sorted' });
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([sorted]),
+            handPickedExercises: [hand],
+            criteria: baseCriteria(),
+            context: {},
+        });
+        expect(result === null || result === void 0 ? void 0 : result.id).toBe('hand');
+    });
+    it('pass 5: relaxes the category filter when no isolation matches are available', () => {
+        // Ask for isolation, provide only compound candidates. Pass 5 should
+        // re-run the search with exerciseCategory: 'all' and return the compound.
+        const compoundOnly = makeExercise({
+            id: 'compound',
+            category: 'compound',
+        });
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([compoundOnly]),
+            criteria: baseCriteria({ exerciseCategory: 'isolation' }),
+            context: {},
+        });
+        expect(result === null || result === void 0 ? void 0 : result.id).toBe('compound');
+    });
+    it('pass 6: falls back to exercises whose other_muscles include the target muscle', () => {
+        const secondaryChest = makeExercise({
+            id: 'secondary',
+            muscle_group: 'shoulders',
+            other_muscles: ['chest'],
+        });
+        const sorted = __1.muscleGroups.reduce((acc, mg) => {
+            acc[mg] = [];
+            return acc;
+        }, {});
+        sorted.shoulders = [secondaryChest];
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: sorted,
+            criteria: baseCriteria({ muscleGroup: 'chest' }),
+            context: {},
+        });
+        expect(result === null || result === void 0 ? void 0 : result.id).toBe('secondary');
+    });
+    describe('barbell cap at frequency === 1', () => {
+        const barbellExercise = (id) => makeExercise({ id, equipment_category: 'barbell' });
+        it('allows barbell exercises regardless of count when frequency > 1', () => {
+            const ex = barbellExercise('bench');
+            const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+                sortedExercises: chestOnlySorted([ex]),
+                criteria: baseCriteria({
+                    frequency: 3,
+                    routineBarbellExerciseCount: 10,
+                    equipments: ['dumbbell'],
+                }),
+                context: {},
+            });
+            expect(result === null || result === void 0 ? void 0 : result.id).toBe('bench');
+        });
+        it('allows barbell exercises under the cap when frequency === 1', () => {
+            const ex = barbellExercise('bench');
+            const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+                sortedExercises: chestOnlySorted([ex]),
+                criteria: baseCriteria({
+                    frequency: 1,
+                    routineBarbellExerciseCount: 2,
+                    equipments: ['dumbbell'],
+                }),
+                context: {},
+            });
+            expect(result === null || result === void 0 ? void 0 : result.id).toBe('bench');
+        });
+        it('rejects barbell exercises at or over the cap when a substitute is available', () => {
+            const ex = barbellExercise('bench');
+            const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+                sortedExercises: chestOnlySorted([ex]),
+                criteria: baseCriteria({
+                    frequency: 1,
+                    routineBarbellExerciseCount: 3,
+                    // Dumbbell is listed as a barbell substitute, so the cap applies.
+                    equipments: ['dumbbell'],
+                }),
+                context: {},
+            });
+            expect(result).toBeUndefined();
+        });
+        it('still allows barbell exercises over the cap when the user has no substitutes', () => {
+            const ex = barbellExercise('bench');
+            const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+                sortedExercises: chestOnlySorted([ex]),
+                criteria: baseCriteria({
+                    frequency: 1,
+                    routineBarbellExerciseCount: 5,
+                    // No substitutes → avoid dead-ends by allowing the barbell.
+                    equipments: [],
+                }),
+                context: {},
+            });
+            expect(result === null || result === void 0 ? void 0 : result.id).toBe('bench');
+        });
+    });
+    it('returns a trace when `withTrace: true` and records the winning pass', () => {
+        var _a;
+        const fresh = makeExercise({ id: 'fresh' });
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([fresh]),
+            criteria: baseCriteria(),
+            context: {},
+            withTrace: true,
+        });
+        expect((_a = result.exercise) === null || _a === void 0 ? void 0 : _a.id).toBe('fresh');
+        expect(result.trace.selectedPass).toBe(1);
+        expect(result.trace.entries[0]).toMatchObject({
+            pass: 1,
+            selectedExerciseId: 'fresh',
+        });
+    });
+    it('returns a trace with no selected pass when nothing matches', () => {
+        const result = (0, hevyTrainer_1.pickExerciseForPrescription)({
+            sortedExercises: chestOnlySorted([]),
+            criteria: baseCriteria(),
+            context: {},
+            withTrace: true,
+        });
+        expect(result.exercise).toBeUndefined();
+        expect(result.trace.selectedPass).toBeUndefined();
+        // Six passes should have been attempted.
+        expect(result.trace.entries).toHaveLength(6);
+    });
+});
+describe('generateProgram', () => {
+    const buildSettingsForChestProgram = () => {
+        const settings = makeSettings();
+        // Put a single chest compound prescription into the 1-day full body routine.
+        settings.templates.full_body_1 = {
+            exercises: [
+                { muscle_group: 'chest', category: 'compound', warmup_set_count: 2 },
+            ],
+            notes: 'Hit the chest hard.',
+        };
+        return settings;
+    };
+    it('produces one routine per programSplit and populates exercise fields from the settings', () => {
+        const settings = buildSettingsForChestProgram();
+        const chestExercise = makeExercise({ id: 'bench', muscle_group: 'chest' });
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [chestExercise],
+            cardioPreference: undefined,
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.program.name).toBe(1);
+        expect(result.program.routines).toHaveLength(hevyTrainer_1.programSplits[1].length);
+        const [routine] = result.program.routines;
+        expect(routine.name).toBe('full_body_1');
+        expect(routine.notes).toBe('Hit the chest hard.');
+        expect(routine.exercises).toHaveLength(1);
+        const [exercise] = routine.exercises;
+        expect(exercise.kind).toBe('resistance');
+        if (exercise.kind !== 'resistance')
+            return;
+        expect(exercise.exerciseTemplate.id).toBe('bench');
+        expect(exercise.category).toBe('compound');
+        expect(exercise.muscleGroup).toBe('chest');
+        expect(exercise.warmupSetCount).toBe(2);
+        // strength + one_day -> 1 (see `makeSettings`)
+        expect(exercise.sets).toBe(1);
+        // strength + compound -> 1..5
+        expect(exercise.repRangeStart).toBe(1);
+        expect(exercise.repRangeEnd).toBe(5);
+        // strength + medium + compound -> 60
+        expect(exercise.restTimerSeconds).toBe(60);
+    });
+    it('returns a partial program and errors when no matching exercise can be found', () => {
+        const settings = buildSettingsForChestProgram();
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [],
+            cardioPreference: undefined,
+        });
+        expect(result.success).toBe(false);
+        if (result.success)
+            return;
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toMatchObject({
+            type: 'exercise_not_found',
+            muscleGroup: 'chest',
+        });
+        // The routine structure still exists in the partial program, just without
+        // any resolved exercises.
+        expect(result.partialProgram.routines).toHaveLength(1);
+        expect(result.partialProgram.routines[0].exercises).toEqual([]);
+    });
+    describe('min_workout_duration_limit filtering', () => {
+        /**
+         * Runs a 1-day program containing a single chest compound prescription
+         * with the provided `min_workout_duration_limit` against the provided
+         * `workoutDurationMinutes`, and returns whether the prescription was
+         * placed.
+         */
+        const runDurationProbe = ({ limit, workoutDurationMinutes, }) => {
+            const settings = makeSettings();
+            settings.templates.full_body_1 = {
+                exercises: [
+                    {
+                        muscle_group: 'chest',
+                        category: 'compound',
+                        min_workout_duration_limit: limit,
+                    },
+                ],
+            };
+            const result = (0, hevyTrainer_1.generateProgram)({
+                trainerAlgorithmSettings: settings,
+                frequency: 1,
+                goal: 'strength',
+                level: 'beginner',
+                equipments: [],
+                workoutDurationMinutes,
+                restTimerLength: 'medium',
+                exerciseStore: [makeExercise({ id: 'bench' })],
+                cardioPreference: undefined,
+            });
+            const routine = (result.success ? result.program : result.partialProgram)
+                .routines[0];
+            return routine.exercises.length === 1;
+        };
+        it('skips prescriptions whose limit is strictly greater than the selected duration', () => {
+            expect(runDurationProbe({ limit: 80, workoutDurationMinutes: 40 })).toBe(false);
+            expect(runDurationProbe({ limit: 80, workoutDurationMinutes: 60 })).toBe(false);
+            expect(runDurationProbe({ limit: 60, workoutDurationMinutes: 40 })).toBe(false);
+        });
+        it('includes prescriptions whose limit equals the selected duration (boundary is inclusive)', () => {
+            // The check is `limit > selected`, so equality must pass through.
+            expect(runDurationProbe({ limit: 40, workoutDurationMinutes: 40 })).toBe(true);
+            expect(runDurationProbe({ limit: 60, workoutDurationMinutes: 60 })).toBe(true);
+            expect(runDurationProbe({ limit: 80, workoutDurationMinutes: 80 })).toBe(true);
+        });
+        it('includes prescriptions whose limit is below the selected duration', () => {
+            expect(runDurationProbe({ limit: 40, workoutDurationMinutes: 60 })).toBe(true);
+            expect(runDurationProbe({ limit: 40, workoutDurationMinutes: 80 })).toBe(true);
+            expect(runDurationProbe({ limit: 60, workoutDurationMinutes: 80 })).toBe(true);
+        });
+        it('includes prescriptions with no min_workout_duration_limit regardless of the selected duration', () => {
+            hevyTrainer_1.workoutDurationOptions.forEach((duration) => {
+                expect(runDurationProbe({
+                    limit: undefined,
+                    workoutDurationMinutes: duration,
+                })).toBe(true);
+            });
+        });
+        it('filters prescriptions per-exercise: kept ones remain, skipped ones drop out of order', () => {
+            const settings = makeSettings();
+            // Three chest compound prescriptions at increasing duration gates, with
+            // distinct warmup counts so we can identify which survived.
+            settings.templates.full_body_1 = {
+                exercises: [
+                    {
+                        muscle_group: 'chest',
+                        category: 'compound',
+                        min_workout_duration_limit: 40,
+                        warmup_set_count: 1,
+                    },
+                    {
+                        muscle_group: 'chest',
+                        category: 'compound',
+                        min_workout_duration_limit: 60,
+                        warmup_set_count: 2,
+                    },
+                    {
+                        muscle_group: 'chest',
+                        category: 'compound',
+                        min_workout_duration_limit: 80,
+                        warmup_set_count: 3,
+                    },
+                ],
+            };
+            const result = (0, hevyTrainer_1.generateProgram)({
+                trainerAlgorithmSettings: settings,
+                frequency: 1,
+                goal: 'strength',
+                level: 'beginner',
+                equipments: [],
+                workoutDurationMinutes: 60,
+                restTimerLength: 'medium',
+                exerciseStore: [
+                    makeExercise({ id: 'bench-1', priority: 3 }),
+                    makeExercise({ id: 'bench-2', priority: 2 }),
+                    makeExercise({ id: 'bench-3', priority: 1 }),
+                ],
+                cardioPreference: undefined,
+            });
+            expect(result.success).toBe(true);
+            if (!result.success)
+                return;
+            // Only the 40- and 60-minute prescriptions survive; the 80-minute one
+            // is filtered out. Order is preserved.
+            const placed = result.program.routines[0].exercises;
+            expect(placed.every((e) => e.kind === 'resistance')).toBe(true);
+            expect(placed
+                .filter(hevyTrainer_1.isTrainerProgramResistanceExercise)
+                .map((e) => e.warmupSetCount)).toEqual([1, 2]);
+        });
+    });
+    it('skips focus_muscle prescriptions when no focusMuscle is provided', () => {
+        const settings = makeSettings();
+        settings.templates.full_body_1 = {
+            exercises: [{ muscle_group: 'focus_muscle', category: 'isolation' }],
+        };
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [
+                makeExercise({ id: 'biceps-curl', muscle_group: 'biceps' }),
+            ],
+            cardioPreference: undefined,
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.program.routines[0].exercises).toEqual([]);
+    });
+    it('routes focus_muscle prescriptions to the requested SimplifiedMuscleGroup', () => {
+        const settings = makeSettings();
+        settings.templates.full_body_1 = {
+            exercises: [{ muscle_group: 'focus_muscle', category: 'isolation' }],
+        };
+        const bicepsCurl = makeExercise({
+            id: 'biceps-curl',
+            muscle_group: 'biceps',
+            category: 'isolation',
+        });
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [bicepsCurl],
+            focusMuscle: 'arms',
+            cardioPreference: undefined,
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        const [exercise] = result.program.routines[0].exercises;
+        expect(exercise.kind).toBe('resistance');
+        if (exercise.kind !== 'resistance')
+            return;
+        expect(exercise.exerciseTemplate.id).toBe('biceps-curl');
+        expect(exercise.muscleGroup).toBe('focus_muscle');
+    });
+    it('excludes exercises listed in `excludedExerciseIds`', () => {
+        const settings = buildSettingsForChestProgram();
+        const excluded = makeExercise({ id: 'excluded', priority: 10 });
+        const alt = makeExercise({ id: 'alt', priority: 1 });
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [excluded, alt],
+            excludedExerciseIds: new Set(['excluded']),
+            cardioPreference: undefined,
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.program.routines[0].exercises[0].exerciseTemplate.id).toBe('alt');
+    });
+    it('attaches exercise selection traces when debugExerciseSelectionTrace is true', () => {
+        const settings = buildSettingsForChestProgram();
+        const chest = makeExercise({ id: 'bench' });
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [chest],
+            debugExerciseSelectionTrace: true,
+            cardioPreference: undefined,
+        });
+        expect(result.success).toBe(true);
+        expect(result.exerciseSelectionTraces).toHaveLength(1);
+        const [trace] = result.exerciseSelectionTraces;
+        expect(trace.traceKind).toBe('template');
+        expect(trace.routine).toBe('full_body_1');
+        expect(trace.selectedExerciseId).toBe('bench');
+        expect(trace.trace.selectedPass).toBe(1);
+    });
+    it('reports the correct prescriptionIndex even when the same prescription object is reused in the template', () => {
+        const settings = makeSettings();
+        // Deliberately reuse the same reference so `indexOf`-based indexing
+        // would collapse both traces to index 0.
+        const sharedPrescription = {
+            muscle_group: 'chest',
+            category: 'compound',
+        };
+        settings.templates.full_body_1 = {
+            exercises: [sharedPrescription, sharedPrescription],
+        };
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [
+                makeExercise({ id: 'bench-1' }),
+                makeExercise({ id: 'bench-2' }),
+            ],
+            debugExerciseSelectionTrace: true,
+            cardioPreference: undefined,
+        });
+        expect(result.success).toBe(true);
+        expect(result.exerciseSelectionTraces.map((t) => t.prescriptionIndex)).toEqual([0, 1]);
+    });
+    it('records a single cardio trace entry (no multi-pass picker)', () => {
+        const settings = makeSettings();
+        settings.templates.full_body_1 = {
+            exercises: [{ muscle_group: 'chest', category: 'compound' }],
+        };
+        settings.exercise_priorities.chest = ['bench'];
+        settings.exercise_priorities.cardio = ['run'];
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [
+                makeExercise({ id: 'bench', muscle_group: 'chest' }),
+                makeExercise({
+                    id: 'run',
+                    muscle_group: 'cardio',
+                    category: 'compound',
+                    equipment_category: 'other',
+                }),
+            ],
+            debugExerciseSelectionTrace: true,
+            cardioPreference: 'beginning',
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        const cardioTrace = result.exerciseSelectionTraces.find((t) => t.traceKind === 'cardio');
+        expect(cardioTrace).toBeDefined();
+        expect(cardioTrace.prescriptionIndex).toBe(-1);
+        expect(cardioTrace.trace.entries).toHaveLength(1);
+        expect(cardioTrace.trace.selectedPass).toBe(1);
+        expect(cardioTrace.trace.entries[0].selectedExerciseId).toBe('run');
+        expect(cardioTrace.equipments).toEqual([]);
+        expect(cardioTrace.level).toBe('beginner');
+    });
+    it('uses the same prioritized cardio exercise on every routine (not blocked by program reuse)', () => {
+        const settings = makeSettings();
+        settings.templates.full_body_2_a = {
+            exercises: [{ muscle_group: 'chest', category: 'compound' }],
+        };
+        settings.templates.full_body_2_b = {
+            exercises: [{ muscle_group: 'chest', category: 'compound' }],
+        };
+        settings.exercise_priorities.chest = ['bench-a', 'bench-b'];
+        settings.exercise_priorities.cardio = ['run'];
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 2,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [
+                makeExercise({ id: 'bench-a', muscle_group: 'chest' }),
+                makeExercise({ id: 'bench-b', muscle_group: 'chest' }),
+                makeExercise({
+                    id: 'run',
+                    muscle_group: 'cardio',
+                    category: 'compound',
+                    equipment_category: 'other',
+                }),
+            ],
+            cardioPreference: 'beginning',
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.program.routines[0].exercises[0]).toMatchObject({
+            kind: 'cardio',
+            exerciseTemplate: { id: 'run' },
+        });
+        expect(result.program.routines[1].exercises[0]).toMatchObject({
+            kind: 'cardio',
+            exerciseTemplate: { id: 'run' },
+        });
+    });
+    it('skips cardio exercises that need equipment the user does not have', () => {
+        const settings = makeSettings();
+        settings.templates.full_body_1 = {
+            exercises: [{ muscle_group: 'chest', category: 'compound' }],
+        };
+        settings.exercise_priorities.chest = ['bench'];
+        settings.exercise_priorities.cardio = ['treadmill-run', 'body-run'];
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [
+                makeExercise({ id: 'bench', muscle_group: 'chest' }),
+                makeExercise({
+                    id: 'treadmill-run',
+                    muscle_group: 'cardio',
+                    category: 'compound',
+                    equipment_category: 'other',
+                    granular_equipments: ['treadmill'],
+                }),
+                makeExercise({
+                    id: 'body-run',
+                    muscle_group: 'cardio',
+                    category: 'compound',
+                    equipment_category: 'other',
+                }),
+            ],
+            cardioPreference: 'beginning',
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.program.routines[0].exercises[0]).toMatchObject({
+            kind: 'cardio',
+            exerciseTemplate: { id: 'body-run' },
+        });
+    });
+    it('skips globally excluded cardio and uses the next priority exercise', () => {
+        const settings = makeSettings();
+        settings.templates.full_body_1 = {
+            exercises: [{ muscle_group: 'chest', category: 'compound' }],
+        };
+        settings.exercise_priorities.chest = ['bench'];
+        settings.exercise_priorities.cardio = ['run-a', 'run-b'];
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 1,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [
+                makeExercise({ id: 'bench', muscle_group: 'chest' }),
+                makeExercise({
+                    id: 'run-a',
+                    muscle_group: 'cardio',
+                    category: 'compound',
+                    equipment_category: 'other',
+                }),
+                makeExercise({
+                    id: 'run-b',
+                    muscle_group: 'cardio',
+                    category: 'compound',
+                    equipment_category: 'other',
+                }),
+            ],
+            excludedExerciseIds: new Set(['run-a']),
+            cardioPreference: 'beginning',
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        expect(result.program.routines[0].exercises[0]).toMatchObject({
+            kind: 'cardio',
+            exerciseTemplate: { id: 'run-b' },
+        });
+    });
+    it('keeps global trace order aligned with routine generation (no cross-routine unshift)', () => {
+        const settings = makeSettings();
+        settings.templates.full_body_2_a = {
+            exercises: [{ muscle_group: 'chest', category: 'compound' }],
+        };
+        settings.templates.full_body_2_b = {
+            exercises: [{ muscle_group: 'chest', category: 'compound' }],
+        };
+        settings.exercise_priorities.chest = ['bench-a', 'bench-b'];
+        settings.exercise_priorities.cardio = ['run'];
+        const result = (0, hevyTrainer_1.generateProgram)({
+            trainerAlgorithmSettings: settings,
+            frequency: 2,
+            goal: 'strength',
+            level: 'beginner',
+            equipments: [],
+            workoutDurationMinutes: 60,
+            restTimerLength: 'medium',
+            exerciseStore: [
+                makeExercise({ id: 'bench-a', muscle_group: 'chest' }),
+                makeExercise({ id: 'bench-b', muscle_group: 'chest' }),
+                makeExercise({
+                    id: 'run',
+                    muscle_group: 'cardio',
+                    category: 'compound',
+                    equipment_category: 'other',
+                }),
+            ],
+            debugExerciseSelectionTrace: true,
+            cardioPreference: 'beginning',
+        });
+        expect(result.success).toBe(true);
+        if (!result.success)
+            return;
+        const idxA = result.exerciseSelectionTraces.findIndex((t) => t.routine === 'full_body_2_a');
+        const idxB = result.exerciseSelectionTraces.findIndex((t) => t.routine === 'full_body_2_b');
+        expect(idxA).toBeGreaterThanOrEqual(0);
+        expect(idxB).toBeGreaterThan(idxA);
+    });
+    describe('barbell cap at frequency === 1 (end-to-end)', () => {
+        it('drops the 4th+ barbell prescription when the user has a substitute', () => {
+            const settings = makeSettings();
+            // 4 identical barbell compound prescriptions in the 1-day routine.
+            settings.templates.full_body_1 = {
+                exercises: Array.from({ length: 4 }, () => ({
+                    muscle_group: 'chest',
+                    category: 'compound',
+                })),
+            };
+            // Provide 4 distinct barbell chest exercises so "already used in program"
+            // cannot interfere with the cap we're trying to observe.
+            const exercises = ['a', 'b', 'c', 'd'].map((id) => makeExercise({
+                id,
+                equipment_category: 'barbell',
+                granular_equipments: ['barbell'],
+            }));
+            const result = (0, hevyTrainer_1.generateProgram)({
+                trainerAlgorithmSettings: settings,
+                frequency: 1,
+                goal: 'strength',
+                level: 'beginner',
+                // Include a substitute (dumbbell) so the cap is enforced.
+                equipments: ['barbell', 'dumbbell'],
+                workoutDurationMinutes: 60,
+                restTimerLength: 'medium',
+                exerciseStore: exercises,
+                cardioPreference: undefined,
+            });
+            expect(result.success).toBe(false);
+            if (result.success)
+                return;
+            expect(result.partialProgram.routines[0].exercises).toHaveLength(3);
+            expect(result.errors).toHaveLength(1);
+        });
+        it('allows 4+ barbell prescriptions at frequency 1 when no substitute is present', () => {
+            const settings = makeSettings();
+            settings.templates.full_body_1 = {
+                exercises: Array.from({ length: 4 }, () => ({
+                    muscle_group: 'chest',
+                    category: 'compound',
+                })),
+            };
+            const exercises = ['a', 'b', 'c', 'd'].map((id) => makeExercise({
+                id,
+                equipment_category: 'barbell',
+                granular_equipments: ['barbell'],
+            }));
+            const result = (0, hevyTrainer_1.generateProgram)({
+                trainerAlgorithmSettings: settings,
+                frequency: 1,
+                goal: 'strength',
+                level: 'beginner',
+                // No substitutes → cap is not enforced.
+                equipments: ['barbell'],
+                workoutDurationMinutes: 60,
+                restTimerLength: 'medium',
+                exerciseStore: exercises,
+                cardioPreference: undefined,
+            });
+            expect(result.success).toBe(true);
+            if (!result.success)
+                return;
+            expect(result.program.routines[0].exercises).toHaveLength(4);
+        });
+    });
+    describe('focus_muscle cycling', () => {
+        it('cycles through simplifiedMuscleGroupToMuscleGroups as focus_muscle prescriptions are placed', () => {
+            // Use a 2-day split so we can place 4 focus_muscle exercises across two
+            // routines and confirm the counter survives between routines.
+            const settings = makeSettings();
+            const focusPrescription = {
+                muscle_group: 'focus_muscle',
+                category: 'isolation',
+            };
+            // full_body routines allow any focus muscle. Place 2 per routine so the
+            // combined count across the program is 4.
+            settings.templates.full_body_2_a = {
+                exercises: [focusPrescription, focusPrescription],
+            };
+            settings.templates.full_body_2_b = {
+                exercises: [focusPrescription, focusPrescription],
+            };
+            // `arms` cycles through ['biceps', 'triceps', 'forearms'] and then wraps.
+            const exercises = [
+                makeExercise({
+                    id: 'biceps-ex',
+                    muscle_group: 'biceps',
+                    category: 'isolation',
+                }),
+                makeExercise({
+                    id: 'triceps-ex',
+                    muscle_group: 'triceps',
+                    category: 'isolation',
+                }),
+                makeExercise({
+                    id: 'forearms-ex',
+                    muscle_group: 'forearms',
+                    category: 'isolation',
+                }),
+            ];
+            const result = (0, hevyTrainer_1.generateProgram)({
+                trainerAlgorithmSettings: settings,
+                frequency: 2,
+                goal: 'strength',
+                level: 'beginner',
+                equipments: [],
+                workoutDurationMinutes: 60,
+                restTimerLength: 'medium',
+                exerciseStore: exercises,
+                focusMuscle: 'arms',
+                debugExerciseSelectionTrace: true,
+                cardioPreference: undefined,
+            });
+            const traces = result.exerciseSelectionTraces;
+            // Counter increments once per placed focus_muscle prescription, so the
+            // 4th prescription wraps back to the first entry of
+            // simplifiedMuscleGroupToMuscleGroups.arms ('biceps').
+            expect(traces
+                .filter((t) => t.traceKind === 'template')
+                .map((t) => t.resolvedMuscleGroup)).toEqual(['biceps', 'triceps', 'forearms', 'biceps']);
+            // The first three passes should land on the priority-matching exercise
+            // (each muscle's only exercise is picked by pass 1).
+            expect(traces
+                .filter((t) => t.traceKind === 'template')
+                .slice(0, 3)
+                .map((t) => t.selectedExerciseId)).toEqual(['biceps-ex', 'triceps-ex', 'forearms-ex']);
+        });
+        it('does not advance the focus_muscle counter when a prescription is skipped for template mismatch', () => {
+            // 5-day split: push_1, pull_1, legs_1, upper_2, lower_2.
+            // `legs` focus muscle is only allowed for lower/legs templates, so the
+            // push/pull/upper templates skip the focus_muscle prescription
+            // entirely. The counter must only tick for templates where the
+            // prescription actually runs.
+            const settings = makeSettings();
+            const focusPrescription = {
+                muscle_group: 'focus_muscle',
+                category: 'isolation',
+            };
+            settings.templates.push_1 = { exercises: [focusPrescription] };
+            settings.templates.pull_1 = { exercises: [focusPrescription] };
+            settings.templates.legs_1 = { exercises: [focusPrescription] };
+            settings.templates.upper_2 = { exercises: [focusPrescription] };
+            settings.templates.lower_2 = { exercises: [focusPrescription] };
+            // `legs` cycles through ['quadriceps', 'hamstrings', 'calves', 'glutes',
+            // 'abductors', 'adductors']. The first two allowed routines (legs_1 and
+            // lower_2) should land on quadriceps and hamstrings respectively.
+            const exercises = [
+                makeExercise({
+                    id: 'quad-ex',
+                    muscle_group: 'quadriceps',
+                    category: 'isolation',
+                }),
+                makeExercise({
+                    id: 'ham-ex',
+                    muscle_group: 'hamstrings',
+                    category: 'isolation',
+                }),
+            ];
+            const result = (0, hevyTrainer_1.generateProgram)({
+                trainerAlgorithmSettings: settings,
+                frequency: 5,
+                goal: 'strength',
+                level: 'beginner',
+                equipments: [],
+                workoutDurationMinutes: 60,
+                restTimerLength: 'medium',
+                exerciseStore: exercises,
+                focusMuscle: 'legs',
+                debugExerciseSelectionTrace: true,
+                cardioPreference: undefined,
+            });
+            expect(result.success).toBe(true);
+            if (!result.success)
+                return;
+            // Only legs_1 and lower_2 run the focus_muscle prescription. Both
+            // succeed and should have selected quadriceps then hamstrings in order.
+            expect(result.exerciseSelectionTraces).toHaveLength(2);
+            expect(result.exerciseSelectionTraces.map((t) => t.routine)).toEqual([
+                'legs_1',
+                'lower_2',
+            ]);
+            expect(result.exerciseSelectionTraces
+                .filter((t) => t.traceKind === 'template')
+                .map((t) => t.resolvedMuscleGroup)).toEqual(['quadriceps', 'hamstrings']);
+        });
+    });
+    describe('isFocusMuscleExtraExerciseAllowed template compatibility', () => {
+        /**
+         * Runs a single-routine program that places one focus_muscle
+         * prescription into the requested template and returns whether the
+         * prescription produced an exercise or was skipped.
+         */
+        const runFocusMuscleProbe = (routineName, focusMuscle, frequency, candidateExercise) => {
+            var _a;
+            const settings = makeSettings();
+            settings.templates[routineName] = {
+                exercises: [{ muscle_group: 'focus_muscle', category: 'isolation' }],
+            };
+            const result = (0, hevyTrainer_1.generateProgram)({
+                trainerAlgorithmSettings: settings,
+                frequency,
+                goal: 'strength',
+                level: 'beginner',
+                equipments: [],
+                workoutDurationMinutes: 60,
+                restTimerLength: 'medium',
+                exerciseStore: [candidateExercise],
+                focusMuscle,
+                debugExerciseSelectionTrace: true,
+                cardioPreference: undefined,
+            });
+            // Find the routine we targeted (it may not be first in the split).
+            const routine = (result.success ? result.program : result.partialProgram).routines.find((r) => r.name === routineName);
+            return {
+                placed: ((_a = routine === null || routine === void 0 ? void 0 : routine.exercises.length) !== null && _a !== void 0 ? _a : 0) > 0,
+            };
+        };
+        it('allows every focus muscle on full_body routines', () => {
+            const muscles = ['chest', 'shoulders', 'arms', 'legs', 'back'];
+            muscles.forEach((focusMuscle) => {
+                // Use a muscle that's in the simplified group: biceps for arms, chest
+                // for chest, quadriceps for legs, etc. We just pick the first entry
+                // of each simplified group.
+                const firstUnderlyingMuscle = {
+                    chest: 'chest',
+                    shoulders: 'shoulders',
+                    arms: 'biceps',
+                    legs: 'quadriceps',
+                    back: 'lats',
+                };
+                const ex = makeExercise({
+                    id: `${focusMuscle}-ex`,
+                    muscle_group: firstUnderlyingMuscle[focusMuscle],
+                    category: 'isolation',
+                });
+                const { placed } = runFocusMuscleProbe('full_body_1', focusMuscle, 1, ex);
+                expect(placed).toBe(true);
+            });
+        });
+        it('allows "core" focus muscle on any template', () => {
+            const ex = makeExercise({
+                id: 'core-ex',
+                muscle_group: 'abdominals',
+                category: 'isolation',
+            });
+            // Probe a non-full-body, non-legs template. Core should still be placed.
+            const { placed } = runFocusMuscleProbe('push_1', 'core', 5, ex);
+            expect(placed).toBe(true);
+        });
+        it('skips "chest" and "shoulders" focus muscle on pull/legs/lower templates', () => {
+            const chestEx = makeExercise({
+                id: 'chest-ex',
+                muscle_group: 'chest',
+                category: 'isolation',
+            });
+            const shoulderEx = makeExercise({
+                id: 'shoulder-ex',
+                muscle_group: 'shoulders',
+                category: 'isolation',
+            });
+            expect(runFocusMuscleProbe('pull_1', 'chest', 5, chestEx).placed).toBe(false);
+            expect(runFocusMuscleProbe('legs_1', 'shoulders', 5, shoulderEx).placed).toBe(false);
+        });
+        it('allows "arms" focus muscle on upper, push, and pull templates but not on legs/lower', () => {
+            const bicepsEx = makeExercise({
+                id: 'biceps-ex',
+                muscle_group: 'biceps',
+                category: 'isolation',
+            });
+            expect(runFocusMuscleProbe('upper_1_a', 'arms', 4, bicepsEx).placed).toBe(true);
+            expect(runFocusMuscleProbe('push_1', 'arms', 5, bicepsEx).placed).toBe(true);
+            expect(runFocusMuscleProbe('pull_1', 'arms', 5, bicepsEx).placed).toBe(true);
+            expect(runFocusMuscleProbe('legs_1', 'arms', 5, bicepsEx).placed).toBe(false);
+            expect(runFocusMuscleProbe('lower_1_a', 'arms', 4, bicepsEx).placed).toBe(false);
+        });
+        it('allows "legs" focus muscle only on legs/lower templates', () => {
+            const quadEx = makeExercise({
+                id: 'quad-ex',
+                muscle_group: 'quadriceps',
+                category: 'isolation',
+            });
+            expect(runFocusMuscleProbe('legs_1', 'legs', 5, quadEx).placed).toBe(true);
+            expect(runFocusMuscleProbe('lower_1_a', 'legs', 4, quadEx).placed).toBe(true);
+            expect(runFocusMuscleProbe('push_1', 'legs', 5, quadEx).placed).toBe(false);
+            expect(runFocusMuscleProbe('upper_1_a', 'legs', 4, quadEx).placed).toBe(false);
+        });
+        it('allows "back" focus muscle only on upper/pull templates', () => {
+            const latsEx = makeExercise({
+                id: 'lats-ex',
+                muscle_group: 'lats',
+                category: 'isolation',
+            });
+            expect(runFocusMuscleProbe('upper_1_a', 'back', 4, latsEx).placed).toBe(true);
+            expect(runFocusMuscleProbe('pull_1', 'back', 5, latsEx).placed).toBe(true);
+            expect(runFocusMuscleProbe('push_1', 'back', 5, latsEx).placed).toBe(false);
+            expect(runFocusMuscleProbe('legs_1', 'back', 5, latsEx).placed).toBe(false);
+        });
+    });
+});
+const __2 = require("..");
+describe('hevyTrainer gym types and defaults', () => {
+    it('defines granular equipment defaults for every trainer gym type', () => {
+        __2.trainerGymTypes.forEach((gymType) => {
+            const defaults = __2.granularEquipmentDefaults[gymType];
+            expect(Array.isArray(defaults)).toBe(true);
+            expect(defaults.length).toBeGreaterThan(0);
+        });
+    });
+    it('granular equipment defaults only contain granular equipment values', () => {
+        Object.keys(__2.granularEquipmentDefaults).forEach((gymType) => {
+            const defaults = __2.granularEquipmentDefaults[gymType];
+            defaults.forEach((equipment) => {
+                // Type assertion ensures the mapping stays within the GranularEquipment union.
+                const typed = equipment;
+                expect(typeof typed).toBe('string');
+            });
+        });
+    });
+});