@jjlmoya/utils-health 1.46.0 → 1.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-health",
-    "version": "1.46.0",
+    "version": "1.47.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -35,10 +35,11 @@ import { creatinineClearanceCockcroftGault } from '../tool/creatinineClearanceCo
 import { correctedCalciumCalculator } from '../tool/correctedCalciumCalculator/entry';
 import { egfrCalculator } from '../tool/egfrCalculator/entry';
 import { bmrCalorieDeficitPlanner } from '../tool/bmrCalorieDeficitPlanner/entry';
+import { targetHeartRateZonePlanner } from '../tool/targetHeartRateZonePlanner/entry';
 
 export const healthCategory: HealthCategoryEntry = {
   icon: 'mdi:heart-pulse',
-  tools: [bmiCalculator, amputationAdjustedBmiCalculator, bodyAdiposityIndexCalculator, bodyFatPercentageCalculator, waistHipRatioCalculator, waistHeightRatioCalculator, leanBodyMassCalculator, metabolicAgeCalculator, caloricDeficitCalculator, dailyProteinCalculator, macronutrientCalculator, tdeeCalculator, bunCreatinineCalculator, serumOsmolalityCalculator, meanArterialPressureCalculator, correctedSodiumHyperglycemiaCalculator, fractionalExcretionSodiumCalculator, correctedReticulocyteIndex, estimatedBloodVolumeCalculator, anionGapCalculator, creatinineClearanceCockcroftGault, correctedCalciumCalculator, egfrCalculator, targetHeightEstimator, daltonismSimulator, tinnitusReliever, parametricNoiseSynthesizer, breathingVisualizer, caffeineTracker, waterPurifier, digestionStopwatch, binauralTuner, pelliRobsonTest, peripheralVisionTrainer, epworthSleepinessScale, bmrCalorieDeficitPlanner],
+  tools: [bmiCalculator, amputationAdjustedBmiCalculator, bodyAdiposityIndexCalculator, bodyFatPercentageCalculator, waistHipRatioCalculator, waistHeightRatioCalculator, leanBodyMassCalculator, metabolicAgeCalculator, caloricDeficitCalculator, dailyProteinCalculator, macronutrientCalculator, tdeeCalculator, bunCreatinineCalculator, serumOsmolalityCalculator, meanArterialPressureCalculator, correctedSodiumHyperglycemiaCalculator, fractionalExcretionSodiumCalculator, correctedReticulocyteIndex, estimatedBloodVolumeCalculator, anionGapCalculator, creatinineClearanceCockcroftGault, correctedCalciumCalculator, egfrCalculator, targetHeightEstimator, daltonismSimulator, tinnitusReliever, parametricNoiseSynthesizer, breathingVisualizer, caffeineTracker, waterPurifier, digestionStopwatch, binauralTuner, pelliRobsonTest, peripheralVisionTrainer, epworthSleepinessScale, bmrCalorieDeficitPlanner, targetHeartRateZonePlanner],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -32,6 +32,7 @@ export { correctedCalciumCalculator } from './tool/correctedCalciumCalculator/en
 export { egfrCalculator } from './tool/egfrCalculator/entry';
 export { sleepDebtRecoveryPlanner } from './tool/sleepDebtRecoveryPlanner/entry';
 export { bmrCalorieDeficitPlanner } from './tool/bmrCalorieDeficitPlanner/entry';
+export { targetHeartRateZonePlanner } from './tool/targetHeartRateZonePlanner/entry';
 export { pelliRobsonTest } from './tool/pelliRobsonTest/entry';
 export { peripheralVisionTrainer } from './tool/peripheralVisionTrainer/entry';
 export { readingDistanceCalculator } from './tool/readingDistanceCalculator/entry';
@@ -75,6 +76,7 @@ import { correctedCalciumCalculator } from './tool/correctedCalciumCalculator/en
 import { egfrCalculator } from './tool/egfrCalculator/entry';
 import { sleepDebtRecoveryPlanner } from './tool/sleepDebtRecoveryPlanner/entry';
 import { bmrCalorieDeficitPlanner } from './tool/bmrCalorieDeficitPlanner/entry';
+import { targetHeartRateZonePlanner } from './tool/targetHeartRateZonePlanner/entry';
 import { pelliRobsonTest } from './tool/pelliRobsonTest/entry';
 import { peripheralVisionTrainer } from './tool/peripheralVisionTrainer/entry';
 import { readingDistanceCalculator } from './tool/readingDistanceCalculator/entry';
@@ -83,4 +85,4 @@ import { tinnitusReliever } from './tool/tinnitusReliever/entry';
 import { parametricNoiseSynthesizer } from './tool/parametricNoiseSynthesizer/entry';
 import { ubeCalculator } from './tool/ubeCalculator/entry';
 import { waterPurifier } from './tool/waterPurifier/entry';
-export const ALL_ENTRIES = [binauralTuner, bloodUnitConverter, bmiCalculator, amputationAdjustedBmiCalculator, bodyAdiposityIndexCalculator, bodyFatPercentageCalculator, waistHipRatioCalculator, waistHeightRatioCalculator, breathingVisualizer, caffeineTracker, caloricDeficitCalculator, dailyProteinCalculator, macronutrientCalculator, tdeeCalculator, bunCreatinineCalculator, serumOsmolalityCalculator, meanArterialPressureCalculator, correctedSodiumHyperglycemiaCalculator, fractionalExcretionSodiumCalculator, correctedReticulocyteIndex, estimatedBloodVolumeCalculator, anionGapCalculator, creatinineClearanceCockcroftGault, correctedCalciumCalculator, egfrCalculator, targetHeightEstimator, daltonismSimulator, digestionStopwatch, epworthSleepinessScale, hydrationCalculator, leanBodyMassCalculator, metabolicAgeCalculator, pelliRobsonTest, peripheralVisionTrainer, readingDistanceCalculator, screenDecompressionTime, tinnitusReliever, parametricNoiseSynthesizer, ubeCalculator, waterPurifier, sleepDebtRecoveryPlanner, bmrCalorieDeficitPlanner];
+export const ALL_ENTRIES = [binauralTuner, bloodUnitConverter, bmiCalculator, amputationAdjustedBmiCalculator, bodyAdiposityIndexCalculator, bodyFatPercentageCalculator, waistHipRatioCalculator, waistHeightRatioCalculator, breathingVisualizer, caffeineTracker, caloricDeficitCalculator, dailyProteinCalculator, macronutrientCalculator, tdeeCalculator, bunCreatinineCalculator, serumOsmolalityCalculator, meanArterialPressureCalculator, correctedSodiumHyperglycemiaCalculator, fractionalExcretionSodiumCalculator, correctedReticulocyteIndex, estimatedBloodVolumeCalculator, anionGapCalculator, creatinineClearanceCockcroftGault, correctedCalciumCalculator, egfrCalculator, targetHeightEstimator, daltonismSimulator, digestionStopwatch, epworthSleepinessScale, hydrationCalculator, leanBodyMassCalculator, metabolicAgeCalculator, pelliRobsonTest, peripheralVisionTrainer, readingDistanceCalculator, screenDecompressionTime, tinnitusReliever, parametricNoiseSynthesizer, ubeCalculator, waterPurifier, sleepDebtRecoveryPlanner, bmrCalorieDeficitPlanner, targetHeartRateZonePlanner];

package/src/index.ts

@@ -40,6 +40,7 @@ export { CORRECTED_CALCIUM_CALCULATOR_TOOL } from './tool/correctedCalciumCalcul
 export { EGFR_CALCULATOR_TOOL } from './tool/egfrCalculator';
 export { SLEEP_DEBT_RECOVERY_PLANNER_TOOL } from './tool/sleepDebtRecoveryPlanner';
 export { BMR_CALORIE_DEFICIT_PLANNER_TOOL } from './tool/bmrCalorieDeficitPlanner';
+export { TARGET_HEART_RATE_ZONE_PLANNER_TOOL } from './tool/targetHeartRateZonePlanner';
 
 export { healthCategory } from './category';
 export const healthCategorySEO = () => import('./category/seo.astro').then((m) => m.default);

package/src/tests/locale_completeness.test.ts

@@ -36,6 +36,6 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(42);
+    expect(ALL_TOOLS.length).toBe(43);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { healthCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 42 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(42);
+    it('should have 43 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(43);
     });
 
     it('healthCategory should be defined', () => {

package/src/tool/targetHeartRateZonePlanner/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { targetHeartRateZonePlanner } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await targetHeartRateZonePlanner.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/targetHeartRateZonePlanner/bibliography.ts

@@ -0,0 +1,22 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'American College of Sports Medicine. Exercising Your Way to Lowering Your Blood Pressure',
+    url: 'https://www.acsm.org/wp-content/uploads/2025/02/Exercising-Your-Way-to-Lowering-Your-Blood-Pressure-handout.pdf',
+  },
+  {
+    name: 'American Heart Association. Exercise and Physical Activity',
+    url: 'https://www.heart.org/en/healthy-living/exercise-and-physical-activity/',
+  },
+  {
+    name: 'Ministerio de Sanidad de España. Kilómetros de salud: calculando la zona de actividad',
+    url: 'https://vsf-iwsold-pro-portal.sanidad.gob.es/eu/areas/promocionPrevencion/actividadFisica/entornoEscolar/docs/2CICLOESO_UNIDAD_KILOMETROS_SALUDABLES.pdf',
+  },
+];
+
+export const sourceTraceability = [
+  { country: 'United States', language: 'English', claim: 'Gellish maximum heart rate equation, heart rate reserve limits, RPE caveat and medical clearance', url: bibliography[0].url },
+  { country: 'United States', language: 'English', claim: 'Warm-up, gradual progression and target heart rate values as general guidance', url: bibliography[1].url },
+  { country: 'Spain', language: 'Spanish', claim: 'Heart rate reserve and Karvonen target heart rate method', url: bibliography[2].url },
+];

package/src/tool/targetHeartRateZonePlanner/component.astro

@@ -0,0 +1,66 @@
+---
+import type { TargetHeartRateZonePlannerUI } from './ui';
+
+interface Props {
+  ui: TargetHeartRateZonePlannerUI;
+}
+
+const { ui } = Astro.props;
+const initialUi = JSON.stringify(ui);
+---
+
+<div class="pulse-planner" data-pulse-planner>
+  <div class="pulse-controls">
+    <div class="pulse-input-row">
+      <label class="pulse-field">
+        <span>{ui.ageLabel}</span>
+        <input data-input="age" type="number" inputmode="numeric" min="18" max="90" value="35" />
+        <small>{ui.ageUnit}</small>
+      </label>
+      <label class="pulse-field">
+        <span>{ui.restingHeartRateLabel}</span>
+        <input data-input="restingHeartRate" type="number" inputmode="numeric" min="35" max="110" value="60" />
+        <small>{ui.restingHeartRateHint}</small>
+      </label>
+      <label class="pulse-field">
+        <span>{ui.maximumHeartRateLabel}</span>
+        <input data-input="maximumHeartRate" type="number" inputmode="numeric" min="100" max="220" />
+        <small>{ui.maximumHeartRateHint}</small>
+      </label>
+      <label class="pulse-field">
+        <span>{ui.durationLabel}</span>
+        <input data-input="duration" type="number" inputmode="numeric" min="10" max="180" value="45" />
+        <small>{ui.durationHint}</small>
+      </label>
+    </div>
+    <fieldset class="pulse-choice">
+      <legend>{ui.intensityLabel}</legend>
+      <div class="pulse-choice__options">
+        <button type="button" data-intensity="easy" aria-pressed="false">{ui.intensityEasy}</button>
+        <button type="button" data-intensity="steady" aria-pressed="false">{ui.intensitySteady}</button>
+        <button type="button" data-intensity="endurance" aria-pressed="true">{ui.intensityEndurance}</button>
+        <button type="button" data-intensity="strong" aria-pressed="false">{ui.intensityStrong}</button>
+      </div>
+    </fieldset>
+    <fieldset class="pulse-choice">
+      <legend>{ui.sessionTypeLabel}</legend>
+      <div class="pulse-choice__options">
+        <button type="button" data-session-type="steady" aria-pressed="true">{ui.sessionTypeSteady}</button>
+        <button type="button" data-session-type="intervals" aria-pressed="false">{ui.sessionTypeIntervals}</button>
+        <button type="button" data-session-type="hiit" aria-pressed="false">{ui.sessionTypeHiit}</button>
+      </div>
+      <small class="pulse-choice__hint">{ui.sessionTypeHint}</small>
+    </fieldset>
+  </div>
+  <div class="pulse-scene" data-pulse-scene aria-live="polite"></div>
+  <section class="pulse-result" data-pulse-result aria-live="polite"></section>
+</div>
+
+<script is:inline type="application/json" data-pulse-ui set:html={initialUi}></script>
+<script>
+  import { mountTargetHeartRateZonePlanner } from './controller';
+
+  const root = document.querySelector('[data-pulse-planner]');
+  const data = document.querySelector('[data-pulse-ui]');
+  if (root instanceof HTMLElement && data instanceof HTMLScriptElement) mountTargetHeartRateZonePlanner(root, JSON.parse(data.textContent ?? '{}'));
+</script>

package/src/tool/targetHeartRateZonePlanner/controller.ts

@@ -0,0 +1,59 @@
+import { calculatePlan, validateInput, type IntensityKey, type PlannerInput, type SessionTypeKey } from './logic';
+import { renderInvalid, renderPulseScene, renderResult } from './dom-views';
+import { downloadTcx } from './export-tcx';
+import type { TargetHeartRateZonePlannerUI } from './ui';
+
+function readNumber(root: HTMLElement, key: string): number {
+  const value = (root.querySelector(`[data-input="${key}"]`) as HTMLInputElement)?.value ?? '';
+  return value === '' ? NaN : Number(value);
+}
+
+function readInput(root: HTMLElement, intensity: IntensityKey, sessionType: SessionTypeKey): PlannerInput {
+  const maximumHeartRate = readNumber(root, 'maximumHeartRate');
+  const input: PlannerInput = { age: readNumber(root, 'age'), restingHeartRate: readNumber(root, 'restingHeartRate'), intensity, sessionType, duration: readNumber(root, 'duration') };
+  if (Number.isFinite(maximumHeartRate)) input.maximumHeartRate = maximumHeartRate;
+  return input;
+}
+
+function syncButtons(root: HTMLElement, group: string, value: string): void {
+  root.querySelectorAll(`[data-${group}]`).forEach((button) => button.setAttribute('aria-pressed', String(button.getAttribute(`data-${group}`) === value)));
+}
+
+function bindChoice<T extends string>(root: HTMLElement, group: string, setValue: (value: T) => void, update: () => void): void {
+  root.querySelectorAll(`[data-${group}]`).forEach((button) => button.addEventListener('click', () => { setValue(button.getAttribute(`data-${group}`) as T); syncButtons(root, group, button.getAttribute(`data-${group}`) ?? ''); update(); }));
+}
+
+function bindLiveControls(root: HTMLElement, update: () => void, ui: TargetHeartRateZonePlannerUI, getPlan: () => ReturnType<typeof calculatePlan> | null): void {
+  root.querySelectorAll('[data-input]').forEach((input) => input.addEventListener('input', update));
+  root.addEventListener('click', (event) => {
+    const target = event.target;
+    const plan = getPlan();
+    if (target instanceof HTMLElement && target.closest('[data-export-tcx]') && plan) downloadTcx(plan, ui);
+  });
+}
+
+export function mountTargetHeartRateZonePlanner(root: HTMLElement, ui: TargetHeartRateZonePlannerUI): void {
+  let intensity: IntensityKey = 'endurance';
+  let sessionType: SessionTypeKey = 'steady';
+  let lastPlan: ReturnType<typeof calculatePlan> | null = null;
+  const scene = root.querySelector('[data-pulse-scene]') as HTMLElement;
+  const result = root.querySelector('[data-pulse-result]') as HTMLElement;
+  const update = (): void => {
+    const input = readInput(root, intensity, sessionType);
+    const errors = validateInput(input);
+    if (errors.length > 0) {
+      renderInvalid(result, errors, ui);
+      return;
+    }
+    const plan = calculatePlan(input);
+    lastPlan = plan;
+    renderPulseScene(scene, plan, ui);
+    renderResult(result, plan, ui);
+  };
+  bindChoice(root, 'intensity', (value: IntensityKey) => { intensity = value; }, update);
+  bindChoice(root, 'session-type', (value: SessionTypeKey) => { sessionType = value; }, update);
+  bindLiveControls(root, update, ui, () => lastPlan);
+  syncButtons(root, 'intensity', intensity);
+  syncButtons(root, 'session-type', sessionType);
+  update();
+}

package/src/tool/targetHeartRateZonePlanner/dom-views.ts

@@ -0,0 +1,69 @@
+import type { PlannerResult } from './logic';
+import type { TargetHeartRateZonePlannerUI } from './ui';
+
+function formatRange(result: PlannerResult, ui: TargetHeartRateZonePlannerUI): string {
+  return `${result.targetLow} ${ui.rangeSeparator} ${result.targetHigh} ${ui.bpmUnit}`;
+}
+
+function renderTower(result: PlannerResult, ui: TargetHeartRateZonePlannerUI): string {
+  const bandBottom = ((result.targetLow - result.restingHeartRate) / result.heartRateReserve) * 100;
+  const bandHeight = ((result.targetHigh - result.targetLow) / result.heartRateReserve) * 100;
+  const ceilingLabel = result.usesMeasuredMaximum ? ui.sceneCeilingMeasured : ui.sceneCeiling;
+  return `<div class="pulse-tower" style="--n-band-bottom:${bandBottom}%;--n-band-height:${bandHeight}%"><div class="pulse-tower__cap"><span>${result.maximumHeartRate}</span><small>${ceilingLabel}</small></div><div class="pulse-tower__shaft"><span class="pulse-tower__band"></span><span class="pulse-tower__beam"></span><span class="pulse-tower__rest"><strong>${result.restingHeartRate}</strong><small>${ui.sceneResting}</small></span></div><div class="pulse-tower__window"><strong>${formatRange(result, ui)}</strong><small>${ui.sceneWindow}</small></div></div>`;
+}
+
+function profilePath(result: PlannerResult): string {
+  const warmEnd = (result.segments[0].minutes / result.duration) * 640;
+  const mainEnd = warmEnd + (result.segments[1].minutes / result.duration) * 640;
+  const baseY = 142;
+  const targetY = 72;
+  const easyY = 110;
+  const points = [`M 0 ${baseY}`, `L ${warmEnd.toFixed(1)} ${easyY}`];
+  if (result.sessionType === 'steady') {
+    points.push(`L ${mainEnd.toFixed(1)} ${targetY}`);
+  } else {
+    const rounds = result.sessionType === 'hiit' ? 8 : 6;
+    const width = (mainEnd - warmEnd) / rounds;
+    for (let index = 0; index < rounds; index += 1) {
+      const start = warmEnd + width * index;
+      const peakY = result.sessionType === 'hiit' ? 42 : 58;
+      points.push(`L ${(start + width * 0.28).toFixed(1)} ${peakY}`, `L ${(start + width * 0.55).toFixed(1)} ${targetY}`, `L ${(start + width).toFixed(1)} ${easyY}`);
+    }
+  }
+  points.push('L 640 142');
+  return points.join(' ');
+}
+
+function renderTimeline(result: PlannerResult, ui: TargetHeartRateZonePlannerUI): string {
+  const labels = { warmUp: ui.sceneWarmUp, mainSet: ui.sceneMainSet, coolDown: ui.sceneCoolDown };
+  const warmEnd = (result.segments[0].minutes / result.duration) * 640;
+  const mainEnd = warmEnd + (result.segments[1].minutes / result.duration) * 640;
+  const path = profilePath(result);
+  return `<div class="pulse-timeline"><div class="pulse-timeline__line"><svg viewBox="0 0 640 180" role="img" aria-label="${ui.sceneProfile}"><rect class="pulse-profile__target" x="${warmEnd.toFixed(1)}" y="52" width="${(mainEnd - warmEnd).toFixed(1)}" height="40" rx="8" /><path class="pulse-profile__axis" d="M0 142H640" /><path class="pulse-profile__area" d="${path} L 640 142 L 0 142 Z" /><path class="pulse-profile__path" d="${path}" /><text x="0" y="170">${labels.warmUp}</text><text x="${((warmEnd + mainEnd) / 2).toFixed(1)}" y="170" text-anchor="middle">${labels.mainSet}</text><text x="640" y="170" text-anchor="end">${labels.coolDown}</text></svg></div><div class="pulse-timeline__segments">${result.segments.map((segment) => `<div class="pulse-timeline__segment pulse-timeline__segment--${segment.key}" style="--n-segment:${segment.minutes / result.duration}"><span>${labels[segment.key]}</span><strong>${segment.minutes}<small> ${ui.durationUnit}</small></strong></div>`).join('')}</div></div>`;
+}
+
+export function renderPulseScene(root: HTMLElement, result: PlannerResult, ui: TargetHeartRateZonePlannerUI): void {
+  root.innerHTML = `<div class="pulse-scene__header"><span>${ui.sceneSession}</span><strong>${formatRange(result, ui)}</strong></div><div class="pulse-scene__body">${renderTower(result, ui)}${renderTimeline(result, ui)}</div>`;
+}
+
+function renderMetric(label: string, value: string): string {
+  return `<div class="pulse-metric"><span>${label}</span><strong>${value}</strong></div>`;
+}
+
+function sessionPattern(result: PlannerResult, ui: TargetHeartRateZonePlannerUI): string {
+  if (result.sessionType === 'hiit') return ui.hiitPattern;
+  if (result.sessionType === 'intervals') return ui.intervalsPattern;
+  return ui.steadyPattern;
+}
+
+export function renderResult(root: HTMLElement, result: PlannerResult, ui: TargetHeartRateZonePlannerUI): void {
+  const [warmUp, mainSet, coolDown] = result.segments;
+  const maximumLabel = result.usesMeasuredMaximum ? ui.measuredMaximumLabel : ui.estimatedMaximumLabel;
+  const pattern = sessionPattern(result, ui);
+  root.innerHTML = `<div class="pulse-result__headline"><span>${ui.resultLabel}</span><strong>${formatRange(result, ui)}</strong><p>${ui.monitorInstruction}</p></div><div class="pulse-result__metrics">${renderMetric(maximumLabel, `${result.maximumHeartRate} ${ui.bpmUnit}`)}${renderMetric(ui.reserveLabel, `${result.heartRateReserve} ${ui.bpmUnit}`)}${renderMetric(ui.durationLabel, `${result.duration} ${ui.durationUnit}`)}</div><div class="pulse-result__outline"><h2>${ui.sessionOutlineLabel}</h2><div class="pulse-result__step"><span>01</span><p><strong>${warmUp.minutes} ${ui.durationUnit} ${ui.sceneWarmUp}</strong>${ui.warmUpInstruction}</p></div><div class="pulse-result__step"><span>02</span><p><strong>${mainSet.minutes} ${ui.durationUnit} ${ui.sceneMainSet}</strong>${ui.mainSetInstruction}<em>${ui.sessionPlanLabel}: ${pattern}</em></p></div><div class="pulse-result__step"><span>03</span><p><strong>${coolDown.minutes} ${ui.durationUnit} ${ui.sceneCoolDown}</strong>${ui.coolDownInstruction}</p></div></div><div class="pulse-result__actions"><button type="button" data-export-tcx>${ui.exportTcxLabel}</button><small>${ui.exportTcxHint}</small></div><p class="pulse-result__note"><strong>${ui.warningLabel}</strong> ${ui.rpeInstruction}</p>`;
+}
+
+export function renderInvalid(root: HTMLElement, errors: string[], ui: TargetHeartRateZonePlannerUI): void {
+  const messages: Record<string, string> = { age: ui.invalidAge, restingHeartRate: ui.invalidRestingHeartRate, maximumHeartRate: ui.invalidMaximumHeartRate, duration: ui.invalidDuration, impossibleHeartRate: ui.impossibleHeartRate };
+  root.innerHTML = `<div class="pulse-invalid"><strong>${ui.warningLabel}</strong><p>${errors.map((error) => messages[error]).join(' ')}</p></div>`;
+}

package/src/tool/targetHeartRateZonePlanner/entry.ts

@@ -0,0 +1,27 @@
+import type { HealthToolEntry } from '../../types';
+import type { TargetHeartRateZonePlannerUI } from './ui';
+
+export const targetHeartRateZonePlanner: HealthToolEntry<TargetHeartRateZonePlannerUI> = {
+  id: 'targetHeartRateZonePlanner',
+  icons: {
+    bg: 'mdi:heart-pulse',
+    fg: 'mdi:run-fast',
+  },
+  i18n: {
+    en: () => import('./i18n/en').then((module) => module.content),
+    de: () => import('./i18n/de').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/targetHeartRateZonePlanner/export-tcx.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { buildTcx } from './export-tcx';
+import { calculatePlan } from './logic';
+import type { TargetHeartRateZonePlannerUI } from './ui';
+
+const ui = { sceneSession: 'Pulse session', durationUnit: 'min', sceneWarmUp: 'Warm up', sceneMainSet: 'Main set', sceneCoolDown: 'Cool down' } as TargetHeartRateZonePlannerUI;
+
+describe('target heart rate zone planner TCX export', () => {
+  it('serializes the three session steps and the target range', () => {
+    const result = calculatePlan({ age: 35, restingHeartRate: 60, intensity: 'endurance', sessionType: 'steady', duration: 45 });
+    const tcx = buildTcx(result, ui);
+    expect(tcx).toContain('<Name>Pulse session - 45 min</Name>');
+    expect(tcx).toContain('<Seconds>540</Seconds>');
+    expect(tcx).toContain('<Low>134</Low><High>144</High>');
+    expect(tcx).toContain('<Seconds>420</Seconds>');
+  });
+});

package/src/tool/targetHeartRateZonePlanner/export-tcx.ts

@@ -0,0 +1,36 @@
+import type { PlannerResult } from './logic';
+import type { TargetHeartRateZonePlannerUI } from './ui';
+
+function escapeXml(value: string): string {
+  return value.replace(/[<>&'\"]/g, (character) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', "'": '&apos;', '"': '&quot;' })[character] ?? character);
+}
+
+interface TcxStep {
+  name: string;
+  type: string;
+  minutes: number;
+}
+
+function stepXml(step: TcxStep, result: PlannerResult, target: boolean): string {
+  const targetXml = target ? `<Target xsi:type="HeartRate_t"><Low>${result.targetLow}</Low><High>${result.targetHigh}</High></Target>` : '';
+  return `<Step xsi:type="Step_t"><Name>${escapeXml(step.name)}</Name><StepType>${step.type}</StepType><Duration xsi:type="Time_t"><Seconds>${step.minutes * 60}</Seconds></Duration>${targetXml}<Intensity>Active</Intensity></Step>`;
+}
+
+export function buildTcx(result: PlannerResult, ui: TargetHeartRateZonePlannerUI): string {
+  const workoutName = `${ui.sceneSession} - ${result.duration} ${ui.durationUnit}`;
+  const steps = [{ name: ui.sceneWarmUp, type: 'Warmup', minutes: result.segments[0].minutes }, { name: ui.sceneMainSet, type: 'Active', minutes: result.segments[1].minutes }, { name: ui.sceneCoolDown, type: 'Cooldown', minutes: result.segments[2].minutes }];
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<TrainingCenterDatabase xmlns="http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><Workouts><Workout Sport="Other"><Name>${escapeXml(workoutName)}</Name>${stepXml(steps[0], result, false)}${stepXml(steps[1], result, true)}${stepXml(steps[2], result, false)}</Workout></Workouts></TrainingCenterDatabase>`;
+}
+
+export function downloadTcx(result: PlannerResult, ui: TargetHeartRateZonePlannerUI): void {
+  const blob = new Blob([buildTcx(result, ui)], { type: 'application/vnd.garmin.tcx+xml' });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = 'target-heart-rate-session.tcx';
+  link.style.display = 'none';
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+  window.setTimeout(() => URL.revokeObjectURL(url), 1000);
+}

package/src/tool/targetHeartRateZonePlanner/i18n/de.ts

@@ -0,0 +1,50 @@
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TargetHeartRateZonePlannerUI } from '../ui';
+
+const slug = 'zielherzfrequenz-zonen-planer';
+const title = 'Planer für Zielherzfrequenzzonen';
+const description = 'Plane eine praktische Einheit mit Herzfrequenzreserve aus Alter, Ruhepuls oder gemessener Maximalfrequenz sowie gleichmäßigen, Intervall- und HIIT-Profilen.';
+const faq = [
+  { question: 'Was berechnet dieser Planer für Herzfrequenzzonen?', answer: 'Er schätzt einen Trainingsbereich aus Alter, Ruhepuls und gewählter Intensität. Außerdem teilt er die geplante Dauer in Aufwärmen, Hauptteil und Abkühlen. Die Werte sind pädagogische Schätzungen und keine Diagnose oder persönliche Verordnung.' },
+  { question: 'Wie funktioniert die Karvonen-Methode hier?', answer: 'Der Planer schätzt die maximale Herzfrequenz mit 207 minus 0,7 mal Alter oder verwendet deinen gemessenen Wert. Die maximale Herzfrequenz minus Ruhepuls ergibt die Herzfrequenzreserve. Auf den Ruhepuls wird dann der gewählte Anteil dieser Reserve addiert.' },
+  { question: 'Kann ich eine gemessene maximale Herzfrequenz eingeben?', answer: 'Ja. Lass das optionale Feld leer, um die altersbasierte Schätzung zu nutzen, oder gib einen aktuellen gemessenen Wert aus einem gut verstandenen Belastungstest ein. Das macht die Rechnung persönlicher, aber nicht zu einer medizinischen Verordnung.' },
+  { question: 'Welche Intensität ist für Zone 2 am besten?', answer: 'Zonen sind nicht in jeder Sportuhr oder jedem Trainingssystem gleich definiert. Dieses Tool bezeichnet 60 bis 69 Prozent der Herzfrequenzreserve als aerobe Ausdauerzone. Atmung, subjektive Anstrengung und professionelle Hinweise bleiben wichtig.' },
+  { question: 'Wie messe ich den Ruhepuls?', answer: 'Miss ihn ruhig und erholt, möglichst immer zur gleichen Zeit vor Koffein und Bewegung. Zähle eine volle Minute oder nutze ein zuverlässiges Messgerät. Ein einzelner ungewöhnlicher Wert kann durch Schlaf, Stress, Krankheit oder Trainingsbelastung entstehen.' },
+  { question: 'Kann ich das bei Betablockern oder einer Herzerkrankung verwenden?', answer: 'Verwende den berechneten Bereich dann nicht als persönlichen Zielwert. Medikamente und Erkrankungen können das Verhältnis zwischen Herzfrequenz und Belastung verändern. Bitte einen Arzt oder ein kardiologisches Reha-Team um einen individuellen Plan.' },
+];
+const howTo = [
+  { name: 'Ruhepuls messen', text: 'Miss morgens ruhig und wiederholbar und gib den Wert in Schlägen pro Minute ein.' },
+  { name: 'Belastungsbereich wählen', text: 'Wähle eine Intensität, die zum Zweck und zur erwarteten Dauer der Einheit passt.' },
+  { name: 'Einheitsprofil wählen', text: 'Wähle gleichmäßiges Training, Tempointervalle oder HIIT passend zur geplanten Einheit.' },
+  { name: 'Dauer festlegen', text: 'Gib die Gesamtdauer ein, damit Aufwärmen, Hauptteil und Abkühlen aufgeteilt werden können.' },
+  { name: 'Pulsbereich nutzen', text: 'Nutze den Bereich im Hauptteil, trainiere Aufwärmen und Abkühlen leichter und vergleiche die Zahl mit Atmung und Belastungsgefühl.' },
+];
+const appSchema: WithContext<SoftwareApplication> = { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'HealthApplication', operatingSystem: 'Web', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } };
+const faqSchema: WithContext<FAQPage> = { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) };
+const howToSchema: WithContext<HowTo> = { '@context': 'https://schema.org', '@type': 'HowTo', name: title, description, step: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })) };
+
+export const content: ToolLocaleContent<TargetHeartRateZonePlannerUI> = {
+  slug, title, description, faqTitle: 'Fragen zu Zielherzfrequenzzonen', faq, bibliographyTitle: 'Quellen für diese Schätzung', bibliography, howTo, schemas: [appSchema, faqSchema, howToSchema],
+  ui: {
+    rangeSeparator: 'bis',
+    ageLabel: 'Alter', ageUnit: 'Jahre', restingHeartRateLabel: 'Ruhepuls', restingHeartRateHint: 'Ruhige Messung vor der Aktivität', maximumHeartRateLabel: 'Maximale Herzfrequenz', maximumHeartRateHint: 'Optionale Messung', bpmUnit: 'bpm', intensityLabel: 'Belastungsbereich wählen', intensityEasy: 'Leicht 40 bis 49 %', intensitySteady: 'Moderat 50 bis 59 %', intensityEndurance: 'Aerob 60 bis 69 %', intensityStrong: 'Stark 70 bis 79 %', sessionTypeLabel: 'Einheitsprofil', sessionTypeSteady: 'Gleichmäßig', sessionTypeIntervals: 'Tempointervalle', sessionTypeHiit: 'HIIT-Blöcke', sessionTypeHint: 'Das Profil ändert die Form, nicht die Herzfrequenzrechnung.', durationLabel: 'Einheitsdauer', durationUnit: 'Min.', durationHint: 'Vom Aufwärmen bis zum Abkühlen', sceneResting: 'Ruhepuls', sceneCeiling: 'geschätzte Obergrenze', sceneCeilingMeasured: 'gemessene Obergrenze', sceneWindow: 'Zielbereich', scenePulsePath: 'Pulsverlauf durch die Einheit', sceneProfile: 'Belastungsprofil durch die Einheit', sceneSession: 'Dein Pulsleuchtturm', sceneWarmUp: 'Aufwärmen', sceneMainSet: 'Hauptteil', sceneCoolDown: 'Abkühlen', resultLabel: 'Ziel im Hauptteil', targetRangeLabel: 'Zielbereich', estimatedMaximumLabel: 'Geschätzte Maximalfrequenz', measuredMaximumLabel: 'Gemessene Maximalfrequenz', reserveLabel: 'Herzfrequenzreserve', sessionOutlineLabel: 'Einheitsablauf', sessionPlanLabel: 'Einheitsmuster', steadyPattern: 'Halte ein gleichmäßiges Tempo im Zielbereich.', intervalsPattern: 'Wechsle im Hauptteil zwei Minuten nahe am Ziel mit zwei Minuten lockerem Tempo ab.', hiitPattern: 'Wechsle 30 Sekunden hart mit 90 Sekunden locker für kontrollierte intensive Blöcke ab.', exportTcxLabel: 'TCX Einheit exportieren', exportTcxHint: 'Eine Trainingsdatei für kompatible Plattformen.', warmUpInstruction: 'Steigere dich langsam, bis sich die Atmung ruhig und kontrolliert anfühlt.', mainSetInstruction: 'Bleibe im Zielbereich. Atmung und Belastungsgefühl gehen einer Zahl vor, die sich falsch anfühlt.', coolDownInstruction: 'Verringere das Tempo schrittweise, bis die Atmung fast normal ist.', monitorInstruction: 'Nutze bei Bedarf einen Monitor, aber behandle den Bereich als Startpunkt und nicht als Befehl.', rpeInstruction: 'Wenn sich die Belastung viel härter als erwartet anfühlt, werde langsamer. Medikamente, Krankheit, Hitze, Stress und Fitness können Schätzungen verfälschen.', estimateNote: 'Pädagogische Schätzung für Erwachsene', warningLabel: 'Sicherheitshinweis', invalidAge: 'Gib ein Alter von 18 bis 90 Jahren ein.', invalidRestingHeartRate: 'Gib einen Ruhepuls von 35 bis 110 bpm ein.', invalidMaximumHeartRate: 'Gib eine gemessene Maximalfrequenz von 100 bis 220 bpm ein oder lass das Feld leer.', invalidDuration: 'Gib eine Einheitsdauer von 10 bis 180 Minuten ein.', impossibleHeartRate: 'Dieser Ruhepuls lässt zu wenig Abstand zur geschätzten Maximalfrequenz. Prüfe den Wert und hole vor dem Training individuelle Beratung ein.',
+  },
+  seo: [
+    { type: 'summary', title: 'Eine Einheit mit Zielherzfrequenz planen', items: ['Maximalfrequenz aus dem Alter schätzen oder einen Messwert eingeben.', 'Einen passenden Belastungsbereich statt eines einzelnen Pulswerts wählen.', 'Die Einheit gleichmäßig, als Tempointervall oder HIIT gestalten.', 'Puls mit Atmung, Belastungsgefühl und gesundheitlichem Kontext abgleichen.'] },
+    { type: 'title', text: 'Was eine Zielherzfrequenzzone aussagt', level: 2 },
+    { type: 'paragraph', html: 'Eine Zielherzfrequenzzone ist eine praktische Orientierung für das Tempo. Dieser Planer verbindet Alter und ruhigen Ruhepuls, damit der Startpunkt besser berücksichtigt wird als bei einem einfachen Prozentsatz der Maximalfrequenz. Das Ergebnis gilt für den Hauptteil und misst weder die aerobe Schwelle noch die Sicherheit einer Einheit.' },
+    { type: 'title', text: 'So funktioniert die Reserveberechnung', level: 2 },
+    { type: 'paragraph', html: 'Zuerst wird die maximale Herzfrequenz mit der Gellish-Gleichung geschätzt: 207 minus 0,7 mal Alter, sofern kein Messwert eingegeben wurde. Danach wird der Ruhepuls abgezogen. Auf den Ruhepuls wird der gewählte Anteil der Reserve addiert. Bei 35 Jahren und 60 bpm entstehen 183 bpm Maximalfrequenz, 123 bpm Reserve und bei 60 bis 69 Prozent etwa 134 bis 144 bpm.' },
+    { type: 'table', headers: ['Planerstufe', 'Bedeutung'], rows: [['Ruhepuls', 'Der ruhige Ausgangspuls für die Rechnung.'], ['Maximale Herzfrequenz', 'Eine altersbasierte Schätzung oder dein Messwert.'], ['Herzfrequenzreserve', 'Maximalfrequenz minus Ruhepuls.'], ['Ziel im Hauptteil', 'Ruhepuls plus gewählter Anteil der Reserve.']] },
+    { type: 'title', text: 'Den Belastungsbereich auswählen', level: 2 },
+    { type: 'paragraph', html: 'Leichte und moderate Bereiche passen zu einem Wiedereinstieg oder einer gut kontrollierbaren Einheit. Der aerobe Bereich eignet sich als Planungsband für längere Belastungen, aber der Begriff Zone 2 wird je nach System unterschiedlich verwendet. Der starke Bereich verlangt einen passenden Trainings- und Gesundheitskontext.' },
+    { type: 'list', items: ['Ruhepuls ruhig und möglichst immer zur gleichen Zeit messen.', 'Den niedrigsten Bereich wählen, der zum Ziel der heutigen Einheit passt.', 'Aufwärmen und Abkühlen leichter als den Hauptteil halten.', 'Atmung und Belastungsgefühl genauso beobachten wie den Monitor.', 'Mehrere Einheiten betrachten statt nach einem ungewöhnlichen Wert alles zu ändern.', 'Bei Medikamenten, Symptomen oder Erkrankungen persönliche Beratung einholen.'] },
+    { type: 'title', text: 'Aus der Schätzung eine Einheit machen', level: 2 },
+    { type: 'paragraph', html: 'Die Dauer erhält drei Aufgaben. Das Aufwärmen steigert die Belastung, der Hauptteil nutzt den Zielbereich und das Abkühlen senkt das Tempo schrittweise. Das gewählte Profil macht daraus eine gleichmäßige, Tempo- oder HIIT-Einheit und zeigt, wann der Zahlenbereich relevant ist.' },
+    { type: 'tip', title: 'Den Puls als Gespräch und nicht als Befehl nutzen', html: 'Hitze, Flüssigkeitsmangel, Schlaf, Stress, Krankheit, Höhe, Trainingslast und Medikamente verändern die Herzfrequenz. Wenn die Zahl nicht zum Körpergefühl passt, reduziere die Belastung und kläre den Kontext. Bei starken oder beunruhigenden Symptomen Training abbrechen und dringend Hilfe suchen.' },
+    { type: 'title', text: 'Grenzen dieser Schätzung', level: 2 },
+    { type: 'paragraph', html: 'Dieses Tool diagnostiziert keine Fitness, erstellt keine sichere medizinische Verordnung und bestimmt keine ventilatorische Schwelle. Die Altersgleichung kann für einzelne Personen deutlich abweichen. Ein Belastungstest oder eine professionelle Einschätzung ist bei hohem Präzisionsbedarf geeigneter.' },
+  ],
+};

package/src/tool/targetHeartRateZonePlanner/i18n/en.ts

@@ -0,0 +1,61 @@
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { TargetHeartRateZonePlannerUI } from '../ui';
+
+const slug = 'target-heart-rate-zone-planner';
+const title = 'Target Heart Rate Zone Planner';
+const description = 'Build a practical heart rate reserve session from an age-based or measured maximum heart rate, with steady, interval and HIIT shapes for adults.';
+
+const faq = [
+  { question: 'What does this target heart rate planner calculate?', answer: 'It estimates a training band from your age, resting heart rate and selected intensity. It also divides your planned duration into a warm up, main set and cool down. The numbers are educational estimates, not a diagnosis, prescription or proof of a physiological threshold.' },
+  { question: 'How does the Karvonen method work here?', answer: 'The planner estimates maximum heart rate with 207 minus 0.7 times age, or uses your measured maximum when you provide one. It subtracts resting heart rate to obtain heart rate reserve, then adds the chosen fraction of that reserve back to resting heart rate. Rounding creates a practical whole beat range.' },
+  { question: 'Can I enter a measured maximum heart rate?', answer: 'Yes. Leave the optional maximum field empty to use the age-based estimate, or enter a recent measured maximum from a supervised or well-understood exercise test. A measured value can make the arithmetic more personal, but it does not make the result a medical prescription.' },
+  { question: 'What is the best intensity for zone 2 training?', answer: 'Zone names are not standardized across every sport watch or coaching system. This tool labels a 60 to 69 percent heart rate reserve band as aerobic endurance, but that label is not a measured ventilatory threshold. Use breathing, perceived effort and your own professional guidance alongside the estimate.' },
+  { question: 'How should I measure resting heart rate?', answer: 'Measure when you are calm and rested, ideally at a consistent time before caffeine, exercise or other activity. Count for a full minute or use a reliable monitor. A single unusual reading can reflect sleep, stress, illness or training load.' },
+  { question: 'Can I use this if I take a beta blocker or have a heart condition?', answer: 'Do not treat the calculated band as your personal target in that situation. Medicines and cardiovascular conditions can change the relationship between heart rate and effort. Ask your clinician or cardiac rehabilitation team for an individualized plan, and stop exercise for concerning symptoms.' },
+];
+
+const howTo = [
+  { name: 'Measure your resting heart rate', text: 'Take a calm, repeatable morning reading and enter beats per minute.' },
+  { name: 'Set your effort band', text: 'Choose an intensity that matches the session you can sustain, not the hardest effort you can imagine.' },
+  { name: 'Choose the session shape', text: 'Select a steady session, tempo intervals or HIIT so the profile matches the workout you intend to do.' },
+  { name: 'Choose the session duration', text: 'Enter the total session duration so the planner can divide it into a warm up, main set and cool down.' },
+  { name: 'Follow the pulse window', text: 'Use the target range for the main set, keep the warm up and cool down easy, and compare the number with breathing and perceived effort.' },
+];
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'HealthApplication', operatingSystem: 'Web', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+};
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org', '@type': 'HowTo', name: title, description, step: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })),
+};
+
+export const content: ToolLocaleContent<TargetHeartRateZonePlannerUI> = {
+  slug, title, description, faqTitle: 'Questions about target heart rate zones', faq, bibliographyTitle: 'Sources for this estimate', bibliography, howTo, schemas: [appSchema, faqSchema, howToSchema],
+  ui: {
+    rangeSeparator: 'to',
+    ageLabel: 'Age', ageUnit: 'years', restingHeartRateLabel: 'Resting heart rate', restingHeartRateHint: 'Calm reading before activity', maximumHeartRateLabel: 'Maximum heart rate', maximumHeartRateHint: 'Optional measured value', bpmUnit: 'bpm', intensityLabel: 'Choose the effort window', intensityEasy: 'Easy 40 to 49%', intensitySteady: 'Steady 50 to 59%', intensityEndurance: 'Aerobic 60 to 69%', intensityStrong: 'Strong 70 to 79%', sessionTypeLabel: 'Session shape', sessionTypeSteady: 'Steady state', sessionTypeIntervals: 'Tempo intervals', sessionTypeHiit: 'HIIT blocks', sessionTypeHint: 'The shape changes the profile, not the heart rate math.', durationLabel: 'Session duration', durationUnit: 'min', durationHint: 'Warm up to cool down', sceneResting: 'resting', sceneCeiling: 'estimated ceiling', sceneCeilingMeasured: 'measured ceiling', sceneWindow: 'target window', scenePulsePath: 'Pulse path through the session', sceneProfile: 'Training load profile through the session', sceneSession: 'Your pulse lighthouse', sceneWarmUp: 'Warm up', sceneMainSet: 'Main set', sceneCoolDown: 'Cool down', resultLabel: 'Main set target', targetRangeLabel: 'Target range', estimatedMaximumLabel: 'Estimated maximum', measuredMaximumLabel: 'Measured maximum', reserveLabel: 'Heart rate reserve', sessionOutlineLabel: 'Session outline', sessionPlanLabel: 'Session pattern', steadyPattern: 'Keep a smooth pace inside the target window.', intervalsPattern: 'Alternate 2 minutes near the target with 2 minutes easy during the main set.', hiitPattern: 'Alternate 30 seconds hard with 90 seconds easy for controlled high-intensity blocks.', exportTcxLabel: 'Export TCX workout', exportTcxHint: 'A workout file for compatible training platforms.', warmUpInstruction: 'Build gently until breathing feels comfortable and controlled.', mainSetInstruction: 'Settle inside the target window. Let breathing and perceived effort overrule a number that feels wrong.', coolDownInstruction: 'Ease the pace gradually until your breathing is close to normal.', monitorInstruction: 'Use a monitor if you have one, but treat this as a starting band rather than a command.', rpeInstruction: 'If the effort feels much harder than expected, slow down. Medication, illness, heat, stress and fitness can make heart rate estimates misleading.', estimateNote: 'Educational estimate for adults', warningLabel: 'Safety note', invalidAge: 'Enter an age from 18 to 90 years.', invalidRestingHeartRate: 'Enter a resting heart rate from 35 to 110 bpm.', invalidMaximumHeartRate: 'Enter a measured maximum from 100 to 220 bpm, or leave it empty to use the estimate.', invalidDuration: 'Enter a session from 10 to 180 minutes.', impossibleHeartRate: 'This resting value leaves too little room below the estimated maximum. Check the reading and seek individual guidance before using a target.',
+  },
+  seo: [
+    { type: 'summary', title: 'Plan a target heart rate session', items: ['Estimate maximum heart rate from age or enter a measured maximum.', 'Choose an effort band instead of chasing one exact pulse.', 'Shape the session as steady state, tempo intervals or HIIT.', 'Cross check the number with breathing, perceived effort and medical context.'] },
+    { type: 'title', text: 'What a target heart rate zone can tell you', level: 2 },
+    { type: 'paragraph', html: 'A target heart rate zone is a practical pacing reference. This planner combines age with a calm resting heart rate so the result reflects more of your starting point than a percentage of maximum heart rate alone. The output is a range for the main part of a session, not a measurement of your aerobic threshold or a guarantee that a workout is safe for every person.' },
+    { type: 'title', text: 'How the reserve calculation works', level: 2 },
+    { type: 'paragraph', html: 'First, the planner estimates maximum heart rate with the Gellish equation: 207 minus 0.7 multiplied by age, unless you enter a measured maximum. It then calculates heart rate reserve as maximum heart rate minus resting heart rate. The target is resting heart rate plus the selected percentage of that reserve. For example, a 35 year old with a resting rate of 60 has an estimated maximum of 183 and a reserve of 123. At 60 to 69 percent reserve, the practical target is about 134 to 144 bpm.' },
+    { type: 'table', headers: ['Planner stage', 'What it means'], rows: [['Resting heart rate', 'Your calm starting pulse entered into the calculation.'], ['Maximum heart rate', 'An age-based estimate or your optional measured value.'], ['Heart rate reserve', 'Maximum heart rate minus resting heart rate.'], ['Main set target', 'Resting heart rate plus the selected share of reserve.']] },
+    { type: 'title', text: 'How to choose an effort band', level: 2 },
+    { type: 'paragraph', html: 'Use the easy and steady windows when you are returning to movement or want a controllable session. The aerobic window is a useful planning band for a sustained session, but "zone 2" means different things depending on whether a system uses heart rate reserve, maximum heart rate or a measured ventilatory threshold. The strong window belongs in a plan that matches your experience and health context.' },
+    { type: 'list', items: ['Measure resting heart rate when calm and at a consistent time.', 'Choose the lowest band that matches the purpose of today\'s session.', 'Keep the warm up and cool down easier than the main target.', 'Watch breathing and perceived effort as well as the monitor.', 'Review repeated sessions rather than changing the plan from one unusual reading.', 'Ask a qualified professional for a personal prescription when medication, symptoms or a diagnosed condition is involved.'] },
+    { type: 'title', text: 'Turn the estimate into a session', level: 2 },
+    { type: 'paragraph', html: 'The duration is divided into three jobs. The warm up raises effort gradually, the main set is where the target window is most relevant, and the cool down brings the pace down progressively. The session shape then gives that main set a smooth, tempo or HIIT profile. That structure makes the output more useful than a lone number because it tells you when the number matters and when it should not.' },
+    { type: 'tip', title: 'Use the pulse as a conversation, not a command', html: 'Heart rate can be shifted by heat, dehydration, sleep, stress, illness, altitude, training load and medicines. If the number conflicts with how you feel, reduce the effort and investigate the context. Stop and seek urgent medical help for severe or concerning symptoms.' },
+    { type: 'title', text: 'Limits you should keep in view', level: 2 },
+    { type: 'paragraph', html: 'This tool cannot diagnose cardiovascular fitness, determine a safe training prescription, identify a ventilatory threshold or account for every medication and condition. The age equation can be wrong for an individual, and the relationship between heart rate and effort changes with activity and environment. A measured exercise test or professional assessment is more specific when precision matters.' },
+  ],
+};