Open-source gym & body-weight tracker, now in the App Store (iPhone + Apple Watch) and as an Android APK. Plan routines, log workouts, see which muscles are trained, import from Strong/Hevy/FitNotes. Self-host it or use it on the phone alone.
JavaScript apple-watchbodyweightdockerfitnessfitness-trackergymhealthiosmcpnodejspasskeysprogressive-web-applicationspwareactself-hostedself-hostingvitewebauthnweightliftingworkout-tracker
fix(workout): preserve per-side data across progression and session flows
Sebastian G195db7360073
diff --git a/frontend/src/lib/exercise-history.js b/frontend/src/lib/exercise-history.jsindex e1169c693..72b205b76 100644--- a/frontend/src/lib/exercise-history.js+++ b/frontend/src/lib/exercise-history.js@@ -1,5 +1,5 @@import { metricModeForEntry, metricRowsForEntry, bestWeightForEntry, modeOf } from './history.js'-import { extraVolumeOf } from './workout-model.js'+import { completedVolumeOf } from './workout-model.js'import { bestSetOf } from './onerm.js'// One exercise's past, read back for the history sheet (issue #43): a chart series and the@@ -24,7 +24,7 @@ const startOf = w => (Number.isFinite(w.start) ? w.start : new Date(w.d + 'T12:0// Volume of the exercise in one session: main set plus its drops/bursts, reps mode only —// there is no honest tonnage for a hold or a run.-const entryVolume = rows => rows.reduce((v, s) => v + (s.w || 0) * (s.r || 0) + extraVolumeOf(s), 0)+const entryVolume = rows => rows.reduce((v, s) => v + completedVolumeOf(s), 0)export function exerciseHistory(S, exId, { limit = HISTORY_SESSIONS } = {}) {const workouts = S?.workouts || []diff --git a/frontend/src/lib/finish-workout.js b/frontend/src/lib/finish-workout.jsindex d2fe49514..47390b62a 100644--- a/frontend/src/lib/finish-workout.js+++ b/frontend/src/lib/finish-workout.js@@ -1,6 +1,7 @@// The persisted boundary for a finished session. Keep this pure so compatibility tests can// exercise the exact shape the UI writes without mounting React or mutating store state.import { bestWeightForEntry } from './history.js'+import { hasCompletedWork } from './workout-model.js'export function buildCompletedWorkout(active, { end = Date.now(), prs = [], snapshotFor } = {}) {const entries = (active?.entries || []).map(entry => {@@ -28,7 +29,7 @@ export function buildCompletedWorkout(active, { end = Date.now(), prs = [], snapif (entry.notePin) completed.notePin = true}return completed- }).filter(entry => entry.sets.some(set => set.done))+ }).filter(entry => entry.sets.some(hasCompletedWork))const sessionNote = (active?.note || '').trim()const routineIds = [].concat(active?.routineIds ?? (active?.routineId ? [active.routineId] : []))diff --git a/frontend/src/lib/history.js b/frontend/src/lib/history.jsindex a5290980a..8889e20ee 100644--- a/frontend/src/lib/history.js+++ b/frontend/src/lib/history.js@@ -1,7 +1,7 @@// Pure helpers over the state object S (ported 1:1 from the vanilla app).import { todayISO, isoOf, weekKey, weekStartOf, fmtNum } from './format.js'import { isCardio, isBodyweightEq } from './exercises.js'-import { phaseForSet, modeForSet, modeForEntry, isWarmupRow, normalizeMode, extraVolumeOf, nextDropWeight, splitBurstReps, makeSideSet, isSideSet, syncSideAggregate } from './workout-model.js'+import { phaseForSet, modeForSet, modeForEntry, isWarmupRow, normalizeMode, completedVolumeOf, nextDropWeight, splitBurstReps, makeSideSet, isSideSet, syncSideAggregate } from './workout-model.js'const objectOf = value => value && typeof value === 'object' && !Array.isArray(value) ? value : {}// Completed-state-independent work rows whose authoritative mode matches the requested mode.const workRowsForMode = (entry = {}, mode = 'reps') => {@@ -120,7 +120,11 @@ export function setLabel(id, s, cfg) {// A unilateral set logged per side (issue #60) reads "L 15×8 · R 15×7" — the asymmetry is the// whole point, so both sides are shown rather than a single combined total.if (isSideSet(s)) {- return `${t('L')} ${oneSide(s.sides.L)}${effortTail(s.sides.L)} · ${t('R')} ${oneSide(s.sides.R)}${effortTail(s.sides.R)}`+ const partial = s.sides.L.done !== s.sides.R.done+ return ['L', 'R'].map(key => {+ const side = s.sides[key]+ return `${t(key)} ${partial && !side.done ? '—' : oneSide(side) + effortTail(side)}`+ }).join(' · ')}// Bodyweight reads as what you did — "12", or "+10 × 12" once there is a belt involved —// rather than "0×12", which says a set was performed with no weight and means nothing.@@ -471,20 +475,30 @@ export function applyIntensifierPlan(sets, cfg) {const w = (sets.find(s => !isWarmupRow(s)) || sets[0] || {}).w || 0const warmup = { w, r: Math.max(1, Math.round(cfg.reps) || 1), done: false, phase: 'warmup' }const work = { w, r: totalReps, done: false, type: 'restpause', clusters: splitBurstReps(totalReps).map(r => ({ r, restSec })) }+ if (isPerSide(cfg)) {+ const source = sets.find(s => !isWarmupRow(s))+ // The configured total covers both limbs; preserve it even for an odd total.+ const side = (key, reps) => ({+ w: source?.sides?.[key]?.w ?? w, r: reps, done: false, type: 'restpause',+ clusters: splitBurstReps(reps).map(r => ({ r, restSec })),+ })+ return [warmup, syncSideAggregate({ ...work, sides: {+ L: side('L', Math.ceil(totalReps / 2)), R: side('R', Math.floor(totalReps / 2)),+ } })]+ }return [warmup, work]}export function workoutVolume(w) {let v = 0- // No special case for unilateral work: a per-side set logs its total, so both sides are- // already in the rep count that arrives here. Drop-set drops and rest-pause bursts add their- // own weight x reps on top of the row's main/activation set (see extraVolumeOf).+ // Count each completed limb at its own load, including drops. A rest-pause side's r already+ // includes its bursts. Unchecked limbs and warm-ups contribute no volume.// Warm-ups are excluded here as everywhere else. The config sheet promises it in so many// words ("left out of volume, records and progression") and every other consumer already// does it; this line was the one that did not, which only stopped being harmless when a// routine started planning warm-ups by default. The number is written into the saved// workout, so an inflated one would stay wrong forever.w.entries.forEach(e => e.sets.forEach(s => {- if (s.done && !isWarmupRow(s)) v += (s.w || 0) * (s.r || 0) + extraVolumeOf(s)+ if (!isWarmupRow(s)) v += completedVolumeOf(s)}))return v}diff --git a/frontend/src/lib/progression.js b/frontend/src/lib/progression.jsindex df2dfd0b1..ae0981691 100644--- a/frontend/src/lib/progression.js+++ b/frontend/src/lib/progression.js@@ -18,7 +18,7 @@import { modeOf, repStep, rerampWarmups, isBw, isPerSide, entryExcluded } from './history.js'import { EXIDX } from './exercises.js'-import { isWarmupRow } from './workout-model.js'+import { isWarmupRow, isSideSet, syncSideAggregate, makeSideSet } from './workout-model.js'import { normalizeRepRange } from './rep-range.js'export const POLICIES = ['off', 'linear', 'greyskull', 'double', 'time']@@ -444,6 +444,16 @@ export function applyPrescription(sets, p, step = 2.5) {// the work rows only (a ticked warm-up falling through here would be the data-loss the// cascade fix removed, two files over).if (s.done || isWarmupRow(s)) return s+ if (isSideSet(s)) {+ const sides = Object.fromEntries(['L', 'R'].map(side => {+ const row = s.sides[side]+ return [side, row.done ? row : { ...row,+ ...(p.weight != null ? { w: p.weight } : {}),+ ...(p.reps != null ? { r: p.reps / 2 } : {}),+ }]+ }))+ return syncSideAggregate({ ...s, sides })+ }const o = { ...s }if (p.weight != null) o.w = p.weightif (p.reps != null) o.r = p.reps@@ -464,7 +474,11 @@ export function applyPrescription(sets, p, step = 2.5) {// `type` is kept: that's the exercise's plan (every set is a drop-set/rest-pause), not// something this particular row logged.const { drops, clusters, ...plainSeed } = seed- while (out.filter(s => !isWarmupRow(s)).length < p.sets) out.push({ ...plainSeed, done: false })+ while (out.filter(s => !isWarmupRow(s)).length < p.sets) {+ out.push(isSideSet(seed) ? makeSideSet({+ w: p.weight ?? seed.w, r: p.reps ?? seed.r,+ }) : { ...plainSeed, done: false })+ }}// Last, because the work rows now carry their final weight: the warm-up block ramps toward// what you are actually about to lift, not toward what you lifted last time.diff --git a/frontend/src/lib/unilateral-integration.test.js b/frontend/src/lib/unilateral-integration.test.jsnew file mode 100644index 000000000..146987d9b--- /dev/null+++ b/frontend/src/lib/unilateral-integration.test.js@@ -0,0 +1,100 @@+import { describe, it, expect } from 'vitest'+import { makeSideSet, setSideField, toggleSide, addSideDrop, setSideDropAt, isSideSet } from './workout-model.js'+import { applyPrescription } from './progression.js'+import { buildSessionEntries } from './session-start.js'+import { workoutVolume, applyIntensifierPlan, setLabel, setsDone } from './history.js'+import { convertStateUnit } from './units.js'+import { buildCompletedWorkout } from './finish-workout.js'+import { exerciseHistory } from './exercise-history.js'++const row = () => makeSideSet({ w: 20, r: 16 })+const done = s => toggleSide(toggleSide(s, 'L'), 'R')+const entry = s => ({ id: '0025', target: { mode: 'reps', side: true, bodyweight: false }, sets: [s] })++describe('unilateral sets across session boundaries', () => {+ it('applies weight and rep targets to the displayed sides and survives completion', () => {+ const source = row()+ const [next] = applyPrescription([source], { kind: 'up', weight: 22.5, reps: 20 })+ expect(next.sides.L).toMatchObject({ w: 22.5, r: 10, done: false })+ expect(next.sides.R).toMatchObject({ w: 22.5, r: 10, done: false })+ expect(done(next)).toMatchObject({ w: 22.5, r: 20, done: true })+ expect(source.sides.L.w).toBe(20)+ })++ it('preserves a logged side when applying a prescription mid-session', () => {+ const source = toggleSide(setSideField(row(), 'L', 'rir', 2), 'L')+ const [next] = applyPrescription([source], { kind: 'up', weight: 25, reps: 20 })+ expect(next.sides.L).toEqual(source.sides.L)+ expect(next.sides.R).toMatchObject({ w: 25, r: 10, done: false })+ })++ it('grows fresh independent side rows without copying completed work or drops', () => {+ const source = done(addSideDrop(row()))+ const next = applyPrescription([source], { kind: 'up', weight: 25, reps: 20, sets: 3 })+ expect(next).toHaveLength(3)+ expect(next[0]).toBe(source)+ for (const s of next.slice(1)) {+ expect(s.sides.L).toEqual({ w: 25, r: 10, done: false })+ expect(s.sides.R).toEqual({ w: 25, r: 10, done: false })+ }+ expect(next[1].sides.L).not.toBe(next[2].sides.L)+ })++ it('uses progressed side weights when building a routine session and its planned drops', () => {+ const cfg = { id: '0025', mode: 'reps', side: true, bodyweight: false, sets: 1, reps: 16, weight: 20, policy: 'linear', inc: 2.5, intensifier: { type: 'dropset', count: 1, pct: 20 } }+ const S = { unit: 'kg', exWeights: {}, workouts: [{ id: 'w', d: '2026-09-01', entries: [{ ...entry(done(row())), target: cfg }] }] }+ const [built] = buildSessionEntries(S, { id: 'r', policy: 'linear', ex: [cfg] })+ expect(built.plan.kind).toBe('up')+ expect(built.sets[0].sides.L.w).toBe(built.plan.weight)+ expect(built.sets[0].sides.L.drops[0].w).toBe(18)+ })++ it('converts both limbs and their drops in history and the active session', () => {+ const s = setSideDropAt(addSideDrop(setSideField(row(), 'R', 'w', 30)), 'R', 0, { w: 10 })+ const state = { unit: 'kg', active: { entries: [entry(s)] }, workouts: [{ entries: [entry(done(s))] }] }+ const result = convertStateUnit(state, 'lb')+ for (const e of [result.active.entries[0], result.workouts[0].entries[0]]) {+ expect(e.sets[0].sides.L.w).toBe(44)+ expect(e.sets[0].sides.R.w).toBe(66)+ expect(e.sets[0].sides.L.drops[0].w).toBe(35.5)+ expect(e.sets[0].sides.R.drops[0].w).toBe(22)+ expect(toggleSide(e.sets[0], 'L').w).toBe(66)+ }+ expect(state.active.entries[0].sets[0].sides.L.w).toBe(20)+ expect(convertStateUnit(result, 'kg').active.entries[0].sets[0].sides.R.w).toBe(30)+ })++ it('counts asymmetric loads correctly in workout and exercise-history volume', () => {+ const s = done(setSideField(row(), 'R', 'w', 30))+ const w = { id: 'w', d: '2026-09-01', entries: [entry(s)] }+ expect(workoutVolume(w)).toBe(400)+ expect(exerciseHistory({ workouts: [w] }, '0025').sessions[0].volume).toBe(400)+ })++ it('retains a single completed limb, counts only its volume and labels its partner as unlogged', () => {+ const s = toggleSide(addSideDrop(row()), 'L')+ const completed = buildCompletedWorkout({ id: 'a', entries: [entry(s), entry(row())] })+ expect(completed.entries).toHaveLength(1)+ expect(completed.entries[0].sets[0]).toEqual(s)+ expect(setsDone(completed)).toBe(1)+ expect(workoutVolume(completed)).toBe(20 * 8 + 16 * 8)+ expect(setLabel('0025', s, entry(s).target)).toBe('L 20×8 · R —')+ expect(workoutVolume({ entries: [entry({ ...s, phase: 'warmup' })] })).toBe(0)+ })++ it.each([12, 13])('preserves L/R rows and total reps for a planned rest-pause of %i', totalReps => {+ const [warmup, work] = applyIntensifierPlan([setSideField(row(), 'R', 'w', 30)], {+ side: true, reps: 16, intensifier: { type: 'restpause', totalReps, restSec: 15 },+ })+ expect(warmup.phase).toBe('warmup')+ expect(isSideSet(work)).toBe(true)+ expect(work.r).toBe(totalReps)+ for (const side of [work.sides.L, work.sides.R]) {+ expect(side.clusters.reduce((n, c) => n + c.r, 0)).toBe(side.r)+ expect(side.clusters.every(c => c.restSec === 15)).toBe(true)+ }+ expect(work.sides.L.w).toBe(20)+ expect(work.sides.R.w).toBe(30)+ expect(workoutVolume({ entries: [entry(done(work))] })).toBe(20 * Math.ceil(totalReps / 2) + 30 * Math.floor(totalReps / 2))+ })+})diff --git a/frontend/src/lib/units.js b/frontend/src/lib/units.jsindex 2fb82432c..3c22eed25 100644--- a/frontend/src/lib/units.js+++ b/frontend/src/lib/units.js@@ -2,6 +2,8 @@// (60 kg became "60 lb", issue #22); this walks every stored weight once. Rounded to what a gym// can load: lb to the nearest 0.5, kg to the nearest 0.25 — enough that a value converted there// and back lands where it started for any plate-loadable number.+import { isSideSet, syncSideAggregate } from './workout-model.js'+const LB_PER_KG = 2.2046226218export function convertWeight(value, from, to) {@@ -14,6 +16,9 @@ export function convertWeight(value, from, to) {const convSet = (set, from, to) => {if (!set || typeof set !== 'object') return setconst out = { ...set }+ if (isSideSet(set)) return syncSideAggregate({ ...set, sides: {+ L: convSet(set.sides.L, from, to), R: convSet(set.sides.R, from, to),+ } })if (out.w != null) out.w = convertWeight(out.w, from, to)if (Array.isArray(out.drops)) out.drops = out.drops.map(d => ({ ...d, w: convertWeight(d.w, from, to) }))return outdiff --git a/frontend/src/lib/workout-model.js b/frontend/src/lib/workout-model.jsindex e66e89508..272795489 100644--- a/frontend/src/lib/workout-model.js+++ b/frontend/src/lib/workout-model.js@@ -142,9 +142,8 @@ export function splitBurstReps(total) {// exactly what a single combined row hides. So a per-side row logs each side on its own: weight,// reps, effort and its own done tick, held in `sides: { L, R }`.//-// Like `drops`/`clusters`, this rides on the row while the row's own `w`/`r`/`done`/effort stay a-// correct aggregate of the two sides — so volume, 1RM, PRs, progression, recovery, history and the-// coach keep reading a row's scalar fields and need not know sides exist:+// The row keeps a scalar summary for existing consumers. These fields cannot reconstruct+// asymmetric loads: volume and edits must read the individual sides instead.// r = L.r + R.r (the both-sides total, exactly what those readers expect of a per-side set)// w = max(L.w, R.w) (the heavier side; the two are usually equal)// done = L.done && R.done (a set counts done only once both sides are)@@ -155,6 +154,18 @@ export function isSideSet(set) {return !!(s.sides && typeof s.sides === 'object' && s.sides.L && s.sides.R)}+/** Includes a completed limb even when its partner is still unchecked. */+export const hasCompletedWork = set => isSideSet(set)+ ? set.sides.L.done === true || set.sides.R.done === true+ : set?.done === true++/** Actual completed load x reps; the scalar maximum weight is only a summary. */+export function completedVolumeOf(set) {+ if (isSideSet(set)) return completedVolumeOf(set.sides.L) + completedVolumeOf(set.sides.R)+ if (!set?.done) return 0+ return (Number(set.w) || 0) * (Number(set.r) || 0) + extraVolumeOf(set)+}+const sideOf = value => {const v = objectOf(value)const out = { w: Number(v.w) || 0, r: Number(v.r) || 0, done: v.done === true }diff --git a/frontend/src/sheets.jsx b/frontend/src/sheets.jsxindex 8b1f548c0..60f426fca 100644--- a/frontend/src/sheets.jsx+++ b/frontend/src/sheets.jsx@@ -29,7 +29,7 @@ import { nextPrescription, applyPrescription, policyFor, defaultIncrement, POLICimport { normalizeRepRange } from './lib/rep-range.js'import { MOBILE, shareExport } from './lib/mobile.js'import { buildCompletedWorkout } from './lib/finish-workout.js'-import { isWarmupRow } from './lib/workout-model.js'+import { isWarmupRow, hasCompletedWork } from './lib/workout-model.js'import { nextUnfinishedUnit } from './lib/supersetFlow.js'import { swapActiveExercise } from './lib/active-exercise-swap.js'import { useSheetKeyboard, useRevealActiveChip, tappable } from './lib/use-sheet-keyboard.js'@@ -1628,7 +1628,7 @@ function WorkoutDetail({ w, close }) {return <div key={i} className="row" style={{ marginBottom: 12, alignItems: 'flex-start' }}>{ex && <Thumb ex={ex} />}<div className="grow"><div className="tt capitalize" style={{ fontWeight: 600 }}>{ex ? exerciseNameFor(ex) : (e.n || e.id)} {w.prs && w.prs.includes(e.id) && <span className="pr"><Icon name="trophy" />PR</span>}</div>- <div className="ss">{e.sets.filter(s => s.done).map(s => setLabel(e.id, s, e.target)).join(' · ') || t('no sets')}</div>+ <div className="ss">{e.sets.filter(hasCompletedWork).map(s => setLabel(e.id, s, e.target)).join(' · ') || t('no sets')}</div>{e.note && <div className="small dim" style={{ marginTop: 3 }}>{e.notePin && <Icon name="flag" style={{ fontSize: 12, marginRight: 4, verticalAlign: '-1px', color: 'var(--yellow)' }} />}{e.note}</div>}</div>diff --git a/frontend/src/views/Workout.jsx b/frontend/src/views/Workout.jsxindex 4ac31adef..230c1f280 100644--- a/frontend/src/views/Workout.jsx+++ b/frontend/src/views/Workout.jsx@@ -294,7 +294,11 @@ function ExerciseBlock({ entryIdx, compact, dense, onToggle, onToggleSide, onFieconst v = sd[col.f] ?? nullconst rir = col.eff === 'rpe' ? (v == null ? null : 10 - v) : vconst color = effortColor(rir)- const open = () => effortPickerSheet(col.eff, v, nv => setSide(i, side, col.f, nv))+ const open = () => effortPickerSheet(col.eff, v, nv => {+ setSide(i, side, col.f, nv)+ const fresh = useStore.getState().S.active?.entries[entryIdx]?.sets[i]?.sides?.[side]+ if (nv != null && fresh && !fresh.done) onToggleSide(i, side)+ })if (v == null) return <button className="effcell is-empty" aria-label={col.hd} onClick={open}>{col.hd}</button>const step = dir => setSide(i, side, col.f, stepEffort(col.eff, v, dir))return (diff --git a/frontend/src/views/Workout.test.jsx b/frontend/src/views/Workout.test.jsxindex 804469e5f..01eea0fe2 100644--- a/frontend/src/views/Workout.test.jsx+++ b/frontend/src/views/Workout.test.jsx@@ -1308,3 +1308,38 @@ describe('effort rating auto-ends the set', () => {expect(mocks.S.active.entries[0].sets[0].done).toBe(true) // still done})})++describe('per-side effort completion', () => {+ it.each(['rir', 'rpe'])('completes only the rated side for %s and keeps undo explicit', async scale => {+ const side = () => ({ w: 20, r: 8, done: false })+ await mount([exercise('plain-bench', [false], {+ target: { mode: 'reps', side: true, reps: 16, weight: 20, bodyweight: false },+ sets: [+ { w: 20, r: 16, done: false, sides: { L: side(), R: side() } },+ { w: 20, r: 16, done: false, sides: { L: side(), R: side() } },+ ],+ })], 0, { effort: scale })+ const cells = container.querySelectorAll('.side-rows .effcell.is-empty')+ await act(async () => { cells[0].dispatchEvent(new dom.Event('click', { bubbles: true })) })+ const leftPick = mocks.effortPickerSheet.mock.calls.at(-1)[2]+ await act(async () => { leftPick(scale === 'rir' ? 2 : 8) })+ let set = mocks.S.active.entries[0].sets[0]+ expect(set.sides.L.done).toBe(true)+ expect(set.sides.R.done).toBe(false)+ expect(set.done).toBe(false)+ expect(mocks.startRest).not.toHaveBeenCalled()+ await act(async () => { leftPick(3); leftPick(null) })+ expect(mocks.S.active.entries[0].sets[0].sides.L.done).toBe(true)+ expect(mocks.S.active.entries[0].sets[0].sides.L[scale]).toBeUndefined()+ await act(async () => { cells[1].dispatchEvent(new dom.Event('click', { bubbles: true })) })+ const rightPick = mocks.effortPickerSheet.mock.calls.at(-1)[2]+ await act(async () => { rightPick(scale === 'rir' ? 0 : 10) })+ set = mocks.S.active.entries[0].sets[0]+ expect(set.done).toBe(true)+ expect(mocks.startRest).toHaveBeenCalledWith(90, expect.any(Number))+ const calls = mocks.startRest.mock.calls.length+ await act(async () => { rightPick(1) })+ expect(set.sides.R.done).toBe(true)+ expect(mocks.startRest).toHaveBeenCalledTimes(calls)+ })+})