@dgpholdings/greatoak-shared 1.1.60 → 1.1.62

package/dist/utils/scoring.utils.js

@@ -1,508 +1,276 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeScoreFromRecord = void 0;
-/**
- * GIST: Advanced Exercise Scoring Algorithm
+/*
+ * Exercise Scoring System Documentation
  *
- * This function calculates a comprehensive score for a single exercise set using metabolic science,
- * user personalization, and exercise characteristics. The algorithm:
+ * OVERVIEW:
+ * Evaluates workout performance (0-100) with overall score and muscle fatigue ratings.
+ * Designed to motivate users by quantifying effort and tracking muscle engagement.
  *
- * 🔬 SCIENTIFIC FOUNDATION:
- * - Uses MET (Metabolic Equivalent) values for accurate calorie calculations
- * - Incorporates BMR, exercise calories, and EPOC (post-exercise oxygen consumption)
- * - Validates performance using timing guardrails and realistic human limits
+ * SCORE COMPOSITION:
+ * - Volume (35%): Total work (weight×reps, duration×difficulty, distance×speed)
+ * - Intensity (35%): Effort level (relative weight, rep ranges, speed, RPE when provided)
+ * - Quality (30%): Set consistency and performance maintenance
  *
- * 👤 PERSONALIZATION:
- * - Adjusts for user age, gender, weight, fitness level, and body composition
- * - Provides goal-specific bonuses (strength, hypertrophy, endurance, fat burn, etc.)
- * - Accounts for fitness level efficiency (trained athletes are more metabolically efficient)
+ * SCORE INTERPRETATION:
+ * 90-100: Exceptional - peak performance with high volume/intensity/consistency
+ * 75-89:  Excellent - strong effort with good form and progression
+ * 60-74:  Good - solid baseline performance, room for improvement
+ * 45-59:  Moderate - acceptable but consider increasing intensity/volume
+ * 0-44:   Light - warm-up sets or recovery day
  *
- * 🏋️ EXERCISE INTELLIGENCE:
- * - Handles 5 record types: weight-reps, reps-only, duration, cardio-machine, cardio-free
- * - Scales difficulty based on exercise complexity, compound movements, and muscle engagement
- * - Rewards progressive overload, proper timing, and interval training
+ * MUSCLE FATIGUE (0-100):
+ * Primary muscles get 70% fatigue impact, secondary muscles get 30%
+ * 80-100: Fully fatigued - heavily worked, needs recovery
+ * 60-79:  High fatigue - significant work, approaching limit
+ * 40-59:  Moderate fatigue - good activation, can handle more
+ * 20-39:  Light fatigue - warmed up, plenty capacity remaining
+ * 0-19:   Minimal fatigue - barely engaged
  *
- * 📊 SCORING SYSTEM:
- * - Base score derived from calorie burn (more accurate than arbitrary load calculations)
- * - Bonus system for goal alignment, high intensity, precision timing, stability demands
- * - Penalty system for excessive rest, timing deviations (strict mode only)
- * - Final score normalized to 0-200 range for intuitive user feedback
+ * QUALITY SCORE EXPLAINED:
+ * Measures how well performance is maintained across sets (starts at 85 points)
+ * - Performance drop <10% between sets: +5 points
+ * - Performance drop 10-20%: +2 points
+ * - Performance drop >30%: -10 points
+ * - Consistent RIR/RPE between sets: +3 points
+ * - Completing 3+ sets: +5 points, 4+ sets: +8 total points
  *
- * The result motivates users through science-based, personalized feedback that encourages
- * proper form, progressive overload, and goal-aligned training.
- */
-/**
- * Calculate BMR using Mifflin-St Jeor Equation with body composition adjustment
+ * KEY FACTORS:
+ * - User fitness level (higher level = higher expectations)
+ * - Exercise difficulty (harder exercises boost score)
+ * - RPE (1-10): When provided, adjusts intensity (higher RPE = higher intensity)
+ * - RIR (0+): When provided, checks consistency between sets
+ * - Fatigue multiplier (later sets get 8% bonus per set for accumulated fatigue)
  */
-const calculateBMR = (userProfile) => {
-    var _a, _b, _c;
-    const weight = (_a = userProfile.weightKg) !== null && _a !== void 0 ? _a : 70;
-    const height = (_b = userProfile.heightCm) !== null && _b !== void 0 ? _b : 170;
-    const age = (_c = userProfile.age) !== null && _c !== void 0 ? _c : 30;
-    let bmr;
-    if (userProfile.gender === "female") {
-        bmr = 10 * weight + 6.25 * height - 5 * age - 161;
-    }
-    else {
-        bmr = 10 * weight + 6.25 * height - 5 * age + 5;
-    }
-    // Adjust for body composition if available
-    if (userProfile.bodyFatPercentage) {
-        const leanBodyMass = weight * (1 - userProfile.bodyFatPercentage / 100);
-        const lbmAdjustment = leanBodyMass * 0.56;
-        bmr += lbmAdjustment;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateExerciseScore = void 0;
+const time_util_1 = require("./time.util");
+const calculateExerciseScore = (param) => {
+    const { exercise, record, user } = param;
+    // Filter only completed sets
+    const completedSets = record.filter((r) => r.isDone);
+    if (completedSets.length === 0) {
+        return { score: 0, muscleScores: {} };
     }
-    return Math.max(1200, bmr);
+    // Calculate base performance metrics
+    const totalVolume = calculateTotalVolume(completedSets, user);
+    const avgIntensity = calculateAverageIntensity(completedSets, exercise, user);
+    const setQuality = calculateSetQuality(completedSets);
+    // Calculate muscle fatigue scores
+    const muscleScores = calculateMuscleScores(exercise, completedSets, totalVolume);
+    // Final score composition
+    const volumeComponent = normalizeVolume(totalVolume, exercise, user) * 0.35;
+    const intensityComponent = avgIntensity * 0.35;
+    const qualityComponent = setQuality * 0.3;
+    const score = Math.round(volumeComponent + intensityComponent + qualityComponent);
+    return {
+        score: Math.min(100, Math.max(0, score)),
+        muscleScores,
+    };
 };
-/**
- * Calculate precise MET value using exercise metabolic data
- */
-const calculateMETValue = (record, exercise, effortFactor, userProfile) => {
-    var _a, _b, _c;
-    const { metabolicData } = exercise;
-    const userWeight = (_a = userProfile.weightKg) !== null && _a !== void 0 ? _a : 70;
-    const fitnessLevel = (_b = userProfile.fitnessLevel) !== null && _b !== void 0 ? _b : 3;
-    // Fitness level efficiency: trained individuals are more efficient
-    const efficiencyFactor = 1 - (fitnessLevel - 1) * 0.04; // 4% more efficient per level
-    let calculatedMET = metabolicData.baseMET;
-    // Apply compound movement multiplier
-    calculatedMET *= metabolicData.compoundMultiplier;
-    // Apply muscle group factor
-    calculatedMET *= metabolicData.muscleGroupFactor / 2; // Normalize to reasonable range
-    // Record type specific adjustments
-    switch (record.type) {
-        case "weight-reps": {
-            if (metabolicData.weightFactors) {
-                const weightRatio = record.kg / userWeight;
-                let weightMultiplier = metabolicData.weightFactors.moderateWeight;
-                if (weightRatio < 0.5) {
-                    weightMultiplier = metabolicData.weightFactors.lightWeight;
-                }
-                else if (weightRatio > 1.0) {
-                    weightMultiplier = metabolicData.weightFactors.heavyWeight;
-                }
-                calculatedMET *= weightMultiplier;
-            }
-            // Apply rep-based intensity scaling
-            const repAdjustment = getRepIntensityAdjustment(record.reps, metabolicData.intensityScaling);
-            calculatedMET *= repAdjustment;
-            break;
+exports.calculateExerciseScore = calculateExerciseScore;
+const calculateTotalVolume = (record, user) => {
+    return record.reduce((total, set) => {
+        const weight = parseFloat(set.type === "weight-reps"
+            ? set.kg
+            : set.type === "duration" || set.type === "reps-only"
+                ? set.auxWeightKg
+                : "0") || 0;
+        const reps = parseFloat(set.type === "weight-reps" || set.type === "reps-only" ? set.reps : "0") || 0;
+        const duration = set.type === "duration" ||
+            set.type === "cardio-machine" ||
+            set.type === "cardio-free"
+            ? (0, time_util_1.mmssToSecs)(set.durationMmSs)
+            : 0;
+        if (set.type === "weight-reps") {
+            return total + reps * weight;
         }
-        case "reps-only": {
-            // High rep bodyweight exercises get metabolic bonus
-            const repAdjustment = getRepIntensityAdjustment(record.reps, metabolicData.intensityScaling);
-            calculatedMET *= repAdjustment;
-            // Bodyweight exercises scale with user weight efficiency
-            if (userWeight > 80) {
-                calculatedMET *= 1.1; // Heavier people work harder
-            }
-            else if (userWeight < 60) {
-                calculatedMET *= 0.95; // Lighter people have slight advantage
-            }
-            break;
+        else if (set.type === "reps-only") {
+            const bodyweight = user.weightKg || 70;
+            const effectiveWeight = weight > 0 ? weight : bodyweight * 0.3;
+            return total + reps * effectiveWeight;
         }
-        case "duration": {
-            const durationSecs = record.durationSecs;
-            if (metabolicData.durationFactors) {
-                let durationMultiplier = metabolicData.durationFactors.mediumDuration;
-                if (durationSecs < 30) {
-                    durationMultiplier = metabolicData.durationFactors.shortDuration;
-                }
-                else if (durationSecs > 120) {
-                    durationMultiplier = metabolicData.durationFactors.longDuration;
-                }
-                calculatedMET *= durationMultiplier;
-            }
-            break;
+        else if (set.type === "duration") {
+            const weightFactor = weight > 0 ? 1 + weight / 100 : 1;
+            return total + duration * 10 * weightFactor;
         }
-        case "cardio-machine": {
-            const speed = record.speed;
-            const resistance = (_c = record.rpe) !== null && _c !== void 0 ? _c : 1;
-            const durationSecs = record.durationSecs;
-            // Calculate intensity from speed and resistance combination
-            const intensityFactor = (speed * resistance) / 100; // Normalize intensity
-            // Apply intensity multiplier to base MET
-            const intensityMultiplier = 0.8 + intensityFactor * 0.4; // 0.8 to 1.2x range
-            calculatedMET *= Math.min(2.0, intensityMultiplier); // Cap at 2x
-            // Duration bonus for sustained cardio
-            if (durationSecs > 600) {
-                // 10+ minutes
-                calculatedMET *= 1.1; // 10% bonus for sustained effort
-            }
-            break;
+        else if (set.type === "cardio-machine") {
+            const avgSpeed = (parseFloat(set.speedMin) + parseFloat(set.speedMax)) / 2 || 10;
+            const distance = parseFloat(set.distance || "0") || (avgSpeed * duration) / 3600;
+            return total + distance * 1000 * (1 + avgSpeed / 20);
         }
-        case "cardio-free": {
-            const distance = record.distance;
-            const durationSecs = record.durationSecs;
-            if (distance > 0 && durationSecs > 0 && metabolicData.paceFactors) {
-                const speedKmh = (distance * 3600) / durationSecs;
-                // Find closest pace factor
-                let closestMET = metabolicData.baseMET;
-                let closestSpeed = Infinity;
-                const paceKeys = Object.keys(metabolicData.paceFactors);
-                for (let i = 0; i < paceKeys.length; i++) {
-                    const paceStr = paceKeys[i];
-                    const metVal = metabolicData.paceFactors[paceStr];
-                    const pace = parseFloat(paceStr);
-                    if (Math.abs(speedKmh - pace) < Math.abs(speedKmh - closestSpeed)) {
-                        closestSpeed = pace;
-                        closestMET = metVal;
-                    }
-                }
-                calculatedMET = closestMET;
-            }
-            break;
+        else if (set.type === "cardio-free") {
+            const distance = parseFloat(set.distance) || 0;
+            const speed = distance / (duration / 3600);
+            return total + distance * 1000 * (1 + speed / 20);
         }
-    }
-    // Apply effort factor (RPE/RIR influence on MET)
-    const effortMultiplier = 0.7 + (effortFactor / 10) * 0.5; // 0.7 to 1.2x
-    calculatedMET *= effortMultiplier;
-    // Apply interval training bonus
-    if (record.workDurationSecs && record.restDurationSecs) {
-        const workToRestRatio = record.workDurationSecs / record.restDurationSecs;
-        const intervalBonus = 1 + Math.min(0.3, workToRestRatio * 0.08); // Up to 30% bonus
-        calculatedMET *= intervalBonus;
-    }
-    // Apply fitness level efficiency
-    calculatedMET *= efficiencyFactor;
-    // Ensure MET stays within exercise's defined range
-    const [minMET, maxMET] = metabolicData.metRange;
-    calculatedMET = Math.max(minMET, Math.min(maxMET, calculatedMET));
-    return parseFloat(calculatedMET.toFixed(1));
+        return total;
+    }, 0);
 };
-/**
- * Get rep-based intensity adjustment
- */
-const getRepIntensityAdjustment = (reps, scalingType) => {
-    const baseReps = 8; // Reference point
-    const repDiff = reps - baseReps;
-    switch (scalingType) {
-        case "linear":
-            return Math.max(0.7, 1 + repDiff * 0.02); // 2% per rep difference
-        case "exponential":
-            return Math.max(0.7, Math.pow(1.04, repDiff)); // Exponential growth
-        case "plateau":
-            // Plateaus at high reps but grows quickly initially
-            if (reps > 20)
-                return 1.3;
-            return Math.max(0.7, 1 + repDiff * 0.04);
-        default:
-            return 1.0;
-    }
-};
-/**
- * Calculate exercise duration in minutes using timing guardrails
- */
-const getExerciseDurationMinutes = (record, exercise) => {
-    let durationSecs = 0;
-    const timingGuardrails = exercise.timingGuardrails;
-    // Use actual recorded work duration if available and in strict mode
-    if (record.workDurationSecs && record.isStrictMode) {
-        durationSecs = record.workDurationSecs;
-    }
-    else {
-        // Calculate expected duration using timing guardrails
-        switch (record.type) {
-            case "weight-reps":
-            case "reps-only": {
-                if (timingGuardrails &&
-                    (timingGuardrails.type === "weight-reps" ||
-                        timingGuardrails.type === "reps-only") &&
-                    timingGuardrails.singleRep) {
-                    const repTime = timingGuardrails.singleRep.typical;
-                    const setupTime = timingGuardrails.setupTypicalSecs || 0;
-                    durationSecs = record.reps * repTime + setupTime;
-                }
-                else {
-                    // Fallback to difficulty-based estimation
-                    const baseTimePerRep = exercise.difficultyLevel > 7 ? 3.5 : 2.5;
-                    durationSecs = record.reps * baseTimePerRep;
+const calculateAverageIntensity = (record, exercise, user) => {
+    const intensities = record.map((set, index) => {
+        let baseIntensity = 0;
+        if (set.type === "weight-reps") {
+            const weight = parseFloat(set.kg) || 0;
+            const reps = parseFloat(set.reps) || 0;
+            const userWeight = user.weightKg || 70;
+            const relativeLoad = weight / userWeight;
+            const repIntensity = getRepIntensity(reps);
+            baseIntensity = (relativeLoad * 40 + repIntensity * 60) / 100;
+            // RPE adjustment (only if provided and valid)
+            if (set.rpe && set.rpe !== "0") {
+                const rpe = parseFloat(set.rpe);
+                if (rpe > 0 && rpe <= 10) {
+                    baseIntensity *= 0.5 + rpe / 20; // Scale from 0.55x to 1.0x
                 }
-                break;
             }
-            case "duration": {
-                if (record.workDurationSecs && record.isStrictMode) {
-                    durationSecs = record.workDurationSecs;
-                }
-                else {
-                    durationSecs = record.durationSecs;
-                }
-                break;
+        }
+        else if (set.type === "reps-only") {
+            const reps = parseFloat(set.reps) || 0;
+            baseIntensity = getRepIntensity(reps) / 100;
+            if (set.workDurationSecs) {
+                const tempo = (reps * 3) / set.workDurationSecs;
+                baseIntensity *= Math.min(1.2, Math.max(0.8, tempo));
             }
-            case "cardio-machine":
-            case "cardio-free": {
-                if (record.workDurationSecs && record.isStrictMode) {
-                    durationSecs = record.workDurationSecs;
-                }
-                else {
-                    durationSecs = record.durationSecs;
+            // RPE adjustment for bodyweight exercises
+            if (set.rpe && set.rpe !== "0") {
+                const rpe = parseFloat(set.rpe);
+                if (rpe > 0 && rpe <= 10) {
+                    baseIntensity *= 0.5 + rpe / 20;
                 }
-                break;
             }
         }
-    }
-    // Add rest time if available (but not for cardio exercises)
-    if (record.type !== "cardio-machine" &&
-        record.type !== "cardio-free" &&
-        record.restDurationSecs) {
-        durationSecs += record.restDurationSecs;
-    }
-    return Math.max(0.5, durationSecs / 60);
-};
-/**
- * Calculate comprehensive calorie burn including EPOC
- */
-const calculateCalorieBurn = (record, exercise, metValue, durationMinutes, userProfile) => {
-    var _a;
-    const userWeight = (_a = userProfile.weightKg) !== null && _a !== void 0 ? _a : 70;
-    const bmr = calculateBMR(userProfile);
-    const bmrPerMinute = bmr / (24 * 60);
-    // Exercise calories: MET × weight(kg) × duration(hours)
-    const exerciseCalories = metValue * userWeight * (durationMinutes / 60);
-    // EPOC (Excess Post-Exercise Oxygen Consumption) calories
-    const epocCalories = exerciseCalories * exercise.metabolicData.epocFactor;
-    // BMR calories during exercise time
-    const bmrCaloriesDuringExercise = bmrPerMinute * durationMinutes;
-    // Total calories = exercise + EPOC + BMR during exercise
-    const totalCalories = exerciseCalories + epocCalories + bmrCaloriesDuringExercise;
-    return {
-        exerciseCalories: parseFloat(exerciseCalories.toFixed(1)),
-        epocCalories: parseFloat(epocCalories.toFixed(1)),
-        totalCalories: parseFloat(totalCalories.toFixed(1)),
-    };
-};
-/**
- * Calculate timing adherence bonus/penalty using timing guardrails
- */
-const calculateTimingAdherence = (record, exercise, workingScore) => {
-    const timingGuardrails = exercise.timingGuardrails;
-    if (!timingGuardrails || !record.workDurationSecs) {
-        return { bonus: 0, penalty: 0, reason: "no_timing_data" };
-    }
-    let expectedDuration = 0;
-    let tolerance = 0;
-    switch (record.type) {
-        case "weight-reps":
-        case "reps-only": {
-            if ((timingGuardrails.type === "weight-reps" ||
-                timingGuardrails.type === "reps-only") &&
-                timingGuardrails.singleRep) {
-                const repTime = timingGuardrails.singleRep.typical;
-                const setupTime = timingGuardrails.setupTypicalSecs || 0;
-                expectedDuration = record.reps * repTime + setupTime;
-                tolerance = expectedDuration * 0.25; // 25% tolerance
+        else if (set.type === "duration") {
+            const duration = (0, time_util_1.mmssToSecs)(set.durationMmSs);
+            const weight = parseFloat(set.auxWeightKg) || 0;
+            baseIntensity = Math.min(100, duration * 1.5) / 100;
+            if (weight > 0) {
+                baseIntensity *= 1 + weight / 100;
             }
-            break;
         }
-        case "duration": {
-            if (timingGuardrails.type === "duration" &&
-                timingGuardrails.setDuration) {
-                expectedDuration = record.durationSecs;
-                tolerance = timingGuardrails.setDuration.typical * 0.15; // 15% tolerance for duration exercises
+        else if (set.type === "cardio-machine" || set.type === "cardio-free") {
+            const duration = (0, time_util_1.mmssToSecs)(set.durationMmSs);
+            if (set.type === "cardio-machine") {
+                const avgSpeed = (parseFloat(set.speedMin) + parseFloat(set.speedMax)) / 2 || 0;
+                baseIntensity = Math.min(100, avgSpeed * 5.5) / 100;
+            }
+            else {
+                const distance = parseFloat(set.distance) || 0;
+                const speedKmh = duration > 0 ? distance / (duration / 3600) : 0;
+                baseIntensity = Math.min(100, speedKmh * 5.5) / 100;
             }
-            break;
-        }
-        case "cardio-machine":
-        case "cardio-free": {
-            // For cardio exercises, timing adherence is less critical
-            // Users can go longer or shorter based on their fitness level
-            return { bonus: 0, penalty: 0, reason: "cardio_flexible_timing" };
         }
-    }
-    if (expectedDuration === 0) {
-        return { bonus: 0, penalty: 0, reason: "no_expected_duration" };
-    }
-    const actualDuration = record.workDurationSecs;
-    const deviation = Math.abs(actualDuration - expectedDuration);
-    // Strict mode gets bonus for precision
-    if (record.isStrictMode && deviation <= tolerance) {
-        const precisionBonus = workingScore * 0.05; // 5% bonus for precise timing
-        return {
-            bonus: precisionBonus,
-            penalty: 0,
-            reason: "strict_mode_precision",
-        };
-    }
-    // Penalty for significant deviation (only in strict mode)
-    if (record.isStrictMode && deviation > tolerance) {
-        const deviationPercent = (deviation - tolerance) / expectedDuration;
-        const timingPenalty = Math.min(workingScore * 0.08, // Max 8% penalty
-        deviationPercent * workingScore * 0.03);
-        return { bonus: 0, penalty: timingPenalty, reason: "timing_deviation" };
-    }
-    return { bonus: 0, penalty: 0, reason: "relaxed_mode" };
-};
-/**
- * Enhanced training stress score computation using metabolic data and timing guardrails
- * This is for scoring a SINGLE record of an exercise. Ref: TRecord, TRefinedRecord.
- * To calculate complete scoring/summary of workout use: calculateWorkoutSummary(...) function
- */
-const computeScoreFromRecord = ({ avgRestDurationSecs, record, exercise, userProfile, isTimeIntervalModeEnabled = false, }) => {
-    var _a;
-    if (!record.isDone) {
-        return {
-            baseScore: 0,
-            plus: [],
-            minus: [],
-            finalScore: 0,
-            caloriesBurned: 0,
-            metValue: 0,
-            epocCalories: 0,
-        };
-    }
-    const plus = [];
-    const minus = [];
-    // Calculate effort factor from RPE/RIR
-    let effortFactor = 5; // Default moderate effort
-    if (typeof record.rpe === "number") {
-        effortFactor = Math.max(1, Math.min(10, record.rpe));
-    }
-    else if ("rir" in record && typeof record.rir === "number") {
-        effortFactor = Math.max(1, Math.min(10, 10 - record.rir));
-    }
-    // Calculate precise MET value using exercise metabolic data
-    const metValue = calculateMETValue(record, exercise, effortFactor, userProfile || {});
-    // Calculate exercise duration using timing guardrails
-    const durationMinutes = getExerciseDurationMinutes(record, exercise);
-    // Calculate comprehensive calorie burn
-    const calorieData = calculateCalorieBurn(record, exercise, metValue, durationMinutes, userProfile || {});
-    // Base score from calorie burn (more accurate than arbitrary load calculations)
-    const calorieBasedLoad = calorieData.exerciseCalories + calorieData.epocCalories * 2; // EPOC counts double
-    const base = Math.log10(1 + Math.max(5, calorieBasedLoad));
-    let workingScore = base;
-    // Exercise difficulty bonus (from database)
-    const difficultyMultiplier = 0.8 + (exercise.difficultyLevel / 10) * 0.4; // 0.8 to 1.2x
-    workingScore *= difficultyMultiplier;
-    plus.push({
-        exerciseDifficulty: parseFloat((difficultyMultiplier - 1).toFixed(3)),
+        // Apply fatigue factor for later sets (8% bonus per set)
+        const fatigueMultiplier = 1 + index * 0.08;
+        return Math.min(100, baseIntensity * fatigueMultiplier * 100);
     });
-    // ENHANCED Goal alignment bonus
-    if (userProfile === null || userProfile === void 0 ? void 0 : userProfile.fitnessGoal) {
-        let goalMultiplier = 1;
-        const goal = userProfile.fitnessGoal;
-        switch (goal) {
-            case "strength":
-                goalMultiplier = 1 + (exercise.strengthGainLevel / 10) * 0.15; // Increased from 0.12
-                break;
-            case "hypertrophy":
-                goalMultiplier = 1 + (exercise.hypertrophyLevel / 10) * 0.15;
-                break;
-            case "endurance":
-                goalMultiplier = 1 + (exercise.enduranceLevel / 10) * 0.15;
-                break;
-            case "fat_burn":
-                // For fat burn, prioritize calorie burn level and high MET exercises
-                const calorieBurnBonus = (exercise.calorieBurnLevel / 10) * 0.18; // Higher bonus for calorie burn
-                const metBonus = exercise.metabolicData.baseMET > 6 ? 0.08 : 0; // 8% bonus for high MET exercises
-                goalMultiplier = 1 + calorieBurnBonus + metBonus;
-                break;
-            case "flexibility":
-                goalMultiplier = 1 + (exercise.flexibilityLevel / 10) * 0.15;
-                break;
-            case "general":
-                const avgLevel = (exercise.strengthGainLevel +
-                    exercise.hypertrophyLevel +
-                    exercise.enduranceLevel +
-                    exercise.flexibilityLevel) /
-                    4;
-                goalMultiplier = 1 + (avgLevel / 10) * 0.1;
-                break;
+    const avgIntensity = intensities.reduce((a, b) => a + b, 0) / intensities.length;
+    const difficultyBonus = exercise.difficultyLevel * 5;
+    return Math.min(100, avgIntensity + difficultyBonus);
+};
+const calculateSetQuality = (record) => {
+    if (record.length === 0)
+        return 0;
+    if (record.length === 1)
+        return 75;
+    let qualityScore = 85; // Base score
+    // Check performance drop-off between sets
+    for (let i = 1; i < record.length; i++) {
+        const curr = record[i];
+        const prev = record[i - 1];
+        if (curr.type === "weight-reps" && prev.type === "weight-reps") {
+            const currWork = parseFloat(curr.reps) * parseFloat(curr.kg);
+            const prevWork = parseFloat(prev.reps) * parseFloat(prev.kg);
+            const dropOff = prevWork > 0 ? 1 - currWork / prevWork : 0;
+            if (dropOff < 0.1)
+                qualityScore += 5; // Excellent maintenance
+            else if (dropOff < 0.2)
+                qualityScore += 2; // Good maintenance
+            else if (dropOff > 0.3)
+                qualityScore -= 10; // Poor pacing
         }
-        if (goalMultiplier > 1) {
-            workingScore *= goalMultiplier;
-            plus.push({ goalAlignment: parseFloat((goalMultiplier - 1).toFixed(3)) });
+        else if (curr.type === "reps-only" && prev.type === "reps-only") {
+            const currReps = parseFloat(curr.reps);
+            const prevReps = parseFloat(prev.reps);
+            const dropOff = prevReps > 0 ? 1 - currReps / prevReps : 0;
+            if (dropOff < 0.15)
+                qualityScore += 5;
+            else if (dropOff > 0.3)
+                qualityScore -= 8;
         }
-    }
-    // Stability and complexity bonus
-    const stabilityBonus = 1 + (exercise.stabilityLevel / 10) * 0.06;
-    workingScore *= stabilityBonus;
-    plus.push({ stabilityDemand: parseFloat((stabilityBonus - 1).toFixed(3)) });
-    // High calorie burn efficiency bonus
-    if (calorieData.exerciseCalories > 50) {
-        // High calorie burn exercises
-        const efficiencyBonus = 1.05;
-        workingScore *= efficiencyBonus;
-        plus.push({
-            highCalorieBurn: parseFloat((efficiencyBonus - 1).toFixed(3)),
-        });
-    }
-    // Interval training bonus (already calculated in MET, but add scoring bonus)
-    if (isTimeIntervalModeEnabled) {
-        const intervalScoreBonus = 1.08;
-        workingScore *= intervalScoreBonus;
-        plus.push({
-            intervalTraining: parseFloat((intervalScoreBonus - 1).toFixed(3)),
-        });
-    }
-    // Timing adherence bonus/penalty using guardrails
-    const timingAdherence = calculateTimingAdherence(record, exercise, workingScore);
-    if (timingAdherence.bonus > 0) {
-        workingScore += timingAdherence.bonus;
-        plus.push({
-            timingPrecision: parseFloat(timingAdherence.bonus.toFixed(3)),
-        });
-    }
-    if (timingAdherence.penalty > 0) {
-        workingScore -= timingAdherence.penalty;
-        minus.push({
-            timingDeviation: parseFloat(timingAdherence.penalty.toFixed(3)),
-        });
-    }
-    // User profile adjustments
-    let profileMultiplier = 1;
-    if ((userProfile === null || userProfile === void 0 ? void 0 : userProfile.gender) === "female") {
-        profileMultiplier *= 1.08; // Reduced from 1.12 since metabolic calculations are more accurate
-    }
-    if (userProfile === null || userProfile === void 0 ? void 0 : userProfile.age) {
-        if (userProfile.age > 50)
-            profileMultiplier *= 1.06;
-        if (userProfile.age > 65)
-            profileMultiplier *= 1.1;
-    }
-    if ((userProfile === null || userProfile === void 0 ? void 0 : userProfile.weightKg) && userProfile.weightKg > 0) {
-        const weightAdjustment = 70 / userProfile.weightKg;
-        profileMultiplier *= Math.max(0.85, Math.min(1.25, weightAdjustment));
-    }
-    if (profileMultiplier !== 1) {
-        workingScore *= profileMultiplier;
-        plus.push({
-            profileAdjustment: parseFloat((profileMultiplier - 1).toFixed(3)),
-        });
-    }
-    // Enhanced rest efficiency penalty using timing guardrails
-    if (typeof record.restDurationSecs === "number" &&
-        typeof avgRestDurationSecs === "number" &&
-        ((_a = exercise.timingGuardrails) === null || _a === void 0 ? void 0 : _a.restPeriods)) {
-        const restUsed = record.restDurationSecs;
-        const restGuardrails = exercise.timingGuardrails.restPeriods;
-        const optimalRest = restGuardrails.typical;
-        const maxAcceptableRest = restGuardrails.maximum;
-        // Calculate stress-based rest bonus from guardrails
-        const stressBonus = exercise.timingGuardrails.stressRestBonus || 0;
-        const adjustedOptimalRest = optimalRest + (effortFactor > 7 ? stressBonus : 0);
-        if (restUsed > adjustedOptimalRest) {
-            const excessRest = restUsed - adjustedOptimalRest;
-            const maxExcess = maxAcceptableRest - adjustedOptimalRest;
-            if (excessRest > 0) {
-                const penaltyRatio = Math.min(1, excessRest / maxExcess);
-                const restPenalty = penaltyRatio * 0.1 * workingScore; // Up to 10% penalty
-                workingScore -= restPenalty;
-                minus.push({ excessRestPenalty: parseFloat(restPenalty.toFixed(3)) });
+        // Check effort consistency using either RIR or RPE (whichever is provided)
+        // RIR consistency check
+        if ("rir" in curr &&
+            "rir" in prev &&
+            curr.rir &&
+            prev.rir &&
+            curr.rir !== "0" &&
+            prev.rir !== "0") {
+            const currRir = parseFloat(curr.rir);
+            const prevRir = parseFloat(prev.rir);
+            if (!isNaN(currRir) && !isNaN(prevRir)) {
+                const rirDiff = Math.abs(currRir - prevRir);
+                if (rirDiff <= 1)
+                    qualityScore += 3; // Consistent effort
+            }
+        }
+        // RPE consistency check (alternative to RIR)
+        else if (curr.rpe && prev.rpe && curr.rpe !== "0" && prev.rpe !== "0") {
+            const currRpe = parseFloat(curr.rpe);
+            const prevRpe = parseFloat(prev.rpe);
+            if (!isNaN(currRpe) && !isNaN(prevRpe)) {
+                const rpeDiff = Math.abs(currRpe - prevRpe);
+                if (rpeDiff <= 1)
+                    qualityScore += 3; // Consistent effort
             }
         }
     }
-    // Final score normalization
-    let finalScore = Math.max(0, workingScore);
-    finalScore *= 12; // Scale to intuitive range (0-120+ for typical exercises)
-    finalScore = Math.min(200, finalScore); // Cap extreme scores
-    return {
-        baseScore: parseFloat(base.toFixed(2)),
-        plus,
-        minus,
-        finalScore: parseFloat(finalScore.toFixed(1)),
-        caloriesBurned: calorieData.totalCalories,
-        metValue,
-        epocCalories: calorieData.epocCalories,
-    };
+    // Bonus for multiple quality sets
+    if (record.length >= 3)
+        qualityScore += 5;
+    if (record.length >= 4)
+        qualityScore += 3;
+    return Math.min(100, Math.max(0, qualityScore));
+};
+const calculateMuscleScores = (exercise, record, totalVolume) => {
+    const muscleScores = {};
+    const volumePerSet = totalVolume / record.length;
+    // Primary muscles take 70% of the fatigue
+    exercise.primaryMuscles.forEach((muscle) => {
+        const baseFatigue = Math.min(100, (volumePerSet / 500) * 70);
+        const setMultiplier = Math.min(1.5, 1 + (record.length - 1) * 0.15);
+        muscleScores[muscle] = Math.min(100, baseFatigue * setMultiplier);
+    });
+    // Secondary muscles take 30% of the fatigue
+    exercise.secondaryMuscles.forEach((muscle) => {
+        const baseFatigue = Math.min(100, (volumePerSet / 500) * 30);
+        const setMultiplier = Math.min(1.3, 1 + (record.length - 1) * 0.1);
+        muscleScores[muscle] = Math.min(100, baseFatigue * setMultiplier);
+    });
+    return muscleScores;
+};
+const normalizeVolume = (totalVolume, exercise, user) => {
+    const userWeight = user.weightKg || 70;
+    const fitnessLevel = user.fitnessLevel || 2;
+    // Expected volume baseline
+    const baseExpected = userWeight * 15 * fitnessLevel;
+    const difficultyAdjustment = 1 + exercise.difficultyLevel / 8;
+    const expectedVolume = baseExpected * difficultyAdjustment;
+    // Sigmoid normalization for smooth scoring
+    const ratio = totalVolume / expectedVolume;
+    return 100 / (1 + Math.exp(-3 * (ratio - 0.8)));
+};
+const getRepIntensity = (reps) => {
+    if (reps <= 3)
+        return 95;
+    if (reps <= 5)
+        return 87;
+    if (reps <= 8)
+        return 80;
+    if (reps <= 12)
+        return 70;
+    if (reps <= 15)
+        return 65;
+    if (reps <= 20)
+        return 60;
+    return 50;
 };
-exports.computeScoreFromRecord = computeScoreFromRecord;