@runnerpro/backend 1.21.12 → 1.21.15

package/lib/cjs/achievements/index.js

@@ -0,0 +1,805 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnlockedAchievements = exports.evaluateAchievementsBounded = exports.evaluateAchievements = exports.computeWorkoutEfforts = exports.computeStreakStats = void 0;
+const db_1 = require("../db");
+const moment_1 = __importDefault(require("moment"));
+const streak_1 = require("./streak");
+// Re-export para que los consumidores del paquete (p. ej. Cliente-backend
+// progress) usen el MISMO motor de racha sin duplicar la lógica.
+var streak_2 = require("./streak");
+Object.defineProperty(exports, "computeStreakStats", { enumerable: true, get: function () { return streak_2.computeStreakStats; } });
+const catalog_1 = require("./catalog");
+// Mapa inverso badge → metros (para leer los PRs guardados en PARAMS).
+const BADGE_PR_DISTANCE = {};
+for (const meters of Object.keys(catalog_1.PR_DISTANCE_BADGE)) {
+    BADGE_PR_DISTANCE[catalog_1.PR_DISTANCE_BADGE[Number(meters)]] = Number(meters);
+}
+const typesList = (types) => types.map((t) => `'${t}'`).join(',');
+const countScalar = (sql, params) => __awaiter(void 0, void 0, void 0, function* () {
+    const [row] = yield (0, db_1.query)(sql, params);
+    return Number(row === null || row === void 0 ? void 0 : row.c) || 0;
+});
+/**
+ * Ancla "empezar de cero": solo cuentan los workouts con DATE >= fecha de alta
+ * (CLIENTE."DATE INITIAL FORM"). Evita que el import histórico de Strava/Garmin
+ * desbloquee logros retroactivos.
+ */
+const getAnchorDate = (userId) => __awaiter(void 0, void 0, void 0, function* () {
+    const [row] = yield (0, db_1.query)('SELECT "DATE INITIAL FORM"::date AS "ANCHOR" FROM "CLIENTE" WHERE "ID" = ?', [userId]);
+    return (row === null || row === void 0 ? void 0 : row.anchor) || null;
+});
+/** Todos los agregados por tipo en una sola pasada (DISTANCE/DESNIVEL en metros). */
+const getAllAggregates = (userId, sinceDate) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = [userId];
+    let sinceFilter = '';
+    if (sinceDate) {
+        sinceFilter = ' AND "DATE"::date >= ?::date';
+        params.push(sinceDate);
+    }
+    const runList = typesList(catalog_1.RUNNING_TYPES);
+    const [row] = yield (0, db_1.query)(`SELECT
+       COALESCE(MAX("DISTANCE") FILTER (WHERE "TYPE" IN (${runList})), 0) AS "RUN MAX",
+       COALESCE(SUM("DISTANCE") FILTER (WHERE "TYPE" IN (${runList})), 0) AS "RUN TOTAL",
+       COUNT(*) FILTER (WHERE "TYPE" = 'FUERZA') AS "STR COUNT",
+       COALESCE(MAX("DISTANCE") FILTER (WHERE "TYPE" = 'BIKE'), 0) AS "BIKE MAX",
+       COALESCE(SUM("DISTANCE") FILTER (WHERE "TYPE" = 'BIKE'), 0) AS "BIKE TOTAL",
+       COALESCE(MAX("DISTANCE") FILTER (WHERE "TYPE" = 'SWIM'), 0) AS "SWIM MAX",
+       COUNT(*) FILTER (WHERE "TYPE" = 'SWIM') AS "SWIM COUNT",
+       COALESCE(MAX("DISTANCE") FILTER (WHERE "TYPE" = 'TRAIL'), 0) AS "TRAIL MAX",
+       COALESCE(SUM("DESNIVEL") FILTER (WHERE "TYPE" = 'TRAIL'), 0) AS "TRAIL DESNIVEL",
+       COUNT(*) FILTER (WHERE "TYPE" = 'COMPETICION') AS "RACE COUNT",
+       COUNT(*) FILTER (WHERE "FC MEDIA" IS NOT NULL) AS "HR COUNT"
+     FROM "WORKOUT"
+     WHERE "ID CLIENTE" = ? AND "DONE" = true${sinceFilter}`, params);
+    return {
+        runMax: Number(row === null || row === void 0 ? void 0 : row.runMax) || 0,
+        runTotal: Number(row === null || row === void 0 ? void 0 : row.runTotal) || 0,
+        strCount: Number(row === null || row === void 0 ? void 0 : row.strCount) || 0,
+        bikeMax: Number(row === null || row === void 0 ? void 0 : row.bikeMax) || 0,
+        bikeTotal: Number(row === null || row === void 0 ? void 0 : row.bikeTotal) || 0,
+        swimMax: Number(row === null || row === void 0 ? void 0 : row.swimMax) || 0,
+        swimCount: Number(row === null || row === void 0 ? void 0 : row.swimCount) || 0,
+        trailMax: Number(row === null || row === void 0 ? void 0 : row.trailMax) || 0,
+        trailDesnivel: Number(row === null || row === void 0 ? void 0 : row.trailDesnivel) || 0,
+        raceCount: Number(row === null || row === void 0 ? void 0 : row.raceCount) || 0,
+        hrCount: Number(row === null || row === void 0 ? void 0 : row.hrCount) || 0,
+    };
+});
+const getRaceDates = (userId, sinceDate) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = [userId];
+    let sinceFilter = '';
+    if (sinceDate) {
+        sinceFilter = ' AND "DATE"::date >= ?::date';
+        params.push(sinceDate);
+    }
+    const rows = yield (0, db_1.query)(`SELECT "DATE"::date AS "DATE"
+     FROM "WORKOUT"
+     WHERE "ID CLIENTE" = ? AND "DONE" = true AND "TYPE" = 'COMPETICION'${sinceFilter}
+     ORDER BY "DATE" ASC`, params);
+    return rows.map((r) => r.date);
+});
+// ── Best-effort sobre streams ───────────────────────────────────────────────
+const buildSeries = (distRaw, timeRaw) => {
+    const dist = [];
+    const time = [];
+    const n = Math.min((distRaw === null || distRaw === void 0 ? void 0 : distRaw.length) || 0, (timeRaw === null || timeRaw === void 0 ? void 0 : timeRaw.length) || 0);
+    let lastD = -Infinity;
+    for (let i = 0; i < n; i++) {
+        const d = Number(distRaw[i]);
+        const t = Number(timeRaw[i]);
+        if (!Number.isFinite(d) || !Number.isFinite(t))
+            continue;
+        if (d < lastD)
+            continue;
+        dist.push(d);
+        time.push(t);
+        lastD = d;
+    }
+    return { dist, time };
+};
+/** Segmento continuo más rápido que cubre al menos `target` metros. */
+const bestEffortTime = (dist, time, target) => {
+    const n = dist.length;
+    if (n < 2)
+        return null;
+    if (dist[n - 1] - dist[0] < target)
+        return null;
+    let best = Infinity;
+    let j = 0;
+    for (let i = 0; i < n; i++) {
+        if (j < i)
+            j = i;
+        while (j < n && dist[j] - dist[i] < target)
+            j++;
+        if (j >= n)
+            break;
+        const t = time[j] - time[i];
+        if (t > 0 && t < best)
+            best = t;
+    }
+    return best === Infinity ? null : Math.round(best);
+};
+/** Tiempos candidatos por distancia para un entreno (stream → best-effort; sin stream → híbrido). */
+// Exportado para tests unitarios (no forma parte de la API pública del paquete).
+const computeWorkoutEfforts = (workout, series) => {
+    var _a;
+    const result = {};
+    const hasStream = series && series.dist.length >= 2 && series.time.length >= 2;
+    if (hasStream) {
+        for (const target of catalog_1.PR_DISTANCES) {
+            const t = bestEffortTime(series.dist, series.time, target);
+            if (t !== null)
+                result[target] = { time: t, esBestEffort: true };
+        }
+        return result;
+    }
+    const dist = Number(workout.distance) || 0;
+    const dur = Number(workout.duration) || 0;
+    if (dur <= 0)
+        return result;
+    for (const target of catalog_1.PR_DISTANCES) {
+        // Entrada manual: media/maratón se guardan redondeadas (21000/42000), justo
+        // por debajo del oficial. PR_MANUAL_FLOOR baja el suelo a la distancia
+        // redondeada para esos casos; el resto mantiene suelo = distancia oficial.
+        const floor = (_a = catalog_1.PR_MANUAL_FLOOR[target]) !== null && _a !== void 0 ? _a : target;
+        if (dist >= floor && dist <= target * catalog_1.PR_NO_STREAM_MARGIN) {
+            result[target] = { time: dur, esBestEffort: false };
+        }
+    }
+    return result;
+};
+exports.computeWorkoutEfforts = computeWorkoutEfforts;
+const fetchStreams = (ids) => __awaiter(void 0, void 0, void 0, function* () {
+    const byWorkout = {};
+    if (!ids.length)
+        return byWorkout;
+    const placeholders = ids.map(() => '?').join(',');
+    const streamRows = yield (0, db_1.query)(`SELECT "ID WORKOUT" AS "ID WORKOUT", "METRIC TYPE", "DATA"
+     FROM "WORKOUT STREAM"
+     WHERE "ID WORKOUT" IN (${placeholders}) AND "METRIC TYPE" IN ('distance','time')`, ids);
+    for (const r of streamRows) {
+        if (!byWorkout[r.idWorkout])
+            byWorkout[r.idWorkout] = {};
+        byWorkout[r.idWorkout][r.metricType] = r.data;
+    }
+    return byWorkout;
+});
+/** Mejor tiempo por distancia entre un conjunto de entrenos. */
+const computeBest = (workouts, streamsByWorkout) => {
+    const best = {};
+    for (const w of workouts) {
+        const raw = streamsByWorkout[w.id];
+        const series = raw ? buildSeries(raw.distance, raw.time) : null;
+        const efforts = (0, exports.computeWorkoutEfforts)(w, series);
+        for (const distStr of Object.keys(efforts)) {
+            const d = Number(distStr);
+            const eff = efforts[distStr];
+            if (!best[d] || eff.time < best[d].time) {
+                best[d] = { time: eff.time, workoutId: w.id, date: w.date, esBestEffort: eff.esBestEffort };
+            }
+        }
+    }
+    return best;
+};
+/**
+ * Guarda los PRs en los PARAMS del logro de distancia correspondiente, con
+ * "solo mejora" ATÓMICO (un solo UPDATE/INSERT por distancia, sin leer-modificar
+ * -escribir en JS → race-safe). Si la fila no existe, la inserta (cubrir esa
+ * distancia desbloquea el logro, así que es correcto unlockearlo aquí).
+ */
+const applyPRs = (userId, best, markSeen = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const nuevos = [];
+    // markSeen: igual que en persistLogros — backfill inserta "FECHA VISTO"=now()
+    // (sin celebración retroactiva), evento en vivo NULL (lo recoge pendingCongrats).
+    // En el DO UPDATE (mejora de PR sobre un dist_* YA desbloqueado) NO se toca
+    // "FECHA VISTO": no se re-celebra un récord mejorado. Literal seguro.
+    const seenSql = markSeen ? 'now()' : 'NULL';
+    for (const distStr of Object.keys(best)) {
+        const badgeId = catalog_1.PR_DISTANCE_BADGE[Number(distStr)];
+        if (!badgeId)
+            continue;
+        const b = best[distStr];
+        // prDate en formato ISO (YYYY-MM-DD), no el toString de Date con locale/timezone.
+        const prDate = b.date ? (0, moment_1.default)(b.date).format('YYYY-MM-DD') : null;
+        // RETURNING (xmax = 0) AS inserted: distingue una fila recién CREADA (desbloqueo
+        // nuevo de este dist_*) de una ACTUALIZADA (solo mejora de PR sobre un badge ya
+        // desbloqueado). Solo las creadas se notifican como recién desbloqueadas.
+        const rows = yield (0, db_1.query)(`INSERT INTO "CLIENTE LOGRO" ("ID CLIENTE", "LOGRO ID", "PARAMS", "FECHA VISTO")
+       VALUES (?, ?, jsonb_build_object('prTime', ?::numeric, 'prWorkout', ?::int, 'prDate', ?::text, 'prBestEffort', ?::boolean), ${seenSql})
+       ON CONFLICT ("ID CLIENTE", "LOGRO ID") DO UPDATE
+       SET "PARAMS" = COALESCE("CLIENTE LOGRO"."PARAMS", '{}'::jsonb) || EXCLUDED."PARAMS"
+       WHERE "CLIENTE LOGRO"."PARAMS" IS NULL
+          OR "CLIENTE LOGRO"."PARAMS"->>'prTime' IS NULL
+          OR ("CLIENTE LOGRO"."PARAMS"->>'prTime')::numeric > (EXCLUDED."PARAMS"->>'prTime')::numeric
+       RETURNING "LOGRO ID" AS "ID", "FECHA DESBLOQUEO", (xmax = 0) AS "INSERTED"`, [userId, badgeId, b.time, b.workoutId, prDate, !!b.esBestEffort]);
+        for (const r of rows) {
+            // El wrapper query() puede devolver el boolean como true/'t'; normalizamos.
+            const inserted = r.inserted === true || r.inserted === 't';
+            if (!inserted)
+                continue;
+            nuevos.push({
+                id: r.id,
+                fechaDesbloqueo: r.fechaDesbloqueo,
+                params: {
+                    prTime: Number(b.time),
+                    prWorkout: b.workoutId,
+                    prDate,
+                    prBestEffort: !!b.esBestEffort,
+                },
+            });
+        }
+    }
+    return nuevos;
+});
+/** Lee el mapa de PRs {metros: segundos} desde los PARAMS de los logros dist_*. */
+const getPrMap = (userId) => __awaiter(void 0, void 0, void 0, function* () {
+    const badgeIds = Object.values(catalog_1.PR_DISTANCE_BADGE);
+    const placeholders = badgeIds.map(() => '?').join(',');
+    const rows = yield (0, db_1.query)(`SELECT "LOGRO ID" AS "ID", ("PARAMS"->>'prTime')::numeric AS "PR TIME"
+     FROM "CLIENTE LOGRO"
+     WHERE "ID CLIENTE" = ? AND "LOGRO ID" IN (${placeholders}) AND "PARAMS"->>'prTime' IS NOT NULL`, [userId, ...badgeIds]);
+    const prMap = {};
+    for (const r of rows) {
+        const dist = BADGE_PR_DISTANCE[r.id];
+        if (dist)
+            prMap[dist] = Number(r.prTime);
+    }
+    return prMap;
+});
+const RUN_SELECT = 'SELECT "ID" AS "ID", "DISTANCE", "DURATION", "DATE"::date AS "DATE" FROM "WORKOUT"';
+/** PR de UN entreno (evento): procesa solo ese entreno y actualiza sus PRs.
+ *  Devuelve los dist_* recién desbloqueados por este entreno (con su PR en params). */
+const processWorkoutPR = (userId, anchor, workoutId, markSeen = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = [userId, workoutId];
+    let sinceFilter = '';
+    if (anchor) {
+        sinceFilter = ' AND "DATE"::date >= ?::date';
+        params.push(anchor);
+    }
+    const workouts = yield (0, db_1.query)(`${RUN_SELECT}
+     WHERE "ID CLIENTE" = ? AND "ID" = ? AND "DONE" = true
+       AND "TYPE" IN (${typesList(catalog_1.RUNNING_TYPES)}) AND "DISTANCE" >= 1000${sinceFilter}`, params);
+    if (!workouts.length)
+        return [];
+    const streams = yield fetchStreams(workouts.map((w) => w.id));
+    return applyPRs(userId, computeBest(workouts, streams), markSeen);
+});
+/** PR desde cero (backfill): procesa todos los entrenos de carrera desde el ancla.
+ *  Devuelve los dist_* recién desbloqueados (con su PR en params). */
+const recomputeAllPRs = (userId, anchor, markSeen = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = [userId];
+    let sinceFilter = '';
+    if (anchor) {
+        sinceFilter = ' AND "DATE"::date >= ?::date';
+        params.push(anchor);
+    }
+    const workouts = yield (0, db_1.query)(`${RUN_SELECT}
+     WHERE "ID CLIENTE" = ? AND "DONE" = true
+       AND "TYPE" IN (${typesList(catalog_1.RUNNING_TYPES)}) AND "DISTANCE" >= 1000${sinceFilter}`, params);
+    if (!workouts.length)
+        return [];
+    const streams = yield fetchStreams(workouts.map((w) => w.id));
+    return applyPRs(userId, computeBest(workouts, streams), markSeen);
+});
+/**
+ * Persiste logros (filas) en una sola query, idempotente (no revoca).
+ * Devuelve SOLO los recién insertados (RETURNING + ON CONFLICT DO NOTHING),
+ * para que el caller pueda notificar al FE qué se acaba de desbloquear.
+ */
+const persistLogros = (userId, ids, markSeen = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const uniq = Array.from(new Set(ids));
+    if (!uniq.length)
+        return [];
+    // markSeen: en backfill (event='all') se inserta "FECHA VISTO"=now() para NO
+    // celebrar logros retroactivos; en eventos en vivo se deja NULL ("no visto")
+    // para que el FE lo recoja en pendingCongrats y muestre la celebración (A2).
+    // Literal seguro (no entra input de usuario).
+    const seenSql = markSeen ? 'now()' : 'NULL';
+    const valuesSql = uniq.map(() => `(?, ?, ${seenSql})`).join(', ');
+    const params = [];
+    for (const id of uniq)
+        params.push(userId, id);
+    const rows = yield (0, db_1.query)(`INSERT INTO "CLIENTE LOGRO" ("ID CLIENTE", "LOGRO ID", "FECHA VISTO")
+     VALUES ${valuesSql}
+     ON CONFLICT ("ID CLIENTE", "LOGRO ID") DO NOTHING
+     RETURNING "LOGRO ID" AS "ID", "FECHA DESBLOQUEO"`, params);
+    return rows.map((r) => ({ id: r.id, fechaDesbloqueo: r.fechaDesbloqueo }));
+});
+// ── Reglas por categoría ────────────────────────────────────────────────────
+const evaluateConsistency = (longestWeeks) => catalog_1.CONSISTENCY.filter((c) => longestWeeks >= c.weeks).map((c) => c.id);
+const evaluateDistance = (maxMeters) => catalog_1.DISTANCE.filter((d) => maxMeters >= d.meters).map((d) => d.id);
+const evaluateVolume = (totalMeters) => catalog_1.VOLUME.filter((v) => totalMeters >= v.km * 1000).map((v) => v.id);
+const evaluateStrength = (count) => catalog_1.STRENGTH_COUNT.filter((s) => count >= s.count).map((s) => s.id);
+const evaluateCycling = (agg) => [
+    ...catalog_1.CYCLING_DISTANCE.filter((d) => agg.bikeMax >= d.meters).map((d) => d.id),
+    ...catalog_1.CYCLING_VOLUME.filter((v) => agg.bikeTotal >= v.km * 1000).map((v) => v.id),
+];
+const evaluateSwim = (agg) => catalog_1.SWIM_DISTANCE.filter((d) => agg.swimMax >= d.meters).map((d) => d.id);
+const evaluateTriSwim = (agg) => [
+    ...(agg.swimCount >= 1 ? ['tri_first_swim'] : []),
+    ...catalog_1.TRI_SWIM_DISTANCE.filter((d) => agg.swimMax >= d.meters).map((d) => d.id),
+];
+const evaluateTrail = (agg) => [
+    ...catalog_1.TRAIL_DISTANCE.filter((d) => agg.trailMax >= d.meters).map((d) => d.id),
+    ...catalog_1.TRAIL_ELEVATION.filter((e) => agg.trailDesnivel >= e.meters).map((e) => e.id),
+];
+const has3RacesIn365 = (raceDates) => {
+    if (raceDates.length < 3)
+        return false;
+    const sorted = raceDates.map((d) => new Date(d).getTime()).sort((a, b) => a - b);
+    const DAY = 24 * 60 * 60 * 1000;
+    for (let i = 0; i + 2 < sorted.length; i++) {
+        if (sorted[i + 2] - sorted[i] <= 365 * DAY)
+            return true;
+    }
+    return false;
+};
+const evaluateRaces = (count, raceDates) => {
+    const ids = catalog_1.RACE_COUNT.filter((r) => count >= r.count).map((r) => r.id);
+    if (has3RacesIn365(raceDates))
+        ids.push('pc_3carreras_anio');
+    return ids;
+};
+const evaluatePace = (prMap) => {
+    const best1k = prMap[1000];
+    if (typeof best1k !== 'number')
+        return [];
+    return catalog_1.PACE.filter((p) => best1k <= p.maxSecPerKm).map((p) => p.id);
+};
+const evaluateTimePR = (prMap) => catalog_1.TIME_PR.filter((t) => typeof prMap[t.distance] === 'number' && prMap[t.distance] <= t.maxSeconds).map((t) => t.id);
+const evalCount = (rules, count) => rules.filter((r) => count >= r.count).map((r) => r.id);
+// ── Plan + Hitos del Plan ─────────────────────────────────────────────────
+/**
+ * Plan activo del cliente: id, ventana (inicio/objetivo) y rangos de fecha de
+ * los 4 bloques (base/desarrollo/pico/taper). Devuelve null si no hay plan.
+ */
+const getPlanContext = (userId) => __awaiter(void 0, void 0, void 0, function* () {
+    const [row] = yield (0, db_1.query)(`SELECT
+       "ID PLAN CARRERA" AS "PLAN ID",
+       "START DATE PLAN"::date AS "PLAN START",
+       "GOAL DATE"::date AS "PLAN GOAL",
+       "GOAL DISTANCE" AS "GOAL DIST",
+       "GOAL DURATION" AS "GOAL DUR",
+       "ALGORITMO BLOQUE 1 INICIO"::date AS "BASE INI",
+       "ALGORITMO BLOQUE 1 FIN"::date AS "BASE FIN",
+       "ALGORITMO BLOQUE 2 INICIO"::date AS "DESA INI",
+       "ALGORITMO BLOQUE 2 FIN"::date AS "DESA FIN",
+       "ALGORITMO BLOQUE 3 INICIO"::date AS "PICO INI",
+       "ALGORITMO BLOQUE 3 FIN"::date AS "PICO FIN",
+       "ALGORITMO BLOQUE 4 INICIO"::date AS "TAPER INI",
+       "ALGORITMO BLOQUE 4 FIN"::date AS "TAPER FIN"
+     FROM "CLIENTE" WHERE "ID" = ?`, [userId]);
+    return row || null;
+});
+/**
+ * Logros de Plan + Hitos del Plan (TIER 1, todos derivables ya):
+ *  - plan_baseline: el cliente tiene un plan activo.
+ *  - plan_82: adherencia ≥ 82%.
+ *  - plan_completado: alcanzó GOAL DATE con adherencia ≥ 80%.
+ *  - hito_base/desarrollo/pico/taper: bloque ya finalizado con adherencia ≥ 80%.
+ *  - hito_semana_race: competición completada en la semana de GOAL DATE.
+ *  - str_plan_full: plan terminado con el 100% de las sesiones de FUERZA hechas.
+ *  - plan_tirada_larga / plan_ritmo_carrera.
+ * Adherencia = planificadas ("SHOW CLIENT"=true, tipo entrenable) completadas /
+ * DEBIDAS (DATE <= hoy), para no penalizar las sesiones futuras aún no vencidas.
+ */
+const evaluatePlan = (userId, anchor) => __awaiter(void 0, void 0, void 0, function* () {
+    const plan = yield getPlanContext(userId);
+    if (!plan || !plan.planId || !plan.planStart)
+        return [];
+    const fmt = (d) => (0, moment_1.default)(d).format('YYYY-MM-DD');
+    const today = (0, moment_1.default)().format('YYYY-MM-DD');
+    const ids = ['plan_baseline'];
+    const rows = yield (0, db_1.query)(`SELECT "DATE"::date AS "DATE", "DONE", "TYPE",
+            "DISTANCE", "DURATION",
+            "DISTANCE PLANNED" AS "DIST PLANNED", "DURATION PLANNED" AS "DUR PLANNED"
+     FROM "WORKOUT"
+     WHERE "ID CLIENTE" = ?
+       AND "SHOW CLIENT" = true
+       AND "TYPE" IN (${typesList(catalog_1.PLAN_SESSION_TYPES)})
+       AND "DATE"::date >= ?::date
+       AND "DATE"::date <= ?::date`, [userId, plan.planStart, today]);
+    const total = rows.length;
+    const adherence = total > 0 ? rows.filter((r) => r.done).length / total : 0;
+    if (total > 0 && adherence >= catalog_1.PLAN_ADHERENCE_82)
+        ids.push('plan_82');
+    const goal = plan.planGoal ? fmt(plan.planGoal) : null;
+    if (goal && today >= goal && total > 0 && adherence >= catalog_1.PLAN_COMPLETE_ADHERENCE) {
+        ids.push('plan_completado');
+    }
+    // str_plan_full: plan terminado con el 100% de las sesiones de FUERZA hechas.
+    if (goal && today >= goal) {
+        const strengthSessions = rows.filter((r) => r.type === 'FUERZA');
+        if (strengthSessions.length > 0 && strengthSessions.every((r) => r.done)) {
+            ids.push('str_plan_full');
+        }
+    }
+    // Hitos de bloque: cada bloque YA finalizado con adherencia ≥80%.
+    const blocks = [
+        { id: 'hito_base', ini: plan.baseIni, fin: plan.baseFin },
+        { id: 'hito_desarrollo', ini: plan.desaIni, fin: plan.desaFin },
+        { id: 'hito_pico', ini: plan.picoIni, fin: plan.picoFin },
+        { id: 'hito_taper', ini: plan.taperIni, fin: plan.taperFin },
+    ];
+    for (const b of blocks) {
+        if (!b.ini || !b.fin)
+            continue;
+        const finStr = fmt(b.fin);
+        if (today <= finStr)
+            continue; // bloque aún no terminado
+        const iniStr = fmt(b.ini);
+        const inBlock = rows.filter((r) => {
+            const d = fmt(r.date);
+            return d >= iniStr && d <= finStr;
+        });
+        if (inBlock.length > 0 && inBlock.filter((r) => r.done).length / inBlock.length >= catalog_1.PLAN_BLOCK_ADHERENCE) {
+            ids.push(b.id);
+        }
+    }
+    // Semana de carrera: competición completada alrededor de GOAL DATE.
+    if (goal) {
+        const raceStart = (0, moment_1.default)(plan.planGoal).subtract(catalog_1.PLAN_RACE_WEEK_DAYS, 'days').format('YYYY-MM-DD');
+        const raceEnd = (0, moment_1.default)(plan.planGoal).add(1, 'days').format('YYYY-MM-DD');
+        const raceDone = yield countScalar(`SELECT COUNT(*) AS "C" FROM "WORKOUT"
+       WHERE "ID CLIENTE" = ? AND "TYPE" = 'COMPETICION' AND "DONE" = true
+         AND "DATE"::date BETWEEN ?::date AND ?::date`, [userId, raceStart, raceEnd]);
+        if (raceDone >= 1)
+            ids.push('hito_semana_race');
+    }
+    // plan_tirada_larga: la tirada larga (carrera prevista más larga de su semana)
+    // completada, si supera el mínimo de volumen.
+    const runRows = rows.filter((r) => catalog_1.PLAN_RUN_TYPES.includes(r.type));
+    const longestByWeek = {};
+    for (const r of runRows) {
+        const wk = (0, moment_1.default)(r.date).format('GGGG-WW'); // semana ISO + año
+        const planned = Number(r.distPlanned) || 0;
+        if (!longestByWeek[wk] || planned > (Number(longestByWeek[wk].distPlanned) || 0)) {
+            longestByWeek[wk] = r;
+        }
+    }
+    const longRunDone = Object.values(longestByWeek).some((r) => {
+        if (!r.done)
+            return false;
+        const dist = Number(r.distPlanned) || Number(r.distance) || 0;
+        const dur = Number(r.durPlanned) || Number(r.duration) || 0;
+        return dist >= catalog_1.PLAN_LONG_RUN_MIN_DISTANCE || dur >= catalog_1.PLAN_LONG_RUN_MIN_DURATION;
+    });
+    if (longRunDone)
+        ids.push('plan_tirada_larga');
+    // plan_ritmo_carrera: carrera planificada hecha cuyo ritmo medio (s/m) ≈ ritmo
+    // objetivo (GOAL DURATION/GOAL DISTANCE). Solo si el cliente fijó tiempo objetivo.
+    const goalDist = Number(plan.goalDist) || 0;
+    const goalDur = Number(plan.goalDur) || 0;
+    if (goalDist > 0 && goalDur > 0) {
+        const targetPace = goalDur / goalDist; // segundos por metro
+        const hitRacePace = runRows.some((r) => {
+            if (!r.done)
+                return false;
+            const dist = Number(r.distance) || 0;
+            const dur = Number(r.duration) || 0;
+            if (dist < catalog_1.PLAN_RACE_PACE_MIN_DISTANCE || dur <= 0)
+                return false;
+            return Math.abs(dur / dist - targetPace) / targetPace <= catalog_1.PLAN_RACE_PACE_TOLERANCE;
+        });
+        if (hitRacePace)
+            ids.push('plan_ritmo_carrera');
+    }
+    // pc_nuevo_capitulo: empezaste un nuevo objetivo tras cerrar una etapa = existe
+    // una COMPETICION completada (post-ancla) ANTERIOR al inicio del plan actual.
+    const prevRaceParams = [userId, plan.planStart];
+    let prevRaceAnchor = '';
+    if (anchor) {
+        prevRaceAnchor = ' AND "DATE"::date >= ?::date';
+        prevRaceParams.push(anchor);
+    }
+    const prevRaces = yield countScalar(`SELECT COUNT(*) AS "C" FROM "WORKOUT"
+     WHERE "ID CLIENTE" = ? AND "TYPE" = 'COMPETICION' AND "DONE" = true
+       AND "DATE"::date < ?::date${prevRaceAnchor}`, prevRaceParams);
+    if (prevRaces >= 1)
+        ids.push('pc_nuevo_capitulo');
+    return ids;
+});
+// ── Fuerza: frecuencia / hábito ──────────────────────────────────────────────
+/** Fechas (moment) de las sesiones de FUERZA completadas desde el ancla, asc. */
+const getStrengthDates = (userId, sinceDate) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = [userId];
+    let sinceFilter = '';
+    if (sinceDate) {
+        sinceFilter = ' AND "DATE"::date >= ?::date';
+        params.push(sinceDate);
+    }
+    const rows = yield (0, db_1.query)(`SELECT "DATE"::date AS "DATE" FROM "WORKOUT"
+     WHERE "ID CLIENTE" = ? AND "TYPE" = 'FUERZA' AND "DONE" = true${sinceFilter}
+     ORDER BY "DATE" ASC`, params);
+    return rows.map((r) => (0, moment_1.default)(r.date));
+});
+/** ¿Hay ≥sessions sesiones dentro de una ventana de `days` días? (momentos asc) */
+const hasSessionsInWindow = (moments, sessions, days) => {
+    for (let i = 0; i + sessions - 1 < moments.length; i++) {
+        if (moments[i + sessions - 1].diff(moments[i], 'days') <= days - 1)
+            return true;
+    }
+    return false;
+};
+/** ¿Hay ≥n semanas ISO consecutivas con al menos una sesión? (tolerante a DST) */
+const hasConsecutiveWeeks = (moments, n) => {
+    const starts = [...new Map(moments.map((m) => {
+            const s = m.clone().startOf('isoWeek');
+            return [s.format('GGGG-[W]WW'), s];
+        })).values()].sort((a, b) => a.valueOf() - b.valueOf());
+    let run = 1;
+    for (let i = 1; i < starts.length; i++) {
+        const d = starts[i].diff(starts[i - 1], 'days');
+        run = d >= 6 && d <= 8 ? run + 1 : 1;
+        if (run >= n)
+            return true;
+    }
+    return false;
+};
+const evaluateStrengthFrequency = (moments) => {
+    const ids = catalog_1.STRENGTH_WINDOWS
+        .filter((w) => hasSessionsInWindow(moments, w.sessions, w.days))
+        .map((w) => w.id);
+    if (hasConsecutiveWeeks(moments, catalog_1.STRENGTH_HABIT_WEEKS))
+        ids.push('str_habito');
+    return ids;
+};
+// ── Triatlón: brick (bici + carrera el mismo día) ─────────────────────────────
+const evaluateBrick = (userId, sinceDate) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = [userId];
+    let sinceFilter = '';
+    if (sinceDate) {
+        sinceFilter = ' AND "DATE"::date >= ?::date';
+        params.push(sinceDate);
+    }
+    const c = yield countScalar(`SELECT COUNT(*) AS "C" FROM (
+       SELECT "DATE"::date AS d
+       FROM "WORKOUT"
+       WHERE "ID CLIENTE" = ? AND "DONE" = true AND "TYPE" IN (${typesList(catalog_1.BRICK_TYPES)})${sinceFilter}
+       GROUP BY "DATE"::date
+       HAVING COUNT(DISTINCT "TYPE") = 2
+     ) t`, params);
+    return c >= 1 ? ['tri_brick'] : [];
+});
+// ── Post-carrera: recovery run tras competición ───────────────────────────────
+const evaluateRecovery = (userId, sinceDate) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = [userId];
+    let sinceR = '';
+    let sinceC = '';
+    if (sinceDate) {
+        sinceR = ' AND r."DATE"::date >= ?::date';
+        sinceC = ' AND c."DATE"::date >= ?::date';
+        params.push(sinceDate, sinceDate);
+    }
+    const c = yield countScalar(`SELECT COUNT(*) AS "C"
+     FROM "WORKOUT" r
+     WHERE r."ID CLIENTE" = ?
+       AND r."TYPE" = 'CORRER' AND r."DONE" = true AND r."ZONE PLANNED" = ${catalog_1.RECOVERY_RUN_ZONE}${sinceR}
+       AND EXISTS (
+         SELECT 1 FROM "WORKOUT" c
+         WHERE c."ID CLIENTE" = r."ID CLIENTE"
+           AND c."TYPE" = 'COMPETICION' AND c."DONE" = true${sinceC}
+           AND r."DATE"::date > c."DATE"::date
+           AND r."DATE"::date <= c."DATE"::date + (${catalog_1.RECOVERY_RUN_DAYS} * INTERVAL '1 day')
+       )`, params);
+    return c >= 1 ? ['pc_recovery'] : [];
+});
+/**
+ * coach_llamada: el cliente tiene una llamada programada cuya fecha ya llegó
+ * (CLIENTE."LLAMADA SCHEDULE"::date <= hoy). Es por TIEMPO (no hay acción de
+ * usuario que la dispare), así que se re-evalúa de forma oportunista en el
+ * evento 'workout' y en el backfill ('all').
+ */
+const evaluateCoachCall = (userId) => __awaiter(void 0, void 0, void 0, function* () {
+    const c = yield countScalar('SELECT COUNT(*) AS "C" FROM "CLIENTE" WHERE "ID" = ? AND "LLAMADA SCHEDULE" IS NOT NULL AND "LLAMADA SCHEDULE"::date <= CURRENT_DATE', [userId]);
+    return c >= 1 ? ['coach_llamada'] : [];
+});
+/** Categorías no-workout (cada una su query de conteo). `event`='all' las corre todas. */
+const evaluateNonWorkout = (userId, event) => __awaiter(void 0, void 0, void 0, function* () {
+    const want = (e) => event === 'all' || event === e;
+    const ids = [];
+    if (want('chat')) {
+        const c = yield countScalar('SELECT COUNT(*) AS "C" FROM "CHAT MESSAGE" WHERE "ID CLIENTE" = ? AND "ID SENDER" = ?', [userId, userId]);
+        ids.push(...evalCount(catalog_1.CHAT_MSG, c));
+    }
+    if (want('survey')) {
+        const s = yield countScalar('SELECT COUNT(*) AS "C" FROM "CLIENTE ENCUESTA" WHERE "ID CLIENTE" = ?', [userId]);
+        if (s >= 1)
+            ids.push('coach_encuesta');
+    }
+    if (want('availability')) {
+        // coach_ajuste_plan repurposado = "Editar Disponibilidad": filas en WORKOUT DISPONIBILIDAD EXCEPCION.
+        const c = yield countScalar('SELECT COUNT(*) AS "C" FROM "WORKOUT DISPONIBILIDAD EXCEPCION" WHERE "ID CLIENTE" = ?', [userId]);
+        if (c >= 1)
+            ids.push('coach_ajuste_plan');
+    }
+    if (want('nutrition')) {
+        const meals = yield countScalar('SELECT COUNT(*) AS "C" FROM "CLIENTE NUTRICION" WHERE "ID CLIENTE" = ?', [userId]);
+        const days = yield countScalar('SELECT COUNT(DISTINCT "DATE") AS "C" FROM "CLIENTE NUTRICION" WHERE "ID CLIENTE" = ?', [userId]);
+        ids.push(...evalCount(catalog_1.NUTRITION_MEALS, meals));
+        if (days >= catalog_1.NUTRITION_DAYS_THRESHOLD)
+            ids.push('nut_7d_plan');
+    }
+    // 'food_photo' (primera foto a la comida): se desbloquea AL ANALIZAR una foto
+    // de comida con éxito (POST /nutricion/analizar-foto). No persiste ninguna
+    // tabla que contar, así que se otorga por el EVENTO explícito — NO en backfill
+    // ('all'), que no puede saber retroactivamente si el usuario hizo una foto.
+    if (event === 'food_photo') {
+        ids.push('nut_foto_comida');
+    }
+    if (want('wearable')) {
+        const rows = yield (0, db_1.query)('SELECT DISTINCT "TIPO APLICATION" AS "TIPO" FROM "CLIENTE APLICACIONES" WHERE "ID CLIENTE" = ?', [userId]);
+        const tipoSet = new Set(rows.map((r) => Number(r.tipo)).filter((n) => Number.isFinite(n)));
+        ids.push(...catalog_1.WEARABLE_APPS.filter((w) => tipoSet.has(w.tipo)).map((w) => w.id));
+    }
+    return ids;
+});
+/**
+ * Evalúa los logros del usuario PARA UN EVENTO y persiste los desbloqueados
+ * (idempotente, no revoca). Se llama justo donde ocurre la condición:
+ *   - 'workout'  → al completar un entreno. opts.workoutId procesa SOLO ese
+ *                  entreno para los PRs (incremental); sin él, recalcula todos.
+ *   - 'chat' | 'survey' | 'availability' | 'nutrition' | 'food_photo' | 'wearable'.
+ *   - 'goal'     → al añadir un objetivo (re-evalúa Plan, incl. pc_nuevo_capitulo).
+ *   - 'all'      → todo (backfill; recalcula los PRs desde cero).
+ * Nunca lanza por categorías aisladas (no debe romper el flujo que la invoca).
+ *
+ * Devuelve los logros RECIÉN desbloqueados en esta llamada: [{id, fechaDesbloqueo,
+ * params?}] (params solo en los dist_* con PR). Sirve para que el FE parchee su caché
+ * y suba el chip sin refetch. RETRO-COMPATIBLE: los callers que ignoran el retorno
+ * (backfill, postHooks de saveWorkoutAplication) siguen funcionando igual.
+ */
+const evaluateAchievements = (userId, event = 'all', opts = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!userId)
+        return [];
+    const anchor = yield getAnchorDate(userId);
+    const want = (e) => event === 'all' || event === e;
+    // Backfill ('all') marca como vistos al insertar (sin celebración retroactiva);
+    // los eventos en vivo dejan "FECHA VISTO"=NULL para que el FE los celebre (A2).
+    const markSeen = event === 'all';
+    const eligible = [];
+    // Recién desbloqueados que se devuelven al caller (para que el FE parchee su
+    // caché y suba el chip sin refetch). Los dist_* vienen de applyPRs CON params (PR);
+    // el resto de persistLogros SIN params. Se deduplica por id al final.
+    const nuevos = [];
+    if (want('workout')) {
+        // PRs (guardados en PARAMS de los dist_*). Aislado: streams no deben tumbar el resto.
+        try {
+            if (opts && opts.workoutId)
+                nuevos.push(...(yield processWorkoutPR(userId, anchor, opts.workoutId, markSeen)));
+            else
+                nuevos.push(...(yield recomputeAllPRs(userId, anchor, markSeen)));
+        }
+        catch (_) {
+            // ignore
+        }
+        const [streak, agg] = yield Promise.all([
+            (0, streak_1.computeStreakStats)(userId, anchor),
+            getAllAggregates(userId, anchor),
+        ]);
+        // Racha MÁXIMA persistida (high-water mark, con ancla): se guarda aquí —en el
+        // evento de workout, donde ya tenemos `streak.longest` calculado— para que la
+        // lectura (chip/StreakSheet) sea un simple SELECT y se pueda eliminar
+        // /progress/overview. GREATEST = solo sube, nunca baja (no se revoca el récord).
+        // Aislado: si la columna aún no existe (migración 0004 sin aplicar) no rompe.
+        try {
+            yield (0, db_1.query)('UPDATE "CLIENTE" SET "RACHA MAXIMA" = GREATEST(COALESCE("RACHA MAXIMA", 0), ?) WHERE "ID" = ?', [streak.longest, userId]);
+        }
+        catch (_) {
+            // ignore
+        }
+        eligible.push(...evaluateConsistency(streak.longest), ...evaluateDistance(agg.runMax), ...evaluateVolume(agg.runTotal), ...evaluateStrength(agg.strCount), ...evaluateCycling(agg), ...evaluateSwim(agg), ...evaluateTriSwim(agg), ...evaluateTrail(agg));
+        const raceDates = agg.raceCount >= 3 ? yield getRaceDates(userId, anchor) : [];
+        eligible.push(...evaluateRaces(agg.raceCount, raceDates));
+        if (agg.hrCount >= 1)
+            eligible.push('wear_fc');
+        // Plan + Hitos, frecuencia de fuerza, brick, recovery y coach_llamada. Todas
+        // dependen de workouts (o se re-evalúan al completar uno). Cada grupo aislado:
+        // un fallo (p. ej. una columna de plan ausente) no tumba el resto.
+        try {
+            eligible.push(...(yield evaluatePlan(userId, anchor)));
+        }
+        catch (_) { /* ignore */ }
+        try {
+            const strengthDates = yield getStrengthDates(userId, anchor);
+            eligible.push(...evaluateStrengthFrequency(strengthDates));
+        }
+        catch (_) { /* ignore */ }
+        try {
+            eligible.push(...(yield evaluateBrick(userId, anchor)));
+        }
+        catch (_) { /* ignore */ }
+        try {
+            eligible.push(...(yield evaluateRecovery(userId, anchor)));
+        }
+        catch (_) { /* ignore */ }
+        try {
+            eligible.push(...(yield evaluateCoachCall(userId)));
+        }
+        catch (_) { /* ignore */ }
+    }
+    if (want('chat') || want('survey') || want('availability') || want('nutrition') || want('food_photo') || want('wearable')) {
+        try {
+            eligible.push(...(yield evaluateNonWorkout(userId, event)));
+        }
+        catch (_) {
+            // ignore
+        }
+    }
+    // 'goal' (añadir objetivo) re-evalúa los logros de Plan (incl. pc_nuevo_capitulo).
+    // En 'all'/'workout' ya se cubre en el branch de workout; por eso aquí solo 'goal'.
+    if (event === 'goal') {
+        try {
+            eligible.push(...(yield evaluatePlan(userId, anchor)));
+        }
+        catch (_) { /* ignore */ }
+    }
+    nuevos.push(...(yield persistLogros(userId, eligible, markSeen)));
+    // pace_*/pr_* se derivan del mapa de PRs ya persistido en los PARAMS de dist_*.
+    if (want('workout')) {
+        try {
+            const prMap = yield getPrMap(userId);
+            nuevos.push(...(yield persistLogros(userId, [...evaluatePace(prMap), ...evaluateTimePR(prMap)])));
+        }
+        catch (_) {
+            // ignore
+        }
+    }
+    // Dedup por id, preservando el PRIMERO de cada id. applyPRs se acumula antes que
+    // persistLogros(eligible), así que para un dist_* que salta por las dos vías nos
+    // quedamos con el objeto que trae `params` (el PR). El INSERT ON CONFLICT DO NOTHING
+    // de persistLogros ya evita el doble alta, pero deduplicamos por seguridad.
+    const seen = new Set();
+    const result = [];
+    for (const n of nuevos) {
+        if (!n || !n.id || seen.has(n.id))
+            continue;
+        seen.add(n.id);
+        result.push(n);
+    }
+    return result;
+});
+exports.evaluateAchievements = evaluateAchievements;
+/**
+ * Variante acotada con timeout para el CAMINO CALIENTE (hooks de evento que
+ * responden HTTP). Devuelve los recién desbloqueados si el motor termina dentro
+ * de `timeoutMs`; si vence (o falla), devuelve [] sin romper el flujo que la invoca.
+ *
+ * La promesa del motor lleva su propio `.catch` ANTES del race, así que si vence el
+ * timeout sigue corriendo en background SIN unhandled rejection y persiste igual
+ * (el INSERT ocurre dentro de evaluateAchievements) → el FE lo recupera en el
+ * siguiente refetch. Nunca lanza.
+ */
+const evaluateAchievementsBounded = (userId, event = 'all', opts = {}, timeoutMs = 1500) => __awaiter(void 0, void 0, void 0, function* () {
+    const motor = (0, exports.evaluateAchievements)(userId, event, opts).catch(() => []);
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve([]), timeoutMs);
+    });
+    const result = yield Promise.race([motor, timeout]);
+    // El motor podría seguir vivo tras el timeout; ya tiene su .catch, así que no hay
+    // unhandled rejection. Limpiamos el timer si el motor ganó la carrera.
+    motor.finally(() => clearTimeout(timer));
+    return Array.isArray(result) ? result : [];
+});
+exports.evaluateAchievementsBounded = evaluateAchievementsBounded;
+/** Set completo de logros desbloqueados del usuario (para lecturas / verificación). */
+const getUnlockedAchievements = (userId) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!userId)
+        return [];
+    const rows = yield (0, db_1.query)('SELECT "LOGRO ID" AS "ID" FROM "CLIENTE LOGRO" WHERE "ID CLIENTE" = ?', [userId]);
+    return rows.map((r) => r.id);
+});
+exports.getUnlockedAchievements = getUnlockedAchievements;