/* Training mode — Hero Set redesign. All session/persistence logic identical to original (Supabase sync, push-over scheduling, plan-diff prompt, swap-exercise sheet, rest timer, abandon flow). */ const { useState: useStateT, useEffect: useEffectT, useRef: useRefT } = React; // ── Debug log ──────────────────────────────────────────────────────────────── window._dbg = window._dbg || []; window._log = window._log || ((msg) => { const entry = { t: Date.now(), msg }; window._dbg.push(entry); if (window._dbg.length > 1000) window._dbg.shift(); }); const _log = window._log; // Patch console so DebugPanel captures it like DevTools if (!window._consolePatched) { window._consolePatched = true; // console.log / warn / error ['log', 'warn', 'error'].forEach(level => { const orig = console[level]; console[level] = (...args) => { window._log(`[${level.toUpperCase()}] ${args.map(a => { try { return typeof a === 'object' ? JSON.stringify(a) : String(a); } catch (_) { return String(a); } }).join(' ')}`); orig.apply(console, args); }; }); // Uncaught JS exceptions window.addEventListener('error', e => { window._log(`[UNCAUGHT] ${e.message} @ ${(e.filename || '').split('/').pop()}:${e.lineno}`); }); // Unhandled promise rejections window.addEventListener('unhandledrejection', e => { const reason = e.reason instanceof Error ? e.reason.message : String(e.reason ?? 'unknown'); window._log(`[PROMISE] ${reason}`); }); // Fetch — log every request and its response const origFetch = window.fetch; window.fetch = async (...args) => { const url = typeof args[0] === 'string' ? args[0] : (args[0]?.url || '?'); const method = (args[1]?.method || 'GET').toUpperCase(); const short = url.replace(/^https?:\/\/[^/]+/, '').slice(0, 80); window._log(`[FETCH →] ${method} ${short}`); try { const res = await origFetch(...args); window._log(`[FETCH ${res.ok ? '✓' : '✗'}] ${res.status} ${method} ${short}`); return res; } catch (err) { window._log(`[FETCH ERR] ${method} ${short} — ${err.message}`); throw err; } }; // WebSocket — log Realtime connection state changes const _OrigWS = window.WebSocket; window.WebSocket = function(url, protocols) { const short = String(url).replace(/^wss?:\/\/[^/]+/, '').slice(0, 70); window._log(`[WS] connect → ${short}`); const ws = protocols !== undefined ? new _OrigWS(url, protocols) : new _OrigWS(url); ws.addEventListener('open', () => window._log('[WS] open')); ws.addEventListener('close', e => window._log(`[WS] close code=${e.code} reason=${e.reason || '-'}`)); ws.addEventListener('error', () => window._log('[WS] error')); return ws; }; } // ───────────────────────────────────────────────────────────────────────────── function KgInput({ value, onChange, done, style, onActivate, kbRaw, isKbActive }) { const fmt = v => v != null ? String(v).replace('.', ',') : ''; const [raw, setRaw] = useStateT(() => fmt(value)); const focused = useRefT(false); useEffectT(() => { if (!focused.current && !isKbActive) setRaw(fmt(value)); }, [value, isKbActive]); if (onActivate !== undefined) { return ( { e.preventDefault(); e.stopPropagation(); if (!done) onActivate(); }} /> ); } return ( { focused.current = true; e.target.select(); }} onBlur={() => { focused.current = false; const num = raw === '' ? null : parseFloat(raw.replace(',', '.')); setRaw(num != null ? fmt(num) : ''); }} onChange={e => { const str = e.target.value; setRaw(str); const num = str === '' ? null : parseFloat(str.replace(',', '.')); if (str === '' || !isNaN(num)) onChange(num ?? null); }} /> ); } // ─── Plate Calculator ──────────────────────────────────────────────── const PLATES_KG = [20, 10, 5, 2.5, 1.25, 0.75, 0.5, 0.25]; const PLATE_COLORS = { 20:'#2471a3', 10:'#1a1a1a', 5:'#1e8449', 2.5:'#ca6f1e', 1.25:'#148f77', 0.75:'#808b96', 0.5:'#808b96', 0.25:'#808b96' }; const PLATE_TEXT = { 20:'#fff', 10:'#ccc', 5:'#fff', 2.5:'#fff', 1.25:'#fff', 0.75:'#fff', 0.5:'#fff', 0.25:'#fff' }; const PLATE_SIZE = { 20: 64, 10: 56, 5: 48, 2.5: 42, 1.25: 36, 0.75: 30, 0.5: 30, 0.25: 30 }; function calcPlates(weight) { const result = []; let rem = Math.round(weight * 1000) / 1000; for (const p of PLATES_KG) { const n = Math.floor(rem / p + 1e-9); if (n > 0) { result.push({ p, n }); rem = Math.round((rem - p * n) * 1000) / 1000; } } return { plates: result, remainder: rem }; } function PlateCalcSheet({ open, onClose, initialWeight }) { const [tab, setTab] = useStateT(0); const [raw, setRaw] = useStateT(''); const [fresh, setFresh] = useStateT(false); const prevOpen = useRefT(false); useEffectT(() => { if (open && !prevOpen.current) { setRaw(initialWeight != null ? String(initialWeight).replace('.', ',') : ''); setFresh(initialWeight != null); } prevOpen.current = open; }, [open, initialWeight]); const target = parseFloat(raw.replace(',', '.')) || 0; const perSide = tab === 0 ? target / 2 : target; const { plates, remainder } = calcPlates(perSide); // round up per-side to next achievable multiple of smallest plate const sides = tab === 0 ? 2 : 1; const correctedTotal = remainder > 0.01 ? (() => { const smallest = PLATES_KG[PLATES_KG.length - 1]; // 0.25 const units = Math.round(smallest * 1000); const newPerSide = Math.ceil(Math.round(perSide * 1000) / units) * units / 1000; return Math.round(newPerSide * sides * 1000) / 1000; })() : null; const correctionDelta = correctedTotal !== null ? Math.round((correctedTotal - target) * 1000) / 1000 : null; return ( {/* Segmented control */}
{['Dual side', 'Single'].map((l, i) => ( ))}
{/* Weight input — large, centered */}
e.preventDefault()} style={{ background: 'transparent', border: 'none', outline: 'none', color: UI.ink, fontFamily: UI.fontNum, fontSize: 48, fontWeight: 300, letterSpacing: '-0.03em', textAlign: 'center', width: '100%', boxSizing: 'border-box', paddingBottom: 8, caretColor: 'transparent', userSelect: 'none', }} /> KG
{/* Per-side hint */}
{tab === 0 && target > 0 && (
{perSide} KG PER SIDE
)}
{/* Plate circles */} {target > 0 && ( plates.length > 0 ? (
{plates.map(({ p, n }) => { const size = PLATE_SIZE[p] || 32; const hole = Math.round(size * 0.3); return (
{p} × {n}
); })}
) : (
NO PLATES NEEDED
) )} {correctionDelta !== null && (
CAN'T REACH EXACTLY — {correctionDelta} KG MISSING
)} {/* Inline numpad — avoids native keyboard / floating cursor */}
{['7','8','9','4','5','6','1','2','3',',','0','⌫'].map(k => ( ))}
); } // ─── Custom Keyboard ────────────────────────────────────────────────── function CustomKeyboard({ visible, field, onType, onBackspace, onAdjust, onConfirm, onDismiss, onPlateCalc }) { if (!visible) return null; const isKg = field === 'kg'; const H = 40; const base = { background: 'var(--bg-raised)', border: `0.5px solid var(--hair)`, borderRadius: 8, color: 'var(--ink)', fontFamily: '"JetBrains Mono", monospace', fontSize: 18, fontWeight: 500, cursor: 'pointer', display: 'flex', alignItems: 'center', justifyContent: 'center', WebkitTapHighlightColor: 'transparent', userSelect: 'none', padding: 0, }; const act = { ...base, background: 'var(--bg-inset)', color: 'var(--ink-soft)', fontSize: 13, fontFamily: '"Inter", sans-serif' }; return (
{ e.preventDefault(); e.stopPropagation(); }} onTouchStart={e => { e.preventDefault(); e.stopPropagation(); }} style={{ position: 'fixed', bottom: 0, left: 0, right: 0, zIndex: 95, background: 'var(--bg)', borderTop: `0.5px solid var(--hair)`, padding: `5px 8px calc(env(safe-area-inset-bottom, 0px) + 5px)`, }}>
{/* Row 1: ↓ 🏋 ↑ | ✓ (spans rows 1-4) */} {/* Row 2: 1 2 3 */} {[1,2,3].map(n => )} {/* Row 3: 4 5 6 */} {[4,5,6].map(n => )} {/* Row 4: 7 8 9 */} {[7,8,9].map(n => )} {/* Row 5: , 0 ⌫ | ⌄ */}
); } function TrainingScreen(props) { const session = props.store.sessions.find(s => s.id === props.sessionId); // Redirect from an effect — never call go() during render, and never return // before the hooks below. The inner component mounts only when the session // exists, so its hook order stays stable even if the session disappears // mid-workout (abandon, delete, cross-device sync). useEffectT(() => { if (!session) props.go({ name: 'home' }); }, [!!session]); if (!session) return null; return ; } function TrainingScreenInner({ store, setStore, go, sessionId, userId, session }) { useEffectT(() => { if (!('wakeLock' in navigator)) return; let lock = null; const acquire = async () => { try { lock = await navigator.wakeLock.request('screen'); } catch {} }; const onVisibility = () => { if (!document.hidden) acquire(); }; acquire(); document.addEventListener('visibilitychange', onVisibility); return () => { document.removeEventListener('visibilitychange', onVisibility); lock?.release(); }; }, []); const _sch = store.schedules?.find(s => s.id === session.scheduleId); const isWeekdayMode = _sch ? LB.isWeekdayPlan(_sch) : false; const exIdx = session.currentExIdx || 0; const entry = session.entries[exIdx]; const exercise = entry ? LB.findExercise(store, entry.exId) : null; const last = entry ? LB.lastSessionForExercise(store, entry.exId, session.dayId) : null; const isUnilateral = !!exercise?.unilateral; const progressionTarget = (() => { if (!store.settings?.smartProgression) return null; const base = (exercise?.progression_reps ?? entry?.plannedReps) ?? 0; const target = base + (store.settings?.progressionRangeTop ?? 4); return target > 0 ? target : null; })(); // Keep the reducer pure — no logging or Error().stack side effects inside // setStore (React may invoke updaters more than once). fn only runs for the // matching session, so a vanished session is a safe no-op. const updateSession = (fn) => { setStore(s => ({ ...s, sessions: s.sessions.map(x => x.id === session.id ? fn(x) : x), })); }; const updateSet = (setIdx, patch) => { if ('done' in patch) _log(`updateSet(${setIdx}, done=${patch.done})`); updateSession(sess => ({ ...sess, entries: sess.entries.map((e, i) => i === exIdx ? { ...e, sets: e.sets.map((st, k) => k === setIdx ? { ...st, ...patch } : st) } : e), })); }; const isImprovement = (st, prevSet) => { if (!prevSet || st.kg == null || prevSet.kg == null) return false; const repsA = LB.effReps(st); const repsB = LB.effReps(prevSet); if (repsA == null || repsB == null) return false; return (st.kg > prevSet.kg && repsA >= repsB - 2) || (st.kg >= prevSet.kg && repsA > repsB); }; const isDecline = (st, prevSet) => { if (!prevSet || !st || st.skipped || prevSet.skipped) return false; if (st.kg == null || prevSet.kg == null) return false; const rA = LB.effReps(st); const rB = LB.effReps(prevSet); if (rA == null || rB == null) return false; return (st.kg < prevSet.kg && rA <= rB) || (st.kg === prevSet.kg && rA < rB); }; const completeSet = (setIdx) => { const isLastWarmupSet = !!entry.sets[setIdx]?.warmup && !entry.sets.slice(setIdx + 1).some(s => s.warmup); const kb = kbFieldRef.current; const rawRef = kbRawRef.current; _log(`completeSet(${setIdx}) kb=${kb?.field ?? 'none'} raw='${rawRef}'`); kbFieldRef.current = null; kbRawRef.current = ''; kbFreshRef.current = false; setKbField(null); setKbRaw(''); setKbFresh(false); armKbShield(); recentCompleteRef.current[setIdx] = Date.now(); lastCompleteRef.current = Date.now(); _log(`completeSet(${setIdx}) → lastCompleteRef stamped`); // Build the done patch inside the functional updater so we can read the // latest queued session state and take the max of ref value vs. session // value. This wins regardless of which kbApply calls have flushed yet. updateSession(sess => { const currSet = sess.entries[exIdx]?.sets[setIdx]; if (!currSet) return sess; const patch = { done: true }; if (kb && kb.setIdx === setIdx && kb.field !== 'kg') { const fromRef = parseInt(rawRef, 10); const fromSess = currSet[kb.field] || 0; const best = Math.max(isNaN(fromRef) ? 0 : fromRef, fromSess); if (best > 0) patch[kb.field] = best; } return { ...sess, entries: sess.entries.map((en, ei) => ei !== exIdx ? en : { ...en, sets: en.sets.map((st, si) => si !== setIdx ? st : { ...st, ...patch }), }), }; }); setFlashSet(setIdx); setTimeout(() => setFlashSet(null), 1400); // Match the current set to the same working-set position in the previous // session. Either session may carry a different number of warm-up sets, so // compare by working-set index (warm-ups excluded), never the raw index. const prevWorkingSets = (last?.entry?.sets || []).filter(s => !s.warmup); const prevWorkingSetFor = (idx) => { if (entry.sets[idx]?.warmup) return undefined; const wIdx = entry.sets.slice(0, idx + 1).filter(s => !s.warmup).length - 1; return wIdx >= 0 ? prevWorkingSets[wIdx] : undefined; }; const prevSet = prevWorkingSetFor(setIdx); const updatedSets = entry.sets.map((st, k) => k === setIdx ? { ...st, done: true } : st); const progressionResult = (() => { if (!store.settings?.smartProgression) return null; if (!updatedSets.filter(s => !s.warmup).every(s => s.done || s.skipped)) return null; const catCfg = exercise?.equipment ? (store.settings?.equipmentConfig?.[exercise.equipment] ?? {}) : {}; const increment = catCfg.increment ?? null; if (!increment) return null; const baseReps = exercise?.progression_reps ?? entry.plannedReps; const targetRepsTop = (baseReps ?? 0) + (store.settings?.progressionRangeTop ?? 4); const doneSets = updatedSets.filter(s => s.done && !s.skipped && !s.warmup && s.kg != null); if (!doneSets.length) return null; const allHitTop = doneSets.every(s => { const reps = s.repsL != null ? Math.min(s.repsL ?? 0, s.repsR ?? 0) : (s.reps ?? 0); return reps >= targetRepsTop; }); if (!allHitTop) return null; const refKg = doneSets[0].kg; const newKg = Math.round((refKg + increment) * 100) / 100; const nextKg = catCfg.maxKg ? Math.min(newKg, catCfg.maxKg) : newKg; return nextKg > refKg ? { exName: entry.name, currentKg: refKg, nextKg } : null; })(); if (!entry.sets[setIdx]?.warmup && !progressionResult) { if (isImprovement(entry.sets[setIdx], prevSet)) { setImprovedSet(true); setTimeout(() => setImprovedSet(false), 2500); } else { const anyImprovementBefore = entry.sets.slice(0, setIdx).some((s, k) => isImprovement(s, prevWorkingSetFor(k))); if (!anyImprovementBefore && isDecline(entry.sets[setIdx], prevSet)) { setRegressionSet(true); setTimeout(() => setRegressionSet(false), 2500); } } } if (progressionResult) { pendingNavRef.current = true; setTimeout(() => { setProgressionUnlocked(progressionResult); setTimeout(() => { setProgressionUnlocked(null); if (pendingNavRef.current) { pendingNavRef.current = false; navigate(1); } }, 4000); }, 800); } const group = entry.supersetGroup; if (group) { const newDoneCount = updatedSets.filter(s => s.done).length; const partners = session.entries.map((e, i) => ({ e, i })).filter(({ e, i }) => e.supersetGroup === group && i !== exIdx); const nextPartner = partners.find(({ e }) => e.sets.filter(s => s.done).length < newDoneCount); if (nextPartner) { // Mid-round: jump to partner, no rest setTimeout(() => updateSession(sess => ({ ...sess, currentExIdx: nextPartner.i })), 300); } else { // Round complete: start rest persistRestStart(Date.now(), restDef); const allGroupDone = updatedSets.every(s => s.done) && partners.every(({ e }) => e.sets.every(s => s.done)); if (allGroupDone) { const lastGroupIdx = Math.max(...session.entries.map((e, i) => e.supersetGroup === group ? i : -1)); setTimeout(() => { if (lastGroupIdx + 1 >= session.entries.length) setFinishOpen(true); else updateSession(sess => ({ ...sess, currentExIdx: lastGroupIdx + 1 })); }, 600); } else { const allGroup = session.entries.map((e, i) => ({ e, i })).filter(({ e }) => e.supersetGroup === group); const firstIncomplete = allGroup.find(({ e, i }) => i === exIdx ? !updatedSets.every(s => s.done) : e.sets.some(s => !s.done) ); if (firstIncomplete) setTimeout(() => updateSession(sess => ({ ...sess, currentExIdx: firstIncomplete.i })), 600); } } } else { if (!entry.sets[setIdx]?.warmup) { persistRestStart(Date.now(), restDef); } if (updatedSets.every(st => st.done)) { if (!progressionResult) setTimeout(() => navigate(1), 600); } } // Last warmup set done → start 3-min rest, workout timer begins when rest expires if (isLastWarmupSet && !session.startedAt) { persistRestStart(Date.now(), 180); } }; const addSet = () => { updateSession(sess => ({ ...sess, entries: sess.entries.map((e, i) => { if (i !== exIdx) return e; const last = e.sets[e.sets.length - 1]; const newSet = isUnilateral ? { kg: last?.kg ?? null, repsL: last?.repsL ?? null, repsR: last?.repsR ?? null, done: false } : { kg: last?.kg ?? null, reps: last?.reps ?? null, done: false }; return { ...e, sets: [...e.sets, newSet] }; }), })); }; const removeSet = async (setIdx) => { if (!await confirm(`Remove set ${setIdx + 1}?`, { ok: 'Remove', danger: true })) return; updateSession(sess => ({ ...sess, entries: sess.entries.map((e, i) => i === exIdx ? { ...e, sets: e.sets.filter((_, k) => k !== setIdx) } : e), })); }; const setNote = (note) => { updateSession(sess => ({ ...sess, entries: sess.entries.map((e, i) => i === exIdx ? { ...e, note } : e), })); }; const navigate = (dir) => { const newIdx = exIdx + dir; if (newIdx < 0) return; if (newIdx >= session.entries.length) { setFinishOpen(true); return; } updateSession(sess => ({ ...sess, currentExIdx: newIdx })); }; const skipSet = () => { const idx = entry.sets.findIndex(s => !s.done && !s.skipped); if (idx < 0) return; updateSet(idx, { skipped: true }); const willBeAllDone = entry.sets.every((s, i) => i === idx || s.done || s.skipped); if (willBeAllDone) navigate(1); }; const checkSet = () => { const idx = entry.sets.findIndex(s => !s.done && !s.skipped); if (idx < 0) return; completeSet(idx); }; const skipExercise = () => { updateSession(sess => ({ ...sess, entries: sess.entries.map((e, i) => i === exIdx ? { ...e, sets: e.sets.map(st => st.done ? st : { ...st, skipped: true }) } : e), })); navigate(1); }; const cancelPushover = () => LB.cancelPushover(store.settings, userId); const playBeep = (phase, count = 1, scheduledTime = null) => { try { if (!audioCtxRef.current) audioCtxRef.current = new (window.AudioContext || window.webkitAudioContext)(); const ctx = audioCtxRef.current; if (ctx.state === 'suspended') ctx.resume(); const freq = phase === 'ecc' ? 330 : 880; const beepDur = 0.07; const gap = 0.06; const startAt = scheduledTime ?? ctx.currentTime; for (let i = 0; i < count; i++) { const osc = ctx.createOscillator(); const gain = ctx.createGain(); osc.connect(gain); gain.connect(ctx.destination); osc.type = 'sine'; osc.frequency.value = freq; const t = startAt + i * (beepDur + gap); gain.gain.setValueAtTime(0.9, t); gain.gain.exponentialRampToValueAtTime(0.001, t + beepDur); osc.start(t); osc.stop(t + beepDur); } } catch (e) {} }; const stopTempo = () => { if (tempoTimerRef.current) { clearTimeout(tempoTimerRef.current); tempoTimerRef.current = null; } setTempoActive(false); }; const startTempo = () => { stopTempo(); setTempoActive(true); const eccSecs = store.settings?.tempoEccentric ?? 4; const conSecs = store.settings?.tempoConcentric ?? 1; if (!audioCtxRef.current) audioCtxRef.current = new (window.AudioContext || window.webkitAudioContext)(); const ctx = audioCtxRef.current; if (ctx.state === 'suspended') ctx.resume(); const runPhase = (phase, phaseStart) => { const phaseDur = phase === 'ecc' ? eccSecs : conSecs; const n = Math.max(1, Math.floor(phaseDur)); const beatInterval = phaseDur / n; for (let i = 0; i < n; i++) { playBeep(phase, i + 1, phaseStart + i * beatInterval); } const nextStart = phaseStart + phaseDur; const delay = Math.max(0, (nextStart - ctx.currentTime) * 1000); tempoTimerRef.current = setTimeout(() => runPhase(phase === 'ecc' ? 'con' : 'ecc', nextStart), delay); }; runPhase('ecc', ctx.currentTime); }; const finish = () => { cancelPushover(); updateSession(sess => { const now = new Date(); const mins = sess.startedAt ? Math.round((now - new Date(sess.startedAt)) / 60000) : null; // Seal non-warmup sets that have values as done — guards against a sync // race where kbApply (done:false) lands in Supabase after completeSet // (done:true). Only seal exercises where at least one set is done; if no // set was ever confirmed the exercise was skipped/not started. const entries = sess.entries.map(e => { const hasDone = e.sets.some(st => st.done); return { ...e, sets: e.sets.map(st => { if (st.done || st.warmup || st.skipped) return st; if (!hasDone) return st; const hasValue = st.kg != null || st.reps != null || st.repsL != null || st.repsR != null; return hasValue ? { ...st, done: true } : st; }), }; }); return { ...sess, entries, ended: now.toISOString(), ...(mins != null && { durationMinutes: mins }) }; }); setStore(s => ({ ...s, inProgress: null, ...(!isWeekdayMode && { cycleIndex: s.cycleIndex + 1 }), lastAdvancedDate: LB.todayISO(), })); go({ name: 'session', sessionId: session.id, justFinished: true }); }; const abandon = async () => { if (!await confirm('All inputs will be lost.', { title: 'Cancel session?', ok: 'Cancel', cancel: 'Keep training', danger: true })) return; cancelPushover(); setStore(s => ({ ...s, sessions: s.sessions.filter(x => x.id !== session.id), inProgress: null, })); LB.broadcastSessionNav('cancel', session.id); go({ name: 'home' }); }; // chip strip scroll const chipRowRef = useRefT(null); useEffectT(() => { const row = chipRowRef.current; if (!row) return; const chip = row.children[exIdx]; if (!chip) return; const target = chip.offsetLeft - row.offsetWidth / 2 + chip.offsetWidth / 2; row.scrollLeft = target; }, [exIdx]); // rest timer — persisted in session so navigation doesn't kill it const [restStart, setRestStart] = useStateT(() => session.restStart ?? null); const [restDuration, setRestDuration] = useStateT(() => session.restDuration ?? null); const persistRestStart = (val, dur) => { setRestStart(val); const newDur = val !== null ? (dur ?? null) : null; setRestDuration(newDur); updateSession(sess => ({ ...sess, restStart: val, restDuration: newDur })); }; const [now, setNow] = useStateT(Date.now()); useEffectT(() => { const t = setInterval(() => setNow(Date.now()), 250); return () => clearInterval(t); }, []); const sessionStart = session.startedAt ? new Date(session.startedAt).getTime() : null; const sessionElapsed = sessionStart ? Math.floor((now - sessionStart) / 1000) : 0; const _sh = Math.floor(sessionElapsed / 3600); const _sm = Math.floor((sessionElapsed % 3600) / 60); const _ss = sessionElapsed % 60; const sessionTimeStr = _sh > 0 ? `${_sh}:${String(_sm).padStart(2,'0')}:${String(_ss).padStart(2,'0')}` : `${String(_sm).padStart(2,'0')}:${String(_ss).padStart(2,'0')}`; const cat = exercise?.category; const restDef = cat === 'big' ? (store.settings?.restBig || 180) : cat === 'medium' ? (store.settings?.restMedium || 120) : cat === 'small' ? (store.settings?.restSmall || 90) : (store.settings?.restDefault || 120); // Use the duration snapshotted when the timer started, not the current exercise's category const activeRestDef = (restStart !== null && restDuration !== null) ? restDuration : restDef; const restElapsed = restStart ? Math.floor((now - restStart) / 1000) : null; const restRemaining = restElapsed != null ? Math.max(0, activeRestDef - restElapsed) : null; const restPct = restElapsed != null ? Math.max(0, Math.min(100, (restElapsed / activeRestDef) * 100)) : 0; useEffectT(() => { if (!restStart) return; if (!store.settings?.pushEnabled) return; const delaySeconds = Math.round(Math.max(0, restStart + activeRestDef * 1000 - Date.now()) / 1000); fetch(LB.PUSHOVER_URL, { method: 'POST', headers: { 'Authorization': `Bearer ${LB.SUPABASE_ANON_KEY}`, 'Content-Type': 'application/json', }, body: JSON.stringify({ delaySeconds, nonce: String(restStart) + '-' + Math.random().toString(36).slice(2, 8), userKey: store.settings?.pushoverUserKey ?? '', userId, priority: 1 }), }).catch(() => {}); }, [restStart]); // beep + auto-open modal when rest timer hits zero const prevRestRemaining = useRefT(null); useEffectT(() => { const prev = prevRestRemaining.current; prevRestRemaining.current = restRemaining; if (prev !== null && prev > 0 && restRemaining === 0) { const wasPostWarmup = !session.startedAt; if (wasPostWarmup) { updateSession(sess => sess.startedAt ? sess : { ...sess, startedAt: new Date().toISOString() }); } else { setRestModalOpen(true); } // gold screen flash 3× let i = 0; const flash = () => { if (i >= 3) return; setScreenFlash(true); setTimeout(() => { setScreenFlash(false); i++; setTimeout(flash, 140); }, 220); }; flash(); // audio: two beeps + higher tone (blocked by iOS silent switch, but nice to have) // Reuse the shared AudioContext created during a prior user gesture — creating // a new one here (timer tick, no gesture) causes iOS to suspend it immediately // and resume() silently fails, so the sound never plays. try { if (!audioCtxRef.current) audioCtxRef.current = new (window.AudioContext || window.webkitAudioContext)(); const ctx = audioCtxRef.current; const play = () => { const beep = (t, freq, dur) => { const osc = ctx.createOscillator(); const gain = ctx.createGain(); osc.connect(gain); gain.connect(ctx.destination); osc.type = 'sine'; osc.frequency.value = freq; gain.gain.setValueAtTime(0.35, t); gain.gain.exponentialRampToValueAtTime(0.001, t + dur); osc.start(t); osc.stop(t + dur); }; beep(ctx.currentTime, 880, 0.14); beep(ctx.currentTime + 0.18, 880, 0.14); beep(ctx.currentTime + 0.36, 1320, 0.28); }; ctx.state === 'suspended' ? ctx.resume().then(play) : play(); } catch (_) {} } }, [restRemaining]); const [flashSet, setFlashSet] = useStateT(null); const [improvedSet, setImprovedSet] = useStateT(false); const [regressionSet, setRegressionSet] = useStateT(false); const [progressionUnlocked, setProgressionUnlocked] = useStateT(null); const [screenFlash, setScreenFlash] = useStateT(false); const [restModalOpen, setRestModalOpen] = useStateT(false); const [confirmEl, confirm] = useConfirm(); const [finishOpen, setFinishOpen] = useStateT(false); const [notePicker, setNotePicker] = useStateT(false); const [sessionNoteOpen, setSessionNoteOpen] = useStateT(false); const [exNoteOpen, setExNoteOpen] = useStateT(false); const [exNoteVal, setExNoteVal] = useStateT(''); const [planDiffOpen, setPlanDiffOpen] = useStateT(false); const [planDiff, setPlanDiff] = useStateT([]); const [swapOpen, setSwapOpen] = useStateT(false); const [avgStats, setAvgStats] = useStateT(null); const [tempoActive, setTempoActive] = useStateT(false); const tempoTimerRef = useRefT(null); const audioCtxRef = useRefT(null); const [kbField, setKbField] = useStateT(null); // { setIdx, field } const [kbRaw, setKbRaw] = useStateT(''); const [kbFresh, setKbFresh] = useStateT(false); const kbFieldRef = useRefT(null); const kbRawRef = useRefT(''); const kbFreshRef = useRefT(false); const [kbShield, setKbShield] = useStateT(false); const kbShieldTimerRef = useRefT(null); // After keyboard dismissal (completeSet or ⌄), briefly keep a touch-blocking // shield at the keyboard's screen position so iOS ghost clicks (fired 200-300ms // after the touch that closed the keyboard) don't land on revealed content. const armKbShield = () => { setKbShield(true); clearTimeout(kbShieldTimerRef.current); kbShieldTimerRef.current = setTimeout(() => setKbShield(false), 400); }; const [plateCalcOpen, setPlateCalcOpen] = useStateT(false); const pendingNavRef = useRefT(false); // Records when a set was last completed via the checkbox; used to ignore // iOS ghost-clicks that fire 200-400ms after completion and would otherwise // re-enter the onClick handler with s.done=true and undo the completion. const recentCompleteRef = useRefT({}); // Global timestamp of the most-recent completion across all sets — catches // ghost-clicks that land on a *different* row than the one just completed // (e.g. the keyboard ✓ is over an older row at the time iOS fires the ghost). const lastCompleteRef = useRefT(0); useEffectT(() => { kbFieldRef.current = null; kbRawRef.current = ''; kbFreshRef.current = false; setKbField(null); setKbRaw(''); setKbFresh(false); }, [exIdx, sessionId]); useEffectT(() => () => stopTempo(), []); useEffectT(() => { if (userId && sessionId) LB.broadcastExIdx(sessionId, exIdx); }, [exIdx]); // Log ALL document pointer/click events — captures ghost-clicks and shows where they land. useEffectT(() => { const onPD = e => { const isKb = !!e.target.closest('[data-keyboard]'); const isComplete = !!e.target.closest('[data-complete-btn]'); _log(`[DOM] pointerdown type=${e.pointerType} isPrimary=${e.isPrimary} kb=${isKb} completebtn=${isComplete} tag=${e.target.tagName}`); }; const onClick = e => { const isKb = !!e.target.closest('[data-keyboard]'); const isComplete = !!e.target.closest('[data-complete-btn]'); _log(`[DOM] click isTrusted=${e.isTrusted} kb=${isKb} completebtn=${isComplete} tag=${e.target.tagName}`); }; document.addEventListener('pointerdown', onPD, true); document.addEventListener('click', onClick, true); return () => { document.removeEventListener('pointerdown', onPD, true); document.removeEventListener('click', onClick, true); }; }, []); useEffectT(() => { if (!session?.dayId || !session?.id || !userId) return; LB.supabase .from('zane_sessions') .select('started_at, ended, entries, duration_minutes') .eq('user_id', userId) .eq('day_id', session.dayId) .not('ended', 'is', null) .neq('id', session.id) .then(({ data }) => { if (!data?.length) return; const valid = data.filter(s => { const durSec = s.duration_minutes != null ? s.duration_minutes * 60 : (s.started_at ? (new Date(s.ended) - new Date(s.started_at)) / 1000 : null); return durSec != null && durSec > 0; }); if (!valid.length) return; const avgDurSec = valid.reduce((sum, s) => { const sec = s.duration_minutes != null ? s.duration_minutes * 60 : (new Date(s.ended) - new Date(s.started_at)) / 1000; return sum + sec; }, 0) / valid.length; const avgSetsTotal = valid.reduce((sum, s) => sum + (s.entries || []).reduce((t, e) => t + (e.sets?.filter(st => st.done).length || 0), 0), 0) / valid.length; setAvgStats({ avgDurSec, avgSetsTotal }); }); }, [session?.id]); // No document-level dismiss: the auto-dismiss fired during digit presses (iOS // multi-touch / accidental palm) and cleared kbFieldRef synchronously, causing // kbTypeChar to return early on the next digit and "swallowing" it. The keyboard // now stays open until the user taps ⌄ explicitly or navigates away. const activateKb = (setIdx, field) => { _log(`activateKb(set${setIdx} ${field})`); const s = (store.sessions.find(x => x.id === sessionId)?.entries[exIdx]?.sets[setIdx]); const val = field === 'kg' ? (s?.kg != null ? String(s.kg).replace('.', ',') : '') : (s?.[field] != null ? String(s[field]) : ''); kbFieldRef.current = { setIdx, field }; kbRawRef.current = val; kbFreshRef.current = true; setKbField({ setIdx, field }); setKbRaw(val); setKbFresh(true); setTimeout(() => { const el = document.querySelector(`[data-kb-row="${setIdx}"]`); if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' }); }, 80); }; const kbApply = (newRaw, field, setIdx) => { _log(`kbApply(set${setIdx} ${field} '${newRaw}')`); if (field === 'kg') { const num = newRaw === '' ? null : parseFloat(newRaw.replace(',', '.')); if (newRaw === '' || !isNaN(num)) { updateSession(sess => ({ ...sess, entries: sess.entries.map((en, ei) => ei !== exIdx ? en : { ...en, sets: en.sets.map((st, si) => si === setIdx ? { ...st, kg: num ?? null, done: false } : si > setIdx && !st.done ? { ...st, kg: num ?? null } : st ), }), })); } } else { const num = newRaw === '' ? null : parseInt(newRaw, 10); if (newRaw === '' || !isNaN(num)) updateSet(setIdx, { [field]: num ?? null, done: false }); } }; const kbTypeChar = (char) => { if (!kbFieldRef.current) { _log(`TYPE '${char}' → NULL kbField (swallowed!)`); return; } const { setIdx, field } = kbFieldRef.current; const base = kbFreshRef.current ? '' : kbRawRef.current; if (char === ',' && (field !== 'kg' || base.includes(','))) return; const newRaw = base + char; kbRawRef.current = newRaw; kbFreshRef.current = false; setKbRaw(newRaw); setKbFresh(false); _log(`TYPE '${char}' → '${newRaw}' (set${setIdx} ${field})`); kbApply(newRaw, field, setIdx); }; const kbBackspace = () => { if (!kbFieldRef.current) return; const { setIdx, field } = kbFieldRef.current; const newRaw = kbFreshRef.current ? '' : kbRawRef.current.slice(0, -1); kbRawRef.current = newRaw; kbFreshRef.current = false; setKbRaw(newRaw); setKbFresh(false); kbApply(newRaw, field, setIdx); }; const kbAdjust = (dir) => { if (!kbFieldRef.current) return; const { setIdx, field } = kbFieldRef.current; if (field === 'kg') { const cur = parseFloat(kbRawRef.current.replace(',', '.')) || 0; const step = (exercise?.equipment && store.settings?.equipmentConfig?.[exercise.equipment]?.increment) || 1.25; const next = Math.max(0, Math.round((cur + dir * step) * 100) / 100); const newRaw = String(next).replace('.', ','); kbRawRef.current = newRaw; setKbRaw(newRaw); updateSession(sess => ({ ...sess, entries: sess.entries.map((en, ei) => ei !== exIdx ? en : { ...en, sets: en.sets.map((st, si) => si === setIdx ? { ...st, kg: next, done: false } : si > setIdx && !st.done ? { ...st, kg: next } : st ), }), })); } else { const cur = parseInt(kbRawRef.current, 10) || 0; const next = Math.max(0, cur + dir); kbRawRef.current = String(next); setKbRaw(String(next)); updateSet(setIdx, { [field]: next, done: false }); } }; const kbConfirm = () => { if (!kbFieldRef.current) { _log('kbConfirm: NULL kbField (ignored)'); return; } const { setIdx, field } = kbFieldRef.current; _log(`kbConfirm: set${setIdx} field=${field} raw='${kbRawRef.current}'`); kbApply(kbRawRef.current, field, setIdx); if (field === 'kg') { _log(`kbConfirm: kg→${isUnilateral ? 'repsL' : 'reps'}`); activateKb(setIdx, isUnilateral ? 'repsL' : 'reps'); } else if (field === 'repsL') { _log('kbConfirm: repsL→repsR'); activateKb(setIdx, 'repsR'); } else { _log(`kbConfirm: ${field}→completeSet(${setIdx})`); completeSet(setIdx); const nextIdx = entry.sets.findIndex((s, i) => i > setIdx && !s.done); if (nextIdx !== -1) setTimeout(() => activateKb(nextIdx, isUnilateral ? 'repsL' : 'reps'), 350); } }; const saveExNote = () => { setStore(s => ({ ...s, exercises: s.exercises.map(e => e.id === entry.exId ? { ...e, note: exNoteVal.trim() } : e) })); setExNoteOpen(false); }; const swapExercise = async () => { if (!await confirm(`Swap "${entry.name}"?`, { ok: 'Swap' })) return; setSwapOpen(true); }; const doSwap = (newExId) => { // resolve the name from fresh state — a just-created exercise isn't in the // closed-over `store` yet (its setStore hasn't re-rendered the screen) setStore(s => { const newEx = LB.findExercise(s, newExId); return { ...s, sessions: s.sessions.map(x => x.id !== session.id ? x : { ...x, entries: x.entries.map((e, i) => i !== exIdx ? e : { ...e, exId: newExId, name: newEx?.name || e.name }), }), }; }); setSwapOpen(false); }; const computePlanDiff = () => { const schedule = store.schedules?.find(s => s.id === session.scheduleId); const day = schedule?.days?.find(d => d.id === session.dayId); if (!day) return []; return session.entries.reduce((acc, entry, i) => { const planItem = day.items[i]; if (!planItem) return acc; if (entry.exId !== planItem.exId) { const oldEx = LB.findExercise(store, planItem.exId); acc.push({ type: 'swap', idx: i, oldName: oldEx?.name || '?', newName: entry.name, newExId: entry.exId }); } else if (entry.sets.filter(s => !s.warmup).length !== planItem.sets) { acc.push({ type: 'sets', idx: i, exName: entry.name, oldSets: planItem.sets, newSets: entry.sets.filter(s => !s.warmup).length }); } return acc; }, []); }; const tryFinish = () => { const diffs = computePlanDiff(); if (diffs.length > 0) { setPlanDiff(diffs); setFinishOpen(false); setPlanDiffOpen(true); } else { finish(); } }; const applyPlanAndFinish = () => { const schedule = store.schedules?.find(s => s.id === session.scheduleId); const day = schedule?.days?.find(d => d.id === session.dayId); if (schedule && day) { const newItems = day.items.map((item, i) => { const diff = planDiff.find(d => d.idx === i); if (!diff) return item; if (diff.type === 'swap') return { ...item, exId: session.entries[i].exId }; if (diff.type === 'sets') return { ...item, sets: session.entries[i].sets.filter(s => !s.warmup).length }; return item; }); setStore(s => ({ ...s, schedules: s.schedules.map(sch => sch.id === schedule.id ? { ...sch, days: sch.days.map(d => d.id === day.id ? { ...d, items: newItems } : d), } : sch), })); } finish(); }; if (!entry) { return go({ name: 'home' })}>Back} />; } const completed = entry.sets.filter(s => s.done).length; const allDone = completed === entry.sets.length; const currentSetIdx = entry.sets.findIndex(s => !s.done); const warmupCount = entry.sets.filter(s => s.warmup).length; const isCurrentWarmup = warmupCount > 0 && currentSetIdx >= 0 && !!entry.sets[currentSetIdx]?.warmup; const warmupSetsRemaining = warmupCount > 0 && entry.sets.filter(s => s.warmup).some(s => !s.done); const allWarmupDone = warmupCount > 0 && entry.sets.filter(s => s.warmup).every(s => s.done); const postWarmupRest = allWarmupDone && !session.startedAt; const warmupActive = warmupCount > 0 && !session.startedAt; const currentSetNum = currentSetIdx >= 0 ? currentSetIdx + 1 : entry.sets.length; // While the warmup overlay is showing, the background displays the first working set (not the warmup set) const bgSetIdx = warmupSetsRemaining ? entry.sets.findIndex(s => !s.warmup) : currentSetIdx; const heroSet = bgSetIdx >= 0 ? entry.sets[bgSetIdx] : null; // For warmup sets there's no meaningful "last session" comparison const prevHeroSet = isCurrentWarmup ? null : (last?.entry?.sets || []).filter(s => !s.warmup)[bgSetIdx >= 0 ? bgSetIdx - warmupCount : 0]; const workingSetsArr = entry.sets.filter(s => !s.warmup); const allWorkingDone = workingSetsArr.length > 0 && workingSetsArr.every(s => s.done || s.skipped); const anyMissingData = workingSetsArr.some(st => !st.done && !st.skipped && (st.kg == null || (isUnilateral ? (!st.repsL || !st.repsR) : !st.reps))); const checkAllSets = async () => { if (allWorkingDone || anyMissingData) return; if (!await confirm(`Check off all ${workingSetsArr.length} sets and continue?`, { ok: 'Check all' })) return; updateSession(sess => ({ ...sess, entries: sess.entries.map((e, i) => i === exIdx ? { ...e, sets: e.sets.map(st => st.warmup ? st : { ...st, done: true }) } : e), })); persistRestStart(Date.now(), restDef); setTimeout(() => navigate(1), 600); }; const skipWarmup = () => { updateSession(sess => ({ ...sess, startedAt: new Date().toISOString(), entries: sess.entries.map((e, i) => i === 0 ? { ...e, sets: e.sets.map(st => st.warmup ? { ...st, done: true } : st) } : e ), })); persistRestStart(null); }; const startNow = () => { updateSession(sess => sess.startedAt ? sess : { ...sess, startedAt: new Date().toISOString() }); persistRestStart(null); }; // Derive warmup overlay vars here so they're available inside the main return const warmupOverlayGlobalIdx = warmupSetsRemaining ? entry.sets.findIndex(s => s.warmup && !s.done) : -1; const warmupOverlaySets = entry.sets.filter(s => s.warmup); const warmupOverlaySet = warmupOverlayGlobalIdx >= 0 ? entry.sets[warmupOverlayGlobalIdx] : null; const warmupOverlayNum = warmupOverlaySets.findIndex(s => !s.done) + 1; const warmupOverlayHasKg = warmupOverlaySet?.kg != null; return ( {/* Gold screen flash overlay */} {screenFlash && (
)} {/* Improvement overlay */} {/* Block keyboard and content interaction while any overlay is visible */} {(improvedSet || regressionSet || !!progressionUnlocked) && (
)} {improvedSet && (
{/* pulsing border ring */}
{/* centered label */}
↑ IMPROVEMENT
)} {/* Regression overlay */} {regressionSet && (
↓ REGRESSION
)} {/* Progression unlocked overlay */} {progressionUnlocked && (
{ setProgressionUnlocked(null); if (pendingNavRef.current) { pendingNavRef.current = false; navigate(1); } }} style={{ position: 'fixed', inset: 0, zIndex: 160, background: 'rgb(8,6,3)', animation: 'improvedFade 4s ease forwards', display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', gap: 8, }}>
↑ PROGRESSION UNLOCKED You've earned the next load.
{progressionUnlocked.currentKg}kg → {progressionUnlocked.nextKg}kg
{progressionUnlocked.exName}
)} {/* Top: close + session timer */}
{/* session time / warmup indicator */}
{warmupActive ? WARMUP : {sessionTimeStr} }
{/* rest countdown — only when active */} {restStart && restRemaining > 0 && (<>
)}
{/* Pace bar — only when historical avg is available */} {avgStats && (() => { const totalSetsDone = session.entries.reduce((s, e) => s + (e.sets?.filter(x => x.done && !x.warmup).length || 0), 0); const totalSetsTotal = session.entries.reduce((s, e) => s + (e.sets?.filter(x => !x.skipped && !x.warmup).length || 0), 0); const avgDurSec = avgStats.avgDurSec; const avgSetsTotal = avgStats.avgSetsTotal; if (!avgDurSec || !session.startedAt) return null; const elapsedSec = (now - new Date(session.startedAt).getTime()) / 1000; const remainingSets = Math.max(0, totalSetsTotal - totalSetsDone); const histPace = avgSetsTotal > 0 ? avgDurSec / avgSetsTotal : null; const currPace = totalSetsDone >= 2 ? elapsedSec / totalSetsDone : null; let remainingSec; if (!histPace || totalSetsTotal === 0) { remainingSec = Math.max(0, avgDurSec - elapsedSec); } else if (!currPace) { remainingSec = Math.max(0, avgDurSec - elapsedSec); } else { const w = Math.min(totalSetsDone / 8, 0.7); remainingSec = Math.max(0, (w * currPace + (1 - w) * histPace) * remainingSets); } const remMin = Math.round(remainingSec / 60); const avgDurMin = avgDurSec / 60; const elapsedMin = elapsedSec / 60; if (totalSetsDone < 2) return null; if (remainingSets === 0) return null; const diffMin = Math.round(elapsedMin + remMin - avgDurMin); if (Math.abs(diffMin) < 2) return null; const ahead = diffMin < 0; const pct = Math.min(Math.abs(diffMin) / 20 * 50, 50); return (
{ahead ? `${Math.abs(diffMin)}m ahead` : `+${diffMin}m behind`}
); })()} {/* Day name + exercise position */}
{session.dayName} {String(exIdx + 1).padStart(2, '0')} / {String(session.entries.length).padStart(2, '0')}
{/* Exercise chips */}
{session.entries.flatMap((e, i) => { const done = e.sets.every(s => s.done || s.skipped); const active = i === exIdx; const nextE = session.entries[i + 1]; const linkedToNext = e.supersetGroup && e.supersetGroup === nextE?.supersetGroup; const chip = ( ); if (linkedToNext) { return [chip, ⟷]; } return [chip]; })}
{/* Exercise name */}
28 ? 16 : entry.name.length > 22 ? 20 : entry.name.length > 16 ? 26 : 32, color: UI.ink, lineHeight: 1.05, letterSpacing: '0.02em', fontWeight: 700, whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis', }}> {entry.name}
{(exercise?.category || exercise?.equipment || (exercise?.tags || []).length > 0) && (
{exercise?.category && {exercise.category}} {exercise?.equipment && {(window.EQUIPMENT_TYPES||[]).find(t=>t.key===exercise.equipment)?.label ?? exercise.equipment}} {(exercise?.tags || []).map(t => {t})}
)}
{/* HERO CURRENT SET */} {allDone ? (
ALL SETS
Done.
Next exercise ready.
navigate(1)} style={{ marginTop: 18 }}> {exIdx === session.entries.length - 1 ? 'Finish session →' : 'Next exercise →'} ) : heroSet && (
{(!warmupSetsRemaining && isCurrentWarmup) ? `WARMUP ${String(entry.sets.slice(0,currentSetIdx+1).filter(s=>s.warmup).length).padStart(2,'0')} / ${String(warmupCount).padStart(2,'0')}` : `SET ${String(entry.sets.slice(0,bgSetIdx+1).filter(s=>!s.warmup).length).padStart(2,'0')} / ${String(workingSetsArr.length).padStart(2,'0')}` }
{prevHeroSet && prevHeroSet.kg ? ( LAST TIME {prevHeroSet.kg}kg × {(prevHeroSet.repsL != null || prevHeroSet.repsR != null) ? `L${prevHeroSet.repsL ?? '?'}/R${prevHeroSet.repsR ?? '?'}` : prevHeroSet.reps} ) : null} {progressionTarget && (
≥{progressionTarget} reps · next weight
)}
{/* HUGE inputs */}
activateKb(bgSetIdx, 'kg')} kbRaw={kbRaw} isKbActive={kbField?.setIdx === bgSetIdx && kbField?.field === 'kg'} onChange={kg => updateSession(sess => ({ ...sess, entries: sess.entries.map((en, ei) => ei !== exIdx ? en : { ...en, sets: en.sets.map((st, si) => si === bgSetIdx ? { ...st, kg, done: false } : si > bgSetIdx && !st.done && !st.warmup ? { ...st, kg } : st ), }), }))} />
KILOGRAMS
×
{isUnilateral ? (
{ e.preventDefault(); e.stopPropagation(); activateKb(bgSetIdx, 'repsL'); }} />
LEFT
/
{ e.preventDefault(); e.stopPropagation(); activateKb(bgSetIdx, 'repsR'); }} />
RIGHT
) : (
{ e.preventDefault(); e.stopPropagation(); activateKb(bgSetIdx, 'reps'); }} />
REPETITIONS
)}
{/* Big confirm button */}
)} {/* All sets list */}
{warmupCount > 0 && warmupActive ? 'WARMUP' : 'ALL SETS'}
Last time kg {isUnilateral ? ( <> L R ) : ( {store.settings?.smartProgression ? 'Reps (min)' : 'Reps'} )}
{entry.sets.map((s, i) => { const isWarmupRow = !!s.warmup; // Hide warmup rows once training has started — they're done and tapping them would re-trigger the overlay if (isWarmupRow && !warmupActive) return null; // Working sets offset index by warmupCount so prev-session lookup is correct const prevSet = isWarmupRow ? null : (last?.entry?.sets || []).filter(s => !s.warmup)[i - warmupCount]; const isCurrent = i === currentSetIdx; const showWorkingSep = !isWarmupRow && i === warmupCount && warmupCount > 0 && warmupActive; const warmupRowNum = isWarmupRow ? entry.sets.slice(0, i + 1).filter(x => x.warmup).length : 0; const workingRowNum = !isWarmupRow ? entry.sets.slice(0, i + 1).filter(x => !x.warmup).length : 0; return ( {showWorkingSep && ( <>
WORKING SETS
)}
{isWarmupRow ? `W${warmupRowNum}` : workingRowNum}
{isWarmupRow ? {s.warmupPct}% : prevSet?.kg != null && (prevSet.reps != null || prevSet.repsL != null || prevSet.repsR != null) ? `${prevSet.kg}kg × ${(prevSet.repsL != null || prevSet.repsR != null) ? `L${prevSet.repsL ?? '?'}/R${prevSet.repsR ?? '?'}` : prevSet.reps}` : '—' }
activateKb(i, 'kg')} kbRaw={kbRaw} isKbActive={kbField?.setIdx === i && kbField?.field === 'kg'} onChange={kg => updateSession(sess => ({ ...sess, entries: sess.entries.map((en, ei) => ei !== exIdx ? en : { ...en, sets: en.sets.map((st, si) => si === i ? { ...st, kg, done: false } : si > i && !st.done && !st.warmup ? { ...st, kg } : st ), }), }))} /> {isUnilateral ? ( <> { e.preventDefault(); e.stopPropagation(); if (!s.done && !s.skipped) activateKb(i, 'repsL'); }} /> { e.preventDefault(); e.stopPropagation(); if (!s.done && !s.skipped) activateKb(i, 'repsR'); }} /> ) : ( { e.preventDefault(); e.stopPropagation(); if (!s.done && !s.skipped) activateKb(i, 'reps'); }} /> )} {!s.warmup && !s.done && entry.sets.length > 1 ? ( ) : }
{i < entry.sets.length - 1 && !(i === warmupCount - 1 && warmupCount > 0) &&
} ); })}
{/* Add set / swap / note */}
{store.settings?.tempoEnabled && ( )}
{/* Session note display — tap to edit */} {entry.note ? ( ) : null}
{/* Exercise note (permanent, from exercise definition) */} {exercise?.note && ( { setExNoteVal(exercise?.note || ''); setExNoteOpen(true); }}>
NOTE · {entry.name.toUpperCase()}
{exercise.note}
)}
{/* Footer nav */}
{allDone ? ( navigate(1)} style={{ flex: 1, minHeight: 44, padding: '10px 16px' }}> {exIdx === session.entries.length - 1 ? 'Finish →' : 'Next exercise →'} ) : (<> {(() => { const pending = entry.sets.find(s => !s.done && !s.skipped); const hasVal = pending && (pending.kg != null || pending.reps != null || pending.repsL != null || pending.repsR != null); return Check set; })()} Skip remaining sets {exIdx === session.entries.length - 1 && ( navigate(1)} style={{ flex: 1, minHeight: 44, padding: '10px 8px' }}>Finish → )} )}
{/* finish confirmation */} setFinishOpen(false)} title="End session?">
{(() => { const incomplete = session.entries .map(e => ({ name: e.name, remaining: e.sets.filter(s => !s.done && !s.skipped).length })) .filter(e => e.remaining > 0); if (!incomplete.length) return null; return (
Incomplete sets
{incomplete.map(e => (
{e.name} {e.remaining} left
))}
); })()}
Sets {session.entries.reduce((c, e) => c + e.sets.filter(s => s.done).length, 0)} / {session.entries.reduce((c, e) => c + e.sets.length, 0)}
Volume {Math.round(LB.totalVolume(session)).toLocaleString('en-US')} kg
Duration {sessionTimeStr}
setFinishOpen(false)} style={{ flex: 1 }}>Continue Finish ✓
{/* note type picker */} setNotePicker(false)} title="Which note?">
{/* session note editor */} setSessionNoteOpen(false)} title="Session note">