@dgpholdings/greatoak-shared 1.1.36 → 1.1.37

package/dist/typeGuards/index.d.ts

@@ -1,4 +1,5 @@
-import { TRecord, TRecordBodyWeight, TRecordDuration, TRecordWeight } from "../types/TApiExerciseRecord";
+import { TRecord, TRecordBodyWeight, TRecordDistance, TRecordDuration, TRecordWeight } from "../types/TApiExerciseRecord";
 export declare const isRecordWeightTypeGuard: (param: TRecord[]) => param is TRecordWeight[];
 export declare const isRecordDurationTypeGuard: (param: TRecord[]) => param is TRecordDuration[];
 export declare const isRecordBodyWeightTypeGuard: (param: TRecord[]) => param is TRecordBodyWeight[];
+export declare const isRecordDistanceTypeGuard: (param: TRecord[]) => param is TRecordDistance[];

package/dist/typeGuards/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRecordBodyWeightTypeGuard = exports.isRecordDurationTypeGuard = exports.isRecordWeightTypeGuard = void 0;
+exports.isRecordDistanceTypeGuard = exports.isRecordBodyWeightTypeGuard = exports.isRecordDurationTypeGuard = exports.isRecordWeightTypeGuard = void 0;
 const isRecordWeightTypeGuard = (param) => { var _a; return ((_a = param === null || param === void 0 ? void 0 : param[0]) === null || _a === void 0 ? void 0 : _a.type) === "weight-reps"; };
 exports.isRecordWeightTypeGuard = isRecordWeightTypeGuard;
 const isRecordDurationTypeGuard = (param) => { var _a; return ((_a = param === null || param === void 0 ? void 0 : param[0]) === null || _a === void 0 ? void 0 : _a.type) === "duration"; };
 exports.isRecordDurationTypeGuard = isRecordDurationTypeGuard;
 const isRecordBodyWeightTypeGuard = (param) => { var _a; return ((_a = param === null || param === void 0 ? void 0 : param[0]) === null || _a === void 0 ? void 0 : _a.type) === "reps-only"; };
 exports.isRecordBodyWeightTypeGuard = isRecordBodyWeightTypeGuard;
+const isRecordDistanceTypeGuard = (param) => param[0].type === "distance";
+exports.isRecordDistanceTypeGuard = isRecordDistanceTypeGuard;

package/dist/types/TApiAuth.d.ts

@@ -78,6 +78,7 @@ export type TUser = {
     billingPlanType: "monthly" | "annually" | "free";
     billingPlanVersion?: string;
     billingPlanGeoCountryCode: string;
+    fitnessLevel?: number;
     paymentMethod?: "credit_card" | "paypal" | "apple_pay" | "upi";
     billingPlanNextDueDate?: string;
     devices: {
@@ -91,6 +92,7 @@ export type TUser = {
     dob?: Date;
     weightKg?: number;
     heightCm?: number;
+    bodyFatPercentage?: number;
 };
 export type TUserSignInData = Pick<TUser, "email" | "isVerified" | "appLanguage" | "billingPlanType" | "billingPlanVersion" | "paymentMethod" | "authMethod" | "dob" | "weightKg" | "gender"> & {
     createdAt: Date;

package/dist/types/TApiExercise.d.ts

@@ -39,7 +39,6 @@ export type TExercise = {
     secondaryMuscles: TBodyPartKeys;
     trainingTypes: TTrainingType[];
     avgSetDurationInSecs?: number;
-    difficultyScoreMultiplier: number;
     difficultyLevel: number;
     hypertrophyLevel: number;
     strengthGainLevel: number;
@@ -47,6 +46,27 @@ export type TExercise = {
     calorieBurnLevel: number;
     stabilityLevel: number;
     enduranceLevel: number;
+    metabolicData: {
+        baseMET: number;
+        metRange: [number, number];
+        compoundMultiplier: number;
+        muscleGroupFactor: number;
+        intensityScaling: "linear" | "exponential" | "plateau";
+        epocFactor: number;
+        weightFactors?: {
+            lightWeight: number;
+            moderateWeight: number;
+            heavyWeight: number;
+        };
+        durationFactors?: {
+            shortDuration: number;
+            mediumDuration: number;
+            longDuration: number;
+        };
+        paceFactors?: {
+            [key: string]: number;
+        };
+    };
     youtubeVideoUrl: string[];
     modelVideoUrl: string;
     thumbnailUrl: string;

package/dist/types/TApiUser.d.ts

@@ -1,9 +1,12 @@
+import { TGender } from "./TApiAuth";
 export type TUserMetric = {
     dob: Date;
     weightKg?: number;
+    heightCm?: number;
     appLanguage: string;
     emailAddress?: string;
-    gender: "male" | "female" | "unmentioned";
+    gender: TGender;
+    fitnessLevel?: 1 | 2 | 3 | 4 | 5;
     createdAt: Date;
     updatedAt?: Date;
 };

package/dist/utils/index.d.ts

@@ -4,4 +4,7 @@ export { countryToCurrencyCode } from "./billing.utils";
 export { computeScoreFromRecord } from "./scoring.utils";
 export { isDefined, isDefinedNumber } from "./isDefined.utils";
 export { refineRecordEntry } from "./record.utils";
+export { generateWorkoutSummaryText, calculateWorkoutSummary, } from "./workoutSummary.util";
 export type { TRefinedRecord, TRefinedBodyWeightRecord, TRefinedDurationRecord, TRefinedWeightRecord, } from "./record.utils";
+export type { TUserProfile, TScoreBreakdown } from "./scoring.utils";
+export type { TWorkoutSummary, TExerciseSummary, TSetSummary, TMuscleRecoveryMap, } from "./workoutSummary.util";

package/dist/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.refineRecordEntry = exports.isDefinedNumber = exports.isDefined = exports.computeScoreFromRecord = exports.countryToCurrencyCode = exports.getDaysAndHoursDifference = exports.isUserAllowedToUpdate = exports.mmssToSecs = exports.toNumber = void 0;
+exports.calculateWorkoutSummary = exports.generateWorkoutSummaryText = exports.refineRecordEntry = exports.isDefinedNumber = exports.isDefined = exports.computeScoreFromRecord = exports.countryToCurrencyCode = exports.getDaysAndHoursDifference = exports.isUserAllowedToUpdate = exports.mmssToSecs = exports.toNumber = void 0;
 var number_util_1 = require("./number.util");
 Object.defineProperty(exports, "toNumber", { enumerable: true, get: function () { return number_util_1.toNumber; } });
 var time_util_1 = require("./time.util");
@@ -16,3 +16,6 @@ Object.defineProperty(exports, "isDefined", { enumerable: true, get: function ()
 Object.defineProperty(exports, "isDefinedNumber", { enumerable: true, get: function () { return isDefined_utils_1.isDefinedNumber; } });
 var record_utils_1 = require("./record.utils");
 Object.defineProperty(exports, "refineRecordEntry", { enumerable: true, get: function () { return record_utils_1.refineRecordEntry; } });
+var workoutSummary_util_1 = require("./workoutSummary.util");
+Object.defineProperty(exports, "generateWorkoutSummaryText", { enumerable: true, get: function () { return workoutSummary_util_1.generateWorkoutSummaryText; } });
+Object.defineProperty(exports, "calculateWorkoutSummary", { enumerable: true, get: function () { return workoutSummary_util_1.calculateWorkoutSummary; } });

package/dist/utils/scoring.utils.d.ts

@@ -1,10 +1,15 @@
 import { TRefinedRecord } from "./record.utils";
-type TUserProfile = {
+import { TExercise, TGender, TUserMetric } from "../types";
+export type TUserProfile = {
     age?: number;
-    gender?: "male" | "female" | "non-binary" | "unspecified";
+    gender?: TGender;
     weightKg?: number;
+    heightCm?: number;
+    bodyFatPercentage?: number;
+    fitnessLevel?: TUserMetric["fitnessLevel"];
+    fitnessGoal?: "strength" | "hypertrophy" | "endurance" | "general";
 };
-type TScoreBreakdown = {
+export type TScoreBreakdown = {
     baseScore: number;
     plus: {
         [reason: string]: number;
@@ -13,18 +18,19 @@ type TScoreBreakdown = {
         [reason: string]: number;
     }[];
     finalScore: number;
+    caloriesBurned: number;
+    metValue: number;
+    epocCalories: number;
 };
 type TParams = {
     record: TRefinedRecord;
+    exercise: TExercise;
     userProfile?: TUserProfile;
     avgRestDurationSecs?: number;
-    exerciseDefaultDifficultyMultiplier?: number;
     isTimeIntervalModeEnabled?: boolean;
-    sessionSetCount?: number;
 };
 /**
- * Compute the training stress score for a given record.
- * Uses improved load calculations with type-specific normalization and MET values for cardio.
+ * Enhanced training stress score computation using metabolic data
  */
-export declare const computeScoreFromRecord: ({ exerciseDefaultDifficultyMultiplier, avgRestDurationSecs, record, userProfile, isTimeIntervalModeEnabled, sessionSetCount, }: TParams) => TScoreBreakdown;
+export declare const computeScoreFromRecord: ({ avgRestDurationSecs, record, exercise, userProfile, isTimeIntervalModeEnabled, }: TParams) => TScoreBreakdown;
 export {};

package/dist/utils/scoring.utils.js

@@ -3,151 +3,309 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeScoreFromRecord = void 0;
 const time_util_1 = require("./time.util");
 /**
- * Compute the training stress score for a given record.
- * Uses improved load calculations with type-specific normalization and MET values for cardio.
+ * Calculate BMR using Mifflin-St Jeor Equation with body composition adjustment
  */
-const computeScoreFromRecord = ({ exerciseDefaultDifficultyMultiplier = 1, avgRestDurationSecs, record, userProfile, isTimeIntervalModeEnabled = false, sessionSetCount = 1, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    if (!record.isDone) {
-        return {
-            baseScore: 0,
-            plus: [],
-            minus: [],
-            finalScore: 0,
-        };
+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;
     }
-    const userWeight = (_a = userProfile === null || userProfile === void 0 ? void 0 : userProfile.weightKg) !== null && _a !== void 0 ? _a : 70;
-    const plus = [];
-    const minus = [];
-    // Step 1: Compute type-specific load with normalization
-    let rawLoad = 0;
-    let normalizedLoad = 0;
+    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;
+    }
+    return Math.max(1200, bmr);
+};
+/**
+ * Calculate precise MET value using exercise metabolic data
+ */
+const calculateMETValue = (record, exercise, effortFactor, userProfile) => {
+    var _a, _b, _c, _d, _e;
+    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": {
-            rawLoad = record.kg * record.reps;
-            normalizedLoad = rawLoad; // Baseline - no scaling needed
+            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;
         }
-        case "duration": {
-            const durationSecs = (0, time_util_1.mmssToSecs)((_b = record.durationSecs) !== null && _b !== void 0 ? _b : "00:00");
-            const auxWeight = (_c = record.auxWeightKg) !== null && _c !== void 0 ? _c : 0;
-            if (auxWeight > 0) {
-                // Weighted duration exercise (e.g., weighted plank)
-                rawLoad = auxWeight * durationSecs;
-                normalizedLoad = rawLoad * 0.8; // Slightly less intense than pure weight training
+        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 {
-                // Bodyweight duration exercise (e.g., plank, wall sit)
-                rawLoad = userWeight * (durationSecs / 60); // Per minute scaling
-                normalizedLoad = rawLoad * 1.2; // Duration exercises are metabolically demanding
+            else if (userWeight < 60) {
+                calculatedMET *= 0.95; // Lighter people have slight advantage
             }
             break;
         }
-        case "reps-only": {
-            const reps = (_d = record.reps) !== null && _d !== void 0 ? _d : 0;
-            const auxWeight = (_e = record.auxWeightKg) !== null && _e !== void 0 ? _e : 0;
-            const effectiveWeight = auxWeight > 0 ? auxWeight : userWeight;
-            rawLoad = effectiveWeight * reps;
-            normalizedLoad = rawLoad * 0.7; // Bodyweight exercises slightly less intense than free weights
+        case "duration": {
+            const durationSecs = (0, time_util_1.mmssToSecs)((_c = record.durationSecs) !== null && _c !== void 0 ? _c : "00:00");
+            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;
         }
         case "distance": {
-            const distance = (_f = record.distanceKm) !== null && _f !== void 0 ? _f : 0;
-            const durationSecs = (0, time_util_1.mmssToSecs)((_g = record.durationSecs) !== null && _g !== void 0 ? _g : "00:00");
-            if (distance > 0 && durationSecs > 0) {
-                // Calculate speed and estimate MET value
+            const distance = (_d = record.distanceKm) !== null && _d !== void 0 ? _d : 0;
+            const durationSecs = (0, time_util_1.mmssToSecs)((_e = record.durationSecs) !== null && _e !== void 0 ? _e : "00:00");
+            if (distance > 0 && durationSecs > 0 && metabolicData.paceFactors) {
                 const speedKmh = (distance * 3600) / durationSecs;
-                // MET estimation based on speed (conservative estimates)
-                let metValue = 3; // Walking baseline
-                if (speedKmh > 4)
-                    metValue = 4.5; // Brisk walking
-                if (speedKmh > 6)
-                    metValue = 7; // Light jogging
-                if (speedKmh > 8)
-                    metValue = 9; // Running
-                if (speedKmh > 12)
-                    metValue = 12; // Fast running
-                if (speedKmh > 16)
-                    metValue = 15; // Very fast running
-                // Calculate calories burned: MET × weight(kg) × hours
-                const caloriesBurned = metValue * userWeight * (durationSecs / 3600);
-                rawLoad = caloriesBurned;
-                normalizedLoad = caloriesBurned * 8; // Scale cardio to match resistance training
+                // 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;
         }
     }
-    // Step 2: Base score using log scale with minimum threshold
-    const base = Math.log10(1 + Math.max(10, normalizedLoad)); // Minimum 10 to avoid very low scores
-    let workingScore = base;
-    // Step 3: Effort multiplier (RPE/RIR)
-    let effortFactor = 5; // Default moderate effort if no RPE/RIR provided
+    // 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));
+};
+/**
+ * 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
+ */
+const getExerciseDurationMinutes = (record, exercise) => {
+    var _a, _b;
+    let durationSecs = 0;
+    switch (record.type) {
+        case "weight-reps":
+        case "reps-only": {
+            if (exercise.avgSetDurationInSecs) {
+                durationSecs = exercise.avgSetDurationInSecs;
+            }
+            else {
+                // Estimate based on reps and exercise complexity
+                const reps = record.type === "weight-reps" ? record.reps : record.reps;
+                const baseTimePerRep = exercise.difficultyLevel > 7 ? 3.5 : 2.5;
+                durationSecs = reps * baseTimePerRep;
+            }
+            break;
+        }
+        case "duration": {
+            durationSecs = (0, time_util_1.mmssToSecs)((_a = record.durationSecs) !== null && _a !== void 0 ? _a : "00:00");
+            break;
+        }
+        case "distance": {
+            durationSecs = (0, time_util_1.mmssToSecs)((_b = record.durationSecs) !== null && _b !== void 0 ? _b : "00:00");
+            break;
+        }
+    }
+    // Add rest time if available (but not for distance exercises)
+    if (record.type !== "distance" && 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)),
+    };
+};
+/**
+ * Enhanced training stress score computation using metabolic data
+ */
+const computeScoreFromRecord = ({ avgRestDurationSecs, record, exercise, userProfile, isTimeIntervalModeEnabled = false, }) => {
+    var _a, _b;
+    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 (typeof record.rir === "number") {
         effortFactor = Math.max(1, Math.min(10, 10 - record.rir));
     }
-    const effortMultiplier = 0.7 + effortFactor * 0.06; // Range: 0.76 to 1.3
-    workingScore *= effortMultiplier;
+    // Calculate precise MET value using exercise metabolic data
+    const metValue = calculateMETValue(record, exercise, effortFactor, userProfile || {});
+    // Calculate exercise duration
+    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({
-        effortMultiplier: parseFloat((effortMultiplier - 1).toFixed(3)),
+        exerciseDifficulty: parseFloat((difficultyMultiplier - 1).toFixed(3)),
     });
-    // Step 4: Volume/Fatigue factor (later sets are harder)
-    if (sessionSetCount > 1) {
-        const fatigueMultiplier = 1 + Math.min(0.3, (sessionSetCount - 1) * 0.05);
-        workingScore *= fatigueMultiplier;
-        plus.push({ fatigueBonus: parseFloat((fatigueMultiplier - 1).toFixed(3)) });
+    // Goal alignment bonus
+    if (userProfile === null || userProfile === void 0 ? void 0 : userProfile.fitnessGoal) {
+        let goalMultiplier = 1;
+        switch (userProfile.fitnessGoal) {
+            case "strength":
+                goalMultiplier = 1 + (exercise.strengthGainLevel / 10) * 0.12;
+                break;
+            case "hypertrophy":
+                goalMultiplier = 1 + (exercise.hypertrophyLevel / 10) * 0.12;
+                break;
+            case "endurance":
+                goalMultiplier = 1 + (exercise.enduranceLevel / 10) * 0.12;
+                break;
+            case "general":
+                const avgLevel = (exercise.strengthGainLevel +
+                    exercise.hypertrophyLevel +
+                    exercise.enduranceLevel +
+                    exercise.flexibilityLevel) /
+                    4;
+                goalMultiplier = 1 + (avgLevel / 10) * 0.08;
+                break;
+        }
+        if (goalMultiplier > 1) {
+            workingScore *= goalMultiplier;
+            plus.push({ goalAlignment: parseFloat((goalMultiplier - 1).toFixed(3)) });
+        }
     }
-    // Step 5: Interval training adjustments
+    // 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) {
-        let intervalMultiplier = 1.08; // Base 8% boost for interval training
-        if (record.workDurationSecs && record.restDurationSecs) {
-            const restRatio = record.restDurationSecs / record.workDurationSecs;
-            // Optimal rest ratios vary by exercise type
-            let optimalRestRatio = 2.0; // Default
-            switch (record.type) {
-                case "weight-reps":
-                    optimalRestRatio = 3.0; // Strength needs more rest
-                    break;
-                case "distance":
-                case "duration":
-                    optimalRestRatio = 1.0; // Cardio can handle shorter rest
-                    break;
-                case "reps-only":
-                    optimalRestRatio = 1.5; // Bodyweight middle ground
-                    break;
-            }
-            // Bonus for staying close to optimal ratio (within 50% deviation)
-            const deviation = Math.abs(restRatio - optimalRestRatio) / optimalRestRatio;
-            if (deviation <= 0.5) {
-                const ratioBonus = 0.05 * (1 - deviation * 2); // Up to 5% bonus
-                intervalMultiplier += ratioBonus;
-            }
-        }
-        workingScore *= intervalMultiplier;
+        const intervalScoreBonus = 1.08;
+        workingScore *= intervalScoreBonus;
         plus.push({
-            intervalTraining: parseFloat((intervalMultiplier - 1).toFixed(3)),
+            intervalTraining: parseFloat((intervalScoreBonus - 1).toFixed(3)),
         });
     }
-    // Step 6: User profile adjustments
+    // User profile adjustments
     let profileMultiplier = 1;
-    // Gender adjustment (women typically have less muscle mass)
     if ((userProfile === null || userProfile === void 0 ? void 0 : userProfile.gender) === "female") {
-        profileMultiplier *= 1.12;
+        profileMultiplier *= 1.08; // Reduced from 1.12 since metabolic calculations are more accurate
     }
-    // Age adjustment (strength declines with age)
     if (userProfile === null || userProfile === void 0 ? void 0 : userProfile.age) {
         if (userProfile.age > 50)
-            profileMultiplier *= 1.1;
+            profileMultiplier *= 1.06;
         if (userProfile.age > 65)
-            profileMultiplier *= 1.15;
+            profileMultiplier *= 1.1;
     }
-    // Weight normalization (smaller people work harder relatively)
     if ((userProfile === null || userProfile === void 0 ? void 0 : userProfile.weightKg) && userProfile.weightKg > 0) {
         const weightAdjustment = 70 / userProfile.weightKg;
-        // Cap adjustment to prevent extreme values
-        profileMultiplier *= Math.max(0.7, Math.min(1.4, weightAdjustment));
+        profileMultiplier *= Math.max(0.85, Math.min(1.25, weightAdjustment));
     }
     if (profileMultiplier !== 1) {
         workingScore *= profileMultiplier;
@@ -155,38 +313,39 @@ const computeScoreFromRecord = ({ exerciseDefaultDifficultyMultiplier = 1, avgRe
             profileAdjustment: parseFloat((profileMultiplier - 1).toFixed(3)),
         });
     }
-    // Step 7: Rest efficiency penalty
+    // Enhanced rest efficiency penalty
     if (typeof record.restDurationSecs === "number" &&
         typeof avgRestDurationSecs === "number") {
         const restUsed = record.restDurationSecs;
-        const baseGrace = 10; // Base grace period
-        const effortGrace = effortFactor * 3; // More grace for higher effort
+        const baseGrace = 8 + exercise.difficultyLevel * 1.5; // More grace for complex exercises
+        const effortGrace = effortFactor * 2.5;
         const totalGrace = baseGrace + effortGrace;
-        const maxPenaltyThreshold = totalGrace + 60; // Cap penalty threshold
+        const maxPenaltyThreshold = totalGrace + 45;
         const excessRest = restUsed - avgRestDurationSecs;
         if (excessRest > totalGrace) {
             const penaltyExcess = Math.min(excessRest - totalGrace, maxPenaltyThreshold - totalGrace);
             const penaltyRatio = penaltyExcess / (maxPenaltyThreshold - totalGrace);
-            const restPenalty = penaltyRatio * 0.15 * workingScore; // Up to 15% penalty
+            const restPenalty = penaltyRatio * 0.12 * workingScore; // Reduced penalty
             workingScore -= restPenalty;
             minus.push({ excessRestPenalty: parseFloat(restPenalty.toFixed(3)) });
         }
     }
-    // Step 8: Work duration adherence (for timed exercises in interval mode)
+    // Work duration adherence for interval training
     if (isTimeIntervalModeEnabled && record.workDurationSecs) {
         let actualDuration = 0;
         if (record.type === "duration") {
-            actualDuration = (0, time_util_1.mmssToSecs)((_h = record.durationSecs) !== null && _h !== void 0 ? _h : "00:00");
+            actualDuration = (0, time_util_1.mmssToSecs)((_a = record.durationSecs) !== null && _a !== void 0 ? _a : "00:00");
         }
         else if (record.type === "distance") {
-            actualDuration = (0, time_util_1.mmssToSecs)((_j = record.durationSecs) !== null && _j !== void 0 ? _j : "00:00");
+            actualDuration = (0, time_util_1.mmssToSecs)((_b = record.durationSecs) !== null && _b !== void 0 ? _b : "00:00");
         }
         if (actualDuration > 0) {
-            const durationDiff = Math.abs(actualDuration - record.workDurationSecs);
-            const tolerance = record.workDurationSecs * 0.2; // 20% tolerance
+            const expectedDuration = exercise.avgSetDurationInSecs || record.workDurationSecs;
+            const durationDiff = Math.abs(actualDuration - expectedDuration);
+            const tolerance = expectedDuration * 0.25; // 25% tolerance
             if (durationDiff > tolerance) {
-                const excessPercent = (durationDiff - tolerance) / record.workDurationSecs;
-                const timingPenalty = Math.min(0.1 * workingScore, excessPercent * 0.08 * workingScore);
+                const excessPercent = (durationDiff - tolerance) / expectedDuration;
+                const timingPenalty = Math.min(0.08 * workingScore, excessPercent * 0.05 * workingScore);
                 workingScore -= timingPenalty;
                 minus.push({
                     timingDeviationPenalty: parseFloat(timingPenalty.toFixed(3)),
@@ -194,24 +353,18 @@ const computeScoreFromRecord = ({ exerciseDefaultDifficultyMultiplier = 1, avgRe
             }
         }
     }
-    // Step 9: Exercise difficulty multiplier
-    workingScore *= exerciseDefaultDifficultyMultiplier;
-    if (exerciseDefaultDifficultyMultiplier !== 1) {
-        plus.push({
-            exerciseDifficulty: parseFloat((exerciseDefaultDifficultyMultiplier - 1).toFixed(3)),
-        });
-    }
-    // Step 10: Final score normalization and capping
+    // Final score normalization
     let finalScore = Math.max(0, workingScore);
-    // Scale to a more intuitive range (roughly 0-100 for typical exercises)
-    finalScore *= 10;
-    // Cap extreme scores to prevent runaway values
-    finalScore = Math.min(200, finalScore);
+    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,
     };
 };
 exports.computeScoreFromRecord = computeScoreFromRecord;

package/dist/utils/workoutSummary.util.d.ts

@@ -0,0 +1,87 @@
+import { TRefinedRecord } from "./record.utils";
+import { TExercise, TBodyPartKeys } from "../types";
+import { TScoreBreakdown, TUserProfile } from "./scoring.utils";
+/**
+ * EXERCISE SCORING SYSTEM DOCUMENTATION
+ * =====================================
+ *
+ * What the Score Represents:
+ * -------------------------
+ * The exercise score is a comprehensive measure of training stress that combines:
+ *
+ * 1. **Energy Expenditure (40%)**: Actual calories burned during exercise + afterburn (EPOC)
+ * 2. **Exercise Complexity (25%)**: Difficulty level, stability demands, muscle groups involved
+ * 3. **Effort Level (20%)**: RPE/RIR indicating how hard you worked
+ * 4. **Goal Alignment (10%)**: How well exercise matches your fitness goals
+ * 5. **Personal Factors (5%)**: Age, gender, weight, fitness level adjustments
+ *
+ * Score Ranges:
+ * -------------
+ * - 0-20:   Light effort (walking, easy stretching)
+ * - 21-40:  Moderate effort (bodyweight exercises, light weights)
+ * - 41-60:  Hard effort (challenging sets, compound movements)
+ * - 61-80:  Very hard effort (heavy weights, high-intensity cardio)
+ * - 81-100: Extremely hard effort (max effort sets, intense HIIT)
+ * - 100+:   Elite/competition level effort
+ *
+ * Usage:
+ * ------
+ * - Each SET gets its own score
+ * - Higher scores = higher training stress
+ * - Use for tracking progress, planning recovery
+ * - Compare different workouts objectively
+ */
+export type TWorkoutSummary = {
+    totalScore: number;
+    averageScore: number;
+    totalCalories: number;
+    totalEpocCalories: number;
+    workoutDuration: number;
+    exerciseSummaries: TExerciseSummary[];
+    muscleRecovery: TMuscleRecoveryMap;
+    fatigueLevel: "light" | "moderate" | "hard" | "very_hard" | "extreme";
+    recommendedRestDays: number;
+};
+export type TExerciseSummary = {
+    exercise: TExercise;
+    sets: TSetSummary[];
+    totalScore: number;
+    averageScore: number;
+    totalCalories: number;
+    bestSet: {
+        setNumber: number;
+        score: number;
+        reason: string;
+    };
+    muscleActivation: {
+        primary: number;
+        secondary: number;
+    };
+};
+export type TSetSummary = {
+    setNumber: number;
+    record: TRefinedRecord;
+    scoreBreakdown: TScoreBreakdown;
+    description: string;
+};
+export type TMuscleRecoveryMap = {
+    [muscle in TBodyPartKeys[number]]: {
+        fatigueLevel: number;
+        recoveryHours: number;
+        trainingStress: number;
+        exercises: string[];
+    };
+};
+/**
+ * Calculate comprehensive workout summary
+ */
+export declare const calculateWorkoutSummary: (exercises: Array<{
+    exercise: TExercise;
+    records: TRefinedRecord[];
+    startTime?: Date;
+    endTime?: Date;
+}>, userProfile?: TUserProfile) => TWorkoutSummary;
+/**
+ * Generate user-friendly workout summary text
+ */
+export declare const generateWorkoutSummaryText: (summary: TWorkoutSummary) => string;

package/dist/utils/workoutSummary.util.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWorkoutSummaryText = exports.calculateWorkoutSummary = void 0;
+const scoring_utils_1 = require("./scoring.utils");
+/**
+ * Calculate comprehensive workout summary
+ */
+const calculateWorkoutSummary = (exercises, userProfile) => {
+    var _a, _b;
+    let totalScore = 0;
+    let totalCalories = 0;
+    let totalEpocCalories = 0;
+    let totalSets = 0;
+    const exerciseSummaries = [];
+    const muscleStressMap = new Map();
+    // Calculate workout duration
+    const workoutStart = ((_a = exercises[0]) === null || _a === void 0 ? void 0 : _a.startTime) || new Date();
+    const workoutEnd = ((_b = exercises[exercises.length - 1]) === null || _b === void 0 ? void 0 : _b.endTime) || new Date();
+    const workoutDuration = Math.max(1, (workoutEnd.getTime() - workoutStart.getTime()) / (1000 * 60));
+    // Process each exercise
+    exercises.forEach((exerciseData) => {
+        const { exercise, records } = exerciseData;
+        const sets = [];
+        let exerciseScore = 0;
+        let exerciseCalories = 0;
+        let bestSetScore = 0;
+        let bestSetNumber = 1;
+        let bestSetReason = "highest score";
+        // Process each set/record
+        records.forEach((record, index) => {
+            if (!record.isDone)
+                return;
+            const scoreBreakdown = (0, scoring_utils_1.computeScoreFromRecord)({
+                record,
+                exercise,
+                userProfile,
+                isTimeIntervalModeEnabled: !!(record.workDurationSecs && record.restDurationSecs),
+            });
+            const setNumber = index + 1;
+            const setDescription = generateSetDescription(record, exercise, scoreBreakdown);
+            sets.push({
+                setNumber,
+                record,
+                scoreBreakdown,
+                description: setDescription,
+            });
+            exerciseScore += scoreBreakdown.finalScore;
+            exerciseCalories += scoreBreakdown.caloriesBurned;
+            totalSets++;
+            // Track best set
+            if (scoreBreakdown.finalScore > bestSetScore) {
+                bestSetScore = scoreBreakdown.finalScore;
+                bestSetNumber = setNumber;
+                bestSetReason = getBestSetReason(record, exercise);
+            }
+            // Accumulate muscle stress
+            exercise.primaryMuscles.forEach((muscle) => {
+                const currentStress = muscleStressMap.get(muscle) || 0;
+                muscleStressMap.set(muscle, currentStress + scoreBreakdown.finalScore * 1.0); // Primary muscles get full stress
+            });
+            exercise.secondaryMuscles.forEach((muscle) => {
+                const currentStress = muscleStressMap.get(muscle) || 0;
+                muscleStressMap.set(muscle, currentStress + scoreBreakdown.finalScore * 0.6); // Secondary muscles get 60% stress
+            });
+        });
+        if (sets.length > 0) {
+            exerciseSummaries.push({
+                exercise,
+                sets,
+                totalScore: exerciseScore,
+                averageScore: exerciseScore / sets.length,
+                totalCalories: exerciseCalories,
+                bestSet: {
+                    setNumber: bestSetNumber,
+                    score: bestSetScore,
+                    reason: bestSetReason,
+                },
+                muscleActivation: calculateMuscleActivation(exercise, sets),
+            });
+        }
+    });
+    // Calculate totals
+    totalScore = exerciseSummaries.reduce((sum, ex) => sum + ex.totalScore, 0);
+    totalCalories = exerciseSummaries.reduce((sum, ex) => sum + ex.totalCalories, 0);
+    totalEpocCalories = exerciseSummaries.reduce((sum, ex) => sum +
+        ex.sets.reduce((setSum, set) => setSum + set.scoreBreakdown.epocCalories, 0), 0);
+    // Calculate muscle recovery
+    const muscleRecovery = calculateMuscleRecovery(muscleStressMap, exercises);
+    // Determine overall fatigue level
+    const averageScore = totalSets > 0 ? totalScore / totalSets : 0;
+    const fatigueLevel = getFatigueLevel(averageScore, totalScore, workoutDuration);
+    const recommendedRestDays = getRecommendedRestDays(fatigueLevel, muscleRecovery);
+    return {
+        totalScore: Math.round(totalScore),
+        averageScore: Math.round(averageScore),
+        totalCalories: Math.round(totalCalories),
+        totalEpocCalories: Math.round(totalEpocCalories),
+        workoutDuration: Math.round(workoutDuration),
+        exerciseSummaries,
+        muscleRecovery,
+        fatigueLevel,
+        recommendedRestDays,
+    };
+};
+exports.calculateWorkoutSummary = calculateWorkoutSummary;
+/**
+ * Generate human-readable set description
+ */
+const generateSetDescription = (record, exercise, scoreBreakdown) => {
+    const effort = record.rpe
+        ? `RPE ${record.rpe}`
+        : record.rir
+            ? `${record.rir} RIR`
+            : "";
+    const calories = `${Math.round(scoreBreakdown.caloriesBurned)} cal`;
+    switch (record.type) {
+        case "weight-reps":
+            return `${record.kg}kg × ${record.reps} reps ${effort} • ${calories}`;
+        case "reps-only":
+            const auxWeight = record.auxWeightKg ? ` (+${record.auxWeightKg}kg)` : "";
+            return `${record.reps} reps${auxWeight} ${effort} • ${calories}`;
+        case "duration":
+            const auxWeightDur = record.auxWeightKg
+                ? ` (+${record.auxWeightKg}kg)`
+                : "";
+            return `${record.durationSecs}${auxWeightDur} ${effort} • ${calories}`;
+        case "distance":
+            let pace = "";
+            if (record.avgPaceSecsPerKm) {
+                const minutes = Math.floor(record.avgPaceSecsPerKm / 60);
+                const seconds = (record.avgPaceSecsPerKm % 60).toFixed(0);
+                const secondsFormatted = seconds.length === 1 ? "0" + seconds : seconds;
+                pace = ` (${minutes}:${secondsFormatted}/km)`;
+            }
+            return `${record.distanceKm}km in ${record.durationSecs}${pace} ${effort} • ${calories}`;
+        default:
+            return `${effort} • ${calories}`;
+    }
+};
+/**
+ * Determine reason for best set
+ */
+const getBestSetReason = (record, exercise) => {
+    switch (record.type) {
+        case "weight-reps":
+            return "heaviest weight";
+        case "reps-only":
+            return "most reps";
+        case "duration":
+            return "longest hold";
+        case "distance":
+            return "fastest pace";
+        default:
+            return "highest effort";
+    }
+};
+/**
+ * Calculate muscle activation levels
+ */
+const calculateMuscleActivation = (exercise, sets) => {
+    if (sets.length === 0)
+        return { primary: 0, secondary: 0 };
+    const avgScore = sets.reduce((sum, set) => sum + set.scoreBreakdown.finalScore, 0) /
+        sets.length;
+    const maxPossibleScore = 100; // Reference point
+    // Activation based on exercise difficulty and average set score
+    const baseActivation = Math.min(100, (avgScore / maxPossibleScore) * 100);
+    const difficultyBonus = exercise.difficultyLevel * 2; // Up to 20% bonus
+    return {
+        primary: Math.min(100, Math.round(baseActivation + difficultyBonus)),
+        secondary: Math.min(100, Math.round((baseActivation + difficultyBonus) * 0.7)), // 70% of primary
+    };
+};
+/**
+ * Calculate muscle recovery times
+ */
+const calculateMuscleRecovery = (muscleStressMap, exercises) => {
+    const recovery = {};
+    muscleStressMap.forEach((totalStress, muscle) => {
+        // Base recovery time based on muscle group
+        const baseRecovery = getMuscleBaseRecovery(muscle);
+        // Stress level (0-100)
+        const fatigueLevel = Math.min(100, (totalStress / 200) * 100); // 200 = very high stress threshold
+        // Recovery time increases with fatigue level
+        let recoveryHours = baseRecovery;
+        if (fatigueLevel > 80)
+            recoveryHours *= 1.5; // 50% longer for high fatigue
+        else if (fatigueLevel > 60)
+            recoveryHours *= 1.3; // 30% longer for moderate-high fatigue
+        else if (fatigueLevel > 40)
+            recoveryHours *= 1.1; // 10% longer for moderate fatigue
+        // Find exercises that worked this muscle - using indexOf instead of includes
+        const involvedExercises = exercises
+            .filter(({ exercise }) => exercise.primaryMuscles.indexOf(muscle) !==
+            -1 ||
+            exercise.secondaryMuscles.indexOf(muscle) !==
+                -1)
+            .map(({ exercise }) => exercise.name);
+        recovery[muscle] = {
+            fatigueLevel: Math.round(fatigueLevel),
+            recoveryHours: Math.round(recoveryHours),
+            trainingStress: Math.round(totalStress),
+            exercises: involvedExercises,
+        };
+    });
+    return recovery;
+};
+/**
+ * Get base recovery time for different muscle groups
+ */
+const getMuscleBaseRecovery = (muscle) => {
+    // Recovery times in hours based on muscle size and recovery capacity
+    const recoveryTimes = {
+        "pectoralis-major": 48,
+        "pectoralis-minor": 48,
+        "latissimus-dorsi": 48,
+        trapezius: 36,
+        rhomboids: 36,
+        "deltoids-anterior": 36,
+        "deltoids-middle": 36,
+        "bicep-short-inner": 24,
+        "bicep-long-outer": 24,
+        "tricep-brachii-long": 24,
+        "tricep-brachii-lateral": 24,
+        quadriceps: 48,
+        hamstrings: 48,
+        "maximus-lower": 48,
+        "medius-upper": 36,
+        "calf-inner": 24,
+        "calf-outer": 24,
+        "abs-upper": 24,
+        "abs-lower": 24,
+        obliques: 24,
+        "lower-back": 48,
+        "fore-arm-inner": 18,
+        "fore-arm-outer": 18,
+    };
+    return recoveryTimes[muscle] || 36; // Default 36 hours
+};
+/**
+ * Determine overall fatigue level
+ */
+const getFatigueLevel = (averageScore, totalScore, workoutDuration) => {
+    const intensity = averageScore;
+    const volume = totalScore / 100; // Normalize volume
+    const density = totalScore / workoutDuration; // Score per minute
+    if (intensity > 80 || volume > 15 || density > 8)
+        return "extreme";
+    if (intensity > 65 || volume > 12 || density > 6)
+        return "very_hard";
+    if (intensity > 50 || volume > 8 || density > 4)
+        return "hard";
+    if (intensity > 35 || volume > 5 || density > 2)
+        return "moderate";
+    return "light";
+};
+/**
+ * Get recommended rest days based on fatigue
+ */
+const getRecommendedRestDays = (fatigueLevel, muscleRecovery) => {
+    // Base rest days by fatigue level
+    const baseDays = {
+        light: 0,
+        moderate: 1,
+        hard: 1,
+        very_hard: 2,
+        extreme: 3,
+    };
+    const restDays = baseDays[fatigueLevel];
+    // Consider muscle recovery times - using manual iteration instead of Object.values
+    const recoveryHours = [];
+    for (const muscle in muscleRecovery) {
+        if (muscleRecovery.hasOwnProperty(muscle)) {
+            recoveryHours.push(muscleRecovery[muscle].recoveryHours);
+        }
+    }
+    const maxRecoveryHours = recoveryHours.length > 0 ? Math.max.apply(Math, recoveryHours) : 0;
+    const muscleBasedDays = Math.ceil(maxRecoveryHours / 24);
+    return Math.max(restDays, muscleBasedDays);
+};
+/**
+ * Generate user-friendly workout summary text
+ */
+const generateWorkoutSummaryText = (summary) => {
+    const { totalScore, averageScore, totalCalories, totalEpocCalories, workoutDuration, fatigueLevel, recommendedRestDays, exerciseSummaries, } = summary;
+    const intensityMap = {
+        light: "Light workout",
+        moderate: "Moderate workout",
+        hard: "Hard workout",
+        very_hard: "Very hard workout",
+        extreme: "Extreme workout",
+    };
+    const intensityText = intensityMap[fatigueLevel];
+    const restText = recommendedRestDays === 0
+        ? "You can train again tomorrow"
+        : `Recommended rest: ${recommendedRestDays} day${recommendedRestDays > 1 ? "s" : ""}`;
+    return `
+🏋️ **${intensityText}** (Score: ${totalScore})
+⏱️ Duration: ${workoutDuration} minutes
+🔥 Calories: ${totalCalories} + ${totalEpocCalories} afterburn
+📊 Average set intensity: ${averageScore}/100
+
+💪 **Exercises completed:**
+${exerciseSummaries
+        .map((ex) => `• ${ex.exercise.name}: ${ex.sets.length} sets (${Math.round(ex.totalScore)} pts)`)
+        .join("\n")}
+
+🛌 **Recovery:** ${restText}
+  `.trim();
+};
+exports.generateWorkoutSummaryText = generateWorkoutSummaryText;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dgpholdings/greatoak-shared",
-  "version": "1.1.36",
+  "version": "1.1.37",
   "description": "Shared TypeScript types and utilities for @dgpholdings projects",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",