No nutrition data logged — sync MFP from the Nutrition tab
)}
{/* ── Weekly Briefing ───────────────────────────────────────
Auto-generates once per ISO week (cached server-side), a
2-3 paragraph coach-style recap of last week + outlook
for the week ahead. Frontend assembles structured data;
cloud function turns it into prose. */}
{(() => {
const [briefing, setBriefing] = useState(null);
const [briefLoading, setBriefLoading] = useState(false);
const [briefError, setBriefError] = useState(null);
// Compute current ISO week key client-side so we can lazy-load
// a previously-cached briefing instantly without a function call.
const weekKey = (() => {
const d = new Date();
const dt = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
const dayNum = dt.getUTCDay() || 7;
dt.setUTCDate(dt.getUTCDate() + 4 - dayNum);
const yearStart = new Date(Date.UTC(dt.getUTCFullYear(), 0, 1));
const weekNum = Math.ceil(((dt - yearStart) / 86400000 + 1) / 7);
return `${dt.getUTCFullYear()}-W${String(weekNum).padStart(2, "0")}`;
})();
// Load any cached briefing for this week from Firestore on mount.
useEffect(() => {
if (!userId) return;
db.collection("users").doc(userId).collection("briefings").doc(weekKey).get()
.then(doc => { if (doc.exists) setBriefing(doc.data()); })
.catch(e => console.warn("[briefing] cache read:", e.message));
}, [userId, weekKey]);
// Build the structured input the cloud function expects.
const buildBriefingData = () => {
if (!activePlanSummary?.weeks?.length) return null;
const weeks = activePlanSummary.weeks;
const w1Start = window.PlanMath?.planWeek1Start?.(activePlanSummary);
if (!w1Start) return null;
const now = new Date();
const msSinceW1 = now - w1Start;
const currentIdx = Math.floor(msSinceW1 / (7 * 86400000));
if (currentIdx <= 0) return null;
const lastWeekIdx = currentIdx - 1;
const thisWeekIdx = currentIdx;
const lastWeek = weeks[lastWeekIdx];
const thisWeek = weeks[thisWeekIdx];
if (!lastWeek) return null;
const RUN_TYPES = window.PlanMath?.RUN_TYPES || ["easy","recovery","tempo","intervals","long","race_pace"];
const QUAL = new Set(["tempo","intervals","race_pace","threshold"]);
const plannedMi = window.PlanMath.plannedMiForWeek(lastWeek);
const actualMi = window.PlanMath.actualMiForWeek(activePlanSummary, lastWeekIdx, activities) || 0;
const compliancePct = plannedMi > 0 ? Math.round((actualMi / plannedMi) * 100) : null;
// Activities credited to last week (uses same range as actualMiForWeek).
const range = window.PlanMath.weekDateRange(activePlanSummary, lastWeekIdx);
const lastWeekActs = (activities || []).filter(a => {
if (a.type !== "Run" && a.type !== "VirtualRun") return false;
const t = a.start_date_local || a.start_date;
const ms = typeof t === "string" ? Date.parse(t) : (t?.toDate ? t.toDate().getTime() : (t?.seconds ? t.seconds * 1000 : 0));
return ms >= range.start.getTime() && ms < range.end.getTime();
});
const totalSec = lastWeekActs.reduce((s, a) => s + (a.moving_time || 0), 0);
const totalDistM = lastWeekActs.reduce((s, a) => s + (a.distance || 0), 0);
const avgPaceSec = totalDistM > 0 ? totalSec / (totalDistM / 1609.34) : null;
const fmtPace = avgPaceSec ? `${Math.floor(avgPaceSec/60)}:${String(Math.round(avgPaceSec%60)).padStart(2,"0")}` : null;
// Quality executed in last week (from completed plan days).
const qualitySessions = (lastWeek.days || [])
.filter(d => d.completed && QUAL.has((d.type || "").toLowerCase()))
.map(d => ({ type: d.type, grade: d.completedGrade || null }));
const qualityScheduled = (lastWeek.days || [])
.filter(d => QUAL.has((d.type || "").toLowerCase()))
.map(d => d.type).join(", ") || null;
// Long run = the single longest run of the week. We
// deliberately do NOT use the planned long-day's actualMi
// because that's an aggregated sum across all activities
// matched to that day-of-week — cross-source duplicates
// (Strava + Runalyze writing the same run as separate docs
// with different ids) make it inflate, e.g. a 14mi long run
// reported as 28mi. The single longest activity is robust
// to that aggregation. The grade still comes from the long
// day if it was marked complete.
const longDay = (lastWeek.days || []).find(d => d.type === "long");
const longestAct = lastWeekActs.reduce(
(max, a) => (a.distance || 0) > (max?.distance || 0) ? a : max,
null,
);
const longRunMi = longestAct && longestAct.distance > 0
? Math.round(longestAct.distance / 1609.34 * 10) / 10
: null;
const longRun = longRunMi != null ? {
distanceMi: longRunMi,
classification: longDay?.completedGrade ? `grade ${longDay.completedGrade}` : null,
} : null;
// Aerobic %: easy mileage / total mileage.
const easyMi = lastWeekActs.filter(a => {
const hr = a.average_heartrate;
return !hr || hr <= (athleteProfile?.zones?.[0]?.maxBPM || 145);
}).reduce((s, a) => s + (a.distance || 0), 0) / 1609.34;
const aerobicPct = totalDistM > 0 ? Math.round((easyMi / (totalDistM / 1609.34)) * 100) : null;
// Health averages.
const lwHealth = (healthEntries || []).filter(h => {
const t = Date.parse(h.date);
return t >= range.start.getTime() && t < range.end.getTime();
});
const avgOf = (key, get) => {
const xs = lwHealth.map(get).filter(v => Number.isFinite(v));
return xs.length ? Math.round(xs.reduce((s, v) => s + v, 0) / xs.length) : null;
};
const avgHRV = avgOf("hrv", h => Number(h?.hrv?.lastNight ?? h?.hrv?.lastNightAvg ?? (typeof h?.hrv === "number" ? h.hrv : null)));
const avgRHR = avgOf("rhr", h => Number(h?.restingHR));
const avgSleep = avgOf("sleep", h => Number(h?.sleepScore ?? h?.sleep?.overall));
// Nutrition.
const lwNut = (nutritionHistory || []).filter(n => {
const t = Date.parse(n.date);
return t >= range.start.getTime() && t < range.end.getTime();
});
const avgIntake = lwNut.length ? Math.round(lwNut.reduce((s, n) => s + (n.calories || 0), 0) / lwNut.length) : null;
const avgProtein = lwNut.length ? Math.round(lwNut.reduce((s, n) => s + (n.protein || 0), 0) / lwNut.length) : null;
// Weight delta (avg this week vs prior).
const lwWt = lwHealth.filter(h => h.weight).map(h => h.weight);
const priorRange = window.PlanMath.weekDateRange(activePlanSummary, Math.max(0, lastWeekIdx - 1));
const pwHealth = priorRange ? (healthEntries || []).filter(h => {
const t = Date.parse(h.date);
return t >= priorRange.start.getTime() && t < priorRange.end.getTime();
}) : [];
const pwWt = pwHealth.filter(h => h.weight).map(h => h.weight);
const lwAvg = lwWt.length ? lwWt.reduce((s, v) => s + v, 0) / lwWt.length : null;
const pwAvg = pwWt.length ? pwWt.reduce((s, v) => s + v, 0) / pwWt.length : null;
const weightDelta = (lwAvg != null && pwAvg != null) ? lwAvg - pwAvg : null;
// Notable flags from REDS / overtraining if present.
const notableFlags = [];
if (redsRisk?.riskLevel === "high") notableFlags.push("RED-S high risk");
else if (redsRisk?.riskLevel === "moderate") notableFlags.push("RED-S moderate risk");
if (compliancePct != null && compliancePct < 80) notableFlags.push(`compliance ${compliancePct}%`);
// Next week.
const nwTarget = thisWeek ? window.PlanMath.plannedMiForWeek(thisWeek) : null;
const nwLong = thisWeek ? (thisWeek.days || []).find(d => d.type === "long") : null;
const nwQuality = thisWeek ? (thisWeek.days || [])
.filter(d => QUAL.has((d.type || "").toLowerCase()))
.map(d => `${d.day} ${d.type} ${d.distanceMi || ""}mi`).join("; ") : null;
return {
profile: { name: "Chris", age: 45 },
race: {
name: activePlanSummary.raceName,
date: activePlanSummary.raceDate,
goalTime: activePlanSummary.goalTime,
weeksOut: activePlanSummary.raceDate ? Math.max(0, Math.ceil((Date.parse(activePlanSummary.raceDate) - Date.now()) / (7 * 86400000))) : null,
phase: thisWeek?.phase || lastWeek?.phase,
},
lastWeek: {
weekNum: lastWeekIdx + 1,
plannedMi: Math.round(plannedMi),
actualMi: Math.round(actualMi * 10) / 10,
compliancePct,
runs: lastWeekActs.length,
avgPace: fmtPace,
qualitySessions,
qualityScheduled,
longRun,
aerobicPct,
avgHRV, avgRHR, avgSleep,
avgIntake, avgProtein,
weightDelta,
notableFlags,
},
nextWeek: {
weekNum: thisWeekIdx + 1,
targetMi: nwTarget ? Math.round(nwTarget) : null,
deltaVsLast: (nwTarget && actualMi) ? Math.round((nwTarget - actualMi) * 10) / 10 : null,
longRunMi: nwLong?.distanceMi,
longRunNote: nwLong?.description ? nwLong.description.slice(0, 80) : null,
qualityScheduled: nwQuality,
theme: thisWeek?.theme,
},
};
};
const generateBriefing = async (force = false) => {
const briefingData = buildBriefingData();
if (!briefingData) { setBriefError("Need an active plan with at least one completed week."); return; }
setBriefLoading(true); setBriefError(null);
try {
const fn = functions.httpsCallable("generateWeeklyBriefing", { timeout: 90000 });
const result = await fn({ briefingData, force });
setBriefing(result.data);
} catch (e) {
setBriefError(e.message || "Generation failed");
}
setBriefLoading(false);
};
// No active plan with prior week → don't render at all.
if (!activePlanSummary?.weeks?.length) return null;
const hasBriefing = briefing && briefing.briefing;
return (
Weekly Briefing
{weekKey} · last week recap + week ahead
{isOwner && (
{!hasBriefing && (
)}
{hasBriefing && (
)}
)}
{briefError && (
Error: {briefError}
)}
{hasBriefing ? (
{briefing.briefing}
) : !briefError && !briefLoading && (
Click Generate for a coach-style recap of last week + outlook for the week ahead. Cached server-side once per week — refresh anytime to regenerate.
)}
);
})()}
{/* ── Bite-sized status widgets row ─────────────────────────
Three compact tiles for at-a-glance status: RED-S risk
score, glycogen replenishment %, and plan compliance %.
Each links/hints toward the dedicated detail tab. */}
{/* Race-day equivalents — if you hit your goal time at the
planned race distance, what does that imply at every
other distance via Riegel? Helps the athlete sanity-
check whether their goal is consistent with workouts. */}
{raceGoalEquivalents && (
If you hit {raceGoalEquivalents.goalLabel}, equivalents:
{trainingPaces.map((tp, i) => {
const obsKey = tp.zone.toLowerCase();
const obs = observedPaces?.[obsKey] ?? null;
// Typical workout SHAPE for each zone — the zone is the
// pace band (left), this is how that pace is usually run.
// Distance/duration is a separate axis from the zone: a
// 3.5mi block or a 15-min sustained effort is classified
// by the pace it held, not its length.
const repGuide = {
REC: "easy continuous · 3–6 mi",
E: "easy continuous · 4–10 mi",
L: "continuous · 13–22 mi",
S: "sustained aerobic · 3–8 mi / MP long-run segments",
M: "race or MP segments · 6–16 mi",
T: "tempo · 15–25 min sustained or 1–2 mi cruise reps",
I: "VO2 reps · 800m–1200m (3–5 min)",
R: "short reps · 100–200m (20–40s)",
}[tp.abbr];
// Colour the current value vs the target band: within
// = green, faster = cyan (ahead of schedule), slower
// = amber (room to push). Muted when unknown.
let obsColor = C.textMuted;
if (obs != null && tp.min != null && tp.max != null) {
if (obs >= tp.min && obs <= tp.max) obsColor = C.green;
else if (obs < tp.min) obsColor = C.cyan;
else obsColor = C.amber;
}
// Treadmill speed (sec/mi → mph) as a small dim sub-line
// under each pace, so treadmill users don't have to
// convert. Faster pace (lower sec) = higher mph.
const mph = (sec) => (sec > 0 ? (3600 / sec).toFixed(1) : null);
const tMaxMph = mph(tp.max), tMinMph = mph(tp.min), obsMph = mph(obs);
return (
);
})}
{(() => {
if (!trainingPaces.source) return null;
const fmtPace = sec => {
const m = Math.floor(sec / 60);
const s = Math.round(sec % 60);
return `${m}:${String(s).padStart(2, "0")}/mi`;
};
// Current-fitness MP for the "building from current fitness
// (X)" reference — prefer the snapshot's effectiveVDOT so it
// matches the canonical MP anchor above, falling back to the
// live client VO2max before the first snapshot exists.
const fitnessVO2 = trainingSnapshot?.fitness?.effectiveVDOT || effectiveVO2;
const fitnessPreds = fitnessVO2 ? predictRaceTimes(fitnessVO2, runs || []) : null;
const fitnessMp = fitnessPreds?.find(p => p.name === "Marathon")?.pace;
if (trainingPaces.source === "goal") {
// Show the gap to current-fitness MP so the runner
// sees whether the goal is realistic vs. current shape.
return (
Anchored on goal MP {fmtPace(trainingPaces.mp)}
{fitnessMp ? <> — current fitness predicts {fmtPace(fitnessMp)} MP. : "."}
);
}
return (
Anchored on current-fitness MP {fmtPace(trainingPaces.mp)} (no marathon goal configured — set one to anchor on goal pace instead).
);
})()}
) : (
Need VO2max estimate or marathon goal for paces
)}
{/* Race Time History — predicted times for each distance over the
past 16 weeks, with a horizontal goal line at the race-day
target. Tabbed by distance so each chart has full y-axis
resolution (a 5K time of 22:00 vs a marathon of 3:30 in the
same axis would compress 5K to a flat line). */}
{racePredHistory.length >= 3 && (
Race Time History
({racePredHistory.length}w · weekly snapshots from Garmin VO₂max)
{(() => {
const dataKey = raceHistDist;
const data = racePredHistory.filter(p => p[dataKey] != null);
// Determine the goal-line value for this distance: if the
// active plan's race matches, use the goal time; otherwise
// use the equivalent (Riegel) of the goal at this distance.
let goalSec = null;
if (activePlanSummary?.goalTime) {
const cleaned = String(activePlanSummary.goalTime).replace(/^sub[- ]?/i, "");
const parts = cleaned.split(":").map(p => parseInt(p, 10));
let totalGoal = null;
if (parts.length === 3 && parts.every(Number.isFinite)) totalGoal = parts[0] * 3600 + parts[1] * 60 + parts[2];
else if (parts.length === 2 && parts.every(Number.isFinite)) totalGoal = parts[0] * 3600 + parts[1] * 60;
if (totalGoal) {
const distMap = { "5K": 5000, "10K": 10000, "Half Marathon": 21097, "Marathon": 42195 };
const goalDistMeters = distMap[activePlanSummary.raceDistance] || 42195;
const targetMeters = distMap[dataKey];
if (goalDistMeters === targetMeters) goalSec = totalGoal;
else goalSec = predictFromRace(goalDistMeters, totalGoal, targetMeters);
}
}
const yMin = data.reduce((m, d) => Math.min(m, d[dataKey]), goalSec || Infinity);
const yMax = data.reduce((m, d) => Math.max(m, d[dataKey]), goalSec || -Infinity);
const pad = Math.max(30, (yMax - yMin) * 0.1);
// Recharts pins ticks to the raw numeric domain endpoints
// when handed a hard [min,max], producing a lopsided final
// interval (e.g. 25/25/38 min). Snap the domain to a round
// time step and pass explicit, evenly-spaced ticks so every
// gridline gap is equal and labels land on clean values.
const axisLo0 = Math.max(0, yMin - pad);
const axisHi0 = yMax + pad;
const axisSpan = Math.max(1, axisHi0 - axisLo0);
const axisStep = [15, 30, 60, 120, 300, 600, 900, 1200, 1800]
.find(s => axisSpan / s <= 5) || 1800;
const axisMin = Math.floor(axisLo0 / axisStep) * axisStep;
const axisMax = Math.ceil(axisHi0 / axisStep) * axisStep;
const axisTicks = [];
if (Number.isFinite(axisMin) && Number.isFinite(axisMax) && axisStep > 0) {
for (let t = axisMin; t <= axisMax + 0.5 && axisTicks.length < 24; t += axisStep) axisTicks.push(t);
}
const fmtPaceTick = s => { const t = Math.round(s); const m = Math.floor(t / 60); return `${m}:${String(t % 60).padStart(2, "0")}`; };
const fmtDurTick = s => {
const t = Math.round(s); const h = Math.floor(t / 3600), m = Math.floor((t % 3600) / 60);
return h > 0 ? `${h}:${String(m).padStart(2, "0")}` : `${m}:${String(t % 60).padStart(2, "0")}`;
};
const tickFmt = dataKey === "5K" || dataKey === "10K" ? fmtPaceTick : fmtDurTick;
return (
<>
n === dataKey ? [fmt.duration(v), n] : [v, n]}
labelFormatter={l => `Week of ${l}`} />
{
const { cx, cy, payload } = props;
if (cx == null || cy == null) return null;
const isCalc = payload?.source === "calc";
// Faded hollow dot for calc-fallback weeks so the
// user sees where Garmin readings began.
return isCalc
?
: ;
}}
/>
{goalSec && (
)}
{(() => {
const calcCount = racePredHistory.filter(p => p.source === "calc").length;
return calcCount > 0 ? (
Garmin reading
derived from quality runs ({calcCount}w pre-Garmin)
) : null;
})()}
Each point is the predicted {dataKey} time given that week's Garmin VO₂max reading.
{goalSec && data.length > 0 && (() => {
const latest = data[data.length - 1][dataKey];
const gap = latest - goalSec;
return ` Latest: ${fmt.duration(latest)} — ${gap > 0 ? `${fmt.duration(gap)} off goal` : "ahead of goal"}.`;
})()}
);
})()}
)}
{/* Prediction Accuracy — backtest of the live engine against
every completed race: prediction replayed as-of the day
before, scored vs the actual finish. */}
{predictionBacktest && (
Prediction Accuracy
(engine replayed as-of the day before each race)
Positive miss = you ran slower than predicted (engine optimistic). Bias within ±2% and avg miss ≤3% is excellent for race prediction. Riegel exponent uses today's calibration (includes these races), a mild hindsight bias.
)}
{/* Goal Probability — the point prediction widened into honest
finish bands using the backtest's OWN error distribution
(bias + spread of past misses), not assumed variance. */}
{predictionBacktest && predictionBacktest.rows.length >= 3 && activePlanSummary?.raceDistance && (() => {
const distMap = { "5K": 5000, "10K": 10000, "10 Mile": 16093, "Half Marathon": 21097, "Half": 21097, "Marathon": 42195, "50K": 50000 };
const meters = distMap[activePlanSummary.raceDistance] || 42195;
const preds = predictRaceTimes(effectiveVO2, runs, riegelCalibration?.exponent, intentOpts);
const pred = preds && preds.find(p => p.meters === meters);
if (!pred) return null;
const errs = predictionBacktest.rows.map(r => r.errPct);
const n = errs.length;
const mu = errs.reduce((s, e) => s + e, 0) / n;
const sd = Math.sqrt(errs.reduce((s, e) => s + (e - mu) * (e - mu), 0) / (n - 1)) * Math.sqrt(1 + 1 / n);
if (!(sd > 0.2)) return null;
const at = (z) => Math.round(pred.seconds * (1 + (mu + z * sd) / 100));
const erf = (x) => { const s = x < 0 ? -1 : 1; x = Math.abs(x); const t = 1 / (1 + 0.3275911 * x); const y = 1 - (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * Math.exp(-x * x); return s * y; };
const cdf = (z) => 0.5 * (1 + erf(z / Math.SQRT2));
const cleaned = String(activePlanSummary.goalTime || "").replace(/^sub[- ]?/i, "");
const gp = cleaned.split(":").map(Number);
const goalSec = gp.length === 3 && gp.every(Number.isFinite) ? gp[0] * 3600 + gp[1] * 60 + gp[2] : gp.length === 2 && gp.every(Number.isFinite) ? gp[0] * 60 + gp[1] : null;
const pSub = goalSec ? Math.round(cdf(((goalSec / pred.seconds - 1) * 100 - mu) / sd) * 100) : null;
const pCol = pSub == null ? C.textMuted : pSub >= 65 ? C.green : pSub >= 40 ? C.amber : C.red;
return (
Goal Probability
({activePlanSummary.raceDistance} · bands from your {n} backtested races)
{pSub != null && (
{pSub}% chance of {activePlanSummary.goalTime}
)}
{[["Great day (10%)", at(-1.2816), C.green], ["Median", at(0), C.text], ["Rough day (90%)", at(1.2816), C.amber]].map(([lab, sec, col]) => (
{lab}
{fmt.duration(sec)}
))}
The point prediction widened by how the engine has actually missed on your races (bias {predictionBacktest.meanPct > 0 ? "+" : ""}{predictionBacktest.meanPct}%, spread ±{Math.round(sd * 10) / 10}%). 10%/90% = one-in-ten best/worst days. Tightens as more races accumulate.
);
})()}
{/* Fitness & Fatigue — Banister impulse-response model. CTL
(42-day weighted load) = fitness, ATL (7-day) = fatigue,
TSB = form (yesterday's fitness − fatigue). The classic
"am I peaking or digging a hole" chart: form goes negative
through a hard block, then climbs through the taper into
the +5..+25 race-ready window. */}
{fitnessFatigueModel && fitnessFatigueModel.points.length >= 14 && (() => {
const ffm = fitnessFatigueModel;
const chartData = ffm.points.slice(-120).map(p => ({
label: p.date.slice(5).replace("-", "/"), ctl: p.ctl, atl: p.atl, tsb: p.tsb,
}));
const cur = ffm.current;
const tsbColor = cur.tsb >= 5 ? C.green : cur.tsb >= -30 ? C.purple : C.red;
return (
Fitness & Fatigue
(Banister model · intensity-weighted TRIMP, all sports)
Form (TSB) = fitness − fatigue. Negative mid-build is productive training; +5..+25 on race morning is the target. A hard block drops form; the taper converts it.
{ffm.acwr && <> EWMA load ratio {ffm.acwr.ratio} ({ffm.acwr.flag}).}
{ffm.monotony && ffm.monotony.monotony > 2 && <> Monotony {ffm.monotony.monotony} — vary hard/easy days.}
);
})()}
{/* Durability — aerobic decoupling (Pa:HR drift) on long runs.
The strongest modern marathon-readiness signal: <5% on the
long stuff means pace and HR stayed coupled deep into the
run; a falling trend across a build is endurance arriving. */}
{(() => {
const toD = (x) => x.start_date?.toDate ? x.start_date.toDate() : new Date(x.start_date);
const pts = runs
.filter(r => (r.distance >= 10 * 1609.34) || ((r.moving_time || 0) >= 90 * 60))
.map(r => ({ d: toD(r), dec: r.dynamics?.aerobicDecouplingPct, mi: r.distance / 1609.34 }))
.filter(p => Number.isFinite(p.dec) && !isNaN(p.d.getTime()))
.sort((a, b) => a.d - b.d)
.slice(-24)
.map(p => ({ date: `${p.d.getMonth() + 1}/${p.d.getDate()}`, dec: Math.round(p.dec * 10) / 10, mi: Math.round(p.mi * 10) / 10 }));
if (pts.length < 3) return null;
const recent = pts.slice(-5);
const avgRecent = Math.round(recent.reduce((s, p) => s + p.dec, 0) / recent.length * 10) / 10;
const avgColor = avgRecent < 5 ? C.green : avgRecent < 10 ? C.amber : C.red;
return (
Durability
(aerobic decoupling on long runs — last {pts.length})
Decoupling = how much pace:HR efficiency decayed from the first half to the second. Under 5% on 16+ mi runs is the classic "marathon-ready" signal; a falling trend across the build is endurance arriving. Heat and hills inflate it — read trends, not single runs.
);
})()}
{/* Cycle Comparison — current race-prep cycle vs a previous one,
aligned by weeks-to-race rather than calendar date. Answers
the rear-view-mirror coaching question: "at 8 weeks out for
Philly I was at 45 mi/wk; today for NYC I'm at 32 mi/wk —
I'm 4 weeks behind where I was." */}
{pastRaces.length > 0 && activePlanSummary?.raceDate && (() => {
// Multi-overlay: cycleCmpRaceId is now treated as a
// comma-separated string of past race ids ("philly,shamrock")
// backed by the existing single-key state — keeps the
// state-shape compatible while supporting N comparisons.
const selectedIds = (cycleCmpRaceId || "").split(",").filter(Boolean);
// Default to the most recent past marathon when nothing's
// selected (preserves the prior single-overlay behavior).
const effectiveSelectedIds = selectedIds.length > 0
? selectedIds
: (pastRaces[0] ? [pastRaces[0].id] : []);
const selectedRaces = effectiveSelectedIds
.map(id => pastRaces.find(r => r.id === id))
.filter(Boolean);
const weeksOut = 16;
const allRuns = (activities || []).filter(a => a.type === "Run" || a.type === "VirtualRun");
const isQualityFn = (r) => {
const intent = classifyRunIntent(r);
return intent === "race" || intent === "hard";
};
const currentSeries = window.CycleComparison.buildCycleSeries({
raceDate: activePlanSummary.raceDate, runs: allRuns, weeksOut, isQualityFn,
});
// Distinct color per comparison cycle. Cycle through the
// palette deterministically based on selection order.
const palette = [C.amber, "#84cc16", C.purple || "#a78bfa", C.pink || "#f472b6", "#06b6d4"];
const labelOf = (r) => r.name || `${r.distance} ${new Date(r.date).toLocaleDateString("en-US", { month: "short", year: "numeric" })}`;
const comparisons = selectedRaces.map((r, i) => ({
id: r.id,
label: labelOf(r),
color: palette[i % palette.length],
series: window.CycleComparison.buildCycleSeries({
raceDate: r.date, runs: allRuns, weeksOut, isQualityFn,
}),
}));
const aligned = window.CycleComparison.alignCyclesMulti(currentSeries, comparisons, { weeksOut });
const metricLabels = {
mileage: { label: "Weekly Mileage", unit: "mi", color: C.cyan },
longestRun: { label: "Long Run", unit: "mi", color: C.green },
qualityRunCount: { label: "Quality Runs", unit: "/wk", color: C.amber },
runCount: { label: "Runs", unit: "/wk", color: C.purple || "#a78bfa" },
};
const m = metricLabels[cycleCmpMetric];
// Build chart data — current under "current" key, each
// comparison under its id.
const chartData = aligned.map(a => {
const row = {
wtr: a.weeksToRace,
label: a.weeksToRace === 0 ? "Race" : `-${a.weeksToRace}w`,
current: a.current ? a.current[cycleCmpMetric] : null,
};
for (const c of comparisons) {
row[c.id] = a.comparisons[c.id] ? a.comparisons[c.id][cycleCmpMetric] : null;
}
return row;
});
// Cumulative totals for the summary strip.
const sumOver = (key) => aligned.reduce((s, a) => {
const cell = key === "current" ? a.current : a.comparisons[key];
return s + (cell ? (cell[cycleCmpMetric] || 0) : 0);
}, 0);
const currentTotal = sumOver("current");
// Toggle a race in/out of the selection.
const togglePill = (raceId) => {
const next = effectiveSelectedIds.includes(raceId)
? effectiveSelectedIds.filter(id => id !== raceId)
: [...effectiveSelectedIds, raceId];
setCycleCmpRaceId(next.join(","));
};
return (
All cycles aligned by weeks-to-race — race week is W-0, far left is 16 weeks out. Click a race pill to toggle it on/off the chart. {m.label} on the y-axis.
);
})()}
{/* Recent Workouts Reviewed — coach-style fidelity grading
of the last quality + long sessions in the active plan.
Pulls each plan day with a linkedActivityId, matches the
activity, runs gradeWorkout (pure helper) and renders an
A-D grade with reasoning. Drops the page from "data
viewer" toward "actually coach-like." */}
{activePlanSummary?.weeks?.length > 0 && (() => {
// Walk the plan, collect quality/long plan days paired with the
// run that executed them. The activity comes from either an
// explicit linkedActivityId OR — for any past, non-skipped day —
// an auto-match on that plan-day's calendar date (longest run on
// the day = the session). Previously this only followed
// linkedActivityId, so the panel was frozen on the one workout
// the athlete had ever manually linked.
const QUALITY_TYPES = new Set(["tempo", "threshold", "intervals", "interval", "race_pace", "race", "long"]);
const DAY_OFFSET = { Monday: 0, Tuesday: 1, Wednesday: 2, Thursday: 3, Friday: 4, Saturday: 5, Sunday: 6 };
const isRunAct = (a) => a && (a.type === "Run" || a.type === "VirtualRun");
const actMs = (a) => {
const t = a?.start_date_local || a?.start_date;
return (typeof t === "string") ? Date.parse(t)
: (t?.toDate ? t.toDate().getTime() : (t?.seconds ? t.seconds * 1000 : 0));
};
const w1Start = window.PlanMath?.planWeek1Start?.(activePlanSummary);
const nowMs = Date.now();
const linked = [];
(activePlanSummary.weeks || []).forEach((week, wi) => {
(week?.days || []).forEach(d => {
if (d.skipped) return;
if (!QUALITY_TYPES.has((d.type || "").toLowerCase())) return;
// 1. Manual link wins.
let act = d.linkedActivityId ? (activities || []).find(a => String(a.id) === String(d.linkedActivityId)) : null;
// 2. Else auto-match a run on this plan-day's date (only once
// that date is in the past — don't pre-grade future days).
if (!act && w1Start) {
const lo = w1Start.getTime() + (wi * 7 + (DAY_OFFSET[d.day] ?? 0)) * 86400000;
const hi = lo + 86400000;
if (lo < nowMs) {
const cands = (activities || []).filter(a => isRunAct(a) && a.distance > 0 && actMs(a) >= lo && actMs(a) < hi);
act = cands.sort((a, b) => b.distance - a.distance)[0] || null;
}
}
if (!isRunAct(act)) return;
linked.push({ planDay: d, activity: act, weekNum: wi + 1, _ms: actMs(act) });
});
});
// Dedupe by activity id (a run could match more than one plan day
// in pathological cases), newest first, take 5.
const seenAct = new Set();
const reviewed = linked
.sort((a, b) => b._ms - a._ms)
.filter(({ activity }) => { const id = String(activity.id); if (seenAct.has(id)) return false; seenAct.add(id); return true; })
.slice(0, 5);
if (!reviewed.length) return null;
const hrZonesData = getHRZones(hrZoneConfig, activities, hrMethod, userHRConfig);
const fmtDate = (ms) => new Date(ms).toLocaleDateString("en-US", { month: "short", day: "numeric" }); // gradeColor: module-level
const ex = trainingSnapshot?.execution || null;
return (
Recent Workouts Reviewed
Last {reviewed.length} quality + long sessions, graded A-D on pace/zone fidelity
Tempo / threshold workouts graded on avg pace adherence vs targetPace (±5s/mi = A, ±15 = B, ±30 = C). Intervals / race-pace graded on whether avg HR landed inside the day's targetHR band (overall avg pace of a workout that mixes warmup + reps + recovery doesn't represent execution). Easy / long / recovery graded on the polarized zone. Distance gates apply (short or overcooked drops the grade).
);
})()}
{/* Today's Wellness — 30-second daily 1-10 self-rating
that flows into the Telegram coach context. The
"should I push or back off today?" judgement needs the
subjective signal alongside Garmin's objective metrics
(research consistently shows subjective inputs catch
overtraining earlier than HRV alone). Pre-fills with
yesterday's values to make daily entry one-tap. */}
{(() => {
// Pure-component-style block — internal state for the
// entry form, fetched docs from a small useEffect below.
const [wellnessDocs, setWellnessDocs] = useState([]);
const [wellnessForm, setWellnessForm] = useState({ sleep: 7, soreness: 4, motivation: 7, stress: 4, note: "" });
const [wellnessSaving, setWellnessSaving] = useState(false);
const [wellnessSavedAt, setWellnessSavedAt] = useState(null);
const todayISO = new Date().toISOString().split("T")[0];
const yesterdayISO = new Date(Date.now() - 86400000).toISOString().split("T")[0];
useEffect(() => {
if (!userId) return;
const cutoff = new Date(Date.now() - 14 * 86400000).toISOString().split("T")[0];
const unsub = db.collection("users").doc(userId).collection("wellness")
.orderBy(firebase.firestore.FieldPath.documentId(), "asc")
.startAt(cutoff)
.onSnapshot(snap => {
const docs = snap.docs.map(d => ({ date: d.id, ...d.data() }));
setWellnessDocs(docs);
// Pre-fill the form with today's entry if present, else yesterday's.
const today = docs.find(d => d.date === todayISO);
const yest = docs.find(d => d.date === yesterdayISO);
const seed = today || yest;
if (seed) {
setWellnessForm({
sleep: seed.sleep ?? 7,
soreness: seed.soreness ?? 4,
motivation: seed.motivation ?? 7,
stress: seed.stress ?? 4,
note: today?.note ?? "",
});
}
});
return () => unsub && unsub();
}, [userId, todayISO, yesterdayISO]);
const todayEntry = wellnessDocs.find(d => d.date === todayISO);
// Composite + interpretation match the lib's math.
const HIGHER = new Set(["sleep", "motivation"]);
const composite = (e) => {
if (!e) return null;
const fields = ["sleep", "soreness", "motivation", "stress"];
let s = 0, n = 0;
for (const k of fields) {
const v = e[k];
if (!Number.isFinite(v) || v < 1 || v > 10) continue;
s += HIGHER.has(k) ? v : (11 - v);
n += 1;
}
if (!n) return null;
return Math.round(((s / n) - 1) / 9 * 100);
};
const interpret = (s) => s == null ? null : s >= 80 ? "Ready" : s >= 60 ? "Decent" : s >= 40 ? "Compromised" : "Depleted";
const tagColor = (s) => s == null ? C.textMuted : s >= 80 ? C.green : s >= 60 ? C.cyan : s >= 40 ? C.amber : C.red;
const todayScore = composite(todayEntry);
const tagText = interpret(todayScore);
const submit = async () => {
setWellnessSaving(true);
try {
const fn = functions.httpsCallable("logWellness");
await fn({ ...wellnessForm, date: todayISO });
setWellnessSavedAt(Date.now());
} catch (e) { console.warn("[wellness] save failed:", e.message); }
setWellnessSaving(false);
};
const Slider = ({ label, value, lowerIsBetter, onChange }) => (
Race-day rehearsal = ≥{window.LongRunQuality.RACE_REHEARSAL_MIN_MI}mi within ±15s/mi of MP. MP simulation = ±30s/mi. Structure detection (progressive / fast-finish / mp-finish / fading) requires lap data — click into an activity to fetch it.
{/* LTHR refresh banner — auto-population is one-shot
so once the configured value lands it never updates,
even if Garmin re-measures threshold (which it does
every few weeks on intervals/tempos). When Garmin's
current reading differs from the configured value by
≥3 bpm, surface a one-click apply. */}
{(() => {
const garminLTHR = garminStats?.lactateThrHR && garminStats.lactateThrHR > 100
? Math.round(garminStats.lactateThrHR) : null;
const cfgLTHR = userHRConfig?.lthr || null;
if (!garminLTHR || !cfgLTHR) return null;
const delta = garminLTHR - cfgLTHR;
if (Math.abs(delta) < 3) return null;
const direction = delta > 0 ? "higher" : "lower";
const sev = Math.abs(delta) >= 8 ? C.amber : C.cyan;
return (
Garmin's current measurement is {garminLTHR} bpm — {Math.abs(delta)} bpm {direction} than your configured {cfgLTHR}. Threshold drifts as fitness changes, so the older value is likely stale.
{isOwner && (
)}
LT Progress {ltHistory[0]?.label ? `— since ${ltHistory[0].label}` : ""}
{ const m = Math.floor(v / 60); const s = Math.round(v % 60); return `${m}:${s.toString().padStart(2, "0")}`; }}
label={{ value: "Pace (/mi)", angle: 90, position: "insideRight", fill: C.textMuted, fontSize: 10 }} />
{
if (name.includes("Pace")) { const m = Math.floor(v/60); const s = Math.round(v%60); return [`${m}:${s.toString().padStart(2,"0")} /mi`, name]; }
return [name.includes("HR") ? `${v} bpm` : v, name];
}} />
{
const { cx, cy, payload } = props;
if (cx == null || cy == null) return null;
const isCalc = payload?.source === "calc";
return isCalc
?
: ;
}}
/>
{/* Anchor lines for the current measured/configured
values, so the chart's per-week derivations can be
read against the present-day truth. The historical
line is empirical/predicted (Garmin doesn't carry
a per-week LTHR/pace history), so the anchor
lines tell the runner where they actually are
right now. */}
{ltEstimates?.lt2?.pace && (
)}
{ltEstimates?.lt2?.hr && (
)}
{(() => {
const calcCount = ltHistory.filter(p => p.source === "calc").length;
return calcCount > 0 ? (
LT2 Pace from Garmin VO₂max
from quality runs ({calcCount}w pre-Garmin)
) : null;
})()}
Per-week values use the Garmin VO₂max reading on or before that Monday (falling back to a trailing 90d window of quality runs if no Garmin reading exists). Dotted reference lines show your current measured/configured LT2 — what the panel above is showing.
)}
)}
{/* Gait Profile — derived from Garmin run-dynamics. Tells the
shoe-pick logic (and the runner) what kind of stride
they have. No new input — all from existing per-activity
dynamics already on the activities collection. */}
{(() => {
const allRuns = (activities || []).filter(a => a.type === "Run" || a.type === "VirtualRun");
const gait = window.GaitProfile.buildGaitProfile({ runs: allRuns });
if (!gait || !gait.runCount) return null;
const cadColor = gait.cadenceClass === "high" ? C.green : gait.cadenceClass === "average" ? C.amber : C.red;
const effColor = gait.efficiencyClass === "efficient" ? C.green : gait.efficiencyClass === "average" ? C.amber : C.red;
const Stat = ({ label, value, unit, sub, color }) => (
{label}
{value != null ? value : "—"}
{value != null && unit && {unit}}
{sub &&
{sub}
}
);
return (
Gait Profile
(median across {gait.runCount} runs in last {gait.windowDays}d{gait.fastRunCount >= 3 ? `, fast = top ${gait.fastRunCount} by pace` : ""} · from Garmin run dynamics)
{(() => {
// Form Challenges & Suggestions — coach-style readout of
// which metrics fall outside healthy ranges, with one
// targeted drill / cue per issue. Keeps the suggestion
// surface honest: only shows what's actually flagged,
// not generic "do strides every week" boilerplate.
const issues = [];
// Pace-aware: if we have ≥3 fast runs, judge cadence /
// GCT / vert ratio off the fast-pace median. Cadence and
// stride length both rise with pace, so a long-legged
// runner whose easy cadence sits at 165 but who turns
// over at 182 at threshold should NOT see "low cadence"
// here. Only flag issues that persist at race effort.
const hasFast = gait.fastRunCount >= 3;
const judgeCad = hasFast && gait.cadenceSpmFast != null ? gait.cadenceSpmFast : gait.cadenceSpm;
const judgeGct = hasFast && gait.groundContactTimeMsFast != null ? gait.groundContactTimeMsFast : gait.groundContactTimeMs;
const judgeVR = hasFast && gait.verticalRatioPctFast != null ? gait.verticalRatioPctFast : gait.verticalRatioPct;
const paceQual = hasFast ? " at fast pace" : "";
if (judgeCad != null && judgeCad < 170) {
issues.push({
label: `Low cadence (${judgeCad} spm${paceQual})`,
fix: "Add 6×30s strides 2× / week at ~180 spm. Use a metronome on easy runs to nudge turnover up — short, quick steps cut overstriding.",
});
}
if (judgeGct != null && judgeGct > 280) {
issues.push({
label: `Long ground contact (${judgeGct} ms${paceQual})`,
fix: "Plyometrics 1×/week (pogo hops, A-skips, bounding 3×20m). Shorter contact ≈ more elastic recoil; the calf/Achilles needs to learn quicker rebound.",
});
}
if (judgeVR != null && judgeVR >= 9) {
issues.push({
label: `High vertical ratio (${judgeVR}%${paceQual})`,
fix: "Forward-lean cue + 6×30s hill strides. You're losing energy upward — drive forward off the ankle, not up off the knee.",
});
}
if (gait.gctBalance != null && Math.abs(gait.gctBalance - 50) > 1.5) {
const heavySide = gait.gctBalance > 50 ? "left" : "right";
issues.push({
label: `L/R asymmetry (${gait.gctBalance}% L)`,
fix: `Heavier on ${heavySide}. Single-leg work 2×/week (RDL, step-ups, calf raises) on the lighter side. Persistent >1.5% drift correlates with overuse on the loaded side.`,
});
}
if (!issues.length) {
return (
No form challenges flagged — cadence, GCT, efficiency, and L/R symmetry all within healthy ranges.
);
}
return (
Form Challenges & Suggestions
{issues.map((iss, i) => (
{iss.label} — {iss.fix}
))}
);
})()}
Used to bias the shoe-pick logic and (later) shopping recommendations. High cadence + low GCT + low vert osc suits low-stack low-drop shoes; low cadence + heel bias does better with cushioned high-drop trainers.
);
})()}
{/* Weekly Training Dimensions — endurance / VO2 / hills /
speed / aerobic / anaerobic / form scoring across the
last 4 completed weeks. Showing the in-progress current
week was misleading: on a Friday it reads "19mi total"
and the dimensions look terrible because half the week
hasn't happened yet. We pull 5 weeks back, drop weeks[0]
(the partial current week), and treat weeks[1] — the
most recently completed Mon-Sun — as "current". Trend
and persistent-deficit analysis run on the same 4
completed weeks. */}
{(() => {
if (!window.DeficitAnalysis) return null;
const allRuns = (activities || []).filter(a => a.type === "Run" || a.type === "VirtualRun");
if (!allRuns.length) return null;
// Derive easyHrCap from the athlete's actual Z1 ceiling so
// aerobic % isn't computed against the hardcoded default
// 145 bpm. When LTHR is correct, zones[0].maxBPM ≈ Z1 cap.
const easyHrCap = athleteProfile?.zones?.[0]?.maxBPM
|| (athleteProfile?.maxHR ? Math.round(athleteProfile.maxHR * 0.82) : 145);
const allWeeks = window.DeficitAnalysis.analyzeWeeks({ runs: allRuns, weeksBack: 5, easyHrCap });
if (!allWeeks || allWeeks.length < 2) return null;
const weeks = allWeeks.slice(1); // drop in-progress current week
const persistent = window.DeficitAnalysis.persistentDeficit(weeks, { threshold: 35 });
const trends = window.DeficitAnalysis.dimensionTrends(weeks);
const cur = weeks[0];
const dimOrder = ["endurance", "vo2", "hills", "speed", "aerobic", "anaerobic", "form"];
const labels = { endurance: "Endurance", vo2: "VO₂", hills: "Hills", speed: "Speed", aerobic: "Aerobic", anaerobic: "Anaerobic", form: "Form" };
const colorFor = (s) => s == null ? C.textMuted : s >= 70 ? C.green : s >= 40 ? C.amber : C.red;
const trendArrow = (t) => t === "improving" ? "↑" : t === "declining" ? "↓" : t === "stable" ? "→" : "";
const trendColor = (t) => t === "improving" ? C.green : t === "declining" ? C.red : C.textMuted;
return (
Weekly Training Dimensions
(last completed week · trend vs earlier weeks)
This week's weakest · {labels[cur.weakest.dimension]} · {cur.weakest.score}/100
Suggested drills:
{cur.weakest.drills.map((dr, i) =>
{dr}
)}
)}
Same deficit analysis the Telegram coach sees. ↑ improving · → stable · ↓ declining (vs prior weeks). Form is n/a when no Garmin run-dynamics data this week.
);
})()}
{/* Footwear + Shoe Recommendations now live on the dedicated
Shoes tab — see above Settings. The Summary tab
keeps a small pointer for muscle memory. */}
{(() => {
const haveGear = Array.isArray(gearList) && gearList.length > 0;
return (
Footwear
{haveGear
? <>Your shoe rotation, retirement bars, race-day pick, and shopping recs live on the Shoes tab.
: <>No shoes synced yet. Open Settings → Strava → Sync Now, then check the Shoes tab.}