Pulled from forecast for {wxForecast.location} — note: forecasts only reach 3 days out, useful in race week.
)}
)}
);
}
// ── Race Fueling card — the gut-training ledger + race-day fuel plan
// + carb-load protocol for an upcoming HM/marathon. All rules come
// from the mirrored RaceFueling lib; the gut ledger prefers the
// snapshot (racePrep.gutTraining), recomputing client-side through
// the same lib when the snapshot hasn't caught up.
// ── Goal Evidence card — demonstrated readiness gates (banked, not
// projected) for an upcoming goal race. Snapshot-first
// (racePrep.goalEvidence); client fallback recomputes through the
// same mirrored GoalEvidence lib (default Riegel exponent — the
// snapshot's calibrated one wins once it recomputes).
function GoalEvidenceCard({ race, goalTime, activities }) {
const { trainingSnapshot } = useData() || {};
const GE = window.GoalEvidence;
if (!GE || !race || !goalTime) return null;
const raceMs = race.date ? Date.parse(race.date) : NaN;
if (!Number.isFinite(raceMs) || raceMs < Date.now() - 86400000) return null;
const snapGe = trainingSnapshot?.racePrep?.goalEvidence;
const ge = (snapGe && snapGe.goalTimeSec === GE.parseGoalSec(goalTime))
? snapGe
: GE.goalEvidenceLedger({ activities: activities || [], goalTime, raceDistance: race.distance || "marathon", raceMath: window.RaceMath });
if (!ge) return null;
const pct = ge.gateCount ? ge.metCount / ge.gateCount : 0;
const headColor = pct >= 1 ? C.green : pct >= 0.5 ? C.amber : C.red;
return (
Goal Evidence — {race.name}
{ge.metCount}/{ge.gateCount} gates banked
Projections say what the model believes; gates say what you've demonstrated in the last {ge.windowDays / 7} weeks. A goal with unbanked gates is a hope, not a plan.
Race-day absorption is trained, not hoped for. The plan below is gated by what your gut has demonstrated on logged long runs — log fueling in the Training log's Athlete Log card to unlock higher rates.
{/* Gut-training ledger */}
Gut training — last {gut.windowDays || 70} days
{gut.fueledLongRuns}/{gut.longRuns} long runs fueled
{gut.bestCarbsPerHour != null && best {gut.bestCarbsPerHour} g/h}
{gut.giIssueRuns ? `GI issues ×${gut.giIssueRuns}` : "no GI issues logged"}
{gut.longRuns - gut.loggedLongRuns > 0 && {gut.longRuns - gut.loggedLongRuns} unlogged}
Carb-load targets need a recent weight reading (Health sync).
)}
);
}
function Races({ userId, activities, isOwner, hrZoneConfig }) {
const [races, setRaces] = useState([]);
const [showAdd, setShowAdd] = useState(false);
const [form, setForm] = useState({ name:"", date:"", distance:"marathon", goalTime:"", targetPace:"", notes:"" });
const [editingRace, setEditingRace] = useState(null); // race id being edited
const [editForm, setEditForm] = useState({ name:"", date:"", distance:"marathon", goalTime:"", targetPace:"", notes:"" });
const [qualityDetail, setQualityDetail] = useState({}); // { activityId: {laps,streams}|null } — detail docs for work-pace analysis
const { activePlan, healthEntries } = useData();
// Quality-session detection — shared by the lap prefetch below and
// the Pace Progress chart. Layered so warmup + recovery-jog dilution
// of the whole-run averages doesn't bury genuine tempo / interval
// workouts (the reason the chart kept reading "not enough sessions").
const QUALITY_PLAN_TYPES = { tempo:"Tempo", intervals:"Intervals", interval:"Intervals", threshold:"Threshold", race_pace:"Race Pace", race:"Race" };
const planQualityTypeById = {};
(activePlan?.weeks || []).forEach(w => (w.days || []).forEach(d => {
if (d.linkedActivityId && d.type) planQualityTypeById[String(d.linkedActivityId)] = (d.type || "").toLowerCase();
}));
// Two return shapes: tight match (plan-tagged or Strava-tagged or hard
// intent) means the chart should keep the dot even when work isolation
// fails and falls back to whole-run pace; loose match (max-speed gap or
// a linked "long" with possible MP segments) means the dot only renders
// if an analyzer actually isolates work — otherwise the whole-run avg
// misrepresents the session (a 5:40 rep set lands at 9:00+ once the
// jog rest is mixed in).
const qualityRunType = (r, obsMaxHR) => {
const pt = planQualityTypeById[String(r.id)];
if (pt && QUALITY_PLAN_TYPES[pt]) return { label: QUALITY_PLAN_TYPES[pt], loose: false };
if (r.workout_type === 1) return { label: "Race", loose: false };
if (r.workout_type === 3) return { label: "Quality", loose: false };
const intent = classifyRunIntent(r);
if (intent === "race") return { label: "Race", loose: false };
if (intent === "hard") return { label: "Quality", loose: false };
if (intent !== "easy" && obsMaxHR > 0 && r.max_heartrate && r.max_heartrate >= 0.92 * obsMaxHR) return { label: "Quality", loose: false };
// Named stride / pickup sessions. The athlete tags these in the
// activity name, so trust the name even when the run reads "easy"
// overall (strides tacked onto a shakeout) or carries no max_speed
// (treadmill) — both cases the max-speed gap below never catches.
// Loose: the analyzers still have to isolate the burst, so a run
// merely *mentioning* strides with no fast segment drops out.
if (/\bstrides?\b|\bpick.?ups?\b/.test(String(r.name || "").toLowerCase())) return { label: "Strides", loose: true };
// Loose detection — needs work isolation to render.
if (pt === "long" && r.distance > 9000) return { label: "Long-Quality", loose: true };
// Top-speed vs average gap. Strava's max_speed is a 1s peak so it
// false-positives on GPS glitches; a ≥20% gap on a run that's also
// ≥2 mi long filters most of those while still surfacing genuine
// pace surges (strides, MP segments, accidentally hard finishes).
const avg = r.average_speed || 0, mx = r.max_speed || 0;
if (avg > 0 && mx > 0 && mx >= avg * 1.20 && r.distance >= 3200) return { label: "Quality", loose: true };
return null;
};
// Prefetch cached laps + streams for every quality session in the
// chart window so the work-rep pace (work/rest split) can replace the
// jog-diluted whole-run average on the Pace Progress chart.
useEffect(() => {
if (!userId) return;
const acts = (activities || []).filter(a => a.type === "Run" || a.type === "VirtualRun");
const obsMaxHR = Math.max(150, ...acts.map(a => a.max_heartrate || 0));
const cutoff = Date.now() - 16 * 7 * 86400000;
const ids = new Set();
acts.forEach(a => {
if (!a.id) return;
const rd = a.start_date?.toDate ? a.start_date.toDate() : new Date(a.start_date);
if (!(rd.getTime() >= cutoff)) return;
if (qualityRunType(a, obsMaxHR)) ids.add(String(a.id));
// Long runs always get a detail prefetch — even if qualityRunType
// returns null we still want to peek at the stream to detect any
// embedded MP/HMP segment that would upgrade the dot.
if (a.distance > 14000) ids.add(String(a.id));
});
ids.forEach(id => {
if (qualityDetail[id] !== undefined) return;
setQualityDetail(prev => prev[id] !== undefined ? prev : { ...prev, [id]: null });
db.collection("users").doc(userId).collection("activities").doc(id)
.collection("detail").doc("laps").get()
.then(async doc => {
const d = doc.exists ? (doc.data() || {}) : {};
const haveStreams = Array.isArray(d.streams) && d.streams.length > 0;
const haveLaps = Array.isArray(d.laps) && d.laps.length > 0;
// No cached streams/laps → ask the cloud function to pull from
// Strava. Without this the chart silently uses whole-run avg
// (warmup + work + recovery diluted together), which is what
// made a 4×10min @ 6:59 session read as 8:15/mi.
if (!haveStreams && !haveLaps) {
try {
const fn = functions.httpsCallable("fetchActivityDetail");
const res = await fn({ activityId: id });
const r = res?.data || {};
setQualityDetail(prev => ({ ...prev, [id]: {
laps: Array.isArray(r.laps) ? r.laps : [],
streams: Array.isArray(r.streams) ? r.streams : [],
} }));
return;
} catch (_) {
// Fall through to whatever (empty) cache had.
}
}
setQualityDetail(prev => ({ ...prev, [id]: {
laps: Array.isArray(d.laps) ? d.laps : [],
streams: Array.isArray(d.streams) ? d.streams : [],
} }));
})
.catch(() => setQualityDetail(prev => ({ ...prev, [id]: { laps: [], streams: [] } })));
});
}, [userId, activities, activePlan]);
// The active training plan is the single source of truth for the
// goal of its target race; a races-collection entry for the same
// race only mirrors it for display/pacing here.
const isPlanRace = (r) =>
activePlan?.raceName && r?.name &&
String(r.name).trim().toLowerCase() === String(activePlan.raceName).trim().toLowerCase();
const effGoal = (r) =>
(isPlanRace(r) && activePlan?.goalTime) ? activePlan.goalTime : (r?.goalTime || "");
useEffect(() => {
if (!userId) return;
const unsub = db.collection("users").doc(userId).collection("races")
.orderBy("date","asc").onSnapshot(snap => {
setRaces(snap.docs.map(d => ({ id:d.id, ...d.data() })));
});
return unsub;
}, [userId]);
const addRace = async () => {
if (!form.name || !form.date) return;
await db.collection("users").doc(userId).collection("races").add({
...form, createdAt: firebase.firestore.FieldValue.serverTimestamp()
});
setForm({ name:"", date:"", distance:"marathon", goalTime:"", targetPace:"", notes:"" });
setShowAdd(false);
};
const startEdit = (race) => {
setEditingRace(race.id);
setEditForm({
name: race.name||"", date: race.date||"", distance: race.distance||"marathon",
goalTime: race.goalTime||"", targetPace: race.targetPace||"",
actualTime: race.actualTime||"", notes: race.notes||"",
});
};
const updateRace = async () => {
if (!editingRace || !editForm.name || !editForm.date) return;
await db.collection("users").doc(userId).collection("races").doc(editingRace).update(editForm);
setEditingRace(null);
};
const deleteRace = async (raceId) => {
if (!confirm("Delete this race?")) return;
await db.collection("users").doc(userId).collection("races").doc(raceId).delete();
if (editingRace === raceId) setEditingRace(null);
};
// Blended race time projections (Daniels VDOT + Riegel) — Garmin
// VO2max is the canonical source (matches Status panel + Analytics
// Race Calc); calc-from-runs is only the fallback when no Garmin
// reading exists.
const runs = activities.filter(a=>a.type==="Run"||a.type==="VirtualRun").sort((a,b)=>b.start_date?.seconds-a.start_date?.seconds);
// Garmin VO2max is noisy day-to-day (45↔56 depending on whether the
// last run was a Z1 treadmill jog or a quality effort). Anchoring
// the projection on the single latest reading let one base run
// swing "realistic" by 30min. Use the median of recent readings —
// robust to the swing, still tracks genuine fitness change.
const recentGarminVO2 = (healthEntries || [])
.filter(h => h?.garminVO2max > 30 && h.date)
.sort((a, b) => (b.date || "").localeCompare(a.date || ""))
.slice(0, 21)
.map(h => h.garminVO2max)
.sort((a, b) => a - b);
const robustGarminVO2 = recentGarminVO2.length
? recentGarminVO2[Math.floor(recentGarminVO2.length / 2)]
: undefined;
const effectiveVO2 = robustGarminVO2 || calcEffectiveVO2max(runs, 90);
const projections = predictRaceTimes(effectiveVO2, runs);
const upcomingRaces = races.filter(r => new Date(r.date) >= new Date());
const pastRaces = races.filter(r => new Date(r.date) < new Date());
return (
{/* Readiness hero — score + projected-vs-goal delta. The
previous version stacked four ScoreBars (Volume / Long
Run / Fitness / Consistency) anchored on whole-plan
targets, which duplicated the phase-specific bars
rendered just below in the End-of-Phase Goals panel
with different denominators (whole plan vs current
phase) and confused the read. For race prep the
actionable framing is "where am I against my goal?"
+ "what does this phase demand?" — so we collapse the
top to a single hero and let the phase view carry the
detailed milestone progress. */}
{overallReadiness}
{readinessLabel}
{(() => {
// One-line readiness narrative. Three cases:
// 1. No quality effort in 90d → don't fabricate
// a projection from VO2max alone. Prompt for
// a tempo/race effort instead.
// 2. Have a projection but no goal → just show
// the projected time on its own.
// 3. Have both → show projection + goal + gap.
if (!recentQuality) {
return
No race-effort run in last 90d — projection requires a recent tempo, race, or sustained quality effort.
;
}
if (!adjustedProjectedSec || !goalSec) {
return
Phase progress and milestones below.
;
}
// Confidence bands — A/B/C goals with rough probability,
// computed from quality-effort variance + Riegel
// extrapolation + weeks-out uncertainty. Replaces the
// single "+1:05 to close" gap with the more honest
// "fitness floor 3:15 / realistic 3:05 / stretch 2:58"
// framing a coach actually uses.
const distMetersMap = { "5K": 5000, "10K": 10000, "half": 21097, "marathon": 42195 };
const targetMeters = distMetersMap[race.distance] || 42195;
const bestEffortM = recentQuality?.dist || null;
const weeksOut = Math.max(0, Math.ceil(daysAway / 7));
const bands = window.GoalConfidence.confidenceProjection({
pointEstimateSec: projectedSec, // pre-course-adjustment point estimate
targetMeters, bestEffortMeters: bestEffortM,
weeksOut, runs, courseAdjustSec: courseAdjSec || 0,
// Past races feed PR-anchoring so the bands don't
// underestimate proven capability.
pastRaces: (pastRaces || []).map(r => ({
distance: r.distance,
timeSec: r.timeSeconds || r.timeSec || (r.time && /^\d+:\d+(:\d+)?$/.test(r.time) ? r.time.split(":").reduce((a, b) => Number(a) * 60 + Number(b)) : null),
date: r.date,
})).filter(r => r.timeSec),
});
if (!bands) {
// Fall back to the original single-line format
const gap = adjustedProjectedSec - goalSec;
const ahead = gap < 0;
const gapAbs = Math.abs(gap);
const gapStr = gapAbs >= 60
? `${Math.floor(gapAbs / 60)}:${String(Math.round(gapAbs % 60)).padStart(2, "0")}`
: `${Math.round(gapAbs)}s`;
const gapColor = ahead ? C.green : gap < 120 ? C.amber : C.red;
return (
{sub3Prob.prob < 15 ? "Significant gap to close. Focus on building consistent volume (30+ mi/wk) before speed work." :
sub3Prob.prob < 35 ? "Achievable with dedicated training. Volume and long runs are the priority over the next 8-12 weeks." :
sub3Prob.prob < 60 ? "On track but needs sustained effort. Don't skip long runs and maintain 4-5 runs per week minimum." :
"Strong position. Execute the plan, stay healthy, and trust the process."}
)}
{/* Course Strategy — only for known courses */}
{course && (
Course Strategy: {race.name} ({course.elevGainFt}ft elevation gain, {course.bridges.length} bridges)
{course.bridges.map((b, bi) => (
Mile {b.mile}
{b.name} (+{b.gainFt}ft)
{b.note}
))}
TRAINING RECOMMENDATIONS
{course.trainingRecs.map((rec, ri) => (
→ {rec}
))}
)}
{/* Overall Progress Chart — readiness % over time */}
{(() => {
const raceDate = new Date(race.date);
const sixMonthsAgo = new Date(raceDate); sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 8);
const firstRunDate = runs.length > 0 ? (() => {
const dates = runs.map(r => r.start_date?.toDate ? r.start_date.toDate() : new Date(r.start_date));
return new Date(Math.min(...dates));
})() : sixMonthsAgo;
const trainingStart = new Date(Math.max(firstRunDate.getTime(), sixMonthsAgo.getTime()));
const totalWeeks = Math.ceil((raceDate - trainingStart) / (7*86400000));
const nowMs = Date.now();
// S-curve target trajectory (0→100%)
const k = 8;
const sCurveNorm = (pct) => {
const raw = 1 / (1 + Math.exp(-k * (pct - 0.45)));
const min = 1 / (1 + Math.exp(-k * (-0.45)));
const max = 1 / (1 + Math.exp(-k * (1 - 0.45)));
return (raw - min) / (max - min);
};
const progressData = [];
for (let w = 0; w <= totalWeeks; w++) {
const weekDate = new Date(trainingStart.getTime() + w * 7 * 86400000);
const weekLabel = weekDate.toLocaleDateString("en-US", { month: "short", day: "numeric" });
const pct = w / totalWeeks;
const targetPct = Math.round(sCurveNorm(pct) * 100);
// Compute actual readiness at this week from cumulative data up to this point
let actual = null;
if (weekDate <= new Date(nowMs + 86400000)) {
const wEnd = new Date(weekDate.getTime() + 7 * 86400000);
// 4-week rolling window for metrics
const w4Start = new Date(wEnd.getTime() - 28 * 86400000);
const windowRuns = runs.filter(r => {
const rd = r.start_date?.toDate ? r.start_date.toDate() : new Date(r.start_date);
return rd >= w4Start && rd < wEnd && r.distance > 0;
});
if (windowRuns.length > 0) {
// Volume: weekly avg miles vs target (race distance * 0.6/wk)
const totalMi = windowRuns.reduce((s,r) => s + r.distance/1609.34, 0);
const avgWeeklyMi = totalMi / 4;
const volScore = Math.min(100, (avgWeeklyMi / (raceDistMi * 0.6)) * 100);
// Long run: longest in window vs 75% race dist
const longest = Math.max(...windowRuns.map(r => r.distance/1609.34));
const lrScore = Math.min(100, (longest / (raceDistMi * 0.75)) * 100);
// Fitness: Riegel-projected pace vs goal
let fitScore = 50;
if (goalSec) {
const best = windowRuns.filter(r => r.distance > 1500 && r.moving_time > 0);
if (best.length > 0) {
const projTimes = best.map(r => r.moving_time * Math.pow(raceDist / r.distance, 1.06));
const bestProj = Math.min(...projTimes);
fitScore = Math.min(100, (goalSec / bestProj) * 100);
}
}
// Consistency: weeks with 3+ runs out of last 4
let consWeeks = 0;
for (let cw = 0; cw < 4; cw++) {
const cwStart = new Date(w4Start.getTime() + cw * 7 * 86400000);
const cwEnd = new Date(cwStart.getTime() + 7 * 86400000);
const cwRuns = runs.filter(r => {
const rd = r.start_date?.toDate ? r.start_date.toDate() : new Date(r.start_date);
return rd >= cwStart && rd < cwEnd;
});
if (cwRuns.length >= 3) consWeeks++;
}
const consScore = Math.min(100, (consWeeks / 4) * 100);
actual = Math.round(volScore * 0.25 + lrScore * 0.25 + fitScore * 0.3 + consScore * 0.2);
}
}
progressData.push({ week: weekLabel, target: targetPct, actual, isFuture: weekDate > new Date(nowMs) });
}
// Smooth actual with 3-week rolling avg
const smoothed = progressData.map((d, i) => {
if (d.actual === null) return { ...d, smoothed: null };
const win = [d.actual];
if (i > 0 && progressData[i-1].actual != null) win.push(progressData[i-1].actual);
if (i > 1 && progressData[i-2].actual != null) win.push(progressData[i-2].actual);
return { ...d, smoothed: Math.round(win.reduce((s,v)=>s+v,0) / win.length) };
});
const latestActual = smoothed.filter(d => d.smoothed != null).pop();
const currentPct = latestActual ? latestActual.smoothed : 0;
const latestTarget = latestActual ? smoothed[smoothed.indexOf(latestActual)]?.target : 0;
const delta = currentPct - latestTarget;
const statusColor = delta >= 0 ? C.green : delta >= -15 ? C.amber : C.red;
/* Status reflects "actual readiness vs the generic S-curve trajectory for today",
NOT "plan adherence". Following the plan should track near the curve, not exceed it. */
const statusText = delta >= 5 ? "Above trajectory" : delta >= -5 ? "On trajectory" : delta >= -15 ? "Slightly below" : "Below trajectory";
return (
100% = peak race fitness on race day. Score blends volume (25%), longest long run (25%), pace fitness (30%), and consistency (20%) from your actual training data. The dashed line is a generic readiness curve, not your plan.
{/* ComposedChart, not AreaChart — Recharts'
AreaChart only natively renders Area
children, so the Line below was silently
being dropped. The orange target S-curve
now appears alongside the green Area. */}
v + "%"} axisLine={false} tickLine={false} width={38} />
{
if (!active || !payload || !payload.length) return null;
return (
{label}
{payload.map((p, i) => p.value != null && (
{p.name}:{p.value}%
))}
);
}} />
Target (S-curve)Actual readiness
);
})()}
{/* Plan Compliance — prescribed weekly mileage vs actual logged miles.
Concrete grounded-in-miles companion to the readiness chart, since
"% of plan" only makes sense when both numerator and denominator
come from the actual prescribed plan (not a generic S-curve). */}
{activePlan?.weeks?.length > 0 && (() => {
// All week-date math + actual-mileage credit goes
// through PlanMath so this chart, the Weekly Mileage
// chart, and per-week cards all agree on (a) which
// calendar Monday a given plan week starts on and
// (b) which runs count toward each week's total.
if (!window.PlanMath.planWeek1Start(activePlan)) return null;
const nowMs = Date.now();
const data = activePlan.weeks.map((week, wi) => {
const range = window.PlanMath.weekDateRange(activePlan, wi);
const wkStart = range.start;
const wkEnd = range.end;
const wkLabel = wkStart.toLocaleDateString("en-US", { month: "short", day: "numeric" });
const prescribed = Math.round(window.PlanMath.plannedMiForWeek(week));
const isFuture = wkStart > new Date(nowMs);
const isCurrent = wkStart <= new Date(nowMs) && wkEnd > new Date(nowMs);
const actual = isFuture
? null
: Math.round(window.PlanMath.actualMiForWeek(activePlan, wi, activities) * 10) / 10;
return { week: wkLabel, prescribed, actual, isCurrent, isFuture };
});
/* Compliance summary: only count fully-completed weeks (skip the
in-progress one to avoid scoring against a partial number). Cap
a single week at 120% so one heroic over-mileage week doesn't
mask under-execution elsewhere. */
const completed = data.filter(d => !d.isCurrent && !d.isFuture && d.actual != null && d.prescribed > 0);
const compliancePct = completed.length > 0
? Math.round(completed.reduce((s, d) => s + Math.min(120, (d.actual / d.prescribed) * 100), 0) / completed.length)
: null;
const compColor = compliancePct == null ? C.textMuted : compliancePct >= 90 ? C.green : compliancePct >= 70 ? C.amber : C.red;
const compText = compliancePct == null ? "" : compliancePct >= 90 ? "On plan" : compliancePct >= 70 ? "Mostly on plan" : "Behind plan";
return (
Plan Compliance
{compliancePct != null && (
{compliancePct}%{compText}
)}
Bars = prescribed mileage from your plan. Line = actual logged miles. 100% = doing the plan exactly. Skips the in-progress week.
);
})()}
{/* Curated course profile + per-mile pacing strategy for
this race (renders only if the race name matches a
catalog entry: NYC, Boston, Chicago, London, Berlin,
Tokyo). Mirrors the card on the Summary tab. */}
);
})}
{/* Add race form */}
{showAdd && (