@dgpholdings/greatoak-shared 1.1.49 → 1.1.51

package/dist/typeGuards/index.d.ts

@@ -1,5 +1,6 @@
-import { TRecord, TRecordWeight, TRecordDuration, TRecordBodyWeight, TRecordDistance } from "../types";
+import { TRecord, TRecordWeight, TRecordDuration, TRecordBodyWeight, TRecordCardioFree, TRecordCardioMachine } from "../types";
 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[];
+export declare const isRecordCardioFreeTypeGuard: (param: TRecord[]) => param is TRecordCardioFree[];
+export declare const isRecordCardioMachineTypeGuard: (param: TRecord[]) => param is TRecordCardioMachine[];

package/dist/typeGuards/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRecordDistanceTypeGuard = exports.isRecordBodyWeightTypeGuard = exports.isRecordDurationTypeGuard = exports.isRecordWeightTypeGuard = void 0;
+exports.isRecordCardioMachineTypeGuard = exports.isRecordCardioFreeTypeGuard = 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;
+const isRecordCardioFreeTypeGuard = (param) => param[0].type === "cardio-free";
+exports.isRecordCardioFreeTypeGuard = isRecordCardioFreeTypeGuard;
+const isRecordCardioMachineTypeGuard = (param) => param[0].type === "cardio-machine";
+exports.isRecordCardioMachineTypeGuard = isRecordCardioMachineTypeGuard;

package/dist/types/TApiExercise.d.ts

@@ -61,13 +61,6 @@ export type TTimingGuardrails = TBaseTimingGuardrails & ({
         max: number;
         typical: number;
     };
-} | {
-    type: "distance";
-    pacing: {
-        minPacePerUnit: number;
-        maxPacePerUnit: number;
-        typicalPacePerUnit: number;
-    };
 });
 export type TExercise = {
     exerciseId: string;

package/dist/types/TApiUser.d.ts

@@ -1,7 +1,6 @@
 export type TAuthType = "email" | "apple" | "anonymous";
 export type TGender = "male" | "female" | "unmentioned";
 export type TFitnessGoal = "strength" | "hypertrophy" | "endurance" | "general" | "fat_burn" | "flexibility";
-export type TUserFitnessGoal = "strength" | "hypertrophy" | "endurance" | "general";
 export type TUserMetric = {
     dob: Date;
     weightKg?: number;
@@ -39,7 +38,6 @@ export type TUser = {
     billingPlanType: "monthly" | "annually" | "free";
     billingPlanVersion?: string;
     billingPlanGeoCountryCode: string;
-    fitnessLevel?: number;
     paymentMethod?: "credit_card" | "paypal" | "apple_pay" | "upi";
     billingPlanNextDueDate?: string;
     devices: {
@@ -54,5 +52,6 @@ export type TUser = {
     weightKg?: number;
     heightCm?: number;
     bodyFatPercentage?: number;
-    fitnessGoal: TUserFitnessGoal;
+    fitnessGoal: TFitnessGoal;
+    fitnessLevel: number;
 };

package/dist/types/commonTypes.d.ts

@@ -20,9 +20,13 @@ export type TRecord = {
     auxWeightKg: string;
     rir?: string;
 } | {
-    type: "distance";
+    type: "cardio-machine";
+    speed: string;
+    resistance: string;
+    durationSecs: string;
+} | {
+    type: "cardio-free";
     distanceKm: string;
-    auxWeightKg: string;
     durationSecs: string;
 });
 export type TRecordDuration = Extract<TRecord, {
@@ -34,8 +38,11 @@ export type TRecordWeight = Extract<TRecord, {
 export type TRecordBodyWeight = Extract<TRecord, {
     type: "reps-only";
 }>;
-export type TRecordDistance = Extract<TRecord, {
-    type: "distance";
+export type TRecordCardioFree = Extract<TRecord, {
+    type: "cardio-free";
+}>;
+export type TRecordCardioMachine = Extract<TRecord, {
+    type: "cardio-machine";
 }>;
 export type TTemplateConfig = {
     enableAuxWeight?: boolean;

package/dist/utils/record.utils.d.ts

@@ -2,7 +2,6 @@ import { TRecord } from "../types";
 type RefinedBase = {
     isDone: boolean;
     rpe?: number;
-    rir?: number;
     workDurationSecs?: number;
     restDurationSecs?: number;
     setNote?: string;
@@ -12,24 +11,33 @@ export type TRefinedWeightRecord = RefinedBase & {
     type: "weight-reps";
     kg: number;
     reps: number;
+    rir?: number;
 };
 export type TRefinedDurationRecord = RefinedBase & {
     type: "duration";
     durationSecs: number;
-    auxWeightKg?: number;
+    auxWeightKg: number;
 };
 export type TRefinedBodyWeightRecord = RefinedBase & {
     type: "reps-only";
     reps: number;
-    auxWeightKg?: number;
+    auxWeightKg: number;
+    rir?: number;
+};
+export type TRefinedCardioMachineRecord = RefinedBase & {
+    type: "cardio-machine";
+    speed: number;
+    resistance: number;
+    durationSecs: number;
+    intensityScore?: number;
 };
-export type TRefinedDistanceRecord = RefinedBase & {
-    type: "distance";
+export type TRefinedCardioFreeRecord = RefinedBase & {
+    type: "cardio-free";
     distanceKm: number;
-    auxWeightKg?: number;
     durationSecs: number;
     avgPaceSecsPerKm?: number;
+    avgSpeedKmh?: number;
 };
-export type TRefinedRecord = TRefinedWeightRecord | TRefinedDurationRecord | TRefinedBodyWeightRecord | TRefinedDistanceRecord;
+export type TRefinedRecord = TRefinedWeightRecord | TRefinedDurationRecord | TRefinedBodyWeightRecord | TRefinedCardioMachineRecord | TRefinedCardioFreeRecord;
 export declare const refineRecordEntry: (entry: TRecord) => TRefinedRecord;
 export {};

package/dist/utils/record.utils.js

@@ -4,40 +4,48 @@ exports.refineRecordEntry = void 0;
 const isDefined_utils_1 = require("./isDefined.utils");
 const number_util_1 = require("./number.util");
 const refineRecordEntry = (entry) => {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     const base = Object.assign(Object.assign(Object.assign(Object.assign({ isDone: entry.isDone, isStrictMode: entry.isStrictMode }, ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.rpe)) && { rpe: (0, number_util_1.toNumber)(entry.rpe) })), ((0, isDefined_utils_1.isDefinedNumber)(entry.workDurationSecs) && {
         workDurationSecs: entry.workDurationSecs,
     })), ((0, isDefined_utils_1.isDefinedNumber)(entry.restDurationSecs) && {
         restDurationSecs: entry.restDurationSecs,
     })), ((0, isDefined_utils_1.isDefined)(entry.setNote) && { setNote: entry.setNote }));
     if (entry.type === "weight-reps") {
-        return Object.assign(Object.assign({}, base), { type: "weight-reps", kg: (_a = (0, number_util_1.toNumber)(entry.kg)) !== null && _a !== void 0 ? _a : 0, rir: (0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.rir))
+        return Object.assign(Object.assign({}, base), { type: "weight-reps", kg: (_a = (0, number_util_1.toNumber)(entry.kg)) !== null && _a !== void 0 ? _a : 0, reps: (_b = (0, number_util_1.toNumber)(entry.reps)) !== null && _b !== void 0 ? _b : 0, rir: (0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.rir))
                 ? (0, number_util_1.toNumber)(entry.rir)
-                : undefined, reps: (_b = (0, number_util_1.toNumber)(entry.reps)) !== null && _b !== void 0 ? _b : 0 });
+                : undefined });
     }
     if (entry.type === "duration") {
-        return Object.assign(Object.assign(Object.assign({}, base), { type: "duration", durationSecs: (_c = (0, number_util_1.toNumber)(entry.durationSecs)) !== null && _c !== void 0 ? _c : 0 }), ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.auxWeightKg)) && {
-            auxWeightKg: (0, number_util_1.toNumber)(entry.auxWeightKg),
-        }));
+        return Object.assign(Object.assign({}, base), { type: "duration", durationSecs: (_c = (0, number_util_1.toNumber)(entry.durationSecs)) !== null && _c !== void 0 ? _c : 0, auxWeightKg: (_d = (0, number_util_1.toNumber)(entry.auxWeightKg)) !== null && _d !== void 0 ? _d : 0 });
     }
     if (entry.type === "reps-only") {
-        return Object.assign(Object.assign(Object.assign({}, base), { type: "reps-only", rir: (0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.rir))
+        return Object.assign(Object.assign({}, base), { type: "reps-only", reps: (_e = (0, number_util_1.toNumber)(entry.reps)) !== null && _e !== void 0 ? _e : 0, auxWeightKg: (_f = (0, number_util_1.toNumber)(entry.auxWeightKg)) !== null && _f !== void 0 ? _f : 0, rir: (0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.rir))
                 ? (0, number_util_1.toNumber)(entry.rir)
-                : undefined, reps: (_d = (0, number_util_1.toNumber)(entry.reps)) !== null && _d !== void 0 ? _d : 0 }), ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.auxWeightKg)) && {
-            auxWeightKg: (0, number_util_1.toNumber)(entry.auxWeightKg),
-        }));
+                : undefined });
     }
-    if (entry.type === "distance") {
-        const distanceKm = (_e = (0, number_util_1.toNumber)(entry.distanceKm)) !== null && _e !== void 0 ? _e : 0;
-        const durationSecs = (_f = (0, number_util_1.toNumber)(entry.durationSecs)) !== null && _f !== void 0 ? _f : 0;
-        // Calculate pace if both distance and duration are provided
+    if (entry.type === "cardio-machine") {
+        const speed = (_g = (0, number_util_1.toNumber)(entry.speed)) !== null && _g !== void 0 ? _g : 0;
+        const resistance = (_h = (0, number_util_1.toNumber)(entry.resistance)) !== null && _h !== void 0 ? _h : 0;
+        const durationSecs = (_j = (0, number_util_1.toNumber)(entry.durationSecs)) !== null && _j !== void 0 ? _j : 0;
+        // Calculate intensity score for progress tracking
+        const intensityScore = speed > 0 && resistance > 0 ? speed * resistance : undefined;
+        return Object.assign(Object.assign(Object.assign({}, base), { type: "cardio-machine", speed,
+            resistance,
+            durationSecs }), ((0, isDefined_utils_1.isDefinedNumber)(intensityScore) && { intensityScore }));
+    }
+    if (entry.type === "cardio-free") {
+        const distanceKm = (_k = (0, number_util_1.toNumber)(entry.distanceKm)) !== null && _k !== void 0 ? _k : 0;
+        const durationSecs = (_l = (0, number_util_1.toNumber)(entry.durationSecs)) !== null && _l !== void 0 ? _l : 0;
+        // Calculate pace (seconds per km)
         const avgPaceSecsPerKm = distanceKm > 0 && durationSecs > 0
             ? durationSecs / distanceKm
             : undefined;
-        return Object.assign(Object.assign(Object.assign(Object.assign({}, base), { type: "distance", distanceKm,
-            durationSecs }), ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.auxWeightKg)) && {
-            auxWeightKg: (0, number_util_1.toNumber)(entry.auxWeightKg),
-        })), ((0, isDefined_utils_1.isDefinedNumber)(avgPaceSecsPerKm) && { avgPaceSecsPerKm }));
+        // Calculate average speed (km/h)
+        const avgSpeedKmh = distanceKm > 0 && durationSecs > 0
+            ? distanceKm / (durationSecs / 3600)
+            : undefined;
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, base), { type: "cardio-free", distanceKm,
+            durationSecs }), ((0, isDefined_utils_1.isDefinedNumber)(avgPaceSecsPerKm) && { avgPaceSecsPerKm })), ((0, isDefined_utils_1.isDefinedNumber)(avgSpeedKmh) && { avgSpeedKmh }));
     }
     throw new Error(`Unknown record type: ${entry.type}`);
 };

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

@@ -1,5 +1,5 @@
 import { TRefinedRecord } from "./record.utils";
-import { TExercise, TGender, TUserFitnessGoal, TUserMetric } from "../types";
+import { TExercise, TGender, TFitnessGoal, TUserMetric } from "../types";
 export type TUserProfile = {
     age?: number;
     gender?: TGender;
@@ -7,7 +7,7 @@ export type TUserProfile = {
     heightCm?: number;
     bodyFatPercentage?: number;
     fitnessLevel?: TUserMetric["fitnessLevel"];
-    fitnessGoal?: TUserFitnessGoal;
+    fitnessGoal?: TFitnessGoal;
 };
 export type TScoreBreakdown = {
     baseScore: number;

package/dist/utils/scoring.utils.js

@@ -1,6 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeScoreFromRecord = void 0;
+/**
+ * GIST: Advanced Exercise Scoring Algorithm
+ *
+ * This function calculates a comprehensive score for a single exercise set using metabolic science,
+ * user personalization, and exercise characteristics. The algorithm:
+ *
+ * 🔬 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
+ *
+ * 👤 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)
+ *
+ * 🏋️ 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
+ *
+ * 📊 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
+ *
+ * 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
  */
@@ -28,7 +58,7 @@ const calculateBMR = (userProfile) => {
  * Calculate precise MET value using exercise metabolic data
  */
 const calculateMETValue = (record, exercise, effortFactor, userProfile) => {
-    var _a, _b, _c;
+    var _a, _b;
     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;
@@ -85,11 +115,27 @@ const calculateMETValue = (record, exercise, effortFactor, userProfile) => {
             }
             break;
         }
-        case "distance": {
-            const distance = (_c = record.distanceKm) !== null && _c !== void 0 ? _c : 0;
+        case "cardio-machine": {
+            const speed = record.speed;
+            const resistance = record.resistance;
             const durationSecs = record.durationSecs;
-            if (distance > 0 && durationSecs > 0 && metabolicData.paceFactors) {
-                const speedKmh = (distance * 3600) / 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;
+        }
+        case "cardio-free": {
+            const distanceKm = record.distanceKm;
+            const durationSecs = record.durationSecs;
+            if (distanceKm > 0 && durationSecs > 0 && metabolicData.paceFactors) {
+                const speedKmh = (distanceKm * 3600) / durationSecs;
                 // Find closest pace factor
                 let closestMET = metabolicData.baseMET;
                 let closestSpeed = Infinity;
@@ -183,7 +229,8 @@ const getExerciseDurationMinutes = (record, exercise) => {
                 }
                 break;
             }
-            case "distance": {
+            case "cardio-machine":
+            case "cardio-free": {
                 if (record.workDurationSecs && record.isStrictMode) {
                     durationSecs = record.workDurationSecs;
                 }
@@ -194,8 +241,10 @@ const getExerciseDurationMinutes = (record, exercise) => {
             }
         }
     }
-    // Add rest time if available (but not for distance exercises)
-    if (record.type !== "distance" && record.restDurationSecs) {
+    // 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);
@@ -253,15 +302,11 @@ const calculateTimingAdherence = (record, exercise, workingScore) => {
             }
             break;
         }
-        case "distance": {
-            if (timingGuardrails.type === "distance" &&
-                timingGuardrails.pacing &&
-                record.distanceKm) {
-                expectedDuration =
-                    record.distanceKm * timingGuardrails.pacing.typicalPacePerUnit;
-                tolerance = expectedDuration * 0.2; // 20% tolerance for distance
-            }
-            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) {
@@ -312,7 +357,7 @@ const computeScoreFromRecord = ({ avgRestDurationSecs, record, exercise, userPro
     if (typeof record.rpe === "number") {
         effortFactor = Math.max(1, Math.min(10, record.rpe));
     }
-    else if (typeof record.rir === "number") {
+    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
@@ -331,18 +376,28 @@ const computeScoreFromRecord = ({ avgRestDurationSecs, record, exercise, userPro
     plus.push({
         exerciseDifficulty: parseFloat((difficultyMultiplier - 1).toFixed(3)),
     });
-    // Goal alignment bonus
+    // ENHANCED Goal alignment bonus
     if (userProfile === null || userProfile === void 0 ? void 0 : userProfile.fitnessGoal) {
         let goalMultiplier = 1;
-        switch (userProfile.fitnessGoal) {
+        const goal = userProfile.fitnessGoal;
+        switch (goal) {
             case "strength":
-                goalMultiplier = 1 + (exercise.strengthGainLevel / 10) * 0.12;
+                goalMultiplier = 1 + (exercise.strengthGainLevel / 10) * 0.15; // Increased from 0.12
                 break;
             case "hypertrophy":
-                goalMultiplier = 1 + (exercise.hypertrophyLevel / 10) * 0.12;
+                goalMultiplier = 1 + (exercise.hypertrophyLevel / 10) * 0.15;
                 break;
             case "endurance":
-                goalMultiplier = 1 + (exercise.enduranceLevel / 10) * 0.12;
+                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 +
@@ -350,7 +405,7 @@ const computeScoreFromRecord = ({ avgRestDurationSecs, record, exercise, userPro
                     exercise.enduranceLevel +
                     exercise.flexibilityLevel) /
                     4;
-                goalMultiplier = 1 + (avgLevel / 10) * 0.08;
+                goalMultiplier = 1 + (avgLevel / 10) * 0.1;
                 break;
         }
         if (goalMultiplier > 1) {

package/dist/utils/workoutSummary.util.js

@@ -109,7 +109,7 @@ exports.calculateWorkoutSummary = calculateWorkoutSummary;
 const generateSetDescription = (record, exercise, scoreBreakdown) => {
     const effort = record.rpe
         ? `RPE ${record.rpe}`
-        : record.rir
+        : "rir" in record && record.rir
             ? `${record.rir} RIR`
             : "";
     const calories = `${Math.round(scoreBreakdown.caloriesBurned)} cal`;
@@ -123,16 +123,34 @@ const generateSetDescription = (record, exercise, scoreBreakdown) => {
             const auxWeightDur = record.auxWeightKg
                 ? ` (+${record.auxWeightKg}kg)`
                 : "";
-            return `${record.durationSecs}${auxWeightDur} ${effort} • ${calories}`;
-        case "distance":
+            const minutes = Math.floor(record.durationSecs / 60);
+            const seconds = record.durationSecs % 60;
+            const timeStr = minutes > 0
+                ? `${minutes}:${seconds < 10 ? `0${seconds}` : `${seconds}`}`
+                : `${seconds}s`;
+            return `${timeStr}${auxWeightDur} ${effort} • ${calories}`;
+        case "cardio-machine":
+            const resistance = record.resistance > 0 ? ` R${record.resistance}` : "";
+            const minutes_cm = Math.floor(record.durationSecs / 60);
+            const seconds_cm = record.durationSecs % 60;
+            const timeStr_cm = minutes_cm > 0
+                ? `${minutes_cm}:${seconds_cm < 10 ? `0${seconds_cm}` : `${seconds_cm}`}`
+                : `${seconds_cm}s`;
+            return `${record.speed} speed${resistance} × ${timeStr_cm} ${effort} • ${calories}`;
+        case "cardio-free":
+            const minutes_cf = Math.floor(record.durationSecs / 60);
+            const seconds_cf = record.durationSecs % 60;
+            const timeStr_cf = minutes_cf > 0
+                ? `${minutes_cf}:${seconds_cf < 10 ? `0${seconds_cf}` : `${seconds_cf}`}`
+                : `${seconds_cf}s`;
             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)`;
+            if ("avgPaceSecsPerKm" in record && record.avgPaceSecsPerKm) {
+                const paceMinutes = Math.floor(record.avgPaceSecsPerKm / 60);
+                const paceSeconds = Math.round(record.avgPaceSecsPerKm % 60);
+                const paceSecondsFormatted = paceSeconds < 10 ? `0${paceSeconds}` : `${paceSeconds}`;
+                pace = ` (${paceMinutes}:${paceSecondsFormatted}/km)`;
             }
-            return `${record.distanceKm}km in ${record.durationSecs}${pace} ${effort} • ${calories}`;
+            return `${record.distanceKm}km in ${timeStr_cf}${pace} ${effort} • ${calories}`;
         default:
             return `${effort} • ${calories}`;
     }
@@ -148,7 +166,9 @@ const getBestSetReason = (record, exercise) => {
             return "most reps";
         case "duration":
             return "longest hold";
-        case "distance":
+        case "cardio-machine":
+            return "highest intensity";
+        case "cardio-free":
             return "fastest pace";
         default:
             return "highest effort";
@@ -189,13 +209,30 @@ const calculateMuscleRecovery = (muscleStressMap, exercises) => {
             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);
+        // Find exercises that worked this muscle - using manual search instead of includes
+        const involvedExercises = [];
+        exercises.forEach(({ exercise }) => {
+            let found = false;
+            // Check primary muscles
+            for (let i = 0; i < exercise.primaryMuscles.length; i++) {
+                if (exercise.primaryMuscles[i] === muscle) {
+                    found = true;
+                    break;
+                }
+            }
+            // Check secondary muscles if not found in primary
+            if (!found) {
+                for (let i = 0; i < exercise.secondaryMuscles.length; i++) {
+                    if (exercise.secondaryMuscles[i] === muscle) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (found) {
+                involvedExercises.push(exercise.name);
+            }
+        });
         recovery[muscle] = {
             fatigueLevel: Math.round(fatigueLevel),
             recoveryHours: Math.round(recoveryHours),
@@ -270,14 +307,19 @@ const getRecommendedRestDays = (fatigueLevel, muscleRecovery) => {
         extreme: 3,
     };
     const restDays = baseDays[fatigueLevel];
-    // Consider muscle recovery times - using manual iteration instead of Object.values
+    // Consider muscle recovery times - using manual iteration
     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;
+    let maxRecoveryHours = 0;
+    for (let i = 0; i < recoveryHours.length; i++) {
+        if (recoveryHours[i] > maxRecoveryHours) {
+            maxRecoveryHours = recoveryHours[i];
+        }
+    }
     const muscleBasedDays = Math.ceil(maxRecoveryHours / 24);
     return Math.max(restDays, muscleBasedDays);
 };

package/package.json

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