@indaco/garmin-personal-mcp 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import process$1 from "node:process";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync } from "node:fs";
 import { copyFile, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
-import { appendFileSync, mkdirSync, readFileSync, renameSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, dirname, join, resolve } from "node:path";
 import { randomBytes } from "node:crypto";
 import { createRequire } from "module";
 // node_modules/.pnpm/@modelcontextprotocol+server@2.4.0/node_modules/@modelcontextprotocol/server/dist/chunk-vYduTEsO.mjs
@@ -3297,7 +3298,7 @@ const error = () => {
 		}
 	};
 };
-function en_default() {
+function en_default$1() {
 	return { localeError: error() };
 }
 // node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/registries.js
@@ -5026,7 +5027,7 @@ const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
 const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 // node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/schemas.js
 function _ensureDefaultLocale() {
-	if (!globalConfig.localeError) config(en_default());
+	if (!globalConfig.localeError) config(en_default$1());
 }
 function _ensureDefaultMemoizer() {
 	if (!globalConfig.memoizer) config({ memoizer: memoizer() });
@@ -24093,17 +24094,9 @@ function serveStdio(factory, options = {}) {
 function toError(value) {
 	return value instanceof Error ? value : new Error(String(value));
 }
-// src/config.ts
-/** Defaults reuse an existing ~/.config/garmin-mcp/api-key and ~/workspace/garmin-data. */
-function loadConfig(env = process.env) {
-	return {
-		baseUrl: env.GARMIN_BASE_URL || "https://personal.connectapi.garmin.com",
-		apiKeyFile: env.GARMIN_API_KEY_FILE || join(homedir(), ".config/garmin-mcp/api-key"),
-		dataDir: env.GARMIN_DATA_DIR || join(homedir(), "workspace/garmin-data")
-	};
-}
 // package.json
-var version = "0.1.1";
+var name = "@indaco/garmin-personal-mcp";
+var version = "0.3.0";
 // src/log.ts
 /** Past this size the log moves to `<file>.1`, replacing the one before, and a new log starts. */
 const MAX_BYTES = 1e6;
@@ -59005,13 +58998,13 @@ function round(v, decimals) {
 	const f = 10 ** decimals;
 	return Math.round(v * f) / f;
 }
-const pad = (n) => String(n).padStart(2, "0");
+const pad$1 = (n) => String(n).padStart(2, "0");
 function hms(seconds) {
 	const s = Math.round(seconds);
 	const h = Math.floor(s / 3600);
 	const m = Math.floor(s % 3600 / 60);
 	const sec = s % 60;
-	return h > 0 ? `${h}:${pad(m)}:${pad(sec)}` : `${m}:${pad(sec)}`;
+	return h > 0 ? `${h}:${pad$1(m)}:${pad$1(sec)}` : `${m}:${pad$1(sec)}`;
 }
 // src/tools.ts
 const DAY_MS = 864e5;
@@ -59029,7 +59022,8 @@ var GarminTools = class {
 		this.api = api;
 		this.dataDir = dataDir;
 	}
-	async listActivities(startDate, endDate, activityType, limit, raw) {
+	async listActivities(startDate, endDate, activityType, limit, raw, names) {
+		const wanted = names?.map((n) => n.toLowerCase()).filter(Boolean) ?? [];
 		const asked = limit == null || limit <= 0 ? 20 : Math.min(limit, 200);
 		const search = (max, type, subType) => this.api.getJson("/activitylist-service/activities/search/activities", {
 			start: "0",
@@ -59040,14 +59034,15 @@ var GarminTools = class {
 			activitySubType: subType
 		});
 		const refused = (e) => activityType !== void 0 && e instanceof GarminApiError && /-> HTTP 400\b/.test(e.message);
+		const max = wanted.length > 0 ? 200 : asked;
 		let json;
 		let local = false;
 		try {
-			json = await search(asked, activityType);
+			json = await search(max, activityType);
 		} catch (e) {
 			if (!refused(e)) throw e;
 			try {
-				json = await search(asked, void 0, activityType);
+				json = await search(max, void 0, activityType);
 				log("INFO", `activityType ${activityType} refused, asked as activitySubType`);
 			} catch (e2) {
 				if (!refused(e2)) throw e2;
@@ -59058,12 +59053,20 @@ var GarminTools = class {
 		}
 		const list = Array.isArray(json) ? json : firstArray(json);
 		if (!list) return JSON.stringify(json);
-		const rows = local ? list.filter((a) => field$1(isObject$3(a) ? a.activityType : void 0, "typeKey") === activityType).slice(0, asked) : list;
-		return JSON.stringify(raw === true ? local ? rows : json : rows.map((a) => summarize(isObject$3(a) ? a : {})));
+		const named = (a) => {
+			const name = isObject$3(a) ? a.activityName : void 0;
+			return typeof name === "string" && wanted.some((n) => name.toLowerCase().includes(n));
+		};
+		const filtered = local || wanted.length > 0;
+		const rows = filtered ? list.filter((a) => (!local || field$2(isObject$3(a) ? a.activityType : void 0, "typeKey") === activityType) && (wanted.length === 0 || named(a))).slice(0, asked) : list;
+		return JSON.stringify(raw === true ? filtered ? rows : json : rows.map((a) => summarize(isObject$3(a) ? a : {})));
 	}
 	async getActivity(activityId) {
 		return JSON.stringify(await this.api.getJson(`/activity-service/activity/${activityId}`, {}));
 	}
+	async getActivityWorkouts(activityId) {
+		return JSON.stringify(await this.api.getJson(`/activity-service/activity/${activityId}/workouts`, {}), (_, v) => v === null ? void 0 : v);
+	}
 	async downloadActivityFit(activityId) {
 		const fit = await this.fetchFit(activityId);
 		return JSON.stringify({
@@ -59094,6 +59097,17 @@ var GarminTools = class {
 			endDate: toDate
 		}));
 	}
+	async getWeight(fromDate, toDate, includeAll) {
+		checkRange(fromDate, toDate, Infinity);
+		return JSON.stringify(await this.api.getJson(`/weight-service/weight/range/${fromDate}/${toDate}`, { includeAll: includeAll === true ? "true" : void 0 }));
+	}
+	async getBodyBattery(fromDate, toDate) {
+		checkRange(fromDate, toDate);
+		return JSON.stringify(await this.api.getJson("/wellness-service/wellness/bodyBattery/reports/daily", {
+			startDate: fromDate,
+			endDate: toDate
+		}));
+	}
 	async getHeartRateZones() {
 		return JSON.stringify(await this.api.getJson("/biometric-service/heartRateZones/v2", {}));
 	}
@@ -59168,7 +59182,7 @@ function summarize(a) {
 	const o = {};
 	copy$1(a, o, "activityId", "id");
 	copy$1(a, o, "activityName", "name");
-	const typeKey = asString$1(field$1(a.activityType, "typeKey"));
+	const typeKey = asString$1(field$2(a.activityType, "typeKey"));
 	if (typeKey !== null) o.type = typeKey;
 	const sport = Number.isInteger(a.sportTypeId) ? SPORTS[a.sportTypeId] : void 0;
 	if (sport !== void 0) o.sport = sport;
@@ -59184,7 +59198,7 @@ function summarize(a) {
 	copy$1(a, o, "elevationGain", "ascentM");
 	const elapsedS = asDouble(a.duration, 0);
 	if (elapsedS - durS >= 60) o.elapsed = hms(elapsedS);
-	if (asString$1(field$1(a.eventType, "typeKey")) === "race") o.race = true;
+	if (asString$1(field$2(a.eventType, "typeKey")) === "race") o.race = true;
 	putRounded(a, o, "activityTrainingLoad", "trainingLoad", 1);
 	putRounded(a, o, "aerobicTrainingEffect", "aerobicTE", 1);
 	putRounded(a, o, "anaerobicTrainingEffect", "anaerobicTE", 1);
@@ -59228,13 +59242,13 @@ function summarize(a) {
 	}
 	if (Object.keys(best).length > 0) o.best = best;
 	for (const split of Array.isArray(a.splitSummaries) ? a.splitSummaries : []) {
-		const type = asString$1(field$1(split, "splitType")) ?? "";
-		const speed = asDouble(field$1(split, "averageSpeed"), 0);
+		const type = asString$1(field$2(split, "splitType")) ?? "";
+		const speed = asDouble(field$2(split, "averageSpeed"), 0);
 		if (type === "RWD_RUN" && speed > 0) {
 			const runWalk = o.runWalk ??= {};
 			runWalk.runPace = `${hms(1e3 / speed)}/km`;
-			runWalk.runKm = round(asDouble(field$1(split, "distance"), 0) / 1e3, 2);
-		} else if (type === "RWD_WALK") (o.runWalk ??= {}).walkTime = hms(asDouble(field$1(split, "duration"), 0));
+			runWalk.runKm = round(asDouble(field$2(split, "distance"), 0) / 1e3, 2);
+		} else if (type === "RWD_WALK") (o.runWalk ??= {}).walkTime = hms(asDouble(field$2(split, "duration"), 0));
 	}
 	return o;
 }
@@ -59274,7 +59288,7 @@ function copy$1(from, to, name, as) {
 function isObject$3(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function field$1(v, name) {
+function field$2(v, name) {
 	return isObject$3(v) ? v[name] : void 0;
 }
 /** A number, or text holding one (spaces around it allowed); the default otherwise (null too). */
@@ -59294,11 +59308,11 @@ function isDate(d) {
 	const t = Date.parse(`${d}T00:00:00Z`);
 	return /^\d{4}-\d{2}-\d{2}$/.test(d) && !Number.isNaN(t) && new Date(t).toISOString().startsWith(d);
 }
-/** Throws unless from and to are real yyyy-MM-dd dates, from <= to, and the range has at most RANGE_DAYS days. */
-function checkRange(from, to) {
+/** Throws unless from and to are real yyyy-MM-dd dates, from <= to, and the range has at most maxDays days. */
+function checkRange(from, to, maxDays = RANGE_DAYS) {
 	if (!isDate(from) || !isDate(to) || from > to) throw new Error("fromDate and toDate must be real dates yyyy-MM-dd with fromDate <= toDate");
 	const days = (Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / 864e5 + 1;
-	if (days > RANGE_DAYS) throw new Error(`A range has at most ${RANGE_DAYS} days; this one has ${days}. Ask for it in parts.`);
+	if (days > maxDays) throw new Error(`A range has at most ${maxDays} days; this one has ${days}. Ask for it in parts.`);
 }
 /** A tool call for one date or for a range: `date` alone, or `fromDate` and `toDate` without it. */
 function dayOrRange(a, day, range) {
@@ -59317,7 +59331,7 @@ const text = (s) => ({ content: [{
 	type: "text",
 	text: s
 }] });
-/** Registers the 12 tools. */
+/** Registers the 15 tools. */
 function registerTools(server, tools) {
 	server.registerTool("listActivities", {
 		description: [
@@ -59335,13 +59349,26 @@ function registerTools(server, tools) {
 			endDate: string().describe("End date yyyy-MM-dd (optional)").optional(),
 			activityType: string().describe("Activity type key (optional): a parent type such as running or cycling, or a subtype such as trail_running").optional(),
 			limit: number$1().int().describe("Max number of activities, default 20").optional(),
-			raw: boolean().describe("Return Garmin's raw JSON instead of the summary").optional()
+			raw: boolean().describe("Return Garmin's raw JSON instead of the summary").optional(),
+			names: array(string()).describe("Activity names (optional): keep only the activities whose name contains one of them, ignoring case").optional()
 		})
-	}, async (a) => text(await tools.listActivities(a.startDate, a.endDate, a.activityType, a.limit, a.raw)));
+	}, async (a) => text(await tools.listActivities(a.startDate, a.endDate, a.activityType, a.limit, a.raw, a.names)));
 	server.registerTool("getActivity", {
 		description: "Get the full detail of one activity (summary, metadata, splits/laps) as JSON.",
 		inputSchema: object({ activityId })
 	}, async (a) => text(await tools.getActivity(a.activityId)));
+	server.registerTool("getActivityWorkouts", {
+		description: [
+			"The planned workout that an activity followed, as created in Garmin Connect: its steps in",
+			"order, each with its intensity (warmup/active/rest/recovery/cooldown), its duration (time in",
+			"seconds, reps, or open), its target (cadence, heart rate, pace, or open, with low and high",
+			"values), the exercise for strength steps, and the coach's notes. A step with durationType",
+			"REPEAT_UNTIL_STEPS_CMPLT repeats the steps from stepIndex durationValue up to it, targetValue",
+			"times in all. Compare it with getActivitySets or getActivityLaps for plan against done.",
+			"An empty list means the activity followed no planned workout. Null fields are left out."
+		].join("\n"),
+		inputSchema: object({ activityId })
+	}, async (a) => text(await tools.getActivityWorkouts(a.activityId)));
 	server.registerTool("downloadActivityFit", {
 		description: ["Download the ORIGINAL .FIT file of an activity and save it on the user's computer.", "Returns the absolute path of the saved .fit file (second-by-second HR, cadence, speed, laps)."].join("\n"),
 		inputSchema: object({ activityId })
@@ -59383,6 +59410,30 @@ function registerTools(server, tools) {
 		description: "Sleep data for one night (date: the morning you woke up), or for up to 14 nights (fromDate and toDate), yyyy-MM-dd.",
 		inputSchema: dayOrRangeInput
 	}, async (a) => text(await dayOrRange(a, (d) => tools.getSleep(d), (f, t) => tools.getSleepRange(f, t))));
+	server.registerTool("getWeight", {
+		description: [
+			"Weight for a date range, yyyy-MM-dd: the latest weight of each day (with body fat, muscle",
+			"and bone mass, BMI and body water when a scale records them), the average of the range, and",
+			"the last weight before and the first after the range. Set includeAll=true for every entry",
+			"of each day. Weight, muscle mass and bone mass are in grams."
+		].join("\n"),
+		inputSchema: object({
+			fromDate: string().describe("From date yyyy-MM-dd"),
+			toDate: string().describe("To date yyyy-MM-dd"),
+			includeAll: boolean().describe("Every weight entry of each day, not only the latest").optional()
+		})
+	}, async (a) => text(await tools.getWeight(a.fromDate, a.toDate, a.includeAll)));
+	server.registerTool("getBodyBattery", {
+		description: [
+			"Body Battery for up to 14 days, yyyy-MM-dd: for each day how much it charged and drained,",
+			"its readings through the day, and the events that changed it (sleep, activities, stress,",
+			"naps) with their impact."
+		].join("\n"),
+		inputSchema: object({
+			fromDate: string().describe("From date yyyy-MM-dd"),
+			toDate: string().describe("To date yyyy-MM-dd")
+		})
+	}, async (a) => text(await tools.getBodyBattery(a.fromDate, a.toDate)));
 	server.registerTool("getHeartRateZones", {
 		description: "Heart rate zones currently configured in Garmin Connect.",
 		inputSchema: object({})
@@ -59456,7 +59507,13 @@ var GarminDashboard = class {
 		await this.#syncRecovery(cache, addDays(today, -13), today, sync);
 		cache.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
 		await writeAtomically(this.#file(), JSON.stringify(cache));
-		const [zones, fitnessAge] = await Promise.all([optional(sync, "zones", () => this.tools.getHeartRateZones()), optional(sync, "fitnessAge", () => this.tools.getFitnessAge(today))]);
+		const [zones, fitnessAge, settings] = await Promise.all([
+			optional(sync, "zones", () => this.tools.getHeartRateZones()),
+			optional(sync, "fitnessAge", () => this.tools.getFitnessAge(today)),
+			optional(sync, "units", () => this.api.getJson("/userprofile-service/userprofile/settings"))
+		]);
+		const units = isObject$2(settings) ? settings.measurementSystem : void 0;
+		const locale = isObject$2(settings) ? String(settings.preferredLocale).replace("_", "-") : "";
 		const out = {
 			generated: today,
 			weeks: w,
@@ -59465,7 +59522,9 @@ var GarminDashboard = class {
 			prevStart,
 			prevEnd: addDays(start, -1),
 			zones,
-			fitnessAge
+			fitnessAge,
+			...typeof units === "string" && UNITS.includes(units) ? { units } : {},
+			.../^[a-z]{2,3}(-[A-Z]{2})?$/.test(locale) ? { locale } : {}
 		};
 		const activities = activitiesBetween(cache, start, today).map((a) => structuredClone(a));
 		await this.#attachDetails(activities);
@@ -59530,16 +59589,16 @@ var GarminDashboard = class {
 				failed = true;
 				continue;
 			}
-			const summaries = field(json, "hrvSummaries");
+			const summaries = field$1(json, "hrvSummaries");
 			for (const h of Array.isArray(summaries) ? summaries : []) {
-				const day = date(field(h, "calendarDate"));
+				const day = date(field$1(h, "calendarDate"));
 				if (day === void 0) continue;
 				const o = { date: day };
 				copy(h, o, "lastNightAvg", "hrv");
 				copy(h, o, "weeklyAvg", "weeklyAvg");
 				copy(h, o, "status", "status");
-				copy(field(h, "baseline"), o, "balancedLow", "low");
-				copy(field(h, "baseline"), o, "balancedUpper", "high");
+				copy(field$1(h, "baseline"), o, "balancedLow", "low");
+				copy(field$1(h, "baseline"), o, "balancedUpper", "high");
 				byDate[day] = o;
 			}
 		}
@@ -59633,10 +59692,10 @@ function recoveryRow(day, sleep, summary) {
 	hours(sleep, r, "lightSleepSeconds", "light");
 	hours(sleep, r, "remSleepSeconds", "rem");
 	hours(sleep, r, "awakeSleepSeconds", "awake");
-	copy(field(field(sleep, "sleepScores"), "overall"), r, "value", "sleepScore");
-	const need = field(field(sleep, "sleepNeed"), "actual");
+	copy(field$1(field$1(sleep, "sleepScores"), "overall"), r, "value", "sleepScore");
+	const need = field$1(field$1(sleep, "sleepNeed"), "actual");
 	if (typeof need === "number") r.needH = round2(need / 60);
-	const bed = field(sleep, "sleepStartTimestampLocal");
+	const bed = field$1(sleep, "sleepStartTimestampLocal");
 	if (typeof bed === "number") {
 		const t = new Date(Math.trunc(bed));
 		r.bedMin = t.getUTCHours() * 60 + t.getUTCMinutes();
@@ -59647,7 +59706,7 @@ function recoveryRow(day, sleep, summary) {
 	copy(summary, r, "averageStressLevel", "stress");
 	copy(summary, r, "totalSteps", "steps");
 	copy(summary, r, "dailyStepGoal", "stepGoal");
-	const floors = field(summary, "floorsAscended");
+	const floors = field$1(summary, "floorsAscended");
 	if (typeof floors === "number") r.floors = Math.round(floors);
 	return r;
 }
@@ -59708,7 +59767,7 @@ function setCovered(cache, fromField, toField, [from, to]) {
 	cache[toField] = to;
 }
 function dayOf$1(a) {
-	const s = field(a, "start");
+	const s = field$1(a, "start");
 	return typeof s === "string" && s.length >= 10 ? date(s.slice(0, 10)) : void 0;
 }
 /** A yyyy-MM-dd date; undefined when missing or not a real date, so the range is fetched again. */
@@ -59718,11 +59777,11 @@ function date(v) {
 	return !Number.isNaN(t) && new Date(t).toISOString().startsWith(v) ? v : void 0;
 }
 function copy(from, to, name, as) {
-	const v = field(from, name);
+	const v = field$1(from, name);
 	if (v !== void 0 && v !== null) to[as] = v;
 }
 function hours(from, to, name, as) {
-	const v = field(from, name);
+	const v = field$1(from, name);
 	if (typeof v === "number") to[as] = round2(v / 3600);
 }
 function round2(v) {
@@ -59731,7 +59790,7 @@ function round2(v) {
 function isObject$2(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function field(v, name) {
+function field$1(v, name) {
 	return isObject$2(v) ? v[name] : void 0;
 }
 /** Text, or a number as text; "" for anything else. */
@@ -59743,6 +59802,12 @@ function asLong(v) {
 	if (typeof v === "number") return Math.trunc(v);
 	return typeof v === "string" && /^[+-]?\d+$/.test(v) ? Number(v) : 0;
 }
+/** The measurement systems of a Garmin profile. */
+const UNITS = [
+	"metric",
+	"statute_us",
+	"statute_uk"
+];
 /** Registers getDashboardData. */
 function registerDashboard(server, dashboard) {
 	server.registerTool("getDashboardData", {
@@ -59750,8 +59815,11 @@ function registerDashboard(server, dashboard) {
 			"All the data of the training dashboard in one call: HR zones, fitness age, the activities of the",
 			"last `weeks` weeks (compact summaries, with strength sets and laps where they apply), the activities",
 			"of the weeks before for the period comparison, daily HRV, and the last 14 days of sleep and daily",
-			"summaries. Keeps a local cache and fetches from Garmin only what is new since the last call, so a",
-			"rebuild or an update needs few calls. `sync` in the result says what was fetched."
+			"summaries, and `units`: the measurement system of the Garmin profile (metric, statute_us or",
+			"statute_uk) that the page shows; the data itself is always metric; `locale`: the language of",
+			"the Garmin profile, e.g. it or pt-BR. Keeps a local cache and",
+			"fetches from Garmin only what is new since the last call, so a rebuild or an update needs few",
+			"calls. `sync` in the result says what was fetched."
 		].join("\n"),
 		inputSchema: object({ weeks: number$1().int().describe("Weeks to cover, default 12, max 52").optional() })
 	}, async (a) => ({ content: [{
@@ -60266,452 +60334,2275 @@ const ABOUT = {
 * The built-in languages besides English. The page script does not hold them: the server writes the
 * languages that the page's settings choose into its languages block, so the file has no other texts.
 */
-const BUILT_IN = { it: {
-	title: "Allenamento + Recupero",
-	headline: "Carico di allenamento, recupero e progressi da Garmin Connect",
-	na: "n/d",
-	noData: "Questa pagina non ha ancora dati. Chiedi al tuo assistente di scrivere la dashboard.",
-	period: "dal {from} al {to}",
-	inProgress: "* settimana in corso",
-	"menu.settings": "Impostazioni",
-	"menu.theme": "Tema",
-	"footer.updated": "Dati da Garmin Connect, aggiornati il {date}",
-	"footer.failed": "Giorni non letti da Garmin: {n} (i loro valori mostrano n/d)",
-	"footer.license": "Licenza MIT",
-	"menu.language": "Lingua",
-	"lang.auto": "Automatica",
-	"themeGroup.auto": "Automatico",
-	"themeGroup.dark": "Scuri",
-	"themeGroup.light": "Chiari",
-	"themeGroup.accessible": "Accessibili",
-	"theme.system": "Sistema",
-	"theme.midnight": "Mezzanotte",
-	"theme.graphite": "Grafite",
-	"theme.ocean": "Oceano",
-	"theme.forest": "Foresta",
-	"theme.plum": "Prugna",
-	"theme.light": "Chiaro",
-	"theme.paper": "Carta",
-	"theme.mist": "Nebbia",
-	"theme.hcDark": "Alto contrasto scuro",
-	"theme.hcLight": "Alto contrasto chiaro",
-	"window.label": "Settimane",
-	"window.last": "Ultime {n}",
-	"window.all": "Tutte",
-	"window.from": "Dalla settimana",
-	"window.to": "Alla settimana",
-	"type.all": "Tutte",
-	"type.recovery": "Recupero",
-	"type.running": "Corsa",
-	"type.strengthTraining": "Forza",
-	"type.walking": "Camminata",
-	"type.hiking": "Escursionismo",
-	"type.cycling": "Bici",
-	"type.swimming": "Nuoto",
-	"type.racket": "Sport di racchetta",
-	"type.generic": "Altro",
-	"type.transition": "Transizione",
-	"type.fitnessEquipment": "Attrezzi fitness",
-	"type.basketball": "Pallacanestro",
-	"type.soccer": "Calcio",
-	"type.tennis": "Tennis",
-	"type.americanFootball": "Football americano",
-	"type.training": "Allenamento",
-	"type.crossCountrySkiing": "Sci di fondo",
-	"type.alpineSkiing": "Sci alpino",
-	"type.snowboarding": "Snowboard",
-	"type.rowing": "Canottaggio",
-	"type.mountaineering": "Alpinismo",
-	"type.multisport": "Multisport",
-	"type.paddling": "Pagaia",
-	"type.flying": "Volo",
-	"type.eBiking": "E-bike",
-	"type.motorcycling": "Motociclismo",
-	"type.boating": "Nautica",
-	"type.driving": "Guida",
-	"type.golf": "Golf",
-	"type.hangGliding": "Deltaplano",
-	"type.horsebackRiding": "Equitazione",
-	"type.hunting": "Caccia",
-	"type.fishing": "Pesca",
-	"type.inlineSkating": "Pattinaggio in linea",
-	"type.rockClimbing": "Arrampicata",
-	"type.sailing": "Vela",
-	"type.iceSkating": "Pattinaggio su ghiaccio",
-	"type.skyDiving": "Paracadutismo",
-	"type.snowshoeing": "Ciaspolata",
-	"type.snowmobiling": "Motoslitta",
-	"type.standUpPaddleboarding": "Stand up paddle",
-	"type.surfing": "Surf",
-	"type.wakeboarding": "Wakeboard",
-	"type.waterSkiing": "Sci nautico",
-	"type.kayaking": "Kayak",
-	"type.rafting": "Rafting",
-	"type.windsurfing": "Windsurf",
-	"type.kitesurfing": "Kitesurf",
-	"type.tactical": "Tattico",
-	"type.jumpmaster": "Jumpmaster",
-	"type.boxing": "Pugilato",
-	"type.floorClimbing": "Salita di piani",
-	"type.baseball": "Baseball",
-	"type.diving": "Immersione",
-	"type.shooting": "Tiro",
-	"type.winterSport": "Sport invernali",
-	"type.grinding": "Grinding",
-	"type.hiit": "HIIT",
-	"type.videoGaming": "Videogiochi",
-	"type.wheelchairPushWalk": "Passeggiata in carrozzina",
-	"type.wheelchairPushRun": "Corsa in carrozzina",
-	"type.meditation": "Meditazione",
-	"type.paraSport": "Sport paralimpici",
-	"type.discGolf": "Disc golf",
-	"type.teamSport": "Sport di squadra",
-	"type.cricket": "Cricket",
-	"type.rugby": "Rugby",
-	"type.hockey": "Hockey",
-	"type.lacrosse": "Lacrosse",
-	"type.volleyball": "Pallavolo",
-	"type.waterTubing": "Tubing",
-	"type.wakesurfing": "Wakesurf",
-	"type.waterSport": "Sport acquatici",
-	"type.archery": "Tiro con l'arco",
-	"type.mixedMartialArts": "Arti marziali miste",
-	"type.motorSports": "Motorsport",
-	"type.snorkeling": "Snorkeling",
-	"type.dance": "Danza",
-	"type.jumpRope": "Salto della corda",
-	"type.poolApnea": "Apnea in piscina",
-	"type.mobility": "Mobilità",
-	"type.geocaching": "Geocaching",
-	"type.canoeing": "Canoa",
-	"tabs.label": "Tipi di attività",
-	"edit.start": "Modifica layout",
-	"edit.done": "Fine",
-	"edit.add": "Aggiungi widget",
-	"edit.reset": "Ripristina scheda",
-	"edit.discard": "Annulla",
-	"edit.bar": "Modifica layout",
-	"edit.editing": "Modifica · {board}",
-	"edit.unsaved": "Modifiche non salvate",
-	"discard.title": "Annullare le modifiche?",
-	"discard.text": "Il layout torna com'era prima di selezionare Modifica layout, in ogni scheda.",
-	"discard.keep": "Continua a modificare",
-	"discard.confirm": "Annulla le modifiche",
-	"edit.copy": "Copia layout",
-	"edit.hide": "Nascondi {title}",
-	"edit.show": "Mostra {title}",
-	"edit.remove": "Rimuovi {title}",
-	"edit.move": "Sposta {title}",
-	"edit.moveHint": "Trascina per spostare, oppure premi Spazio e poi le frecce",
-	"edit.width": "Larghezza di {title}",
-	"edit.widthValue": "{n} colonne su {cols}",
-	"edit.addHidden": "Aggiungi widget · {n} nascosti",
-	"add.addOne": "Aggiungi {title}",
-	"said.picked": "{title} preso, posizione {n} di {count}. Le frecce lo spostano, Spazio lo rilascia, Esc lo rimette al suo posto.",
-	"said.position": "Posizione {n} di {count}",
-	"said.cancelled": "{title} è di nuovo al suo posto",
-	"said.moved": "{title} spostato in posizione {n} di {count}",
-	"said.width": "{title}: {n} colonne su {cols}",
-	"said.hidden": "{title} nascosto",
-	"said.shown": "{title} visibile",
-	"said.removed": "{title} rimosso",
-	"said.added": "{title} aggiunto",
-	"said.saved": "Layout salvato",
-	"said.unchanged": "Nessuna modifica da salvare",
-	"said.discarded": "Modifiche annullate",
-	"stale.label": "Nuovo layout",
-	"stale.text": "Il tuo assistente ha scritto un nuovo layout per questa dashboard. Il layout che hai fatto in questo browser resta finché non scegli.",
-	"stale.keep": "Tieni il mio",
-	"stale.new": "Usa il nuovo",
-	"stale.used": "Ora usi il nuovo layout",
-	"stale.kept": "Ora usi il tuo layout",
-	"add.title": "Aggiungi un widget",
-	"add.type": "Tipo",
-	"add.add": "Aggiungi",
-	"add.close": "Chiudi",
-	"add.hiddenGroup": "Nascosti in questa scheda",
-	"add.none": "Tutti i widget sono già in questa scheda.",
-	"copy.title": "Copia layout",
-	"copy.hint": "Questo layout è salvato solo in questo browser. Per tenerlo nella pagina, incolla questo testo al tuo assistente e chiedigli di salvare il layout della dashboard.",
-	"copy.copy": "Copia",
-	"copy.copied": "Copiato",
-	"board.empty": "Questa scheda non ha widget.",
-	"board.emptyEdit": "Questa scheda non ha widget: usa “Aggiungi widget” per metterne.",
-	"widget.failed": "Questo widget non funziona: {message}",
-	"widget.unknown": "Widget sconosciuto: {id}",
-	"empty.window": "Nessuna sessione nelle settimane scelte.",
-	"w.coachNotes": "Note del coach",
-	"notes.none": "Nessuna nota.",
-	"notes.disclaimer": "Suggerimenti di allenamento sui dati fino al {date}. Non sono consigli medici.",
-	"w.kpis": "Panoramica",
-	"kpi.totals": "{km} km · {time} · {n} sessione|{km} km · {time} · {n} sessioni",
-	"kpi.distance": "Distanza · ultimi 7 giorni",
-	"kpi.time": "Tempo · ultimi 7 giorni",
-	"kpi.vs4w": "rispetto alla media di 4 settimane",
-	"delta.good": "meglio",
-	"delta.bad": "peggio",
-	"kpi.ratio": "Rapporto di carico 7:28",
-	"kpi.band": "Fascia 0,8-1,3",
-	"kpi.ratioAll": "Usa tutte le attività, anche con un filtro per tipo",
-	"kpi.hrv": "HRV della notte",
-	"kpi.vsBaseline": "rispetto alla media di 7 giorni {v} ms",
-	"w.readiness": "Prontezza di oggi",
-	"ready.easy": "Vai piano",
-	"ready.push": "Pronto a spingere",
-	"ready.normal": "Normale",
-	"ready.hrv": "Stato HRV",
-	"ready.sleep": "Punteggio sonno",
-	"ready.rhr": "FC a riposo",
-	"ready.rhrVs": "7 giorni prima: {avg} bpm",
-	"ready.ratio": "Rapporto di carico 7:28",
-	"ready.note": "Una regola della dashboard, non la prontezza di Garmin. Mostra oggi: la finestra di settimane non la cambia.",
-	"w.fitnessAge": "Età fitness",
-	"fa.age": "Età fitness",
-	"fa.actual": "Età reale",
-	"fa.achievable": "Raggiungibile",
-	"fa.details": "Dettagli",
-	"fa.component": "Componente",
-	"fa.value": "Ora",
-	"fa.target": "Obiettivo Garmin",
-	"fa.potential": "Età possibile",
-	"fa.bodyFat": "Grasso corporeo %",
-	"fa.bmi": "IMC",
-	"fa.rhr": "FC a riposo",
-	"fa.vigorousDaysAvg": "Giorni intensi / settimana",
-	"fa.vigorousMinutesAvg": "Minuti intensi / settimana",
-	"today.note": "Mostra oggi: la finestra di settimane non la cambia.",
-	"w.periodComparison": "Confronto tra periodi",
-	"pc.vs": "dal {from} al {to} rispetto a dal {pfrom} al {pto}",
-	"pc.partial": "parziale: queste settimane iniziano prima dei dati",
-	"pc.type": "Tipo",
-	"pc.sessions": "Sessioni",
-	"pc.distance": "Distanza",
-	"pc.time": "Tempo",
-	"pc.load": "Carico",
-	"pc.total": "Totale",
-	"w.records": "Record",
-	"rec.best": "{d} più veloce",
-	"d.1k": "1 km",
-	"d.mile": "miglio",
-	"d.5k": "5 km",
-	"d.10k": "10 km",
-	"d.half": "mezza maratona",
-	"d.marathon": "maratona",
-	"rec.longestRun": "Corsa più lunga",
-	"rec.longestRide": "Uscita in bici più lunga",
-	"rec.topSet": "Serie più pesante",
-	"rec.e1rm": "Miglior 1RM stimato · {name}",
-	"rec.none": "Nessun record nelle settimane scelte.",
-	"rec.estimate": "I valori 1RM sono stime (Epley, serie da 1-12 ripetizioni).",
-	"w.weeklyVolume": "Volume settimanale",
-	"m.time": "Tempo",
-	"m.distance": "Distanza",
-	"m.sessions": "Sessioni",
-	"m.load": "Carico",
-	"vol.avg": "Media di 4 settimane",
-	"w.intensityMinutes": "Minuti di intensità",
-	"im.guide": "Linea guida 150 min",
-	"im.note": "Minuti moderati + 2 x intensi delle sole attività, non di tutta la giornata.",
-	"w.loadSafety": "Sicurezza del carico",
-	"ls.weekLoad": "Carico · ultimi 7 giorni",
-	"ls.monotony": "Monotonia · 7 giorni",
-	"ls.monotonyFlag": "Sopra 2,0",
-	"ls.strain": "Strain · 7 giorni",
-	"ls.flagged": "Settimane sopra +10%",
-	"ls.load": "Carico settimanale",
-	"ls.ramp": "Variazione sulla settimana prima (%)",
-	"ls.note": "Tutte le attività. Le settimane rosse sono salite più del 10%; una settimana in corso non viene segnalata. Monotonia e strain (Foster) sono stime.",
-	"ls.estimated": "Alcuni carichi sono stime: l'attività non ha un carico Garmin.",
-	"w.loadVsRecovery": "Carico e recupero",
-	"lvr.hrv": "HRV (ms)",
-	"lvr.note": "Carico giornaliero per tipo (barre) e HRV notturna (linea).",
-	"w.calendar": "Costanza",
-	"cal.minutes": "{n} min",
-	"cal.rest": "Giorno di riposo",
-	"cal.label": "Giorni di allenamento, per settimana; le frecce si spostano",
-	"cal.less": "Meno",
-	"cal.more": "Più",
-	"m.label": "Misura",
-	skip: "Vai alla scheda",
-	"w.hrv": "HRV",
-	"hrv.low": "Minimo dell'intervallo",
-	"hrv.band": "Intervallo bilanciato",
-	"hrv.nightly": "HRV notturna",
-	"hrv.avg": "Media di 7 giorni",
-	rec14: "Ultimi 14 giorni: la finestra di settimane non li cambia.",
-	"rec.board": "I widget di recupero mostrano gli ultimi 14 giorni: la finestra di settimane non li cambia.",
-	"w.restingHr": "FC a riposo",
-	"w.sleep": "Sonno",
-	"sl.deep": "Profondo",
-	"sl.light": "Leggero",
-	"sl.rem": "REM",
-	"sl.awake": "Sveglio",
-	"sl.score": "Punteggio",
-	"w.sleepNeed": "Fabbisogno di sonno",
-	"sn.gap": "Sotto il fabbisogno · media",
-	"sn.actual": "Dormito",
-	"sn.need": "Fabbisogno",
-	"w.bedtime": "Ora di andare a letto",
-	"bt.spread": "Variabilità dell'orario",
-	"w.bodyBattery": "Body Battery",
-	"bb.high": "Massimo",
-	"bb.low": "Minimo",
-	"w.activities": "Attività",
-	"col.date": "Data",
-	"col.type": "Tipo",
-	"col.name": "Nome",
-	"col.distance": "Distanza",
-	"col.time": "Tempo",
-	"col.pace": "Passo / velocità",
-	"col.hr": "FC media",
-	"col.ascent": "Dislivello",
-	"col.race": "Gara",
-	"laps.show": "giri",
-	"lap.n": "Giro",
-	"lap.intensity": "Intensità",
-	"act.more": "Mostra tutte ({n})",
-	"act.less": "Mostra meno",
-	"one.session": "Una sola sessione finora: i grafici di tendenza iniziano da 2 sessioni.",
-	"w.typeKpis": "Riepilogo",
-	"tk.sessions": "Sessioni",
-	"tk.time": "Tempo",
-	"tk.avg": "{v} a sessione",
-	"tk.distance": "Distanza",
-	"tk.speed": "Velocità media",
-	"tk.pace": "Passo medio",
-	"tk.ascent": "Dislivello",
-	"tk.hr": "FC media",
-	"tk.peak": "Picco {v} bpm",
-	"tk.load": "Carico di allenamento Garmin",
-	"tk.share": "{v}% di tutto il carico",
-	"w.typeWeekly": "Ogni settimana",
-	"w.hrZones": "Tempo nelle zone FC",
-	"zones.approximate": "Approssimato: alcune attività non hanno il tempo per zona, quindi tutti i loro minuti contano nella zona della FC media.",
-	"form.cadence": "Cadenza",
-	"form.stride": "Falcata",
-	"form.gct": "Contatto al suolo",
-	"form.vertOsc": "Oscillazione verticale",
-	"form.vertRatio": "Rapporto verticale",
-	"form.power": "Potenza",
-	"form.normPower": "Potenza normalizzata",
-	"w.bestEfforts": "Migliori prestazioni",
-	"be.distance": "Distanza",
-	"be.activity": "Attività",
-	"w.races": "Gare",
-	"races.none": "Nessuna gara nelle settimane scelte.",
-	"te.aerobic": "TE aerobico",
-	"te.anaerobic": "TE anaerobico",
-	"w.aerobicFitness": "Forma aerobica",
-	"af.runs": "Corse (le più vecchie più chiare)",
-	"af.pace": "Passo (min/km)",
-	"af.weekPace": "Passo settimanale",
-	"af.efficiency": "Efficienza",
-	"af.effUnit": "m per battito",
-	"w.intensityShare": "Corsa facile e intensa",
-	"is.easy": "Z1-2 (facile)",
-	"is.hard": "Z4-5 (intensa)",
-	"w.runningForm": "Tecnica di corsa",
-	"w.runWalk": "Corsa e camminata",
-	"rw.none": "Nessuna sessione di corsa e camminata nelle settimane scelte.",
-	"rw.runPace": "Passo di corsa",
-	"rw.pace": "Passo totale",
-	"rw.walk": "Tempo di camminata",
-	"w.trainingEffect": "Effetto allenante",
-	"w.racePredictor": "Previsione gare",
-	"rp.none": "Nessuna prestazione di 5 km o più nelle settimane scelte.",
-	"rp.note": "Stima (Riegel) dai {d} in {time} del {date}.",
-	"w.longRuns": "Lunghi e ripartizione del passo",
-	"lr.share": "Quota del lungo sui km settimanali",
-	"lr.ascent": "Dislivello settimanale",
-	"lr.note": "Settimane rosse: il lungo supera il 35% dei km della settimana. La tabella mostra le gare e le corse oltre 15 km con i giri.",
-	"lr.first": "Prima metà",
-	"lr.second": "Seconda metà",
-	"lr.split": "Ripartizione",
-	"lr.gap": "Passo corretto per pendenza",
-	"lr.positive": "positiva",
-	"lr.negative": "negativa",
-	"lr.even": "regolare",
-	"w.setsPerCategory": "Serie per movimento",
-	"ex.sets": "Serie completate",
-	"w.muscleBalance": "Equilibrio tra gruppi muscolari",
-	"mb.pushPull": "Serie di spinta : tirata",
-	"mb.avg": "Media di serie a settimana",
-	"mb.perWeek": "serie a settimana",
-	"mb.note": "Una serie conta 1 per ogni gruppo muscolare primario e 0,5 per ogni gruppo secondario. Intervallo usuale: 10-20 serie a settimana (giallo sotto, rosso sopra).",
-	"w.exercises": "Esercizi",
-	"ex.groups": "Gruppi muscolari",
-	"ex.search": "Cerca esercizi",
-	"ex.name": "Esercizio",
-	"ex.sessions": "Sessioni",
-	"ex.last": "Ultima",
-	"ex.top": "Ultima serie migliore",
-	"ex.best": "Miglior 1RM stimato",
-	"ex.change": "Variazione",
-	"ex.trend": "Tendenza",
-	"ex.groupRow": "{n} esercizio · {sets} serie completate|{n} esercizi · {sets} serie completate",
-	"ex.reps": "{n} ripetizione|{n} ripetizioni",
-	"ex.rest": "recupero mediano {v}",
-	"ex.weight": "Serie migliore (kg)",
-	"ex.e1rm": "1RM stimato (kg)",
-	"ex.volume": "Volume (kg)",
-	"ex.maxReps": "Ripetizioni massime",
-	"ex.totalReps": "Ripetizioni totali",
-	"ex.longest": "Serie più lunga (s)",
-	"ex.restAfter": "recupero {v}",
-	"ex.notDone": "non completata",
-	"w.strengthSessions": "Sessioni",
-	"ss.count": "{n} esercizio|{n} esercizi",
-	"mg.chest": "Petto",
-	"mg.back": "Schiena",
-	"mg.shoulders": "Spalle",
-	"mg.biceps": "Bicipiti",
-	"mg.triceps": "Tricipiti",
-	"mg.forearms": "Avambracci",
-	"mg.quads": "Quadricipiti",
-	"mg.hamstrings": "Femorali",
-	"mg.glutes": "Glutei",
-	"mg.calves": "Polpacci",
-	"mg.abs": "Addominali",
-	"mg.hips": "Anche",
-	"mg.other": "Altro",
-	"w.walkDetails": "Passo e camminate",
-	"wd.steps": "Passi",
-	"wd.battery": "Variazione Body Battery",
-	"wd.goal": "Obiettivo passi",
-	"wd.floors": "Piani",
-	"w.steps": "Passi giornalieri",
-	"w.hikeVertical": "Velocità verticale",
-	"hv.vam": "Metri verticali all'ora",
-	"w.bikeDetails": "Uscite in bici",
-	"bd.outdoor": "All'aperto",
-	"bd.indoor": "Al chiuso",
-	"bd.rides": "{n} uscita|{n} uscite",
-	"bd.where": "Dove",
-	"w.swimDetails": "Nuotate",
-	"sw.pace": "Passo",
-	"sw.lengths": "Vasche",
-	"sw.strokes": "Bracciate",
-	"sw.pool": "Piscina",
-	"w.racketDetails": "Sessioni e intensità",
-	"pd.peak": "FC di picco",
-	"pd.z3": "Tempo in Z3+",
-	"pd.z45": "Quota Z4-5",
-	"pd.kcal": "kcal all'ora",
-	"pd.load": "Carico / corsa della stessa durata",
-	"pd.note": "Il secondo carico è una stima: il carico Garmin medio al minuto delle tue corse, per la durata della sessione.",
-	"col.sport": "Sport",
-	"sport.tennis": "Tennis",
-	"sport.padel": "Padel",
-	"sport.pickleball": "Pickleball",
-	"sport.racquetball": "Racquetball",
-	"sport.squash": "Squash",
-	"sport.badminton": "Badminton",
-	"sport.tableTennis": "Tennis tavolo",
-	"sport.platformTennis": "Platform tennis"
-} };
-// src/page/i18n/en.ts
-/** The page texts in English: the source of the keys. Every other catalogue has exactly these keys. */
-const en = {
+const BUILT_IN = {
+	it: {
+		title: "Allenamento + Recupero",
+		headline: "Carico di allenamento, recupero e progressi da Garmin Connect",
+		na: "n/d",
+		noData: "Questa pagina non ha ancora dati. Chiedi al tuo assistente di scrivere la dashboard.",
+		period: "dal {from} al {to}",
+		inProgress: "* settimana in corso",
+		"menu.settings": "Impostazioni",
+		"menu.theme": "Tema",
+		"footer.updated": "Dati da Garmin Connect, aggiornati il {date}",
+		"footer.failed": "Giorni non letti da Garmin: {n} (i loro valori mostrano n/d)",
+		"footer.license": "Licenza MIT",
+		"menu.language": "Lingua",
+		"lang.auto": "Automatica",
+		"lang.missing": "{language} non è ancora in questa pagina. Chiedi al tuo assistente di aggiungere la lingua.",
+		"themeGroup.auto": "Automatico",
+		"themeGroup.dark": "Scuri",
+		"themeGroup.light": "Chiari",
+		"themeGroup.accessible": "Accessibili",
+		"theme.system": "Sistema",
+		"theme.midnight": "Mezzanotte",
+		"theme.graphite": "Grafite",
+		"theme.ocean": "Oceano",
+		"theme.forest": "Foresta",
+		"theme.plum": "Prugna",
+		"theme.light": "Chiaro",
+		"theme.paper": "Carta",
+		"theme.mist": "Nebbia",
+		"theme.hcDark": "Alto contrasto scuro",
+		"theme.hcLight": "Alto contrasto chiaro",
+		"window.label": "Settimane",
+		"window.last": "Ultime {n}",
+		"window.all": "Tutte",
+		"window.from": "Dalla settimana",
+		"window.to": "Alla settimana",
+		"names.label": "Nomi delle attività",
+		"names.all": "Tutti",
+		"names.count": "{n} scelto|{n} scelti",
+		"names.search": "Cerca nomi",
+		"names.noMatch": "Nessun nome corrisponde.",
+		"names.remove": "Togli {name}",
+		"names.clear": "Mostra tutte",
+		"type.all": "Tutte",
+		"type.recovery": "Recupero",
+		"type.running": "Corsa",
+		"type.strengthTraining": "Forza",
+		"type.walking": "Camminata",
+		"type.hiking": "Escursionismo",
+		"type.cycling": "Bici",
+		"type.swimming": "Nuoto",
+		"type.racket": "Sport di racchetta",
+		"type.generic": "Altro",
+		"type.transition": "Transizione",
+		"type.fitnessEquipment": "Attrezzi fitness",
+		"type.basketball": "Pallacanestro",
+		"type.soccer": "Calcio",
+		"type.tennis": "Tennis",
+		"type.americanFootball": "Football americano",
+		"type.training": "Allenamento",
+		"type.crossCountrySkiing": "Sci di fondo",
+		"type.alpineSkiing": "Sci alpino",
+		"type.snowboarding": "Snowboard",
+		"type.rowing": "Canottaggio",
+		"type.mountaineering": "Alpinismo",
+		"type.multisport": "Multisport",
+		"type.paddling": "Pagaia",
+		"type.flying": "Volo",
+		"type.eBiking": "E-bike",
+		"type.motorcycling": "Motociclismo",
+		"type.boating": "Nautica",
+		"type.driving": "Guida",
+		"type.golf": "Golf",
+		"type.hangGliding": "Deltaplano",
+		"type.horsebackRiding": "Equitazione",
+		"type.hunting": "Caccia",
+		"type.fishing": "Pesca",
+		"type.inlineSkating": "Pattinaggio in linea",
+		"type.rockClimbing": "Arrampicata",
+		"type.sailing": "Vela",
+		"type.iceSkating": "Pattinaggio su ghiaccio",
+		"type.skyDiving": "Paracadutismo",
+		"type.snowshoeing": "Ciaspolata",
+		"type.snowmobiling": "Motoslitta",
+		"type.standUpPaddleboarding": "Stand up paddle",
+		"type.surfing": "Surf",
+		"type.wakeboarding": "Wakeboard",
+		"type.waterSkiing": "Sci nautico",
+		"type.kayaking": "Kayak",
+		"type.rafting": "Rafting",
+		"type.windsurfing": "Windsurf",
+		"type.kitesurfing": "Kitesurf",
+		"type.tactical": "Tattico",
+		"type.jumpmaster": "Jumpmaster",
+		"type.boxing": "Pugilato",
+		"type.floorClimbing": "Salita di piani",
+		"type.baseball": "Baseball",
+		"type.diving": "Immersione",
+		"type.shooting": "Tiro",
+		"type.winterSport": "Sport invernali",
+		"type.grinding": "Grinding",
+		"type.hiit": "HIIT",
+		"type.videoGaming": "Videogiochi",
+		"type.wheelchairPushWalk": "Passeggiata in carrozzina",
+		"type.wheelchairPushRun": "Corsa in carrozzina",
+		"type.meditation": "Meditazione",
+		"type.paraSport": "Sport paralimpici",
+		"type.discGolf": "Disc golf",
+		"type.teamSport": "Sport di squadra",
+		"type.cricket": "Cricket",
+		"type.rugby": "Rugby",
+		"type.hockey": "Hockey",
+		"type.lacrosse": "Lacrosse",
+		"type.volleyball": "Pallavolo",
+		"type.waterTubing": "Tubing",
+		"type.wakesurfing": "Wakesurf",
+		"type.waterSport": "Sport acquatici",
+		"type.archery": "Tiro con l'arco",
+		"type.mixedMartialArts": "Arti marziali miste",
+		"type.motorSports": "Motorsport",
+		"type.snorkeling": "Snorkeling",
+		"type.dance": "Danza",
+		"type.jumpRope": "Salto della corda",
+		"type.poolApnea": "Apnea in piscina",
+		"type.mobility": "Mobilità",
+		"type.geocaching": "Geocaching",
+		"type.canoeing": "Canoa",
+		"tabs.label": "Tipi di attività",
+		"edit.start": "Modifica layout",
+		"edit.done": "Fine",
+		"edit.add": "Aggiungi widget",
+		"edit.reset": "Ripristina scheda",
+		"edit.discard": "Annulla",
+		"edit.bar": "Modifica layout",
+		"edit.editing": "Modifica · {board}",
+		"edit.unsaved": "Modifiche non salvate",
+		"discard.title": "Annullare le modifiche?",
+		"discard.text": "Il layout torna com'era prima di selezionare Modifica layout, in ogni scheda.",
+		"discard.keep": "Continua a modificare",
+		"discard.confirm": "Annulla le modifiche",
+		"edit.copy": "Copia layout",
+		"edit.hide": "Nascondi {title}",
+		"edit.show": "Mostra {title}",
+		"edit.remove": "Rimuovi {title}",
+		"edit.move": "Sposta {title}",
+		"edit.moveHint": "Trascina per spostare, oppure premi Spazio e poi le frecce",
+		"edit.width": "Larghezza di {title}",
+		"edit.widthValue": "{n} colonne su {cols}",
+		"edit.addHidden": "Aggiungi widget · {n} nascosti",
+		"add.addOne": "Aggiungi {title}",
+		"said.picked": "{title} preso, posizione {n} di {count}. Le frecce lo spostano, Spazio lo rilascia, Esc lo rimette al suo posto.",
+		"said.position": "Posizione {n} di {count}",
+		"said.cancelled": "{title} è di nuovo al suo posto",
+		"said.moved": "{title} spostato in posizione {n} di {count}",
+		"said.width": "{title}: {n} colonne su {cols}",
+		"said.hidden": "{title} nascosto",
+		"said.shown": "{title} visibile",
+		"said.removed": "{title} rimosso",
+		"said.added": "{title} aggiunto",
+		"said.saved": "Layout salvato",
+		"said.unchanged": "Nessuna modifica da salvare",
+		"said.discarded": "Modifiche annullate",
+		"stale.label": "Nuovo layout",
+		"stale.text": "Il tuo assistente ha scritto un nuovo layout per questa dashboard. Il layout che hai fatto in questo browser resta finché non scegli.",
+		"stale.keep": "Tieni il mio",
+		"stale.new": "Usa il nuovo",
+		"stale.used": "Ora usi il nuovo layout",
+		"stale.kept": "Ora usi il tuo layout",
+		"add.title": "Aggiungi un widget",
+		"add.type": "Tipo",
+		"add.add": "Aggiungi",
+		"add.close": "Chiudi",
+		"add.hiddenGroup": "Nascosti in questa scheda",
+		"add.none": "Tutti i widget sono già in questa scheda.",
+		"add.search": "Cerca widget",
+		"add.noMatch": "Nessun widget corrisponde.",
+		"copy.title": "Copia layout",
+		"copy.hint": "Questo layout è salvato solo in questo browser. Per tenerlo nella pagina, incolla questo testo al tuo assistente e chiedigli di salvare il layout della dashboard.",
+		"copy.copy": "Copia",
+		"copy.copied": "Copiato",
+		"board.empty": "Questa scheda non ha widget.",
+		"board.emptyEdit": "Questa scheda non ha widget: usa “Aggiungi widget” per metterne.",
+		"widget.failed": "Questo widget non funziona: {message}",
+		"widget.unknown": "Widget sconosciuto: {id}",
+		"empty.window": "Nessuna sessione nelle settimane scelte.",
+		"w.coachNotes": "Note del coach",
+		"notes.none": "Nessuna nota.",
+		"notes.disclaimer": "Suggerimenti di allenamento sui dati fino al {date}. Non sono consigli medici.",
+		"w.kpis": "Panoramica",
+		"kpi.totals": "{distance} · {time} · {n} sessione|{distance} · {time} · {n} sessioni",
+		"kpi.distance": "Distanza · ultimi 7 giorni",
+		"kpi.time": "Tempo · ultimi 7 giorni",
+		"kpi.vs4w": "rispetto alla media di 4 settimane",
+		"delta.good": "meglio",
+		"delta.bad": "peggio",
+		"kpi.ratio": "Rapporto di carico 7:28",
+		"kpi.band": "Fascia 0,8-1,3",
+		"kpi.ratioAll": "Usa tutte le attività, anche con un filtro per tipo",
+		"kpi.hrv": "HRV della notte",
+		"kpi.vsBaseline": "rispetto alla media di 7 giorni {v} ms",
+		"w.readiness": "Prontezza di oggi",
+		"ready.easy": "Vai piano",
+		"ready.push": "Pronto a spingere",
+		"ready.normal": "Normale",
+		"ready.hrv": "Stato HRV",
+		"ready.sleep": "Punteggio sonno",
+		"ready.rhr": "FC a riposo",
+		"ready.rhrVs": "7 giorni prima: {avg} bpm",
+		"ready.ratio": "Rapporto di carico 7:28",
+		"ready.note": "Una regola della dashboard, non la prontezza di Garmin. Mostra oggi: la finestra di settimane non la cambia.",
+		"w.fitnessAge": "Età fitness",
+		"fa.age": "Età fitness",
+		"fa.actual": "Età reale",
+		"fa.achievable": "Raggiungibile",
+		"fa.details": "Dettagli",
+		"fa.component": "Componente",
+		"fa.value": "Ora",
+		"fa.target": "Obiettivo Garmin",
+		"fa.potential": "Età possibile",
+		"fa.bodyFat": "Grasso corporeo %",
+		"fa.bmi": "IMC",
+		"fa.rhr": "FC a riposo",
+		"fa.vigorousDaysAvg": "Giorni intensi / settimana",
+		"fa.vigorousMinutesAvg": "Minuti intensi / settimana",
+		"today.note": "Mostra oggi: la finestra di settimane non la cambia.",
+		"w.periodComparison": "Confronto tra periodi",
+		"pc.vs": "dal {from} al {to} rispetto a dal {pfrom} al {pto}",
+		"pc.partial": "parziale: queste settimane iniziano prima dei dati",
+		"pc.type": "Tipo",
+		"pc.sessions": "Sessioni",
+		"pc.distance": "Distanza",
+		"pc.time": "Tempo",
+		"pc.load": "Carico",
+		"pc.total": "Totale",
+		"w.records": "Record",
+		"rec.best": "{d} più veloce",
+		"d.1k": "1 km",
+		"d.mile": "miglio",
+		"d.5k": "5 km",
+		"d.10k": "10 km",
+		"d.half": "mezza maratona",
+		"d.marathon": "maratona",
+		"rec.longestRun": "Corsa più lunga",
+		"rec.longestRide": "Uscita in bici più lunga",
+		"rec.topSet": "Serie più pesante",
+		"rec.e1rm": "Miglior 1RM stimato · {name}",
+		"rec.none": "Nessun record nelle settimane scelte.",
+		"rec.estimate": "I valori 1RM sono stime (Epley, serie da 1-12 ripetizioni).",
+		"w.weeklyVolume": "Volume settimanale",
+		"m.time": "Tempo",
+		"m.distance": "Distanza",
+		"m.sessions": "Sessioni",
+		"m.load": "Carico",
+		"vol.avg": "Media di 4 settimane",
+		"w.intensityMinutes": "Minuti di intensità",
+		"im.guide": "Linea guida 150 min",
+		"im.note": "Minuti moderati + 2 x intensi delle sole attività, non di tutta la giornata.",
+		"w.loadSafety": "Sicurezza del carico",
+		"ls.weekLoad": "Carico · ultimi 7 giorni",
+		"ls.monotony": "Monotonia · 7 giorni",
+		"ls.monotonyFlag": "Sopra 2,0",
+		"ls.strain": "Strain · 7 giorni",
+		"ls.flagged": "Settimane sopra +10%",
+		"ls.load": "Carico settimanale",
+		"ls.ramp": "Variazione sulla settimana prima (%)",
+		"ls.note": "Tutte le attività. Le settimane rosse sono salite più del 10%; una settimana in corso non viene segnalata. Monotonia e strain (Foster) sono stime.",
+		"ls.estimated": "Alcuni carichi sono stime: l'attività non ha un carico Garmin.",
+		"w.loadVsRecovery": "Carico e recupero",
+		"lvr.hrv": "HRV (ms)",
+		"lvr.note": "Carico giornaliero per tipo (barre) e HRV notturna (linea).",
+		"w.calendar": "Costanza",
+		"cal.minutes": "{n} min",
+		"cal.rest": "Giorno di riposo",
+		"cal.label": "Giorni di allenamento, per settimana; le frecce si spostano",
+		"cal.less": "Meno",
+		"cal.more": "Più",
+		"m.label": "Misura",
+		skip: "Vai alla scheda",
+		"w.hrv": "HRV",
+		"hrv.low": "Minimo dell'intervallo",
+		"hrv.band": "Intervallo bilanciato",
+		"hrv.nightly": "HRV notturna",
+		"hrv.avg": "Media di 7 giorni",
+		rec14: "Ultimi 14 giorni: la finestra di settimane non li cambia.",
+		"rec.board": "I widget di recupero mostrano gli ultimi 14 giorni: la finestra di settimane non li cambia.",
+		"w.restingHr": "FC a riposo",
+		"w.sleep": "Sonno",
+		"sl.deep": "Profondo",
+		"sl.light": "Leggero",
+		"sl.rem": "REM",
+		"sl.awake": "Sveglio",
+		"sl.score": "Punteggio",
+		"w.sleepNeed": "Fabbisogno di sonno",
+		"sn.gap": "Sotto il fabbisogno · media",
+		"sn.actual": "Dormito",
+		"sn.need": "Fabbisogno",
+		"w.bedtime": "Ora di andare a letto",
+		"bt.spread": "Variabilità dell'orario",
+		"w.bodyBattery": "Body Battery",
+		"bb.high": "Massimo",
+		"bb.low": "Minimo",
+		"w.activities": "Attività",
+		"col.date": "Data",
+		"col.type": "Tipo",
+		"col.name": "Nome",
+		"col.distance": "Distanza",
+		"col.time": "Tempo",
+		"col.pace": "Passo / velocità",
+		"col.hr": "FC media",
+		"col.ascent": "Dislivello",
+		"col.race": "Gara",
+		"laps.show": "giri",
+		"lap.n": "Giro",
+		"lap.intensity": "Intensità",
+		"act.more": "Mostra tutte ({n})",
+		"act.less": "Mostra meno",
+		"one.session": "Una sola sessione finora: i grafici di tendenza iniziano da 2 sessioni.",
+		"w.typeKpis": "Riepilogo",
+		"tk.sessions": "Sessioni",
+		"tk.time": "Tempo",
+		"tk.avg": "{v} a sessione",
+		"tk.distance": "Distanza",
+		"tk.speed": "Velocità media",
+		"tk.pace": "Passo medio",
+		"tk.ascent": "Dislivello",
+		"tk.hr": "FC media",
+		"tk.peak": "Picco {v} bpm",
+		"tk.load": "Carico di allenamento Garmin",
+		"tk.share": "{v}% di tutto il carico",
+		"w.typeWeekly": "Ogni settimana",
+		"w.hrZones": "Tempo nelle zone FC",
+		"zones.approximate": "Approssimato: alcune attività non hanno il tempo per zona, quindi tutti i loro minuti contano nella zona della FC media.",
+		"form.cadence": "Cadenza",
+		"form.stride": "Falcata",
+		"form.gct": "Contatto al suolo",
+		"form.vertOsc": "Oscillazione verticale",
+		"form.vertRatio": "Rapporto verticale",
+		"form.power": "Potenza",
+		"form.normPower": "Potenza normalizzata",
+		"w.bestEfforts": "Migliori prestazioni",
+		"be.distance": "Distanza",
+		"be.activity": "Attività",
+		"w.races": "Gare",
+		"races.none": "Nessuna gara nelle settimane scelte.",
+		"te.aerobic": "TE aerobico",
+		"te.anaerobic": "TE anaerobico",
+		"w.aerobicFitness": "Forma aerobica",
+		"af.runs": "Corse (le più vecchie più chiare)",
+		"af.pace": "Passo (min{unit})",
+		"af.weekPace": "Passo settimanale",
+		"af.efficiency": "Efficienza",
+		"af.effUnit": "m per battito",
+		"w.intensityShare": "Corsa facile e intensa",
+		"is.easy": "Z1-2 (facile)",
+		"is.hard": "Z4-5 (intensa)",
+		"w.runningForm": "Tecnica di corsa",
+		"w.runWalk": "Corsa e camminata",
+		"rw.none": "Nessuna sessione di corsa e camminata nelle settimane scelte.",
+		"rw.runPace": "Passo di corsa",
+		"rw.pace": "Passo totale",
+		"rw.walk": "Tempo di camminata",
+		"w.trainingEffect": "Effetto allenante",
+		"w.racePredictor": "Previsione gare",
+		"rp.none": "Nessuna prestazione di 5 km o più nelle settimane scelte.",
+		"rp.note": "Stima (Riegel) dai {d} in {time} del {date}.",
+		"w.longRuns": "Lunghi e ripartizione del passo",
+		"lr.share": "Quota del lungo sulla distanza settimanale",
+		"lr.ascent": "Dislivello settimanale",
+		"lr.note": "Settimane rosse: il lungo supera il 35% della distanza della settimana. La tabella mostra le gare e le corse oltre 15 km con i giri.",
+		"lr.first": "Prima metà",
+		"lr.second": "Seconda metà",
+		"lr.split": "Ripartizione",
+		"lr.gap": "Passo corretto per pendenza",
+		"lr.positive": "positiva",
+		"lr.negative": "negativa",
+		"lr.even": "regolare",
+		"w.setsPerCategory": "Serie per movimento",
+		"ex.sets": "Serie completate",
+		"w.muscleBalance": "Equilibrio tra gruppi muscolari",
+		"mb.pushPull": "Serie di spinta : tirata",
+		"mb.avg": "Media di serie a settimana",
+		"mb.perWeek": "serie a settimana",
+		"mb.note": "Una serie conta 1 per ogni gruppo muscolare primario e 0,5 per ogni gruppo secondario. Intervallo usuale: 10-20 serie a settimana (giallo sotto, rosso sopra).",
+		"w.exercises": "Esercizi",
+		"ex.groups": "Gruppi muscolari",
+		"ex.search": "Cerca esercizi",
+		"ex.name": "Esercizio",
+		"ex.sessions": "Sessioni",
+		"ex.last": "Ultima",
+		"ex.top": "Ultima serie migliore",
+		"ex.best": "Miglior 1RM stimato",
+		"ex.change": "Variazione",
+		"ex.trend": "Tendenza",
+		"ex.groupRow": "{n} esercizio · {sets} serie completate|{n} esercizi · {sets} serie completate",
+		"ex.reps": "{n} ripetizione|{n} ripetizioni",
+		"ex.rest": "recupero mediano {v}",
+		"ex.weight": "Serie migliore ({unit})",
+		"ex.e1rm": "1RM stimato ({unit})",
+		"ex.volume": "Volume ({unit})",
+		"ex.maxReps": "Ripetizioni massime",
+		"ex.totalReps": "Ripetizioni totali",
+		"ex.longest": "Serie più lunga (s)",
+		"ex.restAfter": "recupero {v}",
+		"ex.notDone": "non completata",
+		"w.strengthSessions": "Sessioni",
+		"ss.count": "{n} esercizio|{n} esercizi",
+		"mg.chest": "Petto",
+		"mg.back": "Schiena",
+		"mg.shoulders": "Spalle",
+		"mg.biceps": "Bicipiti",
+		"mg.triceps": "Tricipiti",
+		"mg.forearms": "Avambracci",
+		"mg.quads": "Quadricipiti",
+		"mg.hamstrings": "Femorali",
+		"mg.glutes": "Glutei",
+		"mg.calves": "Polpacci",
+		"mg.abs": "Addominali",
+		"mg.hips": "Anche",
+		"mg.other": "Altro",
+		"w.walkDetails": "Passo e camminate",
+		"wd.steps": "Passi",
+		"wd.battery": "Variazione Body Battery",
+		"wd.goal": "Obiettivo passi",
+		"wd.floors": "Piani",
+		"w.steps": "Passi giornalieri",
+		"w.hikeVertical": "Velocità verticale",
+		"hv.vam": "Dislivello ({unit}) all'ora",
+		"w.bikeDetails": "Uscite in bici",
+		"bd.outdoor": "All'aperto",
+		"bd.indoor": "Al chiuso",
+		"bd.rides": "{n} uscita|{n} uscite",
+		"bd.where": "Dove",
+		"w.swimDetails": "Nuotate",
+		"sw.pace": "Passo",
+		"sw.lengths": "Vasche",
+		"sw.strokes": "Bracciate",
+		"sw.pool": "Piscina",
+		"w.racketDetails": "Sessioni e intensità",
+		"pd.peak": "FC di picco",
+		"pd.z3": "Tempo in Z3+",
+		"pd.z45": "Quota Z4-5",
+		"pd.kcal": "kcal all'ora",
+		"pd.load": "Carico / corsa della stessa durata",
+		"pd.note": "Il secondo carico è una stima: il carico Garmin medio al minuto delle tue corse, per la durata della sessione.",
+		"col.sport": "Sport",
+		"sport.tennis": "Tennis",
+		"sport.padel": "Padel",
+		"sport.pickleball": "Pickleball",
+		"sport.racquetball": "Racquetball",
+		"sport.squash": "Squash",
+		"sport.badminton": "Badminton",
+		"sport.tableTennis": "Tennis tavolo",
+		"sport.platformTennis": "Platform tennis"
+	},
+	de: {
+		title: "Training + Erholung",
+		headline: "Trainingsbelastung, Erholung und Fortschritt aus Garmin Connect",
+		na: "k. A.",
+		noData: "Diese Seite hat noch keine Daten. Bitte deinen Assistenten, das Dashboard zu schreiben.",
+		period: "{from} bis {to}",
+		inProgress: "* laufende Woche",
+		"menu.settings": "Einstellungen",
+		"menu.theme": "Design",
+		"footer.updated": "Daten aus Garmin Connect, aktualisiert am {date}",
+		"footer.failed": "Nicht von Garmin gelesene Tage: {n} (ihre Werte zeigen k. A.)",
+		"footer.license": "MIT-Lizenz",
+		"menu.language": "Sprache",
+		"lang.auto": "Automatisch",
+		"lang.missing": "{language} ist noch nicht auf dieser Seite. Bitte deinen Assistenten, die Sprache hinzuzufügen.",
+		"themeGroup.auto": "Automatisch",
+		"themeGroup.dark": "Dunkel",
+		"themeGroup.light": "Hell",
+		"themeGroup.accessible": "Barrierefrei",
+		"theme.system": "System",
+		"theme.midnight": "Mitternacht",
+		"theme.graphite": "Graphit",
+		"theme.ocean": "Ozean",
+		"theme.forest": "Wald",
+		"theme.plum": "Pflaume",
+		"theme.light": "Hell",
+		"theme.paper": "Papier",
+		"theme.mist": "Nebel",
+		"theme.hcDark": "Hoher Kontrast dunkel",
+		"theme.hcLight": "Hoher Kontrast hell",
+		"window.label": "Wochen",
+		"window.last": "Letzte {n}",
+		"window.all": "Alle",
+		"window.from": "Von Woche",
+		"window.to": "Bis Woche",
+		"names.label": "Aktivitätsnamen",
+		"names.all": "Alle",
+		"names.count": "{n} gewählt|{n} gewählt",
+		"names.search": "Namen suchen",
+		"names.noMatch": "Kein Name passt.",
+		"names.remove": "{name} entfernen",
+		"names.clear": "Alle zeigen",
+		"type.all": "Alle",
+		"type.recovery": "Erholung",
+		"type.running": "Laufen",
+		"type.strengthTraining": "Kraft",
+		"type.walking": "Gehen",
+		"type.hiking": "Wandern",
+		"type.cycling": "Rad",
+		"type.swimming": "Schwimmen",
+		"type.racket": "Rückschlagsport",
+		"type.generic": "Sonstiges",
+		"type.transition": "Wechsel",
+		"type.fitnessEquipment": "Fitnessgeräte",
+		"type.basketball": "Basketball",
+		"type.soccer": "Fußball",
+		"type.tennis": "Tennis",
+		"type.americanFootball": "American Football",
+		"type.training": "Training",
+		"type.crossCountrySkiing": "Skilanglauf",
+		"type.alpineSkiing": "Ski alpin",
+		"type.snowboarding": "Snowboarden",
+		"type.rowing": "Rudern",
+		"type.mountaineering": "Bergsteigen",
+		"type.multisport": "Multisport",
+		"type.paddling": "Paddeln",
+		"type.flying": "Fliegen",
+		"type.eBiking": "E-Bike",
+		"type.motorcycling": "Motorradfahren",
+		"type.boating": "Bootfahren",
+		"type.driving": "Autofahren",
+		"type.golf": "Golf",
+		"type.hangGliding": "Drachenfliegen",
+		"type.horsebackRiding": "Reiten",
+		"type.hunting": "Jagen",
+		"type.fishing": "Angeln",
+		"type.inlineSkating": "Inlineskaten",
+		"type.rockClimbing": "Klettern",
+		"type.sailing": "Segeln",
+		"type.iceSkating": "Eislaufen",
+		"type.skyDiving": "Fallschirmspringen",
+		"type.snowshoeing": "Schneeschuhwandern",
+		"type.snowmobiling": "Schneemobil",
+		"type.standUpPaddleboarding": "Stand-up-Paddling",
+		"type.surfing": "Surfen",
+		"type.wakeboarding": "Wakeboarden",
+		"type.waterSkiing": "Wasserski",
+		"type.kayaking": "Kajak",
+		"type.rafting": "Rafting",
+		"type.windsurfing": "Windsurfen",
+		"type.kitesurfing": "Kitesurfen",
+		"type.tactical": "Taktisch",
+		"type.jumpmaster": "Jumpmaster",
+		"type.boxing": "Boxen",
+		"type.floorClimbing": "Etagensteigen",
+		"type.baseball": "Baseball",
+		"type.diving": "Tauchen",
+		"type.shooting": "Schießen",
+		"type.winterSport": "Wintersport",
+		"type.grinding": "Grinding",
+		"type.hiit": "HIIT",
+		"type.videoGaming": "Videospiele",
+		"type.wheelchairPushWalk": "Rollstuhl Gehen",
+		"type.wheelchairPushRun": "Rollstuhl Laufen",
+		"type.meditation": "Meditation",
+		"type.paraSport": "Parasport",
+		"type.discGolf": "Discgolf",
+		"type.teamSport": "Mannschaftssport",
+		"type.cricket": "Cricket",
+		"type.rugby": "Rugby",
+		"type.hockey": "Hockey",
+		"type.lacrosse": "Lacrosse",
+		"type.volleyball": "Volleyball",
+		"type.waterTubing": "Tubing",
+		"type.wakesurfing": "Wakesurfen",
+		"type.waterSport": "Wassersport",
+		"type.archery": "Bogenschießen",
+		"type.mixedMartialArts": "Mixed Martial Arts",
+		"type.motorSports": "Motorsport",
+		"type.snorkeling": "Schnorcheln",
+		"type.dance": "Tanzen",
+		"type.jumpRope": "Seilspringen",
+		"type.poolApnea": "Apnoetauchen im Becken",
+		"type.mobility": "Mobilität",
+		"type.geocaching": "Geocaching",
+		"type.canoeing": "Kanufahren",
+		"tabs.label": "Aktivitätstypen",
+		"edit.start": "Layout bearbeiten",
+		"edit.done": "Fertig",
+		"edit.add": "Widget hinzufügen",
+		"edit.reset": "Board zurücksetzen",
+		"edit.discard": "Verwerfen",
+		"edit.bar": "Layout bearbeiten",
+		"edit.editing": "Bearbeiten · {board}",
+		"edit.unsaved": "Ungespeicherte Änderungen",
+		"discard.title": "Änderungen verwerfen?",
+		"discard.text": "Das Layout kehrt auf jedem Board zum Stand vor „Layout bearbeiten“ zurück.",
+		"discard.keep": "Weiter bearbeiten",
+		"discard.confirm": "Änderungen verwerfen",
+		"edit.copy": "Layout kopieren",
+		"edit.hide": "{title} ausblenden",
+		"edit.show": "{title} einblenden",
+		"edit.remove": "{title} entfernen",
+		"edit.move": "{title} verschieben",
+		"edit.moveHint": "Zum Verschieben ziehen, oder Leertaste und dann die Pfeiltasten drücken",
+		"edit.width": "Breite von {title}",
+		"edit.widthValue": "{n} von {cols} Spalten",
+		"edit.addHidden": "Widget hinzufügen · {n} ausgeblendet",
+		"add.addOne": "{title} hinzufügen",
+		"said.picked": "{title} aufgenommen, Position {n} von {count}. Die Pfeiltasten verschieben es, die Leertaste legt es ab, Escape setzt es zurück.",
+		"said.position": "Position {n} von {count}",
+		"said.cancelled": "{title} ist wieder an seinem Platz",
+		"said.moved": "{title} auf Position {n} von {count} verschoben",
+		"said.width": "{title}: {n} von {cols} Spalten",
+		"said.hidden": "{title} ausgeblendet",
+		"said.shown": "{title} eingeblendet",
+		"said.removed": "{title} entfernt",
+		"said.added": "{title} hinzugefügt",
+		"said.saved": "Layout gespeichert",
+		"said.unchanged": "Keine Änderungen zu speichern",
+		"said.discarded": "Änderungen verworfen",
+		"stale.label": "Neues Layout",
+		"stale.text": "Dein Assistent hat ein neues Layout für dieses Dashboard geschrieben. Das Layout, das du in diesem Browser erstellt hast, bleibt, bis du wählst.",
+		"stale.keep": "Meins behalten",
+		"stale.new": "Das neue verwenden",
+		"stale.used": "Das neue Layout ist aktiv",
+		"stale.kept": "Dein Layout ist aktiv",
+		"add.title": "Widget hinzufügen",
+		"add.type": "Typ",
+		"add.add": "Hinzufügen",
+		"add.close": "Schließen",
+		"add.hiddenGroup": "Auf diesem Board ausgeblendet",
+		"add.none": "Alle Widgets sind auf diesem Board.",
+		"add.search": "Widgets suchen",
+		"add.noMatch": "Kein Widget passt.",
+		"copy.title": "Layout kopieren",
+		"copy.hint": "Dieses Layout ist nur in diesem Browser gespeichert. Um es in der Seite zu behalten, füge diesen Text bei deinem Assistenten ein und bitte ihn, das Dashboard-Layout zu speichern.",
+		"copy.copy": "Kopieren",
+		"copy.copied": "Kopiert",
+		"board.empty": "Dieses Board hat keine Widgets.",
+		"board.emptyEdit": "Dieses Board hat keine Widgets: Füge mit „Widget hinzufügen“ welche hinzu.",
+		"widget.failed": "Dieses Widget ist fehlgeschlagen: {message}",
+		"widget.unknown": "Unbekanntes Widget: {id}",
+		"empty.window": "Keine Einheiten in den gewählten Wochen.",
+		"w.coachNotes": "Coach-Notizen",
+		"notes.none": "Keine Notizen.",
+		"notes.disclaimer": "Trainingsvorschläge für die Daten bis {date}. Kein medizinischer Rat.",
+		"w.kpis": "Überblick",
+		"kpi.totals": "{distance} · {time} · {n} Einheit|{distance} · {time} · {n} Einheiten",
+		"kpi.distance": "Distanz · letzte 7 Tage",
+		"kpi.time": "Zeit · letzte 7 Tage",
+		"kpi.vs4w": "ggü. 4-Wochen-Schnitt",
+		"delta.good": "besser",
+		"delta.bad": "schlechter",
+		"kpi.ratio": "Belastungsverhältnis 7:28",
+		"kpi.band": "Bereich 0,8-1,3",
+		"kpi.ratioAll": "Nutzt alle Aktivitäten, auch mit einem Typfilter",
+		"kpi.hrv": "HRV letzte Nacht",
+		"kpi.vsBaseline": "ggü. 7-Tage-Schnitt {v} ms",
+		"w.readiness": "Bereitschaft heute",
+		"ready.easy": "Locker bleiben",
+		"ready.push": "Bereit für mehr",
+		"ready.normal": "Normal",
+		"ready.hrv": "HRV-Status",
+		"ready.sleep": "Schlafwert",
+		"ready.rhr": "Ruhe-HF",
+		"ready.rhrVs": "7 Tage davor: {avg} bpm",
+		"ready.ratio": "Belastungsverhältnis 7:28",
+		"ready.note": "Eine eigene Regel des Dashboards, nicht die Trainingsbereitschaft von Garmin. Sie zeigt heute: Das Wochenfenster ändert sie nicht.",
+		"w.fitnessAge": "Fitnessalter",
+		"fa.age": "Fitnessalter",
+		"fa.actual": "Tatsächliches Alter",
+		"fa.achievable": "Erreichbar",
+		"fa.details": "Details",
+		"fa.component": "Faktor",
+		"fa.value": "Jetzt",
+		"fa.target": "Garmin-Ziel",
+		"fa.potential": "Mögliches Alter",
+		"fa.bodyFat": "Körperfett %",
+		"fa.bmi": "BMI",
+		"fa.rhr": "Ruhe-HF",
+		"fa.vigorousDaysAvg": "Intensive Tage / Woche",
+		"fa.vigorousMinutesAvg": "Intensive Minuten / Woche",
+		"today.note": "Zeigt heute: Das Wochenfenster ändert es nicht.",
+		"w.periodComparison": "Zeitraumvergleich",
+		"pc.vs": "{from} bis {to} gegenüber {pfrom} bis {pto}",
+		"pc.partial": "unvollständig: diese Wochen beginnen vor den Daten",
+		"pc.type": "Typ",
+		"pc.sessions": "Einheiten",
+		"pc.distance": "Distanz",
+		"pc.time": "Zeit",
+		"pc.load": "Belastung",
+		"pc.total": "Gesamt",
+		"w.records": "Rekorde",
+		"rec.best": "Bestzeit {d}",
+		"d.1k": "1 km",
+		"d.mile": "Meile",
+		"d.5k": "5 km",
+		"d.10k": "10 km",
+		"d.half": "Halbmarathon",
+		"d.marathon": "Marathon",
+		"rec.longestRun": "Längster Lauf",
+		"rec.longestRide": "Längste Radfahrt",
+		"rec.topSet": "Schwerster Satz",
+		"rec.e1rm": "Bestes geschätztes 1RM · {name}",
+		"rec.none": "Keine Rekorde in den gewählten Wochen.",
+		"rec.estimate": "1RM-Werte sind Schätzungen (Epley, Sätze mit 1-12 Wiederholungen).",
+		"w.weeklyVolume": "Wochenumfang",
+		"m.time": "Zeit",
+		"m.distance": "Distanz",
+		"m.sessions": "Einheiten",
+		"m.load": "Belastung",
+		"vol.avg": "4-Wochen-Schnitt",
+		"w.intensityMinutes": "Intensitätsminuten",
+		"im.guide": "Richtwert 150 min",
+		"im.note": "Moderate + 2 x intensive Minuten nur der Aktivitäten, nicht des ganzen Tages.",
+		"w.loadSafety": "Belastungssicherheit",
+		"ls.weekLoad": "Belastung · letzte 7 Tage",
+		"ls.monotony": "Monotonie · 7 Tage",
+		"ls.monotonyFlag": "Über 2,0",
+		"ls.strain": "Strain · 7 Tage",
+		"ls.flagged": "Wochen über +10%",
+		"ls.load": "Wochenbelastung",
+		"ls.ramp": "Änderung ggü. Vorwoche (%)",
+		"ls.note": "Alle Aktivitäten. Rote Wochen sind um mehr als 10% gestiegen; eine laufende Woche wird nicht markiert. Monotonie und Strain (Foster) sind Schätzungen.",
+		"ls.estimated": "Einige Belastungen sind Schätzungen: Die Aktivität hat keine Garmin-Belastung.",
+		"w.loadVsRecovery": "Belastung und Erholung",
+		"lvr.hrv": "HRV (ms)",
+		"lvr.note": "Tägliche Belastung nach Typ (Balken) und nächtliche HRV (Linie).",
+		"w.calendar": "Regelmäßigkeit",
+		"cal.minutes": "{n} min",
+		"cal.rest": "Ruhetag",
+		"cal.label": "Trainingstage, nach Woche; die Pfeiltasten bewegen",
+		"cal.less": "Weniger",
+		"cal.more": "Mehr",
+		"m.label": "Messwert",
+		skip: "Zum Board springen",
+		"w.hrv": "HRV",
+		"hrv.low": "Untergrenze",
+		"hrv.band": "Ausgeglichener Bereich",
+		"hrv.nightly": "Nächtliche HRV",
+		"hrv.avg": "7-Tage-Schnitt",
+		rec14: "Letzte 14 Tage: Das Wochenfenster ändert sie nicht.",
+		"rec.board": "Die Erholungs-Widgets zeigen die letzten 14 Tage: Das Wochenfenster ändert sie nicht.",
+		"w.restingHr": "Ruhe-HF",
+		"w.sleep": "Schlaf",
+		"sl.deep": "Tief",
+		"sl.light": "Leicht",
+		"sl.rem": "REM",
+		"sl.awake": "Wach",
+		"sl.score": "Wert",
+		"w.sleepNeed": "Schlafbedarf",
+		"sn.gap": "Unter Bedarf · Schnitt",
+		"sn.actual": "Geschlafen",
+		"sn.need": "Bedarf",
+		"w.bedtime": "Schlafenszeit",
+		"bt.spread": "Streuung der Schlafenszeit",
+		"w.bodyBattery": "Body Battery",
+		"bb.high": "Hoch",
+		"bb.low": "Tief",
+		"w.activities": "Aktivitäten",
+		"col.date": "Datum",
+		"col.type": "Typ",
+		"col.name": "Name",
+		"col.distance": "Distanz",
+		"col.time": "Zeit",
+		"col.pace": "Pace / Tempo",
+		"col.hr": "Ø HF",
+		"col.ascent": "Anstieg",
+		"col.race": "Wettkampf",
+		"laps.show": "Runden",
+		"lap.n": "Runde",
+		"lap.intensity": "Intensität",
+		"act.more": "Alle {n} zeigen",
+		"act.less": "Weniger zeigen",
+		"one.session": "Bisher eine Einheit: Trends beginnen ab 2 Einheiten.",
+		"w.typeKpis": "Zusammenfassung",
+		"tk.sessions": "Einheiten",
+		"tk.time": "Zeit",
+		"tk.avg": "{v} pro Einheit",
+		"tk.distance": "Distanz",
+		"tk.speed": "Ø Geschwindigkeit",
+		"tk.pace": "Ø Pace",
+		"tk.ascent": "Anstieg",
+		"tk.hr": "Ø HF",
+		"tk.peak": "Spitze {v} bpm",
+		"tk.load": "Garmin-Trainingsbelastung",
+		"tk.share": "{v}% der gesamten Belastung",
+		"w.typeWeekly": "Jede Woche",
+		"w.hrZones": "Zeit in HF-Zonen",
+		"zones.approximate": "Näherungswert: Einige Aktivitäten haben keine Zonenzeit, daher zählen alle ihre Minuten in der Zone ihrer Ø HF.",
+		"form.cadence": "Schrittfrequenz",
+		"form.stride": "Schrittlänge",
+		"form.gct": "Bodenkontaktzeit",
+		"form.vertOsc": "Vertikale Bewegung",
+		"form.vertRatio": "Vertikales Verhältnis",
+		"form.power": "Leistung",
+		"form.normPower": "Normalisierte Leistung",
+		"w.bestEfforts": "Bestleistungen",
+		"be.distance": "Distanz",
+		"be.activity": "Aktivität",
+		"w.races": "Wettkämpfe",
+		"races.none": "Keine Wettkämpfe in den gewählten Wochen.",
+		"te.aerobic": "Aerober TE",
+		"te.anaerobic": "Anaerober TE",
+		"w.aerobicFitness": "Aerobe Fitness",
+		"af.runs": "Läufe (ältere heller)",
+		"af.pace": "Pace (min{unit})",
+		"af.weekPace": "Wochen-Pace",
+		"af.efficiency": "Effizienz",
+		"af.effUnit": "m pro Herzschlag",
+		"w.intensityShare": "Lockeres und hartes Laufen",
+		"is.easy": "Z1-2 (locker)",
+		"is.hard": "Z4-5 (hart)",
+		"w.runningForm": "Laufeffizienz",
+		"w.runWalk": "Laufen und Gehen",
+		"rw.none": "Keine Lauf-Geh-Einheiten in den gewählten Wochen.",
+		"rw.runPace": "Lauf-Pace",
+		"rw.pace": "Gesamt-Pace",
+		"rw.walk": "Gehzeit",
+		"w.trainingEffect": "Trainingseffekt",
+		"w.racePredictor": "Wettkampfprognose",
+		"rp.none": "Keine Bestleistung über 5 km oder mehr in den gewählten Wochen.",
+		"rp.note": "Schätzung (Riegel) aus {d} in {time} am {date}.",
+		"w.longRuns": "Lange Läufe und Pace-Aufteilung",
+		"lr.share": "Anteil des längsten Laufs an der Wochendistanz",
+		"lr.ascent": "Wochenanstieg",
+		"lr.note": "Rote Wochen: Der längste Lauf ist mehr als 35% der Wochendistanz. Die Tabelle zeigt Wettkämpfe und Läufe über 15 km mit Runden.",
+		"lr.first": "Erste Hälfte",
+		"lr.second": "Zweite Hälfte",
+		"lr.split": "Split",
+		"lr.gap": "Steigungsbereinigte Pace",
+		"lr.positive": "positiv",
+		"lr.negative": "negativ",
+		"lr.even": "gleichmäßig",
+		"w.setsPerCategory": "Sätze pro Bewegung",
+		"ex.sets": "Absolvierte Sätze",
+		"w.muscleBalance": "Muskelgruppen-Balance",
+		"mb.pushPull": "Druck- : Zugsätze",
+		"mb.avg": "Ø Sätze pro Woche",
+		"mb.perWeek": "Sätze pro Woche",
+		"mb.note": "Ein Satz zählt 1 für jede primäre Muskelgruppe und 0,5 für jede sekundäre. Üblicher Bereich: 10-20 Sätze pro Woche (gelb darunter, rot darüber).",
+		"w.exercises": "Übungen",
+		"ex.groups": "Muskelgruppen",
+		"ex.search": "Übungen suchen",
+		"ex.name": "Übung",
+		"ex.sessions": "Einheiten",
+		"ex.last": "Zuletzt",
+		"ex.top": "Letzter Top-Satz",
+		"ex.best": "Bestes geschätztes 1RM",
+		"ex.change": "Änderung",
+		"ex.trend": "Trend",
+		"ex.groupRow": "{n} Übung · {sets} absolvierte Sätze|{n} Übungen · {sets} absolvierte Sätze",
+		"ex.reps": "{n} Wiederholung|{n} Wiederholungen",
+		"ex.rest": "Median-Pause {v}",
+		"ex.weight": "Top-Satz ({unit})",
+		"ex.e1rm": "Geschätztes 1RM ({unit})",
+		"ex.volume": "Volumen ({unit})",
+		"ex.maxReps": "Max. Wiederholungen",
+		"ex.totalReps": "Wiederholungen gesamt",
+		"ex.longest": "Längster Satz (s)",
+		"ex.restAfter": "Pause {v}",
+		"ex.notDone": "nicht absolviert",
+		"w.strengthSessions": "Einheiten",
+		"ss.count": "{n} Übung|{n} Übungen",
+		"mg.chest": "Brust",
+		"mg.back": "Rücken",
+		"mg.shoulders": "Schultern",
+		"mg.biceps": "Bizeps",
+		"mg.triceps": "Trizeps",
+		"mg.forearms": "Unterarme",
+		"mg.quads": "Quadrizeps",
+		"mg.hamstrings": "Beinbeuger",
+		"mg.glutes": "Gesäß",
+		"mg.calves": "Waden",
+		"mg.abs": "Bauch",
+		"mg.hips": "Hüfte",
+		"mg.other": "Sonstiges",
+		"w.walkDetails": "Tempo und Spaziergänge",
+		"wd.steps": "Schritte",
+		"wd.battery": "Body-Battery-Änderung",
+		"wd.goal": "Schrittziel",
+		"wd.floors": "Etagen",
+		"w.steps": "Tägliche Schritte",
+		"w.hikeVertical": "Vertikalgeschwindigkeit",
+		"hv.vam": "Höhe ({unit}) pro Stunde",
+		"w.bikeDetails": "Radfahrten",
+		"bd.outdoor": "Draußen",
+		"bd.indoor": "Drinnen",
+		"bd.rides": "{n} Fahrt|{n} Fahrten",
+		"bd.where": "Wo",
+		"w.swimDetails": "Schwimmeinheiten",
+		"sw.pace": "Pace",
+		"sw.lengths": "Bahnen",
+		"sw.strokes": "Züge",
+		"sw.pool": "Becken",
+		"w.racketDetails": "Einheiten und Intensität",
+		"pd.peak": "Spitzen-HF",
+		"pd.z3": "Zeit in Z3+",
+		"pd.z45": "Anteil Z4-5",
+		"pd.kcal": "kcal pro Stunde",
+		"pd.load": "Belastung / Lauf gleicher Dauer",
+		"pd.note": "Die zweite Belastung ist eine Schätzung: die durchschnittliche Garmin-Belastung pro Minute deiner Läufe, mal die Dauer der Einheit.",
+		"col.sport": "Sportart",
+		"sport.tennis": "Tennis",
+		"sport.padel": "Padel",
+		"sport.pickleball": "Pickleball",
+		"sport.racquetball": "Racquetball",
+		"sport.squash": "Squash",
+		"sport.badminton": "Badminton",
+		"sport.tableTennis": "Tischtennis",
+		"sport.platformTennis": "Platform-Tennis"
+	},
+	fr: {
+		title: "Entraînement + Récupération",
+		headline: "Charge d'entraînement, récupération et progrès depuis Garmin Connect",
+		na: "n.d.",
+		noData: "Cette page n'a pas encore de données. Demande à ton assistant d'écrire le tableau de bord.",
+		period: "du {from} au {to}",
+		inProgress: "* semaine en cours",
+		"menu.settings": "Réglages",
+		"menu.theme": "Thème",
+		"footer.updated": "Données de Garmin Connect, mises à jour le {date}",
+		"footer.failed": "Jours non lus depuis Garmin : {n} (leurs valeurs affichent n.d.)",
+		"footer.license": "Licence MIT",
+		"menu.language": "Langue",
+		"lang.auto": "Automatique",
+		"lang.missing": "{language} n'est pas encore dans cette page. Demande à ton assistant d'ajouter la langue.",
+		"themeGroup.auto": "Automatique",
+		"themeGroup.dark": "Sombres",
+		"themeGroup.light": "Clairs",
+		"themeGroup.accessible": "Accessibles",
+		"theme.system": "Système",
+		"theme.midnight": "Minuit",
+		"theme.graphite": "Graphite",
+		"theme.ocean": "Océan",
+		"theme.forest": "Forêt",
+		"theme.plum": "Prune",
+		"theme.light": "Clair",
+		"theme.paper": "Papier",
+		"theme.mist": "Brume",
+		"theme.hcDark": "Contraste élevé sombre",
+		"theme.hcLight": "Contraste élevé clair",
+		"window.label": "Semaines",
+		"window.last": "{n} dernières",
+		"window.all": "Toutes",
+		"window.from": "De la semaine",
+		"window.to": "À la semaine",
+		"names.label": "Noms des activités",
+		"names.all": "Tous",
+		"names.count": "{n} choisi|{n} choisis",
+		"names.search": "Rechercher un nom",
+		"names.noMatch": "Aucun nom ne correspond.",
+		"names.remove": "Retirer {name}",
+		"names.clear": "Tout afficher",
+		"type.all": "Toutes",
+		"type.recovery": "Récupération",
+		"type.running": "Course",
+		"type.strengthTraining": "Musculation",
+		"type.walking": "Marche",
+		"type.hiking": "Randonnée",
+		"type.cycling": "Vélo",
+		"type.swimming": "Natation",
+		"type.racket": "Sports de raquette",
+		"type.generic": "Autre",
+		"type.transition": "Transition",
+		"type.fitnessEquipment": "Appareils de fitness",
+		"type.basketball": "Basket-ball",
+		"type.soccer": "Football",
+		"type.tennis": "Tennis",
+		"type.americanFootball": "Football américain",
+		"type.training": "Entraînement",
+		"type.crossCountrySkiing": "Ski de fond",
+		"type.alpineSkiing": "Ski alpin",
+		"type.snowboarding": "Snowboard",
+		"type.rowing": "Aviron",
+		"type.mountaineering": "Alpinisme",
+		"type.multisport": "Multisport",
+		"type.paddling": "Pagaie",
+		"type.flying": "Vol",
+		"type.eBiking": "Vélo électrique",
+		"type.motorcycling": "Moto",
+		"type.boating": "Navigation",
+		"type.driving": "Conduite",
+		"type.golf": "Golf",
+		"type.hangGliding": "Deltaplane",
+		"type.horsebackRiding": "Équitation",
+		"type.hunting": "Chasse",
+		"type.fishing": "Pêche",
+		"type.inlineSkating": "Roller",
+		"type.rockClimbing": "Escalade",
+		"type.sailing": "Voile",
+		"type.iceSkating": "Patinage sur glace",
+		"type.skyDiving": "Parachutisme",
+		"type.snowshoeing": "Raquettes à neige",
+		"type.snowmobiling": "Motoneige",
+		"type.standUpPaddleboarding": "Stand up paddle",
+		"type.surfing": "Surf",
+		"type.wakeboarding": "Wakeboard",
+		"type.waterSkiing": "Ski nautique",
+		"type.kayaking": "Kayak",
+		"type.rafting": "Rafting",
+		"type.windsurfing": "Planche à voile",
+		"type.kitesurfing": "Kitesurf",
+		"type.tactical": "Tactique",
+		"type.jumpmaster": "Jumpmaster",
+		"type.boxing": "Boxe",
+		"type.floorClimbing": "Montée d'étages",
+		"type.baseball": "Baseball",
+		"type.diving": "Plongée",
+		"type.shooting": "Tir",
+		"type.winterSport": "Sports d'hiver",
+		"type.grinding": "Grinding",
+		"type.hiit": "HIIT",
+		"type.videoGaming": "Jeux vidéo",
+		"type.wheelchairPushWalk": "Marche en fauteuil roulant",
+		"type.wheelchairPushRun": "Course en fauteuil roulant",
+		"type.meditation": "Méditation",
+		"type.paraSport": "Parasport",
+		"type.discGolf": "Disc golf",
+		"type.teamSport": "Sports d'équipe",
+		"type.cricket": "Cricket",
+		"type.rugby": "Rugby",
+		"type.hockey": "Hockey",
+		"type.lacrosse": "Lacrosse",
+		"type.volleyball": "Volley-ball",
+		"type.waterTubing": "Bouée tractée",
+		"type.wakesurfing": "Wakesurf",
+		"type.waterSport": "Sports nautiques",
+		"type.archery": "Tir à l'arc",
+		"type.mixedMartialArts": "Arts martiaux mixtes",
+		"type.motorSports": "Sports mécaniques",
+		"type.snorkeling": "Snorkeling",
+		"type.dance": "Danse",
+		"type.jumpRope": "Corde à sauter",
+		"type.poolApnea": "Apnée en piscine",
+		"type.mobility": "Mobilité",
+		"type.geocaching": "Géocaching",
+		"type.canoeing": "Canoë",
+		"tabs.label": "Types d'activité",
+		"edit.start": "Modifier la mise en page",
+		"edit.done": "Terminé",
+		"edit.add": "Ajouter un widget",
+		"edit.reset": "Réinitialiser le tableau",
+		"edit.discard": "Annuler",
+		"edit.bar": "Modifier la mise en page",
+		"edit.editing": "Modification · {board}",
+		"edit.unsaved": "Modifications non enregistrées",
+		"discard.title": "Annuler tes modifications ?",
+		"discard.text": "La mise en page revient à celle d'avant ton choix de Modifier la mise en page, sur chaque tableau.",
+		"discard.keep": "Continuer à modifier",
+		"discard.confirm": "Annuler les modifications",
+		"edit.copy": "Copier la mise en page",
+		"edit.hide": "Masquer {title}",
+		"edit.show": "Afficher {title}",
+		"edit.remove": "Retirer {title}",
+		"edit.move": "Déplacer {title}",
+		"edit.moveHint": "Fais glisser pour déplacer, ou appuie sur Espace puis sur les flèches",
+		"edit.width": "Largeur de {title}",
+		"edit.widthValue": "{n} colonnes sur {cols}",
+		"edit.addHidden": "Ajouter un widget · {n} masqués",
+		"add.addOne": "Ajouter {title}",
+		"said.picked": "{title} saisi, position {n} sur {count}. Les flèches le déplacent, Espace le dépose, Échap le remet à sa place.",
+		"said.position": "Position {n} sur {count}",
+		"said.cancelled": "{title} est revenu à sa place",
+		"said.moved": "{title} déplacé en position {n} sur {count}",
+		"said.width": "{title} : {n} colonnes sur {cols}",
+		"said.hidden": "{title} masqué",
+		"said.shown": "{title} affiché",
+		"said.removed": "{title} retiré",
+		"said.added": "{title} ajouté",
+		"said.saved": "Mise en page enregistrée",
+		"said.unchanged": "Aucune modification à enregistrer",
+		"said.discarded": "Modifications annulées",
+		"stale.label": "Nouvelle mise en page",
+		"stale.text": "Ton assistant a écrit une nouvelle mise en page pour ce tableau de bord. Celle que tu as faite dans ce navigateur reste jusqu'à ce que tu choisisses.",
+		"stale.keep": "Garder la mienne",
+		"stale.new": "Utiliser la nouvelle",
+		"stale.used": "La nouvelle mise en page est utilisée",
+		"stale.kept": "Ta mise en page est utilisée",
+		"add.title": "Ajouter un widget",
+		"add.type": "Type",
+		"add.add": "Ajouter",
+		"add.close": "Fermer",
+		"add.hiddenGroup": "Masqués sur ce tableau",
+		"add.none": "Tous les widgets sont sur ce tableau.",
+		"add.search": "Rechercher un widget",
+		"add.noMatch": "Aucun widget ne correspond.",
+		"copy.title": "Copier la mise en page",
+		"copy.hint": "Cette mise en page est enregistrée uniquement dans ce navigateur. Pour la garder dans la page, colle ce texte à ton assistant et demande-lui d'enregistrer la mise en page du tableau de bord.",
+		"copy.copy": "Copier",
+		"copy.copied": "Copié",
+		"board.empty": "Ce tableau n'a aucun widget.",
+		"board.emptyEdit": "Ce tableau n'a aucun widget : utilise « Ajouter un widget » pour en mettre.",
+		"widget.failed": "Ce widget a échoué : {message}",
+		"widget.unknown": "Widget inconnu : {id}",
+		"empty.window": "Aucune séance dans les semaines choisies.",
+		"w.coachNotes": "Notes du coach",
+		"notes.none": "Aucune note.",
+		"notes.disclaimer": "Conseils d'entraînement sur les données jusqu'au {date}. Ce ne sont pas des conseils médicaux.",
+		"w.kpis": "Vue d'ensemble",
+		"kpi.totals": "{distance} · {time} · {n} séance|{distance} · {time} · {n} séances",
+		"kpi.distance": "Distance · 7 derniers jours",
+		"kpi.time": "Temps · 7 derniers jours",
+		"kpi.vs4w": "par rapport à la moyenne sur 4 semaines",
+		"delta.good": "mieux",
+		"delta.bad": "moins bien",
+		"kpi.ratio": "Ratio de charge 7:28",
+		"kpi.band": "Plage 0,8-1,3",
+		"kpi.ratioAll": "Utilise toutes les activités, même avec un filtre par type",
+		"kpi.hrv": "HRV de la nuit",
+		"kpi.vsBaseline": "par rapport à la moyenne sur 7 jours {v} ms",
+		"w.readiness": "Forme du jour",
+		"ready.easy": "Vas-y doucement",
+		"ready.push": "Prêt pour l'intensité",
+		"ready.normal": "Normal",
+		"ready.hrv": "Statut HRV",
+		"ready.sleep": "Score de sommeil",
+		"ready.rhr": "FC au repos",
+		"ready.rhrVs": "7 jours avant : {avg} bpm",
+		"ready.ratio": "Ratio de charge 7:28",
+		"ready.note": "Une règle propre au tableau de bord, pas la disposition à l'entraînement de Garmin. Affiche aujourd'hui : la fenêtre de semaines ne la change pas.",
+		"w.fitnessAge": "Âge physique",
+		"fa.age": "Âge physique",
+		"fa.actual": "Âge réel",
+		"fa.achievable": "Atteignable",
+		"fa.details": "Détails",
+		"fa.component": "Composante",
+		"fa.value": "Actuel",
+		"fa.target": "Objectif Garmin",
+		"fa.potential": "Âge potentiel",
+		"fa.bodyFat": "Masse grasse %",
+		"fa.bmi": "IMC",
+		"fa.rhr": "FC au repos",
+		"fa.vigorousDaysAvg": "Jours intenses / semaine",
+		"fa.vigorousMinutesAvg": "Minutes intenses / semaine",
+		"today.note": "Affiche aujourd'hui : la fenêtre de semaines ne le change pas.",
+		"w.periodComparison": "Comparaison de périodes",
+		"pc.vs": "du {from} au {to} par rapport à la période du {pfrom} au {pto}",
+		"pc.partial": "partiel : ces semaines commencent avant les données",
+		"pc.type": "Type",
+		"pc.sessions": "Séances",
+		"pc.distance": "Distance",
+		"pc.time": "Temps",
+		"pc.load": "Charge",
+		"pc.total": "Total",
+		"w.records": "Records",
+		"rec.best": "Meilleur {d}",
+		"d.1k": "1 km",
+		"d.mile": "mile",
+		"d.5k": "5 km",
+		"d.10k": "10 km",
+		"d.half": "semi-marathon",
+		"d.marathon": "marathon",
+		"rec.longestRun": "Plus longue course",
+		"rec.longestRide": "Plus longue sortie à vélo",
+		"rec.topSet": "Série la plus lourde",
+		"rec.e1rm": "Meilleur 1RM estimé · {name}",
+		"rec.none": "Aucun record dans les semaines choisies.",
+		"rec.estimate": "Les valeurs 1RM sont des estimations (Epley, séries de 1-12 répétitions).",
+		"w.weeklyVolume": "Volume hebdomadaire",
+		"m.time": "Temps",
+		"m.distance": "Distance",
+		"m.sessions": "Séances",
+		"m.load": "Charge",
+		"vol.avg": "Moyenne sur 4 semaines",
+		"w.intensityMinutes": "Minutes d'intensité",
+		"im.guide": "Recommandation 150 min",
+		"im.note": "Minutes modérées + 2 x intenses des activités seulement, pas de toute la journée.",
+		"w.loadSafety": "Sécurité de la charge",
+		"ls.weekLoad": "Charge · 7 derniers jours",
+		"ls.monotony": "Monotonie · 7 jours",
+		"ls.monotonyFlag": "Au-dessus de 2,0",
+		"ls.strain": "Contrainte · 7 jours",
+		"ls.flagged": "Semaines au-dessus de +10 %",
+		"ls.load": "Charge hebdomadaire",
+		"ls.ramp": "Variation par rapport à la semaine précédente (%)",
+		"ls.note": "Toutes les activités. Les semaines en rouge ont augmenté de plus de 10 % ; une semaine en cours n'est pas signalée. La monotonie et la contrainte (Foster) sont des estimations.",
+		"ls.estimated": "Certaines charges sont des estimations : l'activité n'a pas de charge Garmin.",
+		"w.loadVsRecovery": "Charge et récupération",
+		"lvr.hrv": "HRV (ms)",
+		"lvr.note": "Charge quotidienne par type (barres) et HRV nocturne (ligne).",
+		"w.calendar": "Régularité",
+		"cal.minutes": "{n} min",
+		"cal.rest": "Jour de repos",
+		"cal.label": "Jours d'entraînement, par semaine ; les flèches permettent de se déplacer",
+		"cal.less": "Moins",
+		"cal.more": "Plus",
+		"m.label": "Mesure",
+		skip: "Aller au tableau",
+		"w.hrv": "HRV",
+		"hrv.low": "Bas de la plage",
+		"hrv.band": "Plage équilibrée",
+		"hrv.nightly": "HRV nocturne",
+		"hrv.avg": "Moyenne sur 7 jours",
+		rec14: "14 derniers jours : la fenêtre de semaines ne les change pas.",
+		"rec.board": "Les widgets de récupération affichent les 14 derniers jours : la fenêtre de semaines ne les change pas.",
+		"w.restingHr": "FC au repos",
+		"w.sleep": "Sommeil",
+		"sl.deep": "Profond",
+		"sl.light": "Léger",
+		"sl.rem": "Paradoxal",
+		"sl.awake": "Éveillé",
+		"sl.score": "Score",
+		"w.sleepNeed": "Besoin de sommeil",
+		"sn.gap": "En dessous du besoin · moyenne",
+		"sn.actual": "Dormi",
+		"sn.need": "Besoin",
+		"w.bedtime": "Heure du coucher",
+		"bt.spread": "Écart des heures de coucher",
+		"w.bodyBattery": "Body Battery",
+		"bb.high": "Maximum",
+		"bb.low": "Minimum",
+		"w.activities": "Activités",
+		"col.date": "Date",
+		"col.type": "Type",
+		"col.name": "Nom",
+		"col.distance": "Distance",
+		"col.time": "Temps",
+		"col.pace": "Allure / vitesse",
+		"col.hr": "FC moy.",
+		"col.ascent": "Dénivelé",
+		"col.race": "Compétition",
+		"laps.show": "tours",
+		"lap.n": "Tour",
+		"lap.intensity": "Intensité",
+		"act.more": "Tout afficher ({n})",
+		"act.less": "Afficher moins",
+		"one.session": "Une seule séance pour l'instant : les tendances commencent à 2 séances.",
+		"w.typeKpis": "Résumé",
+		"tk.sessions": "Séances",
+		"tk.time": "Temps",
+		"tk.avg": "{v} par séance",
+		"tk.distance": "Distance",
+		"tk.speed": "Vitesse moyenne",
+		"tk.pace": "Allure moyenne",
+		"tk.ascent": "Dénivelé",
+		"tk.hr": "FC moyenne",
+		"tk.peak": "Pic {v} bpm",
+		"tk.load": "Charge d'entraînement Garmin",
+		"tk.share": "{v} % de toute la charge",
+		"w.typeWeekly": "Chaque semaine",
+		"w.hrZones": "Temps dans les zones FC",
+		"zones.approximate": "Approximatif : certaines activités n'ont pas de temps par zone, donc toutes leurs minutes comptent dans la zone de leur FC moyenne.",
+		"form.cadence": "Cadence",
+		"form.stride": "Longueur de foulée",
+		"form.gct": "Temps de contact au sol",
+		"form.vertOsc": "Oscillation verticale",
+		"form.vertRatio": "Rapport vertical",
+		"form.power": "Puissance",
+		"form.normPower": "Puissance normalisée",
+		"w.bestEfforts": "Meilleurs efforts",
+		"be.distance": "Distance",
+		"be.activity": "Activité",
+		"w.races": "Compétitions",
+		"races.none": "Aucune compétition dans les semaines choisies.",
+		"te.aerobic": "TE aérobie",
+		"te.anaerobic": "TE anaérobie",
+		"w.aerobicFitness": "Forme aérobie",
+		"af.runs": "Courses (les plus anciennes plus pâles)",
+		"af.pace": "Allure (min{unit})",
+		"af.weekPace": "Allure hebdomadaire",
+		"af.efficiency": "Efficacité",
+		"af.effUnit": "m par battement",
+		"w.intensityShare": "Course facile et intense",
+		"is.easy": "Z1-2 (facile)",
+		"is.hard": "Z4-5 (intense)",
+		"w.runningForm": "Technique de course",
+		"w.runWalk": "Course-marche",
+		"rw.none": "Aucune séance de course-marche dans les semaines choisies.",
+		"rw.runPace": "Allure de course",
+		"rw.pace": "Allure globale",
+		"rw.walk": "Temps de marche",
+		"w.trainingEffect": "Effet d'entraînement",
+		"w.racePredictor": "Prédicteur de course",
+		"rp.none": "Aucun meilleur effort de 5 km ou plus dans les semaines choisies.",
+		"rp.note": "Estimation (Riegel) à partir du {d} en {time} le {date}.",
+		"w.longRuns": "Sorties longues et répartition de l'allure",
+		"lr.share": "Part de la sortie la plus longue dans la distance hebdomadaire",
+		"lr.ascent": "Dénivelé hebdomadaire",
+		"lr.note": "Semaines en rouge : la sortie la plus longue dépasse 35 % de la distance de la semaine. Le tableau affiche les compétitions et les courses de plus de 15 km avec leurs tours.",
+		"lr.first": "Première moitié",
+		"lr.second": "Seconde moitié",
+		"lr.split": "Répartition",
+		"lr.gap": "Allure ajustée à la pente",
+		"lr.positive": "positive",
+		"lr.negative": "négative",
+		"lr.even": "régulière",
+		"w.setsPerCategory": "Séries par mouvement",
+		"ex.sets": "Séries terminées",
+		"w.muscleBalance": "Équilibre des groupes musculaires",
+		"mb.pushPull": "Séries poussée : tirage",
+		"mb.avg": "Moyenne de séries par semaine",
+		"mb.perWeek": "séries par semaine",
+		"mb.note": "Une série compte 1 pour chaque groupe musculaire principal et 0,5 pour chaque groupe secondaire. Plage habituelle : 10-20 séries par semaine (jaune en dessous, rouge au-dessus).",
+		"w.exercises": "Exercices",
+		"ex.groups": "Groupes musculaires",
+		"ex.search": "Rechercher des exercices",
+		"ex.name": "Exercice",
+		"ex.sessions": "Séances",
+		"ex.last": "Dernière",
+		"ex.top": "Dernière meilleure série",
+		"ex.best": "Meilleur 1RM estimé",
+		"ex.change": "Variation",
+		"ex.trend": "Tendance",
+		"ex.groupRow": "{n} exercice · {sets} séries terminées|{n} exercices · {sets} séries terminées",
+		"ex.reps": "{n} répétition|{n} répétitions",
+		"ex.rest": "repos médian {v}",
+		"ex.weight": "Meilleure série ({unit})",
+		"ex.e1rm": "1RM estimé ({unit})",
+		"ex.volume": "Volume ({unit})",
+		"ex.maxReps": "Répétitions max",
+		"ex.totalReps": "Répétitions totales",
+		"ex.longest": "Série la plus longue (s)",
+		"ex.restAfter": "repos {v}",
+		"ex.notDone": "non faite",
+		"w.strengthSessions": "Séances",
+		"ss.count": "{n} exercice|{n} exercices",
+		"mg.chest": "Pectoraux",
+		"mg.back": "Dos",
+		"mg.shoulders": "Épaules",
+		"mg.biceps": "Biceps",
+		"mg.triceps": "Triceps",
+		"mg.forearms": "Avant-bras",
+		"mg.quads": "Quadriceps",
+		"mg.hamstrings": "Ischio-jambiers",
+		"mg.glutes": "Fessiers",
+		"mg.calves": "Mollets",
+		"mg.abs": "Abdominaux",
+		"mg.hips": "Hanches",
+		"mg.other": "Autre",
+		"w.walkDetails": "Allure et marches",
+		"wd.steps": "Pas",
+		"wd.battery": "Variation de Body Battery",
+		"wd.goal": "Objectif de pas",
+		"wd.floors": "Étages",
+		"w.steps": "Pas quotidiens",
+		"w.hikeVertical": "Vitesse verticale",
+		"hv.vam": "Dénivelé ({unit}) par heure",
+		"w.bikeDetails": "Sorties à vélo",
+		"bd.outdoor": "Extérieur",
+		"bd.indoor": "Intérieur",
+		"bd.rides": "{n} sortie|{n} sorties",
+		"bd.where": "Où",
+		"w.swimDetails": "Séances de natation",
+		"sw.pace": "Allure",
+		"sw.lengths": "Longueurs",
+		"sw.strokes": "Mouvements",
+		"sw.pool": "Piscine",
+		"w.racketDetails": "Séances et intensité",
+		"pd.peak": "FC maximale",
+		"pd.z3": "Temps en Z3+",
+		"pd.z45": "Part Z4-5",
+		"pd.kcal": "kcal par heure",
+		"pd.load": "Charge / course de même durée",
+		"pd.note": "La seconde charge est une estimation : la charge Garmin moyenne par minute de tes courses, multipliée par la durée de la séance.",
+		"col.sport": "Sport",
+		"sport.tennis": "Tennis",
+		"sport.padel": "Padel",
+		"sport.pickleball": "Pickleball",
+		"sport.racquetball": "Racquetball",
+		"sport.squash": "Squash",
+		"sport.badminton": "Badminton",
+		"sport.tableTennis": "Tennis de table",
+		"sport.platformTennis": "Platform tennis"
+	},
+	es: {
+		title: "Entrenamiento + Recuperación",
+		headline: "Carga de entrenamiento, recuperación y progreso desde Garmin Connect",
+		na: "n/d",
+		noData: "Esta página aún no tiene datos. Pide a tu asistente que escriba el panel.",
+		period: "del {from} al {to}",
+		inProgress: "* semana en curso",
+		"menu.settings": "Ajustes",
+		"menu.theme": "Tema",
+		"footer.updated": "Datos de Garmin Connect, actualizados el {date}",
+		"footer.failed": "Días no leídos de Garmin: {n} (sus valores muestran n/d)",
+		"footer.license": "Licencia MIT",
+		"menu.language": "Idioma",
+		"lang.auto": "Automático",
+		"lang.missing": "{language} aún no está en esta página. Pide a tu asistente que añada el idioma.",
+		"themeGroup.auto": "Automático",
+		"themeGroup.dark": "Oscuros",
+		"themeGroup.light": "Claros",
+		"themeGroup.accessible": "Accesibles",
+		"theme.system": "Sistema",
+		"theme.midnight": "Medianoche",
+		"theme.graphite": "Grafito",
+		"theme.ocean": "Océano",
+		"theme.forest": "Bosque",
+		"theme.plum": "Ciruela",
+		"theme.light": "Claro",
+		"theme.paper": "Papel",
+		"theme.mist": "Niebla",
+		"theme.hcDark": "Alto contraste oscuro",
+		"theme.hcLight": "Alto contraste claro",
+		"window.label": "Semanas",
+		"window.last": "Últimas {n}",
+		"window.all": "Todas",
+		"window.from": "Desde la semana",
+		"window.to": "Hasta la semana",
+		"names.label": "Nombres de actividad",
+		"names.all": "Todos",
+		"names.count": "{n} elegido|{n} elegidos",
+		"names.search": "Buscar nombres",
+		"names.noMatch": "Ningún nombre coincide.",
+		"names.remove": "Quitar {name}",
+		"names.clear": "Mostrar todas",
+		"type.all": "Todas",
+		"type.recovery": "Recuperación",
+		"type.running": "Carrera",
+		"type.strengthTraining": "Fuerza",
+		"type.walking": "Caminata",
+		"type.hiking": "Senderismo",
+		"type.cycling": "Bici",
+		"type.swimming": "Natación",
+		"type.racket": "Deportes de raqueta",
+		"type.generic": "Otro",
+		"type.transition": "Transición",
+		"type.fitnessEquipment": "Máquinas de fitness",
+		"type.basketball": "Baloncesto",
+		"type.soccer": "Fútbol",
+		"type.tennis": "Tenis",
+		"type.americanFootball": "Fútbol americano",
+		"type.training": "Entrenamiento",
+		"type.crossCountrySkiing": "Esquí de fondo",
+		"type.alpineSkiing": "Esquí alpino",
+		"type.snowboarding": "Snowboard",
+		"type.rowing": "Remo",
+		"type.mountaineering": "Montañismo",
+		"type.multisport": "Multideporte",
+		"type.paddling": "Remo con pala",
+		"type.flying": "Vuelo",
+		"type.eBiking": "Bici eléctrica",
+		"type.motorcycling": "Motociclismo",
+		"type.boating": "Navegación",
+		"type.driving": "Conducción",
+		"type.golf": "Golf",
+		"type.hangGliding": "Ala delta",
+		"type.horsebackRiding": "Equitación",
+		"type.hunting": "Caza",
+		"type.fishing": "Pesca",
+		"type.inlineSkating": "Patinaje en línea",
+		"type.rockClimbing": "Escalada",
+		"type.sailing": "Vela",
+		"type.iceSkating": "Patinaje sobre hielo",
+		"type.skyDiving": "Paracaidismo",
+		"type.snowshoeing": "Raquetas de nieve",
+		"type.snowmobiling": "Moto de nieve",
+		"type.standUpPaddleboarding": "Stand up paddle",
+		"type.surfing": "Surf",
+		"type.wakeboarding": "Wakeboard",
+		"type.waterSkiing": "Esquí acuático",
+		"type.kayaking": "Kayak",
+		"type.rafting": "Rafting",
+		"type.windsurfing": "Windsurf",
+		"type.kitesurfing": "Kitesurf",
+		"type.tactical": "Táctico",
+		"type.jumpmaster": "Jumpmaster",
+		"type.boxing": "Boxeo",
+		"type.floorClimbing": "Subida de pisos",
+		"type.baseball": "Béisbol",
+		"type.diving": "Buceo",
+		"type.shooting": "Tiro",
+		"type.winterSport": "Deportes de invierno",
+		"type.grinding": "Grinding",
+		"type.hiit": "HIIT",
+		"type.videoGaming": "Videojuegos",
+		"type.wheelchairPushWalk": "Paseo en silla de ruedas",
+		"type.wheelchairPushRun": "Carrera en silla de ruedas",
+		"type.meditation": "Meditación",
+		"type.paraSport": "Deporte adaptado",
+		"type.discGolf": "Disc golf",
+		"type.teamSport": "Deportes de equipo",
+		"type.cricket": "Críquet",
+		"type.rugby": "Rugby",
+		"type.hockey": "Hockey",
+		"type.lacrosse": "Lacrosse",
+		"type.volleyball": "Voleibol",
+		"type.waterTubing": "Tubing",
+		"type.wakesurfing": "Wakesurf",
+		"type.waterSport": "Deportes acuáticos",
+		"type.archery": "Tiro con arco",
+		"type.mixedMartialArts": "Artes marciales mixtas",
+		"type.motorSports": "Deportes de motor",
+		"type.snorkeling": "Snorkel",
+		"type.dance": "Baile",
+		"type.jumpRope": "Salto de cuerda",
+		"type.poolApnea": "Apnea en piscina",
+		"type.mobility": "Movilidad",
+		"type.geocaching": "Geocaching",
+		"type.canoeing": "Canoa",
+		"tabs.label": "Tipos de actividad",
+		"edit.start": "Editar diseño",
+		"edit.done": "Listo",
+		"edit.add": "Añadir widget",
+		"edit.reset": "Restablecer pestaña",
+		"edit.discard": "Descartar",
+		"edit.bar": "Editar diseño",
+		"edit.editing": "Editando · {board}",
+		"edit.unsaved": "Cambios sin guardar",
+		"discard.title": "¿Descartar los cambios?",
+		"discard.text": "El diseño vuelve a como estaba antes de seleccionar Editar diseño, en todas las pestañas.",
+		"discard.keep": "Seguir editando",
+		"discard.confirm": "Descartar cambios",
+		"edit.copy": "Copiar diseño",
+		"edit.hide": "Ocultar {title}",
+		"edit.show": "Mostrar {title}",
+		"edit.remove": "Quitar {title}",
+		"edit.move": "Mover {title}",
+		"edit.moveHint": "Arrastra para mover, o pulsa Espacio y luego las flechas",
+		"edit.width": "Ancho de {title}",
+		"edit.widthValue": "{n} de {cols} columnas",
+		"edit.addHidden": "Añadir widget · {n} ocultos",
+		"add.addOne": "Añadir {title}",
+		"said.picked": "{title} seleccionado, posición {n} de {count}. Las flechas lo mueven, Espacio lo suelta, Escape lo devuelve a su sitio.",
+		"said.position": "Posición {n} de {count}",
+		"said.cancelled": "{title} vuelve a estar en su sitio",
+		"said.moved": "{title} movido a la posición {n} de {count}",
+		"said.width": "{title}: {n} de {cols} columnas",
+		"said.hidden": "{title} oculto",
+		"said.shown": "{title} visible",
+		"said.removed": "{title} quitado",
+		"said.added": "{title} añadido",
+		"said.saved": "Diseño guardado",
+		"said.unchanged": "No hay cambios que guardar",
+		"said.discarded": "Cambios descartados",
+		"stale.label": "Nuevo diseño",
+		"stale.text": "Tu asistente escribió un nuevo diseño para este panel. El diseño que hiciste en este navegador se mantiene hasta que elijas.",
+		"stale.keep": "Mantener el mío",
+		"stale.new": "Usar el nuevo",
+		"stale.used": "El nuevo diseño está en uso",
+		"stale.kept": "Tu diseño está en uso",
+		"add.title": "Añadir un widget",
+		"add.type": "Tipo",
+		"add.add": "Añadir",
+		"add.close": "Cerrar",
+		"add.hiddenGroup": "Ocultos en esta pestaña",
+		"add.none": "Todos los widgets ya están en esta pestaña.",
+		"add.search": "Buscar widgets",
+		"add.noMatch": "Ningún widget coincide.",
+		"copy.title": "Copiar diseño",
+		"copy.hint": "Este diseño solo está guardado en este navegador. Para conservarlo en la página, pega este texto a tu asistente y pídele que guarde el diseño del panel.",
+		"copy.copy": "Copiar",
+		"copy.copied": "Copiado",
+		"board.empty": "Esta pestaña no tiene widgets.",
+		"board.emptyEdit": "Esta pestaña no tiene widgets: usa “Añadir widget” para poner alguno.",
+		"widget.failed": "Este widget falló: {message}",
+		"widget.unknown": "Widget desconocido: {id}",
+		"empty.window": "No hay sesiones en las semanas elegidas.",
+		"w.coachNotes": "Notas del entrenador",
+		"notes.none": "Sin notas.",
+		"notes.disclaimer": "Sugerencias de entrenamiento según los datos hasta el {date}. No es consejo médico.",
+		"w.kpis": "Vista general",
+		"kpi.totals": "{distance} · {time} · {n} sesión|{distance} · {time} · {n} sesiones",
+		"kpi.distance": "Distancia · últimos 7 días",
+		"kpi.time": "Tiempo · últimos 7 días",
+		"kpi.vs4w": "frente a la media de 4 semanas",
+		"delta.good": "mejor",
+		"delta.bad": "peor",
+		"kpi.ratio": "Ratio de carga 7:28",
+		"kpi.band": "Rango 0,8-1,3",
+		"kpi.ratioAll": "Usa todas las actividades, también con un filtro por tipo",
+		"kpi.hrv": "HRV de anoche",
+		"kpi.vsBaseline": "frente a la media de 7 días {v} ms",
+		"w.readiness": "Preparación de hoy",
+		"ready.easy": "Tómatelo con calma",
+		"ready.push": "Listo para exigirte",
+		"ready.normal": "Normal",
+		"ready.hrv": "Estado de HRV",
+		"ready.sleep": "Puntuación del sueño",
+		"ready.rhr": "FC en reposo",
+		"ready.rhrVs": "7 días antes: {avg} bpm",
+		"ready.ratio": "Ratio de carga 7:28",
+		"ready.note": "Una regla propia del panel, no la preparación de Garmin. Muestra hoy: el intervalo de semanas no la cambia.",
+		"w.fitnessAge": "Edad física",
+		"fa.age": "Edad física",
+		"fa.actual": "Edad real",
+		"fa.achievable": "Alcanzable",
+		"fa.details": "Detalles",
+		"fa.component": "Componente",
+		"fa.value": "Ahora",
+		"fa.target": "Objetivo de Garmin",
+		"fa.potential": "Edad potencial",
+		"fa.bodyFat": "Grasa corporal %",
+		"fa.bmi": "IMC",
+		"fa.rhr": "FC en reposo",
+		"fa.vigorousDaysAvg": "Días intensos / semana",
+		"fa.vigorousMinutesAvg": "Minutos intensos / semana",
+		"today.note": "Muestra hoy: el intervalo de semanas no lo cambia.",
+		"w.periodComparison": "Comparación de períodos",
+		"pc.vs": "del {from} al {to} frente al período del {pfrom} al {pto}",
+		"pc.partial": "parcial: estas semanas empiezan antes de los datos",
+		"pc.type": "Tipo",
+		"pc.sessions": "Sesiones",
+		"pc.distance": "Distancia",
+		"pc.time": "Tiempo",
+		"pc.load": "Carga",
+		"pc.total": "Total",
+		"w.records": "Récords",
+		"rec.best": "Mejor {d}",
+		"d.1k": "1 km",
+		"d.mile": "milla",
+		"d.5k": "5 km",
+		"d.10k": "10 km",
+		"d.half": "media maratón",
+		"d.marathon": "maratón",
+		"rec.longestRun": "Carrera más larga",
+		"rec.longestRide": "Salida en bici más larga",
+		"rec.topSet": "Serie más pesada",
+		"rec.e1rm": "Mejor 1RM estimado · {name}",
+		"rec.none": "No hay récords en las semanas elegidas.",
+		"rec.estimate": "Los valores de 1RM son estimaciones (Epley, series de 1-12 repeticiones).",
+		"w.weeklyVolume": "Volumen semanal",
+		"m.time": "Tiempo",
+		"m.distance": "Distancia",
+		"m.sessions": "Sesiones",
+		"m.load": "Carga",
+		"vol.avg": "Media de 4 semanas",
+		"w.intensityMinutes": "Minutos de intensidad",
+		"im.guide": "Recomendación 150 min",
+		"im.note": "Minutos moderados + 2 x intensos solo de las actividades, no de todo el día.",
+		"w.loadSafety": "Seguridad de la carga",
+		"ls.weekLoad": "Carga · últimos 7 días",
+		"ls.monotony": "Monotonía · 7 días",
+		"ls.monotonyFlag": "Por encima de 2,0",
+		"ls.strain": "Strain · 7 días",
+		"ls.flagged": "Semanas por encima de +10%",
+		"ls.load": "Carga semanal",
+		"ls.ramp": "Cambio frente a la semana anterior (%)",
+		"ls.note": "Todas las actividades. Las semanas en rojo subieron más del 10%; una semana en curso no se marca. La monotonía y el strain (Foster) son estimaciones.",
+		"ls.estimated": "Algunas cargas son estimaciones: la actividad no tiene carga de Garmin.",
+		"w.loadVsRecovery": "Carga y recuperación",
+		"lvr.hrv": "HRV (ms)",
+		"lvr.note": "Carga diaria por tipo (barras) y HRV nocturna (línea).",
+		"w.calendar": "Constancia",
+		"cal.minutes": "{n} min",
+		"cal.rest": "Día de descanso",
+		"cal.label": "Días de entrenamiento, por semana; muévete con las flechas",
+		"cal.less": "Menos",
+		"cal.more": "Más",
+		"m.label": "Medida",
+		skip: "Saltar a la pestaña",
+		"w.hrv": "HRV",
+		"hrv.low": "Mínimo del rango",
+		"hrv.band": "Rango equilibrado",
+		"hrv.nightly": "HRV nocturna",
+		"hrv.avg": "Media de 7 días",
+		rec14: "Últimos 14 días: el intervalo de semanas no los cambia.",
+		"rec.board": "Los widgets de recuperación muestran los últimos 14 días: el intervalo de semanas no los cambia.",
+		"w.restingHr": "FC en reposo",
+		"w.sleep": "Sueño",
+		"sl.deep": "Profundo",
+		"sl.light": "Ligero",
+		"sl.rem": "REM",
+		"sl.awake": "Despierto",
+		"sl.score": "Puntuación",
+		"w.sleepNeed": "Necesidad de sueño",
+		"sn.gap": "Por debajo de lo necesario · media",
+		"sn.actual": "Dormido",
+		"sn.need": "Necesario",
+		"w.bedtime": "Hora de acostarse",
+		"bt.spread": "Variación del horario",
+		"w.bodyBattery": "Body Battery",
+		"bb.high": "Máximo",
+		"bb.low": "Mínimo",
+		"w.activities": "Actividades",
+		"col.date": "Fecha",
+		"col.type": "Tipo",
+		"col.name": "Nombre",
+		"col.distance": "Distancia",
+		"col.time": "Tiempo",
+		"col.pace": "Ritmo / velocidad",
+		"col.hr": "FC media",
+		"col.ascent": "Ascenso",
+		"col.race": "Competición",
+		"laps.show": "vueltas",
+		"lap.n": "Vuelta",
+		"lap.intensity": "Intensidad",
+		"act.more": "Mostrar las {n}",
+		"act.less": "Mostrar menos",
+		"one.session": "Solo una sesión por ahora: las tendencias empiezan con 2 sesiones.",
+		"w.typeKpis": "Resumen",
+		"tk.sessions": "Sesiones",
+		"tk.time": "Tiempo",
+		"tk.avg": "{v} por sesión",
+		"tk.distance": "Distancia",
+		"tk.speed": "Velocidad media",
+		"tk.pace": "Ritmo medio",
+		"tk.ascent": "Ascenso",
+		"tk.hr": "FC media",
+		"tk.peak": "Pico {v} bpm",
+		"tk.load": "Carga de entrenamiento de Garmin",
+		"tk.share": "{v}% de toda la carga",
+		"w.typeWeekly": "Cada semana",
+		"w.hrZones": "Tiempo en zonas de FC",
+		"zones.approximate": "Aproximado: algunas actividades no tienen tiempo por zona, así que todos sus minutos cuentan en la zona de su FC media.",
+		"form.cadence": "Cadencia",
+		"form.stride": "Zancada",
+		"form.gct": "Contacto con el suelo",
+		"form.vertOsc": "Oscilación vertical",
+		"form.vertRatio": "Relación vertical",
+		"form.power": "Potencia",
+		"form.normPower": "Potencia normalizada",
+		"w.bestEfforts": "Mejores marcas",
+		"be.distance": "Distancia",
+		"be.activity": "Actividad",
+		"w.races": "Competiciones",
+		"races.none": "No hay competiciones en las semanas elegidas.",
+		"te.aerobic": "TE aeróbico",
+		"te.anaerobic": "TE anaeróbico",
+		"w.aerobicFitness": "Forma aeróbica",
+		"af.runs": "Carreras (las antiguas más claras)",
+		"af.pace": "Ritmo (min{unit})",
+		"af.weekPace": "Ritmo semanal",
+		"af.efficiency": "Eficiencia",
+		"af.effUnit": "m por latido",
+		"w.intensityShare": "Carrera suave e intensa",
+		"is.easy": "Z1-2 (suave)",
+		"is.hard": "Z4-5 (intensa)",
+		"w.runningForm": "Técnica de carrera",
+		"w.runWalk": "Correr y caminar",
+		"rw.none": "No hay sesiones de correr y caminar en las semanas elegidas.",
+		"rw.runPace": "Ritmo de carrera",
+		"rw.pace": "Ritmo total",
+		"rw.walk": "Tiempo caminando",
+		"w.trainingEffect": "Efecto del entrenamiento",
+		"w.racePredictor": "Predicción de carrera",
+		"rp.none": "No hay mejores marcas de 5 km o más en las semanas elegidas.",
+		"rp.note": "Estimación (Riegel) a partir de {d} en {time} ({date}).",
+		"w.longRuns": "Tiradas largas y reparto del ritmo",
+		"lr.share": "Peso de la tirada más larga en la distancia semanal",
+		"lr.ascent": "Ascenso semanal",
+		"lr.note": "Semanas en rojo: la tirada más larga supera el 35% de la distancia de la semana. La tabla muestra las competiciones y las carreras de más de 15 km con vueltas.",
+		"lr.first": "Primera mitad",
+		"lr.second": "Segunda mitad",
+		"lr.split": "Reparto",
+		"lr.gap": "Ritmo ajustado a la pendiente",
+		"lr.positive": "positivo",
+		"lr.negative": "negativo",
+		"lr.even": "regular",
+		"w.setsPerCategory": "Series por movimiento",
+		"ex.sets": "Series completadas",
+		"w.muscleBalance": "Equilibrio de grupos musculares",
+		"mb.pushPull": "Series de empuje : tirón",
+		"mb.avg": "Media de series por semana",
+		"mb.perWeek": "series por semana",
+		"mb.note": "Una serie cuenta 1 por cada grupo muscular principal y 0,5 por cada secundario. Rango habitual: 10-20 series por semana (amarillo por debajo, rojo por encima).",
+		"w.exercises": "Ejercicios",
+		"ex.groups": "Grupos musculares",
+		"ex.search": "Buscar ejercicios",
+		"ex.name": "Ejercicio",
+		"ex.sessions": "Sesiones",
+		"ex.last": "Última",
+		"ex.top": "Última serie máxima",
+		"ex.best": "Mejor 1RM estimado",
+		"ex.change": "Cambio",
+		"ex.trend": "Tendencia",
+		"ex.groupRow": "{n} ejercicio · {sets} series completadas|{n} ejercicios · {sets} series completadas",
+		"ex.reps": "{n} repetición|{n} repeticiones",
+		"ex.rest": "descanso mediano {v}",
+		"ex.weight": "Serie máxima ({unit})",
+		"ex.e1rm": "1RM estimado ({unit})",
+		"ex.volume": "Volumen ({unit})",
+		"ex.maxReps": "Repeticiones máximas",
+		"ex.totalReps": "Repeticiones totales",
+		"ex.longest": "Serie más larga (s)",
+		"ex.restAfter": "descanso {v}",
+		"ex.notDone": "no completada",
+		"w.strengthSessions": "Sesiones",
+		"ss.count": "{n} ejercicio|{n} ejercicios",
+		"mg.chest": "Pecho",
+		"mg.back": "Espalda",
+		"mg.shoulders": "Hombros",
+		"mg.biceps": "Bíceps",
+		"mg.triceps": "Tríceps",
+		"mg.forearms": "Antebrazos",
+		"mg.quads": "Cuádriceps",
+		"mg.hamstrings": "Isquiotibiales",
+		"mg.glutes": "Glúteos",
+		"mg.calves": "Gemelos",
+		"mg.abs": "Abdominales",
+		"mg.hips": "Caderas",
+		"mg.other": "Otro",
+		"w.walkDetails": "Ritmo y caminatas",
+		"wd.steps": "Pasos",
+		"wd.battery": "Cambio de Body Battery",
+		"wd.goal": "Objetivo de pasos",
+		"wd.floors": "Pisos",
+		"w.steps": "Pasos diarios",
+		"w.hikeVertical": "Velocidad vertical",
+		"hv.vam": "Desnivel ({unit}) por hora",
+		"w.bikeDetails": "Salidas en bici",
+		"bd.outdoor": "Exterior",
+		"bd.indoor": "Interior",
+		"bd.rides": "{n} salida|{n} salidas",
+		"bd.where": "Dónde",
+		"w.swimDetails": "Sesiones de natación",
+		"sw.pace": "Ritmo",
+		"sw.lengths": "Largos",
+		"sw.strokes": "Brazadas",
+		"sw.pool": "Piscina",
+		"w.racketDetails": "Sesiones e intensidad",
+		"pd.peak": "FC máxima",
+		"pd.z3": "Tiempo en Z3+",
+		"pd.z45": "Proporción Z4-5",
+		"pd.kcal": "kcal por hora",
+		"pd.load": "Carga / carrera de igual duración",
+		"pd.note": "La segunda carga es una estimación: la carga media de Garmin por minuto de tus carreras, por la duración de la sesión.",
+		"col.sport": "Deporte",
+		"sport.tennis": "Tenis",
+		"sport.padel": "Pádel",
+		"sport.pickleball": "Pickleball",
+		"sport.racquetball": "Ráquetbol",
+		"sport.squash": "Squash",
+		"sport.badminton": "Bádminton",
+		"sport.tableTennis": "Tenis de mesa",
+		"sport.platformTennis": "Platform tennis"
+	},
+	pt: {
+		title: "Treino + Recuperação",
+		headline: "Carga de treino, recuperação e progresso do Garmin Connect",
+		na: "n/d",
+		noData: "Esta página ainda não tem dados. Peça ao seu assistente para escrever o painel.",
+		period: "de {from} a {to}",
+		inProgress: "* semana em andamento",
+		"menu.settings": "Configurações",
+		"menu.theme": "Tema",
+		"footer.updated": "Dados do Garmin Connect, atualizados em {date}",
+		"footer.failed": "Dias não lidos do Garmin: {n} (os valores deles aparecem como n/d)",
+		"footer.license": "Licença MIT",
+		"menu.language": "Idioma",
+		"lang.auto": "Automático",
+		"lang.missing": "{language} ainda não está nesta página. Peça ao seu assistente para adicionar o idioma.",
+		"themeGroup.auto": "Automático",
+		"themeGroup.dark": "Escuros",
+		"themeGroup.light": "Claros",
+		"themeGroup.accessible": "Acessíveis",
+		"theme.system": "Sistema",
+		"theme.midnight": "Meia-noite",
+		"theme.graphite": "Grafite",
+		"theme.ocean": "Oceano",
+		"theme.forest": "Floresta",
+		"theme.plum": "Ameixa",
+		"theme.light": "Claro",
+		"theme.paper": "Papel",
+		"theme.mist": "Névoa",
+		"theme.hcDark": "Alto contraste escuro",
+		"theme.hcLight": "Alto contraste claro",
+		"window.label": "Semanas",
+		"window.last": "Últimas {n}",
+		"window.all": "Todas",
+		"window.from": "Da semana",
+		"window.to": "Até a semana",
+		"names.label": "Nomes das atividades",
+		"names.all": "Todos",
+		"names.count": "{n} escolhido|{n} escolhidos",
+		"names.search": "Pesquisar nomes",
+		"names.noMatch": "Nenhum nome corresponde.",
+		"names.remove": "Remover {name}",
+		"names.clear": "Mostrar todas",
+		"type.all": "Todas",
+		"type.recovery": "Recuperação",
+		"type.running": "Corrida",
+		"type.strengthTraining": "Força",
+		"type.walking": "Caminhada",
+		"type.hiking": "Trilha",
+		"type.cycling": "Ciclismo",
+		"type.swimming": "Natação",
+		"type.racket": "Esportes de raquete",
+		"type.generic": "Outros",
+		"type.transition": "Transição",
+		"type.fitnessEquipment": "Aparelhos de fitness",
+		"type.basketball": "Basquete",
+		"type.soccer": "Futebol",
+		"type.tennis": "Tênis",
+		"type.americanFootball": "Futebol americano",
+		"type.training": "Treino",
+		"type.crossCountrySkiing": "Esqui cross-country",
+		"type.alpineSkiing": "Esqui alpino",
+		"type.snowboarding": "Snowboard",
+		"type.rowing": "Remo",
+		"type.mountaineering": "Montanhismo",
+		"type.multisport": "Multiesporte",
+		"type.paddling": "Remada",
+		"type.flying": "Voo",
+		"type.eBiking": "E-bike",
+		"type.motorcycling": "Motociclismo",
+		"type.boating": "Navegação",
+		"type.driving": "Direção",
+		"type.golf": "Golfe",
+		"type.hangGliding": "Asa-delta",
+		"type.horsebackRiding": "Equitação",
+		"type.hunting": "Caça",
+		"type.fishing": "Pesca",
+		"type.inlineSkating": "Patinação em linha",
+		"type.rockClimbing": "Escalada",
+		"type.sailing": "Vela",
+		"type.iceSkating": "Patinação no gelo",
+		"type.skyDiving": "Paraquedismo",
+		"type.snowshoeing": "Caminhada com raquetes de neve",
+		"type.snowmobiling": "Moto de neve",
+		"type.standUpPaddleboarding": "Stand up paddle",
+		"type.surfing": "Surfe",
+		"type.wakeboarding": "Wakeboard",
+		"type.waterSkiing": "Esqui aquático",
+		"type.kayaking": "Caiaque",
+		"type.rafting": "Rafting",
+		"type.windsurfing": "Windsurf",
+		"type.kitesurfing": "Kitesurf",
+		"type.tactical": "Tático",
+		"type.jumpmaster": "Jumpmaster",
+		"type.boxing": "Boxe",
+		"type.floorClimbing": "Subida de andares",
+		"type.baseball": "Beisebol",
+		"type.diving": "Mergulho",
+		"type.shooting": "Tiro",
+		"type.winterSport": "Esportes de inverno",
+		"type.grinding": "Grinding",
+		"type.hiit": "HIIT",
+		"type.videoGaming": "Videogame",
+		"type.wheelchairPushWalk": "Passeio em cadeira de rodas",
+		"type.wheelchairPushRun": "Corrida em cadeira de rodas",
+		"type.meditation": "Meditação",
+		"type.paraSport": "Esportes paralímpicos",
+		"type.discGolf": "Disc golf",
+		"type.teamSport": "Esportes coletivos",
+		"type.cricket": "Críquete",
+		"type.rugby": "Rúgbi",
+		"type.hockey": "Hóquei",
+		"type.lacrosse": "Lacrosse",
+		"type.volleyball": "Vôlei",
+		"type.waterTubing": "Boia rebocada",
+		"type.wakesurfing": "Wakesurf",
+		"type.waterSport": "Esportes aquáticos",
+		"type.archery": "Tiro com arco",
+		"type.mixedMartialArts": "Artes marciais mistas",
+		"type.motorSports": "Esportes a motor",
+		"type.snorkeling": "Snorkel",
+		"type.dance": "Dança",
+		"type.jumpRope": "Pular corda",
+		"type.poolApnea": "Apneia na piscina",
+		"type.mobility": "Mobilidade",
+		"type.geocaching": "Geocaching",
+		"type.canoeing": "Canoagem",
+		"tabs.label": "Tipos de atividade",
+		"edit.start": "Editar layout",
+		"edit.done": "Concluir",
+		"edit.add": "Adicionar widget",
+		"edit.reset": "Redefinir quadro",
+		"edit.discard": "Descartar",
+		"edit.bar": "Editar layout",
+		"edit.editing": "Editando · {board}",
+		"edit.unsaved": "Alterações não salvas",
+		"discard.title": "Descartar as alterações?",
+		"discard.text": "O layout volta a ser como era antes de você selecionar Editar layout, em todos os quadros.",
+		"discard.keep": "Continuar editando",
+		"discard.confirm": "Descartar alterações",
+		"edit.copy": "Copiar layout",
+		"edit.hide": "Ocultar {title}",
+		"edit.show": "Mostrar {title}",
+		"edit.remove": "Remover {title}",
+		"edit.move": "Mover {title}",
+		"edit.moveHint": "Arraste para mover ou pressione Espaço e depois as teclas de seta",
+		"edit.width": "Largura de {title}",
+		"edit.widthValue": "{n} de {cols} colunas",
+		"edit.addHidden": "Adicionar widget · {n} ocultos",
+		"add.addOne": "Adicionar {title}",
+		"said.picked": "{title} selecionado, posição {n} de {count}. As setas o movem, Espaço o solta, Esc o devolve ao lugar.",
+		"said.position": "Posição {n} de {count}",
+		"said.cancelled": "{title} voltou ao seu lugar",
+		"said.moved": "{title} movido para a posição {n} de {count}",
+		"said.width": "{title}: {n} de {cols} colunas",
+		"said.hidden": "{title} oculto",
+		"said.shown": "{title} visível",
+		"said.removed": "{title} removido",
+		"said.added": "{title} adicionado",
+		"said.saved": "Layout salvo",
+		"said.unchanged": "Nenhuma alteração para salvar",
+		"said.discarded": "Alterações descartadas",
+		"stale.label": "Novo layout",
+		"stale.text": "Seu assistente escreveu um novo layout para este painel. O layout que você fez neste navegador continua até você escolher.",
+		"stale.keep": "Manter o meu",
+		"stale.new": "Usar o novo",
+		"stale.used": "O novo layout está em uso",
+		"stale.kept": "Seu layout está em uso",
+		"add.title": "Adicionar um widget",
+		"add.type": "Tipo",
+		"add.add": "Adicionar",
+		"add.close": "Fechar",
+		"add.hiddenGroup": "Ocultos neste quadro",
+		"add.none": "Todos os widgets já estão neste quadro.",
+		"add.search": "Pesquisar widgets",
+		"add.noMatch": "Nenhum widget corresponde.",
+		"copy.title": "Copiar layout",
+		"copy.hint": "Este layout está salvo apenas neste navegador. Para mantê-lo na página, cole este texto na conversa com o seu assistente e peça que ele salve o layout do painel.",
+		"copy.copy": "Copiar",
+		"copy.copied": "Copiado",
+		"board.empty": "Este quadro não tem widgets.",
+		"board.emptyEdit": "Este quadro não tem widgets: use “Adicionar widget” para colocar alguns.",
+		"widget.failed": "Este widget falhou: {message}",
+		"widget.unknown": "Widget desconhecido: {id}",
+		"empty.window": "Nenhuma sessão nas semanas selecionadas.",
+		"w.coachNotes": "Notas do treinador",
+		"notes.none": "Nenhuma nota.",
+		"notes.disclaimer": "Sugestões de treino para os dados até {date}. Não é aconselhamento médico.",
+		"w.kpis": "Visão geral",
+		"kpi.totals": "{distance} · {time} · {n} sessão|{distance} · {time} · {n} sessões",
+		"kpi.distance": "Distância · últimos 7 dias",
+		"kpi.time": "Tempo · últimos 7 dias",
+		"kpi.vs4w": "em relação à média de 4 semanas",
+		"delta.good": "melhor",
+		"delta.bad": "pior",
+		"kpi.ratio": "Relação de carga 7:28",
+		"kpi.band": "Faixa 0,8-1,3",
+		"kpi.ratioAll": "Usa todas as atividades, mesmo com um filtro de tipo",
+		"kpi.hrv": "HRV da última noite",
+		"kpi.vsBaseline": "em relação à média de 7 dias {v} ms",
+		"w.readiness": "Prontidão de hoje",
+		"ready.easy": "Vá com calma",
+		"ready.push": "Pronto para intensificar",
+		"ready.normal": "Normal",
+		"ready.hrv": "Status de HRV",
+		"ready.sleep": "Pontuação do sono",
+		"ready.rhr": "FC em repouso",
+		"ready.rhrVs": "7 dias antes: {avg} bpm",
+		"ready.ratio": "Relação de carga 7:28",
+		"ready.note": "Uma regra do próprio painel, não a prontidão da Garmin. Mostra hoje: a janela de semanas não a altera.",
+		"w.fitnessAge": "Idade física",
+		"fa.age": "Idade física",
+		"fa.actual": "Idade real",
+		"fa.achievable": "Alcançável",
+		"fa.details": "Detalhes",
+		"fa.component": "Componente",
+		"fa.value": "Agora",
+		"fa.target": "Meta Garmin",
+		"fa.potential": "Idade possível",
+		"fa.bodyFat": "Gordura corporal %",
+		"fa.bmi": "IMC",
+		"fa.rhr": "FC em repouso",
+		"fa.vigorousDaysAvg": "Dias vigorosos / semana",
+		"fa.vigorousMinutesAvg": "Minutos vigorosos / semana",
+		"today.note": "Mostra hoje: a janela de semanas não a altera.",
+		"w.periodComparison": "Comparação de períodos",
+		"pc.vs": "de {from} a {to} comparado com {pfrom} a {pto}",
+		"pc.partial": "parcial: estas semanas começam antes dos dados",
+		"pc.type": "Tipo",
+		"pc.sessions": "Sessões",
+		"pc.distance": "Distância",
+		"pc.time": "Tempo",
+		"pc.load": "Carga",
+		"pc.total": "Total",
+		"w.records": "Recordes",
+		"rec.best": "Melhor tempo · {d}",
+		"d.1k": "1 km",
+		"d.mile": "milha",
+		"d.5k": "5 km",
+		"d.10k": "10 km",
+		"d.half": "meia maratona",
+		"d.marathon": "maratona",
+		"rec.longestRun": "Corrida mais longa",
+		"rec.longestRide": "Pedalada mais longa",
+		"rec.topSet": "Série mais pesada",
+		"rec.e1rm": "Melhor 1RM estimado · {name}",
+		"rec.none": "Nenhum recorde nas semanas selecionadas.",
+		"rec.estimate": "Os valores de 1RM são estimativas (Epley, séries de 1-12 repetições).",
+		"w.weeklyVolume": "Volume semanal",
+		"m.time": "Tempo",
+		"m.distance": "Distância",
+		"m.sessions": "Sessões",
+		"m.load": "Carga",
+		"vol.avg": "Média de 4 semanas",
+		"w.intensityMinutes": "Minutos de intensidade",
+		"im.guide": "Recomendação 150 min",
+		"im.note": "Minutos moderados + 2 x vigorosos só das atividades, não do dia inteiro.",
+		"w.loadSafety": "Segurança da carga",
+		"ls.weekLoad": "Carga · últimos 7 dias",
+		"ls.monotony": "Monotonia · 7 dias",
+		"ls.monotonyFlag": "Acima de 2,0",
+		"ls.strain": "Strain · 7 dias",
+		"ls.flagged": "Semanas acima de +10%",
+		"ls.load": "Carga semanal",
+		"ls.ramp": "Variação em relação à semana anterior (%)",
+		"ls.note": "Todas as atividades. As semanas vermelhas subiram mais de 10%; uma semana em andamento não é sinalizada. Monotonia e strain (Foster) são estimativas.",
+		"ls.estimated": "Algumas cargas são estimativas: a atividade não tem carga Garmin.",
+		"w.loadVsRecovery": "Carga e recuperação",
+		"lvr.hrv": "HRV (ms)",
+		"lvr.note": "Carga diária por tipo (barras) e HRV noturna (linha).",
+		"w.calendar": "Consistência",
+		"cal.minutes": "{n} min",
+		"cal.rest": "Dia de descanso",
+		"cal.label": "Dias de treino, por semana; as teclas de seta movem a seleção",
+		"cal.less": "Menos",
+		"cal.more": "Mais",
+		"m.label": "Medida",
+		skip: "Pular para o quadro",
+		"w.hrv": "HRV",
+		"hrv.low": "Limite inferior da faixa",
+		"hrv.band": "Faixa equilibrada",
+		"hrv.nightly": "HRV noturna",
+		"hrv.avg": "Média de 7 dias",
+		rec14: "Últimos 14 dias: a janela de semanas não os altera.",
+		"rec.board": "Os widgets de recuperação mostram os últimos 14 dias: a janela de semanas não os altera.",
+		"w.restingHr": "FC em repouso",
+		"w.sleep": "Sono",
+		"sl.deep": "Profundo",
+		"sl.light": "Leve",
+		"sl.rem": "REM",
+		"sl.awake": "Acordado",
+		"sl.score": "Pontuação",
+		"w.sleepNeed": "Necessidade de sono",
+		"sn.gap": "Abaixo da necessidade · média",
+		"sn.actual": "Dormido",
+		"sn.need": "Necessidade",
+		"w.bedtime": "Hora de dormir",
+		"bt.spread": "Variação do horário",
+		"w.bodyBattery": "Body Battery",
+		"bb.high": "Máximo",
+		"bb.low": "Mínimo",
+		"w.activities": "Atividades",
+		"col.date": "Data",
+		"col.type": "Tipo",
+		"col.name": "Nome",
+		"col.distance": "Distância",
+		"col.time": "Tempo",
+		"col.pace": "Ritmo / velocidade",
+		"col.hr": "FC média",
+		"col.ascent": "Subida",
+		"col.race": "Prova",
+		"laps.show": "voltas",
+		"lap.n": "Volta",
+		"lap.intensity": "Intensidade",
+		"act.more": "Mostrar todas ({n})",
+		"act.less": "Mostrar menos",
+		"one.session": "Só uma sessão até agora: as tendências começam com 2 sessões.",
+		"w.typeKpis": "Resumo",
+		"tk.sessions": "Sessões",
+		"tk.time": "Tempo",
+		"tk.avg": "{v} por sessão",
+		"tk.distance": "Distância",
+		"tk.speed": "Velocidade média",
+		"tk.pace": "Ritmo médio",
+		"tk.ascent": "Subida",
+		"tk.hr": "FC média",
+		"tk.peak": "Pico {v} bpm",
+		"tk.load": "Carga de treino Garmin",
+		"tk.share": "{v}% de toda a carga",
+		"w.typeWeekly": "Por semana",
+		"w.hrZones": "Tempo nas zonas de FC",
+		"zones.approximate": "Aproximado: algumas atividades não têm tempo por zona, então todos os seus minutos contam na zona da sua FC média.",
+		"form.cadence": "Cadência",
+		"form.stride": "Passada",
+		"form.gct": "Contato com o solo",
+		"form.vertOsc": "Oscilação vertical",
+		"form.vertRatio": "Relação vertical",
+		"form.power": "Potência",
+		"form.normPower": "Potência normalizada",
+		"w.bestEfforts": "Melhores esforços",
+		"be.distance": "Distância",
+		"be.activity": "Atividade",
+		"w.races": "Provas",
+		"races.none": "Nenhuma prova nas semanas selecionadas.",
+		"te.aerobic": "TE aeróbico",
+		"te.anaerobic": "TE anaeróbico",
+		"w.aerobicFitness": "Condicionamento aeróbico",
+		"af.runs": "Corridas (as mais antigas mais claras)",
+		"af.pace": "Ritmo (min{unit})",
+		"af.weekPace": "Ritmo semanal",
+		"af.efficiency": "Eficiência",
+		"af.effUnit": "m por batimento",
+		"w.intensityShare": "Corrida leve e intensa",
+		"is.easy": "Z1-2 (leve)",
+		"is.hard": "Z4-5 (intensa)",
+		"w.runningForm": "Técnica de corrida",
+		"w.runWalk": "Corrida e caminhada",
+		"rw.none": "Nenhuma sessão de corrida e caminhada nas semanas selecionadas.",
+		"rw.runPace": "Ritmo de corrida",
+		"rw.pace": "Ritmo geral",
+		"rw.walk": "Tempo de caminhada",
+		"w.trainingEffect": "Efeito do treino",
+		"w.racePredictor": "Previsão de provas",
+		"rp.none": "Nenhum melhor esforço de 5 km ou mais nas semanas selecionadas.",
+		"rp.note": "Estimativa (Riegel) a partir de {d} em {time}, em {date}.",
+		"w.longRuns": "Corridas longas e divisão do ritmo",
+		"lr.share": "Parte da corrida mais longa na distância semanal",
+		"lr.ascent": "Subida semanal",
+		"lr.note": "Semanas vermelhas: a corrida mais longa passa de 35% da distância da semana. A tabela mostra provas e corridas acima de 15 km com voltas.",
+		"lr.first": "Primeira metade",
+		"lr.second": "Segunda metade",
+		"lr.split": "Divisão",
+		"lr.gap": "Ritmo ajustado à inclinação",
+		"lr.positive": "positiva",
+		"lr.negative": "negativa",
+		"lr.even": "equilibrada",
+		"w.setsPerCategory": "Séries por movimento",
+		"ex.sets": "Séries concluídas",
+		"w.muscleBalance": "Equilíbrio entre grupos musculares",
+		"mb.pushPull": "Séries de empurrar : puxar",
+		"mb.avg": "Média de séries por semana",
+		"mb.perWeek": "séries por semana",
+		"mb.note": "Uma série conta 1 para cada grupo muscular primário e 0,5 para cada secundário. Faixa usual: 10-20 séries por semana (amarelo abaixo, vermelho acima).",
+		"w.exercises": "Exercícios",
+		"ex.groups": "Grupos musculares",
+		"ex.search": "Pesquisar exercícios",
+		"ex.name": "Exercício",
+		"ex.sessions": "Sessões",
+		"ex.last": "Última",
+		"ex.top": "Última série mais pesada",
+		"ex.best": "Melhor 1RM estimado",
+		"ex.change": "Variação",
+		"ex.trend": "Tendência",
+		"ex.groupRow": "{n} exercício · {sets} séries concluídas|{n} exercícios · {sets} séries concluídas",
+		"ex.reps": "{n} repetição|{n} repetições",
+		"ex.rest": "descanso mediano {v}",
+		"ex.weight": "Série mais pesada ({unit})",
+		"ex.e1rm": "1RM estimado ({unit})",
+		"ex.volume": "Volume ({unit})",
+		"ex.maxReps": "Máximo de repetições",
+		"ex.totalReps": "Total de repetições",
+		"ex.longest": "Série mais longa (s)",
+		"ex.restAfter": "descanso {v}",
+		"ex.notDone": "não feita",
+		"w.strengthSessions": "Sessões",
+		"ss.count": "{n} exercício|{n} exercícios",
+		"mg.chest": "Peito",
+		"mg.back": "Costas",
+		"mg.shoulders": "Ombros",
+		"mg.biceps": "Bíceps",
+		"mg.triceps": "Tríceps",
+		"mg.forearms": "Antebraços",
+		"mg.quads": "Quadríceps",
+		"mg.hamstrings": "Posteriores da coxa",
+		"mg.glutes": "Glúteos",
+		"mg.calves": "Panturrilhas",
+		"mg.abs": "Abdominais",
+		"mg.hips": "Quadris",
+		"mg.other": "Outros",
+		"w.walkDetails": "Ritmo e caminhadas",
+		"wd.steps": "Passos",
+		"wd.battery": "Variação do Body Battery",
+		"wd.goal": "Meta de passos",
+		"wd.floors": "Andares",
+		"w.steps": "Passos diários",
+		"w.hikeVertical": "Velocidade vertical",
+		"hv.vam": "Subida ({unit}) por hora",
+		"w.bikeDetails": "Pedaladas",
+		"bd.outdoor": "Ao ar livre",
+		"bd.indoor": "Indoor",
+		"bd.rides": "{n} pedalada|{n} pedaladas",
+		"bd.where": "Onde",
+		"w.swimDetails": "Sessões de natação",
+		"sw.pace": "Ritmo",
+		"sw.lengths": "Comprimentos",
+		"sw.strokes": "Braçadas",
+		"sw.pool": "Piscina",
+		"w.racketDetails": "Sessões e intensidade",
+		"pd.peak": "FC de pico",
+		"pd.z3": "Tempo em Z3+",
+		"pd.z45": "Parte em Z4-5",
+		"pd.kcal": "kcal por hora",
+		"pd.load": "Carga / corrida de mesma duração",
+		"pd.note": "A segunda carga é uma estimativa: a carga Garmin média por minuto das suas corridas, vezes a duração da sessão.",
+		"col.sport": "Esporte",
+		"sport.tennis": "Tênis",
+		"sport.padel": "Padel",
+		"sport.pickleball": "Pickleball",
+		"sport.racquetball": "Raquetebol",
+		"sport.squash": "Squash",
+		"sport.badminton": "Badminton",
+		"sport.tableTennis": "Tênis de mesa",
+		"sport.platformTennis": "Platform tennis"
+	}
+};
+// src/page/i18n/locales/en.json
+var en_default = {
 	title: "Training + Recovery",
 	headline: "Training load, recovery and progress from Garmin Connect",
 	na: "n/a",
@@ -60725,6 +62616,7 @@ const en = {
 	"footer.license": "MIT License",
 	"menu.language": "Language",
 	"lang.auto": "Auto",
+	"lang.missing": "{language} is not in this page yet. Ask your assistant to add it.",
 	"themeGroup.auto": "Auto",
 	"themeGroup.dark": "Dark",
 	"themeGroup.light": "Light",
@@ -60745,6 +62637,13 @@ const en = {
 	"window.all": "All",
 	"window.from": "From week",
 	"window.to": "To week",
+	"names.label": "Activity names",
+	"names.all": "All",
+	"names.count": "{n} chosen|{n} chosen",
+	"names.search": "Search names",
+	"names.noMatch": "No name matches.",
+	"names.remove": "Remove {name}",
+	"names.clear": "Show all",
 	"type.all": "All",
 	"type.recovery": "Recovery",
 	"type.running": "Run",
@@ -60876,6 +62775,8 @@ const en = {
 	"add.close": "Close",
 	"add.hiddenGroup": "Hidden on this board",
 	"add.none": "Every widget is on this board.",
+	"add.search": "Search widgets",
+	"add.noMatch": "No widget matches.",
 	"copy.title": "Copy layout",
 	"copy.hint": "This layout is saved in this browser only. To keep it in the page, paste this text to your assistant and ask it to save the dashboard layout.",
 	"copy.copy": "Copy",
@@ -60889,7 +62790,7 @@ const en = {
 	"notes.none": "No notes.",
 	"notes.disclaimer": "Training suggestions for the data up to {date}. Not medical advice.",
 	"w.kpis": "Overview",
-	"kpi.totals": "{km} km · {time} · {n} session|{km} km · {time} · {n} sessions",
+	"kpi.totals": "{distance} · {time} · {n} session|{distance} · {time} · {n} sessions",
 	"kpi.distance": "Distance · last 7 days",
 	"kpi.time": "Time · last 7 days",
 	"kpi.vs4w": "vs 4-week average",
@@ -61048,7 +62949,7 @@ const en = {
 	"te.anaerobic": "Anaerobic TE",
 	"w.aerobicFitness": "Aerobic fitness",
 	"af.runs": "Runs (older paler)",
-	"af.pace": "Pace (min/km)",
+	"af.pace": "Pace (min{unit})",
 	"af.weekPace": "Weekly pace",
 	"af.efficiency": "Efficiency",
 	"af.effUnit": "m per heartbeat",
@@ -61066,9 +62967,9 @@ const en = {
 	"rp.none": "No best effort of 5 km or more in the selected weeks.",
 	"rp.note": "Estimate (Riegel) from the {d} in {time} on {date}.",
 	"w.longRuns": "Long runs and pace split",
-	"lr.share": "Longest run share of weekly km",
+	"lr.share": "Longest run share of weekly distance",
 	"lr.ascent": "Weekly ascent",
-	"lr.note": "Red weeks: the longest run is more than 35% of the week's km. The table shows races and runs over 15 km with laps.",
+	"lr.note": "Red weeks: the longest run is more than 35% of the week's distance. The table shows races and runs over 15 km with laps.",
 	"lr.first": "First half",
 	"lr.second": "Second half",
 	"lr.split": "Split",
@@ -61096,9 +62997,9 @@ const en = {
 	"ex.groupRow": "{n} exercise · {sets} completed sets|{n} exercises · {sets} completed sets",
 	"ex.reps": "{n} rep|{n} reps",
 	"ex.rest": "median rest {v}",
-	"ex.weight": "Top set (kg)",
-	"ex.e1rm": "Est. 1RM (kg)",
-	"ex.volume": "Volume (kg)",
+	"ex.weight": "Top set ({unit})",
+	"ex.e1rm": "Est. 1RM ({unit})",
+	"ex.volume": "Volume ({unit})",
 	"ex.maxReps": "Max reps",
 	"ex.totalReps": "Total reps",
 	"ex.longest": "Longest set (s)",
@@ -61126,7 +63027,7 @@ const en = {
 	"wd.floors": "Floors",
 	"w.steps": "Daily steps",
 	"w.hikeVertical": "Vertical speed",
-	"hv.vam": "Vertical m per hour",
+	"hv.vam": "Vertical {unit} per hour",
 	"w.bikeDetails": "Rides",
 	"bd.outdoor": "Outdoor",
 	"bd.indoor": "Indoor",
@@ -61376,25 +63277,28 @@ const THEMES = [
 const WIDGET_API = `A custom widget is the body of a JavaScript function (el, ctx). Draw into el. The page runs it like a built-in widget, inside try/catch: an error shows in its tile only.
 
 ctx gives:
-- ctx.data: the getDashboardData result (activities, previousActivities, hrv, recovery, zones, fitnessAge, sync) and notes (plain text).
+- ctx.data: the getDashboardData result (activities, previousActivities, hrv, recovery, zones, fitnessAge, sync, units) and notes (plain text). The data is always metric (km, m, kg, seconds per km); units is the measurement system of the Garmin profile (metric, statute_us or statute_uk).
 - ctx.type: "all" or the board the widget shows: running, strengthTraining, walking, hiking, cycling, swimming, racket, generic (Other), or another SDK sport name such as alpineSkiing. Each activity has type (the Garmin type key) and sport (the SDK sport name).
 - ctx.from, ctx.to: Mondays of the first and last week of the window; ctx.weeks: every Monday in it.
-- ctx.activities: the activities of the window and of ctx.type. ctx.allActivities: every type. ctx.ofType(list): the same type filter for any list.
+- ctx.activities: the activities of the window and of ctx.type. ctx.allActivities: every type. ctx.ofType(list): the same type filter for any list. When the user chooses activity names on the page, ctx.activities and ctx.ofType keep only the activities with those names; ctx.allActivities and ctx.data keep every activity.
 - ctx.t(key, params): a page text; ctx.lang: the page language.
-- ctx.fmt: num(v, digits), pct(v), day("yyyy-MM-dd"), longDay(d), hms(seconds), hours(seconds), na (the text for a missing value).
+- ctx.text(key, params): a text of the widget's own texts in the page language, else in English, with its {placeholders} filled from params.
+- ctx.fmt: num(v, digits), pct(v), day("yyyy-MM-dd"), longDay(d), hms(seconds), hours(seconds), na (the text for a missing value). In the profile's units, from metric data: dist(km, digits), pace(secondsPerKm), speed(kmh), elev(m), mass(kg), swimPace(secondsPer100m). ctx.fmt.to.dist/pace/speed/elev/mass/swim(value) give the number only, for sums and charts; ctx.fmt.unit.dist/pace/speed/elev/mass/swim give the unit names, for axis titles. Show every distance, pace, speed, elevation and weight with these, never with a fixed "km" or "kg".
 - ctx.calc: groupOf(activity) (its board), sportOf(typeKey), seconds("1:02:03"), sessionSeconds(activity), dayOf(activity), mondayOf(day), weekly(activities, weeks, a => value), loadOf(activity, maxHR), loadRatio(activities, day, maxHR), dailyLoads(activities, from, to, maxHR), mean, sd, rolling(values, n), change(now, before), zonesOf(ctx.data.zones), zoneSeconds(activity, floors), paceSeconds(activity), efficiency(activity), epley(kg, reps), riegel(seconds, km, km), exerciseStats(activities), muscleSets(activities, weeks), swimPace(activity), verticalPerHour(activity).
 - ctx.chart(el, config, heightPx): a Chart.js 4 chart that follows the theme, with tooltips. Chart types: bar, line, scatter, doughnut, pie, with the category and linear scales.
 - ctx.color(token): a theme colour: text, muted, accent, good, bad, warn, line, panel, panel2, or a board (running, strengthTraining, walking, hiking, cycling, swimming, racket, generic); another sport gets the generic colour.
 - ctx.empty(el, message): a short message in place of the content.
 
+Texts: give every text that the widget shows in its texts, by language code and key: { en: { title: "...", best: "Best: {value}" }, it: { ... } }. title is the widget's title. Write English and each language of pageLanguages (from editDashboard), with the same keys and {placeholders}. Draw texts with ctx.text(key, params), never as fixed strings in the code. A missing text shows in English.
+
 Rules: build elements with document.createElement and set text with textContent, never innerHTML with data. Use only values in ctx.data; show ctx.fmt.na for a missing value; label an estimate as one. Keep the code short. Requests from the page are blocked: fetch, XMLHttpRequest, and images, scripts and styles from the web.
 
-Example (the longest ride of the window):
+Example (the longest ride of the window), with texts { en: { title: "Longest ride", best: "{distance} on {day}" } }:
 const rides = ctx.activities.filter((a) => ctx.calc.groupOf(a) === "cycling" && typeof a.km === "number");
 if (rides.length === 0) return ctx.empty(el);
 const best = rides.reduce((x, y) => (y.km > x.km ? y : x));
 const p = document.createElement("p");
-p.textContent = \`\${ctx.fmt.num(best.km, 1)} km · \${best.name ?? ""} · \${ctx.fmt.day(best.start.slice(0, 10))}\`;
+p.textContent = ctx.text("best", { distance: ctx.fmt.dist(best.km), day: ctx.fmt.day(best.start.slice(0, 10)) });
 el.append(p);`;
 // src/prompts.ts
 /**
@@ -61424,6 +63328,9 @@ function registerPrompts(server) {
 		const layout = layoutOf(arg(args.layout) === "" ? args.weeks : args.layout);
 		const text = layout === "freeform" ? renderDashboard(freeform, w) : render(renderDashboard(build, w), {
 			layout,
+			title: en_default.title,
+			headline: en_default.headline,
+			builtIn: Object.keys(BUILT_IN).map((code) => `${languageName(code)} (${code})`).join(", "),
 			layoutNote: layout === "blank" ? "\nThe page is an empty grid: tell me to add widgets with \"Edit layout\" and \"Add widget\"." : ""
 		});
 		return result(dashboardDescription, text);
@@ -61472,10 +63379,10 @@ function registerPrompts(server) {
 	}, (args) => result(setupDescription, render(setupPrompt, {
 		weeks: String(weeks(args.weeks)),
 		today: localToday(),
-		title: en.title,
-		headline: en.headline,
+		title: en_default.title,
+		headline: en_default.headline,
 		languages: ["en", ...Object.keys(BUILT_IN)].join(", "),
-		languageNames: ["English", ...Object.keys(BUILT_IN).map(languageName)].join(" and "),
+		languageNames: new Intl.ListFormat("en").format(["English", ...Object.keys(BUILT_IN).map(languageName)]),
 		themes: THEMES.map((t) => t.id).join(", ")
 	})));
 	const languageDescription = "Add a language to the training dashboard (the assistant translates its texts)";
@@ -61557,6 +63464,8 @@ function weeks(v) {
 	if (!/^[+-]?\d+$/.test(s)) return DEFAULT_WEEKS;
 	return Math.min(Math.max(Number(s), 1), MAX_WEEKS);
 }
+/** The user's custom widgets, in the data dir: every page from the template gets them. */
+const LIBRARY_FILE = "widgets.json";
 const MAX_NOTES = 5;
 const REUSE_MS = 9e5;
 const marker = (b) => new RegExp(`/\\*\\s*garmin-${b}:start\\s*\\*/([\\s\\S]*?)/\\*\\s*garmin-${b}:end\\s*\\*/`);
@@ -61632,8 +63541,12 @@ function filterData(data, s) {
 	if (no.has("zones")) delete out.zones;
 	return out;
 }
-/** The built-in languages that the settings choose, by code. */
-const languagesOf = (s) => Object.fromEntries(Object.entries(BUILT_IN).filter(([code]) => !s.languages || s.languages.includes(code)));
+/** The built-in languages that the settings choose, by code; without a choice, the one of the profile locale. */
+function languagesOf(s, locale) {
+	const own = typeof locale === "string" ? [locale, locale.slice(0, 2)] : [];
+	const keep = s.languages ?? [own.find((code) => code in BUILT_IN)];
+	return Object.fromEntries(Object.entries(BUILT_IN).filter(([code]) => keep.includes(code)));
+}
 /**
 * A page from the template with the settings: its settings block, its title, and the CSS of the chosen
 * themes. Only rules for one theme alone go: a rule that lists more selectors is kept as it is.
@@ -61647,11 +63560,13 @@ function styled(page, s) {
 }
 /** The page with the built-in languages and the data that the settings keep, and the escaped notes. */
 function withData(page, data, s, notes) {
-	const next = writeBlock(page, "languages", languagesOf(s));
+	const next = writeBlock(page, "languages", languagesOf(s, data.locale));
 	const kept = s.exclude?.includes("notes") ? [] : notes;
 	return writeBlock(next, "data", {
 		...filterData(data, s),
 		v: 3,
+		server: version,
+		updated: (/* @__PURE__ */ new Date()).toISOString(),
 		notes: kept.map(escapeHtml)
 	});
 }
@@ -61732,13 +63647,14 @@ var DashboardWriter = class {
 		this.#queue = run.catch(() => {});
 		return run;
 	}
-	async #write({ weeks, notes = [], layout, page, path, settings }) {
+	async #write({ weeks, notes = [], layout, page, path, settings, onlyExisting }) {
 		if (layout && page) throw new Error("Give either `layout` (a page from the template) or `page` (your own page), not both");
 		if (page !== void 0 && !marker("data").test(page)) throw new Error("`page` has no /* garmin-data:start */ ... /* garmin-data:end */ block");
 		if (notes.length > MAX_NOTES) throw new Error(`At most ${MAX_NOTES} notes`);
 		const asked = settings === void 0 ? void 0 : checkSettings(settings);
 		const target = this.#target(path);
 		const old = await readExisting(target);
+		if (onlyExisting && old === void 0) throw new Error(`${target} does not exist: make it first with the training-dashboard prompt`);
 		let oldSettings;
 		let unreadable = false;
 		try {
@@ -61773,6 +63689,7 @@ var DashboardWriter = class {
 		}
 		if (Object.keys(own).length > 0 && !marker("settings").test(next)) throw new Error("Settings need a page from the template; this page has no garmin-settings block");
 		if (page === void 0 && next !== old) next = styled(next, own);
+		if (page === void 0) next = await this.#withLibrary(next, old);
 		const raw = JSON.parse(await this.#data(weeks ?? weeksOf(old)));
 		next = withData(next, raw, own, notes);
 		let backup;
@@ -61787,7 +63704,11 @@ var DashboardWriter = class {
 			...backup ? { backup } : {},
 			notes: own.exclude?.includes("notes") ? 0 : notes.length,
 			digest: digest(filterData(raw, own)),
-			...hasLanguages(next) ? { languages: missingTexts(next) } : {}
+			pageLanguages: pageLanguages(next, own),
+			settings: own,
+			...hasLanguages(next) ? { languages: missingTexts(next) } : {},
+			...page === void 0 && missingLanguage(next, raw.locale) ? { missingProfileLanguage: raw.locale } : {},
+			...page === void 0 ? withMissing(widgetGaps(next, pageLanguages(next, own))) : {}
 		};
 	}
 	/** Changes the layout, the custom widgets or the languages of a page from the template; no options only reads. */
@@ -61803,6 +63724,7 @@ var DashboardWriter = class {
 		let page = old;
 		let layout;
 		let widgets;
+		let library;
 		let texts;
 		let settings;
 		try {
@@ -61815,6 +63737,8 @@ var DashboardWriter = class {
 		} catch (e) {
 			throw new Error(`${e.message} in ${target}`, { cause: e });
 		}
+		library = await this.#library(widgets);
+		widgets = merged(widgets, library);
 		let layoutChanged = false;
 		if (o.layout !== void 0) {
 			layout = parseLayout(o.layout);
@@ -61823,8 +63747,26 @@ var DashboardWriter = class {
 		for (const w of o.widgets ?? []) {
 			const clean = checkWidget(w);
 			widgets = [...widgets.filter((x) => x.id !== clean.id), clean];
+			library = [...library.filter((x) => x.id !== clean.id), clean];
+		}
+		for (const [id, byLang] of Object.entries(o.widgetTexts ?? {})) {
+			const w = widgets.find((x) => x.id === id);
+			if (!w) throw new Error(`Unknown custom widget ${id}`);
+			const own = { ...w.texts };
+			for (const [lang, entries] of Object.entries(byLang)) own[lang] = {
+				...own[lang],
+				...entries
+			};
+			const clean = checkWidget({
+				...w,
+				texts: own
+			});
+			widgets = widgets.map((x) => x.id === id ? clean : x);
+			library = library.map((x) => x.id === id ? clean : x);
 		}
-		for (const id of o.removeWidgets ?? []) {
+		const forget = new Set(o.forgetWidgets);
+		library = library.filter((x) => !forget.has(x.id));
+		for (const id of [...o.removeWidgets ?? [], ...forget]) {
 			widgets = widgets.filter((x) => x.id !== id);
 			for (const [board, list] of Object.entries(layout.boards)) if (list.some((i) => i.widget === id)) {
 				layout = withBoard(layout, board, list.filter((i) => i.widget !== id));
@@ -61851,7 +63793,8 @@ var DashboardWriter = class {
 			if (!Object.hasOwn(texts, lang)) throw new Error(`The page has no added texts for ${lang}: built-in languages are chosen with writeDashboard settings.languages`);
 			delete texts[lang];
 		}
-		const changed = layoutChanged || o.widgets !== void 0 || o.removeWidgets !== void 0 || o.languages !== void 0 || o.removeLanguages !== void 0;
+		const changed = layoutChanged || o.widgets !== void 0 || o.removeWidgets !== void 0 || o.forgetWidgets !== void 0 || o.widgetTexts !== void 0 || o.languages !== void 0 || o.removeLanguages !== void 0;
+		if (o.widgets !== void 0 || o.forgetWidgets !== void 0 || o.widgetTexts !== void 0) await this.#saveLibrary(library);
 		if (changed) {
 			if (layoutChanged) layout = {
 				...layout,
@@ -61866,24 +63809,59 @@ var DashboardWriter = class {
 			path: target,
 			changed,
 			layout,
-			customWidgets: widgets.map(({ id, title, span, types }) => ({
-				id,
-				title,
-				span: span ?? 1,
-				...types ? { types } : {}
+			customWidgets: widgets.map((w) => ({
+				id: w.id,
+				title: w.title,
+				span: spanOf(w.span),
+				...w.types ? { types: w.types } : {},
+				...w.texts ? { texts: w.texts } : {},
+				library: library.some((l) => l.id === w.id)
 			})),
+			pageLanguages: pageLanguages(page, settings),
 			languages: missingTexts(page),
 			catalogue: CATALOGUE.filter((c) => !c.needs || !settings.exclude?.includes(c.needs)).map((c) => ({
 				id: c.id,
-				title: en[c.title],
+				title: en_default[c.title],
 				...c.types ? { types: c.types } : {},
 				span: c.span,
 				about: ABOUT[c.id]
 			})),
 			widgetApi: WIDGET_API,
-			...o.englishTexts ? { englishTexts: en } : {}
+			...o.englishTexts ? { englishTexts: en_default } : {}
 		};
 	}
+	/**
+	* The widget library. Without a library file, the first page that has custom widgets starts it, so
+	* the widgets made before the library existed join it.
+	*/
+	async #library(seed) {
+		const file = resolve(this.dataDir, LIBRARY_FILE);
+		let text;
+		try {
+			text = await readFile(file, "utf8");
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			if (seed.length > 0) await this.#saveLibrary(seed);
+			return seed;
+		}
+		try {
+			const list = JSON.parse(text);
+			if (!Array.isArray(list)) throw new Error("not a list of widgets");
+			return list.map((w) => checkWidget(w));
+		} catch (e) {
+			throw new Error(`${file}: ${e.message}; correct or delete the file`, { cause: e });
+		}
+	}
+	#saveLibrary(widgets) {
+		return writeAtomically(resolve(this.dataDir, LIBRARY_FILE), `${JSON.stringify(widgets, null, 2)}\n`);
+	}
+	/** The page with the library in its widgets block; `old` is the page that it replaces, to start the library. */
+	async #withLibrary(page, old) {
+		if (!marker("widgets").test(page)) return page;
+		const own = readBlock(page, "widgets") ?? [];
+		const before = old === void 0 ? [] : readBlock(old, "widgets") ?? [];
+		return writeBlock(page, "widgets", merged(own, await this.#library(before)));
+	}
 	/** The data for `weeks`; the same snapshot for 15 minutes, so the notes match the digest they come from. */
 	async #data(weeks) {
 		const covered = weeksCovered(weeks);
@@ -61899,11 +63877,15 @@ var DashboardWriter = class {
 	}
 	/** The page file: relative paths sit in the data dir; only .html files. */
 	#target(path) {
-		const target = resolve(this.dataDir, (path ?? "garmin-dashboard.html").replace(/^~(?=$|[/\\])/, homedir()));
-		if (!/\.html$/i.test(target)) throw new Error(`The dashboard must be an .html file: ${target}`);
-		return target;
+		return pageTarget(this.dataDir, path);
 	}
 };
+/** The absolute page file: a relative path is inside the data dir; only .html files. */
+function pageTarget(dataDir, path) {
+	const target = resolve(dataDir, (path || "garmin-dashboard.html").replace(/^~(?=$|[/\\])/, homedir()));
+	if (!/\.html$/i.test(target)) throw new Error(`The dashboard must be an .html file: ${target}`);
+	return target;
+}
 /** The boards: All, Recovery, the type boards, and a board for any other SDK sport. */
 const TYPES = /* @__PURE__ */ new Set([
 	"all",
@@ -61912,6 +63894,8 @@ const TYPES = /* @__PURE__ */ new Set([
 	...Object.values(Profile.types.sport)
 ]);
 const spanOf = (v) => Math.min(3, Math.max(1, Math.round(Number(v) || 1)));
+/** The page's custom widgets and the library; the library version wins on the same id. */
+const merged = (own, library) => [...own.filter((w) => !library.some((l) => l.id === w.id)), ...library];
 /** A custom widget that the page can run; throws with what is wrong. */
 function checkWidget(w) {
 	if (CATALOGUE.some((c) => c.id === w.id)) throw new Error(`${w.id} is a built-in widget: give the custom widget another id`);
@@ -61920,22 +63904,49 @@ function checkWidget(w) {
 	if (!w.code?.trim() || w.code.length > 2e4) throw new Error("A widget needs code, at most 20000 characters");
 	const unknown = (w.types ?? []).filter((t) => !TYPES.has(t));
 	if (unknown.length > 0) throw new Error(`Unknown widget types: ${unknown.join(", ")}`);
+	const texts = checkWidgetTexts(w);
 	return {
 		id: w.id,
 		title: w.title.trim(),
 		code: w.code,
 		span: spanOf(w.span),
-		...w.types?.length ? { types: w.types } : {}
+		...w.types?.length ? { types: w.types } : {},
+		...texts ? { texts } : {}
 	};
 }
+/** The texts of a custom widget: language codes, short keys, and the placeholders of the English text. */
+function checkWidgetTexts(w) {
+	const texts = w.texts;
+	if (texts === void 0 || Object.keys(texts).length === 0) return void 0;
+	if (JSON.stringify(texts).length > 2e4) throw new Error(`The texts of ${w.id} are too long: at most 20000 characters`);
+	const problems = [];
+	for (const [lang, entries] of Object.entries(texts)) {
+		if (!/^[a-z]{2,3}(-[A-Z]{2})?$/.test(lang)) {
+			problems.push(`bad language code ${lang}`);
+			continue;
+		}
+		if (!entries || typeof entries !== "object" || Array.isArray(entries)) {
+			problems.push(`${lang}: texts by key`);
+			continue;
+		}
+		for (const [key, text] of Object.entries(entries)) {
+			const english = texts.en?.[key];
+			if (!/^[a-zA-Z][\w.-]{0,40}$/.test(key)) problems.push(`bad key ${key}`);
+			else if (typeof text !== "string" || !text.trim() || text.length > 500) problems.push(`${lang}.${key}: 1 to 500 characters`);
+			else if (english !== void 0 && placeholders(text) !== placeholders(english)) problems.push(`${lang}.${key}: keep the placeholders ${placeholders(english) || "(none)"}`);
+		}
+	}
+	if (problems.length > 0) throw new Error(`Texts of ${w.id}: ${problems.join("; ")}`);
+	return texts;
+}
 const placeholders = (s) => [...new Set(s.match(/\{\w+\}/g) ?? [])].toSorted().join(" ");
 /** Texts of a language: known keys only, strings, with the placeholders of the English text. */
 function checkTexts(lang, entries) {
 	if (!/^[a-z]{2,3}(-[A-Z]{2})?$/.test(lang)) throw new Error(`Bad language code ${lang}: use a code such as de, fr or pt-BR`);
 	const problems = [];
-	for (const [key, text] of Object.entries(entries)) if (!Object.hasOwn(en, key)) problems.push(`unknown text ${key}`);
+	for (const [key, text] of Object.entries(entries)) if (!Object.hasOwn(en_default, key)) problems.push(`unknown text ${key}`);
 	else if (typeof text !== "string" || !text.trim() || text.length > 500) problems.push(`${key}: 1 to 500 characters`);
-	else if (placeholders(text) !== placeholders(en[key])) problems.push(`${key}: keep the placeholders ${placeholders(en[key]) || "(none)"}`);
+	else if (placeholders(text) !== placeholders(en_default[key])) problems.push(`${key}: keep the placeholders ${placeholders(en_default[key]) || "(none)"}`);
 	if (problems.length > 0) throw new Error(`Texts of ${lang}: ${problems.join("; ")}`);
 	return entries;
 }
@@ -61943,10 +63954,43 @@ function hasLanguages(page) {
 	const t = readBlock(page, "i18n");
 	return !!t && typeof t === "object" && Object.keys(t).length > 0;
 }
+/** English unless the settings leave it out, then the built-in and the added languages of the page. */
+function pageLanguages(page, s) {
+	const codes = [
+		...s.languages && !s.languages.includes("en") ? [] : ["en"],
+		...Object.keys(readBlock(page, "languages") ?? {}),
+		...Object.keys(readBlock(page, "i18n") ?? {})
+	];
+	return [...new Set(codes)];
+}
+/**
+* For each custom widget with texts, the page languages it has no texts in. A widget without texts
+* (written before widgets had them) shows fixed text, so there is nothing to add.
+*/
+function widgetGaps(page, languages) {
+	const out = {};
+	for (const w of readBlock(page, "widgets") ?? []) {
+		if (!w.texts) continue;
+		const gaps = languages.filter((code) => !w.texts[code] && !w.texts[code.slice(0, 2)]);
+		if (gaps.length > 0) out[w.id] = gaps;
+	}
+	return out;
+}
+const withMissing = (gaps) => Object.keys(gaps).length > 0 ? { missingWidgetTexts: gaps } : {};
+/** True when the profile locale is not English, not built in and not added to the page. */
+function missingLanguage(page, locale) {
+	if (typeof locale !== "string" || !locale) return false;
+	const known = [
+		"en",
+		...Object.keys(BUILT_IN),
+		...Object.keys(readBlock(page, "i18n") ?? {})
+	];
+	return ![locale, locale.slice(0, 2)].some((code) => known.includes(code));
+}
 /** For each language of the page, the keys that it does not translate. */
 function missingTexts(page) {
 	const t = readBlock(page, "i18n") ?? {};
-	return Object.fromEntries(Object.entries(t).map(([lang, texts]) => [lang, { missing: Object.keys(en).filter((k) => !(k in texts)) }]));
+	return Object.fromEntries(Object.entries(t).map(([lang, texts]) => [lang, { missing: Object.keys(en_default).filter((k) => !(k in texts)) }]));
 }
 /** The page at `target`, or undefined when there is none; refuses a file that is not a dashboard. */
 async function readExisting(target) {
@@ -61963,13 +64007,20 @@ function registerDashboardWriter(server, writer) {
 			"last `weeks` weeks, and returns its path and a short digest of the data (totals, weekly sums, load,",
 			"best efforts, races, strength top sets, HRV, recovery, fitness age, sync) for the coach notes.",
 			"An existing page keeps all its code, layout and widgets: only its data is replaced. A page from an",
-			"older template gets the new template and keeps its layout and widgets. `layout` writes a new page",
+			"older template gets the new template and keeps its layout and widgets. Every page from the template",
+			"also gets the custom widgets of the widget library (<data-dir>/widgets.json), not placed on a board.",
+			"`layout` writes a new page",
 			"from the template: `preset` (the default widgets) or `blank` (empty boards). `page` writes your own",
 			"page code instead; it must contain /* garmin-data:start */null/* garmin-data:end */. A replaced",
 			"page is kept as <file>.bak. `notes`: at most 5 plain-text coach notes; the server escapes them.",
 			"`settings` replace the page's settings (title, headline, sports, data to leave out, languages,",
 			"themes); without them the page keeps its own. The page holds only the data, languages and themes",
-			"they keep. `preview: true` writes nothing: it returns the digest and the activities of each board."
+			"they keep. `pageLanguages` in the result lists the languages of the page's Language menu, and",
+			"`settings` the settings that the page keeps. `missingProfileLanguage` is the language of the Garmin",
+			"profile when the page has no texts in it (it shows English); editDashboard `languages` adds it.",
+			"`missingWidgetTexts` lists the custom widgets that miss texts in a language of the page, with",
+			"those languages; editDashboard `widgetTexts` adds them.",
+			"`preview: true` writes nothing: it returns the digest and the activities of each board."
 		].join("\n"),
 		inputSchema: object({
 			weeks: number$1().int().describe("Weeks to cover, default 12, max 52").optional(),
@@ -61982,7 +64033,7 @@ function registerDashboardWriter(server, writer) {
 				headline: string().describe("A line under the title").optional(),
 				sports: array(string()).describe("The boards to keep, e.g. running, cycling; all when not set").optional(),
 				exclude: array(_enum(DATA_ITEMS)).describe("The data to leave out of the page").optional(),
-				languages: array(string()).describe(`Languages to keep: en, ${Object.keys(BUILT_IN).join(", ")}`).optional(),
+				languages: array(string()).describe(`Languages to keep: en, ${Object.keys(BUILT_IN).join(", ")}; when not set, English and the language of the Garmin profile`).optional(),
 				language: string().describe("Default language: auto or a code").optional(),
 				themes: array(string()).describe(`Themes to keep: ${THEMES.map((t) => t.id).join(", ")}`).optional(),
 				theme: string().describe("Default theme").optional()
@@ -62000,7 +64051,10 @@ function registerDashboardWriter(server, writer) {
 			"custom widgets, the missing texts of each language, the catalogue of built-in widgets and `widgetApi`,",
 			"the guide to writing a custom widget. `layout` replaces the whole layout (the text of the page's",
 			"'Copy layout'); `place` adds widgets at the end of a board; `widgets` adds or replaces custom widgets",
-			"by id; `removeWidgets` removes them, also from the boards. `languages` adds texts by key, e.g.",
+			"by id and saves them in the widget library (<data-dir>/widgets.json), which every page from the",
+			"template gets; `removeWidgets` removes them from this page and its boards, `forgetWidgets` also",
+			"from the library. `widgetTexts` adds texts to custom widgets by id, language and key, e.g.",
+			"{\"longest-ride\": {\"de\": {\"title\": \"Längste Fahrt\"}}}. `languages` adds page texts by key, e.g.",
 			"{\"de\": {\"title\": \"Training + Erholung\"}}: keys and {placeholders} as in `englishTexts: true`; a",
 			"text with \"|\" has a singular and a plural form. Missing texts show in English.",
 			"`removeLanguages` removes languages that `languages` added."
@@ -62018,9 +64072,12 @@ function registerDashboardWriter(server, writer) {
 				title: string(),
 				code: string().describe("The body of a function (el, ctx): see widgetApi"),
 				span: number$1().int().optional(),
-				types: array(string()).describe("Types the widget can show").optional()
+				types: array(string()).describe("Types the widget can show").optional(),
+				texts: record(string(), record(string(), string())).describe("Texts by language code and key; title is the title: see widgetApi").optional()
 			})).optional(),
-			removeWidgets: array(string()).describe("Ids of custom widgets").optional(),
+			removeWidgets: array(string()).describe("Ids of custom widgets to remove from this page").optional(),
+			forgetWidgets: array(string()).describe("Ids of custom widgets to remove from the library and from this page").optional(),
+			widgetTexts: record(string(), record(string(), record(string(), string()))).describe("Texts of custom widgets by widget id, language code and key").optional(),
 			languages: record(string(), record(string(), string())).describe("Texts by language code and key").optional(),
 			removeLanguages: array(string()).describe("Codes of added languages, e.g. de").optional(),
 			englishTexts: boolean().describe("Also return the English texts to translate").optional(),
@@ -62031,24 +64088,584 @@ function registerDashboardWriter(server, writer) {
 		text: JSON.stringify(await writer.edit(a))
 	}] }));
 }
+// src/schedule.ts
+/**
+* The automatic refresh of dashboard pages: one job in the scheduler of the operating system (launchd,
+* cron or Task Scheduler) runs `refresh --auto`, which updates the pages listed in
+* `<data-dir>/auto-refresh.json`. Nothing is installed until the user asks.
+*/
+const DAYS = [
+	"sunday",
+	"monday",
+	"tuesday",
+	"wednesday",
+	"thursday",
+	"friday",
+	"saturday"
+];
+const MONTHS = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+/** Garmin gets about 8 requests per refresh: two runs must be at least this far apart. */
+const MIN_GAP_MINUTES = 60;
+/** Runs a command without a shell; its output never reaches our stdout. */
+const run = (cmd, args, input) => new Promise((ok, fail) => {
+	const p = spawn(cmd, args, { stdio: "pipe" });
+	let stdout = "";
+	let stderr = "";
+	p.stdout.on("data", (d) => stdout += d);
+	p.stderr.on("data", (d) => stderr += d);
+	p.on("error", fail);
+	p.on("close", (code) => ok({
+		code: code ?? 1,
+		stdout,
+		stderr
+	}));
+	p.stdin.end(input ?? "");
+});
+const STATE_FILE = "auto-refresh.json";
+const DEFAULT_CRON = "0 7 * * *";
+const LABEL = "com.indaco.garmin-personal-mcp.refresh";
+const TASK = "garmin-personal-mcp refresh";
+const MARK = "# garmin-personal-mcp refresh";
+const FIELDS = [
+	[
+		"minute",
+		0,
+		59
+	],
+	[
+		"hour",
+		0,
+		23
+	],
+	[
+		"day of month",
+		1,
+		31
+	],
+	[
+		"month",
+		1,
+		12
+	],
+	[
+		"weekday",
+		0,
+		7
+	]
+];
+/** One cron field: *, n, a-b, with an optional /step, separated by commas. */
+function field(text, [label, min, max]) {
+	const values = /* @__PURE__ */ new Set();
+	for (const part of text.split(",")) {
+		const m = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
+		const from = m?.[2] === void 0 ? min : Number(m[2]);
+		const to = m?.[3] !== void 0 ? Number(m[3]) : m?.[2] === void 0 || m[4] ? max : from;
+		const step = m?.[4] === void 0 ? 1 : Number(m[4]);
+		if (!m || from < min || to > max || from > to || step < 1) throw new Error(`Cron ${label}: "${part}" is not ${min}-${max}, a list, a range or a /step`);
+		for (let v = from; v <= to; v += step) values.add(label === "weekday" && v === 7 ? 0 : v);
+	}
+	return [...values].toSorted((a, b) => a - b);
+}
+/** Reads and checks a cron expression: numbers only, and at least an hour between two runs. */
+function parseCron(text) {
+	const parts = text.trim().split(/\s+/);
+	if (parts.length !== 5) throw new Error(`Cron: 5 fields, minute hour day-of-month month weekday (0 = Sunday), e.g. "0 7 * * 1"`);
+	const [minutes, hours, days, months, weekdays] = parts.map((p, i) => field(p, FIELDS[i]));
+	const times = hours.flatMap((h) => minutes.map((m) => h * 60 + m)).toSorted((a, b) => a - b);
+	const gaps = times.map((t, i) => (i === 0 ? t + 1440 : t) - times[(i || times.length) - 1]);
+	if (times.length > 1 && Math.min(...gaps) < MIN_GAP_MINUTES) throw new Error("Cron: the runs must be at least 1 hour apart");
+	const cron = {
+		text: parts.join(" "),
+		times,
+		...parts[2].startsWith("*") ? {} : { days },
+		...parts[3].startsWith("*") ? {} : { months },
+		...parts[4].startsWith("*") ? {} : { weekdays }
+	};
+	if (nextRuns(cron, /* @__PURE__ */ new Date(), 1).length === 0) throw new Error("Cron: this date never comes");
+	return cron;
+}
+/** The CLI forms: daily [HH:MM], weekdays [HH:MM], weekly <day> [HH:MM], or a cron expression. */
+function cronOf(words) {
+	if (words.length === 1 && words[0].trim().includes(" ")) return words[0];
+	const [kind, ...rest] = words.map((w) => w.toLowerCase());
+	const day = kind === "weekly" && rest[0] && !rest[0].includes(":") ? DAYS.indexOf(rest.shift()) : 1;
+	const m = /^([01]?\d|2[0-3]):([0-5]\d)$/.exec(rest[0] ?? "07:00");
+	const weekday = {
+		daily: "*",
+		weekdays: "1-5",
+		weekly: String(day)
+	}[kind ?? ""];
+	if (!weekday || !m || rest.length > 1 || day < 0) throw new Error("Schedule: daily [HH:MM], weekdays [HH:MM], weekly <day> [HH:MM] or a cron expression in quotes, e.g. \"0 7 * * 1\"");
+	return `${Number(m[2])} ${Number(m[1])} * * ${weekday}`;
+}
+/** Whether the job runs on that day. */
+function runsOn(c, d) {
+	if (c.months && !c.months.includes(d.getMonth() + 1)) return false;
+	if (c.days && c.weekdays) return c.days.includes(d.getDate()) || c.weekdays.includes(d.getDay());
+	if (c.days) return c.days.includes(d.getDate());
+	return c.weekdays?.includes(d.getDay()) ?? true;
+}
+const pad = (n) => String(n).padStart(2, "0");
+/** The next `count` runs after `from`, as local "YYYY-MM-DD HH:MM"; empty when the date never comes. */
+function nextRuns(c, from, count) {
+	const runs = [];
+	for (let i = 0; i < 2928 && runs.length < count; i++) {
+		const d = new Date(from.getFullYear(), from.getMonth(), from.getDate() + i);
+		if (!runsOn(c, d)) continue;
+		for (const t of c.times) {
+			const at = new Date(d.getFullYear(), d.getMonth(), d.getDate(), Math.floor(t / 60), t % 60);
+			if (at > from && runs.length < count) runs.push(`${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())} ${pad(at.getHours())}:${pad(at.getMinutes())}`);
+		}
+	}
+	return runs;
+}
+const xml = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+/** launchd has no cron syntax: each run time is a dict, and a run matches any dict of the array. */
+function calendar(c) {
+	const months = c.months ?? [void 0];
+	const days = c.days || c.weekdays ? [...(c.days ?? []).map((d) => ({ Day: d })), ...(c.weekdays ?? []).map((w) => ({ Weekday: w }))] : [{}];
+	return c.times.flatMap((t) => months.flatMap((m) => days.map((d) => ({
+		...m === void 0 ? {} : { Month: m },
+		...d,
+		Hour: Math.floor(t / 60),
+		Minute: t % 60
+	}))));
+}
+function plist(job, c) {
+	const when = calendar(c).map((e) => `    <dict>${Object.entries(e).map(([k, v]) => `<key>${k}</key><integer>${v}</integer>`).join("")}</dict>`);
+	const strings = (xs) => xs.map((x) => `    <string>${xml(x)}</string>`).join("\n");
+	const env = Object.entries(job.env).map(([k, v]) => `    <key>${k}</key><string>${xml(v)}</string>`).join("\n");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${strings([job.program, ...job.args])}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${env}
+  </dict>
+  <key>StartCalendarInterval</key>
+  <array>
+${when.join("\n")}
+  </array>
+  <key>StandardOutPath</key><string>${xml(job.log)}</string>
+  <key>StandardErrorPath</key><string>${xml(job.log)}</string>
+</dict>
+</plist>
+`;
+}
+const sh = (s) => `'${s.replaceAll("'", `'\\''`)}'`;
+/** The crontab line; % is a newline for cron, so it is escaped. */
+function cronLine(job, c) {
+	const command = [
+		...Object.entries(job.env).map(([k, v]) => `${k}=${sh(v)}`),
+		sh(job.program),
+		...job.args.map(sh),
+		">>",
+		sh(job.log),
+		"2>&1"
+	].join(" ");
+	return `${c.text} ${command.replaceAll("%", "\\%")} ${MARK}`;
+}
+/** The crontab with our line replaced (or removed when `line` is undefined); other lines stay. */
+function withCronLine(crontab, line) {
+	return [...crontab.split("\n").filter((l) => l.trim() !== "" && !l.endsWith(MARK)), ...line ? [line] : []].map((l) => `${l}\n`).join("");
+}
+/** The .cmd file the Windows task runs. */
+function windowsScript(job) {
+	const env = Object.entries(job.env).map(([k, v]) => k === "PATH" ? `set "PATH=${v};%PATH%"` : `set "${k}=${v}"`);
+	const command = [job.program, ...job.args].map((a) => `"${a}"`).join(" ");
+	return [
+		"@echo off",
+		...env,
+		`call ${command} >> "${job.log}" 2>&1`,
+		""
+	].join("\r\n");
+}
+const tags = (names) => names.map((n) => `<${n} />`).join("");
+/**
+* The Task Scheduler task: schtasks /SC cannot say most cron schedules, so each run time is a calendar
+* trigger. StartWhenAvailable runs a time that the computer missed, as launchd does.
+*/
+function taskXml(script, c) {
+	const months = `<Months>${tags((c.months ?? MONTHS.map((_, i) => i + 1)).map((m) => MONTHS[m - 1]))}</Months>`;
+	const weekdays = c.weekdays ? `<DaysOfWeek>${tags(c.weekdays.map((w) => DAYS[w][0].toUpperCase() + DAYS[w].slice(1)))}</DaysOfWeek>` : "";
+	const byMonth = (days) => `<ScheduleByMonth><DaysOfMonth>${days.map((d) => `<Day>${d}</Day>`).join("")}</DaysOfMonth>${months}</ScheduleByMonth>`;
+	const schedules = [
+		...c.days ? [byMonth(c.days)] : [],
+		...c.weekdays ? [c.months ? `<ScheduleByMonthDayOfWeek><Weeks><Week>1</Week><Week>2</Week><Week>3</Week><Week>4</Week><Week>Last</Week></Weeks>${weekdays}${months}</ScheduleByMonthDayOfWeek>` : `<ScheduleByWeek><WeeksInterval>1</WeeksInterval>${weekdays}</ScheduleByWeek>`] : [],
+		...c.days || c.weekdays ? [] : [c.months ? byMonth(Array.from({ length: 31 }, (_, i) => i + 1)) : "<ScheduleByDay><DaysInterval>1</DaysInterval></ScheduleByDay>"]
+	];
+	const triggers = c.times.flatMap((t) => schedules.map((s) => `    <CalendarTrigger><StartBoundary>2026-01-01T${pad(Math.floor(t / 60))}:${pad(t % 60)}:00</StartBoundary>${s}</CalendarTrigger>`));
+	return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo><Description>Updates the Garmin dashboard pages (${xml(c.text)})</Description></RegistrationInfo>
+  <Triggers>
+${triggers.join("\n")}
+  </Triggers>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <ExecutionTimeLimit>PT1H</ExecutionTimeLimit>
+  </Settings>
+  <Actions><Exec><Command>${xml(script)}</Command></Exec></Actions>
+</Task>
+`;
+}
+var AutoRefresh = class {
+	config;
+	platform;
+	home;
+	exec;
+	nodeDir;
+	entry;
+	constructor(config, platform = process.platform, home = homedir(), exec = run, nodeDir = dirname(process.execPath), entry = realEntry(process.argv[1])) {
+		this.config = config;
+		this.platform = platform;
+		this.home = home;
+		this.exec = exec;
+		this.nodeDir = nodeDir;
+		this.entry = entry;
+	}
+	get #stateFile() {
+		return join(this.config.dataDir, STATE_FILE);
+	}
+	get #plist() {
+		return join(this.home, "Library/LaunchAgents", `${LABEL}.plist`);
+	}
+	get #script() {
+		return join(this.config.dataDir, "auto-refresh.cmd");
+	}
+	get #taskFile() {
+		return join(this.config.dataDir, "auto-refresh-task.xml");
+	}
+	get #log() {
+		return join(this.home, ".cache/garmin-personal-mcp/refresh.log");
+	}
+	get #scheduler() {
+		return {
+			darwin: "launchd",
+			linux: "cron",
+			win32: "Task Scheduler"
+		}[this.platform];
+	}
+	/** The pages that `refresh --auto` updates. */
+	async pages() {
+		return (await this.#state())?.pages ?? [];
+	}
+	async status() {
+		const state = await this.#state();
+		if (!state) return { scheduled: false };
+		return {
+			scheduled: true,
+			cron: state.cron,
+			next: nextRuns(parseCron(state.cron), /* @__PURE__ */ new Date(), 3),
+			pages: state.pages,
+			scheduler: this.#scheduler,
+			installed: await this.#installed(),
+			log: this.#log
+		};
+	}
+	/** Adds the page (default: the main dashboard) and sets the cron, or keeps the current one. */
+	async set(o) {
+		if (!this.#scheduler) throw new Error("Automatic refresh works on macOS, Linux and Windows");
+		if (!existsSync(this.config.apiKeyFile)) throw new Error(`Save the API key in ${this.config.apiKeyFile} first: a scheduled job cannot read the key from your MCP client`);
+		const page = pageTarget(this.config.dataDir, o.path);
+		if (!existsSync(page)) throw new Error(`${page} does not exist: make it first with the training-dashboard prompt`);
+		const old = await this.#state();
+		const cron = parseCron(o.cron ?? old?.cron ?? DEFAULT_CRON);
+		const pages = [.../* @__PURE__ */ new Set([...old?.pages ?? [], page])];
+		await this.#install(cron);
+		await writeFile(this.#stateFile, `${JSON.stringify({
+			cron: cron.text,
+			pages
+		}, null, 2)}\n`);
+		return this.status();
+	}
+	/** Removes the page; without a page, or when no page is left, removes the job. */
+	async off(path) {
+		const old = await this.#state();
+		if (!old) return { scheduled: false };
+		const pages = path ? old.pages.filter((p) => p !== pageTarget(this.config.dataDir, path)) : [];
+		if (pages.length > 0) {
+			await writeFile(this.#stateFile, `${JSON.stringify({
+				...old,
+				pages
+			}, null, 2)}\n`);
+			return this.status();
+		}
+		await this.#uninstall();
+		await rm(this.#stateFile, { force: true });
+		return { scheduled: false };
+	}
+	#job() {
+		const win = this.platform === "win32";
+		const npx = this.entry === "" || /[/\\]_npx[/\\]/.test(this.entry);
+		return {
+			program: join(this.nodeDir, npx ? win ? "npx.cmd" : "npx" : win ? "node.exe" : "node"),
+			args: [
+				...npx ? ["-y", `${name}@latest`] : [this.entry],
+				"refresh",
+				"--auto"
+			],
+			env: {
+				GARMIN_DATA_DIR: this.config.dataDir,
+				GARMIN_API_KEY_FILE: this.config.apiKeyFile,
+				GARMIN_BASE_URL: this.config.baseUrl,
+				PATH: win ? this.nodeDir : [
+					this.nodeDir,
+					"/usr/bin",
+					"/bin"
+				].join(delimiter)
+			},
+			log: this.#log
+		};
+	}
+	async #install(c) {
+		await mkdir(dirname(this.#log), { recursive: true });
+		const job = this.#job();
+		if (this.platform === "darwin") {
+			await mkdir(dirname(this.#plist), { recursive: true });
+			await writeFile(this.#plist, plist(job, c));
+			await this.exec("launchctl", [
+				"bootout",
+				this.#domain(),
+				this.#plist
+			]);
+			await this.#must("launchctl", [
+				"bootstrap",
+				this.#domain(),
+				this.#plist
+			]);
+		} else if (this.platform === "linux") await this.#must("crontab", ["-"], withCronLine(await this.#crontab(), cronLine(job, c)));
+		else {
+			await writeFile(this.#script, windowsScript(job));
+			await writeFile(this.#taskFile, Buffer.from(`\ufeff${taskXml(this.#script, c)}`, "utf16le"));
+			await this.#must("schtasks", [
+				"/Create",
+				"/F",
+				"/TN",
+				TASK,
+				"/XML",
+				this.#taskFile
+			]);
+		}
+	}
+	async #uninstall() {
+		if (this.platform === "darwin") {
+			await this.exec("launchctl", [
+				"bootout",
+				this.#domain(),
+				this.#plist
+			]);
+			await rm(this.#plist, { force: true });
+		} else if (this.platform === "linux") await this.#must("crontab", ["-"], withCronLine(await this.#crontab(), void 0));
+		else {
+			await this.exec("schtasks", [
+				"/Delete",
+				"/F",
+				"/TN",
+				TASK
+			]);
+			await rm(this.#script, { force: true });
+			await rm(this.#taskFile, { force: true });
+		}
+	}
+	async #installed() {
+		if (this.platform === "darwin") return existsSync(this.#plist);
+		if (this.platform === "linux") return (await this.#crontab()).includes(MARK);
+		return (await this.exec("schtasks", [
+			"/Query",
+			"/TN",
+			TASK
+		])).code === 0;
+	}
+	#domain() {
+		return `gui/${process.getuid()}`;
+	}
+	/** The user's crontab; "" when there is none (crontab -l then exits with 1). */
+	async #crontab() {
+		const r = await this.exec("crontab", ["-l"]);
+		return r.code === 0 ? r.stdout : "";
+	}
+	async #must(cmd, args, input) {
+		const r = await this.exec(cmd, args, input);
+		if (r.code !== 0) throw new Error(`${cmd} failed (${r.code}): ${(r.stderr || r.stdout).trim()}`);
+	}
+	async #state() {
+		const text = await readFile(this.#stateFile, "utf8").catch(() => void 0);
+		return text === void 0 ? void 0 : JSON.parse(text);
+	}
+};
+/** The real path of the running script, so the job does not follow a link that can change. */
+function realEntry(path) {
+	try {
+		return path ? realpathSync(path) : "";
+	} catch {
+		return "";
+	}
+}
+/** Updates each page; one failure does not stop the others. Returns one log line per page. */
+async function refreshPages(writer, pages) {
+	const lines = [];
+	let failed = false;
+	for (const path of pages) {
+		const at = (/* @__PURE__ */ new Date()).toISOString();
+		try {
+			await writer.write({
+				path,
+				onlyExisting: true
+			});
+			lines.push(`${at} updated ${path}`);
+		} catch (e) {
+			failed = true;
+			lines.push(`${at} failed ${path}: ${e.message}`);
+		}
+	}
+	return {
+		lines,
+		failed
+	};
+}
+/** Registers scheduleDashboardRefresh. */
+function registerSchedule(server, auto) {
+	server.registerTool("scheduleDashboardRefresh", {
+		description: [
+			"Turns on, changes or stops the automatic refresh of a dashboard page. Use it only when the user",
+			"asks for it or says yes to the question of a dashboard prompt. A job in the scheduler of the",
+			"computer (launchd, cron or Task Scheduler) replaces the data of the page at the given times, also",
+			"with no assistant open. The refresh removes the coach notes, because old notes do not agree",
+			"with new data. The computer must be on at that time. The page must exist (writeDashboard first).",
+			"`cron`: convert what the user says, in any language, into a 5-field cron expression in local",
+			"time: minute hour day-of-month month weekday, numbers only (0 = Sunday), e.g. \"0 7 * * 1-5\" for",
+			"weekdays at 7. Two runs must be at least 1 hour apart. The cron is for all scheduled pages;",
+			"`path` adds that page (default the main page); `off` stops the refresh of `path`, or of every",
+			"page when no `path` is given. Without arguments it only reads. The reply has `next`, the next",
+			"runs in local time: tell them to the user in their language, so they can check the schedule."
+		].join("\n"),
+		inputSchema: object({
+			cron: string().describe("minute hour day-of-month month weekday, e.g. \"0 7 * * *\"; default 0 7 * * *").optional(),
+			path: string().describe("The .html file; relative paths are inside the data dir").optional(),
+			off: boolean().describe("Stop the refresh").optional()
+		})
+	}, async ({ cron, path, off }) => {
+		const status = off ? await auto.off(path) : cron !== void 0 || path !== void 0 ? await auto.set({
+			cron,
+			path
+		}) : await auto.status();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(status)
+		}] };
+	});
+}
+// src/cli.ts
+/** The commands for a terminal or a scheduler; any other start is the MCP server. */
+const COMMANDS = ["refresh", "schedule"];
+/**
+* Runs `refresh [page.html | --auto]` or
+* `schedule [daily|weekdays|weekly <day>] [HH:MM] | "<cron>" | off`, each with an optional page.
+* Not MCP, so the result may go to stdout.
+*/
+async function cli(command, args, auto, writer) {
+	try {
+		if (command === "refresh") {
+			const pages = args[0] === "--auto" ? await auto.pages() : [args[0] ?? ""];
+			const { lines, failed } = await refreshPages(writer(), pages);
+			return {
+				code: failed ? 1 : 0,
+				stdout: lines.join("\n")
+			};
+		}
+		const rest = [...args];
+		const path = rest.at(-1)?.toLowerCase().endsWith(".html") ? rest.pop() : void 0;
+		return {
+			code: 0,
+			stdout: summary(rest[0] === "off" ? await auto.off(path) : rest.length === 0 && path === void 0 ? await auto.status() : await auto.set({
+				...rest.length > 0 ? { cron: cronOf(rest) } : {},
+				path
+			}))
+		};
+	} catch (e) {
+		return {
+			code: 1,
+			stderr: `${command} failed: ${e.message}`
+		};
+	}
+}
+function summary(s) {
+	if (!s.scheduled) return "Automatic refresh is off.";
+	return [
+		`Automatic refresh "${s.cron}" with ${s.scheduler}, next: ${s.next.join(", ")}`,
+		"Pages:",
+		...s.pages.map((p) => `  ${p}`),
+		...s.installed ? [] : [`The job is missing from ${s.scheduler}: run the schedule again.`],
+		`Log: ${s.log}`
+	].join("\n");
+}
+// src/config.ts
+/** Defaults reuse an existing ~/.config/garmin-mcp/api-key and ~/workspace/garmin-data. */
+function loadConfig(env = process.env) {
+	return {
+		baseUrl: env.GARMIN_BASE_URL || "https://personal.connectapi.garmin.com",
+		apiKeyFile: env.GARMIN_API_KEY_FILE || join(homedir(), ".config/garmin-mcp/api-key"),
+		dataDir: env.GARMIN_DATA_DIR || join(homedir(), "workspace/garmin-data")
+	};
+}
 // src/server.ts
 /** The page template; the build writes it next to dist/index.js. */
 const template = () => readFile(new URL("./dashboard.html", import.meta.url), "utf8");
-/** The garmin-personal MCP server with its 15 tools and 5 prompts. */
+/** The tools, the dashboard data and the page writer, wired to one API client. */
+function createParts(config) {
+	const api = new GarminApiClient(config);
+	const tools = new GarminTools(api, config.dataDir);
+	const dashboard = new GarminDashboard(tools, api, config.dataDir);
+	return {
+		tools,
+		dashboard,
+		writer: new DashboardWriter((weeks) => dashboard.getDashboardData(weeks), config.dataDir, template)
+	};
+}
+/** The garmin-personal MCP server with its tools and prompts. */
 function createServer(config) {
 	const server = new McpServer({
 		name: "garmin-personal",
 		version
 	});
-	const api = new GarminApiClient(config);
-	const tools = new GarminTools(api, config.dataDir);
+	const { tools, dashboard, writer } = createParts(config);
 	registerTools(server, tools);
-	const dashboard = new GarminDashboard(tools, api, config.dataDir);
 	registerDashboard(server, dashboard);
-	registerDashboardWriter(server, new DashboardWriter((weeks) => dashboard.getDashboardData(weeks), config.dataDir, template));
+	registerDashboardWriter(server, writer);
+	registerSchedule(server, new AutoRefresh(config));
 	registerPrompts(server);
 	return server;
 }
 // src/index.ts
-serveStdio(() => createServer(loadConfig()));
+const [command = "", ...args] = process.argv.slice(2);
+if (COMMANDS.includes(command)) {
+	const config = loadConfig();
+	const r = await cli(command, args, new AutoRefresh(config), () => createParts(config).writer);
+	if (r.stdout) process.stdout.write(`${r.stdout}\n`);
+	if (r.stderr) process.stderr.write(`${r.stderr}\n`);
+	process.exitCode = r.code;
+} else serveStdio(() => createServer(loadConfig()));
 export {};