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
sync: pushes are conditional on the revision this device last saw and a refused push merges both copies (lib/sync-merge.js — no workout, routine or weigh-in is dropped, the newer copy decides settings); the store pulls when the tab, window, app or network comes back, one push and one pull at a time, and nothing pushes before boot has pulled
Duarte Santosc92cfc372aac
diff --git a/frontend/src/lib/api.js b/frontend/src/lib/api.jsindex ec1c3d821..dc15c65ba 100644--- a/frontend/src/lib/api.js+++ b/frontend/src/lib/api.js@@ -20,7 +20,8 @@ export async function api(path, opts) {if (remoteToken) headers.Authorization = 'Bearer ' + remoteTokenconst r = await fetch(remoteBase + path, Object.assign({}, opts, { headers }))const data = await r.json().catch(() => ({}))- if (!r.ok) { const e = new Error(data.error || ('HTTP ' + r.status)); e.status = r.status; throw e }+ // The body rides along on the error: a 409 from /api/data carries the server's document.+ if (!r.ok) { const e = new Error(data.error || ('HTTP ' + r.status)); e.status = r.status; e.data = data; throw e }return data}diff --git a/frontend/src/lib/api.test.js b/frontend/src/lib/api.test.jsindex 53360dcbc..30618a7b9 100644--- a/frontend/src/lib/api.test.js+++ b/frontend/src/lib/api.test.js@@ -33,3 +33,16 @@ describe('webauthnOK', () => {expect(webauthnOK()).toBe(false)})})++describe('api()', () => {+ it('a failed request throws with the status and the parsed body attached', async () => {+ const { api } = await import('./api.js')+ const original = globalThis.fetch+ globalThis.fetch = async () => ({ ok: false, status: 409, json: async () => ({ error: 'conflict', rev: 3, state: { _rev: 3 } }) })+ try {+ await expect(api('/api/data', { method: 'PUT', body: '{}' })).rejects.toMatchObject({+ message: 'conflict', status: 409, data: { error: 'conflict', rev: 3, state: { _rev: 3 } }+ })+ } finally { globalThis.fetch = original }+ })+})diff --git a/frontend/src/lib/mobile.js b/frontend/src/lib/mobile.jsindex f2cc584e7..fa89aa516 100644--- a/frontend/src/lib/mobile.js+++ b/frontend/src/lib/mobile.js@@ -163,6 +163,16 @@ export function initReminderSync(getState) {}).catch(() => {})}+// Runs cb whenever the native shell returns to the foreground — the store pulls the account's+// state then, so a phone that sat in a pocket all afternoon shows what the desktop did. No-op+// off mobile; the store's own visibility/focus listeners cover the browser.+export function onAppActive(cb) {+ if (!MOBILE) return+ import('@capacitor/app').then(({ App }) => {+ App.addListener('appStateChange', ({ isActive }) => { if (isActive) cb() })+ }).catch(() => {})+}+// WKWebView can't do blob-URL downloads, so the backup goes out through the OS share sheet// (Files, AirDrop, mail, …) from a temp file instead.export async function shareExport(json, filename) {diff --git a/frontend/src/lib/sync-merge.js b/frontend/src/lib/sync-merge.jsnew file mode 100644index 000000000..4ce274060--- /dev/null+++ b/frontend/src/lib/sync-merge.js@@ -0,0 +1,88 @@+/* Two copies of the account state, one merged copy.+ *+ * The server refuses a push over a document the device never saw (PUT /api/data with a stale+ * `baseRev` answers 409 and hands back the current document). Before revisions the newer `_ts`+ * simply replaced the other copy wholesale — which is exactly how a desktop tab that sat open+ * all day dropped the workout the phone logged in the meantime. The merge keeps both sides'+ * entries and lets the newer copy decide everything that has no natural union.+ *+ * Rules, by field:+ * - scalars and settings, `week`, `dayPlan`, `wc`, `reminder`, …: from the copy with the newer `_ts`+ * - workouts, routines, customEx, equipProfiles, gymCards: union by id, the newer copy's version+ * of an id that both have; workouts sorted by day and start like every other writer+ * - bodyweight: union by day, the later-edited (`t`) entry of a day that both have+ * - favEx: ordered set union, the newer copy first+ * - exWeights: union by exercise, the larger `w` (the app itself only ever raises it — a PR+ * logged on the other device must not be forgotten); exNotes, barWeights: key union+ * - `_ts`: the later of the two; `_rev` dropped (the server sets it); `active` left to the caller+ *+ * Known limit: with no record of what each side deleted, an entry removed on one device inside+ * the conflict window comes back from the other. The window is a few seconds now (the store pulls+ * on resume and every push is conditional), and a resurrected entry beats a lost one. Tombstones+ * would close it.+ */+const clone = o => JSON.parse(JSON.stringify(o))+const list = v => (Array.isArray(v) ? v : [])++/** The copy with the later `_ts`; on a tie the first argument (callers pass local first). */+export const newerOf = (a, b) => ((b?._ts || 0) > (a?._ts || 0) ? b : a)++/**+ * Entries of `newer` in their order, then those of `older` whose key nothing in `newer` has.+ * Same key → `newer`'s entry. Duplicate keys within one list are dropped (first wins).+ */+export function unionById(newer = [], older = [], key = x => x?.id) {+ const seen = new Set()+ const out = []+ for (const x of [...list(newer), ...list(older)]) {+ const k = key(x)+ if (k == null) { out.push(x); continue }+ if (seen.has(k)) continue+ seen.add(k)+ out.push(x)+ }+ return out+}++const workoutKey = w => (w?.id != null ? w.id : `${w?.d}|${w?.start}`)+const byDayStart = (a, b) => (a.d === b.d ? (a.start || 0) - (b.start || 0) : a.d < b.d ? -1 : 1)++/** One entry per day; where both have a day, the one edited later (`t`); sorted by day. */+export function mergeBodyweight(a = [], b = []) {+ const byDay = new Map()+ for (const e of [...list(a), ...list(b)]) {+ if (!e || e.d == null) continue+ const cur = byDay.get(e.d)+ if (!cur || (e.t || 0) > (cur.t || 0)) byDay.set(e.d, e)+ }+ return [...byDay.values()].sort((x, y) => (x.d < y.d ? -1 : 1))+}++function mergeExWeights(n = {}, o = {}) {+ const out = { ...(o || {}), ...(n || {}) }+ for (const k of Object.keys(o || {})) {+ if (n && n[k] && o[k] && (o[k].w || 0) > (n[k].w || 0)) out[k] = o[k]+ }+ return out+}++export function mergeStates(a, b) {+ if (!a) return b ? clone(b) : b+ if (!b) return clone(a)+ const n = newerOf(a, b)+ const o = n === a ? b : a+ const out = clone(n)+ out.workouts = unionById(n.workouts, o.workouts, workoutKey).map(clone).sort(byDayStart)+ for (const f of ['routines', 'customEx', 'equipProfiles', 'gymCards']) {+ if (list(n[f]).length || list(o[f]).length) out[f] = unionById(n[f], o[f]).map(clone)+ }+ out.bodyweight = mergeBodyweight(n.bodyweight, o.bodyweight).map(clone)+ if (list(n.favEx).length || list(o.favEx).length) out.favEx = [...new Set([...list(n.favEx), ...list(o.favEx)])]+ out.exWeights = clone(mergeExWeights(n.exWeights, o.exWeights))+ for (const f of ['exNotes', 'barWeights']) {+ if (n[f] || o[f]) out[f] = clone({ ...(o[f] || {}), ...(n[f] || {}) })+ }+ out._ts = Math.max(a._ts || 0, b._ts || 0)+ delete out._rev+ return out+}diff --git a/frontend/src/lib/sync-merge.test.js b/frontend/src/lib/sync-merge.test.jsnew file mode 100644index 000000000..608da779a--- /dev/null+++ b/frontend/src/lib/sync-merge.test.js@@ -0,0 +1,133 @@+import { describe, expect, it } from 'vitest'+import { mergeBodyweight, mergeStates, newerOf, unionById } from './sync-merge.js'++const workout = (id, d = '2026-09-01', start = 1) => ({ id, d, start, entries: [] })+const routine = (id, name = id) => ({ id, name, ex: [] })+const base = (over = {}) => ({+ unit: 'kg', restSec: 90, lang: 'en', week: { 1: ['r1'] }, dayPlan: {},+ workouts: [], routines: [], bodyweight: [], customEx: [], favEx: [], exWeights: {}, exNotes: {}, barWeights: {},+ equipProfiles: [], gymCards: [], _ts: 0, ...over+})+const ids = xs => (xs || []).map(x => x.id)++describe('newerOf / unionById / mergeBodyweight', () => {+ it('picks the later _ts, first argument on a tie or missing stamps', () => {+ const a = { _ts: 5 }, b = { _ts: 9 }+ expect(newerOf(a, b)).toBe(b)+ expect(newerOf(b, a)).toBe(b)+ expect(newerOf({ _ts: 5 }, { _ts: 5 })).toEqual({ _ts: 5 })+ expect(newerOf({}, { })).toEqual({})+ })+ it('unions by id in the newer order, newer wins a shared id, dupes dropped', () => {+ const out = unionById([routine('a', 'A2'), routine('b'), routine('b')], [routine('c'), routine('a', 'A1')])+ expect(ids(out)).toEqual(['a', 'b', 'c'])+ expect(out[0].name).toBe('A2')+ expect(unionById(undefined, null)).toEqual([])+ })+ it('bodyweight: one entry per day, the later-edited one, sorted', () => {+ const out = mergeBodyweight([{ d: '2026-09-02', w: 80, t: 5 }], [{ d: '2026-09-01', w: 81, t: 1 }, { d: '2026-09-02', w: 79, t: 9 }])+ expect(out).toEqual([{ d: '2026-09-01', w: 81, t: 1 }, { d: '2026-09-02', w: 79, t: 9 }])+ })+})++describe('mergeStates', () => {+ const A = () => base({+ _ts: 200, restSec: 120, week: { 1: ['rA'] },+ workouts: [workout('w1'), workout('wA', '2026-09-03')],+ routines: [routine('shared', 'from A'), routine('onlyA')],+ bodyweight: [{ d: '2026-09-01', w: 80, t: 10 }],+ customEx: [{ id: 'cA', name: 'A ex' }], favEx: ['x', 'y'],+ exWeights: { sq: { w: 100 }, bp: { w: 60 } }, exNotes: { sq: 'A note' }, barWeights: { sq: 20 },+ gymCards: [{ id: 'g1', value: '1' }], _rev: 7+ })+ const B = () => base({+ _ts: 100, restSec: 60, week: { 1: ['rB'] },+ workouts: [workout('w1'), workout('wB', '2026-09-02')],+ routines: [routine('shared', 'from B'), routine('onlyB')],+ bodyweight: [{ d: '2026-09-01', w: 79, t: 20 }, { d: '2026-08-30', w: 82, t: 1 }],+ customEx: [{ id: 'cB', name: 'B ex' }], favEx: ['y', 'z'],+ exWeights: { sq: { w: 110 }, dl: { w: 140 } }, exNotes: { dl: 'B note' }, barWeights: { dl: 15 },+ gymCards: [{ id: 'g2', value: '2' }], _rev: 8+ })++ it('no entity of either side disappears, ids stay unique', () => {+ const m = mergeStates(A(), B())+ expect(ids(m.workouts).sort()).toEqual(['w1', 'wA', 'wB'])+ expect(ids(m.routines).sort()).toEqual(['onlyA', 'onlyB', 'shared'])+ expect(ids(m.customEx).sort()).toEqual(['cA', 'cB'])+ expect(ids(m.gymCards).sort()).toEqual(['g1', 'g2'])+ expect(m.bodyweight.map(b => b.d)).toEqual(['2026-08-30', '2026-09-01'])+ expect(m.favEx).toEqual(['x', 'y', 'z'])+ expect(new Set(ids(m.workouts)).size).toBe(m.workouts.length)+ })++ it('the newer copy decides settings, week, and a shared id; the other way round too', () => {+ const m = mergeStates(A(), B())+ expect(m.restSec).toBe(120)+ expect(m.week).toEqual({ 1: ['rA'] })+ expect(m.routines.find(r => r.id === 'shared').name).toBe('from A')+ const m2 = mergeStates(B(), { ...A(), _ts: 50 })+ expect(m2.restSec).toBe(60)+ expect(m2.week).toEqual({ 1: ['rB'] })+ expect(m2.routines.find(r => r.id === 'shared').name).toBe('from B')+ })++ it('bodyweight keeps the later-edited entry of a day, exWeights the larger weight, notes union', () => {+ const m = mergeStates(A(), B())+ expect(m.bodyweight.find(b => b.d === '2026-09-01')).toEqual({ d: '2026-09-01', w: 79, t: 20 })+ expect(m.exWeights).toEqual({ sq: { w: 110 }, bp: { w: 60 }, dl: { w: 140 } })+ expect(m.exNotes).toEqual({ sq: 'A note', dl: 'B note' })+ expect(m.barWeights).toEqual({ sq: 20, dl: 15 })+ })++ it('is commutative on the union fields and idempotent', () => {+ const ab = mergeStates(A(), B()), ba = mergeStates(B(), A())+ for (const f of ['workouts', 'routines', 'customEx', 'gymCards']) expect(ids(ab[f]).sort()).toEqual(ids(ba[f]).sort())+ expect(ab.bodyweight).toEqual(ba.bodyweight)+ expect([...ab.favEx].sort()).toEqual([...ba.favEx].sort())+ expect(ab.exWeights).toEqual(ba.exWeights)+ const again = mergeStates(A(), ab)+ expect(ids(again.workouts)).toEqual(ids(ab.workouts))+ expect(ids(again.routines)).toEqual(ids(ab.routines))+ expect(mergeStates(A(), A()).workouts).toEqual(A().workouts)+ })++ it('sorts workouts by day and start, takes the later _ts, drops _rev, does not touch inputs', () => {+ const a = A(), b = B()+ const m = mergeStates(a, b)+ expect(m.workouts.map(w => w.d)).toEqual(['2026-09-01', '2026-09-02', '2026-09-03'])+ expect(m._ts).toBe(200)+ expect('_rev' in m).toBe(false)+ expect(a).toEqual(A())+ expect(b).toEqual(B())+ m.workouts[0].entries.push('x')+ expect(a.workouts[0].entries).toEqual([])+ })++ it('tolerates a missing side and missing lists', () => {+ expect(mergeStates(A(), null)).toEqual(A())+ expect(mergeStates(null, B())).toEqual(B())+ const sparse = { _ts: 5, workouts: null, routines: undefined }+ const m = mergeStates(sparse, { _ts: 1, workouts: [workout('w')], bodyweight: undefined })+ expect(ids(m.workouts)).toEqual(['w'])+ expect(m.bodyweight).toEqual([])+ })++ it('a workout without an id is kept once by day and start', () => {+ const legacy = { d: '2026-09-01', start: 5, entries: [] }+ const m = mergeStates({ _ts: 2, workouts: [legacy] }, { _ts: 1, workouts: [{ ...legacy }, { d: '2026-09-01', start: 6, entries: [] }] })+ expect(m.workouts).toHaveLength(2)+ })++ // The report that started this: desktop adopted the server copy at T0, the phone logged a+ // workout at T1, the desktop then changed one setting at T2 and pushed its whole document.+ it('the desktop setting and the phone workout both survive', () => {+ const t0 = base({ _ts: 1000, workouts: [workout('w1')], restSec: 90 })+ const server = { ...t0, _ts: 1001, workouts: [workout('w1'), workout('from-phone', '2026-09-05')], _rev: 4 }+ const desktop = { ...t0, _ts: 1002, restSec: 75 }+ const m = mergeStates(desktop, server)+ expect(ids(m.workouts)).toEqual(['w1', 'from-phone'])+ expect(m.restSec).toBe(75)+ expect(m._ts).toBe(1002)+ })+})diff --git a/frontend/src/store/useStore.js b/frontend/src/store/useStore.jsindex f38f35a98..c8a3cd85b 100644--- a/frontend/src/store/useStore.js+++ b/frontend/src/store/useStore.js@@ -5,13 +5,20 @@ import { t } from '../lib/i18n.js'import { registerCustom } from '../lib/exercises.js'import { DEMO, DEMO_SEEDED } from '../lib/demo.js'import { guestAllowed } from '../lib/guest.js'-import { MOBILE, initReminderSync, nativeLoad, nativeSave, syncReminder, writeAutoBackup } from '../lib/mobile.js'+import { MOBILE, initReminderSync, nativeLoad, nativeSave, onAppActive, syncReminder, writeAutoBackup } from '../lib/mobile.js'+import { mergeStates } from '../lib/sync-merge.js'import { loadRemote, chooseLocal, forgetRemote, connect } from '../lib/remote.js'import { loadCoachDevice, saveCoachDevice, coachDeviceSettings } from '../lib/coach-device.js'import { WC_DEFAULT } from '../lib/workout-controls.js'const KEY = 'gym_state_v1'+// Where this device stands with the server: the revision it last adopted or pushed, and its own+// `_ts` at that moment. `rev` goes back to the server as `baseRev` on every push, so a write over+// a document this device never saw is refused (409) instead of dropping another device's work;+// `ts` tells a pull whether anything changed here since. See pushState/pullState.+const SYNC_KEY = 'gym_sync'+const PULL_MIN_MS = 15000 // resume pulls closer together than this are noise, not newsexport const DEF = {unit: 'kg', restSec: 90, restPauseSec: 15, sound: true, timerFlash: false, keepAwake: true, lang: 'en',theme: 'dark', accent: 'lime', body: 'male', targetW: null,@@ -94,6 +101,15 @@ export const useStore = create((set, get) => {let pushTm = nulllet saveTm = nulllet toldTooLarge = false+ let pushing = null // the PUT in flight, so a second push waits for it instead of racing it+ let pushAgain = false // a push asked for while one was in flight — run once more after it+ let pulling = null // the GET in flight, so two resume signals make one request+ let pushPending = false // a change made before boot's pull — pushed once boot is through+ let forceNext = false // the next push replaces the server copy outright (import, reset)+ let lastPull = 0++ const readSync = () => { try { return JSON.parse(localStorage.getItem(SYNC_KEY)) || null } catch { return null } }+ const writeSync = (rev, ts) => localStorage.setItem(SYNC_KEY, JSON.stringify({ rev, ts: ts || 0 }))initReminderSync(() => get().S)@@ -115,9 +131,89 @@ export const useStore = create((set, get) => {set({ S })if (MOBILE) nativePersist()if (push && get().user) {+ // Before boot has pulled, the copy in hand may be older than the server's: a push now+ // would carry it with a stale (or no) baseRev. It waits for finishBoot.+ if (!get().ready) { pushPending = true; return }+ clearTimeout(pushTm)+ pushTm = setTimeout(() => get().pushState(), 1500)+ }+ }+ // Boot's last step: from here on changes push, and one made during boot goes now.+ const finishBoot = (extra = {}) => {+ set({ ready: true, ...extra })+ if (pushPending && get().user) {clearTimeout(pushTm)pushTm = setTimeout(() => get().pushState(), 1500)}+ pushPending = false+ }++ // The other side of the hidden-tab flush below: coming back — to the tab, the window, the app,+ // the network — asks the server what happened meanwhile. A phone that sat in a pocket all+ // afternoon and a desktop tab left open all week used to show, and then push, whatever they+ // last had; now they catch up first. Throttled, since focus and visibility fire together.+ const resumePull = (force = false) => {+ if (!get().user || !get().ready || document.visibilityState === 'hidden') return+ if (!force && Date.now() - lastPull < PULL_MIN_MS) return+ get().pullState()+ }+ document.addEventListener('visibilitychange', () => { if (document.visibilityState === 'visible') resumePull() })+ window.addEventListener('focus', () => resumePull())+ window.addEventListener('pageshow', e => { if (e.persisted) resumePull() })+ window.addEventListener('online', () => resumePull(true)) // also retries a push that failed offline+ onAppActive(() => resumePull())++ // Both copies changed: keep both sides' entries, let the newer copy decide the rest+ // (lib/sync-merge.js), and remember the server's revision so the push that follows is+ // conditional on exactly the document that was merged. The merged copy is stamped — it is a+ // real change this device now holds — while `ts` in the marker stays old, so a pull that+ // happens before the push lands still sees it as unsent.+ const mergeInto = (local, remote, rev) => {+ const merged = Object.assign(clone(DEF), mergeStates(local, remote))+ merged.active = local.active || null+ persist(merged, false)+ writeSync(rev, readSync()?.ts || 0)+ }+ // Take the server's copy as this device's own, timestamp and all (see persist).+ const adopt = (next, rev) => { persist(next, false, false); writeSync(rev, next._ts) }++ const doPush = async (attempt = 0) => {+ const S = get().S+ const sync = readSync()+ const force = forceNext+ const body = { state: S }+ if (!force && sync) body.baseRev = sync.rev+ try {+ const r = await api('/api/data', { method: 'PUT', body: JSON.stringify(body) })+ if (force) forceNext = false+ // A server from before revisions answers without one — then there is nothing to hold the+ // next push to, and the marker must not pretend otherwise.+ if (r.rev == null) localStorage.removeItem(SYNC_KEY)+ else writeSync(r.rev, S._ts)+ localStorage.removeItem('gym_dirty')+ toldTooLarge = false+ } catch (e) {+ // A session that is gone is boot's business (/api/me); the copy stays owed to the server.+ if (e.status === 401) { localStorage.setItem('gym_dirty', '1'); return }+ if (e.status === 409 && e.data && attempt < 2) {+ // Another device wrote since this one last read. The server sent its document along;+ // merge and push once more against that revision. A second refusal in a row leaves the+ // copy dirty and the next resume pull takes it from there.+ mergeInto(get().S, e.data.state, e.data.rev || 0)+ return doPush(attempt + 1)+ }+ localStorage.setItem('gym_dirty', '1')+ // A 413 comes from the proxy in front of the API (nginx: client_max_body_size), which+ // caps the request body. Every later push is at least as big, so nothing reaches the+ // server until the limit is raised — said once per refusal streak; gym_dirty keeps the+ // retries going. useUI imports this store, hence the lazy import.+ if (e.status === 413 && !toldTooLarge) {+ toldTooLarge = true+ import('./useUI.js')+ .then(({ useUI }) => useUI.getState().toast(t('Sync failed: the server refused the upload as too large. Your changes have not reached the server.')))+ .catch(() => {})+ }+ }}// A setting changed right before switching away/closing the tab must not get lost mid-debounce@@ -161,6 +257,7 @@ export const useStore = create((set, get) => {get().setUser(null)localStorage.removeItem('gym_guest')localStorage.removeItem('gym_dirty')+ localStorage.removeItem(SYNC_KEY)localStorage.removeItem(KEY)persist(clone(DEF), false)localStorage.removeItem('gym_owner')@@ -189,7 +286,9 @@ export const useStore = create((set, get) => {mut(S)persist(S, push)},- replaceState(S, push = false) { persist(clone(S), push) },+ // A replace that is meant to reach the server (backup import, reset) is a deliberate+ // overwrite, not a change to merge: the push it arms goes without a baseRev.+ replaceState(S, push = false) { if (push) forceNext = true; persist(clone(S), push) },// Fires after the moments where losing local data would actually hurt — a workout just// logged, a routine just edited — not on every keystroke. No-op off mobile or with the@@ -227,6 +326,7 @@ export const useStore = create((set, get) => {const owner = localStorage.getItem('gym_owner')if (owner && owner !== u.id) {localStorage.removeItem('gym_dirty')+ localStorage.removeItem(SYNC_KEY)localStorage.removeItem(KEY)persist(clone(DEF), false)}@@ -236,34 +336,67 @@ export const useStore = create((set, get) => {set({ user: u })},+ // One PUT at a time: a push asked for while one is in flight runs after it (once, however+ // many asked), and the promise returned covers that follow-up too, so a caller that awaits+ // before signing out knows the last change is on the server.async pushState() {if (!get().user) returnclearTimeout(pushTm)- try { await api('/api/data', { method: 'PUT', body: JSON.stringify({ state: get().S }) }); localStorage.removeItem('gym_dirty'); toldTooLarge = false }- catch (e) {- localStorage.setItem('gym_dirty', '1')- // A 413 comes from the proxy in front of the API (nginx: client_max_body_size), which- // caps the request body. Every later push is at least as big, so nothing reaches the- // server until the limit is raised — said once per refusal streak; gym_dirty keeps the- // retries going. useUI imports this store, hence the lazy import.- if (e.status === 413 && !toldTooLarge) {- toldTooLarge = true- import('./useUI.js')- .then(({ useUI }) => useUI.getState().toast(t('Sync failed: the server refused the upload as too large. Your changes have not reached the server.')))- .catch(() => {})- }- }+ pushTm = null+ if (pushing) { pushAgain = true; return pushing.then(() => pushing) }+ pushing = doPush().finally(() => {+ pushing = null+ if (pushAgain) { pushAgain = false; get().pushState() }+ })+ return pushing},+ // Ask the server for its copy and settle the difference. Coalesced, and a push still waiting+ // in the debounce goes first — the server's answer is then the one that already includes it,+ // and the push itself is what catches a conflict.async pullState() {- try {- const { state } = await api('/api/data')- const S = get().S- const dirty = localStorage.getItem('gym_dirty') === '1'- const restored = restoredStateFor(S, state, dirty)- if (restored) {- persist(restored, false, false)- } else if (hasData(S)) { await get().pushState() }- } catch (e) { /* offline — keep local */ }+ if (pulling) return pulling+ pulling = (async () => {+ try {+ if (pushTm) { clearTimeout(pushTm); pushTm = null; await get().pushState() }+ else if (pushing) await pushing+ const res = await api('/api/data')+ lastPull = Date.now()+ const { state, rev } = res+ const S = get().S+ // Owed to the server: a push that failed, or a change made while boot was still pulling.+ const dirty = localStorage.getItem('gym_dirty') === '1' || pushPending+ const sync = readSync()+ // A server from before revisions: the old rule, newer `_ts` wins outright.+ if (rev == null) {+ localStorage.removeItem(SYNC_KEY)+ const restored = restoredStateFor(S, state, dirty)+ if (restored) persist(restored, false, false)+ else if (hasData(S)) await get().pushState()+ return+ }+ // No marker yet — first pull on this device, or a client that just learned about+ // revisions. The newer copy wins as before, except that a copy still owed to the+ // server (dirty) is merged instead of pushed over whatever is there.+ if (!sync) {+ if (dirty && state) { mergeInto(S, state, rev); pushPending = false; await get().pushState(); return }+ const restored = restoredStateFor(S, state, false)+ if (restored) adopt(restored, rev)+ else if (hasData(S)) { writeSync(rev, 0); await get().pushState() }+ else writeSync(rev, state?._ts || 0)+ return+ }+ const serverMoved = rev !== sync.rev+ const localChanged = dirty || (S._ts || 0) > (sync.ts || 0)+ if (!serverMoved) { if (localChanged) await get().pushState(); return }+ if (!state) { writeSync(rev, 0); if (hasData(S)) await get().pushState(); return }+ if (!localChanged) { adopt(Object.assign(clone(DEF), state, { active: S.active || null }), rev); return }+ mergeInto(S, state, rev)+ pushPending = false+ await get().pushState()+ } catch (e) { /* offline — keep local */ }+ finally { pulling = null }+ })()+ return pulling},async signOut() {@@ -340,7 +473,7 @@ export const useStore = create((set, get) => {else get().setUser(remote.user) // offline — keep going from the last-synced local copy}syncReminder(get().S)- set({ ready: true })+ finishBoot()return}const saved = await nativeLoad()@@ -355,7 +488,7 @@ export const useStore = create((set, get) => {// Only a genuinely first launch — nothing chosen yet and nothing to lose either — offers// the choice. Picking local (even with no data yet) persists that choice below and this// never asks again.- set({ ready: true, needsMobileOnboarding: !remote && !hasData(get().S) })+ finishBoot({ needsMobileOnboarding: !remote && !hasData(get().S) })return}// Demo build (GitHub Pages): no backend at all — seed once, stay in guest mode.@@ -365,7 +498,7 @@ export const useStore = create((set, get) => {await get().resetDemo()}get().setGuest(true)- set({ ready: true })+ finishBoot()return}// Guests never authenticate, so an instance that turned guest mode off has no request to@@ -387,7 +520,7 @@ export const useStore = create((set, get) => {} catch (e) {if (e.status === 401) get().setUser(null)}- set({ ready: true })+ finishBoot()}}})diff --git a/frontend/src/store/useStore.restore.test.jsx b/frontend/src/store/useStore.restore.test.jsxindex 149ac4837..abf28a23d 100644--- a/frontend/src/store/useStore.restore.test.jsx+++ b/frontend/src/store/useStore.restore.test.jsx@@ -75,7 +75,29 @@ describe('saved workout state sync and restore', () => {expect(useStore.getState().S.routines.map(r => r.id)).toEqual(['local'])})- it('pushes local data instead of overwriting a dirty local state', async () => {+ // A dirty copy is one the server has not seen yet — not one that outranks the server's. With a+ // revision in the answer the two are merged and the merge is pushed against that revision.+ it('merges a dirty local state with the server copy and pushes the merge', async () => {+ const local = { ...clone(DEF), _ts: 10, routines: [routine('local')] }+ const remote = { ...clone(DEF), _ts: 20, routines: [routine('remote')], _rev: 3 }+ localStorage.setItem('gym_dirty', '1')+ useStore.setState({ S: local, user: { id: 'user-1' }, ready: true })+ api.mockResolvedValueOnce({ state: remote, rev: 3 }).mockResolvedValueOnce({ ok: true, rev: 4 })++ await useStore.getState().pullState()++ expect(api).toHaveBeenCalledTimes(2)+ const put = JSON.parse(api.mock.calls[1][1].body)+ expect(put.baseRev).toBe(3)+ expect(put.state.routines.map(r => r.id).sort()).toEqual(['local', 'remote'])+ expect(useStore.getState().S.routines.map(r => r.id).sort()).toEqual(['local', 'remote'])+ expect(localStorage.getItem('gym_dirty')).toBeNull()+ expect(JSON.parse(localStorage.getItem('gym_sync'))).toEqual({ rev: 4, ts: useStore.getState().S._ts })+ })++ // A server from before revisions answers without one; then the old rule holds and the dirty+ // copy is pushed as it is.+ it('pushes a dirty local state as-is to a server without revisions', async () => {const local = { ...clone(DEF), _ts: 10, routines: [routine('local')] }const remote = { ...clone(DEF), _ts: 20, routines: [routine('remote')] }localStorage.setItem('gym_dirty', '1')diff --git a/frontend/src/store/useStore.sync.test.jsx b/frontend/src/store/useStore.sync.test.jsxnew file mode 100644index 000000000..b3c2a42ff--- /dev/null+++ b/frontend/src/store/useStore.sync.test.jsx@@ -0,0 +1,326 @@+// @vitest-environment happy-dom++/* Two devices, one account: the server refuses a push over a document this device never saw+ (409 with the current copy), the store merges and pushes again; a pull adopts, pushes or+ merges by comparing the server revision and its own marker; nothing pushes before boot has+ pulled; coming back to the tab pulls. */+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'++vi.mock('../lib/api.js', () => ({ api: vi.fn() }))+const { toast } = vi.hoisted(() => ({ toast: vi.fn() }))+vi.mock('./useUI.js', () => ({ useUI: { getState: () => ({ toast }) } }))++import { api } from '../lib/api.js'+import { DEF, useStore } from './useStore.js'++const clone = value => JSON.parse(JSON.stringify(value))+const routine = id => ({ id, name: id, ex: [] })+const workout = (id, d = '2026-09-01') => ({ id, d, start: 1, entries: [] })+const httpError = (status, data) => Object.assign(new Error(data?.error || 'HTTP ' + status), { status, data })+const sync = () => JSON.parse(localStorage.getItem('gym_sync'))+const puts = () => api.mock.calls.filter(([, o]) => o?.method === 'PUT').map(([, o]) => JSON.parse(o.body))+const gets = () => api.mock.calls.filter(([, o]) => !o)+const signedIn = (S, extra = {}) => useStore.setState({ S, user: { id: 'user-1' }, ready: true, ...extra })++beforeEach(() => {+ localStorage.clear()+ api.mockReset()+ useStore.setState({ S: clone(DEF), user: null, ready: false })+})+afterEach(() => {+ vi.useRealTimers()+ localStorage.clear()+ useStore.setState({ S: clone(DEF), user: null, ready: false })+})++describe('pull against a revisioned server', () => {+ it('adopts the server copy when only the server moved, and records its revision', async () => {+ const local = { ...clone(DEF), _ts: 100, workouts: [workout('w1')], active: { id: 'running' } }+ signedIn(local)+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ api.mockResolvedValueOnce({ state: { ...clone(DEF), _ts: 200, workouts: [workout('w1'), workout('w2')], _rev: 2 }, rev: 2 })++ await useStore.getState().pullState()++ expect(puts()).toHaveLength(0)+ expect(useStore.getState().S.workouts.map(w => w.id)).toEqual(['w1', 'w2'])+ expect(useStore.getState().S._ts).toBe(200)+ expect(useStore.getState().S.active).toEqual({ id: 'running' })+ expect(sync()).toEqual({ rev: 2, ts: 200 })+ })++ it('does nothing when neither side moved', async () => {+ signedIn({ ...clone(DEF), _ts: 100, workouts: [workout('w1')] })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ api.mockResolvedValueOnce({ state: { ...clone(DEF), _ts: 100, workouts: [workout('w1')], _rev: 1 }, rev: 1 })++ await useStore.getState().pullState()++ expect(api).toHaveBeenCalledTimes(1)+ expect(useStore.getState().S.workouts.map(w => w.id)).toEqual(['w1'])+ })++ it('pushes when only this device changed', async () => {+ signedIn({ ...clone(DEF), _ts: 150, workouts: [workout('w1')], restSec: 75 })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ api.mockResolvedValueOnce({ state: { ...clone(DEF), _ts: 100, workouts: [workout('w1')], _rev: 1 }, rev: 1 })+ api.mockResolvedValueOnce({ ok: true, rev: 2 })++ await useStore.getState().pullState()++ expect(puts()).toHaveLength(1)+ expect(puts()[0].baseRev).toBe(1)+ expect(puts()[0].state.restSec).toBe(75)+ expect(sync()).toEqual({ rev: 2, ts: 150 })+ })++ // The report: desktop adopted rev 1, the phone logged a workout (rev 2), the desktop changed a+ // setting. One PUT, against rev 2, carrying both.+ it('merges and pushes once against the server revision when both sides changed', async () => {+ signedIn({ ...clone(DEF), _ts: 300, workouts: [workout('w1')], restSec: 75 })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ api.mockResolvedValueOnce({ state: { ...clone(DEF), _ts: 200, workouts: [workout('w1'), workout('from-phone', '2026-09-02')], _rev: 2 }, rev: 2 })+ api.mockResolvedValueOnce({ ok: true, rev: 3 })++ await useStore.getState().pullState()++ expect(gets()).toHaveLength(1)+ expect(puts()).toHaveLength(1)+ expect(puts()[0].baseRev).toBe(2)+ expect(puts()[0].state.workouts.map(w => w.id)).toEqual(['w1', 'from-phone'])+ expect(puts()[0].state.restSec).toBe(75)+ expect(useStore.getState().S.workouts.map(w => w.id)).toEqual(['w1', 'from-phone'])+ expect(sync().rev).toBe(3)+ expect(sync().ts).toBe(useStore.getState().S._ts)+ expect(localStorage.getItem('gym_dirty')).toBeNull()+ })++ it('a first pull with a newer server copy adopts it and starts the marker', async () => {+ signedIn(clone(DEF))+ api.mockResolvedValueOnce({ state: { ...clone(DEF), _ts: 50, routines: [routine('r')], _rev: 5 }, rev: 5 })++ await useStore.getState().pullState()++ expect(puts()).toHaveLength(0)+ expect(useStore.getState().S.routines.map(r => r.id)).toEqual(['r'])+ expect(sync()).toEqual({ rev: 5, ts: 50 })+ })++ it('a first pull with a newer local copy pushes it against the server revision', async () => {+ signedIn({ ...clone(DEF), _ts: 500, routines: [routine('local')] })+ api.mockResolvedValueOnce({ state: { ...clone(DEF), _ts: 50, routines: [routine('remote')], _rev: 5 }, rev: 5 })+ api.mockResolvedValueOnce({ ok: true, rev: 6 })++ await useStore.getState().pullState()++ expect(puts()).toHaveLength(1)+ expect(puts()[0].baseRev).toBe(5)+ expect(sync()).toEqual({ rev: 6, ts: 500 })+ })++ it('a 401 on pull leaves the copy, the marker and the user alone', async () => {+ signedIn({ ...clone(DEF), _ts: 100, workouts: [workout('w1')] })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ api.mockRejectedValueOnce(httpError(401, { error: 'not signed in' }))++ await useStore.getState().pullState()++ expect(useStore.getState().user).toEqual({ id: 'user-1' })+ expect(useStore.getState().S.workouts.map(w => w.id)).toEqual(['w1'])+ expect(sync()).toEqual({ rev: 1, ts: 100 })+ expect(localStorage.getItem('gym_dirty')).toBeNull()+ })+})++describe('push against a revisioned server', () => {+ it('sends the marker revision as baseRev and records the one it gets back', async () => {+ signedIn({ ...clone(DEF), _ts: 120, routines: [routine('r')] })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 4, ts: 100 }))+ api.mockResolvedValueOnce({ ok: true, rev: 5 })++ await useStore.getState().pushState()++ expect(puts()[0].baseRev).toBe(4)+ expect(sync()).toEqual({ rev: 5, ts: 120 })+ })++ it('a 409 merges the server copy it carries and pushes again against that revision', async () => {+ signedIn({ ...clone(DEF), _ts: 300, workouts: [workout('w1')], restSec: 75 })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ api.mockRejectedValueOnce(httpError(409, { error: 'conflict', rev: 2, state: { ...clone(DEF), _ts: 200, workouts: [workout('w1'), workout('w2')], _rev: 2 } }))+ api.mockResolvedValueOnce({ ok: true, rev: 3 })++ await useStore.getState().pushState()++ expect(puts()).toHaveLength(2)+ expect(puts()[0].baseRev).toBe(1)+ expect(puts()[1].baseRev).toBe(2)+ expect(puts()[1].state.workouts.map(w => w.id)).toEqual(['w1', 'w2'])+ expect(puts()[1].state.restSec).toBe(75)+ expect(useStore.getState().S.workouts.map(w => w.id)).toEqual(['w1', 'w2'])+ expect(sync().rev).toBe(3)+ expect(localStorage.getItem('gym_dirty')).toBeNull()+ })++ it('gives up after two conflicts in a row and leaves the copy dirty for the next pull', async () => {+ signedIn({ ...clone(DEF), _ts: 300, workouts: [workout('w1')] })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ const conflict = rev => httpError(409, { error: 'conflict', rev, state: { ...clone(DEF), _ts: 200, workouts: [workout('w' + rev)], _rev: rev } })+ api.mockRejectedValueOnce(conflict(2)).mockRejectedValueOnce(conflict(3)).mockRejectedValueOnce(conflict(4))++ await useStore.getState().pushState()++ expect(puts()).toHaveLength(3)+ expect(localStorage.getItem('gym_dirty')).toBe('1')+ expect(useStore.getState().S.workouts.map(w => w.id).sort()).toEqual(['w1', 'w2', 'w3'])+ })++ it('a replace meant for the server goes without a baseRev, the change after it with one', async () => {+ vi.useFakeTimers()+ signedIn({ ...clone(DEF), _ts: 100, routines: [routine('old')] })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 4, ts: 100 }))+ api.mockResolvedValueOnce({ ok: true, rev: 5 }).mockResolvedValueOnce({ ok: true, rev: 6 })++ useStore.getState().replaceState({ ...clone(DEF), routines: [routine('imported')] }, true)+ await vi.advanceTimersByTimeAsync(2000)+ expect(puts()).toHaveLength(1)+ expect('baseRev' in puts()[0]).toBe(false)+ expect(sync().rev).toBe(5)++ useStore.getState().update(s => { s.restSec = 45 })+ await vi.advanceTimersByTimeAsync(2000)+ expect(puts()).toHaveLength(2)+ expect(puts()[1].baseRev).toBe(5)+ })++ it('a push asked for during a push runs once after it, and the caller waits for it', async () => {+ signedIn({ ...clone(DEF), _ts: 100, routines: [routine('r')] })+ let release+ api.mockImplementationOnce(() => new Promise(r => { release = () => r({ ok: true, rev: 1 }) }))+ api.mockResolvedValue({ ok: true, rev: 2 })++ const first = useStore.getState().pushState()+ useStore.getState().update(s => { s.restSec = 30 }, false)+ const second = useStore.getState().pushState()+ const third = useStore.getState().pushState()+ expect(puts()).toHaveLength(1)+ release()+ await Promise.all([first, second, third])++ expect(puts()).toHaveLength(2)+ expect(puts()[1].state.restSec).toBe(30)+ expect(sync().rev).toBe(2)+ })++ it('a server without revisions drops the marker', async () => {+ signedIn({ ...clone(DEF), _ts: 100, routines: [routine('r')] })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 4, ts: 100 }))+ api.mockResolvedValueOnce({ ok: true })++ await useStore.getState().pushState()++ expect(localStorage.getItem('gym_sync')).toBeNull()+ })+})++describe('ordering', () => {+ it('a change made before boot is through does not push until it is', async () => {+ vi.useFakeTimers()+ useStore.setState({ S: clone(DEF), user: { id: 'user-1' }, ready: false })+ api.mockResolvedValue({ ok: true, rev: 1 })++ useStore.getState().update(s => { s.restSec = 30 })+ await vi.advanceTimersByTimeAsync(5000)+ expect(puts()).toHaveLength(0)++ // what boot does last, on every path+ useStore.setState({ ready: true })+ useStore.getState().update(s => { s.restSec = 45 })+ await vi.advanceTimersByTimeAsync(2000)+ expect(puts()).toHaveLength(1)+ expect(puts()[0].state.restSec).toBe(45)+ })++ // The change lands while the server copy is still on its way: it is merged into that copy+ // rather than overwritten by it, and the merge is what boot pushes.+ it('boot keeps a change made during its pull and pushes the merge', async () => {+ vi.useFakeTimers()+ useStore.setState({ S: clone(DEF), user: { id: 'user-1' }, ready: false })+ localStorage.setItem('gym_user', JSON.stringify({ id: 'user-1' }))+ api.mockImplementation(async (path, opts) => {+ if (path === '/api/config') return { allow_guest: true }+ if (path === '/api/me') return { user: { id: 'user-1', name: 'One' } }+ if (path === '/api/data' && !opts) {+ useStore.getState().update(s => { s.restSec = 30 }) // a change while the pull is in flight+ return { state: { ...clone(DEF), _ts: 10, routines: [routine('r')], _rev: 1 }, rev: 1 }+ }+ return { ok: true, rev: 2 }+ })++ const boot = useStore.getState().boot()+ await vi.advanceTimersByTimeAsync(10)+ await boot+ await vi.advanceTimersByTimeAsync(2000)++ expect(puts()).toHaveLength(1)+ expect(puts()[0].baseRev).toBe(1)+ expect(puts()[0].state.restSec).toBe(30)+ expect(puts()[0].state.routines.map(r => r.id)).toEqual(['r'])+ expect(useStore.getState().S.restSec).toBe(30)+ expect(useStore.getState().S.routines.map(r => r.id)).toEqual(['r'])+ expect(useStore.getState().ready).toBe(true)+ })++ it('a pull sends a push still waiting in the debounce first', async () => {+ vi.useFakeTimers()+ signedIn({ ...clone(DEF), _ts: 100, routines: [routine('r')] })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ api.mockImplementation(async (path, opts) => opts ? { ok: true, rev: 2 } : { state: { ...clone(DEF), _ts: 100, routines: [routine('r')], _rev: 2 }, rev: 2 })++ useStore.getState().update(s => { s.restSec = 30 }) // arms the 1.5 s push+ const pull = useStore.getState().pullState()+ await vi.advanceTimersByTimeAsync(10)+ await pull++ expect(api.mock.calls[0][1]?.method).toBe('PUT')+ expect(api.mock.calls[1][1]).toBeUndefined()+ expect(puts()).toHaveLength(1)+ expect(sync().rev).toBe(2)+ })++ it('coming back to the tab pulls, not twice within 15 s, and going online always does', async () => {+ vi.useFakeTimers()+ signedIn({ ...clone(DEF), _ts: 100, routines: [routine('r')] })+ localStorage.setItem('gym_sync', JSON.stringify({ rev: 1, ts: 100 }))+ api.mockResolvedValue({ state: { ...clone(DEF), _ts: 100, routines: [routine('r')], _rev: 1 }, rev: 1 })+ const visible = () => {+ Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'visible' })+ document.dispatchEvent(new Event('visibilitychange'))+ }++ await vi.advanceTimersByTimeAsync(16000) // clear of any pull an earlier test made+ visible()+ await vi.advanceTimersByTimeAsync(10)+ expect(gets()).toHaveLength(1)++ window.dispatchEvent(new Event('focus'))+ visible()+ await vi.advanceTimersByTimeAsync(10)+ expect(gets()).toHaveLength(1)++ window.dispatchEvent(new Event('online'))+ await vi.advanceTimersByTimeAsync(10)+ expect(gets()).toHaveLength(2)++ await vi.advanceTimersByTimeAsync(16000)+ window.dispatchEvent(new Event('focus'))+ await vi.advanceTimersByTimeAsync(10)+ expect(gets()).toHaveLength(3)++ useStore.setState({ user: null })+ await vi.advanceTimersByTimeAsync(16000)+ window.dispatchEvent(new Event('focus'))+ await vi.advanceTimersByTimeAsync(10)+ expect(gets()).toHaveLength(3)+ })+})