@dgpholdings/greatoak-shared 1.1.41 → 1.1.43

package/dist/types/TApiExercise.d.ts

@@ -29,6 +29,46 @@ export declare enum EBodyParts {
 }
 export type TBodyPartKeys = Array<keyof typeof EBodyParts>;
 export type TTrainingType = "band" | "body-weight" | "weight" | "yoga" | "cardio" | "stretching" | "plyometric" | "sports-specific" | "rehabilitation" | "balance" | "isometric";
+type TBaseTimingGuardrails = {
+    stressRestBonus: number;
+    fatigueMultiplier: number;
+    setupTypicalSecs: number;
+    restPeriods: {
+        minimum: number;
+        typical: number;
+        maximum: number;
+        optimalRange: [number, number];
+    };
+};
+export type TTimingGuardrails = TBaseTimingGuardrails & ({
+    type: "weight-reps";
+    singleRep: {
+        min: number;
+        max: number;
+        typical: number;
+    };
+} | {
+    type: "reps-only";
+    singleRep: {
+        min: number;
+        max: number;
+        typical: number;
+    };
+} | {
+    type: "duration";
+    setDuration: {
+        min: number;
+        max: number;
+        typical: number;
+    };
+} | {
+    type: "distance";
+    pacing: {
+        minPacePerUnit: number;
+        maxPacePerUnit: number;
+        typicalPacePerUnit: number;
+    };
+});
 export type TExercise = {
     exerciseId: string;
     name: string;
@@ -38,7 +78,7 @@ export type TExercise = {
     primaryMuscles: TBodyPartKeys;
     secondaryMuscles: TBodyPartKeys;
     trainingTypes: TTrainingType[];
-    avgSingleRepDurationInSecs?: number;
+    timingGuardrails?: TTimingGuardrails;
     difficultyLevel: number;
     hypertrophyLevel: number;
     strengthGainLevel: number;
@@ -81,10 +121,11 @@ export type TExercise = {
     importantTipsHtml: string;
 };
 export type TBodyPartExercises = Record<TBodyPart, TExercise[]>;
-export type TApiCreateExerciseReq = {
+export type TApiCreateOrUpdateExerciseReq = {
     exercise: Omit<TExercise, "exerciseId">;
+    updateId?: string;
 };
-export type TApiCreateExerciseRes = {
+export type TApiCreateOrUpdateExerciseRes = {
     success: boolean;
     message: string;
 };
@@ -92,3 +133,4 @@ export type TApiListExercisesReq = null;
 export type TApiListExercisesRes = {
     data: TExercise[];
 };
+export {};

package/dist/types/TApiExerciseRecord.d.ts

@@ -4,6 +4,7 @@ export type TRecord = {
     setNote?: string;
     workDurationSecs?: number;
     restDurationSecs?: number;
+    isStrictMode: boolean;
 } & ({
     type: "weight-reps";
     kg: string;
@@ -21,8 +22,8 @@ export type TRecord = {
 } | {
     type: "distance";
     distanceKm: string;
+    auxWeightKg: string;
     durationSecs: string;
-    avgPaceSecsPerKm?: string;
 });
 export type TRecordDuration = Extract<TRecord, {
     type: "duration";

package/dist/types/TApiTemplateData.d.ts

@@ -6,6 +6,10 @@ export type TTemplate = {
     exerciseIds: string[];
     lastUsed?: Date[];
     createdAt?: string;
+    colorHex?: string;
+    config: {
+        isEnabledStrictDurationTrackingMode: boolean;
+    };
 };
 export type TTemplateExercise = {
     template: TTemplate;
@@ -40,7 +44,6 @@ export type TApiTemplateUpdateRes = {
 export type TExerciseLatestRecord = {
     recordDate: Date;
     exerciseNote?: string;
-    restTimeSecs?: number;
     score: number;
     records: {
         kg?: Extract<TRecord, {
@@ -63,10 +66,16 @@ export type TExerciseLatestRecord = {
             type: "weight-reps";
         }>["rir"];
         setNote?: TRecord["setNote"];
+        distanceKm?: Extract<TRecord, {
+            type: "distance";
+        }>["distanceKm"];
+        isStrictMode: TRecord["isStrictMode"];
+        workDurationSecs?: number;
+        restDurationSecs?: number;
     }[];
     config: {
         enableAuxWeight: boolean;
-        enableRestTime: boolean;
+        enableTimeIntervalMode: boolean;
         enableSetNote: boolean;
         enableExerciseNote: boolean;
         enableEffort: "rir" | "rpe" | "none";

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

@@ -6,6 +6,7 @@ type RefinedBase = {
     workDurationSecs?: number;
     restDurationSecs?: number;
     setNote?: string;
+    isStrictMode: boolean;
 };
 export type TRefinedWeightRecord = RefinedBase & {
     type: "weight-reps";
@@ -14,7 +15,7 @@ export type TRefinedWeightRecord = RefinedBase & {
 };
 export type TRefinedDurationRecord = RefinedBase & {
     type: "duration";
-    durationSecs: string;
+    durationSecs: number;
     auxWeightKg?: number;
 };
 export type TRefinedBodyWeightRecord = RefinedBase & {
@@ -25,7 +26,8 @@ export type TRefinedBodyWeightRecord = RefinedBase & {
 export type TRefinedDistanceRecord = RefinedBase & {
     type: "distance";
     distanceKm: number;
-    durationSecs: string;
+    auxWeightKg?: number;
+    durationSecs: number;
     avgPaceSecsPerKm?: number;
 };
 export type TRefinedRecord = TRefinedWeightRecord | TRefinedDurationRecord | TRefinedBodyWeightRecord | TRefinedDistanceRecord;

package/dist/utils/record.utils.js

@@ -4,8 +4,8 @@ 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;
-    const base = Object.assign(Object.assign(Object.assign(Object.assign({ isDone: entry.isDone }, ((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) && {
+    var _a, _b, _c, _d, _e, _f;
+    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,
@@ -16,25 +16,28 @@ const refineRecordEntry = (entry) => {
                 : undefined, reps: (_b = (0, number_util_1.toNumber)(entry.reps)) !== null && _b !== void 0 ? _b : 0 });
     }
     if (entry.type === "duration") {
-        return Object.assign(Object.assign(Object.assign({}, base), { type: "duration", durationSecs: entry.durationSecs }), ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.auxWeightKg)) && {
+        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),
         }));
     }
     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))
                 ? (0, number_util_1.toNumber)(entry.rir)
-                : undefined, reps: (_c = (0, number_util_1.toNumber)(entry.reps)) !== null && _c !== void 0 ? _c : 0 }), ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.auxWeightKg)) && {
+                : 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),
         }));
     }
     if (entry.type === "distance") {
-        const distanceKm = (_d = (0, number_util_1.toNumber)(entry.distanceKm)) !== null && _d !== void 0 ? _d : 0;
-        const durationSecs = (_e = (0, number_util_1.toNumber)(entry.durationSecs)) !== null && _e !== void 0 ? _e : 0;
+        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
         const avgPaceSecsPerKm = distanceKm > 0 && durationSecs > 0
             ? durationSecs / distanceKm
             : undefined;
-        return Object.assign(Object.assign(Object.assign({}, base), { type: "distance", distanceKm, durationSecs: entry.durationSecs }), ((0, isDefined_utils_1.isDefinedNumber)(avgPaceSecsPerKm) && { avgPaceSecsPerKm }));
+        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 }));
     }
     throw new Error(`Unknown record type: ${entry.type}`);
 };

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

@@ -30,7 +30,7 @@ type TParams = {
     isTimeIntervalModeEnabled?: boolean;
 };
 /**
- * Enhanced training stress score computation using metabolic data
+ * 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
  */

package/dist/utils/scoring.utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeScoreFromRecord = void 0;
-const time_util_1 = require("./time.util");
 /**
  * Calculate BMR using Mifflin-St Jeor Equation with body composition adjustment
  */
@@ -29,7 +28,7 @@ const calculateBMR = (userProfile) => {
  * Calculate precise MET value using exercise metabolic data
  */
 const calculateMETValue = (record, exercise, effortFactor, userProfile) => {
-    var _a, _b, _c, _d, _e;
+    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;
@@ -73,7 +72,7 @@ const calculateMETValue = (record, exercise, effortFactor, userProfile) => {
             break;
         }
         case "duration": {
-            const durationSecs = (0, time_util_1.mmssToSecs)((_c = record.durationSecs) !== null && _c !== void 0 ? _c : "00:00");
+            const durationSecs = record.durationSecs;
             if (metabolicData.durationFactors) {
                 let durationMultiplier = metabolicData.durationFactors.mediumDuration;
                 if (durationSecs < 30) {
@@ -87,8 +86,8 @@ const calculateMETValue = (record, exercise, effortFactor, userProfile) => {
             break;
         }
         case "distance": {
-            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");
+            const distance = (_c = record.distanceKm) !== null && _c !== void 0 ? _c : 0;
+            const durationSecs = record.durationSecs;
             if (distance > 0 && durationSecs > 0 && metabolicData.paceFactors) {
                 const speedKmh = (distance * 3600) / durationSecs;
                 // Find closest pace factor
@@ -146,32 +145,53 @@ const getRepIntensityAdjustment = (reps, scalingType) => {
     }
 };
 /**
- * Calculate exercise duration in minutes
+ * Calculate exercise duration in minutes using timing guardrails
  */
 const getExerciseDurationMinutes = (record, exercise) => {
-    var _a, _b;
     let durationSecs = 0;
-    switch (record.type) {
-        case "weight-reps":
-        case "reps-only": {
-            if (exercise.avgSingleRepDurationInSecs) {
-                durationSecs = record.reps * exercise.avgSingleRepDurationInSecs;
+    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;
+                }
+                break;
             }
-            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;
+            case "duration": {
+                if (record.workDurationSecs && record.isStrictMode) {
+                    durationSecs = record.workDurationSecs;
+                }
+                else {
+                    durationSecs = record.durationSecs;
+                }
+                break;
+            }
+            case "distance": {
+                if (record.workDurationSecs && record.isStrictMode) {
+                    durationSecs = record.workDurationSecs;
+                }
+                else {
+                    durationSecs = record.durationSecs;
+                }
+                break;
             }
-            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)
@@ -203,12 +223,77 @@ const calculateCalorieBurn = (record, exercise, metValue, durationMinutes, userP
     };
 };
 /**
- * Enhanced training stress score computation using metabolic data
+ * 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
+            }
+            break;
+        }
+        case "duration": {
+            if (timingGuardrails.type === "duration" &&
+                timingGuardrails.setDuration) {
+                expectedDuration = record.durationSecs;
+                tolerance = timingGuardrails.setDuration.typical * 0.15; // 15% tolerance for duration exercises
+            }
+            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;
+        }
+    }
+    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, _b;
+    var _a;
     if (!record.isDone) {
         return {
             baseScore: 0,
@@ -232,7 +317,7 @@ const computeScoreFromRecord = ({ avgRestDurationSecs, record, exercise, userPro
     }
     // Calculate precise MET value using exercise metabolic data
     const metValue = calculateMETValue(record, exercise, effortFactor, userProfile || {});
-    // Calculate exercise duration
+    // Calculate exercise duration using timing guardrails
     const durationMinutes = getExerciseDurationMinutes(record, exercise);
     // Calculate comprehensive calorie burn
     const calorieData = calculateCalorieBurn(record, exercise, metValue, durationMinutes, userProfile || {});
@@ -294,6 +379,20 @@ const computeScoreFromRecord = ({ avgRestDurationSecs, record, exercise, userPro
             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") {
@@ -315,43 +414,25 @@ const computeScoreFromRecord = ({ avgRestDurationSecs, record, exercise, userPro
             profileAdjustment: parseFloat((profileMultiplier - 1).toFixed(3)),
         });
     }
-    // Enhanced rest efficiency penalty
+    // Enhanced rest efficiency penalty using timing guardrails
     if (typeof record.restDurationSecs === "number" &&
-        typeof avgRestDurationSecs === "number") {
+        typeof avgRestDurationSecs === "number" &&
+        ((_a = exercise.timingGuardrails) === null || _a === void 0 ? void 0 : _a.restPeriods)) {
         const restUsed = record.restDurationSecs;
-        const baseGrace = 8 + exercise.difficultyLevel * 1.5; // More grace for complex exercises
-        const effortGrace = effortFactor * 2.5;
-        const totalGrace = baseGrace + effortGrace;
-        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.12 * workingScore; // Reduced penalty
-            workingScore -= restPenalty;
-            minus.push({ excessRestPenalty: parseFloat(restPenalty.toFixed(3)) });
-        }
-    }
-    // Work duration adherence for interval training
-    if (isTimeIntervalModeEnabled && record.workDurationSecs) {
-        let actualDuration = 0;
-        if (record.type === "duration") {
-            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)((_b = record.durationSecs) !== null && _b !== void 0 ? _b : "00:00");
-        }
-        if (actualDuration > 0) {
-            const expectedDuration = exercise.avgSingleRepDurationInSecs || record.workDurationSecs;
-            const durationDiff = Math.abs(actualDuration - expectedDuration);
-            const tolerance = expectedDuration * 0.25; // 25% tolerance
-            if (durationDiff > tolerance) {
-                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)),
-                });
+        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)) });
             }
         }
     }

package/dist/utils/workoutSummary.util.js

@@ -88,7 +88,7 @@ const calculateWorkoutSummary = (exercises, userProfile) => {
     const muscleRecovery = calculateMuscleRecovery(muscleStressMap, exercises);
     // Determine overall fatigue level
     const averageScore = totalSets > 0 ? totalScore / totalSets : 0;
-    const fatigueLevel = getFatigueLevel(averageScore, totalScore, workoutDuration);
+    const fatigueLevel = getFatigueLevel(averageScore, totalScore, workoutDuration, userProfile);
     const recommendedRestDays = getRecommendedRestDays(fatigueLevel, muscleRecovery);
     return {
         totalScore: Math.round(totalScore),
@@ -240,8 +240,11 @@ const getMuscleBaseRecovery = (muscle) => {
 /**
  * Determine overall fatigue level
  */
-const getFatigueLevel = (averageScore, totalScore, workoutDuration) => {
-    const intensity = averageScore;
+const getFatigueLevel = (averageScore, totalScore, workoutDuration, userProfile) => {
+    const fitnessAdjustment = (userProfile === null || userProfile === void 0 ? void 0 : userProfile.fitnessLevel)
+        ? (userProfile.fitnessLevel - 3) * 0.1 // ±20% based on fitness level
+        : 0;
+    const intensity = averageScore * (1 - fitnessAdjustment);
     const volume = totalScore / 100; // Normalize volume
     const density = totalScore / workoutDuration; // Score per minute
     if (intensity > 80 || volume > 15 || density > 8)

package/package.json

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